C语言的三维数组的应用

C语言的三维数组的应用
摘要：利用程序语言【C语言】编写一个俄罗斯方块游戏，加深对程序入口、出口的理解和编制，掌握数组的运用，以及对知识的拓展。

关键字：C语言, 俄罗斯方块, 三维数组
Abstract: [C programming language - language prepared by a Russian box game, understand the procedures for import, export of understanding and preparation, master the use of the array, and the expansion of knowledge.
Keyword: C language, the Russian box,
three-dimensional array
前言：本设计是为了制作一个“俄罗斯方块”游戏。

俄罗斯方块是一款风靡全球的电视游戏机和掌上游戏机游戏，它曾经造成的轰动与造成的经济价值可以说是游戏史上的一件大事。

这款游戏最初是由苏联的游戏制作人Alex Pajitnov制作的，它看似简单但却变化无穷，令人上瘾。

相信大多数用户都还记得为它痴迷得茶不思饭不想的那个俄罗斯方块时代。

制作此软件是为了使用户既能感受到游戏中的乐趣，也给用户提供了一个展现自己高超技艺的场所。

在毕业论文选题上，我利用c语言制作俄罗斯方块游戏，在c语言中通过利用三维数组来存放最初的形状，利用四个方向键，来控制方块的移动和变形，利用ENTER,ESC,SPACE,HOME,来控制占停，退出，快速下落，和开始。

方块的形状，颜色都是随机的。

在游戏的旁边有积分，和下一个的形状，还设计了过关，加分等等。

系统进入游戏后，会出现俄罗斯方块的字样，和积分NUMBER,NEXTBOX。

按ESC退出游戏，结束出现 GAMEOVER，和成员名，通过函数实现各个功能。

目录
一．概述
1.1俄罗斯方块的题目的描述
1.2俄罗斯方块的设计思想
1.2.1详细规则、胜负判定方法
1.2.2游戏操作方法
1.3 开发工具
1.4 软件运行环境
1.5 项目任务书
二、总体设计
2.1 开发与设计的总体思想
2.2 系统模块结构图
2.3 模块设计
2.3.1 主要模块
2.3.2 图形修饰模块
2.3.3 系统流程图
2.3.4 按键及功能对照表
2.3.5 主要函数名称以及功能表
2.4 模块设计小结
三、实验结果分析及程序代码
四、结果分析：
五、总结
六、参考文献：
一、概述：
1.1俄罗斯方块的题目的描述
1. 运行游戏时.界面随机的产生不同形状的方块,游戏者通过自己的操作使方块进行合理的堆积.如果每层达到饱和状态的时候会自动消除.然后游戏有规则的进行加分.分数达到一定的阶段.游戏的级别也会越来越高.然后方块下降的速度也会随之慢慢加快.以迎合游戏者的挑战,达到最加有趣的游戏!
1.2俄罗斯方块的设计思想
游戏是用来给大家娱乐的，所以要能在使用的过程中给大家带来快乐，消除大家的疲劳，所以我们在游戏中添加了漂亮的场景和动听的音乐，设置了过关升级的功能，激发大家的娱乐激情。

从游戏的基本玩法出发，主要就是俄罗斯方块的形状和旋转，利用三维数组每个方块含有各自的状态,变换只需改变到下一个状态就行了,完全可以用数组来实现(不用写旋转算法了:)
比如:
/* 方块类型为■■■■ */
char[2][4][4] B1={
{
{0,1,0,0},□■□□
{0,1,0,0},□■□□
{0,1,0,0},□■□□
{0,1,0,0} □■□□
},
{
{0,0,0,0},□□□□
{1,1,1,1},■■■■
{0,0,0,0},□□□□
{0,0,0,0} □□□□
}};
含两种状态,每个状态是一个4*4数组,为1表示实心,为0表示空心.因此我们总共设计了7种造型，每种造型又可以通过旋转而变化出2到4种形状，利用随机函数在一个预览窗体中提前展示形状供用户参考，然后将展示的形状复制到游戏窗体中进行摆放，在游戏窗体中用户就可以使用键盘的方向键来控制方块的运动，然后利用递归语句对每一行进行判断，
如果有某行的方块是满的，则消除这行的方块，并且使上面的方块自由下落，其中，方块向下的速度是有时钟控件控制的，在游戏中，用户也可以使用向下键加快下落速度，定义一个变量，对消除的函数进行记录，最后就可以得出用户的分数，用if 语句对分数判断，达到一定的积分就可以升级到下一个档次。

俄罗斯方块游戏设计的主要步骤为以下几个方面：
（1）游戏界面的设计。

（2）俄罗斯方块的造型。

（3）俄罗斯方块的旋转。

（4）俄罗斯方块的运动情况（包括向左，向右和向下）。

（5）俄罗斯方块的自动消行功能。

（6）游戏级别的自由选择。

（7）游戏速度的自由选择。

（8）游戏得分的计算。

（9）游戏菜单选项的设计及功能实现。

1．3 开发环境：
硬件环境：一台电脑386,486,586及兼容机以上，包括键盘、
鼠标，最小硬盘空间1G，内存３２M以上。

软件环境：本系统的设计采用的是C语言开发,Windows操作
系统，win-tc v1.9.1以上
二、总体设计：
2.1 开发与设计的总体思想：
程序的设计方法是采用结构化程序设计方法，用c语言进行开发。

2.2 系统模块结构图：
2.3 模块设计：
2.3.1 主要模块：
先画出主要窗口界面，由外边框、盒状收缩，百页窗效果、主题字及功能函数组成。

根据函数顺序来完成相应功能，进入游戏（先建立游戏界面，屏幕提示选择按任意键开始游戏，）；游戏规则（满一行加一分）；最后是工作人员（显示小组人员名单后返回主界面）；最后按任意键结束整个游戏系统。

2.3.2 图形修饰模块：如下图示：
2.3.3系统流程图：如下图示：
2.3.4 按键及功能对照表：
2.4、模块设计小结
由上述模块分析和设计可知，本游戏的核心模块是主界面模块，图形修饰模块与函数模块均是为其而服务。

三、实验结果分析及程序代码
#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <graphics.h>
#include <stdlib.h>
#define MINBOXSIZE 20 /* 最小方块的尺寸*/
#define BGCOLOR 6 /* 背景着色*/
#define GX 200
#define GY 10
#define SJNUM 10000 /* 每当玩家打到一万分等级加一级*/
/* 按键码*/
#define VK_LEFT 0x4b00 /*左*/
#define VK_RIGHT 0x4d00 /*右*/
#define VK_DOWN 0x5000 /*下*/
#define VK_UP 0x4800 /*上*/
#define VK_SPACE 0x3920 /*空格*/
#define VK_ESC 0x011b /*退出*/
#define VK_ENTER 0x1c0d /*回车*/
/* 定义俄罗斯方块的方向（我定义他为4种）*/
#define F_DONG 0 /*东*/
#define F_NAN 1 /*南*/
#define F_XI 2 /*西*/
#define F_BEI 3 /*北*/
#define NEXTCOL 20 /* 要出的下一个方块的纵坐标*/
#define NEXTROW 12 /* 要出的下一个方块的横坐标*/
#define MAXROW 14 /* 游戏屏幕大小*/
#define MAXCOL 20
#define SCCOL 50 /*游戏屏幕在显示器上的相对位置*/
#define SCROW 30
#define X_Z 0 /* 定义方块的形状（共八种）*/
#define X_REZ 1
#define X_7 2
#define X_RE7 3
#define X_I 4
#define X_REI 5
#define X_TIAN 6
#define X_T 7
void *buf; /*定义无类型指针，用于将来指向内存空间*/
int gril[22][16]; /* 游戏屏幕坐标*/
int col=1,row=7; /* 当前方块的横纵坐标*/
int boxfx=0,boxgs=0; /* 当前方块的形状和方向*/
int nextboxfx,nextboxgs,maxcol=22;/*下一个方块的形状和方向*/
int minboxcolor,nextminboxcolor;/*小方块的颜色，下一个小方块的颜色*/ int num=0; /*游戏分*/
int dj=0,gamedj[10]={18,16,14,12,10,8,6,4,2,1};/* 游戏等级*/
Struct all
{
int x,y;
int fangxiang; /*方向*/
int gesu; /*第几个方块*/
};
/* 以下我用了一个3维数组来纪录方块的最初形状和方向*/
int boxstr[8][4][4]={{
{0,0,0,0},
{0,0,0,0},
{0,1,1,0},
{0,0,1,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,1,1,0}},
{
{0,0,0,0},
{0,0,1,1},
{0,0,0,1},
{0,0,0,1}},
{
{0,0,0,0},
{0,0,1,1},
{0,0,1,0},
{0,0,1,0}},
{
{0,0,0,1},
{0,0,0,1},
{0,0,0,1},
{0,0,0,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,0,0,0},
{1,1,1,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,0,1,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,1,1,1},
{0,0,1,0}}
};
/* 随机得到当前方块和下一个方块的形状和方向*/
void boxrad(){
minboxcolor=nextminboxcolor; /*下一个方块的颜色*/
boxfx=nextboxfx; /*下一个方块的方向*/
boxgs=nextboxgs; /*下一个方块是第几个方块*/
nextminboxcolor=random(16); /*随机产生下一个方块的颜色*/
if(nextminboxcolor==6||nextminboxcolor==7) /*如果颜色是棕色或淡灰色*/ nextminboxcolor=9; /*将其改为淡蓝色*/
nextboxfx=random(4); /*随机产生下一个方块的方向*/
nextboxgs=random(8); /*随机产生下一个方块是第几个方块*/}
/*初始化图形模式*/
void init(void)
{
int gh=DETECT,gm=0;
int errorcode;
registerbgidriver(EGAVGA_driver);
initgraph(&gh,&gm," ");}
/* 在图形模式下的清屏*/
void cls()
{
setfillstyle(SOLID_FILL,0);/*以背景颜色实填充*/
setcolor(0);
bar(0,0,640,480); /*基本图形函数*/}
/*在图形模式下的高级清屏*/
void clscr(int a,int b,int c,int d,int color)
{
setfillstyle(SOLID_FILL,color); /*以color颜色实填充*/
setcolor(color); /*设置当前前景色为color*/
bar(a,b,c,d); /*基本图形函数*/}
/*最小方块的绘制*/
void minbox(int asc,int bsc,int color)
{
int a=0,b=0;
a=SCCOL+asc; /*SCCOL 50，SCROW 30游戏屏幕在显示器上的相对位置*/
b=SCROW+bsc;
clscr(a+1,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE,color); /* MINBOXSIZE 20最小方块的尺寸*/
if(color!=BGCOLOR)/*如果当前色是背景色，将其改为白色*/
{
setcolor(15);
line(a+1,b+1,a-1+MINBOXSIZE,b+1);
line(a+1,b+1,a+1,b-1+MINBOXSIZE);
setcolor(0);
line(a-1+MINBOXSIZE,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE);
line(a+1,b-1+MINBOXSIZE,a-1+MINBOXSIZE,b-1+MINBOXSIZE);} }
/*最小方块的高级绘制*/
void box(int a,int b,int color)
{
clscr(a+1,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE,color);
setcolor(15);
line(a+1,b+1,a-1+MINBOXSIZE,b+1);
line(a+1,b+1,a+1,b-1+MINBOXSIZE);
setcolor(0);
line(a-1+MINBOXSIZE,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE);
line(a+1,b-1+MINBOXSIZE,a-1+MINBOXSIZE,b-1+MINBOXSIZE); }
/*游戏中出现的文字*/
void txt(int a,int b,char *txt,int font,int color)
{
setcolor(color);
settextstyle(0,0,font);
outtextxy(a,b,txt); }
/*windows 绘制*/
void win(int a,int b,int c,int d,int bgcolor,char *text,int font,int textcolor) {
clscr(a,b,c,d,7);
clscr(a+3,b+24,c-3,d-3,bgcolor);
clscr(a+3,b+3,c-3,b+20,9);
setcolor(15);
line(a,b,c,b);
line(a,b,a,d);
line(a+2,b+21,c-2,b+21);
line(c-2,b+2,c-2,b+21);
line(a+2,d-2,c-2,d-2);
line(c-2,b+23,c-2,d-2);
txt(a+5,b+8,text,font,textcolor);
setcolor(0);
line(a,d,c,d);
line(c,b,c,d);
line(a+3,b+2,c-3,b+2);
line(a+2,b+2,a+2,b+20);
line(a+2,b+24,a+2,d-2);
line(a+2,b+23,c-3,b+23); }
/*把方块的方向旋转fx个90度(fx最大等于3)*/
void re90(int boxxy[4][4],int fx)
{
int i,j,k,zero;
int a[4][4];
for(k=0;k<fx;k++)
{
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxxy[3-j][i];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
boxxy[i][j]=a[i][j];
for(i=0;i<4;i++)
{
zero=1;
for(j=0;j<4;j++)
if(boxxy[j][3]!=0)
zero=0;
if(zero)
for(j=0;j<4;j++)
{
boxxy[j][3]=boxxy[j][2];
boxxy[j][2]=boxxy[j][1];
boxxy[j][1]=boxxy[j][0];
boxxy[j][0]=0; } }} }
/* 当前方块的绘制*/
void funbox(int a,int b,int color)
{
int i,j;
int boxz[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
boxz[i][j]=boxstr[boxgs][i][j];
re90(boxz,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(boxz[i][j]==1)
minbox((j+row+a)*MINBOXSIZE,(i+col+b)*MINBOXSIZE,color); } /*下一个方块的绘制*/
void nextfunbox(int a,int b,int color)
{
int i,j;
int boxz[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
boxz[i][j]=boxstr[nextboxgs][i][j];
re90(boxz,nextboxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(boxz[i][j]==1)
minbox((j+a)*MINBOXSIZE,(i+b)*MINBOXSIZE,color); }
/*时间中断定义*/
#define TIMER 0x1c
int TimerCounter=0;
void interrupt ( *oldhandler)(__CPPARGS);
void interrupt newhandler(__CPPARGS)
{
TimerCounter++;
oldhandler();
}
void SetTimer(void interrupt (*IntProc)(__CPPARGS))
{
oldhandler=getvect(TIMER);
disable();
setvect(TIMER,IntProc);
enable(); }
/*由于游戏的规则，消掉都有最小方块的一行*/
void delcol(int a)
{
int i,j;
for(i=a;i>1;i--)
for(j=1;j<15;j++){
minbox(j*MINBOXSIZE,i*MINBOXSIZE,BGCOLOR);
gril[i][j]=gril[i-1][j];
if(gril[i][j]==1)
minbox(j*MINBOXSIZE,i*MINBOXSIZE,minboxcolor); } } /*把数字转换为字符串*/
char *numgochar(int x)
{
char k,*a="000000";
int i,j=10;
if(x==0)
return("0");
for(i=0;x>=1;i++)
{
a[i]='0'+ (x % 10);
x=x/10;
}
for(j=0;j<=i/2;j++)
{
k=a[j];
a[j]=a[i-j];
a[i-j]=k;
}
a[i+1]='\0';
return(a); }
/*消掉所有都有最小方块的行*/
void delete()
{
int i,j,zero,delgx=0;
char *nm;
for(i=1;i<21;i++){
zero=0;
for(j=1;j<15;j++)
if(gril[i][j]==0)
zero=1;
if(zero==0){
delcol(i);
delgx++;
} }
num=num+delgx*delgx*10;
dj=num/10000;
nm=numgochar(num);
clscr(456,173,500,200,BGCOLOR);
txt(456,173,"Number:",1,15);
txt(456,193,nm,1,15); }
/*时间中断结束*/
void KillTimer()
{
disable();
setvect(TIMER,oldhandler);
enable(); }
/* 测试当前方块是否可以向下落*/
int downok()
{
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j] && gril[col+i+1][row+j])
k=0;
return(k); }
/* 测试当前方块是否可以向左行*/
int leftok()
{
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j] && gril[col+i][row+j-1])
k=0;
return(k); }
/* 测试当前方块是否可以向右行*/
int rightok()
{
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j] && gril[col+i][row+j+1])
k=0;
return(k); }
/* 测试当前方块是否可以变形*/
int upok()
{
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx+1);
for(i=3;i>=0;i--)
for(j=3;j>=0;j--)
if(a[i][j] && gril[col+i][row+j])
k=0;
return(k); }
/*当前方块落下之后，给屏幕坐标作标记*/ void setgril()
{
int i,j,a[4][4];
funbox(0,0,minboxcolor);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j])
gril[col+i][row+j]=1;
col=1;row=7;
}
/*游戏结束*/
void gameover()
{
int i,j;
for(i=19;i>=0;i--)
for(j=2;j<16;j++)
box(j*MINBOXSIZE+SCROW,i*MINBOXSIZE+SCCOL,6); txt(103,203,"Game Over",3,10);}
/*按键的设置*/
void call_key(int keyx)
{
switch(keyx){
case VK_DOWN: { /*下方向键，横坐标加一。

*/
if(downok()){
col++;
funbox(0,0,minboxcolor);}
else{
funbox(0,0,minboxcolor);
setgril();
nextfunbox(NEXTCOL,NEXTROW,BGCOLOR);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,nextminboxcolor); delete();
}
break;
}
case VK_UP: { /*上方向键，方向形状旋转90度*/
if(upok())
boxfx++;
if(boxfx>3)
boxfx=0;
funbox(0,0,minboxcolor);
break;
}
case VK_LEFT:{ /*左方向键，纵坐标减一*/
if(leftok())
row--;
funbox(0,0,minboxcolor);
break;
}
case VK_RIGHT:{ /*右方向键，纵坐标加一*/
if(rightok())
row++;
funbox(0,0,minboxcolor);
break;
}
case VK_SPACE: /*空格键，直接落到最后可以落到的们置*/ while(downok())
col++;
funbox(0,0,minboxcolor);
setgril();
nextfunbox(NEXTCOL,NEXTROW,BGCOLOR);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,nextminboxcolor); delete();
break;
default: { win(423,53,620,95,15,"Enter Key Error!",1,15); txt(428,80,"Plese Enter Anly Key AG!",1,4);
getch();
clscr(420,50,622,97,BGCOLOR);
} } }
/*时间中断开始*/
void timezd(void){
int key;
SetTimer(newhandler);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,nextminboxcolor);
for(;;){
if(bioskey(1)){
key=bioskey(0);
funbox(0,0,BGCOLOR);
if(key==VK_ESC)
break;
call_key(key);
}
if(TimerCounter>gamedj[dj]){
TimerCounter=0;
if(downok()){
funbox(0,0,BGCOLOR);
col++;
funbox(0,0,minboxcolor);
}
else {
if(col==1){
gameover();
getch();
break;
}
setgril();
delete();
funbox(0,0,minboxcolor);
col=1;row=7;
funbox(0,0,BGCOLOR);
nextfunbox(NEXTCOL,NEXTROW,BGCOLOR);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,nextminboxcolor);
} } } }
/*百叶窗函数*/
void byc(void)
{ int i,j;
for(i=0;i<40;i++)
for(j=0;j<640;j= j +40) /*每隔40像素画一条线*/
{ setcolor(BLUE); /*设置前景色*/
line(j+i,0,j+i,479);
delay(500);
}
}
/*盒状收缩代码*/
void hzss(void)
{ int x1=0,y1=0,x2=639,y2=479;
setcolor(1);
for(;y1<=y2;x1++,y1++,x2--,y2--)
{
rectangle(x1,y1,x2,y2);
delay(1000);
}
setcolor(6);
x1=239;y1=239;x2=400;y2=239;
for(;x1>=0&&y1>=0&&x2<=639&&y2<=479;x1--,y1--,x2++,y2++)
{
rectangle(x1,y1,x2,y2);
delay(1000);
}}
void drawmat(char *mat,int matsize,int x,int y,int color) /*汉字点阵输出函数*/
{
int i,j,k,m;
m=(matsize-1)/8+1;
for(j=0;j<matsize;j++)
for(i=0;i<m;i++)
for(k=0;k<8;k++)
if(mat[j*m+i]&(0x80>>k))
putpixel(x+i*8+k,y+j,color);
}
char zu48H[]={
/* 以下是'组' 的48点阵黑体字模，288 byte */ };
char zhang_48H[]={
/* 以下是'长' 的48点阵黑体字模，288 byte */ };
char dian48H[]={
/* 以下是'：' 的48点阵黑体字模，288 byte */ };
char yuan_48H[]={
/* 以下是'员' 的48点阵黑体字模，288 byte */ };
char zhang48K[]={
/* 以下是'张' 的48点阵楷体_GB2312 字模，288 byte */ }; char fang48K[]={
/* 以下是'方' 的48点阵楷体_GB2312 字模，288 byte */ }; char yuan48K[]={
/* 以下是'元' 的48点阵楷体_GB2312 字模，288 byte */ }; char jie48K[]={
/* 以下是'解' 的48点阵楷体_GB2312 字模，288 byte */ }; char ying48K[]={
/* 以下是'莹' 的48点阵楷体_GB2312 字模，288 byte */ }; char zhao48K[]={
/* 以下是'赵' 的48点阵楷体_GB2312 字模，288 byte */ }; char jing48K[]={
/* 以下是'静' 的48点阵楷体_GB2312 字模，288 byte */ }; char tao48K[]={
/* 以下是'陶' 的48点阵楷体_GB2312 字模，288 byte */ }; char yuan_48K[]={
/* 以下是'园' 的48点阵楷体_GB2312 字模，288 byte */ }; char huo48K[]={
/* 以下是'霍' 的48点阵楷体_GB2312 字模，288 byte */ }; char shuai48K[]={
/* 以下是'帅' 的48点阵楷体_GB2312 字模，288 byte */ }; char e64H[]={
/* 以下是'俄' 的64点阵黑体字模，512 byte */ };
char luo64H[]={
/* 以下是'罗' 的64点阵黑体字模，512 byte */ };
char si64H[]={
/* 以下是'斯' 的64点阵黑体字模，512 byte */ };
char fang64H[]={
/* 以下是'方' 的64点阵黑体字模，512 byte */ };
char kuai64H[]={
/* 以下是'块' 的64点阵黑体字模，512 byte */ };
void youximing(void)
{
int x=80,y=200,color=1,space=100;
drawmat(e64H,64,x,y,color);
drawmat(luo64H,64,x+=space,y,color);
drawmat(si64H,64,x+=space,y,color);
drawmat(fang64H,64,x+=space,y,color);
drawmat(kuai64H,64,x+=space,y,color);
}
void show_word(void)
/*调用点阵函数，在指定位置上输出汉字*/
{
int x=0,y=0,color=15,space=50;
drawmat(zu48H,48,x,y,color);
drawmat(zhang_48H,48,x+=space,y,color);
drawmat(dian48H,48,x+=space,y,color);
drawmat(zhang48K,48,x+=space/2,y,color);
drawmat(fang48K,48,x+=space,y,color);
drawmat(yuan48K,48,x+=space,y,color);
x=0;y=70;
drawmat(zu48H,48,x,y,color);
drawmat(yuan_48H,48,x+=space,y,color);
drawmat(dian48H,48,x+=space,y,color);
drawmat(jie48K,48,x+=space/2,y,color);
drawmat(ying48K,48,x+=space,y,color);
drawmat(ying48K,48,x+=space,y,color);
x=0;y=140;
drawmat(zhao48K,48,x,y,color);
drawmat(jing48K,48,x+=space-10,y,color);
drawmat(tao48K,48,x+=space,y,color);
drawmat(yuan_48K,48,x+=space-10,y,color);
drawmat(huo48K,48,x+=space,y,color);
drawmat(shuai48K,48,x+=space-10,y,color);
}
void prep_word(void)/*开辟内存空间*/
{
unsigned size;
cleardevice();
show_word();
size=imagesize(0,0,270,260);/*计算局部图像大小，单位字节*/
while(1)
{
buf=malloc(size); /*在内存中开辟空间，并将返回空间地址*/
if(size!=-1&&buf) /*如果开辟成功则退出循环，确保空间的开辟成功*/ break;
}
getimage(0,0,270,260,buf);/*将图像存入buf所指向的内存空间*/
}
void move_word(void)
{
int i;
cleardevice();/*在图形模式下清屏*/
sleep(1); /*程序等待1秒*/
for(i=0;i<100;i++)
{
setcolor(random(15)+1);
line(i,0,i,479);
line(639-i,0,639-i,479);
delay(1000);
}
sleep(1);
for(i=480;i>=160;i--)
{
delay(10);
putimage(180,i,buf,COPY_PUT);
/*将buf所指向的空间内容显示在屏幕的指定位置上*/
}
setcolor(15);
settextstyle(0,0,1);
outtextxy(230,360,"Any key to continue...");
getch();}
/*主程序开始*/
void main(void)
{
int i,j,color=7;
char *nm;
init();
cls();
hzss();/*盒状收缩代码*/
/*屏幕坐标初始化*/
for(i=0;i<=MAXCOL+1;i++)
for(j=0;j<=MAXROW+1;j++)
gril[i][j]=0;
for(i=0;i<=MAXCOL+1;i++)
{
gril[i][0]=1;
gril[i][15]=1;
}
for(j=1;j<=MAXROW;j++)
{
gril[0][j]=1;
gril[21][j]=1;
}
clscr(0,0,640,480,15);
win(1,1,639,479,BGCOLOR,"",1,15);
youximing();
getch();
win(1,1,639,479,BGCOLOR,"",1,15);
setcolor(color);
for(i=0;i<=21;i++)
{
for(j=0;j<=15;j++)
{
if(gril[i][j]==1)
box(j*MINBOXSIZE+SCCOL,i*MINBOXSIZE+SCROW,color);
} }
nextboxgs=random(8);
nextboxfx=random(4);
nm=numgochar(num);
txt(456,173,"Number:",1,15);
txt(456,193,nm,1,15);
txt(456,243,"Next Box:",1,15);
timezd();
KillTimer();
byc();/*百叶窗*/
prep_word();
move_word();
closegraph();
}
四、结果分析：
1.此游戏游戏界面清晰，操作简单、易学、有趣。

