用纯C写的游戏

/**/ /************************* 
<Russia Diamonds Ver 1.0> 
Copyright by forever_chang 
forever_chang@china.com 
2001.11.1 
*************************/  
/**/ /*****************************************************************************************/  
#include  " graphics.h "   /**/ /*头文件*/  
#include  " time.h "  
#include  " stdlib.h "  
#include  " bios.h "  
#include  " dos.h "  
#include  " stdio.h "  
#define  ESC 0x11b /*键盘扫描码*/ 
#define  UP 0x4800 
#define  DOWN 0x5000 
#define  LEFT 0x4b00 
#define  F1 0x3b00 
#define  RIGHT 0x4d00 
#define  YES 0x1579 
#define  NO 0x316e 
#define  RESTART 0x1372 
/**/ /*****************************************************************************************/  
struct  diamond  /**/ /*记录每种方块每种状态的信息*/  
... { 
int x[4]; 
int y[4]; 
int start_x; 
int start_y; 
int color; 
struct diamond *next; 
} ; 
int  grid[ 12 ][ 23 ];  /**/ /*记录所有格子的状态 (0)没有方块 (1)有固定方块 (2)有活动方块*/  
int  x;  /**/ /*活动方块所在位置*/  
int  y; 
int  level;  /**/ /*游戏难度*/  
int  count;  /**/ /*计数器*/  
int  score; /**/ /*得分*/  
struct  diamond  * nowinfo;  /**/ /*当前活动方块*/  
struct  diamond  * nextinfo;  /**/ /*下一个方块*/  
int  color; /**/ /*画格子的颜色*/  
int  backcolor; /**/ /*游戏区域背景色*/  
/**/ /*****************************************************************************************/  
void  show_interface ( int  mode); /**/ /*显示游戏界面*/  
void  show_copsign ( int  topx, int  topy, int  size, int  color); /**/ /*显示公司标志--恒基伟业*/  
void  show_intro ( int  xs, int  ys); /**/ /*显示软件介绍区*/  
/**/ /*void print(); 测试用函数*/  
void  scandel(); /**/ /*扫描所有格子看是否有可消除行*/  
void  show_down (); /**/ /*方块下落后的下一个状态*/  
void  show_next (); /**/ /*方块翻转后的下一个状态*/  
void  show_left (); /**/ /*方块向左移动后的下一个状态*/  
void  show_right (); /**/ /*方块向右移动后的下一个状态*/  
void  interrupt ( * oldtimer)(); /**/ /*指向未安装前的中断向量,即函数指针,指向一段可执行的代码*/  
void  install(); /**/ /*安装新的中断向量,即将中断服务程序安装到中断向量表中*/  
void  interrupt newtimer(); /**/ /*中断服务程序*/  
struct  diamond  * get_diamond(); /**/ /*随机得到一个方块*/  
struct  diamond  * create_I(); /**/ /*函数用来构造各种类形方块的环形链表*/  
struct  diamond  * create_T(); /**/ /*返回链表中随机一个状态的指针*/  
struct  diamond  * create_L(); 
struct  diamond  * create_J(); 
struct  diamond  * create_Z(); 
struct  diamond  * create_N(); 
struct  diamond  * create_H(); 
void  delinfo ( struct  diamond  * info); /**/ /*释放当前方块所占用的空间*/  
void  addtobuffer( int  c); /**/ /*向键盘缓冲区中增加一个DOWN*/  
/**/ /*void clrkey();调用dos中断清空键盘缓冲区,未使用此方法.*/  
void  showsubwin( struct  diamond  * next); /**/ /*在小窗口显示下一个方块*/  
void  showscore( int  scoreget); /**/ /*显示分数*/  
void  startset(); /**/ /*初始化游戏*/  
/**/ /*****************************************************************************************/  
main () 
... { 
int driver=VGA; 
int mode=VGAHI; 
int i;/**//*计数器*/ 
int j; 
int key;/**//*记录键盘扫描码*/ 
initgraph (&driver,&mode,"");/**//*初始化*/ 
color=8; 
backcolor=7; 
level=1; 
score=298; 
count=0; 
show_interface (9);/**//*显示界面*/ 
setfillstyle(SOLID_FILL,1); 
bar(0,465,640,480); 
outtextxy(5,469,"Press any key to start..."); 
getch(); 
setfillstyle(SOLID_FILL,9); 
bar(0,465,640,480); 
showscore(0);/**//*显示分数*/ 
randomize(); 
nowinfo=get_diamond ();/**//*得到一个当前方块*/ 
oldtimer=getvect(0x1c); 
install(newtimer); 
for(i=0;i<=21;i++)/**//*初始化grid[12][23]*/ 
...{ 
for(j=1;j<=10;j++) 
grid[j][i]=0; 
} 
for(i=0;i<=22;i++) 
...{ 
grid[0][i]=1; 
grid[11][i]=1; 
} 
for(i=0;i<=11;i++) 
...{ 
grid[i][22]=1; 
} 　 

x=nowinfo->start_x;/**//*初始化方块位置*/ 
y=nowinfo->start_y; 
nextinfo=get_diamond ();/**//*得到下一个方块*/ 
showsubwin(nextinfo); 　 

for (; 
...{ 
key=bioskey(0);/**//*得到键盘扫描码*/ 
if (key) 
...{ 
switch(key) 
...{ 　 

case DOWN:...{ 
show_down (); 
break; 
} 
case UP:...{ 
show_next (); 
break; 
} 
case LEFT:...{ 
show_left(); 
break; 
} 
case RIGHT:...{ 
show_right(); 
break; 
} 
case RESTART:...{ 
install(oldtimer); 
setfillstyle(SOLID_FILL,1); 
bar(0,465,640,480); 
outtextxy(5,469,"Are you sure to restart (Y/N)..."); 
for (; 
...{ 
key=bioskey(0);/**//*得到键盘扫描码*/ 
if (key==YES) 
...{ 
startset(); 
setfillstyle(SOLID_FILL,9); 
bar(0,465,640,480); 
break; 
} 
if (key==NO) 
...{ 
setfillstyle(SOLID_FILL,9); 
bar(0,465,640,480); 
install(newtimer); 
break; 
} 
} 
break; 
} 
/**//* case F1:{ 
print(); 
break; 
} 
*/ 
case ESC:...{ 
install(oldtimer); 
setfillstyle(SOLID_FILL,1); 
bar(0,465,640,480); 
outtextxy(5,469,"Are you sure to exit (Y/N)..."); 
for (; 
...{ 
key=bioskey(0);/**//*得到键盘扫描码*/ 
if (key==YES) 
...{ 
closegraph(); 
exit(0); 
} 
if (key==NO) 
...{ 
setfillstyle(SOLID_FILL,9); 
bar(0,465,640,480); 
install(newtimer); 
break; 
} 
} 　 

} 
} 
} 
} 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * get_diamond() 
... { 
struct diamond *now; 
switch (random(7)+1) 
...{ 
case 1:...{ 
now=create_I(); 
return now; 
} 
case 2:...{ 
now=create_T(); 
return now; 
} 
case 3:...{ 
now=create_L(); 
return now; 
} 
case 4:...{ 
now=create_J(); 
return now; 
} 
case 5:...{ 
now=create_Z(); 
return now; 
} 
case 6:...{ 
now=create_N(); 
return now; 
} 
case 7:...{ 
now=create_H(); 
return now; 
} 
} 
}  
/**/ /*****************************************************************************************/  
void  show_interface ( int  fill_mode) 
... { 
int i; 
setbkcolor (9); 
setcolor (color); 
setfillstyle (SOLID_FILL,backcolor); 
bar (100,60,300,420); 
bar (360,60,440,140); 
rectangle (100,60,300,420); 
rectangle (96,56,304,424); 　 

rectangle (360,60,440,140); 
rectangle (356,56,444,144); 
setfillstyle (fill_mode,14); 
floodfill (97,57,color); 
floodfill (397,57,color); 
setcolor(1); 
rectangle(96,56,304,424); 
setcolor (color); 
for (i=80;i<=400;i+=20) 
...{ 
line (100,i,300,i); 
} 
for (i=120;i<=280;i+=20) 
...{ 
line (i,60,i,420); 
} 
for (i=80;i<=120;i+=20) 
...{ 
line (360,i,440,i); 
} 
for (i=380;i<=420;i+=20) 
...{ 
line (i,60,i,140); 
} 
show_intro (360,180); 
show_copsign (475,320,40,1); 
setfillstyle(SOLID_FILL,1); 
setcolor(14); 
rectangle(420,405,534,417); 
floodfill (421,406,14); 
outtextxy(422,408,"HI-TECH WEALTH"); 
}  
/**/ /*****************************************************************************************/  
void  show_copsign ( int  topx, int  topy, int  size, int  color) 
... { 
int halfsize,qtrsize; 
int xadd,xdel,yadd1,yadd2; 
halfsize=0.5*size; 
qtrsize=0.25*size; 　 

xadd=topx+size; 
xdel=topx-size; 
yadd1=topy+size; 
yadd2=topy+2*size; 　 

setcolor(color); 
line (topx,topy,xdel,yadd1); 
line (xdel,yadd1,topx,yadd2); 
line (topx,yadd2,xadd,yadd1); 
line (xadd,yadd1,topx,topy); 
rectangle (topx-halfsize,topy+halfsize,topx+halfsize,yadd1+halfsize); 
setfillstyle (SOLID_FILL,color); 
floodfill (topx,topy+1,color); 
floodfill (xdel+1,yadd1,color); 
floodfill (topx,yadd2-1,color); 
floodfill (xadd-1,yadd1,color); 
rectangle (topx-halfsize,yadd1-qtrsize,topx-0.75*halfsize,yadd1+qtrsize); 
floodfill (topx-halfsize+1,yadd1-qtrsize+1,color); 
rectangle (topx-qtrsize,yadd1-halfsize,topx+qtrsize,yadd1-0.25*halfsize); 
floodfill (topx-qtrsize+1,yadd1-halfsize+1,color); 
rectangle (topx+0.75*halfsize,yadd1-qtrsize,topx+halfsize,yadd1+qtrsize); 
floodfill (topx+0.75*halfsize+1,yadd1-qtrsize+1,color); 
rectangle (topx-qtrsize,yadd1+0.25*halfsize,topx+qtrsize,yadd2-halfsize); 
floodfill (topx-qtrsize+1,yadd1+0.25*halfsize+1,color); 
setcolor(14); 
line (topx,topy-1,xdel-1,yadd1); 
line (xdel-1,yadd1,topx,yadd2+1); 
line (topx,yadd2+1,xadd+1,yadd1); 
line (xadd+1,yadd1,topx,topy-1); 
setfillstyle (SOLID_FILL,14); 
floodfill (topx,yadd1,color); 
}  
/**/ /*****************************************************************************************/  
void  show_intro ( int  xs, int  ys) 
... { 
char stemp[20]; 
setcolor (15); 
rectangle(xs-3,ys-3,xs+239,ys+115); 
line (xs-3,ys+26,xs+239,ys+26); 
line (xs-3,ys+72,xs+239,ys+72); 
outtextxy(xs,ys,"Level:"); 
outtextxy(xs,ys+15,"Score:"); 
sprintf(stemp," -Roll -Downwards"); 
stemp[0]=24; 
stemp[7]=25; 
outtextxy(xs,ys+30,"Help:"); 
setcolor(14); 
outtextxy(xs+40,ys+30,stemp); 
outtextxy(xs+40,ys+45,"<-Turn Left >-Turn Right"); 
outtextxy(xs+40,ys+60,"Esc-Exit R-Restart"); 
outtextxy(xs,ys+75,"Russia Diamonds Ver 1.0"); 
outtextxy(xs,ys+90,"CopyRight By ChangYong.01-11-1"); 
outtextxy(xs,ys+105,"Email:forever_chang@163.com"); 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * create_I() 
... { 
struct diamond *info; 
struct diamond *first; 
first=(struct diamond *)malloc(sizeof(struct diamond)); 
info=(struct diamond *)malloc(sizeof(struct diamond)); 
first->next=info; 
info->next=first; 
first->x[0]=0; 
first->y[0]=0; 
first->x[1]=-1; 
first->y[1]=0; 
first->x[2]=1; 
first->y[2]=0; 
first->x[3]=2; 
first->y[3]=0; 
first->start_x=5; 
first->start_y=3; 
first->color=2; 　 

info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=-1; 
info->x[2]=0; 
info->y[2]=1; 
info->x[3]=0; 
info->y[3]=2; 
info->start_x=5; 
info->start_y=1; 
info->color=2; 　 

if(random(2)==0) ...{return first;} 
else ...{return first->next;} 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * create_T() 
... { 
struct diamond *info; 
struct diamond *first; 
struct diamond *last; 
int i; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=-1; 
info->y[1]=0; 
info->x[2]=0; 
info->y[2]=-1; 
info->x[3]=1; 
info->y[3]=0; 
info->start_x=5; 
info->start_y=3; 
info->color=4; 
first=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=1; 
info->x[2]=0; 
info->y[2]=-1; 
info->x[3]=1; 
info->y[3]=0; 
info->start_x=5; 
info->start_y=2; 
info->color=4; 
last->next=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=-1; 
info->y[1]=0; 
info->x[2]=1; 
info->y[2]=0; 
info->x[3]=0; 
info->y[3]=1; 
info->start_x=5; 
info->start_y=2; 
info->color=4; 
last->next=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=1; 
info->x[2]=0; 
info->y[2]=-1; 
info->x[3]=-1; 
info->y[3]=0; 
info->start_x=5; 
info->start_y=2; 
info->color=4; 
last->next=info; 
last=info; 
last->next=first; 　 

for (i=0;i<=random(4);i++) 
...{ 
first=first->next; 
} 
return first; 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * create_L() 
... { 
struct diamond *info; 
struct diamond *first; 
struct diamond *last; 
int i; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=1; 
info->x[2]=0; 
info->y[2]=-1; 
info->x[3]=1; 
info->y[3]=1; 
info->start_x=5; 
info->start_y=2; 
info->color=5; 
first=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=-1; 
info->y[1]=0; 
info->x[2]=1; 
info->y[2]=0; 
info->x[3]=-1; 
info->y[3]=1; 
info->start_x=5; 
info->start_y=2; 
info->color=5; 
last->next=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=1; 
info->x[2]=0; 
info->y[2]=-1; 
info->x[3]=-1; 
info->y[3]=-1; 
info->start_x=5; 
info->start_y=2; 
info->color=5; 
last->next=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=-1; 
info->y[1]=0; 
info->x[2]=1; 
info->y[2]=0; 
info->x[3]=1; 
info->y[3]=-1; 
info->start_x=5; 
info->start_y=2; 
info->color=5; 
last->next=info; 
last=info; 
last->next=first; 　 

for (i=0;i<=random(4);i++) 
...{ 
first=first->next; 
} 
return first; 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * create_J() 
... { 
struct diamond *info; 
struct diamond *first; 
struct diamond *last; 
int i; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=1; 
info->x[2]=0; 
info->y[2]=-1; 
info->x[3]=-1; 
info->y[3]=1; 
info->start_x=5; 
info->start_y=2; 
info->color=6; 
first=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=-1; 
info->y[1]=0; 
info->x[2]=1; 
info->y[2]=0; 
info->x[3]=-1; 
info->y[3]=-1; 
info->start_x=5; 
info->start_y=2; 
info->color=6; 
last->next=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=1; 
info->x[2]=0; 
info->y[2]=-1; 
info->x[3]=1; 
info->y[3]=-1; 
info->start_x=5; 
info->start_y=2; 
info->color=6; 
last->next=info; 
last=info; 　 

info=(struct diamond *)malloc(sizeof(struct diamond)); 
info->x[0]=0; 
info->y[0]=0; 
info->x[1]=-1; 
info->y[1]=0; 
info->x[2]=1; 
info->y[2]=0; 
info->x[3]=1; 
info->y[3]=1; 
info->start_x=5; 
info->start_y=2; 
info->color=6; 
last->next=info; 
last=info; 
last->next=first; 　 

for (i=0;i<=random(4);i++) 
...{ 
first=first->next; 
} 
return first; 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * create_Z() 
... { 
struct diamond *info; 
struct diamond *first; 
first=(struct diamond *)malloc(sizeof(struct diamond)); 
info=(struct diamond *)malloc(sizeof(struct diamond)); 
first->next=info; 
info->next=first; 
first->x[0]=0; 
first->y[0]=0; 
first->x[1]=-1; 
first->y[1]=0; 
first->x[2]=0; 
first->y[2]=1; 
first->x[3]=1; 
first->y[3]=1; 
first->start_x=5; 
first->start_y=2; 
first->color=9; 　 

info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=1; 
info->x[2]=1; 
info->y[2]=0; 
info->x[3]=1; 
info->y[3]=-1; 
info->start_x=5; 
info->start_y=2; 
info->color=9; 　 

if(random(2)==0) ...{return first;} 
else ...{return first->next;} 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * create_N() 
... { 
struct diamond *info; 
struct diamond *first; 
first=(struct diamond *)malloc(sizeof(struct diamond)); 
info=(struct diamond *)malloc(sizeof(struct diamond)); 
first->next=info; 
info->next=first; 
first->x[0]=0; 
first->y[0]=0; 
first->x[1]=0; 
first->y[1]=1; 
first->x[2]=-1; 
first->y[2]=1; 
first->x[3]=1; 
first->y[3]=0; 
first->start_x=5; 
first->start_y=2; 
first->color=14; 　 

info->x[0]=0; 
info->y[0]=0; 
info->x[1]=0; 
info->y[1]=-1; 
info->x[2]=1; 
info->y[2]=0; 
info->x[3]=1; 
info->y[3]=1; 
info->start_x=5; 
info->start_y=2; 
info->color=14; 　 

if(random(2)==0) ...{return first;} 
else ...{return first->next;} 
}  
/**/ /*****************************************************************************************/  
struct  diamond  * create_H() 
... { 
struct diamond *first; 
first=(struct diamond *)malloc(sizeof(struct diamond)); 
first->next=first; 
first->x[0]=0; 
first->y[0]=0; 
first->x[1]=0; 
first->y[1]=1; 
first->x[2]=1; 
first->y[2]=0; 
first->x[3]=1; 
first->y[3]=1; 
first->start_x=5; 
first->start_y=2; 
first->color=1; 
return first; 
}  
/**/ /*****************************************************************************************/  
void  show_next () 
... { 
int nowx;/**//*记录当前每个格子的位置*/ 
int nowy; 
int i;/**//*计数器*/ 
int j; 
int haveit;/**//*当前格子是否已经显示*/ 
struct diamond *next;/**//*当前方块的翻转后的下一个状态*/ 
next=nowinfo->next; 
if (next==NULL) ...{gotoxy(1,1);printf("null");} 
for (i=0;i<=3;i++)/**//*判断是否能够翻转,若不能,就直接退出该函数*/ 
...{ 
if (grid[x+next->x[i]][y+next->y[i]]==1) 
...{ 
return; 
} 
} 　 

setfillstyle(SOLID_FILL,backcolor);/**//*设置背景色以消除不需要的格子*/ 
for (i=0;i<=3;i++) 
...{ 
haveit=0; 
for (j=0;j<=3;j++) 
...{ 
if (next->x[j]==nowinfo->x[i]&&next->y[j]==nowinfo->y[i]) ...{haveit=1;break;} 
} 
if (haveit==0) /**//*判断翻转后该格子是否显示,若不显示,将该格子设为背景色*/ 
...{ 
grid[x+nowinfo->x[i]][y+nowinfo->y[i]]=0; 
if (y+nowinfo->y[i]>=4)/**//*判断该格子是否到了可以显示的区域*/ 
floodfill(80+(nowinfo->x[i]+x)*20+1,-20+(nowinfo->y[i]+y)*20+1,color); 
} 
} 　 

nowinfo=next; 
nowx=x; 
nowy=y; 
setfillstyle(SOLID_FILL,nowinfo->color);/**//*设置填冲色为方块的颜色*/ 
for (i=0;i<=3;i++) 
...{ 
if (grid[x+nowinfo->x[i]][y+nowinfo->y[i]]!=2)/**//*如果该格子还没有被显示*/ 
...{ 
nowx=x+nowinfo->x[i]; 
nowy=y+nowinfo->y[i]; 
if (y+nowinfo->y[i]>=4) 
floodfill(80+nowx*20+1,-20+nowy*20+1,color); 
grid[nowx][nowy]=2; /**//*设置该格子当前有活动方块*/ 
} 
} 
return; 
}  
/**/ /*****************************************************************************************/  
void  show_left () 
... { 
int i;/**//*计数器*/ 
int j; 
int haveit;/**//*当前格子是否已经显示*/ 
int nowx;/**//*记录当前每个格子的位置*/ 
int nowy; 
for (i=0;i<=3;i++)/**//*判断是否可以向左移动*/ 
...{ 
if (grid[x-1+nowinfo->x[i]][y+nowinfo->y[i]]==1) 
...{ 
return; 
} 
} 　 

setfillstyle(SOLID_FILL,backcolor);/**//*设置背景色以消除不需要的格子*/ 
for (i=0;i<=3;i++) 
...{ 
haveit=0; 
for (j=0;j<=3;j++) 
...{ 
if (nowinfo->x[i]==nowinfo->x[j]-1&&nowinfo->y[i]==nowinfo->y[j]) ...{haveit=1;break;} 
} 
if (haveit==0) /**//*判断翻转后该格子是否显示,若不显示,将该格子设为背景色*/ 
...{ 
grid[x+nowinfo->x[i]][y+nowinfo->y[i]]=0; 
if (y+nowinfo->y[i]>=4)/**//*判断该格子是否到了可以显示的区域*/ 
floodfill(80+(nowinfo->x[i]+x)*20+1,-20+(nowinfo->y[i]+y)*20+1,color); 
} 
} 　 

setfillstyle(SOLID_FILL,nowinfo->color);/**//*设置填冲色为方块的颜色*/ 
for (i=0;i<=3;i++) 
...{ 
nowx=x+nowinfo->x[i]-1; 
nowy=y+nowinfo->y[i]; 
if (grid[nowx][nowy]!=2)/**//*如果该格子还没有被显示*/ 
...{ 
if (nowy>=4) 
floodfill(80+nowx*20+1,-20+nowy*20+1,color); 
grid[nowx][nowy]=2; 
} 
} 
x=x-1; 
return; 
}  
/**/ /*****************************************************************************************/  
void  show_right () 
... { 
int i;/**//*计数器*/ 
int j; 
int haveit;/**//*当前格子是否已经显示*/ 
int nowx;/**//*记录当前每个格子的位置*/ 
int nowy; 
for (i=0;i<=3;i++) 
...{ 
if (grid[x+1+nowinfo->x[i]][y+nowinfo->y[i]]==1) 
...{ 
return;/**//*判断是否可以向右移动*/ 
} 
} 　 

setfillstyle(SOLID_FILL,backcolor);/**//*设置背景色以消除不需要的格子*/ 
for (i=0;i<=3;i++) 
...{ 
haveit=0; 
for (j=0;j<=3;j++) 
...{ 
if (nowinfo->x[i]==nowinfo->x[j]+1&&nowinfo->y[i]==nowinfo->y[j]) ...{haveit=1;break;} 
} 
if (haveit==0)/**//*判断翻转后该格子是否显示,若不显示,将该格子设为背景色*/ 
...{ 
grid[x+nowinfo->x[i]][y+nowinfo->y[i]]=0; 
if (y+nowinfo->y[i]>=4)/**//*判断该格子是否到了可以显示的区域*/ 
floodfill(80+(nowinfo->x[i]+x)*20+1,-20+(nowinfo->y[i]+y)*20+1,color); 
} 
} 　 


setfillstyle(SOLID_FILL,nowinfo->color);/**//*设置填冲色为方块的颜色*/ 
for (i=0;i<=3;i++) 
...{ 
nowx=x+nowinfo->x[i]+1; 
nowy=y+nowinfo->y[i]; 
if (grid[nowx][nowy]!=2) 
...{ 
if (nowy>=4)/**//*判断该格子是否到了可以显示的区域*/ 
floodfill(80+nowx*20+1,-20+nowy*20+1,color); 
grid[nowx][nowy]=2; 
} 
} 
x=x+1; 
return; 
}  
/**/ /*****************************************************************************************/  
void  show_down () 
... { 　 

int i;/**//*计数器*/ 
int j; 
int haveit;/**//*当前格子是否已经显示*/ 
int nowx;/**//*记录当前每个格子的位置*/ 
int nowy; 
int key; 
for (i=0;i<=3;i++) 
...{ 
if (grid[x+nowinfo->x[i]][y+nowinfo->y[i]+1]==1)/**//*判断方块是否能够下落*/ 
...{ 
for (j=0;j<=3;j++) 
...{ 
grid[x+nowinfo->x[j]][y+nowinfo->y[j]]=1; 
if (y+nowinfo->y[j]<=3) 
...{/**//*判断游戏是否已经玩完*/ 
install(oldtimer); 
setfillstyle(SOLID_FILL,1); 
bar(0,465,640,480); 
outtextxy(5,469,"Do you want to restart (Y/N)..."); 
for (; 
...{ 
key=bioskey(0); 
if (key==YES) 
...{ 
startset(); 
setfillstyle(SOLID_FILL,9); 
bar(0,465,640,480); 
return; 
} 
if (key==NO) 
...{ 
closegraph(); 
exit (0);} 
} 
} 
} 　 

delinfo(nowinfo); 
scandel();/**//*扫描,删除*/ 
delay(2500); 
while(bioskey(1)) bioskey(0);/**//*清除键盘缓冲区*/ 
/**//* clrkey();*/ 
nowinfo=nextinfo;/**//*得到新的方块*/ 
nextinfo=get_diamond();/**//*得到下一个方块*/ 
showsubwin(nextinfo); 
x=nowinfo->start_x;/**//*重新设置方块位置*/ 
y=nowinfo->start_y; 
return; 
} 
} 　 

setfillstyle(SOLID_FILL,backcolor);/**//*设置背景色以消除不需要的格子*/ 　 

for (i=0;i<=3;i++) 
...{ 
haveit=0; 
for (j=0;j<=3;j++) 
...{ 
if (nowinfo->x[i]==nowinfo->x[j]&&nowinfo->y[i]==nowinfo->y[j]+1) ...{haveit=1;break;} 
} 
if (haveit==0)/**//*判断翻转后该格子是否显示,若不显示,将该格子设为背景色*/ 
...{ 
grid[x+nowinfo->x[i]][y+nowinfo->y[i]]=0; 
if (y+nowinfo->y[i]>=4)/**//*判断该格子是否到了可以显示的区域*/ 
floodfill(80+(nowinfo->x[i]+x)*20+1,-20+(nowinfo->y[i]+y)*20+1,color); 
} 
} 
setfillstyle(SOLID_FILL,nowinfo->color);/**//*设置填冲色为方块的颜色*/ 
for (i=0;i<=3;i++) 
...{ 
nowx=x+nowinfo->x[i]; 
nowy=y+nowinfo->y[i]+1; 
if (grid[nowx][nowy]!=2)/**//*如果该格子还没有被显示*/ 
...{ 
if (nowy>=4) 
floodfill(80+nowx*20+1,-20+nowy*20+1,color); 
grid[nowx][nowy]=2; 
} 
} 
y=y+1; 
return; 
}  
/**/ /*****************************************************************************************/  
/**/ /*void print()测试用函数 
{ 
int i; 
int j; 
gotoxy(1,1); 
for (j=0;j<=22;j++) 
{for (i=0;i<=11;i++) 
{ 
printf ("%d",grid[i][j]);} 
printf (" "); 
} 
}*/  
/**/ /*****************************************************************************************/  
void  scandel() 
... { 
int i; 
int k; 
int j; 
int num; 
int scoreadd; 
scoreadd=0; 
for (k=21;k>=4;k--) 
...{ 
num=0; 
for (i=1;i<=10;i++) 
...{ 
if (grid[i][k]==1) num++; 
} 
if (num==10) 
...{ 
scoreadd++; 
for (i=1;i<=10;i++) 
...{ 
setfillstyle(SOLID_FILL,backcolor); 
floodfill(80+i*20+1,-20+k*20+1,color); 
} 　 

for (j=k;j>=5;j--) 
...{ 
for (i=1;i<=10;i++) 
...{ 
setfillstyle(SOLID_FILL,getpixel(80+i*20+1,-40+j*20+1)); 
floodfill(80+i*20+1,-20+j*20+1,color); 
grid[i][j]=grid[i][j-1]; 
} 
} 
for (i=1;i<=10;i++) 
...{ 
setfillstyle(SOLID_FILL,backcolor); 
floodfill(80+i*20+1,61,color); 
grid[i][4]=0; 
} 
k++; 
} 
} 
if (scoreadd!=0) showscore(2*scoreadd-1); 
}  
/**/ /*****************************************************************************************/  
void  interrupt newtimer() /**/ /*新的定时中断调用*/  
... { 
int leveltemp; 
leveltemp=11-level; 
count++; 
if(count>=leveltemp) 
...{ 
addtobuffer(DOWN); 
count=0; 
} 
(*oldtimer)(); 
}  
/**/ /*****************************************************************************************/  
void  install ( void  interrupt ( * paddr)()) 
... { 
disable(); 
setvect(0x1c,paddr); 
enable(); 
}  
/**/ /******************************************************************************************/  
void  delinfo ( struct  diamond  * info) /**/ /*释放开辟的空间*/  
... { 
struct diamond *now; 
struct diamond *next; 
now=info->next; 
next=info->next; 
while(next!=info) 
...{ 
next=now->next; 
free(now); 
now=next; 
} 
free(info); 
}  
/**/ /******************************************************************************************/  
void  addtobuffer( int  c) /**/ /*向键盘缓冲区中增加一个DOWN*/  
... { 
unsigned i; 
i=*(unsigned far *)0x0040001CL; 
*(unsigned far *)(0x00400000L | i)=c; 
i+=2; 
if (i>=*(unsigned far *)0x00400082L) i=*(unsigned far *)0x00400080L; 
*(unsigned far *)0x0040001CL=i; 
}  
/**/ /******************************************************************************************/  
/**/ /*void clrkey()调用dos中断清空键盘缓冲区,未使用此方法. 
{ 
union REGS in ; 
in.h.ah = 0x0c ; 
in.h.al = 0x00 ; 
intdos(&in , &in) ; 
} 
*/  
/**/ /******************************************************************************************/  
void  showsubwin( struct  diamond  * next) 
... { 
int i;/**//*计数器*/ 
int j; 
setfillstyle (SOLID_FILL,backcolor); 
for (i=0;i<=3;i++) 
...{ 
for(j=0;j<=3;j++) 
...{ 
floodfill(361+20*i,61+20*j,color); 
} 
} 
setfillstyle (SOLID_FILL,next->color); 
for (i=0;i<=3;i++) 
...{ 
floodfill(381+next->x[i]*20,81+next->y[i]*20,color); 
} 
}  
/**/ /******************************************************************************************/  
void  showscore( int  scoreget) 
... { 
char sscore[6]; 
char slevel[2]; 
score+=scoreget; 
if (score<1000) level=score/100+1; 
sprintf(sscore,"%d",score); 
sprintf(slevel,"%d",level); 
setfillstyle(SOLID_FILL,9); 
bar(406,179,490,203); 
setcolor(14); 
outtextxy (408,180,slevel); 
outtextxy (408,195,sscore); 
}  
/**/ /*******************************************************************************************/  
void  startset() 
... { 
int i; 
int j; 
setfillstyle(SOLID_FILL,backcolor); 
for(i=0;i<=21;i++)/**//*重新初始化*/ 
...{ 
for(j=1;j<=10;j++) 
if (grid[j][i]!=0) 
...{ 
grid[j][i]=0; 
if (i>=4) floodfill(80+j*20+1,-20+i*20+1,color); 
} 
} 
score=0; 
showscore(0); 
nowinfo=get_diamond ();/**//*得到一个当前方块*/ 
x=nowinfo->start_x;/**//*初始化方块位置*/ 
y=nowinfo->start_y; 
nextinfo=get_diamond ();/**//*得到下一个方块*/ 
showsubwin(nextinfo); 
install(newtimer); 
}