用C语言编写小游戏

用c语言编写一个五子棋吧，不怎么难，给你程序，自己参考一下

/334 源程序/

#include "graphicsh" /图形系统头文件/

#define LEFT 0x4b00 /光标左键值/

#define RIGHT 0x4d00 /光标右键值/

#define DOWN 0x5000 /光标下键值/

#define UP 0x4800 /光标上键值/

#define ESC 0x011b / ESC键值/

#define ENTER 0x1c0d / 回车键值/

int a[8][8]={0},key,score1,score2;/具体分数以及按键与存放棋子的变量/

char playone[3],playtwo[3];/两个人的得分转换成字符串输出/

void playtoplay(void);/人人对战函数/

void DrawQp(void);/画棋盘函数/

void SetPlayColor(int x);/设置棋子第一次的颜色/

void MoveColor(int x,int y);/恢复原来棋盘状态/

int QpChange(int x,int y,int z);/判断棋盘的变化/

void DoScore(void);/处理分数/

void PrintScore(int n);/输出成绩/

void playWin(void);/输出胜利者信息/

/主函数/

void main(void)

{

int gd=DETECT,gr;

initgraph(&gd,&gr,"c:\\tc"); /初始化图形系统/

DrawQp();/画棋盘/

playtoplay();/人人对战/

getch();

closegraph();/关闭图形系统/

}

void DrawQp()/画棋盘/

{

int i,j;

score1=score2=0;/棋手一开始得分都为0/

setbkcolor(BLUE);

for(i=100;i<=420;i+=40)

{

line(100,i,420,i);/画水平线/

line(i,100,i,420); /画垂直线/

}

setcolor(0);/取消圆周围的一圈东西/

setfillstyle(SOLID_FILL,15);/白色实体填充模式/

fillellipse(500,200,15,15); /在显示得分的位置画棋/

setfillstyle(SOLID_FILL,8); /黑色实体填充模式/

fillellipse(500,300,15,15);

a[3][3]=a[4][4]=1;/初始两个黑棋/

a[3][4]=a[4][3]=2;/初始两个白棋/

setfillstyle(SOLID_FILL,WHITE);

fillellipse(120+340,120+340,15,15);

fillellipse(120+440,120+440,15,15);

setfillstyle(SOLID_FILL,8);

fillellipse(120+340,120+440,15,15);

fillellipse(120+440,120+340,15,15);

score1=score2=2; /有棋后改变分数/

DoScore();/输出开始分数/

}

void playtoplay()/人人对战/

{

int x,y,t=1,i,j,cc=0;

while(1)/换棋手走棋/

{

x=120,y=80;/每次棋子一开始出来的坐标,x为行坐标,y为列坐标/

while(1) /具体一个棋手走棋的过程/

{

PrintScore(1);/输出棋手1的成绩/

PrintScore(2);/输出棋手2的成绩/

SetPlayColor(t);/t变量是用来判断棋手所执棋子的颜色/

fillellipse(x,y,15,15);

key=bioskey(0);/接收按键/

if(key==ESC)/跳出游戏/

break;

else

if(key==ENTER)/如果按键确定就可以跳出循环/

{

if(y!=80&&a[(x-120)/40][(y-120)/40]!=1

&&a[(x-120)/40][(y-120)/40]!=2)/如果落子位置没有棋子/

{

if(t%2==1)/如果是棋手1移动/

a[(x-120)/40][(y-120)/40]=1;

else/否则棋手2移动/

a[(x-120)/40][(y-120)/40]=2;

if(!QpChange(x,y,t))/落子后判断棋盘的变化/

{

a[(x-120)/40][(y-120)/40]=0;/恢复空格状态/

cc++;/开始统计尝试次数/

if(cc>=64-score1-score2) /如果尝试超过空格数则停步/

{

MoveColor(x,y);

fillellipse(x,y,15,15);

break;

}

else

continue;/如果按键无效/

}

DoScore();/分数的改变/

break;/棋盘变化了，则轮对方走棋/

}

else/已经有棋子就继续按键/

continue;

}

else /四个方向按键的判断/

if(key==LEFT&&x>120)/左方向键/

{

MoveColor(x,y);

fillellipse(x,y,15,15);

SetPlayColor(t);

x-=40;

fillellipse(x,y,15,15);

}

else

if(key==RIGHT&&x<400&&y>80)/右方向键/

{

MoveColor(x,y);

fillellipse(x,y,15,15);

SetPlayColor(t);

x+=40;

fillellipse(x,y,15,15);

}

else

if(key==UP&&y>120)/上方向键/

{

MoveColor(x,y);

fillellipse(x,y,15,15);

SetPlayColor(t);

y-=40;

fillellipse(x,y,15,15);

}

else

if(key==DOWN&&y<400)/下方向键/

{

MoveColor(x,y);

fillellipse(x,y,15,15);

SetPlayColor(t);

y+=40;

fillellipse(x,y,15,15);

}

}

if(key==ESC)/结束游戏/

break;

if((score1+score2)==64||score1==0||score2==0)/格子已经占满或一方棋子为0判断胜负/

{

playWin();/输出最后结果/

break;

}

t=t%2+1; /一方走后，改变棋子颜色即轮对方走/

cc=0; /计数值恢复为0/

} /endwhile/

}