2.此游戏是本人参照学习“二维俄罗斯方块参考文件”和“三维俄罗斯方块
算法”总结而来的，较二维数组算法和三维数组算法相比，二维数组算法繁琐、但适合初学者，三维算法清晰易懂，因此本人采用三维数组算法。

3.在有些机器上运行不了，或运行一半就死机，可能是机器的DOS版本低，
从新安装一个高版本的，问题就能解决。

4.如用C语言编程软件运行代码，请用WIN---TC1.9.1版本；否则程序运
行会出错。

五、总结
在毕业设计的这段时间里，这是我第一次系统地，完整的接触软件设计的全过程。

我的选择在c语言中“俄罗斯方块游戏”的设计。

我主要解决（1）游戏界面的设计（2）俄罗斯方块的造型（3）游戏级别的自由选择（4）游戏速度的自由选择（5）游戏的背景音乐。

在这次课程设计中，我的能力得到了锻炼，自己也有许多体会。

这次的课程设计是自己第一次全面接触软件的制作过程。

以前仅仅是对软件的开发有一个大体的印象，通过这次的课程设计，我对软件的开发有了切身的体会。

软件并不像我原来所想的那样十分神秘，而是有着一个相对固定的模式和流程。

我们只要按照这个模式和流程，就能够比较规范的完成一个软件的制作。

