devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c语言——俄罗斯方块_c语言俄罗斯方块

作者：小蓝xlanll | 2024-05-29 07:33:01

赞

踩

c语言俄罗斯方块

一、游戏效果

二. 游戏背景

俄罗斯方块是久负盛名的游戏，它也和贪吃蛇，扫雷等游戏位列经典游戏的⾏列。

《俄罗斯方块》（Tetris，俄文：Тетрис）是一款由俄罗斯人阿列克谢·帕基特诺夫于1984年6月发明的休闲游戏。

该游戏曾经被多家公司代理过。经过多轮诉讼后，该游戏的代理权最终被任天堂获得。 任天堂对于俄罗斯方块来说意义重大，因为将它与GB搭配在一起后，获得了巨大的成功。 

《俄罗斯方块》的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。

三、游戏开发日志

基本逻辑结构与贪吃蛇一致 

四、游戏实现

我们有了贪吃蛇的知识储备及了解WIN32 API,理解下面内容也就不难了。

4.1  游戏逻辑主体

  1. #include"tetris.h"
  2.  
  3. int main()
  4. {
  5. 	//修改当前地区为本地模式，为了⽀持中⽂宽字符的打印
  6. 	setlocale(LC_ALL, "");
  7. 	srand((unsigned int)time(NULL));
  8. 	char ch=0;
  9. 	do
  10. 	{
  11. 		GameInit();
  12. 		GameRun();
  13. 		GameOver();
  14. 		system("cls");
  15. 		SetPos(20, 12);
  16. 		printf("再来一局吗？(Y/N):\n");
  17. 		SetPos(22, 15);
  18. 		ch = getchar();
  19. 		
  20. 		getchar();//清理\n
  21. 	} while (ch == 'y' || ch == 'Y');
  22. 	SetPos(0, 29);
  23. 	
  24. 	return 0;
  25. }

4.2  游戏初始化的实现

4.2.1  设置窗口大小、名称及隐藏光标

  1. //设置控制台窗⼝的⼤⼩，30⾏，30列
  2. 	system("mode con cols=60 lines=30");
  3. 	//设置cmd窗⼝名称
  4. 	system("title  俄罗斯方块");
  5. 	//获取标准输出的句柄(⽤来标识不同设备的数值)
  6. 	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  7. 	//影藏光标操作
  8. 	CONSOLE_CURSOR_INFO CursorInfo;
  9. 	GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
  10. 	CursorInfo.bVisible = false; //隐藏控制台光标
  11. 	SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态

4.2.2 打印欢迎界面 

  1. void WelcomeToGame()
  2. {
  3. 	SetPos(20, 10);
  4. 	printf("欢迎来到俄罗斯方块！");
  5. 	SetPos(20, 23);//让按任意键继续的出现的位置好看点
  6. 	system("pause");
  7. 	system("cls");
  8. 	SetPos(14, 10);
  9. 	printf("↑为变换.↓为加速.←为左移.→为右移\n");
  10. 	
  11. 	SetPos(20, 23);//让按任意键继续的出现的位置好看点
  12. 	system("pause");
  13. 	system("cls");
  14. }

 4.2.3  初始化地图

  1. void CreateMap()
  2. {
  3. 	memset(IF.pos, 0, sizeof(int)*30*60);//对数组初始化(如果不初始化，FAIL后第二次循环会IF.pos会保留上次数据）
  4. 	int i = 0;
  5. 	//墙体轮廓
  6. 	SetPos(40, 0);
  7. 	for (i = 40; i < 60; i += 2)
  8. 	{
  9. 		
  10. 		wprintf(L"%lc", WALL);
  11. 	}
  12. 	SetPos(0,29);
  13. 	for (i = 0; i < 60; i += 2)
  14. 	{
  15. 		IF.pos[i][29] = 1;
  16. 		wprintf(L"%lc", WALL);
  17. 	}
  18. 	//x是0，y从1开始增⻓
  19. 	for (i = 0; i < 30; i++)
  20. 	{
  21. 		IF.pos[0][i] = 1;//标记此处有方块
  22. 		SetPos(0, i);
  23. 		wprintf(L"%c", WALL);
  24. 	}
  25. 	
  26. 	for (i = 0; i < 30; i++)
  27. 	{
  28. 		IF.pos[38][i] = 1;
  29. 		SetPos(38, i);
  30. 		wprintf(L"%c", WALL);
  31. 	}
  32. 	for (i = 0; i < 30; i++)
  33. 	{
  34. 		IF.pos[58][i] = 1;
  35. 		SetPos(58, i);
  36. 		wprintf(L"%c", WALL);
  37. 	}
  38. 	SetPos(40, 10);
  39. 	for (i = 40; i < 60; i += 2)
  40. 	{
  41. 		IF.pos[i][10] = 1;
  42. 		wprintf(L"%lc", WALL);
  43. 	}
  44. 	//提示字体
  45. 	SetPos(40, 1);
  46. 	printf("下一个方块：");
  47.  
  48. 	SetPos(44, 12);
  49. 	printf("左移：←");
  50.  
  51. 	SetPos(44, 14);
  52. 	printf("右移：→");
  53.  
  54. 	SetPos(44, 16);
  55. 	printf("加速：↓");
  56.  
  57. 	SetPos(44, 18);
  58. 	printf("变换：↑");
  59.  
  60. 	SetPos(44, 20);
  61. 	printf("暂停: 空格");
  62.  
  63. 	SetPos(44, 22);
  64. 	printf("退出: Esc");
  65.  
  66. 	SetPos(44, 24);
  67. 	printf("重新开始:R");
  68.  
  69. 	
  70.     SetPos(44, 26);
  71. 	printf("当前分数：%d", grade);
  72.  
  73. 	
  74.  
  75. }

注解： 

1）一个宽字符占2个字节，我们设置 cols=60 lines=30，实际就是长宽各30个字节大小

2）如上图所示，游戏展示区长为20，高为30，右上部分为下一个方块提示区域，正下面为游戏操作提示区

