5个方块的俄罗斯方块源码_俄罗斯方块七种方块_Exploit_中国信息安全门户网站（老牌黑客网站）

文章目录：

1、俄罗斯方块的源代码
2、急需一份俄罗斯方块源代码，Java写的
3、用c语言编写俄罗斯方块程序求详解
4、求俄罗斯方块源代码
5、俄罗斯方块源代码,纯C语言编写,不用图像函数,VC下运行急求！！qq:1
6、求C语言俄罗斯方块代码

俄罗斯方块的源代码

俄罗斯方块C源代码

#include stdio.h

#include windows.h

#include conio.h

#include time.h

#define ZL 4 //坐标增量, 不使游戏窗口靠边

#define WID 36 //游戏窗口的宽度

#define HEI 20 //游戏窗口的高度

int i,j,Ta,Tb,Tc; // Ta,Tb,Tc用于记住和转换方块变量的值

int a[60][60]={0}; //标记游戏屏幕各坐标点：0,1,2分别为空、方块、边框

int b[4]; //标记4个"口"方块：1有，0无，类似开关

int x,y, level,score,speed; //方块中心位置的x,y坐标，游戏等级、得分和游戏速度

int flag,next; //当前要操作的方块类型序号，下一个方块类型序号

void gtxy(int m, int n); //以下声明要用到的自编函数

void gflag( ); //获得下一方块序号

void csh( ); //初始化界面

void start( ); //开始部分

void prfk ( ); //打印方块

void clfk( ); //清除方块

void mkfk( ); //制作方块

void keyD( ); //按键操作

int ifmov( ); //判断方块能否移动或变体

void clHA( ); //清除满行的方块

void clNEXT( ); //清除边框外的NEXT方块

int main( )

{ csh( );

while(1)

{start( ); //开始部分

while(1)

{ prfk( );

Sleep(speed); //延时

clfk( );

Tb=x;Tc=flag; //临存当前x坐标和序号，以备撤销操作

keyD( );

y++; //方块向下移动

if (ifmov( )==0) { y--; prfk( ); dlHA( ); break;} //不可动放下,删行,跨出循环

}

for(i=y-2;iy+2;i++){ if (i==ZL) { j=0; } } //方块触到框顶

if (j==0) { system("cls");gtxy(10,10);printf("游戏结束！"); getch(); break; }

clNEXT( ); //清除框外的NEXT方块

}

return 0;

}

void gtxy(int m, int n) //控制光标移动

{COORD pos; //定义变量

pos.X = m; //横坐标

pos.Y = n; //纵坐标

SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);

}

void csh( ) //初始化界面

{gtxy(ZL+WID/2-5,ZL-2); printf("俄罗斯方块"); //打印游戏名称

gtxy(ZL+WID+3,ZL+7); printf("******* NEXT："); //打印菜单信息

gtxy(ZL+WID+3,ZL+13); printf("**********");

gtxy(ZL+WID+3,ZL+15); printf("Esc ：退出游戏");

gtxy(ZL+WID+3,ZL+17); printf("↑键：变体");

gtxy(ZL+WID+3,ZL+19); printf("空格：暂停游戏");

gtxy(ZL,ZL); printf("╔"); gtxy(ZL+WID-2,ZL); printf("╗"); //打印框角

gtxy(ZL,ZL+HEI); printf("╚"); gtxy(ZL+WID-2,ZL+HEI); printf("╝");

a[ZL][ZL+HEI]=2; a[ZL+WID-2][ZL+HEI]=2; //记住有图案

for(i=2;iWID-2;i+=2) {gtxy(ZL+i,ZL); printf("═"); } //打印上横框

for(i=2;iWID-2;i+=2) {gtxy(ZL+i,ZL+HEI); printf("═"); a[ZL+i][ZL+HEI]=2; } //下框

for(i=1;iHEI;i++) { gtxy(ZL,ZL+i); printf("║"); a[ZL][ZL+i]=2; } //左竖框记住有图案

for(i=1;iHEI;i++) {gtxy(ZL+WID-2,ZL+i); printf("║"); a[ZL+WID-2][ZL+i]=2; } //右框

CONSOLE_CURSOR_INFO cursor_info={1,0}; //以下是隐藏光标的设置

SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),cursor_info);

level=1; score=0; speed=400;

gflag( ); flag=next; //获得一个当前方块序号

}

void gflag( ) //获得下一个方块的序号

{ srand((unsigned)time(NULL)); next = rand()%19+1; }

void start( ) //开始部分

{ gflag( ); Ta=flag; flag=next; //保存当前方块序号，将下一方块序号临时操作

x=ZL+WID+6; y=ZL+10; prfk( ); //给x,y赋值，在框外打印出下一方块

flag=Ta; x=ZL+WID/2; y=ZL-1; //取回当前方块序号，并给x,y赋值

}

void prfk ( ) //打印俄罗斯方块

{ for(i=0;i4;i++) {b[i]=1; } //数组b[4]每个元素的值都为1

mkfk ( ); //制作俄罗斯方块

for( i= x-2; i=x+4; i+=2 ) //打印方块

{ for(j=y-2;j= y+1;j++) { if( a[i][j]==1 jZL ){ gtxy(i,j); printf("□"); } } }

gtxy(ZL+WID+3,ZL+1); printf("level : %d",level); //以下打印菜单信息

gtxy(ZL+WID+3,ZL+3); printf("score : %d",score);

gtxy(ZL+WID+3,ZL+5); printf("speed : %d",speed);

}

void clfk( ) //清除俄罗斯方块

{ for(i=0;i4;i++) { b[i]=0; } //数组b[4]每个元素的值都为0

mkfk ( ); //制作俄罗斯方块

for( i=x-2; i=x+4; i+=2 ) //清除方块

{ for(j=y-2;j=y+1;j++){ if( a[i][j]==0 jZL ){ gtxy(i,j); printf(" "); } } }

}

void mkfk( ) //制作俄罗斯方块