void SetPlayColor(int t)/设置棋子颜色/

{

if(t%2==1)

setfillstyle(SOLID_FILL,15);/白色/

else

setfillstyle(SOLID_FILL,8);/灰色/

}

void MoveColor(int x,int y)/走了一步后恢复原来格子的状态/

{

if(y<100)/如果是从起点出发就恢复蓝色/

setfillstyle(SOLID_FILL,BLUE);

else/其他情况如果是1就恢复白色棋子,2恢复黑色棋子,或恢复蓝色棋盘/

switch(a[(x-120)/40][(y-120)/40])

{

case 1:

setfillstyle(SOLID_FILL,15);break; /白色/

case 2:

setfillstyle(SOLID_FILL,8);break; /黑色/

default:

setfillstyle(SOLID_FILL,BLUE); /蓝色/

}

}

int QpChange(int x,int y,int t)/判断棋盘的变化/

{

int i,j,k,kk,ii,jj,yes;

yes=0;

i=(x-120)/40; /计算数组元素的行下标/

j=(y-120)/40; /计算数组元素的列下标/

SetPlayColor(t);/设置棋子变化的颜色/

/开始往8个方向判断变化/

if(j<6)/往右边/

{

for(k=j+1;k<8;k++)

if(a[i][k]==a[i][j]||a[i][k]==0)/遇到自己的棋子或空格结束/

break;

if(a[i][k]!=0&&k<8)

{

for(kk=j+1;kk<k&&k<8;kk++)/判断右边/

{

a[i][kk]=a[i][j]; /改变棋子颜色/

fillellipse(120+i40,120+kk40,15,15);

}

if(kk!=j+1) /条件成立则有棋子改变过颜色/

yes=1;

}

}

if(j>1)/判断左边/

{

for(k=j-1;k>=0;k--)

if(a[i][k]==a[i][j]||!a[i][k])

break;

if(a[i][k]!=0&&k>=0)

{

for(kk=j-1;kk>k&&k>=0;kk--)

{

a[i][kk]=a[i][j];

fillellipse(120+i40,120+kk40,15,15);

}

if(kk!=j-1)

yes=1;

}

}

if(i<6)/判断下边/

{

for(k=i+1;k<8;k++)

if(a[k][j]==a[i][j]||!a[k][j])

break;

if(a[k][j]!=0&&k<8)

{

for(kk=i+1;kk<k&&k<8;kk++)

{

a[kk][j]=a[i][j];

fillellipse(120+kk40,120+j40,15,15);

}

if(kk!=i+1)

yes=1;

}

}

if(i>1)/判断上边/

{

for(k=i-1;k>=0;k--)

if(a[k][j]==a[i][j]||!a[k][j])

break;

if(a[k][j]!=0&&k>=0)

{

for(kk=i-1;kk>k&&k>=0;kk--)

{

a[kk][j]=a[i][j];

fillellipse(120+kk40,120+j40,15,15);

}

if(kk!=i-1)

yes=1;

}

}

if(i>1&&j<6)/右上/

{

for(k=i-1,kk=j+1;k>=0&&kk<8;k--,kk++)

if(a[k][kk]==a[i][j]||!a[k][kk])

break;

if(a[k][kk]&&k>=0&&kk<8)

{

for(ii=i-1,jj=j+1;ii>k&&k>=0;ii--,jj++)

{

a[ii][jj]=a[i][j];

fillellipse(120+ii40,120+jj40,15,15);

}

if(ii!=i-1)

yes=1;

}

}

if(i<6&&j>1)/左下/

{

for(k=i+1,kk=j-1;k<8&&kk>=0;k++,kk--)

if(a[k][kk]==a[i][j]||!a[k][kk])

break;

if(a[k][kk]!=0&&k<8&&kk>=0)

{

for(ii=i+1,jj=j-1;ii<k&&k<8;ii++,jj--)

{

a[ii][jj]=a[i][j];

fillellipse(120+ii40,120+jj40,15,15);

}

if(ii!=i+1)

yes=1;

}

}

if(i>1&&j>1)/左上/

{

for(k=i-1,kk=j-1;k>=0&&kk>=0;k--,kk--)

if(a[k][kk]==a[i][j]||!a[k][kk])

break;

if(a[k][kk]!=0&&k>=0&&kk>=0)

{

for(ii=i-1,jj=j-1;ii>k&&k>=0;ii--,jj--)

{

a[ii][jj]=a[i][j];

fillellipse(120+ii40,120+jj40,15,15);

}

if(ii!=i-1)

yes=1;

}

}

if(i<6&&j<6)/ 右下/

{

for(k=i+1,kk=j+1;kk<8&&kk<8;k++,kk++)

if(a[k][kk]==a[i][j]||!a[k][kk])

break;

if(a[k][kk]!=0&&kk<8&&k<8)

{

for(ii=i+1,jj=j+1;ii<k&&k<8;ii++,jj++)

{

a[ii][jj]=a[i][j];

fillellipse(120+ii40,120+jj40,15,15);

}

if(ii!=i+1)

yes=1;

}

}

return yes;/返回是否改变过棋子颜色的标记/

}