软件的制作是一个系统的工程，需要我们掌握多方面的知识。

在这次课程设计中，我觉得自己的知识面还是有欠缺的。

需要在以后的学习中加以注意，要全面的提高自己的知识面与知识层次。

我在这次课程设计中主要负责（1）游戏界面的设计（2）俄罗斯方块的造型（3）游戏级别的自由选择（4）游戏速度的自由选择（5）游戏的背景音乐。

在这次课程设计之前，我对VB的编程不是特别的熟悉，这次的课程设计，我是一边学习，一边总结，一边进步。

在编程的过程中，我体会到其实各种计算机语言是有相通之处的。

在以前的学习中，我只接触过C语言，这次在VB课程设计中，我发现C语言中的许多知识可以应用到VB中，两者具有相通的数据结构。

所以我认为现在对计算机语言的学习，不要贪多，而应耐心的学好一门主要的计算机语言，在这个基础上，去学习其他的语言，这样会使学习效率大大提高。

在编程的过程中，我体会到编程是十分辛苦的。

在课程设计这一段时间里，我每天的生活基本是在不断的调试程序和修改代码中完成的。

有时，这种生活令人感到乏味和疲倦，但是在这种近似枯燥的生活中，我的编程水平有了一定程度的提高，这是课程设计中我最大的收获。