{ a[x][ y]=b[0]; //方块中心位置状态: 1-有,0-无

switch(flag) //共6大类，19种小类型

{ case 1: { a[x][y-1]=b[1]; a[x+2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //田字方块

case 2: { a[x-2][y]=b[1]; a[x+2][y]=b[2]; a[x+4][y]=b[3]; break; } //直线方块:----

case 3: { a[x][y-1]=b[1]; a[x][y-2]=b[2]; a[x][y+1]=b[3]; break; } //直线方块: |

case 4: { a[x-2][y]=b[1]; a[x+2][y]=b[2]; a[x][y+1]=b[3]; break; } //T字方块

case 5: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x-2][y]=b[3]; break; } //T字顺时针转90度

case 6: { a[x][y-1]=b[1]; a[x-2][y]=b[2]; a[x+2][y]=b[3]; break; } //T字顺转180度

case 7: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x+2][y]=b[3]; break; } //T字顺转270度

case 8: { a[x][y+1]=b[1]; a[x-2][y]=b[2]; a[x+2][y+1]=b[3]; break; } //Z字方块

case 9: { a[x][y-1]=b[1]; a[x-2][y]=b[2]; a[x-2][y+1]=b[3]; break; } //Z字顺转90度

case 10: { a[x][y-1]=b[1]; a[x-2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //Z字顺转180度

case 11: { a[x][y+1]=b[1]; a[x+2][y-1]=b[2]; a[x+2][ y]=b[3]; break; } //Z字顺转270度

case 12: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x-2][y-1]=b[3]; break; } //7字方块

case 13: {a[x-2][y]=b[1]; a[x+2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //7字顺转90度

case 14: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x+2][y+1]=b[3]; break; } //7字顺转180度

case 15: { a[x-2][y]=b[1]; a[x-2][y+1]=b[2]; a[x+2][y]=b[3]; break; } //7字顺转270度

case 16: { a[x][y+1]=b[1]; a[x][y-1]=b[2]; a[x+2][y-1]=b[3]; break; } //倒7字方块

case 17: { a[x-2][y]=b[1]; a[x+2][y+1]=b[2]; a[x+2][y]=b[3]; break; } //倒7字顺转90度

case 18: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x-2][y+1]=b[3]; break; } //倒7字顺转180度