void DoScore()/处理分数/

{

int i,j;

score1=score2=0;/重新开始计分数/

for(i=0;i<8;i++)

for(j=0;j<8;j++)

if(a[i][j]==1)/分别统计两个人的分数/

score1++;

else

if(a[i][j]==2)

score2++;

}

void PrintScore(int playnum)/输出成绩/

{

if(playnum==1)/清除以前的成绩/

{

setfillstyle(SOLID_FILL,BLUE);

bar(550,100,640,400);

}

setcolor(RED);

settextstyle(0,0,4);/设置文本输出样式/

if(playnum==1)/判断输出哪个棋手的分,在不同的位置输出/

{

sprintf(playone,"%d",score1);

outtextxy(550,200,playone);

}

else

{

sprintf(playtwo,"%d",score2);

outtextxy(550,300,playtwo);

}

setcolor(0);

}

void playWin()/输出最后的胜利者结果/

{

settextstyle(0,0,4);

setcolor(12);

if(score2>score1)/开始判断最后的结果/

outtextxy(100,50,"black win!");

else

if(score2<score1)

outtextxy(100,50,"white win!");

else

outtextxy(60,50,"you all win!");

}

#include

#include

#include

#include

int

i,j=1;

int

scores[6];

void

main()

{

char

control='\0';

int

rand1,guess,score;

printf("开始游戏吗

(yn)");

control=getchar();

while(control!='y'&&control!='y'&&control!='n'&&control!='n')//屏蔽其他按键

{

printf("无效字符！开始游戏吗

(yn)");

fflush(stdin);

control=getchar();

printf("%c",control);

}

while((control=='y')||(control=='y'))

{

system("cls");

srand((unsigned)time(null));

rand1=rand()%10+1;

//printf("%d",rand1);

for(i=0;i<20;i++)

{

printf("请输入你猜的数:");

scanf("%d",&guess);

if(guess>rand1)printf("大啦!\n");

else

if(guess

:猜对了\a\n");//响铃\a

break;

}

i++;

}

i+=1;

if(i==1)

{

score=100;

scores[0]++;

}

else

if(i>=2&&i<=3)

{

score=90;

scores[1]++;

}

else

if(i>=4&&i<=6)

{

score=80;

scores[2]++;

}

else

if(i>=7&&i<=10)

{

score=70;

scores[3]++;

}

else

if(i>=11&&i<=15)

{

score=60;

scores[4]++;

}

else

{

score=0;

scores[5]++;

}

printf("第%d次得分是:%d\n",j,score);

scores[7]+=score;

j++;

printf("是否继续(yn)\n");

fflush(stdin);//请输入缓冲区

control=getchar();

while(control!='y'&&control!='y'&&control!='n'&&control!='n')

{

printf("无效字符！只能按y或y,n或n是否继续(yn)\n");

fflush(stdin);

control=getchar();

printf("%c",control);

}

}

system("cls");//清屏

printf("+++++++++++++++-----------------以下是得分情况：---------------\n");

for(i=0;i<5;i++)

{

printf("+++++++++++++++------------------得%d分%d次：------------------\n",10(10-i),scores[i]);

}

printf("+++++++++++++++------------------得%d分%d次：------------------\n",

0,scores[5]);

}

平面四子棋

事先声明：

代码是我自个儿写的，规则不是我发明的~~~~。 

我觉得我真是太不务正业了！

规则

在一个712的棋盘里，下四子棋。只不过，这个棋盘是竖立着的，它的棋子是从上往下掉的。 

比如说： 



如果该红棋走了，我可以这么走： 



然后红棋就会掉落，落在它下面那颗蓝棋的上面。 



下一步就该蓝棋走，然后红棋……以此类推，谁先四个同色的棋子连成一条线，就获胜。

代码

话不多说，详见代码：

#include<cstdio> #include<windowsh> #include<algorithm> #include<iostream> #include<cstdlib> #include<conioh> using namespace std; char map[25][25]; void

我这有许多C的小游戏。给你一个基础的简单的汉诺塔程序。你看看：

这是个汉诺塔程序，在调试的时候，输入的数字最好不要大于15，因为每大一个数

所得的结果的步骤都会多一倍。如果你有耐心等待结果的话除外。汉诺塔是在欧洲

流行的一种游戏，有a,b,c三个竿。a竿上有若干个由大到小的圆盘，大的在下面，

小的在上面，b,c都是空杆，请你把a杆上的圆盘都倒到别的杆上，或b或c，在倒盘

的过程中不可以大的压小的，实例程序如下：

#include <stdioh>

int i=0;

main()

{

unsigned n;

printf("Please enter the number of discs: ");

scanf("%d",&n);

printf("\tneedle:\ta\t b\t c\n");

movedisc(n,'a','c','b');

printf("\t Total: %d\n",i);

getch();

}

movedisc(n,fromneedle,toneedle,usingneedle)

unsigned n;

char fromneedle,toneedle,usingneedle;

{

if(n>0)

{

movedisc(n-1,fromneedle,usingneedle,toneedle);

i++;

switch(fromneedle)

{

case 'a':switch(toneedle)

{

case 'b':printf("\t[%d]:\t%2d------>%2d\n",i,n,n);

break;

case 'c':printf("\t[%d]:\t%2d------------->%2d\n",i,n,n);

break;

}

break;

case 'b':switch(toneedle)

{

case 'a':printf("\t[%d]:\t%2d<----------%2d\n",i,n,n);

break;

case 'c':printf("\t[%d]:\t\t%2d------>%2d\n",i,n,n);

break;

}

break;

case 'c':switch(toneedle)

{

case 'a':printf("\t[%d]:\t%2d<--------------%2d\n",i,n,n);

break;

case 'b':printf("\t[%d]:\t\t%2d<--------%2d\n",i,n,n);

break;

}

break;

}

movedisc(n-1,usingneedle,toneedle,fromneedle);

}

}

编写程序，实现如下表所示的5-魔方阵。

17    24    1    8    15  

23    5    7    14    16  

4    6    13    20    22  

10    12    19    21    3  

11    18    25    2    9  

5-魔方阵

问题分析

所谓“n-魔方阵”，指的是使用1〜n2共n2个自然数排列成一个n×n的方阵，其中n为奇数；该方阵的每行、每列及对角线元素之和都相等，并为一个只与n有关的常数，该常数为n×(n2+1)/2。

例如5-魔方阵，其第一行、第一列及主对角线上各元素之和如下：

第一行元素之和：17+24+1+8+15=65

第一列元素之和：17+23+4+10+11=65

主对角线上元素之和：17+5+13+21+9=65

而 n×(n2+1)/2=5×(52+1)/2=65 可以验证，5-魔方阵中其余各行、各列及副对角线上的元素之和也都为65。

假定阵列的行列下标都从0开始，则魔方阵的生成方法为：在第0行中间置1，对从2开始的其余n2-1个数依次按下列规则存放：

(1) 假定当前数的下标为(i，j)，则下一个数的放置位置为当前位置的右上方，即下标为(i-1，j+1)的位置。

(2) 如果当前数在第0行，即i-1小于0，则将下一个数放在最后一行的下一列上，即下标为(n-1，j+1)的位置。

(3) 如果当前数在最后一列上，即j+1大于n-1，则将下一个数放在上一行的第一列上，即下标为(i-1，0)的位置。

(4) 如果当前数是n的倍数，则将下一个数直接放在当前位置的正下方，即下标为(i+1，j）的位置。

算法设计

在设计算法时釆用了下面一些方法：

定义array()函数，array()函数的根据输入的n值，生成并显示一个魔方阵，当发现n不是奇数时，就加1使之成为奇数。

使用动态内存分配与释放函数malloc()与free()，在程序执行过程中动态分配与释放内存，这样做的好处是使代码具有通用性，同时提高内存的使用率。

在分配内存时还要注意，由于一个整型数要占用两个内存，因此，如果魔方阵中要存放的数有max个，则分配内存时要分配2max个单元，从而有malloc(max+max)。在malloc()函数中使用max+max而不是2max是考虑了程序运行的性能。

显然应该使用二维数组来表示魔方阵，但虽然数组是二维形式的，而由于内存是一维线性的，因此在存取数组元素时，要将双下标转换为单个索引编号。在程序中直接定义了指针变量来指向数组空间，即使用malloc()函数分配的内存。

我这儿有c语言的自写俄罗斯方块，请指教：#include

#include

#include

#include

#include

#include

#include

#define ESC 0x011b

#define UP 0x4800

#define DOWN 0x5000

#define LEFT 0x4b00

#define RIGHT 0x4d00

#define SPACE 0x3920

#define Y 0x1579

#define N 0x316e

#define clearkbd(); while(bioskey(1)) bioskey(0); /清空键盘缓冲队列/

void update();

void messagebox();

void process();

void initremove();

void initinfo();

void initbox();

void initposition();

void next_shape();

typedef struct shape /形状单一状态的记录/

{ int attr;

int co[8];

}shape;

typedef struct RE_AB /相对,绝对坐标记录/

{ int Rx,Ry;

int x1,x2,y1,y2;

}RE_AB;

RE_AB RA;

shape p[19]={ { RED,0,1,1,0,1,1,2,1 }, /数组中保证y最大的在最后，以便initposition使用/

{ RED,0,1,1,0,1,1,1,2 },

{ RED,0,0,1,0,2,0,1,1 },

{ RED,0,0,0,1,1,1,0,2 },

{ GREEN,0,0,1,0,2,0,3,0 },

{ GREEN,0,0,0,1,0,2,0,3 },

{ CYAN,0,0,0,1,1,0,1,1 },

{ BROWN,0,0,1,0,1,1,2,1 },

{ BROWN,1,0,0,1,1,1,0,2 },

{ BLUE,1,0,2,0,1,1,0,1 },

{ BLUE,0,0,0,1,1,1,1,2 },

{ MAGENTA,0,0,0,1,0,2,1,2 },

{ MAGENTA,2,0,0,1,1,1,2,1},

{ MAGENTA,0,0,1,0,1,1,1,2 },

{ MAGENTA,0,0,0,1,1,0,2,0 },

{ YELLOW,0,2,1,0,1,1,1,2 },

{ YELLOW,0,0,1,0,2,0,2,1 },

{ YELLOW,1,0,0,0,0,1,0,2},

{ YELLOW,0,0,0,1,1,1,2,1 },

};

int nback,nleft,nright,r_f[12][22],rs1,rs2,xcors,xcorb,ycors,ycorb;

/检查方快有没有左,右,下接触,游戏区内所有格子有无颜色记录数组,rs1形状记录,rs2为提示框用,记录小格子在游戏区中的位置,按键存储/

void interrupt (oldint)(); /系统定时中断/

int count_down=0,count_other=0; /中断记时/

void interrupt newint() /设置新的中断程序/

{ count_down++;

count_other++;

oldint();

}

void intenable() /设置中断向量表，启动新的中断程序/

{ oldint=getvect(0x1c);

disable();

setvect(0x1c,newint);

enable();

}

void intrestore() /恢复中断向量/

{ disable();

setvect(0x1c,oldint);

enable();

}

void HZ12(int x0,int y0,int w,int color,char s) /根据字模,在dos下显示汉字/

/横坐标,纵坐标,字间隔,汉字颜色,汉字字符串/

{ FILE fp;

register char buffer[24];

register char str[2];

unsigned long fpos;/fpos为最终偏移动量/

register int i,j,k;

fp=fopen(hzk12,r);/打开1212汉字苦/

while(s)/一直到字符串结束为止/

{

if(s<0)/汉字输出/

{ str[0]=(s)-0xa0;

str[1]=(s+1)-0xa0;

fpos=((str[0]-1)94+(str[1]-1))24L;/计算汉字在hzk12的偏移量/

fseek(fp,fpos,SEEK_SET);/指针移动到当前位置/

fread(buffer,24,1,fp);/读取一个汉字到数组中/

for(i=0;i<12;i++)/12行/

for(j=0;j<2;j++)/两个字节/

for(k=0;k<8;k++)/8位/

if (((buffer[i2+j]>>(7-k))&0x1)!=NULL)/是一就画点/

putpixel(x0+8j+k,y0+i,color);

s+=2;/一个汉字占两个字节，现在将指针移动两个字节/

x0+=w;/显示坐标也按照间隔移动/

}

else/显示非汉字字符/

{ settextstyle(0,0,1);

setcolor(color);

str[0]=s;str[1]=0;

outtextxy(x0,y0+3,str);/显示单个字符/

x0+=w-7;/显示单个字符后的x坐标变化/

s++;/指针移动到下一个字节/

}

}

fclose(fp);

}

void translation() /把相对坐标解释为绝对坐标/

{ if(RARx==1)

{ RAx1=1; RAx2=16; }

else

{ RAx1=16(RARx-1); RAx2=16RARx; }

if(RARy==1)

{ RAy1=1; RAy2=16; }

else

{ RAy1=16(RARy-1); RAy2=16RARy; }

}

int check_b() /检查是否到达低部/

{ int x,y,i,zf=0; /zf为是否有颜色填充记录/

for(i=0;i<7;i++,i++)

{ x=RARx+p[rs1]co[i];

y=RARy+p[rs1]co[i+1];

if(y>=6)

zf+=r_f[x-15][y-6+1];

}

if(zf==0)

return 1;

else

return 0;

}

int finish()

{ int tfull=0,i; /判断顶层空间是否有填充/

for(i=1;i<11;i++)

tfull+=r_f[i][1];

if(tfull!=0)

return 1; /告诉judge()可以结束了/

}

int check_l() /检查形状是否与左接触/

{ int x,y,i,zf=0;

for(i=0;i<7;i++,i++)

{ x=RARx+p[rs1]co[i];

y=RARy+p[rs1]co[i+1];

if(y>6)

zf+=r_f[x-15-1][y-6];

if(y<=6&&x==16)

zf+=1;

}

if(zf==0)

return 1;

else

return 0;

}

int check_r() /检查形状是否与右接触/

{ /zf为是否有颜色填充记录/

int x,y,i,zf=0; /zf为是否有颜色填充记录/

for(i=0;i<7;i++,i++)

{

x=RARx+p[rs1]co[i];

y=RARy+p[rs1]co[i+1];

if(y>6)

zf+=r_f[x-15+1][y-6];

if(y<=6&&x==25)

zf+=1;

}

if(zf==0)

return 1;

else

return 0;

}

void check_touch()

{ nback=check_b();

nleft=check_l();

nright=check_r();

}

void draw(int cb) /画形状,cb=1以填充色画形状，cb=2以背景色画形状,cb=3以白色画形状/

{ int i,recordx=RARx,recordy=RARy;

for(i=0;i<7;i++,i++)

{ RARx+=p[rs1]co[i];

RARy+=p[rs1]co[i+1];

if(RARy<=6)

{ RARx=recordx;

RARy=recordy;

continue;

}

translation();

if(cb==1)

setfillstyle(1,p[rs1]attr);

else

if(cb==2)

setfillstyle(1,BLACK);

else

if(cb==3)

{ setfillstyle(1,WHITE);

r_f[RARx-15][RARy-6]=1; /置对应数组标记元素/

}

bar(RAx1+1,RAy1+1,RAx2-1,RAy2-1);

RARx=recordx;

RARy=recordy;

}

}

void mov(int key) /向下,左,右移动方块/

{ draw(2);

if(key==LEFT&&nleft)

RARx--;

else

if(key==RIGHT&&nright)

RARx++;

else

RARy++;

nback=check_b();

if(nback) /判断形状有没有到达底部，有就将其颜色变为白色/

draw(1);

else

draw(3);

}

void change() /变换形状/

{ int status=rs1,buffer,i,x,y,zf=0;

if(p[rs1]attr==p[rs1+1]attr)

rs1++;

else

while(p[rs1]attr==p[rs1-1]attr)

rs1--;

for(i=0;i<7;i++,i++) /检查变化形状后是否与已存形状发生冲突/

{ x=RARx+p[rs1]co[i];

y=RARy+p[rs1]co[i+1];

if(y>6)

zf+=r_f[x-15][y-6];

}

if(zf!=0)

rs1=status;

buffer=rs1;

rs1=status;

status=buffer;

draw(2);

buffer=rs1;

rs1=status;

status=buffer;

nback=check_b(); /判断变化后的形状是不是到达了低部,这个检查是十分必要的/

if(nback)

draw(1);

else

draw(3);

}

void accelerate()

{ if(count_down>=1)

{ check_touch(); /消除上一步动作对方块状态的影响/

count_down=0;

if(nback) /0表示到达底部,1表示没有到达/

mov(DOWN);

}

}

void drawbox() /画方块所在方框/

{ int xcor,ycor;

for(xcor=xcors;xcor<=xcorb;xcor++)

for(ycor=ycors;ycor<=ycorb;ycor++)

{ if(xcor==xcors||xcor==xcorb||ycor==ycors||ycor==ycorb)

{ RARx=xcor;

RARy=ycor;

translation();

setfillstyle(1,DARKGRAY);

bar(RAx1+1,RAy1+1,RAx2-1,RAy2-1);

}

}

}

void erasure(int k)

{ int i,j,recordx=RARx,recordy=RARy;

{ j=k-1;

for(;j>0;j--)

{ for(i=1;i<11;i++)

{ r_f[i][j+1]=r_f[i][j];

RARx=i+15;

RARy=j+1+6;

translation();

if(r_f[i][j+1]==1)

setfillstyle(1,WHITE);

else

setfillstyle(1,BLACK);

bar(RAx1+1,RAy1+1,RAx2-1,RAy2-1);

RARx=recordx;

RARy=recordy;

}

}

}

}

void pause()

{ HZ12(450,400,15,BLACK,正常);

HZ12(450,400,15,GREEN,暂停);

for(;;)

if(bioskey(1)&&bioskey(0)==SPACE)

{ clearkbd();

HZ12(450,400,15,BLACK,暂停);

HZ12(450,400,15,RED,正常);

return;

}

}

void judge()

{ int i,j,full=0; /full等于10说明某一行满,该消除了/

if(finish()) /判断游戏是否该结束了/

messagebox(); /win编程里有这个函数/

for(j=1;j<21;j++) /判断某一行是否满了/

{ for(i=1;i<11;i++)

full+=r_f[i][j];

if(full==10)

erasure(j); /消除这行/

full=0;

}

}

void update() /使程序可以重新运行/

{ cleardevice();

setbkcolor(BLACK);

initinfo(); /提示信息初始化/

initbox(); /游戏框架初始化/

srand((unsigned)time(NULL)); /随机器函数的初始化/

rs1=random(19);

rs2=random(19);

next_shape();

initposition(); /方块最开始的出现位置/

initremove(); /记录每个方格有无颜色填充数组初始化/

HZ12(450,400,15,RED,正常);

process();

}

void EXIT()

{ closegraph();

intrestore(); /恢复中断向量/

exit(0);

}

void initremove()

{ int i,j;

for(i=0;i<12;i++)

for(j=0;j<22;j++)

if(i==0||i==11||j==0||j==21)

r_f[i][j]=1;

else

r_f[i][j]=0;

}

void initinfo()

{ char aStr[2];

setcolor(RED);

outtextxy(450,100,This game's writer is:);

HZ12(450,140,15,RED,该程序作者:NULL);

outtextxy(525,110,NULL);

outtextxy(450,180,FUNCTION FOR KEYS:);

outtextxy(450,200,UP:change the shape);

outtextxy(450,210,DOWN:accelerate);

outtextxy(450,220,LEFT:move left);

outtextxy(450,230,RIGHT:move right);

outtextxy(450,240,ESC:exit this game);

outtextxy(450,250,SPACE:pause);

HZ12(450,260,20,RED,上:);

HZ12(450,280,20,RED,下:);

HZ12(450,300,20,RED,左:);

HZ12(450,320,20,RED,右:);

HZ12(450,340,20,RED,ESC:退出);

HZ12(450,360,15,RED,空格: 暂停/开始);

HZ12(450,380,15,RED,目前状态:);

HZ12(20,200,15,RED,下一个形状);

aStr[0]=24;

aStr[1]=0;

aStr[6]=0;

HZ12(480,260,12,GREEN,aStr);

HZ12(500,260,12,GREEN,( 变形 ));

aStr[0]=25;

aStr[1]=0;

HZ12(480,280,12,GREEN,aStr);

HZ12(500,280,12,GREEN,( 加速 ));

aStr[0]=27;

aStr[1]=0;

HZ12(480,300,12,GREEN,aStr);

HZ12(500,300,12,GREEN,向左);

aStr[0]=26;

aStr[1]=0;

HZ12(480,320,12,GREEN,aStr);

HZ12(500,320,12,GREEN,向右);

}

void messagebox()

{ int key;

setcolor(GREEN);

setfillstyle(1,DARKGRAY);

rectangle(220,200,420,300);

bar(221,201,419,299);

HZ12(280,210,15,GREEN,GAME OVER);

HZ12(275,230,15,GREEN,重新游戏: Y);

HZ12(275,270,15,GREEN,退出游戏: N);

HZ12(450,400,15,BLACK,正常);

HZ12(450,400,15,GREEN,GAME OVER);

for(;;)

if(bioskey(1))

{ key=bioskey(0);

if(key==Y)

{ clearkbd();

update();

}

else

if(key==N)

{ clearkbd();

EXIT();

}

else

clearkbd();

}

}

void initbox()

{ xcors=15; /画游戏框/

xcorb=26;

ycors=6;

ycorb=27;

drawbox();

xcors=2; /画提示框/

xcorb=7;

ycors=6;

ycorb=11;

drawbox();

}

void initposition()

{ RARx=18;

RARy=6-p[rs1]co[7];;

RAx1=0;

RAx2=0;

RAy1=0;

RAy2=0;

}

void next_shape() /画下一形状提示框/

{ int recordx=RARx,recordy=RARy,buffer;

RARx=3;

RARy=7;

draw(2);

buffer=rs1;

rs1=rs2;

rs2=buffer;

draw(1);

RARx=recordx;

RARy=recordy;

buffer=rs1;

rs1=rs2;

rs2=buffer;

}

void process() /游戏过程/

{ for(;;)

{ check_touch();

if(!nback)

{ rs1=rs2;

rs2=random(19); /产生另一种方块的码数/

initposition();

judge(); /判断某一行是否满了和这个游戏是否可以结束了/

draw(1);

next_shape();

}

if(count_other>=1)

{ count_other=0;

if(bioskey(1)) /对按键的处理/

{ int key=bioskey(0);

clearkbd(); /清除键盘缓冲队列/

if(key==ESC)

EXIT();

if(key==LEFT&&nleft&&nback)

mov(LEFT);

if(key==RIGHT&&nright&&nback)

mov(RIGHT);

if(key==UP&&nback)

change();

if(key==SPACE)

pause();

if(key==DOWN)

accelerate();

}

}

if(count_down>=4)

{ check_touch(); /消除上一步动作对方块状态的影响/

count_down=0;

if(nback) /0表示到达底部,1表示没有到达/

mov(DOWN);

}

}/for/

}

main()

{ int gdriver=DETECT,gmode=0;

initgraph(&gdriver,&gmode,d:turboc); /启动图形与中断部分/

intenable();

update();

}

以上就是关于用C语言编写小游戏全部的内容，包括:用C语言编写小游戏、猜数字游戏 C语言简单程序代码、如何用C程序实现四连环游戏（重力四子棋）等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！