以前学习计算机语言，总是静不下心来，不能认真的看书。

这次课程设计，为了顺利的完成编程工作，我认真的学习了VB语言，并有了一定的心得体会。

所以在以后的学习中，自己全身心的投入，这样学习才会有效率，才会有效果。

这次的课程设计是按小组进行的，我们的小组由两名同学组成。

软件的设计本来就是一个团体的智慧结晶。

这次课程设计也给了我们一次体验团体合作的机会。

在课程设计中，我深深的体会到集体的智慧于力量是个人所无法比拟的。

在课程设计中，我们的小组成员互相帮助，有问题两个人一起讨论解决，大大节省了时间。

互相都提出了很好的建议，使我们的课程设计得以较好的完成。

课程设计已经结束了，但在课程设计的这些体会要应用到今后的日常学习中去。

在新的学期，我觉得自己要在以下几个方面加以注意：
首先，在学习专业课的时候要注意理论联系实际。

注意将课本上的知识应用到日常的操作中，真正做到学以致用。

只有这样，才能做到目的明确，才能有足够的学习动力。

其次，在学习过程中要经常与同学进行交流，讨论所遇到的问题，并一起解决。

在讨论中解决问题，会节约很多时间，并且在交流的过程中，我们也可以学到更多的东西。

课程设计已经结束了，这次课程设计带给自己很多体会，在以后的学习中要不断总结，不断改进，使自己的成绩有新的提高。

六、参考文献：
1、《C语言程序设计》-- 张磊
出版社：高等教育出版社书号：ISBN-7-04-016437-6 – X
2、《Ｃ语言编程宝典》，作者：王大刚
3、《C语言最新编程技巧200例》作者：鲁沐浴，电子工业出版社，1997，1
4、《C语言程序设计实用技巧与程序实例》作者：梁翎，李爱齐，上海科普出版社，1996，5
5、《Turbo C程序设计技巧与应用实例》作者：陈国章，天津科学技术出版社，1995，5
6、《C高级实用程序设计》作者：王士元，清华大学出版社，1996，6
7、《C：The Complete Reference》Author：Herbert Schildt
8、《Programming in C - A Tutorial》Author：Brian W. Kernighan ，Bell Laboratories,Murray Hill, N. J。