3）横轴为x轴，向右坐标逐渐增大，向下为y轴，坐标逐渐增大。（x,y)确定宽字符（小方块）的位置，因为宽字符（小方块）占2个字节宽度，所以x轴坐标没有奇数值

4）为了方便检测下落方块是否靠墙、落地及碰到其它方块，我们定义一个大数组pos[60][30],一一对应地图上每个宽字符（小方块)的位置，用大数组pos[60][30]记录墙体位置及落地的方块位置

  1. typedef struct InterFace
  2. {
  3. 	int pos[60][30]; //用于标记整个界面有方块的位置（1为有，0为无）
  4. 	
  5. }InterFace;
  6.  
  7. InterFace IF;

4.2.4 初始化方块信息

  1. void InitBlockInfo()
  2. {
  3. 	//'T'字型
  4. 	int i = 0;
  5. 	for (i = 0; i < 3; i++)
  6. 	{
  7. 		block[0][0].space[1][i] = 1;
  8. 	}
  9. 	block[0][0].space[2][1] = 1;
  10. 	
  11. 	//‘L'字型
  12. 	for (i = 1; i < 4; i++)
  13. 	{
  14. 		block[1][0].space[i][1] = 1;
  15. 	}
  16. 	block[1][0].space[3][2] = 1;
  17.  
  18. 	//'J'字形
  19. 	for (i = 1; i < 4; i++)
  20. 	{
  21. 		block[2][0].space[i][2] = 1;
  22. 	}
  23. 	block[2][0].space[3][1] = 1;
  24.  
  25. 	//’Z'字型
  26. 	for (i = 0; i < 2; i++)
  27. 	{
  28. 		block[3][0].space[1][i] = 1;
  29. 	}
  30. 	for (i = 1; i < 3; i++)
  31. 	{
  32. 		block[3][0].space[2][i] = 1;
  33. 	}
  34.  
  35. 	//‘S'字型
  36. 	for (i = 1; i < 3; i++)
  37. 	{
  38. 		block[4][0].space[1][i] = 1;
  39. 	}
  40. 	for (i = 0; i < 2; i++)
  41. 	{
  42. 		block[4][0].space[2][i] = 1;
  43. 	}
  44.  
  45. 	//'田’字型
  46. 	int j = 0;
  47. 	for (i = 1; i < 3; i++)
  48. 	{
  49. 		for (j = 1; j < 3; j++)
  50. 		{
  51. 			block[5][0].space[i][j] = 1;
  52. 		}
  53. 	}
  54.  
  55. 	//长条型
  56. 	for (i = 0; i < 4; i++)
  57. 	{
  58. 		block[6][0].space[i][1] = 1;
  59. 	}
  60.  
  61. 	int m = 0;
  62. 	int n = 0;
  63. 	int tmp[4][4];
  64. 	for (i = 0; i < 7; i++)
  65. 	{
  66. 		block[i][0].speed = 200;//初始化下落速度
  67. 		block[i][0].blockstate = NORMAL;
  68. 	}
  69. 	for (i = 0; i < LINES; i++)
  70. 	{
  71. 		for (j = 0; j < COLS-1; j++)
  72. 		{
  73. 			for (m = 0; m < 4; m++)
  74. 			{
  75. 				for (n = 0; n < 4; n++)
  76. 				{
  77. 					tmp[m][n] = block[i][j].space[m][n];
  78. 				}
  79. 			}
  80. 			for (m = 0; m < 4; m++)
  81. 			{
  82. 				for (n = 0; n < 4; n++)
  83. 				{
  84. 					block[i][j + 1].space[n][3-m] = tmp[m][n];
  85. 				}
  86. 			}
  87. 			block[i][j + 1].speed = 200;//初始化下落速度
  88. 			block[i][j + 1].blockstate =NORMAL;//初始化方块状态
  89. 		}
  90. 	}
  91. 	
  92. }

注解： 

1）我们定义结构体二位数组，用于存储7种基本形状方块的各自的4种形态的信息，共28种。

  1. #define  COLS 4
  2. #define LINES  7
  3. enum BlockState{CHANGE,LEFT,RIGHT,DOWN,NORMAL};
  4. typedef struct Block
  5. {
  6. 	int space[4][4];
  7. 	int speed;
  8. 	enum BlockState blockstate;
  9. }Block; 
  10. Block block[LINES][COLS] ;//结构体二位数组，用于存储7种基本形状方块的各自的4种形态的信息，共28种

 2）首先初始化7种基本形状方块，然后基本形状方块通过顺时针旋转依次得到各自剩下的三种形态。

4.3  游戏运行的实现

  1. void GameRun()
  2. {
  3. 	
  4. 	int i = rand() % 7, j = rand() % 4; //随机获取方块的形状
  5. 	do
  6. 	{
  7. 		int x = 18;
  8. 		int y = 0;
  9. 		int next_i =  rand() % 7, next_j = rand() % 4;
  10. 		PrintBlock(next_i, next_j, 46, 4);//绘制提示框图形
  11. 		PrintBlock(i, j, 18, 0);//绘制方块初始位置
  12.  
  13. 		while(IsLegal(i, j, x, y ))//不合法，说明到底了
  14. 		{
  15. 			
  16. 			if (KEY_PRESS(VK_UP))
  17. 			{
  18. 				block[i][j].blockstate = CHANGE;
  19. 			}
  20. 			else if (KEY_PRESS(VK_DOWN))
  21. 			{
  22.  
  23. 				block[i][j].blockstate = DOWN;
  24. 			}
  25. 			else if (KEY_PRESS(VK_LEFT))
  26. 			{
  27. 				block[i][j].blockstate = LEFT;//左移
  28. 			}
  29. 			else if (KEY_PRESS(VK_RIGHT))
  30. 			{
  31. 				block[i][j].blockstate = RIGHT;//右移
  32. 			}
  33. 			else if (KEY_PRESS(VK_SPACE))
  34. 			{
  35. 				pause();//暂停
  36. 			}
  37. 			else if (KEY_PRESS(VK_ESCAPE))
  38. 			{
  39. 				state = END;//退出
  40. 				break;
  41. 			}
  42. 			else if (KEY_PRESS(R))
  43. 			{
  44. 				state = RESTART;//重新开始
  45. 				break;
  46. 			}
  47. 			else//什么都没按
  48. 			{
  49. 				block[i][j].blockstate = NORMAL;
  50. 			}
  51. 			BlockMove(block, &i, &j, &x,&y);
  52. 			PrintBlock(i, j, x, y);//绘制方块位置
  53. 			Sleep(block[i][j].speed);//每一帧休息的时间
  54. 		}
  55. 		i = next_i;
  56. 		j = next_j;
  57. 		PrintSpace(i,j, 46, 4);//覆盖提示框图形
  58. 	} while (state ==RUN);
  59. }