case 19: { a[x-2][y]=b[1]; a[x-2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //倒7字顺转270度

}

void keyD( ) //按键操作

{ if (kbhit( ))

{ int key;

key=getch();

if (key==224)

{ key=getch();

if (key==75) { x-=2; } //按下左方向键，中心横坐标减2

if (key==77) { x+=2; } //按下右方向键，中心横坐标加2

if (key==72) //按下向上方向键,方块变体

{ if (flag=2 flag=3 ) { flag++; flag%=2; flag+=2; }

if ( flag=4 flag=7 ) { flag++; flag%=4; flag+=4; }

if (flag=8 flag=11 ) { flag++; flag%=4; flag+=8; }

if (flag=12 flag=15 ) { flag++; flag%=4; flag+=12; }

if ( flag=16 flag=19 ) { flag++; flag%=4; flag+=16; } }

}

if (key==32) //按空格键，暂停

{ prfk( ); while(1) { if (getch( )==32) { clfk( );break;} } } //再按空格键，继续游戏

if (ifmov( )==0) { x=Tb; flag=Tc; } //如果不可动，撤销上面操作

else { prfk( ); Sleep(speed); clfk( ); Tb=x;Tc=flag;} //如果可动，执行操作

}

int ifmov( ) //判断能否移动

{ if (a[x][y]!=0) { return 0; } //方块中心处有图案返回0，不可移动

else{ if ( (flag==1 ( a[x][ y-1]==0 a[x+2][y-1]==0 a[x+2][y]==0 ) ) ||

(flag==2 ( a[x-2][y]==0 a[x+2][y]==0 a[x+4][y]==0 ) ) ||

(flag==3 ( a[x][y-1]==0 a[x][y-2]==0 a[x][y+1]==0 ) ) ||

(flag==4 ( a[x-2][y]==0 a[x+2][y]==0 a[x][y+1]==0 ) ) ||

(flag==5 ( a[x][y-1]==0 a[x][y+1]==0 a[x-2][y]==0 ) ) ||

(flag==6 ( a[x][ y-1]==0 a[x-2][y]==0 a[x+2][y]==0 ) ) ||

(flag==7 ( a[x][y-1]==0 a[x][y+1]==0 a[x+2][y]==0 ) ) ||

(flag==8 ( a[x][y+1]==0 a[x-2][y]==0 a[x+2][y+1]==0 ) ) ||

(flag==9 ( a[x][y-1]==0 a[x-2][y]==0 a[x-2][y+1]==0 ) ) ||

(flag==10 ( a[x][y-1]==0 a[x-2][y-1]==0 a[x+2][y]==0 ) ) ||

(flag==11 ( a[x][y+1]==0 a[x+2][y-1]==0 a[x+2][y]==0 ) ) ||

(flag==12 ( a[x][y-1]==0 a[x][y+1]==0 a[x-2][y-1]==0 ) ) ||

( flag==13 ( a[x-2][y]==0 a[x+2][y-1]==0 a[x+2][y]==0 ) ) ||

( flag==14 ( a[x][y-1]==0 a[x][y+1]==0 a[x+2][y+1]==0 ) ) ||

(flag==15 ( a[x-2][y]==0 a[x-2][y+1]==0 a[x+2][y]==0 ) ) ||

(flag==16 ( a[x][y+1]==0 a[x][y-1]==0 a[x+2][y-1]==0 ) ) ||

( flag==17 ( a[x-2][y]==0 a[x+2][y+1]==0 a[x+2][y]==0 ) ) ||

(flag==18 ( a[x][y-1]==0 a[x][y+1]==0 a[x-2][y+1]==0 ) ) ||

(flag==19 ( a[x-2][y]==0 a[x-2][y-1]==0

a[x+2][y]==0 ) ) ) { return 1; }

}

return 0; //其它情况返回0

}

void clNEXT( ) //清除框外的NEXT方块

{ flag = next; x=ZL+WID+6; y=ZL+10; clfk( ); }

void clHA( ) //清除满行的方块

{ int k, Hang=0; //k是某行方块个数, Hang是删除的方块行数

for(j=ZL+HEI-1;j=ZL+1;j--) //当某行有WID/2-2个方块时，则为满行

{ k=0; for(i=ZL+2;iZL+WID-2;i+=2)

{ if (a[i][j]==1) //竖坐标从下往上，横坐标由左至右依次判断是否满行

{ k++; //下面将操作删除行

if (k==WID/2-2) { for(k=ZL+2;kZL+WID-2;k+=2)

{ a[k][j]=0; gtxy(k,j); printf(" "); Sleep(1); }

for(k=j-1;kZL;k--)

{ for(i=ZL+2;iZL+WID-2;i+=2) //已删行数上面有方块，先清除再全部下移一行

{ if(a[i][k]==1) { a[i][k]=0; gtxy(i,k); printf(" ");a[i][k+1]=1;

gtxy(i,k+1); printf("□"); } }

}

j++; //方块下移后，重新判断删除行是否满行

Hang++; //记录删除方块的行数

}

score+=100*Hang; //每删除一行，得100分

if ( Hang0 (score%500==0 || score/500 level-1 ) ) //得分满500速度加快升一级

{ speed-=20; level++; if(speed200)speed+=20; }

}

5个方块的俄罗斯方块源码_俄罗斯方块七种方块

急需一份俄罗斯方块源代码，Java写的

使用Java实现小游戏：俄罗斯方块

使用一个二维数组保存游戏的地图：

// 游戏地图格子，每个格子保存一个方块，数组纪录方块的状态

private State map[][] = new State[rows][columns];123

游戏前先将所有地图中的格子初始化为空：

/* 初始化所有的方块为空 */

for (int i = 0; i map.length; i++) {

for (int j = 0; j map[i].length; j++) {

map[i][j] = State.EMPTY;

}

}1234567

玩游戏过程中，我们能够看到界面上的方块，那么就得将地图中所有的方块绘制出来，当然，除了需要绘制方块外，游戏积分和游戏结束的字符串在必要的时候也需要绘制：

/**

* 绘制窗体内容，包括游戏方块，游戏积分或结束字符串

@Override

public void paint(Graphics g) {

super.paint(g);

for (int i = 0; i rows; i++) {

for (int j = 0; j columns; j++) {

if (map[i][j] == State.ACTIVE) { // 绘制活动块

g.setColor(activeColor);

g.fillRoundRect(j * BLOCK_SIZE, i * BLOCK_SIZE + 25,

BLOCK_SIZE - 1, BLOCK_SIZE - 1, BLOCK_SIZE / 5,

BLOCK_SIZE / 5);

} else if (map[i][j] == State.STOPED) { // 绘制静止块

g.setColor(stopedColor);

g.fillRoundRect(j * BLOCK_SIZE, i * BLOCK_SIZE + 25,

BLOCK_SIZE - 1, BLOCK_SIZE - 1, BLOCK_SIZE / 5,

BLOCK_SIZE / 5);

}

/* 打印得分 */

g.setColor(scoreColor);

g.setFont(new Font("Times New Roman", Font.BOLD, 30));

g.drawString("SCORE : " + totalScore, 5, 70);

// 游戏结束，打印结束字符串

if (!isGoingOn) {

g.setColor(Color.RED);

g.setFont(new Font("Times New Roman", Font.BOLD, 40));

g.drawString("GAME OVER !", this.getWidth() / 2 - 140,

this.getHeight() / 2);

}

}123456789101112131415161718192021222324252627282930313233343536

通过随机数的方式产生方块所组成的几种图形，一般七种图形：条形、田形、正7形、反7形、T形、Z形和反Z形，如生成条形：

map[0][randPos] = map[0][randPos - 1] = map[0][randPos + 1]

= map[0][randPos + 2] = State.ACTIVE;123

生成图形后，实现下落的操作。如果遇到阻碍，则不能再继续下落：

isFall = true; // 是否能够下落

// 从当前行检查，如果遇到阻碍，则停止下落

for (int i = 0; i blockRows; i++) {

for (int j = 0; j columns; j++) {

// 遍历到行中块为活动块，而下一行块为静止块，则遇到阻碍

if (map[rowIndex - i][j] == State.ACTIVE

map[rowIndex - i + 1][j] == State.STOPED) {

isFall = false; // 停止下落

break;

}

if (!isFall)

break;

}123456789101112131415

如果未遇到阻碍，则下落的时候，方块图形整体向下移动一行：

// 图形下落一行

for (int i = 0; i blockRows; i++) {

for (int j = 0; j columns; j++) {

if (map[rowIndex - i][j] == State.ACTIVE) { // 活动块向下移动一行

map[rowIndex - i][j] = State.EMPTY; // 原活动块变成空块

map[rowIndex - i + 1][j] = State.ACTIVE; // 下一行块变成活动块

}

}12345678910

向左、向右方向移动时是类似的操作：

/**

* 向左走

private void left() {

// 标记左边是否有阻碍

boolean hasBlock = false;

/* 判断是否左边有阻碍 */

for (int i = 0; i blockRows; i++) {

if (map[rowIndex - i][0] == State.ACTIVE) { // 判断左边是否为墙

hasBlock = true;

break; // 有阻碍，不用再循环判断行

} else {

for (int j = 1; j columns; j++) { // 判断左边是否有其它块

if (map[rowIndex - i][j] == State.ACTIVE

map[rowIndex - i][j - 1] == State.STOPED) {

hasBlock = true;

break; // 有阻碍，不用再循环判断列

}

if (hasBlock)

break; // 有阻碍，不用再循环判断行

}

/* 左边没有阻碍，则将图形向左移动一个块的距离 */

if (!hasBlock) {

for (int i = 0; i blockRows; i++) {

for (int j = 1; j columns; j++) {

if (map[rowIndex - i][j] == State.ACTIVE) {

map[rowIndex - i][j] = State.EMPTY;

map[rowIndex - i][j - 1] = State.ACTIVE;

}

// 重绘

repaint();

}

}1234567891011121314151617181920212223242526272829303132333435363738394041

向下加速移动时，就是减小每次正常状态下落的时间间隔：

/**

* 向下直走

private void down() {

// 标记可以加速下落

immediate = true;

}12345678

如何变换图形方向，这里仅使用了非常简单的方法来实现方向变换，当然可以有更优的算法实现方向变换操作，大家可以自己研究：

/**

* 旋转方块图形

private void rotate() {

try {

if (shape == 4) { // 方形，旋转前后是同一个形状

return;

} else if (shape == 0) { // 条状

// 临时数组，放置旋转后图形

State[][] tmp = new State[4][4];

int startColumn = 0;

// 找到图形开始的第一个方块位置

for (int i = 0; i columns; i++) {

if (map[rowIndex][i] == State.ACTIVE) {

startColumn = i;

break;

}

// 查找旋转之后是否有阻碍，如果有阻碍，则不旋转

for (int i = 0; i 4; i++) {

for (int j = 0; j 4; j++) {

if (map[rowIndex - 3 + i][j + startColumn] == State.STOPED) {

return;

}

if (map[rowIndex][startColumn + 1] == State.ACTIVE) { // 横向条形，变换为竖立条形

for (int i = 0; i 4; i++) {

tmp[i][0] = State.ACTIVE;

for (int j = 1; j 4; j++) {

tmp[i][j] = State.EMPTY;

}

blockRows = 4;

} else { // 竖立条形，变换为横向条形

for (int j = 0; j 4; j++) {

tmp[3][j] = State.ACTIVE;

for (int i = 0; i 3; i++) {

tmp[i][j] = State.EMPTY;

}

blockRows = 1;

}

// 将原地图中图形修改为变换后图形

for (int i = 0; i 4; i++) {

for (int j = 0; j 4; j++) {

map[rowIndex - 3 + i][startColumn + j] = tmp[i][j];

}

} else {

// 临时数组，放置旋转后图形

State[][] tmp = new State[3][3];

int startColumn = columns;

// 找到图形开始的第一个方块位置

for (int j = 0; j 3; j++) {

for (int i = 0; i columns; i++) {

if (map[rowIndex - j][i] == State.ACTIVE) {

startColumn = i startColumn ? i : startColumn;

}

// 判断变换后是否会遇到阻碍

for (int i = 0; i 3; i++) {

for (int j = 0; j 3; j++) {

if (map[rowIndex - 2 + j][startColumn + 2 - i] == State.STOPED)

return;

}

// 变换

for (int i = 0; i 3; i++) {

for (int j = 0; j 3; j++) {

tmp[2 - j][i] = map[rowIndex - 2 + i][startColumn + j];

}

// 将原地图中图形修改为变换后图形

for (int i = 0; i 3; i++) {

for (int j = 0; j 3; j++) {

map[rowIndex - 2 + i][startColumn + j] = tmp[i][j];

}

// 重绘

repaint();

// 重新修改行指针

for (int i = 0; i 3; i++) {

for (int j = 0; j 3; j++) {

if (map[rowIndex - i][startColumn + j] != null

|| map[rowIndex - i][startColumn + j] != State.EMPTY) {

rowIndex = rowIndex - i;

blockRows = 3;

return;

}

} catch (Exception e) {

// 遇到数组下标越界，说明不能变换图形形状，不作任何处理

}

}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101

当图形下落遇到阻碍时停止，我们就需要判断这时是否有某一行或几行可以消除掉，这时可以先获取每行中方块的个数，然后再进行判断：

int[] blocksCount = new int[rows]; // 记录每行有方块的列数

int eliminateRows = 0; // 消除的行数

/* 计算每行方块数量 */

for (int i = 0; i rows; i++) {

blocksCount[i] = 0;

for (int j = 0; j columns; j++) {

if (map[i][j] == State.STOPED)

blocksCount[i]++;

}

}1234567891011

如果有满行的方块，则消除掉该行方块：

/* 实现有满行的方块消除操作 */

for (int i = 0; i rows; i++) {

if (blocksCount[i] == columns) {

// 清除一行

for (int m = i; m = 0; m--) {

for (int n = 0; n columns; n++) {

map[m][n] = (m == 0) ? State.EMPTY : map[m - 1][n];

}

eliminateRows++; // 记录消除行数

}

}12345678910111213

最后我们再重绘显示积分就可以了。

重复以上的生成图形、图形下落、左右下移动、判断消除行的操作，一个简单的俄罗斯方块就完成了。

用c语言编写俄罗斯方块程序求详解

1、用C语言绘制图形界面

EasyX图形库()即TC的图形库在VC下的移植。

包含库#include graphics.h

先初始化图形窗口

initgraph(WINDOW_WIDTH, WINDOW_HIGH) ;WINDOW_WIDTH为窗口的宽带，WINDOW_HIGH为窗口的高度。

清空绘图设备

cleardevice();

设置画笔颜色

setcolor(RED) ;

设置线条风格

setlinestyle(PS_SOLID, NULL, 0);

画矩形

rectangle

还有画线、显示文字等函数，可以参照其帮助文档。

注意：由于我们用的是EasyX图形库，故源文件后缀要为.cpp，但其中内容都是C的语法。

2、存储表示出俄罗斯方块的形状

一、我们可以用编号，不同的编号代表不同的俄罗斯方块，根据编号把不同方块的画法写在代码中，这样19种

方块就得有19种相应的代码来描绘。而且这样扩展性不好，若以后设计了新的方块，则需要更改大量源代码。

二、我们很自然的想到可用字模点阵的形式来表示，即设置一个4行4列的数组，元素置1即代表这个位置有小

方块，元素置0即代表这个位置无小方块，这个整个的4*4的数组组成俄罗斯方块的形状。

1000

1100

0000

这个方法挺靠谱，但我们还可以优化一下：不用4*4的数组，而是用16个bit位来表示这个点阵。这样存储起来比较方便，故我们用unsigned int 的低16位来表示方块的点阵。

我们可以用掩码与表示俄罗斯方块的位进行操作，来识别并在屏幕上画出方块。

我们把俄罗斯方块点阵的数位存在rockArray中，我们可以事先把这19种方块的字模点阵自己转化成十六进制，然后在rockArray数组的初始化时赋值进去。

但这样做未免有点太费力，且扩展性也不太好，若以后设计的新方块种类加入，要改变数组rockArray中的值。

我们可以考虑把所有俄罗斯方块的点阵存储在配置文件中，在程序初始化时读取文件，把这些点阵转换成unsigned int的变量存储在rockArray中。

这样，以后我们增添新的方块形状只需要在配置文件中增加新的点阵即可。

@###

@@##

#### （为使得看起来更醒目，我们用@表示1，用#表示0）

3、让图形动起来

在某位置处用函数DrawRock在屏幕上画出俄罗斯方块，然后再擦除掉(即用背景色在原位置处重绘一次方块)，最后在下落的下一个位置处用函数DrawRock在屏幕上画出俄罗斯方块，如此循环，中间用计时器间隔一段时间以控制下落的速度。

同理，按下屏幕的左右键也是如此，只是在按下键盘时把方块的位置重新计算了。

那么按下上方向键时，如何让方块翻转呢？

我们在配置文件中就把方块的顺时针翻转形态放在了一起：

@###

@@##

####

@@@#

@###

####

@@##

#@##

####

##@#

@@@#

####

我们每按一次上方向键改变一次方块的形状即可。若一直按上键，形状应该是循环地翻滚。

我们想到了循环链表的数据结构可实现这个效果。

可是我们若把这些一种类的方块的各种形态串成循环链表形式，那么每次重新生成方块时我们就难以随机地生成方块了。

故还是得用数组来存储，但又要有循环链表的功能，于是我们想到了静态循环链表。

我们用结构体来作为一个方块在rockArray中的元素

typedef struct ROCK

{ //用来表示方块的形状(每一个字节是8位，用每4位表示方块中的一行)

unsigned int rockShapeBits ;

int nextRockIndex ; //下一个方块，在数组中的下标

} RockType ;

这样，当我们按下上方向键时，把传入函数DrawRock中的rockIndex变为当前方块结构体中的nextRockIndex即可。

参考资料：C语言图形界面篇

求俄罗斯方块源代码

手机游戏---俄罗斯方块

俄罗斯方块——java源代码提供

import java.awt.*;

import java.awt.event.*;

//俄罗斯方块类

public class ERS_Block extends Frame{

public static boolean isPlay=false;

public static int level=1,score=0;

public static TextField scoreField,levelField;

public static MyTimer timer;

GameCanvas gameScr;

public static void main(String[] argus){

ERS_Block ers = new ERS_Block("俄罗斯方块游戏 V1.0 Author:Vincent");

WindowListener win_listener = new WinListener();

ers.addWindowListener(win_listener);

}

//俄罗斯方块类的构造方法

ERS_Block(String title){

super(title);

setSize(600,480);

setLayout(new GridLayout(1,2));

gameScr = new GameCanvas();

gameScr.addKeyListener(gameScr);

timer = new MyTimer(gameScr);

timer.setDaemon(true);

timer.start();

timer.suspend();

add(gameScr);

Panel rightScr = new Panel();

rightScr.setLayout(new GridLayout(2,1,0,30));

rightScr.setSize(120,500);

add(rightScr);

//右边信息窗体的布局

MyPanel infoScr = new MyPanel();

infoScr.setLayout(new GridLayout(4,1,0,5));

infoScr.setSize(120,300);

rightScr.add(infoScr);

//定义标签和初始值

Label scorep = new Label("分数:",Label.LEFT);

Label levelp = new Label("级数:",Label.LEFT);

scoreField = new TextField(8);

levelField = new TextField(8);

scoreField.setEditable(false);

levelField.setEditable(false);

infoScr.add(scorep);

infoScr.add(scoreField);

infoScr.add(levelp);

infoScr.add(levelField);

scorep.setSize(new Dimension(20,60));

scoreField.setSize(new Dimension(20,60));

levelp.setSize(new Dimension(20,60));

levelField.setSize(new Dimension(20,60));

scoreField.setText("0");

levelField.setText("1");

//右边控制按钮窗体的布局

MyPanel controlScr = new MyPanel();

controlScr.setLayout(new GridLayout(5,1,0,5));

rightScr.add(controlScr);

//定义按钮play

Button play_b = new Button("开始游戏");

play_b.setSize(new Dimension(50,200));

play_b.addActionListener(new Command(Command.button_play,gameScr));

//定义按钮Level UP

Button level_up_b = new Button("提高级数");

level_up_b.setSize(new Dimension(50,200));

level_up_b.addActionListener(new Command(Command.button_levelup,gameScr));

//定义按钮Level Down

Button level_down_b =new Button("降低级数");

level_down_b.setSize(new Dimension(50,200));

level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));

//定义按钮Level Pause

Button pause_b =new Button("游戏暂停");

pause_b.setSize(new Dimension(50,200));

pause_b.addActionListener(new Command(Command.button_pause,gameScr));

//定义按钮Quit

Button quit_b = new Button("退出游戏");

quit_b.setSize(new Dimension(50,200));

quit_b.addActionListener(new Command(Command.button_quit,gameScr));

controlScr.add(play_b);

controlScr.add(level_up_b);

controlScr.add(level_down_b);

controlScr.add(pause_b);

controlScr.add(quit_b);

setVisible(true);

gameScr.requestFocus();

}

//重写MyPanel类，使Panel的四周留空间

class MyPanel extends Panel{

public Insets getInsets(){

return new Insets(30,50,30,50);

}

//游戏画布类

class GameCanvas extends Canvas implements KeyListener{

final int unitSize = 30; //小方块边长

int rowNum; //正方格的行数

int columnNum; //正方格的列数

int maxAllowRowNum; //允许有多少行未削

int blockInitRow; //新出现块的起始行坐标

int blockInitCol; //新出现块的起始列坐标

int [][] scrArr; //屏幕数组

Block b; //对方快的引用

//画布类的构造方法

GameCanvas(){

rowNum = 15;

columnNum = 10;

maxAllowRowNum = rowNum - 2;

b = new Block(this);

blockInitRow = rowNum - 1;

blockInitCol = columnNum/2 - 2;

scrArr = new int [32][32];

}

//初始化屏幕，并将屏幕数组清零的方法

void initScr(){

for(int i=0;irowNum;i++)

for (int j=0; jcolumnNum;j++)

scrArr[j]=0;

b.reset();

repaint();

}

//重新刷新画布方法

public void paint(Graphics g){

for(int i = 0; i rowNum; i++)

for(int j = 0; j columnNum; j++)

drawUnit(i,j,scrArr[j]);

}

//画方块的方法

public void drawUnit(int row,int col,int type){

scrArr[row][col] = type;

Graphics g = getGraphics();

tch(type){ //表示画方快的方法

case 0: g.setColor(Color.black);break; //以背景为颜色画

case 1: g.setColor(Color.blue);break; //画正在下落的方块

case 2: g.setColor(Color.magenta);break; //画已经落下的方法

}

g.fill3DRect(col*unitSize,getSize().height-(row+1)*unitSize,unitSize,unitSize,true);

g.dispose();

}

public Block getBlock(){

return b; //返回block实例的引用

}

//返回屏幕数组中(row,col)位置的属性值

public int getScrArrXY(int row,int col){

if (row 0 || row = rowNum || col 0 || col = columnNum)

return(-1);

else

return(scrArr[row][col]);

}

//返回新块的初始行坐标方法

public int getInitRow(){

return(blockInitRow); //返回新块的初始行坐标

}

//返回新块的初始列坐标方法

public int getInitCol(){

return(blockInitCol); //返回新块的初始列坐标

}

//满行删除方法

void deleteFullLine(){

int full_line_num = 0;

int k = 0;

for (int i=0;irowNum;i++){

boolean isfull = true;

L1:for(int j=0;jcolumnNum;j++)

if(scrArr[j] == 0){

k++;

isfull = false;

break L1;

}

if(isfull) full_line_num++;

if(k!=0 k-1!=i !isfull)

for(int j = 0; j columnNum; j++){

if (scrArr[j] == 0)

drawUnit(k-1,j,0);

else

drawUnit(k-1,j,2);

scrArr[k-1][j] = scrArr[j];

}

for(int i = k-1 ;i rowNum; i++){

for(int j = 0; j columnNum; j++){

drawUnit(i,j,0);

scrArr[j]=0;

}

ERS_Block.score += full_line_num;

ERS_Block.scoreField.setText(""+ERS_Block.score);

}

//判断游戏是否结束方法

boolean isGameEnd(){

for (int col = 0 ; col columnNum; col ++){

if(scrArr[maxAllowRowNum][col] !=0)

return true;

}

return false;

}

public void keyTyped(KeyEvent e){

}

public void keyReleased(KeyEvent e){

}

//处理键盘输入的方法

public void keyPressed(KeyEvent e){

if(!ERS_Block.isPlay)

return;

tch(e.getKeyCode()){

case KeyEvent.VK_DOWN:b.fallDown();break;

case KeyEvent.VK_LEFT:b.leftMove();break;

case KeyEvent.VK_RIGHT:b.rightMove();break;

case KeyEvent.VK_SPACE:b.leftTurn();break;

}

//处理控制类

class Command implements ActionListener{

static final int button_play = 1; //给按钮分配编号

static final int button_levelup = 2;

static final int button_leveldown = 3;

static final int button_quit = 4;

static final int button_pause = 5;

static boolean pause_resume = true;

int curButton; //当前按钮

GameCanvas scr;

//控制按钮类的构造方法

Command(int button,GameCanvas scr){

curButton = button;

this.scr=scr;

}

//按钮执行方法

public void actionPerformed (ActionEvent e){

tch(curButton){

case button_play:if(!ERS_Block.isPlay){

scr.initScr();

ERS_Block.isPlay = true;

ERS_Block.score = 0;

ERS_Block.scoreField.setText("0");

ERS_Block.timer.resume();

}

scr.requestFocus();

break;

case button_levelup:if(ERS_Block.level 10){

ERS_Block.level++;

ERS_Block.levelField.setText(""+ERS_Block.level);

ERS_Block.score = 0;

ERS_Block.scoreField.setText(""+ERS_Block.score);

}

scr.requestFocus();

break;

case button_leveldown:if(ERS_Block.level 1){

ERS_Block.level--;

ERS_Block.levelField.setText(""+ERS_Block.level);

ERS_Block.score = 0;

ERS_Block.scoreField.setText(""+ERS_Block.score);

}

scr.requestFocus();

break;

case button_pause:if(pause_resume){

ERS_Block.timer.suspend();

pause_resume = false;

}else{

ERS_Block.timer.resume();

pause_resume = true;

}

scr.requestFocus();

break;

case button_quit:System.exit(0);

}

//方块类

class Block {

static int[][] pattern = {

,//用十六进至表示，本行表示长条四种状态

};

int blockType; //块的模式号（0-6）

int turnState; //块的翻转状态（0-3）

int blockState; //快的下落状态

int row,col; //块在画布上的坐标

GameCanvas scr;

//块类的构造方法

Block(GameCanvas scr){

this.scr = scr;

blockType = (int)(Math.random() * 1000)%7;

turnState = (int)(Math.random() * 1000)%4;

blockState = 1;

row = scr.getInitRow();

col = scr.getInitCol();

}

//重新初始化块，并显示新块

public void reset(){

blockType = (int)(Math.random() * 1000)%7;

turnState = (int)(Math.random() * 1000)%4;

blockState = 1;

row = scr.getInitRow();

col = scr.getInitCol();

dispBlock(1);

}

//实现“块”翻转的方法

public void leftTurn(){

if(assertValid(blockType,(turnState + 1)%4,row,col)){

dispBlock(0);

turnState = (turnState + 1)%4;

dispBlock(1);

}

//实现“块”的左移的方法

public void leftMove(){

if(assertValid(blockType,turnState,row,col-1)){

dispBlock(0);

col--;

dispBlock(1);

}

//实现块的右移

public void rightMove(){

if(assertValid(blockType,turnState,row,col+1)){

dispBlock(0);

col++;

dispBlock(1);

}

//实现块落下的操作的方法

public boolean fallDown(){

if(blockState == 2)

return(false);

if(assertValid(blockType,turnState,row-1,col)){

dispBlock(0);

row--;

dispBlock(1);

return(true);

}else{

blockState = 2;

dispBlock(2);

return(false);

}

//判断是否正确的方法

boolean assertValid(int t,int s,int row,int col){

int k = 0x8000;

for(int i = 0; i 4; i++){

for(int j = 0; j 4; j++){

if((int)(pattern[t][s]k) != 0){

int temp = scr.getScrArrXY(row-i,col+j);

if (temp0||temp==2)

return false;

}

k = k 1;

}

return true;

}

//同步显示的方法

public synchronized void dispBlock(int s){

int k = 0x8000;

for (int i = 0; i 4; i++){

for(int j = 0; j 4; j++){

if(((int)pattern[blockType][turnState]k) != 0){

scr.drawUnit(row-i,col+j,s);

}

k=k1;

}

//定时线程

class MyTimer extends Thread{

GameCanvas scr;

public MyTimer(GameCanvas scr){

this.scr = scr;

}

public void run(){

while(true){

try{

sleep((10-ERS_Block.level + 1)*100);

}

catch(InterruptedException e){}

if(!scr.getBlock().fallDown()){

scr.deleteFullLine();

if(scr.isGameEnd()){

ERS_Block.isPlay = false;

suspend();

}else

scr.getBlock().reset();

}

class WinListener extends WindowAdapter{

public void windowClosing (WindowEvent l){

System.exit(0);

}

俄罗斯方块源代码,纯C语言编写,不用图像函数,VC下运行急求！！qq:1

N = 20;//行数

WIDTH = 20;//方块边长

level = 0;//开始等级（下落速度）

ret = new Array();//当前出现的方块

nextret = new Array();//下一个出现的方块

bg = new Array();//背景数组

createEmptyMovieClip("panel", 1048575);//所有方块都在此mc里

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

//初始化方块数组，2*5格式，前四行代表每个方块的4个小块的位置坐标，最后一行第一列是方块形状，第二列是方块旋转方向

ret.push(new Array(2));

nextret.push(new Array(2));

}

for (i = 0; i 20; i++) {//初始化背景数组，10*20格式

bg.push(new Array(10));

}

X = Y = panel._x = panel._y = 0;//换为X、Y表示

function reach(x:Number, y:Number, ret:Object) {

//x、y为方块位置，ret为方块形状，若方块ret下落一格碰到边界或者方块返回1

var i:Number, j:Number, k:Number;

for (i = 0; i N; i++) {

for (j = 0; j 10; j++) {

if (bg[i][j] == 219) {

for (k = 0; k 4; k++) {

if (x + ret[k][0] == j y + ret[k][1] + 1 == i) {

return 1;

}

return 0;

}

function lrnotout(lorr:Number, a:Object) {

//lorr==-1代表a往左边一格可行性的判断，lorr==1代表右边一格可行性的判断，lorr==0代表a的位置合理性的判断，出现不合理则返回0

var i:Number;

if (lorr == -1) {

for (i = 0; i 4; i++) {

if (x + a[i][0] - 1 0 || reach(x - 1, y - 1, a)) {

return 0;

}

if (lorr == 1) {

for (i = 0; i 4; i++) {

if (x + a[i][0] + 1 9 || reach(x - 1, y + 1, a)) {

return 0;

}

if (lorr == 0) {

for (i = 0; i 4; i++) {

if (x + a[i][0] 0 || x + a[i][0] 9) {

return 0;

}

return 1;

}

function rv(a:Object, ret:Object) {

//方块赋值，将a方块赋值到ret方块

var i:Number;

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

ret[i][0] = a[i][0], ret[i][1] = a[i][1];

}

function rotate(ret:Object) {

//根据方块ret最后一行（分别是形状指示变量和旋转方向变量）为ret的前四行赋以具体形状值

switch (ret[4][0]) {

case 0 ://方形

a = [[1, 0], [2, 0], [1, 1], [2, 1], [0, 0]];

rv(a, ret);

return;

case 1 ://长形

switch (ret[4][1]) {

case 1 :

a = [[0, 0], [1, 0], [2, 0], [3, 0], [1, 0]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 0 :

a = [[1, 0], [1, 1], [1, 2], [1, 3], [1, 1]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

}

case 2 ://Z形

switch (ret[4][1]) {

case 1 :

a = [[0, 1], [1, 1], [1, 2], [2, 2], [2, 0]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 0 :

a = [[2, 0], [1, 1], [2, 1], [1, 2], [2, 1]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

}

case 3 ://反Z形

switch (ret[4][1]) {

case 1 :

a = [[1, 1], [2, 1], [0, 2], [1, 2], [3, 0]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 0 :

a = [[1, 0], [1, 1], [2, 1], [2, 2], [3, 1]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

}

case 4 ://T形

switch (ret[4][1]) {

case 3 :

a = [[1, 0], [0, 1], [1, 1], [2, 1], [4, 0]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 0 :

a = [[1, 0], [0, 1], [1, 1], [1, 2], [4, 1]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 1 :

a = [[0, 1], [1, 1], [2, 1], [1, 2], [4, 2]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 2 :

a = [[1, 0], [1, 1], [2, 1], [1, 2], [4, 3]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

}

case 5 ://倒L形

switch (ret[4][1]) {

case 3 :

a = [[1, 0], [2, 0], [1, 1], [1, 2], [5, 0]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 0 :

a = [[0, 1], [0, 2], [1, 2], [2, 2], [5, 1]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 1 :

a = [[2, 0], [2, 1], [1, 2], [2, 2], [5, 2]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 2 :

a = [[0, 1], [1, 1], [2, 1], [2, 2], [5, 3]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

}

case 6 ://L形

switch (ret[4][1]) {

case 3 :

a = [[1, 0], [2, 0], [2, 1], [2, 2], [5, 0]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 0 :

a = [[0, 1], [1, 1], [2, 1], [0, 2], [5, 1]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 1 :

a = [[1, 0], [1, 1], [1, 2], [2, 2], [5, 2]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

case 2 :

a = [[2, 1], [0, 2], [1, 2], [2, 2], [5, 3]];

if (lrnotout(0, a) !reach(x, y - 1, a)) {

rv(a, ret);

}

return;

}

function generate(ret:Object) {//随机产生方块函数（可进一步修正）

ret[4][0] = Math.floor(Math.random() * 7);

ret[4][1] = Math.floor(Math.random() * 4);

rotate(ret);//完成方块ret的具体形状的赋值

}

function init() {//初始化背景、方块、运动函数

var i:Number, j:Number;

for (i = 0; i N; i++) {//初始化背景，边界为219，其余为' '

for (j = 0; j 10; j++) {

if (i == N - 1) {

bg[i][j] = 219;

} else {

bg[i][j] = ' ';

}

for (i = 0; i 5; i++) {//为当前方块赋初值0

ret[i][0] = ret[i][1] = 0;

}

generate(ret);//产生当前方块

generate(nextret);//产生下一个方块

y = 0, x = 3, score = lines = 0, level=0;//当前位置坐标和计分系统初始化

_tetris.removeTextField();//如果从结束过的游戏恢复，删除结束标志

display();//显示画面

frameflag = 0;//标示下落时间间隔

onEnterFrame = function () {

frameflag++;

if (10 - frameflag level) {//根据等级level确定下落时间间隔

frameflag = 0;

go();//下落及判断

}

};

}

function drawblock(a, b, c, d) {//绘制方块的小块

with (panel) {

beginFill(0x000FFF, 100);

lineStyle(1, 0xFF00FF);

moveTo(panel._x + a, panel._y + b);

lineTo(panel._x + c, panel._y + b);

lineTo(panel._x + c, panel._y + d);

lineTo(panel._x + a, panel._y + d);

lineTo(panel._x + a, panel._y + b);

endFill();

}

function erase() {//删除一行方块

var n:Number = 0, i:Number, j:Number, k:Number, l:Number;

for (i = 0; i N - 1; i++) {

for (j = 0; j 10; j++) {

if (bg[i][j] == ' ') {//如果该行有空，则开始判断下一行

i++, j = -1;

if (i == N - 1) {//行N-1为底线，不判断

break;

}

} else if (j == 9) {//判断到该行最后一列都没有空

for (k = i; k = 1; k--) {//上方方块下落

for (l = 0; l 10; l++) {

bg[k][l] = bg[k - 1][l];

}

for (l = 0; l 10; l++) {//删除该行

bg[0][l] = ' ';

}

n++;//此次删除行数变量增一

if ((lines + n) % 30 == 0) {//删除行数总数到30的倍数则等级上升

level = (level + 1) % 10;

}

lines += n, score += (n * n + n) * 50;//总行数增n，计算得分

}

function display() {

//显示函数，采用全部清除再重绘制的方法（因为这个程序本来是在Turbo C 2.0的文本环境下完成的）

var i:Number, j:Number;

panel.clear();

with (panel) {//画边界

lineStyle(1, 0x0000FF);

moveTo(panel._x, panel._y);

lineTo(panel._x + WIDTH * 10, panel._y);

lineTo(panel._x + WIDTH * 10, panel._y + WIDTH * (N - 1));

lineTo(panel._x, panel._y + WIDTH * (N - 1));

lineTo(panel._x, panel._y);

}

for (i = 0; i 4; i++) {//当前方块占据的地方赋值为边界类型219

bg[y + ret[i][1]][x + ret[i][0]] = 219;

}

for (i = 0; i N - 1; i++) {//绘制背景方块

for (j = 0; j 10; j++) {

if (bg[i][j] == 219) {

drawblock(j * WIDTH + X, i * WIDTH + Y, j * WIDTH + WIDTH + X, i * WIDTH + WIDTH + Y);

}

for (i = 0; i 4; i++) {//绘制当前方块

drawblock(nextret[i][0] * WIDTH + 14 * WIDTH + X, nextret[i][1] * WIDTH + 12 * WIDTH + Y, nextret[i][0] * WIDTH + WIDTH + 14 * WIDTH + X, nextret[i][1] * WIDTH + WIDTH + 12 * WIDTH + Y);

}

for (i = 0; i 4; i++) {//当前方块绘制完毕，重新将当前位置改为' '

bg[y + ret[i][1]][x + ret[i][0]] = ' ';

}

createTextField("_lvltxt", 1, 270, 100, 100, 20);//绘制计分系统

createTextField("_scrtxt", 2, 270, 130, 100, 20);

createTextField("_lnstxt", 3, 270, 160, 100, 20);

_lvltxt.text = "Level: " + level;

_scrtxt.text = "Score: " + score;

_lnstxt.text = "Lines: " + lines;

}

function go() {//下落函数

var sss:Number = reach(x, y, ret);//当前方块下落一格是否碰到边界或方块

var ii:Number;

if (!sss) {

y++;//如果当前方块下落一格没有碰到边界或方块则下落一格

}

display();//重新绘制

if (sss) {//碰到边界或方块

score += 10;//得10分

display();//重新绘制

for (ii = 0; ii 4; ii++) {//修改背景数组，将当前方块的位置改为边界类型

bg[y + ret[ii][1]][x + ret[ii][0]] = 219;

}

erase();//删除行判断及执行

rv(nextret, ret);//将下一个方块赋值为当前方块

y = 0, x = 3;//重置方块位置

generate(nextret);//生成下一个方块

display();//重新绘制

if (reach(x, y, ret)) {//如果下一格碰到方块则游戏结束

createTextField("_tetris", 100000, WIDTH * 3.3, WIDTH * N / 3, 70, 20);

_tetris._x += 200;

_tetris._y += 50;

_tetris._xscale = 300;

_tetris._yscale = 300;

_tetris.background = true;

_tetris.text = "Game Over!";

onEnterFrame = function () {//停止下落

};

}

function key() {

if (Key.isDown(Key.UP)) {

rotate(ret);

display();

}

if (Key.isDown(Key.LEFT)) {

if (lrnotout(-1, ret)) {//左移可行性判断

x--;

display();

}

if (Key.isDown(Key.RIGHT)) {

if (lrnotout(1, ret)) {//右移可行性判断

x++;

display();

}

if (Key.isDown(Key.DOWN)) {//键盘控制下落

go();

}

if (Key.isDown(Key.SPACE)) {//一键下落到底

while (!reach(x, y, ret)) {

y++;

}

go();

}

if (Key.isDown(82)) { //重新开始游戏

init();

}

init();//初始化

setInterval(key, 80);//每个80毫秒执行一次键盘事件函数

createTextField("hinttxt",33324,200,20,300,50);

hinttxt.text="键盘键：上,下,左,右,R（reset）,空格";

求C语言俄罗斯方块代码