OpenGL实现俄罗斯方块源代码剖析.docx
《OpenGL实现俄罗斯方块源代码剖析.docx》由会员分享，可在线阅读，更多相关《OpenGL实现俄罗斯方块源代码剖析.docx（24页珍藏版）》请在冰豆网上搜索。
OpenGL实现俄罗斯方块源代码剖析
OpenGL实现俄罗斯方块
一、设计思路
本程序采用以C++为基础并利用OpenGl库函数的方式实现俄罗斯方块程序，实现俄罗斯方块中正方形，T形，L形，反L形，直线型，Z字形，反Z字形七种形状的变换操作，七种形状的坐标被存储在一个三维数组中，每次随机选择一个形状生成并下落，在下落过程中监听键盘事件。
二、详细设计说明
本程序中主要的函数及其作用说明如下：
down：
定时下落函数，由glutTimerFunc（1000,down,1）;函数设置每隔1000毫秒即调用一次该函数，在函数中将方块的所有纵坐标减一个单位。
key：
键盘事件监听函数，当键盘上有按键被触发的时候即调用该函数，函数内部支持w，a，s，d四个键的响应，依次代表方向键上，左，右，下，其中w键是用来控制图形变换的，每次按w键时，图形在现有基础上顺时针变换一次。
CheckConflict：
冲突检测函数，检测方块下一次将要移动的位置是否会碰到已有的方块或者左右两边的墙壁。
CheckDelete：
每一次方块落到底部之后，调用该函数检查是否有满行，如果有则调用Delete函数删除该行。
myDisplay1：
作图函数。
Change：
变换函数，主要是通过计算变换后的图形与之前图形的坐标关系来实现。
三、源代码
#include
#include
#include
#include
#include
usingnamespacestd;
#defineLEFT'a'
#defineRIGHT'd'
#defineUP'w'
#defineDOWN's'
#defineSTART0//定义图形的范围
#defineEND19
#defineSIZE25
/*
*初始化七个二维数组，即七个块刚开始产生时出现的位置
*这里需要考虑的情况是：
刚开始产生时有的方块还只露出来一部分，
*如果这个时候按了UP键进行变换应该怎么处理
*本程序最初设计并不考虑这个问题，一开始即画出方块的各个部分，以后再考虑完善的事情
*另外，记录坐标的顺序为从左至右，从上至下
*/
GLfloatb[][5][3]={
{{0.0f,0.9f},{0.0f,0.8f},{0.0f,0.7f},{0.0f,0.6f}},//1、记录长条四个坐标
{{-0.1f,0.9f},{0.0f,0.9f},{-0.1f,0.8f},{0.0f,0.8f}},//2、记录正方形
{{-0.1f,0.9f},{-0.2f,0.8f},{-0.1f,0.8f},{0.0f,0.8f}},//3、T字形
{{-0.1f,0.9f},{0.0f,0.9f},{0.0f,0.8f},{0.1f,0.8f}},//4、记录Z字形
{{-0.1f,0.9f},{0.0f,0.9f},{-0.2f,0.8f},{-0.1f,0.8f}},//5、记录倒Z字形
{{-0.1f,0.9f},{-0.1f,0.8f},{-0.1f,0.7f},{0.0f,0.7f}},//6、记录L字形
{{0.0f,0.9f},{0.0f,0.8f},{-0.1f,0.7f},{0.0f,0.7f}},//7、记录倒L字形
};
GLfloatcurLoc[5][3];
GLintcurrentBlock=2;//记录当前正在下落的是第几种方块,顺序如上面所示
GLintturn[7]={0};//应该变换成第几种形态了
GLfloatxd=0.0f,yd=0.0f;
/*
这里定义的over是用来判断方块是否到达了不能再往下降的地方，到了则置
其为true，否则就修改为false。
其中有这样几种情况需要修改over：
1、重新生成了一个方块，修改over=false
2、方块到大底部，修改over=true
*/
boolover=false;
//记录游戏是否结束
boolend=false;
intscore=0;
//设置一个锁，在下降操作时不允许变换，在变换时不允许下降操作，否则将会产生资源竞争
//intlock=1;
/*
定义一个20*20的矩阵来记录当前整个画面中各个小格子的情况,可用来消除满格行
矩阵的存储顺序为从左到右，从下到上，包含下标0
BLOCK[i][j]中i对应的是纵坐标，j对应的是横坐标（这个有点痛苦），但是在消去满格
的时候还是不变，只是在用b数组给其赋值时需要反过来
*/
GLintBLOCK[SIZE][SIZE];
voiddown（intid）;
voidInitBLOCK（）;
voidChange（）;
voidCheckDelete（）;
intCheckConflict（intlef_rig=0）;
voidCreateBlocks（）;
voidmyDisplay1（）;
voidkey（unsignedchark,intx,inty）;
voidDelete（bool*empty）;
voidshow（）;
voidshow（）
{
inti,j;
for（i=0;i<4;i++）//函数调用的顺序对错误有一定的影响
for（j=0;j<2;j++）
{
cout<}
cout<}
/*
初始化方块矩阵，方块是一个上端开口的长方形
*/
voidInitBLOCK（）
{
inti,j;
for（i=0;ifor（j=0;jBLOCK[i][j]=0;
for（i=0;iBLOCK[0][i]=1;
for（i=0;i<4;i++）
for（j=0;j<2;j++）
curLoc[i][j]=b[currentBlock][i][j];
}
voidChange（）//将图形做变换，采用顺时针旋转的规律（下面的工作即是填入坐标）
{
GLfloattemp00=curLoc[0][0];
GLfloattemp01=curLoc[0][1];
GLfloattemp10=curLoc[1][0];
GLfloattemp11=curLoc[1][1];
GLfloattemp20=curLoc[2][0];
GLfloattemp21=curLoc[2][1];
GLfloattemp30=curLoc[3][0];
GLfloattemp31=curLoc[3][1];
switch（currentBlock）
{
case0:
//长条
switch（turn[0]）
{
case0:
curLoc[0][0]=temp10-0.1f;
curLoc[0][1]=temp11;
curLoc[2][0]=temp10+0.1f;
curLoc[2][1]=temp11;
curLoc[3][0]=temp10+0.2f;
curLoc[3][1]=temp11;
break;
case1:
curLoc[0][0]=temp10;
curLoc[0][1]=temp11+0.1f;
curLoc[2][0]=temp10;
curLoc[2][1]=temp11-0.1f;
curLoc[3][0]=temp10;
curLoc[3][1]=temp11-0.2f;
break;
}
turn[0]=（turn[0]+1）%2;
break;
case1:
//正方形
break;
case2:
//T字形
//cout<<"turn[2]="<switch（turn[2]）
{
case0:
curLoc[1][0]=temp20;
curLoc[1][1]=temp21;
curLoc[2][0]=temp30;
curLoc[2][1]=temp31;
curLoc[3][0]=temp20;
curLoc[3][1]=temp21-0.1f;
break;
case1:
curLoc[0][0]=temp10-0.1f;
curLoc[0][1]=temp11;
break;
case2:
curLoc[0][0]=temp10;
curLoc[0][1]=temp11+0.1f;
curLoc[1][0]=temp00;
curLoc[1][1]=temp01;
curLoc[2][0]=temp10;
curLoc[2][1]=temp11;
break;
case3:
curLoc[3][0]=temp20+0.1f;
curLoc[3][1]=temp21;
break;
}
turn[2]=（turn[2]+1）%4;
break;
case3:
//Z字形
switch（turn[3]）
{
case0:
curLoc[0][0]=temp10+0.1f;
curLoc[0][1]=temp11+0.1f;
curLoc[2][0]=temp10+0.1f;
curLoc[2][1]=temp11;
curLoc[3][0]=temp20;
curLoc[3][1]=temp21;
break;
case1:
curLoc[0][0]=temp10-0.1f;
curLoc[0][1]=temp11;
curLoc[2][0]=temp30;
curLoc[2][1]=temp31;
curLoc[3][0]=temp30+0.1f;
curLoc[3][1]=temp31;
break;
}
turn[3]=（turn[3]+1）%2;
break;
case4:
//反Z字形
switch（turn[4]）
{
case0:
curLoc[0][0]=temp00-0.1f;
curLoc[0][1]=temp01+0.1f;
curLoc[1][0]=temp00-0.1f;
curLoc[1][1]=temp01;
curLoc[2][0]=temp00;
curLoc[2][1]=temp01;
curLoc[3][0]=temp00;
curLoc[3][1]=temp01-0.1f;
break;
case1:
curLoc[0][0]=temp20;
curLoc[0][1]=temp21;
curLoc[1][0]=temp20+0.1f;
curLoc[1][1]=temp21;
curLoc[2][0]=temp10;
curLoc[2][1]=temp11-0.1f;
break;
}
turn[4]=（turn[4]+1）%2;
break;
case5:
//L字形
switch（turn[5]）
{
case0:
curLoc[0][0]=temp10;
curLoc[0][1]=temp11;
curLoc[1][0]=temp10+0.1f;
curLoc[1][1]=temp11;
curLoc[2][0]=temp10+0.2f;
curLoc[2][1]=temp11;
curLoc[3][0]=temp20;
curLoc[3][1]=temp21;
break;
case1:
curLoc[0][0]=temp00;
curLoc[0][1]=temp01+0.1f;
curLoc[1][0]=temp10;
curLoc[1][1]=temp11+0.1f;
curLoc[2][0]=temp10;
curLoc[2][1]=temp11;
curLoc[3][0]=temp10;
curLoc[3][1]=temp11-0.1f;
break;
case2:
curLoc[0][0]=temp20+0.1f;
curLoc[0][1]=temp21;
curLoc[1][0]=temp20-0.1f;
curLoc[1][1]=temp21-0.1f;
curLoc[2][0]=temp20;
curLoc[2][1]=temp21-0.1f;
curLoc[3][0]=temp20+0.1f;
curLoc[3][1]=temp21-0.1f;
break;
case3:
curLoc[0][0]=temp10;
curLoc[0][1]=temp11+0.2f;
curLoc[1][0]=temp10;
curLoc[1][1]=temp11+0.1f;
curLoc[2][0]=temp10;
curLoc[2][1]=temp11;
curLoc[3][0]=temp20;
curLoc[3][1]=temp21;
break;
}
turn[5]=（turn[5]+1）%4;
break;
case6:
//反L字形
switch（turn[6]）
{
case0:
curLoc[0][0]=temp20-0.1f;
curLoc[0][1]=temp21+0.1f;
curLoc[1][0]=temp20-0.1f;
curLoc[1][1]=temp21;
break;
case1:
curLoc[0][0]=temp00+0.1f;
curLoc[0][1]=temp01+0.1f;
curLoc[1][0]=temp30;
curLoc[1][1]=temp31+0.2f;
curLoc[2][0]=temp00+0.1f;
curLoc[2][1]=temp01;
curLoc[3][0]=temp20;
curLoc[3][1]=temp21;
break;
case2:
curLoc[0][0]=temp00-0.1f;
curLoc[0][1]=temp01-0.1f;
curLoc[1][0]=temp20;
curLoc[1][1]=temp21;
curLoc[2][0]=temp20+0.1f;
curLoc[2][1]=temp21;
curLoc[3][0]=temp30+0.1f;
curLoc[3][1]=temp31;
break;
case3:
curLoc[0][0]=temp20;
curLoc[0][1]=temp21+0.1f;
curLoc[1][0]=temp20;
curLoc[1][1]=temp21;
curLoc[2][0]=temp30-0.1f;
curLoc[2][1]=temp31;
curLoc[3][0]=temp30;
curLoc[3][1]=temp31;
break;
}
turn[6]=（turn[6]+1）%4;
break;
}
//如果旋转非法（即旋转时碰到墙壁了），则要恢复原来的状态
intret;
ret=CheckConflict（）;
if（ret==1）
{
curLoc[0][0]=temp00;
curLoc[0][1]=temp01;
curLoc[1][0]=temp10;
curLoc[1][1]=temp11;
curLoc[2][0]=temp20;
curLoc[2][1]=temp21;
curLoc[3][0]=temp30;
curLoc[3][1]=temp31;
}
}
/*
消除满格的一行，在每次over被修改为true的时候都要检查一遍
算法思想是从第0行开始依次判断，如果empty为true则将下面的向上，
并不是判断一次就移动所有的，而是只移动最近的，将空出来的
那一行的empty标记为true
*/
voidDelete（int*empty）
{
inti,j;
intpos;
while
（1）//将上面非空的行填补到下面的空行中
{
i=1;
while（i<20&&empty[i]==0）//为空或者满，都需要将上面的行移下来填充
{
i++;
}
if（i>=20）break;
j=i+1;
while（j<20&&empty[j]==-1）j++;
if（j>=20）break;
if（j<20&&empty[j]!
=-1）
{
for（pos=0;pos<20;pos++）
BLOCK[i][pos]=BLOCK[j][pos];
empty[i]=empty[j];
empty[j]=-1;
}
}
for（i=1;i<20;i++）
if（empty[i]!
=0）
{
for（j=0;j<20;j++）
BLOCK[i][j]=0;
}
}
/*
*1、判断新生成的图形是否和原来的图形有冲突，有则不能更改，这个地方比较不好实现
*2、判断是否有满格的行，有则调用Delete函数去掉
*3、这里似乎还要加上判断是否到大顶部，如果到达顶部则游戏结束（可采用监视方框最上
*面一行之上那行里面有没有方格，如果有的话则游戏结束）
*结束之后就可以把当前方块存入BLOCK中
*empty表示一行中方块的数目，-1表示为空行，0表示部分为空，1表示满行
*/
voidCheckDelete（）//目前这个函数还只是实现了一个方块到达终点之后是否有能够被删除的行
{
inti,j;
intempty[SIZE];
boolis_needed=false;
intcount;
for（i=0;iempty[i]=-1;
for（i=0;i<4;i++）
{
doublex=（curLoc[i][0]+1）*10+0.5;//此处无需注意取值，因为checkConflict已经解决
doubley=（curLoc[i][1]+1）*10+0.5;
BLOCK[（int）y][（int）x]=1;//融合
}
for（i=1;i<20;i++）
{
count=0;
for（j=0;j<20;j++）
if（BLOCK[i][j]==1）
count++;
if（count==20）
{
empty[i]=1;//若满格，则可以删除，置为true
score++;//此处计分
is_needed=true;
}
elseif（count>0&&count<20）
{
empty[i]=0;
}
}
if（is_needed==true）//如果有满行则去删除，否则免之
Delete（empty）;
}
intCheckConflict（intlef_rig）
{
inti;
for（i=0;i<4;i++）
{
doublex=（curLoc[i][0]+1）*10;//注意取值!
!
!
doubley=（curLoc[i][1]+1）*10+0.5;//y方向无需注意
x=x>0?
（x+0.5）:
（x-0.5）;
if（lef_rig==1）
{
inttmpx=（int）x;
if（tmpx>19||tmpx<0）break;
}
if（BLOCK[（int）y][（int）x]==1）//判断是否发生冲突
{
break;
}
}
if（i<4）
return1;
return0;
}
/*
关键部分在这里，主要是要判断方块下一次的移动是否合法，
本程序通过对b数组所存储的下标是否在BLOCK数组中已经为1
来判断，这样，只需要在BLOCK的最外层加一圈1，就不用通过
原来的方式来判断方块是否越界
*/
voidkey（unsignedchark,intx,inty）
{
inti,ret;
if（over==false）
{
if（k==UP）//此处需要改成调用变换图形样式的函数
{
Change（）;
}
elseif（k==DOWN）//后续还要修改，移动到底部过了一段时间之后就不能左右移动了
{
for（i=0;i<4;i++）//需继续添加以1和-1作为哨兵
{
curLoc[i][1]-=0.1f;
}
ret=CheckConflict（）;
if（ret==1）//发生冲突，则将修改复原
{
for（i=0;i<4;i++）
curLoc[i][1]+=0.1f;
over=true;//并且可以生成下一个方块了
}
}
elseif（k==RIGHT）
{
for（i=0;i<4;i++）
curLoc[i][0]+=0.1f;
ret=CheckConflict
（1）;
if（ret==1）//发生冲突，则将修改复原
{
for（i=0;i<4;i++）
curLoc[i][0]-=0.1f;
}
}
elseif（k==LEFT）
{
for（i=0;i<4;i++）
curLoc[i][0]-=0.1f;
升级会员 