4.3.1  合法判断（碰撞检测）

  1. //碰撞检测
  2. int IsLegal(int i, int j, int x, int y)
  3. {
  4. 	for (int m = 0; m < 4; m++)
  5. 	{
  6. 		for (int n = 0; n< 4; n++)
  7. 		{
  8. 			//如果方块落下的位置本来就已经有方块了，则不合法
  9. 			if ((block[i][j].space[m][n] == 1) && (IF.pos[x + n * 2][y + m] == 1))
  10. 				return 0; //不合法
  11. 		}
  12. 	}
  13. 	return 1; //合法
  14. }

4.3.2  覆盖方块

  1. void  PrintSpace(int i, int j, int  x, int y)//覆盖指定位置方块
  2. {
  3. 	for (int m = 0; m< 4; m++)
  4. 	{
  5. 		for (int n = 0; n < 4; n++)
  6. 		{
  7. 			if (block[i][j].space[m][n] == 1)
  8. 			{
  9. 				SetPos(x+2*n,y+m); //光标跳转到指定位置
  10. 				printf("  "); //打印空格覆盖（两个空格）
  11. 			}
  12. 		}
  13. 	}
  14.  
  15. }

4.3.3  绘制方块

  1. void PrintBlock(int i, int j, int x, int y)
  2. {
  3. int m = 0;
  4. int n = 0;
  5. for (m = 0; m < 4; m++)
  6. {
  7. 	for (n = 0; n < 4; n++)
  8. 	{
  9. 		if (block[i][j].space[m][n] == 1)
  10. 		{
  11. 			//IF.pos[x+n*2][y+m] = 1;//记录该位置有方块
  12. 			SetPos(x + n * 2, y + m);
  13. 			wprintf(L"%c", BIOCK);
  14. 		}
  15. 	}
  16. }
  17. }

 4.3.4   判断满行消除

  1. int JudeIsErase()
  2. {
  3. 	int sign = 0;
  4. 	int i = 0;
  5. 	
  6. 	for (i = 28; i > 3; i--)
  7. 	{
  8. 		int count = 0;
  9. 		for (int j = 2; j < 38; j += 2)
  10. 		{
  11. 			if (IF.pos[j][i] == 1)
  12. 			{
  13. 				count++;
  14. 			}
  15. 		}
  16. 		if (count == 18)//整行全是方块
  17. 		{
  18. 			sign = 1;
  19. 			grade += 10;
  20. 			SetPos(44, 26);
  21. 			printf("当前分数：%d", grade);//更新当前分数
  22. 			for (int a = 2; a < 38; a += 2)
  23. 			{
  24. 				SetPos(a, i);
  25. 				printf("  ");
  26. 				IF.pos[a][i] = 0;
  27. 			}
  28.  
  29. 			//将该行以上全部下移一格
  30.  
  31. 			for (int m = i; m > 3; m--)
  32. 			{
  33. 				
  34. 				for (int n = 2; n < 38; n += 2)
  35. 				{
  36. 					
  37. 					IF.pos[n][m] = IF.pos[n][m - 1]; //将上一行方块移到下一行
  38.  
  39. 					if (IF.pos[n][m]==1) //上一行移下来的是方块，打印方块
  40. 					{
  41. 						SetPos(n, m); //光标跳转到该位置
  42.  
  43. 						wprintf(L"%c", BIOCK); //打印方块
  44. 					}
  45. 					else //上一行移下来的是空格，打印空格
  46. 					{
  47. 						SetPos(n, m); //光标跳转到该位置
  48. 						printf("  "); //打印空格（两个空格）
  49. 					}
  50. 				}
  51. 				
  52.  
  53. 			}
  54.  
  55. 		}
  56. 	}
  57. 	return sign;
  58.  
  59. }

注：

1)用大数组pos[60][30],从下往上判断是否满行，如果满行，则将将该行以上全部下移一格，这样就达到消行的目的

2）若第十四和第十三行都满行了，当检测到第十四行满行，将第十三行及以上全部下移一格，再次循环，从现十三行（原十二行）开始检测，此时会漏掉现十四行（原十三行），所以引进标识变量sign,只要有消行，则变为1，当sign=0时，表示全部方块没有满行了。

4.4.5   判断游戏失败

  1. void JudeIsOver()
  2. {
  3. 	for (int i = 2; i < 38; i+=2)
  4. 	{
  5. 		if (IF.pos[i][1] == 1) //第一行有方块存在
  6. 		{
  7. 			state = FAIL;
  8. 			
  9. 			
  10. 		}
  11. 	}
  12. 	
  13. }

