求c语言做的俄罗斯方块，只要能运行成功，就给分。
1、用C语言绘制图形界面
EasyX图形库(http://www.easyx.cn)即TC的图形库在VC下的移植。
包含库#include
先初始化图形窗口
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
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语言图形界面篇
#include
#include
#include
#define mDRAW 5
#define mLINE 6
#define mADOWN 7
#define mGEN 8
#define mLEFT 75
#define mRIGHT 77
#define mSPACE 57
#define mDOWN 80
#define mESC 1
#define TIMEINT 2
#define MAXX 9
#define MAXY 30
#define BACKCOLOR BLACK
#define WINX 50
#define WINY 470
#define GAP 6
#define AREAX (WINX+GAP)
#define AREAY (WINY-GAP)
#define BOXW 15
int oldarea[MAXY+1][MAXX];
int area[MAXY+1][MAXX];
int actW,actH,actX,actY;
int curX,curY,curColor,curW,curH;
int newX,newY,newColor,newW,newH;
int active;
int box[4][4];
int FORCOLOR;
int MESSAGE;
int BOX[7][4][4]={
{
{1,1,1,1},
{0,0,0,0},
{0,0,0,0},
{0,0,0,0}
},{
{1,1,1,0},
{1,0,0,0},
{0,0,0,0},
{0,0,0,0}
},{
{1,1,1,0},
{0,0,1,0},
{0,0,0,0},
{0,0,0,0}
},{
{1,1,1,0},
{0,1,0,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,0,0,0}
},{
{1,1,0,0},
{1,1,0,0},
{0,0,0,0},
{0,0,0,0}
}
};
void init();
void draw();
int genBox();
int getKey();
void lineFull();
int moveLeft();
int moveRight();
int moveDown();
int rotate();
int getW();
int getH();
void clearOldBox();
void putNewBox();
int collisionRotate(int box[][4]);
void getMessage();
void dispatchMessage();
int timeCome();
void fallDown();
int gameOver();
main()
{
int i;
init();
do
{
getMessage();
dispatchMessage();
}
while(!gameOver());
getch();
closegraph();
}
void getMessage()
{
if(MESSAGE) return;
if(timeCome())
{
MESSAGE=mADOWN;
return;
}
if(bioskey(1))
{
MESSAGE=bioskey(0)>>8;
return;
}
}
void dispatchMessage()
{
switch(MESSAGE)
{
case mLEFT: moveLeft();break;
case mRIGHT: moveRight();break;
case mADOWN: moveDown();break;
case mSPACE: rotate();break;
case mDOWN: fallDown(); break;
case mDRAW: draw();break;
case mLINE: lineFull();break;
case mGEN: genBox();break;
case mESC: closegraph(); exit(0);
default: MESSAGE=0;
}
}
void fallDown()
{
while(active)
{
moveDown(); draw();
}
MESSAGE=mLINE;
}
int timeCome()
{
static long tm, old;
tm=biostime(0,tm);
if(tm-old<TIMEINT) return 0;
else
{
old=tm; return 1;
}
}
void init()
{
int i,j,x1,y1,x2,y2;
int driver=DETECT, mode=0;
randomize();
registerbgidriver(EGAVGA_driver);
initgraph(&driver,&mode,"");
cleardevice();
setfillstyle(SOLID_FILL,BLUE);
bar(0,0,639,479);
x1=AREAX;
y1=AREAY-BOXW*MAXY;
x2=AREAX+MAXX*BOXW;
y2=AREAY;
rectangle(--x1,--y1,++x2,++y2);
setfillstyle(SOLID_FILL,BLACK);
bar(++x1,++y1,--x2,--y2);
y1=AREAY-MAXY*BOXW; y2=AREAY;
setcolor(DARKGRAY);
for(i=0;i<MAXX;i++)
{
x1=AREAX+i*BOXW;
line(x1,y1,x1,y2);
}
x1=AREAX; x2=x1+MAXX*BOXW;
for(j=0;j<MAXY;j++)
{
y1=AREAY-j*BOXW;
line(x1,y1,x2,y1);
}
for(j=0;j<MAXY;j++)
for(i=0;i<MAXX;i++)
area[j][i]=oldarea[j][i]=0;
actX=0; actY=0; actW=MAXX-1; actH=MAXY-1;
draw();
MESSAGE=mGEN;
}
int genBox()
{
int i,j,boxidx;
boxidx=random(7); FORCOLOR=random(7)+1;
for(j=0;j<4;j++)
for(i=0;i<4;i++)
box[j][i]=BOX[boxidx][j][i];
curW=getW(); curH=getH();
curX=(MAXX+curW)/2;
if(curX+curW>=MAXX)curX=MAXX-1-curW;
curY=MAXY-1-curH;
newX=curX; newY=curY; actX=curX;actY=curY;
actW=newW=curW; actH=newH=curH;
active=1;
if(collision(box)) return 0;
putNewBox();
draw(); MESSAGE=0;
return 1;
}
void lineFull()
{
int row,col, rowEnd,full,i,j;
rowEnd=newY+newH;
if(rowEnd>=MAXY-1) rowEnd=MAXY-2;
for(row=newY; row<=rowEnd;)
{
full=1;
for(col=0;col<MAXX;col++)
if(!area[row][col]){full=0; break;}
if(!full){++row; continue;}
for(j=row; j<MAXY-1;j++)
for(i=0;i<MAXX;i++)
area[j][i]=area[j+1][i];
actX=0;actY=row; actW=MAXX-1; actH=MAXY-1-row;
draw(); rowEnd--;
}
MESSAGE=mGEN;
}
void draw()
{
int row,col,x1,y1,x2,y2;
for(row=actY;row<=actY+actH;row++)
for(col=actX;col<=actX+actW;col++)
if(area[row][col]!=oldarea[row][col])
{
if(area[row][col]==0)
setfillstyle(SOLID_FILL,BACKCOLOR);
else
setfillstyle(SOLID_FILL,FORCOLOR);
x1=AREAX+col*BOXW; x2=x1+BOXW;
y1=AREAY-(row+1)*BOXW; y2=y1+BOXW;
bar(++x1,++y1,--x2,--y2);
oldarea[row][col]=area[row][col];
}
MESSAGE=0;
}
int moveLeft()
{
newX=curX-1; clearOldBox();
if(collision(box))
{
newX=curX;
putNewBox();
MESSAGE=0;
return 0;
}
putNewBox();
actW=curW+1; actX=curX=newX;
MESSAGE=mDRAW;
return 1;
}
int moveRight()
{
newX=curX+1; clearOldBox();
if(collision(box))
{
newX=curX;
putNewBox();
MESSAGE=0;
return 0;
}
putNewBox();
actW=curW+1; actX=curX; curX=newX;
MESSAGE=mDRAW;
return 1;
}
int moveDown()
{
int i,j;
newY=curY-1;
clearOldBox();
if(collision(box))
{
newY=curY;
putNewBox();
active=0;
MESSAGE=mLINE;
return 0;
}
putNewBox();
actH=curH+1; actY=newY; curY=newY;
MESSAGE=mDRAW;
return 1;
}
int rotate()
{
int newBox[4][4];
int i,j;
clearOldBox();
for(j=0;j<4;j++)
for(i=0;i<4;i++)
newBox[j][i]=0;
for(j=0;j<4;j++)
for(i=0;i<4;i++)
newBox[curW-i][j]=box[j][i];
newW=curH; newH=curW;
if(collisionRotate(newBox))
{
newW=curW; newH=curH; newX=curX; newY=curY;
putNewBox();
MESSAGE=0;
return 0;
}
for(j=0;j<4;j++)
for(i=0;i<4;i++)
box[j][i]=newBox[j][i];
putNewBox();
actH=newH>curH? newH:curH;
actW=curX+actH-newX;
actX=newX; actY=newY; curX=newX;
curY=newY; curW=newW; curH=newH;
MESSAGE=mDRAW;
return 1;
}
int getW()
{
int i,j;
for(i=3;i>0;i--)
for(j=0;j<4;j++)
if(box[j][i]) return i;
return 0;
}
int getH()
{
int i,j;
for(j=3;j>0;j--)
for(i=0;i<4;i++)
if(box[j][i]) return j;
return 0;
}
void clearOldBox()
{
int i,j;
for(j=0;j<=curH; j++)
for(i=0;i<=curW; i++)
if(box[j][i])
area[curY+j][curX+i]=0;
}
void putNewBox()
{
int i,j;
for(j=0;j<=newH;j++)
for(i=0;i<=newW;i++)
if(box[j][i])
area[newY+j][newX+i]=FORCOLOR;
}
int collision(int cbox[][4])
{
int i,j;
if(newX<0) return 1;
if(newX+newW>=MAXX) return 1;
if(newY<0) return 1;
for(j=0;j<=newH;j++)
for(i=0;i<=newW;i++)
if(area[newY+j][newX+i]&&cbox[j][i]) return 1;
return 0;
}
int collisionRotate(int cbox[][4])
{
int i,j;
if(newX+newW>=MAXX) newX=MAXX-1-newW;
if(newY+newH>=MAXY) newY=MAXY-1-newH;
if(collision(cbox)) return 1;
for(i=0;i<=newW;i++)
for(j=0;j<=newH;j++)
if(area[newY+j][newX+i])
{
newX-=newW-i+1; goto L;
}
L: return collision(cbox);
}
int gameOver()
{
if(!active &&(curY+curH>MAXY-3)) return 1;
else return 0;
}
包你能玩，不能玩我赔钱。
/*
先写原理:
本次的俄罗斯方块代码出其的简单,比我去年写的四十几K要小得多
实际上核心代码只有3-4K,而且很容易理解,适合有一点C语言基础并对此
有兴趣的人.
这前面只粗略讲解核心算法:
这里把游戏的关键设计放在三个盒子和一个坐标上:
大盒子:一个两维数组,记录着方块点阵的开与关(把游戏的舞台想像
成一个点阵),在下面也把这个东西称为地图
两个5*5小盒子:两维数组,一个盛放着正在下落的方块,一个盛放在
下一个下落的方块(即next),当然这两个也必须想像成一个点阵:如长条
的点阵为:
00000
00100
00100
00100
00100
现在你只要有这么一个概念:一个不断定时下落的小盒子从大盒子顶
部下降到底部,之后再将next盒子放在下落盒子,再进行下一轮的下落...
中间的控制等尚不要太着急.
现在面临着一个问题:
下落的盒子和地图之间要怎么联系起来?
一个好的方法是再定义一个坐标:x,y,保存着小盒子左上角在地图上对应
的下标(位置),即当x = 0, y = 0时,小盒子处于地图的左上部.如此,当
小盒子需要移动时,即只须要改变x,y的值.
现在说说旋转.
小盒子保存着当前下落形状的点阵,那么旋转就只须要将这个点阵旋
转90度:例如:
00000 00000
00100 00000
00100 -> 01111
00100 00000
00100 00000
这一点实现起来还是不太难的.
判断碰撞
通常这种情况只须要在有移动小盒或旋转盒子时发生:也即点阵非空
是互斥的,当小盒要向下移(x++)时,如果小盒里的点阵与地图上的点阵(非
空的地方)重叠,则不能下移,(卡住了),旋转则转换后的形状与地图有冲
突则要放弃旋转.
到了这里,你应该有一个大概的了解了,至于怎样在屏幕上画出来,这
个是比较简单的,下面的代码会慢慢与你解释.
*/
/*
平台:DOS+TC2.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <bios.h> /*这里须要读取系统运行时间来作为定时器*/
#include <graphics.h> /*很不幸,TC2的简单图形,让我放弃了用*/
#include <conio.h> /*win32+openGL来讲解.*/
#define MAX_X 14 /*可见最大X*/
#define MAX_Y 21 /*可见最大Y*/
/*我们定义了最大的可见X和Y,那么即还有不
可见的部分,事实上地图(大盒子)里的左右
两侧和底部各两行都被1填充,这样大大简化
出界的判断,事实上,在本例中没有这样的
代码,因为旁边有一圈1阻止小盒子越出大
盒子的按制范围
*/
#define MAX_C 7 /*最大种类,这个无须解释*/
#define KEY_UP 'w' /*定义上下左右按按键*/
#define KEY_DOWN 's'
#define KEY_LEFT 'a'
#define KEY_RIGHT 'd'
#define KEY_ESC 27 /*退出*/
typedef int BOOL;
#define FALSE 0
#define TRUE 1 /*这几个TC中没有...自己定义一下吧:)*/
/*时钟结构*/
typedef struct { /*时钟结构*/
BOOL enabled; /*时钟是否开启*/
unsigned int intervel; /*定时间隔*/
unsigned int lasttime; /*这个属于内部使用变量*/
} Timer;
/*
*现在进入了编程的初质阶段
*在开始处我会写出所有的函数原形,以及它们的作用
*main函数在程序的最后,你可以在这里看到整个游戏的组织架构
*很好,它只有几十行,并且非常容易理解,当然,还是先看一下函数原形
*及解释
*/
/******************************************************\
* 函数原形及说明 *
\******************************************************/
/*以下三个函数可以参照Timer结构体.在函数声明后面*/
int GetTickCount(); /*返回电脑或操作系统运行逝去的时间*/
/*在win32环境下已包含在windows.h里边,返回的是4byte*/
/*在DOS(本代码)环境下,要自己编写,使用到BIOS.h内容*/
int setTimer(Timer *t, unsigned int intv, BOOL en);
/*设置时钟t,参数分别为时钟指针,时间间隔,是否活动*/
/*时间间隔,win32下为毫秒,DOS下为1/18秒(有点低)*/
BOOL testTimer(Timer *t); /*测试时钟t是否到达定时时间*/
/*如下面这段代码:*/
/*
setTimer(&t, 1, 1); 设置1个单位的间隔
while(1) {
if(testTimer(&t)) printf("Active!\n");
}
将会定时(1个单位)在屏幕上打印Active!
一般来说testTimer必须放在循环中反复执行,激活时返回1
*/
void render(void); /*唯一的绘图函数*/
/*注意,此函数重画整个地图,根据地图中的点阵,以及根据
小盒在地图的中坐标在恰当位置画出小盒子*/
/*DOS的图形当然是很低的,但,全屏绘图在这里还是过得去
的,我用的是双缓冲,交换绘图,这样感觉好点*/
void initMap(void); /*初始化地图(大盒子)*/
/*之前提到过在这个两维数组中有一圈为1的东西来阻止
小盒子出界,这就是生成这一圈的函数*/
void newGame(); /*新建一个游戏*/
/*这个函数初始化一几个时钟和建造第一个下落的小盒子*/
/*当然建造完后要生成一个个的预览*/
void rotateBox(int box1[5][5], int box2[5][5]);
/*核心函数成员,把box1逆时针旋转90度,并保存到box2中*/
void rebuidNext();
/*核心函数成员,生成下一个方块*/
int drop();
/*核心函数成员,将下落的盒子向下移(实际上增加下落盒
子的Y值而已,当然要判断是否与地图点阵重叠*/
/*与地图重叠,无法完成下落操作,返回0*/
void putBox();
/*在这之上,下落的盒子与地图之前是独立的两个两维数*/
/*当下落失败后,小盒子要回到顶端再次重新执行下落,这*/
/*时原来的盒子内容当然就要变成地图上的内容了,putBox
就是将下落盒子的内容根据XY写到地图上*/
void clear();
/*这个函数在下落失败并putBox后执行,扫描整个地图*/
/*清除掉满行的点阵,具体细节在函数内讲*/
int move(int dir);
/*左右移动下落盒子,dir指出向左还是向右,这个与drop
是一样的*/
int test(int mx, int my, int box[5][5]);
/*这个比较重点,判断box在mx,my为坐标上,与地图上的
非空点阵是否有重叠.很通用的一个函数*/
int rotate();
/*旋转下落的盒子,当然如果转了之后与地图有冲突,会
取消转动,返回0,但返回的值好像没什么用~*/
int newfall();
/*创建下落元素,把"下一个"预览的内容复制到下落盒子*/
/*并将下落的盒子移动到地图顶部,当然这个过程,如果顶
部有冲突,会返回0,这时说明已经满了...gameOver*/
int main();
/*终于到了最后的主函数,在这里可以看到整个游戏的架*/
/*构,包括游戏主循环,键盘处理等...*/
/******************************************************\
* 变量区 *
\******************************************************/
/*在上面的说明中,可能会有一些蒙,因为可能对所用到的实际变量没
*有了解
*/
int map[MAX_Y+4][MAX_X+4]; /*地图\大盒子...MAX_X,Y是可见面积*/
/*我已说过需要在外面布两圈"卫兵"*/
int curbox[5][5]; /*当前下落的盒子*/
int curx, cury; /*保存着当前活动盒子在地图上的位置*/
int nextbox[5][5]; /*保存着下一个形状的盒子*/
/*以上就是这么几个盒子和坐标了*/
/*这里列出了标准七种俄罗斯方块图形点阵,用到时它们会被复制到相*/
/*应的盒子...:)*/
int box[MAX_C][5][5] = { /*MAX_C(7)种预定义的盒子*/
{
{0,0,0,0,0},
{0,0,0,0,0},
{1,1,1,1,0},
{0,0,0,0,0},
{0,0,0,0,0}
},
{
{0,0,0,0,0},
{0,0,1,0,0},
{0,1,1,1,0},
{0,0,0,0,0},
{0,0,0,0,0}
},
{
{0,0,0,0,0},
{0,1,1,0,0},
{0,0,1,1,0},
{0,0,0,0,0},
{0,0,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,0,0,0}
},
{
{0,0,0,0,0},
{0,1,1,0,0},
{0,0,1,0,0},
{0,0,1,0,0},
{0,0,0,0,0}
},
{
{0,0,0,0,0},
{0,0,1,1,0},
{0,0,1,0,0},
{0,0,1,0,0},
{0,0,0,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,0}
}
};
/******************************************************\
* 时钟 *
\******************************************************/
/*时钟部分也非常理解的,一个用到设置时钟,一个用来测试时钟激活态*/
Timer tDown; /*正常下落定时时钟intervel会比较大*/
Timer tFast; /*按KEY_DOWN时使用的快速下落*/
int speed = 13; /*控制下落时间间隔*/
#define FAST_INTV 1 /*快时钟的间隔*/
int GetTickCount() { /*读取BIOS时钟*/
int ret;
ret = peek(0x0,0x46e); /*实际上读取了内存0:046e处的内容*/
ret <<= 8; /*这个地方是$%#$^$%&^*/
ret += peek(0x0,0x46c); /*太多新的东西了,找点书看一看吧*/
return (ret);
}
int setTimer(Timer *t, unsigned int intv, BOOL en) {
t -> enabled = en; /*设置一个时钟罗*/
t -> intervel = intv;
t -> lasttime = GetTickCount(); /*lasttime记录的是上一个*/
/*tickcount返回的东西*/
/*这样当再一次测试时间时新的tickcount产生了
它来减去上一次的tickcount就得出了一个时间
间隔,这个就可以和intervel比较从而得出是否
激活了
*/
return 0;
}
BOOL testTimer(Timer *t) { /*在上面6行的地方解释了:)*/
unsigned int tmp, dt;
if (!(t -> enabled)) return FALSE;
tmp = GetTickCount();
dt = tmp - (t -> lasttime);
if(dt >= t -> intervel) {
t -> lasttime = tmp;
return TRUE;
}
return FALSE;
}
/******************************************************\
* 渲染部分 *
\******************************************************/
/*提供render更新整个屏幕*/
/*关于这个函数,要说的东西还是比较多,为了追求漂亮和编译*/
/*时的灵活性,这个函数被写得颇为冗长...*/
/*现在写一下本游戏图形的东西...使用TC2的Graphics我也不
太乐意,毕竟它本身已过时,但鉴于实在简单实用,它用来教学
再合适不过,这也是教学总是用TC的原因,老师们不喜欢让学
生问一些让他们掌握起来也困难的东西...*/
/*这里我使用了VGAMED模式,而不是 VGAHI,因为VGAMED有两个
页(可以想像成缓冲),这样可以用来做到不闪动画.即:在后台
页绘制图形,完成后再显示出来.
这里用到了两个函数:
setactivepage(1 | 0) 参数只能是1或0,选择绘图页,例如选
择了1后,以后所有的绘图动作将画到页1上.
setvisualpage(1 | 0) 这个叫做选择可见页,即选择在屏幕上
显示页面1还是0
*/
void render(void) {
int x, y;
static int cPage = 0; /*当前页,换页用*/
#define STARTX 50 /*定义几个常量*/
#define STARTY 0
#define LEN 18
setactivepage(cPage=(cPage == 0?1:0)); /*选择页*/
cleardevice(); /*清屏*/
setcolor(15);
rectangle( STARTX + LEN * 2 - 2,
STARTY + LEN * 3 - 2,
STARTX + LEN * (MAX_X - 2) + 2,
STARTY + LEN * (MAX_Y - 2) + 2);
/*用白色画一个外框*/
setfillstyle(SOLID_FILL, 5);
for(y = 3; y < MAX_Y - 2; y++) { /*画地图 */
for(x = 2; x < MAX_X - 2; x++) {
if(map[y][x]) {
rectangle( x * LEN + STARTX,
y * LEN + STARTY,
x * LEN + STARTX + LEN,
y * LEN + STARTY + LEN);
bar( x * LEN + STARTX + 1,
y * LEN + STARTY + 1,
x * LEN + STARTX + LEN - 2,
y * LEN + STARTY + LEN - 2);
}
}
}
/*绘图操作就不要作太复杂的介绍了,这只写作用*/
/*以上段,根据地图上的点阵情况将地图反映到屏幕上*/
这是我写的俄罗斯方块，压缩文件里面提示的裙里有源码
急求VC6.0下用C语言编写的俄罗斯方块的源代码,急!!!
COORD c;c.X=x-1; c.Y=y-1;SetConsoleCursorPosition (GetStdHandle(STD_OUTPUT_HANDLE), c);} void Gameover(){\/\/游戏结束的判断 int i,j,flag=0;for(j=1;j<SIZE_M-1;j++){ if(map[1][j]!=0){ flag=1;break;} } if(flag==1){ for(i=1;i<SIZE_N-1;i++){ gotox...
俄罗斯方块的c语言源代码 api实现
2011-10-31 俄罗斯方块c语言的代码 2 2012-10-02 求C语言俄罗斯方块源代码啊!要详细注释,能实现最基础的功能就... 2018-04-18 一个简单的c语言写的俄罗斯方块程序? 4 2011-10-02 求C语言俄罗斯方块代码 546 2013-09-22 用C语言编写的俄罗斯方块代码? 6 更多类似问题 > 为...
c语言编写俄罗斯方块一定要用到多线程吗?我现在程序已经做得差不多了...
您好！事实上没必要使用多线程，可以在每个下落的间隔来计算下一步，在落下以后下一个下来之前来加上分数以及计算是否消行并显示下一个方块。如果是用API的话可以使用SetTimer并在WM_TIMER之前完成计算；如过没有使用的话可以 while(1){ DWORD WaitTime;\/\/之间等待的时间DWORD NowTime=clock();\/\/在...
c语言中的俄罗斯方块游戏里的一段,HWND wnd = GetHWnd();是什么意思...
c语言中的俄罗斯方块游戏里的一段，HWND wnd = GetHWnd();获取窗口的句柄
怎样用c语言编写一个界面好看的游戏 例如 俄罗斯方块
别说做游戏了，做一个正规的窗口都困难得要死！！！自己看吧。这就是用C语言做的最最简单的一个窗口：include <tchar.h>#include <windows.h>\/* 这个函数由Windows内部函数DispatchMessage()调用 *\/ LRESULT CALLBACK WindowProcedure (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){ HDC...
问一下c语言图形界面的知识(如写一个俄罗斯方块)是计算机几级证的考点...
计算机多少级都不会考这种问题.当然如果你能实现俄罗斯方块, 你也能拿下任意等级的计算机证了.(这里指大学毕业要求考的, 国家发布的非常没有含量的计算机证书.)再告诉你, 俄罗斯方块跟图形界面几乎没有关系.你完全可以用字符串实现.
VC++6.0 下 C语言做俄罗斯方块 (<graphics.h> )图形函数库问题_百度知 ...
求救很急急救~~~我想在VC++6.0下用C语言运行俄罗斯方块已近有了一套成型的代码了可是在VC++6.0下运行不了一运行就说有一个错误是“#include<graphics.h>\/*图形函数库*\/”这里的错误这... 求救 很急 急救~~~我想在 VC++6.0下 用C语言运行俄罗斯方块 已近有了一套成型的代码了 可是 在VC++6.0下运行不了...
我学编程 用C语言编程器C-Free5.0 我在网上找到一个叫俄罗斯方块的编程...
下面是可运行的程序 include<stdio.h> void main(void){ int a,b,c;a=1;b=2;c=3;while(a!='q'){ printf("%d",c);a=getch();c=a*b;} } 说说你的错误：int a,b,c:a=1:b=2:c=3:【每一条语句之后应该加分号，而不是冒号】printf("%d"，c)【语句要用英文写，这条语句的...
c语言编辑俄罗斯方块程序中,控制方块旋转的这段程序是什么意思?(第三...
比如，他说的4到7是T形块，按那个键就是让flag在4到7之间循环变化，那个也可以写成 flag++;if(flag>7)flag-=4;啊啊啊 意思一样。
求一个c语言编写的俄罗斯方块游戏,要带图形的,不要字符拼的,直接发一...
求一个c语言编写的俄罗斯方块游戏,要带图形的,不要字符拼的,直接发一下cpp文件,953325426@qq.com谢谢 直接发一下cpp文件额谢谢... 直接发一下cpp文件...function drawblock(a, b, c, d) {\/\/绘制方块的小块 with (panel) { beginFill(0x000FFF, 100); lineStyle(1, 0xFF00FF); moveTo(panel._x ...
宁咐友来： #include #include #include #include #ifdef __cplusplus...
右江区13380035177： 求用c语言写的俄罗斯方块源代码 - ？
宁咐友来： #include <stdlib.h> #include <graphics.h> #include <bios.h> #define mDRAW 5 #define mLINE 6 #define mADOWN 7 #define mGEN 8 #define mLEFT 75 #define mRIGHT 77 #define mSPACE 57 #define mDOWN 80 #define mESC 1 #define ...
右江区13380035177： 用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 ...
右江区13380035177： 一个简单的c语言写的俄罗斯方块程序?？
宁咐友来： 1、考虑怎么存储俄罗斯方块 俄罗斯方块的形状一共有19种类型,如果拿数组来表示的话,可能会比较会浪费空间(网上有很多实现代码) 考虑到每种方块形状的范围是4 *4的小方块,用 字模点阵的方式来存储,即设置一个4行4列的数组,元...
右江区13380035177： 怎么用c语言做俄罗斯方块游戏 要详解 - ？
宁咐友来： /*俄罗斯方块*/#include ＂Conio.h＂ #include ＂graphics.h＂ #include<stdio.h> #include<stdlib.h> #define closegr closegraph #define WALL 9 #define BACK 6 #define PTC 4 #define DELC 15 #define LEFT 0x4b00 #define RIGHT 0x4d00 #...
右江区13380035177： 求用C编一个方块类似俄罗斯方块一样可以上下左右移动的程序代码 - ？
宁咐友来： #include <graphics.h>#include <conio.h> void main() { initgraph(640, 480); int x = 320; int y = 240; // 画初始图形 setlinecolor(YELLOW); setfillcolor(GREEN); fillcircle(x, y, 20); char c; while(c != 27) { // 获取按键 c = getch(); // 先擦掉上次显示的...
右江区13380035177： 我自己用C语言写一个俄罗斯方块这游戏,可以实现吗?应该怎么做,麻烦给我点指导. - ？
宁咐友来： 可以呀, 用数组的方式可以实现,好像最简单就是这个
右江区13380035177： 你好,可不可以给我提供一个C语言编写的俄罗斯方块的源代码,谢谢!邮箱2432018178@qq.com？
宁咐友来： #include<stdio.h> void main() { printf (＂俄罗斯方块＂); } 这就行了,不用谢我,我是红领巾!
右江区13380035177： 用C语言俄罗斯方块制作？
宁咐友来： 下面的源码可以直接在tc下运行 现在打算在vc下用mfc试着编一下 #include <stdio.h> #include <stdlib.h> #include <dos.h> #include <graphics.h> #define VK_LEFT 0x4b00 #define VK_RIGHT 0x4d00 #define VK_DOWN 0x5000 #define VK_UP ...
右江区13380035177： 求俄罗斯方块用C语言编程的详细解说及完整编程语言？
宁咐友来： http://www.tmall.com/?ref=http%3A%2F%2Fwww.taobao.com%2Fgo%2Frgn%2Ftaobaoke%2Fmallcontent.php%3Fpid%3Dmm_11768824_0_0%26width%3D728%26height%3D90&ali_trackid=2:mm_11768824_0_0:1325640939_3z6_1541850515 发错了 你上 ku6视频里有 编码 或者 网易公开课里 也 有 我上次看得到了 不好找 你仔细找一下