4.4.6  方块移动

  1. void BlockMove(Block block[][COLS], int *i, int *j, int *x, int *y)
  2. {
  3. 	switch (block[*i][*j].blockstate)
  4. 	{
  5. 	case CHANGE:
  6. 		if (IsLegal(*i, ((*j) + 1) % 4, *x, (*y )+1) == 1) //判断方块变化后(变化的同时下降一格）是否碰撞
  7. 		{
  8. 			//方块旋转后合法才进行以下操作
  9. 			PrintSpace(*i, *j, *x, *y); //用空格覆盖当前方块所在位置
  10. 			(*j) = ((*j) + 1) % 4;
  11. 			(*y)++;
  12. 			
  13. 			
  14. 			//PrintBlock(i, j, x, y);//绘制下一个变化的方块
  15. 			block[*i][*j].blockstate = NORMAL;
  16. 			block[*i][*j].speed = 200;
  17. 		}
  18. 		//else //方块再下落就碰撞了（已经到达底部）
  19. 		//{
  20. 		//	//将当前方块的信息录入IF当中
  21. 		//	for (int m = 0; m< 4; m++)
  22. 		//	{
  23. 		//		for (int n = 0; n< 4; n++)
  24. 		//		{
  25. 		//			if (block[*i][*j].space[m][n] == 1)
  26. 		//			{
  27. 		//				IF.pos[(*x )+n*2][(*y )+m] = 1; //将该位置标记为有方块
  28. 		//				
  29. 		//			}
  30. 		//		}
  31. 		//	}
  32. 		//	while (JudeIsErase()); //判断此次方块下落是否得分
  33. 		//	JudeIsOver();
  34. 	
  35. 		//}
  36. 		break;
  37. 	case LEFT:
  38. 		if (IsLegal(*i, *j,(*x )-2, *y ) == 1) //判断方块左移后是否合法
  39. 		{
  40. 			//方块左移后合法才进行以下操作
  41. 			PrintSpace(*i, *j, *x, *y); //用空格覆盖当前方块所在位置
  42. 		
  43. 			(*x) = (*x) - 2;
  44. 			block[*i][*j].blockstate = NORMAL;
  45. 			block[*i][*j].speed = 200;
  46. 			
  47. 			//PrintBlock(i, j, x, y);//绘制下一个变化的方块
  48.  
  49. 		}
  50. 		break;
  51. 	case RIGHT:
  52. 		if (IsLegal(*i, *j, (*x) + 2, *y) == 1) //判断方块右移后是否合法
  53. 		{
  54. 			//方块右移后合法才进行以下操作
  55. 			PrintSpace(*i, *j, *x, *y); //用空格覆盖当前方块所在位置
  56. 			(*x) = (*x) + 2;
  57. 			block[*i][*j].blockstate = NORMAL;
  58. 			block[*i][*j].speed = 200;
  59. 			//PrintBlock(i, j, x, y);//绘制下一个变化的方块
  60.  
  61. 		}
  62. 		break;
  63. 	case DOWN:
  64. 		if (IsLegal(*i, *j,* x , (*y) + 1) == 1) //判断方块下移后是否合法
  65. 		{
  66. 			//方块下移后合法才进行以下操作
  67. 			PrintSpace(*i,* j, *x,* y); //用空格覆盖当前方块所在位置
  68. 			(*y)++;
  69. 			block[*i][*j].blockstate = NORMAL;
  70. 			if (block[*i][*j].speed>50)//避免连续按，变成负数，会出现bug
  71. 			{
  72. 				block[*i][*j].speed -= 50;
  73. 			}
  74. 			
  75.  
  76. 		}
  77. 		else //碰撞
  78. 		{
  79. 			//将当前方块的信息录入IF当中
  80.  
  81. 			for (int m = 0; m < 4; m++)
  82. 			{
  83. 				for (int n = 0; n < 4; n++)
  84. 				{
  85. 					if (block[*i][*j].space[m][n] == 1)
  86. 					{
  87. 						IF.pos[(*x) + n * 2][(*y) + m] = 1; //将该位置标记为有方块
  88.  
  89. 					}
  90. 				}
  91. 			}
  92. 			while (JudeIsErase()); //判断此次方块下落是否得分
  93. 			JudeIsOver();
  94. 		}
  95. 		break;
  96. 	case NORMAL:
  97. 		if (IsLegal(*i, *j,*x, (*y) + 1) == 1) //方块再下落合法
  98. 		{
  99.  
  100. 			//方块右移后合法才进行以下操作
  101. 			PrintSpace(*i, *j, *x,* y); //用空格覆盖当前方块所在位置
  102. 			
  103. 			(*y)++;
  104. 			block[*i][*j].blockstate = NORMAL;
  105. 			block[*i][*j].speed=200;
  106. 			
  107. 		}
  108. 		else //碰撞
  109. 		{
  110. 			//将当前方块的信息录入IF当中
  111.  
  112. 			for (int m = 0; m < 4; m++)
  113. 			{
  114. 				for (int n = 0; n < 4; n++)
  115. 				{
  116. 					if (block[*i][*j].space[m][n] == 1)
  117. 					{
  118. 						IF.pos[(*x) + n * 2][(*y) + m] = 1; //将该位置标记为有方块
  119.  
  120. 					}
  121. 				}
  122. 			}
  123. 			while (JudeIsErase()); //判断此次方块下落是否得分
  124. 			JudeIsOver();
  125. 		}
  126. 		break;
  127. 	}
  128. 	
  129. }

注：

1）这里我们根据方块状态判断方块的下一步位置和形状，需要改变参数，所以传的是地址

2）只有在正常下落和加速下落才需要描述不合法时（碰撞时）状况，因为此时已经到底了。变换方块时不需要描述不合法（碰撞时）状况（因为'L'型，在变换时容易与边界发生碰撞，若此时将方块位置记录在pos[60][30]的大数组中，导致跳出该循环，进行下一个方块判断，导致该方块悬浮在半空的BUG）

4.4   游戏结束的实现

  1. enum GameState{ RUN = 1,END,FAIL,RESTART };
  2. enum GameState state;
  3.  
  4. void GameOver()
  5. {
  6.  
  7. 	switch (state)
  8. 	{
  9. 	case END:
  10.  
  11. 		SetPos(14, 15);
  12. 		printf("您主动退出游戏\n");
  13. 		SetPos(14, 18);
  14. 		system("pause");
  15. 		break;
  16. 	case FAIL:
  17. 		Sleep(1000); //留给玩家反应时间
  18. 		system("cls"); //清空屏幕
  19. 		SetPos(20, 10);
  20. 		printf("小垃圾，游戏结束！\n");
  21. 		SetPos(20, 14);
  22. 		printf("你的最终得分为: %d ", grade);
  23. 		SetPos(20, 18);
  24. 		system("pause");
  25. 		break;
  26. 	case RESTART:
  27. 		system("cls"); //清空屏幕
  28. 		SetPos(26, 10);
  29. 		printf("重新开始!\n");
  30. 		SetPos(22, 14);
  31. 		printf("小垃圾，你准备好了吗？\n");
  32. 		Sleep(2000);
  33. 		main();
  34. 		break;
  35. 	}
  36. }

注：

1）对游戏的三个状态分别进行描述。

五、完整代码

5.1   tetris.h

  1. #include<Windows.h>
  2. #include <locale.h>
  3. #include<stdbool.h>
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<time.h>
  7. #include<windows.h>
  8. #define WALL  L'□'
  9. #define BIOCK  L'■' 
  10. #define  COLS 4
  11. #define LINES  7
  12. #define R 0x52	
  13. #define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&0x1) ? 1 : 0)
  14. enum GameState{ RUN = 1,END,FAIL,RESTART };
  15. enum GameState state;
  16.  
  17. enum BlockState{CHANGE,LEFT,RIGHT,DOWN,NORMAL};
  18. int grade;
  19. typedef struct InterFace
  20. {
  21. 	int pos[60][30]; //用于标记整个界面有方块的位置（1为有，0为无）
  22. 	
  23. }InterFace;
  24.  
  25. InterFace IF;
  26. typedef struct Block
  27. {
  28. 	int space[4][4];
  29. 	int speed;
  30. 	enum BlockState blockstate;
  31. }Block; 
  32. Block block[LINES][COLS] ;//结构体二位数组，用于存储7种基本形状方块的各自的4种形态的信息，共28种
  33. void GameInit();
  34. void CreateMap();
  35. void InitBlockInfo();
  36. void GameRun();
  37. void PrintBlock(int i,int j,int x,int y);//ij 为方块形状，x,y为打印坐标
  38. void BlockMove(Block block[][COLS], int *i, int *j, int *x, int *y);
  39. void  PrintSpace(int i, int j, int  x, int y);
  40. int JudeIsErase();
  41. void JudeIsOver();
  42. void GameOver();

5.2   tetris.c

  1. #include"tetris.h"
  2.  
  3. //设置光标的坐标
  4. void SetPos(short x, short y)
  5. {
  6. 	COORD pos = { x, y };
  7. 	HANDLE hOutput = NULL;
  8. 	//获取标准输出的句柄(⽤来标识不同设备的数值)
  9. 	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  10. 	//设置标准输出上光标的位置为pos
  11. 	SetConsoleCursorPosition(hOutput, pos);
  12. 	
  13. }
  14. void WelcomeToGame()
  15. {
  16. 	SetPos(20, 10);
  17. 	printf("欢迎来到俄罗斯方块！");
  18. 	SetPos(20, 23);//让按任意键继续的出现的位置好看点
  19. 	system("pause");
  20. 	system("cls");
  21. 	SetPos(14, 10);
  22. 	printf("↑为变换.↓为加速.←为左移.→为右移\n");
  23. 	
  24. 	SetPos(20, 23);//让按任意键继续的出现的位置好看点
  25. 	system("pause");
  26. 	system("cls");
  27. }
  28. void CreateMap()
  29. {
  30. 	memset(IF.pos, 0, sizeof(int)*30*60);//对数组初始化(如果不初始化，FAIL后第二次循环会IF.pos会保留上次数据）
  31. 	int i = 0;
  32. 	//墙体轮廓
  33. 	SetPos(40, 0);
  34. 	for (i = 40; i < 60; i += 2)
  35. 	{
  36. 		
  37. 		wprintf(L"%lc", WALL);
  38. 	}
  39. 	SetPos(0,29);
  40. 	for (i = 0; i < 60; i += 2)
  41. 	{
  42. 		IF.pos[i][29] = 1;
  43. 		wprintf(L"%lc", WALL);
  44. 	}
  45. 	//x是0，y从1开始增⻓
  46. 	for (i = 0; i < 30; i++)
  47. 	{
  48. 		IF.pos[0][i] = 1;//标记此处有方块
  49. 		SetPos(0, i);
  50. 		wprintf(L"%c", WALL);
  51. 	}
  52. 	
  53. 	for (i = 0; i < 30; i++)
  54. 	{
  55. 		IF.pos[38][i] = 1;
  56. 		SetPos(38, i);
  57. 		wprintf(L"%c", WALL);
  58. 	}
  59. 	for (i = 0; i < 30; i++)
  60. 	{
  61. 		IF.pos[58][i] = 1;
  62. 		SetPos(58, i);
  63. 		wprintf(L"%c", WALL);
  64. 	}
  65. 	SetPos(40, 10);
  66. 	for (i = 40; i < 60; i += 2)
  67. 	{
  68. 		IF.pos[i][10] = 1;
  69. 		wprintf(L"%lc", WALL);
  70. 	}
  71. 	//提示字体
  72. 	SetPos(40, 1);
  73. 	printf("下一个方块：");
  74.  
  75. 	SetPos(44, 12);
  76. 	printf("左移：←");
  77.  
  78. 	SetPos(44, 14);
  79. 	printf("右移：→");
  80.  
  81. 	SetPos(44, 16);
  82. 	printf("加速：↓");
  83.  
  84. 	SetPos(44, 18);
  85. 	printf("变换：↑");
  86.  
  87. 	SetPos(44, 20);
  88. 	printf("暂停: 空格");
  89.  
  90. 	SetPos(44, 22);
  91. 	printf("退出: Esc");
  92.  
  93. 	SetPos(44, 24);
  94. 	printf("重新开始:R");
  95.  
  96. 	/*SetPos(44, 26);
  97. 	printf("最高纪录:%d", max);*/
  98.  
  99. 	SetPos(44, 26);
  100. 	printf("当前分数：%d", grade);
  101.  
  102. 	/*getchar();*/
  103.  
  104. }
  105. void InitBlockInfo()
  106. {
  107. 	//'T'字型
  108. 	int i = 0;
  109. 	for (i = 0; i < 3; i++)
  110. 	{
  111. 		block[0][0].space[1][i] = 1;
  112. 	}
  113. 	block[0][0].space[2][1] = 1;
  114. 	
  115. 	//‘L'字型
  116. 	for (i = 1; i < 4; i++)
  117. 	{
  118. 		block[1][0].space[i][1] = 1;
  119. 	}
  120. 	block[1][0].space[3][2] = 1;
  121.  
  122. 	//'J'字形
  123. 	for (i = 1; i < 4; i++)
  124. 	{
  125. 		block[2][0].space[i][2] = 1;
  126. 	}
  127. 	block[2][0].space[3][1] = 1;
  128.  
  129. 	//’Z'字型
  130. 	for (i = 0; i < 2; i++)
  131. 	{
  132. 		block[3][0].space[1][i] = 1;
  133. 	}
  134. 	for (i = 1; i < 3; i++)
  135. 	{
  136. 		block[3][0].space[2][i] = 1;
  137. 	}
  138.  
  139. 	//‘S'字型
  140. 	for (i = 1; i < 3; i++)
  141. 	{
  142. 		block[4][0].space[1][i] = 1;
  143. 	}
  144. 	for (i = 0; i < 2; i++)
  145. 	{
  146. 		block[4][0].space[2][i] = 1;
  147. 	}
  148.  
  149. 	//'田’字型
  150. 	int j = 0;
  151. 	for (i = 1; i < 3; i++)
  152. 	{
  153. 		for (j = 1; j < 3; j++)
  154. 		{
  155. 			block[5][0].space[i][j] = 1;
  156. 		}
  157. 	}
  158.  
  159. 	//长条型
  160. 	for (i = 0; i < 4; i++)
  161. 	{
  162. 		block[6][0].space[i][1] = 1;
  163. 	}
  164.  
  165. 	int m = 0;
  166. 	int n = 0;
  167. 	int tmp[4][4];
  168. 	for (i = 0; i < 7; i++)
  169. 	{
  170. 		block[i][0].speed = 200;//初始化下落速度
  171. 		block[i][0].blockstate = NORMAL;
  172. 	}
  173. 	for (i = 0; i < LINES; i++)
  174. 	{
  175. 		for (j = 0; j < COLS-1; j++)
  176. 		{
  177. 			for (m = 0; m < 4; m++)
  178. 			{
  179. 				for (n = 0; n < 4; n++)
  180. 				{
  181. 					tmp[m][n] = block[i][j].space[m][n];
  182. 				}
  183. 			}
  184. 			for (m = 0; m < 4; m++)
  185. 			{
  186. 				for (n = 0; n < 4; n++)
  187. 				{
  188. 					block[i][j + 1].space[n][3 - m] = tmp[m][n];
  189. 				}
  190. 			}
  191. 			block[i][j + 1].speed = 200;//初始化下落速度
  192. 			block[i][j + 1].blockstate =NORMAL;//初始化方块状态
  193. 		}
  194. 	}
  195. 	
  196. }
  197.  
  198. void GameInit()
  199. {
  200. 	//设置控制台窗⼝的⼤⼩，30⾏，30列
  201. 	system("mode con cols=60 lines=30");
  202. 	//设置cmd窗⼝名称
  203. 	system("title  俄罗斯方块");
  204. 	//获取标准输出的句柄(⽤来标识不同设备的数值)
  205. 	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  206. 	//影藏光标操作
  207. 	CONSOLE_CURSOR_INFO CursorInfo;
  208. 	GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
  209. 	CursorInfo.bVisible = false; //隐藏控制台光标
  210. 	SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态
  211. 	//打印欢迎界⾯
  212. 	WelcomeToGame();
  213. 	//初始化地图
  214. 	CreateMap();
  215. 	//初始化方块信息
  216. 	InitBlockInfo();
  217. 	//初始化游戏状态
  218. 	state = RUN;
  219. }
  220. void PrintBlock(int i, int j, int x, int y)
  221. {
  222. int m = 0;
  223. int n = 0;
  224. for (m = 0; m < 4; m++)
  225. {
  226. 	for (n = 0; n < 4; n++)
  227. 	{
  228. 		if (block[i][j].space[m][n] == 1)
  229. 		{
  230. 			//IF.pos[x+n*2][y+m] = 1;//记录该位置有方块
  231. 			SetPos(x + n * 2, y + m);
  232. 			wprintf(L"%c", BIOCK);
  233. 		}
  234. 	}
  235. }
  236. }
  237. void pause()//暂停
  238. {
  239. 	while (1)
  240. 	{
  241. 		Sleep(300);
  242. 		if (KEY_PRESS(VK_SPACE))
  243. 		{
  244. 			break;
  245. 		}
  246. 	}
  247. }
  248. //碰撞检测
  249. int IsLegal(int i, int j, int x, int y)
  250. {
  251. 	for (int m = 0; m < 4; m++)
  252. 	{
  253. 		for (int n = 0; n< 4; n++)
  254. 		{
  255. 			//如果方块落下的位置本来就已经有方块了，则不合法
  256. 			if ((block[i][j].space[m][n] == 1) && (IF.pos[x + n * 2][y + m] == 1))
  257. 				return 0; //不合法
  258. 		}
  259. 	}
  260. 	return 1; //合法
  261. }
  262. void  PrintSpace(int i, int j, int  x, int y)//覆盖指定位置方块
  263. {
  264. 	for (int m = 0; m< 4; m++)
  265. 	{
  266. 		for (int n = 0; n < 4; n++)
  267. 		{
  268. 			if (block[i][j].space[m][n] == 1)
  269. 			{
  270. 				SetPos(x+2*n,y+m); //光标跳转到指定位置
  271. 				printf("  "); //打印空格覆盖（两个空格）
  272. 			}
  273. 		}
  274. 	}
  275.  
  276. }
  277. int JudeIsErase()
  278. {
  279. 	int sign = 0;
  280. 	int i = 0;
  281. 	
  282. 	for (i = 28; i > 3; i--)
  283. 	{
  284. 		int count = 0;
  285. 		for (int j = 2; j < 38; j += 2)
  286. 		{
  287. 			if (IF.pos[j][i] == 1)
  288. 			{
  289. 				count++;
  290. 			}
  291. 		}
  292. 		if (count == 18)//整行全是方块
  293. 		{
  294. 			sign = 1;
  295. 			grade += 10;
  296. 			SetPos(44, 26);
  297. 			printf("当前分数：%d", grade);//更新当前分数
  298. 			for (int a = 2; a < 38; a += 2)
  299. 			{
  300. 				SetPos(a, i);
  301. 				printf("  ");
  302. 				IF.pos[a][i] = 0;
  303. 			}
  304.  
  305. 			//将该行以上全部下移一格
  306.  
  307. 			for (int m = i; m > 3; m--)
  308. 			{
  309. 				
  310. 				for (int n = 2; n < 38; n += 2)
  311. 				{
  312. 					
  313. 					IF.pos[n][m] = IF.pos[n][m - 1]; //将上一行方块移到下一行
  314.  
  315. 					if (IF.pos[n][m]==1) //上一行移下来的是方块，打印方块
  316. 					{
  317. 						SetPos(n, m); //光标跳转到该位置
  318.  
  319. 						wprintf(L"%c", BIOCK); //打印方块
  320. 					}
  321. 					else //上一行移下来的是空格，打印空格
  322. 					{
  323. 						SetPos(n, m); //光标跳转到该位置
  324. 						printf("  "); //打印空格（两个空格）
  325. 					}
  326. 				}
  327. 				
  328.  
  329. 			}
  330.  
  331. 		}
  332. 	}
  333. 	return sign;
  334.  
  335. }
  336. void JudeIsOver()
  337. {
  338. 	for (int i = 2; i < 38; i+=2)
  339. 	{
  340. 		if (IF.pos[i][1] == 1) //第一行有方块存在
  341. 		{
  342. 			state = FAIL;
  343. 			
  344. 			
  345. 		}
  346. 	}
  347. 	
  348. }
  349.  
  350. void BlockMove(Block block[][COLS], int *i, int *j, int *x, int *y)
  351. {
  352. 	switch (block[*i][*j].blockstate)
  353. 	{
  354. 	case CHANGE:
  355. 		if (IsLegal(*i, ((*j) + 1) % 4, *x, (*y )+1) == 1) //判断方块变化后(变化的同时下降一格）是否碰撞
  356. 		{
  357. 			//方块旋转后合法才进行以下操作
  358. 			PrintSpace(*i, *j, *x, *y); //用空格覆盖当前方块所在位置
  359. 			(*j) = ((*j) + 1) % 4;
  360. 			(*y)++;
  361. 			
  362. 			
  363. 			//PrintBlock(i, j, x, y);//绘制下一个变化的方块
  364. 			block[*i][*j].blockstate = NORMAL;
  365. 			block[*i][*j].speed = 200;
  366. 		}
  367. 		//else //方块再下落就碰撞了（已经到达底部）
  368. 		//{
  369. 		//	//将当前方块的信息录入IF当中
  370. 		//	for (int m = 0; m< 4; m++)
  371. 		//	{
  372. 		//		for (int n = 0; n< 4; n++)
  373. 		//		{
  374. 		//			if (block[*i][*j].space[m][n] == 1)
  375. 		//			{
  376. 		//				IF.pos[(*x )+n*2][(*y )+m] = 1; //将该位置标记为有方块
  377. 		//				
  378. 		//			}
  379. 		//		}
  380. 		//	}
  381. 		//	while (JudeIsErase()); //判断此次方块下落是否得分
  382. 		//	JudeIsOver();
  383. 	
  384. 		//}
  385. 		break;
  386. 	case LEFT:
  387. 		if (IsLegal(*i, *j,(*x )-2, *y ) == 1) //判断方块左移后是否合法
  388. 		{
  389. 			//方块左移后合法才进行以下操作
  390. 			PrintSpace(*i, *j, *x, *y); //用空格覆盖当前方块所在位置
  391. 		
  392. 			(*x) = (*x) - 2;
  393. 			block[*i][*j].blockstate = NORMAL;
  394. 			block[*i][*j].speed = 200;
  395. 			
  396. 			//PrintBlock(i, j, x, y);//绘制下一个变化的方块
  397.  
  398. 		}
  399. 		break;
  400. 	case RIGHT:
  401. 		if (IsLegal(*i, *j, (*x) + 2, *y) == 1) //判断方块右移后是否合法
  402. 		{
  403. 			//方块右移后合法才进行以下操作
  404. 			PrintSpace(*i, *j, *x, *y); //用空格覆盖当前方块所在位置
  405. 			(*x) = (*x) + 2;
  406. 			block[*i][*j].blockstate = NORMAL;
  407. 			block[*i][*j].speed = 200;
  408. 			//PrintBlock(i, j, x, y);//绘制下一个变化的方块
  409.  
  410. 		}
  411. 		break;
  412. 	case DOWN:
  413. 		if (IsLegal(*i, *j,* x , (*y) + 1) == 1) //判断方块下移后是否合法
  414. 		{
  415. 			//方块下移后合法才进行以下操作
  416. 			PrintSpace(*i,* j, *x,* y); //用空格覆盖当前方块所在位置
  417. 			(*y)++;
  418. 			block[*i][*j].blockstate = NORMAL;
  419. 			if (block[*i][*j].speed>50)//避免连续按，变成负数，会出现bug
  420. 			{
  421. 				block[*i][*j].speed -= 50;
  422. 			}
  423. 			
  424.  
  425. 		}
  426. 		else //碰撞
  427. 		{
  428. 			//将当前方块的信息录入IF当中
  429.  
  430. 			for (int m = 0; m < 4; m++)
  431. 			{
  432. 				for (int n = 0; n < 4; n++)
  433. 				{
  434. 					if (block[*i][*j].space[m][n] == 1)
  435. 					{
  436. 						IF.pos[(*x) + n * 2][(*y) + m] = 1; //将该位置标记为有方块
  437.  
  438. 					}
  439. 				}
  440. 			}
  441. 			while (JudeIsErase()); //判断此次方块下落是否得分
  442. 			JudeIsOver();
  443. 		}
  444. 		break;
  445. 	case NORMAL:
  446. 		if (IsLegal(*i, *j,*x, (*y) + 1) == 1) //方块再下落合法
  447. 		{
  448.  
  449. 			//方块右移后合法才进行以下操作
  450. 			PrintSpace(*i, *j, *x,* y); //用空格覆盖当前方块所在位置
  451. 			
  452. 			(*y)++;
  453. 			block[*i][*j].blockstate = NORMAL;
  454. 			block[*i][*j].speed=200;
  455. 			
  456. 		}
  457. 		else //碰撞
  458. 		{
  459. 			//将当前方块的信息录入IF当中
  460.  
  461. 			for (int m = 0; m < 4; m++)
  462. 			{
  463. 				for (int n = 0; n < 4; n++)
  464. 				{
  465. 					if (block[*i][*j].space[m][n] == 1)
  466. 					{
  467. 						IF.pos[(*x) + n * 2][(*y) + m] = 1; //将该位置标记为有方块
  468.  
  469. 					}
  470. 				}
  471. 			}
  472. 			while (JudeIsErase()); //判断此次方块下落是否得分
  473. 			JudeIsOver();
  474. 		}
  475. 		break;
  476. 	}
  477. 	
  478. }
  479.  
  480. void GameRun()
  481. {
  482. 	
  483. 	int i = rand() % 7, j = rand() % 4; //随机获取方块的形状
  484. 	do
  485. 	{
  486. 		int x = 18;
  487. 		int y = 0;
  488. 		int next_i =  rand() % 7, next_j = rand() % 4;
  489. 		PrintBlock(next_i, next_j, 46, 4);//绘制提示框图形
  490. 		PrintBlock(i, j, 18, 0);//绘制方块初始位置
  491.  
  492. 		while(IsLegal(i, j, x, y ))//不合法，说明到底了
  493. 		{
  494. 			
  495. 			if (KEY_PRESS(VK_UP))
  496. 			{
  497. 				block[i][j].blockstate = CHANGE;
  498. 			}
  499. 			else if (KEY_PRESS(VK_DOWN))
  500. 			{
  501.  
  502. 				block[i][j].blockstate = DOWN;
  503. 			}
  504. 			else if (KEY_PRESS(VK_LEFT))
  505. 			{
  506. 				block[i][j].blockstate = LEFT;//左移
  507. 			}
  508. 			else if (KEY_PRESS(VK_RIGHT))
  509. 			{
  510. 				block[i][j].blockstate = RIGHT;//右移
  511. 			}
  512. 			else if (KEY_PRESS(VK_SPACE))
  513. 			{
  514. 				pause();//暂停
  515. 			}
  516. 			else if (KEY_PRESS(VK_ESCAPE))
  517. 			{
  518. 				state = END;//退出
  519. 				break;
  520. 			}
  521. 			else if (KEY_PRESS(R))
  522. 			{
  523. 				state = RESTART;//重新开始
  524. 				break;
  525. 			}
  526. 			else//什么都没按
  527. 			{
  528. 				block[i][j].blockstate = NORMAL;
  529. 			}
  530. 			BlockMove(block, &i, &j, &x,&y);
  531. 			PrintBlock(i, j, x, y);//绘制方块位置
  532. 			Sleep(block[i][j].speed);//每一帧休息的时间
  533. 		}
  534. 		i = next_i;
  535. 		j = next_j;
  536. 		PrintSpace(i,j, 46, 4);//覆盖提示框图形
  537. 	} while (state ==RUN);
  538. }
  539. void GameOver()
  540. {
  541.  
  542. 	switch (state)
  543. 	{
  544. 	case END:
  545.  
  546. 		SetPos(14, 15);
  547. 		printf("您主动退出游戏\n");
  548. 		SetPos(14, 18);
  549. 		system("pause");
  550. 		break;
  551. 	case FAIL:
  552. 		Sleep(1000); //留给玩家反应时间
  553. 		system("cls"); //清空屏幕
  554. 		SetPos(20, 10);
  555. 		printf("小垃圾，游戏结束！\n");
  556. 		SetPos(20, 14);
  557. 		printf("你的最终得分为: %d ", grade);
  558. 		SetPos(20, 18);
  559. 		system("pause");
  560. 		break;
  561. 	case RESTART:
  562. 		system("cls"); //清空屏幕
  563. 		SetPos(26, 10);
  564. 		printf("重新开始!\n");
  565. 		SetPos(22, 14);
  566. 		printf("小垃圾，你准备好了吗？\n");
  567. 		Sleep(2000);
  568. 		main();
  569. 		break;
  570. 	}
  571. }

5.3  test.c

  1. #include"tetris.h"
  2.  
  3. int main()
  4. {
  5. 	//修改当前地区为本地模式，为了⽀持中⽂宽字符的打印
  6. 	setlocale(LC_ALL, "");
  7. 	srand((unsigned int)time(NULL));
  8. 	char ch=0;
  9. 	do
  10. 	{
  11. 		GameInit();
  12. 		GameRun();
  13. 		GameOver();
  14. 		system("cls");
  15. 		SetPos(20, 12);
  16. 		printf("再来一局吗？(Y/N):\n");
  17. 		SetPos(22, 15);
  18. 		ch = getchar();
  19. 		
  20. 		getchar();//清理\n
  21. 	} while (ch == 'y' || ch == 'Y');
  22. 	SetPos(0, 29);
  23. 	
  24. 	return 0;
  25. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/641187
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号