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

C语言简易小游戏实现—2048_2048小游戏代码

作者：繁依Fanyi0 | 2024-06-11 05:59:44

赞

踩

2048小游戏代码

一、概述

2048小游戏是一款休闲益智类小游戏，游戏在一个4×4的方格上进行，在这里会不断产生方块，方块的初始值为2，玩家通过合并、消除方块使得方块的数值越来越大，最终合成2048的方块来获取胜利，游戏的核心功能逻辑简单易实现，通过C语言的函数功能，同时配合easyx图形库美化游戏界面，一个简单的2048小游戏即可实现。

二、各部分功能实现

对主要功能进行分析后，将其分成了六个函数如下：

1. 随机数产生函数

用于产生整数2或4，这里设置产生2的概率为90%，产生4的概率为10%

  1. void createNum()
  2. {
  3. 	while (1)
  4. 	{
  5. 		int ret = 0;
  6. 		int x = rand() % MAX_SIZE;   //创建一个随机数对MAX_SIZE 取余结果坐标为0，1，2，3
  7. 		int y = rand() % MAX_SIZE;   //创建一个随机数对MAX_SIZE 取余结果坐标为0，1，2，3
  8. 		if (map[x][y] == 0) {     //查看随机的坐标是否等于0
  9. 			if (rand() % 10 == 1)    //判断随机数取10余数是否为1，来限制4出现的几率为10%
  10. 			{
  11. 				map[x][y] = 4;
  12. 			}
  13. 			else
  14. 			{
  15. 				map[x][y] = 2;    //否则2出现的几率为90%  
  16. 			}
  17. 			break;
  18. 		}
  19. 	}
  20. }
2. 游戏初始化函数

初始化游戏，重置游戏方格区域的数据，并在两个随机位置产生2或4，概率同上，由此不难发现，该函数只需要在重置方格数据和生成两个随机位置后，调用以上随机数产生函数即可

  1. void gameInit()
  2. {
  3. 	for (int i = 0; i < MAX_SIZE; i++) {
  4. 		for (int j = 0; j < MAX_SIZE; j++) {
  5. 			map[i][j] = 0; //遍历所有方格并初始化为0
  6. 		}
  7. 	}
  8. 	score = 0; //得分初始化为0
  9. 	//设置随机数种子
  10. 	srand(GetTickCount());
  11. 	createNum();
  12. 	createNum();
  13. }
3. 游戏界面函数（核心）

由于应用了easyx图形库，因此该函数的主要功能就是使用easy图形库的各种命令来优化图形界面，例如打印界面，设置各个区域以及不同数值方块相对应的颜色，打印得分区域和新游戏按钮等

  1. void gameView()
  2. {
  3. 	//打印方格、设置颜色、打印方格值
  4. 	for (int i = 0; i < MAX_SIZE; i++) {      //遍历所以格子起点
  5. 		for (int j = 0; j < MAX_SIZE; j++) {     //遍历所以格子起点
  6. 			int x = j * GRID_W + (j + 1) * INTERVAL;    //起点X坐标
  7. 			int y = i * GRID_W + (i + 1) * INTERVAL;    //起点y坐标 
  8. 			int index = (int)log2((double)map[i][j]);
  9. 			if (map[i][j] == 0) {         //判断当前格子的数字是否为0
  10. 				COLORREF gcolor = arr[0];    //若为0赋值数组中颜色
  11. 				setfillcolor(gcolor); //设置空方格时的颜色
  12. 				solidroundrect(x, y, x + GRID_W, y + GRID_W, 5, 5);  //创建空方格
  13. 			}
  14. 			else { 	               //除方格值为0时，其余情况下打印值
  15. 				COLORREF gcolor = arr[index];
  16. 				setfillcolor(gcolor); //设置不同方格值时的颜色
  17. 				solidroundrect(x, y, x + GRID_W, y + GRID_W, 5, 5);  //创建不同颜色的方格
  18. 				settextstyle(50, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0);   //更改文字颜色大小
  19. 				if (map[i][j] < 8)  settextcolor(RGB(119, 110, 101));    //设置16以下文字的颜色
  20. 				else  settextcolor(WHITE);                             //16以上文字的颜色
  21. 				char snum[10] = "";   //创建一维数组
  22. 				sprintf(snum, "%d", map[i][j]);   //将数字转化成字符串
  23. 				int ntw = textwidth(snum);    //求输出的字的宽
  24. 				int nth = textheight(snum);   //求输出的字的高
  25. 				outtextxy(x + (100 - ntw) / 2, y + (100 - nth) / 2, snum);   //将文字输出
  26. 				//绘制方格值     
  27. 			}
  28. 		}
  29. 	}
  30. 	//将得分转化为字符串打印在得分板上
  31. 	char sscore[10];             //创建数组
  32. 	sprintf(sscore, "%d", score);   //将数字转化成字符串
  33. 	int stw = textwidth(sscore);
  34. 	int sth = textheight(sscore);//数字的宽
  35. 	settextstyle(30, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0);  //设置分数的大小的字体
  36. 	settextcolor(WHITE);    //分数的颜色
  37. 	setbkmode(TRANSPARENT);    //透明背景
  38. 	//将分数打印至得分板区域
  39. 	RECT r = { 530, 65, 670, 100 };
  40. 	HRGN rgn = CreateRectRgn(530, 65, 670, 100); 
  41. 	setcliprgn(rgn); //设置裁剪区
  42. 	clearcliprgn(); //每轮结束后，清空裁减区，重新打印分数（避免分数打印堆积）
  43. 	setcliprgn(NULL);
  44. 	drawtext(sscore, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE); //在对应区域打印分数
  45. }
4. 移动函数（核心）

游戏的核心逻辑部分，接收到玩家的键盘指令后，需要做出相对应的移动逻辑，并且根据方格区域不同的情况要做出不同的反应。例如所要移动的方向上无相同值方块可合并所有方块都到达边界无法前进，此时做出的回应是不执行任何命令，等待下一个键盘指令；而前方若有可合并方块，则需要改变前方可合并方块的数值，使其翻倍，并使得距离所要移动方向更远的方块消失，而若方块朝向索要移动的方向上无其他方块，则需使其向着该方向移动至边界，而若同一行内有三或四个相同数值的方块，则需要先从靠近所移动方向的一侧开始遍历合并，并且每个方块每回合只能合并一次，合并后还需要继续前进直到遇到其他方块或边界，为此，将移动部分拆分为四个函数，根据不同情况产生不同的指令，其根本逻辑都是一样的，只是跟据移动方向的不同会改变遍历的初始位置和方向，此处只展示上移函数，其余移动函数请见完整代码部分

  1. void moveUp()
  2. {
  3. 	bool isMoved = 0;	//是否移动成功
  4. 	for (int i = 0; i < MAX_SIZE; i++)	//遍历列
  5. 	{
  6. 		int now = 0;//标尺位，每一列遍历时都将标尺位调至第一行
  7. 		for (int next = 1; next < MAX_SIZE; next++)	//遍历行，next是now后面的数字
  8. 		{
  9. 			//判断next处是不是0，意思就是除了第一行其他位置是否有数字存在
  10. 			if (map[next][i] != 0)//next处不是0
  11. 			{
  12. 				if (map[now][i] == 0)//出现数字的前方路径上全是0
  13. 				{
  14. 					map[now][i] = map[next][i];//将第一行变成该数字，
  15. 					map[next][i] = 0;//该数字原本的位置置为0
  16. 					isMoved = 1;//成功移动数字，随机在空格位置刷新2或4
  17. 				}
  18. 				else if (map[now][i] == map[next][i])//顺序遍历，标尺位数字和出现数字相同，且中间路径上没有数字
  19. 				{
  20. 					map[now][i] *= 2;//将数字合并，标尺位数字变为原来的二倍
  21. 					score += map[now][i];//方块合成后的得分
  22. 					map[next][i] = 0;//释放原来的数字
  23. 					now++;//标尺位向后一行
  24. 					isMoved = 1;//成功移动数字，随机在空格处刷新2或4
  25. 				}
  26. 				else//标尺位和数字不相等，那就将数字移动到标尺位的后一行，如果本身就在标尺位的后一行，依然可以赋值，但不删除原位置
  27. 				{
  28. 					map[now + 1][i] = map[next][i];//将与标尺位不相同的数字移动到标尺位的后一行
  29. 					if (now + 1 != next)//如果数字就在标尺位的后一行，他俩相邻，就不用执行这一步，因为now+1和next原本就是一个位置他俩原本的数字就相等
  30. 						//如果数字和标尺位中间有空格，就要执行这一步，因为原本的now+1是0，而next原本的数字是一个不为0的数，他俩不相等，要执行这一步进行 next原本位置的删除
  31. 					{
  32. 						map[next][i] = 0;//删除
  33. 						isMoved = 1;//成功移动数字刷新2或4
  34. 					}
  35. 					now++;//标尺位向后一行
  36. 				}
  37. 			}
  38. 		}
  39. 	}
  40. 	if (isMoved)
  41. 	{
  42. 		createNum(); //判定是否产生了移动，若是，则随机空白位置生成一个整数2或4
  43. 	}
  44. 	gameView();  //打印一次游戏界面
  45. }
5. 胜负判定函数

根据当前方格区域的方块数值分布情况来确定胜利或失败，若生成了2048的方块，则游戏胜利，返回数值1；若方格填满且所有方块无法继续合并免责判定游戏失败，返回数值2；否则判定胜负未定，返回数值3；若胜负已定，则会调用胜利/失败界面函数

  1. int isWin()
  2. {
  3. 	int ret = 2; //定义判别变量，初始状态为失败
  4. 	for (int i = 0; i < MAX_SIZE; i++)  //循环遍历每个数字  
  5. 	{
  6. 		for (int j = 0; j < MAX_SIZE; j++)
  7. 		{
  8. 			if (map[i][j] == 2048) {
  9. 				ret = 1;
  10. 				break;
  11. 			}  //如果有数字2048，改变判别变量，判定为胜利，终中断循环
  12. 			if (map[i][j] == 0) {
  13. 				ret = 0;
  14. 				break;
  15. 			}  //如果还有空方格，说明此时仍可移动，改变判别变量，判定为胜负未定，终止循环
  16. 			if (map[i][j] == map[i][j + 1] || map[i][j] == map[i + 1][j]) {
  17. 				if (i < 3 && j < 3) {
  18. 					ret = 0;
  19. 					break;
  20. 				}
  21. 			}
  22. 			if (i == 3 && j != 3 && map[i][j] == map[i][j + 1]) {
  23. 				ret = 0;
  24. 				break;
  25. 			}
  26. 			if (j == 3 && i != 3 && map[i][j] == map[i + 1][j]) {
  27. 				ret = 0;
  28. 				break;
  29. 			}  //如果在不符合前两个if的情形下，且对任意在游戏区域内的方块，其右侧和下侧的方块至少有一个与其相等，则改变判别变量判定为胜负未定，中断循环
  30. 		}
  31. 	}
  32. 	return ret; //否则判定游戏失败
  33. }
6. 胜利/失败界面函数

根据胜负判定函数的返回值来打印游戏胜利/失败界面

  1. void winOrLoseView(int det)
  2. {
  3. 	//接收isWin返回的参数，若为1打印胜利字样，为2打印失败字样
  4. 	HWND window = GetHWnd();          //获取窗口句柄
  5. 	if (det == 1)     //胜利判定
  6. 	{
  7. 		MessageBox(window, "You won the game!", "提示", MB_OK);  //打印提示
  8. 		gameInit();  //新开始游戏
  9. 	}
  10. 	else if (det == 2)
  11. 	{   //失败判定
  12. 		MessageBox(window, "Game over!", "提示", MB_OK);  //打印提示
  13. 		gameInit();  //新开始游戏
  14. 	}
  15. }
7. 定义主函数
  1. int main(void)
  2. {
  3. 	//创建游戏窗口，尺寸为500 * 700
  4. 	initgraph(GAME_ZONE + 200, GAME_ZONE);    //创建游戏窗口
  5. 	//设置背景（方格间距）颜色  
  6.  
  7. 	setbkmode(TRANSPARENT);      //设置窗口为透明色
  8. 	setbkcolor(INTERVRL_COLOR);   //设置背景颜色
  9. 	cleardevice();     //清除背景
  10. 	//打印游戏右侧区域并设置颜色
  11. 	setfillcolor(RIGHT_RECTANGLE);    //设置矩形填充颜色
  12. 	solidrectangle(GAME_ZONE, 0, GAME_ZONE + 200, GAME_ZONE);     //创建游戏额外区域的矩形
  13. 	//打印并设置积分板颜色，并打印对应字体
  14. 	setfillcolor(SCORE_COLOR);             //设置游戏界面右侧的颜色
  15. 	solidroundrect(530, 40, 670, 100, 5, 5); //得分板的左上和右下坐标分别为(530，40), (670，100)   创建得分板
  16. 	settextcolor(RGB(238, 228, 218));        //设置字体颜色
  17. 	settextstyle(30, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0); //设置文字大小和字体
  18. 	outtextxy(565, 40, "SCORE");      //出入文字
  19. 	//打印New Gme按钮以及字体并设置字体颜色和格式
  20. 	setfillcolor(NEWGAME_COLOR);          //设置新游戏按钮区域背景颜色
  21. 	solidroundrect(525, 160, 675, 210, 5, 5); //New Game区域的左上和右下坐标分别为(525，160), (675，210)       
  22. 	int btw = textwidth("New Game");     //文字宽距离按钮居中更多距离
  23. 	int bth = textheight("New Game");    //文字高距离按钮居中更多距离
  24. 	settextcolor(WHITE);   //设置文字颜色为白色
  25. 	settextstyle(30, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0);    //设置文字的字体和大小
  26. 	outtextxy(525 + (150 - btw) / 2, 160 + (50 - bth) / 2, "New Game");  //将文字居中放在矩形中
  27. 	gameInit();
  28. 	gameView();    //调用函数
  29. 	ExMessage m; //定义接收键鼠输入的变量
  30.  
  31. 	//开始游戏，置于恒定循环内
  32. 	BeginBatchDraw(); //开始批量绘图，防止游戏过程中闪屏
  33. 	while (1)
  34. 	{
  35. 		gameView();
  36. 		//每轮开始时，进行一次胜负判定，若胜负未定则继续游戏，否则调用胜利/失败界面函数
  37. 		int det = isWin();
  38. 		if (det != 0) winOrLoseView(det);
  39. 		//接收键鼠输入
  40. 		m = getmessage(EX_MOUSE | EX_KEY);
  41. 		switch (m.message)
  42. 		{
  43. 		case WM_KEYDOWN: //如果键盘输入wasd或上下左右键，则做出相对应移动指令
  44. 			if (m.vkcode == VK_UP || m.vkcode == 'w' || m.vkcode == 'W') moveUp();
  45. 			if (m.vkcode == VK_DOWN || m.vkcode == 's' || m.vkcode == 'S')moveDown();
  46. 			if (m.vkcode == VK_LEFT || m.vkcode == 'a' || m.vkcode == 'A')moveLeft();
  47. 			if (m.vkcode == VK_RIGHT || m.vkcode == 'd' || m.vkcode == 'D')moveRight();
  48. 			break;
  49. 		case WM_LBUTTONDOWN: //若点击了New game按钮所在区域，则调用gameInit函数，即初始化游戏数据并打印游戏界面
  50. 			if (m.x >= 525 && m.x <= 675 && m.y >= 160 && m.y < 210) {
  51. 				gameInit();
  52. 				break;
  53. 			}
  54. 		}
  55. 		FlushBatchDraw(); //结束批量绘图
  56. 	}
  57.  
  58. 	getchar();
  59. 	return 0;
  60. }

三、完整代码

  1. #include <stdio.h>
  2. #include <easyx.h> //easyx图形库头文件
  3. #include <stdlib.h>
  4. #include <math.h>
  5. #define GRID_W 100 //格子宽度（正方形边长）
  6. #define INTERVAL 20 //格子间距
  7. #define MAX_SIZE 4 //每行每列各自的最大数量
  8. #define GAME_ZONE MAX_SIZE * GRID_W + (MAX_SIZE + 1) * INTERVAL //游戏格子区域的边长（实际为500）
  9.  
  10. //枚举出游戏中用到的颜色
  11. enum color
  12. {
  13. 	BLANK_GRID = RGB(215, 203, 190), //空格子颜色
  14. 	INTERVRL_COLOR = RGB(187, 173, 160), //间距颜色，在函数中设定为背景颜色
  15. 	RIGHT_RECTANGLE = RGB(250, 248, 219), //窗口右侧矩形区域颜色，即除格子和间隔以外的颜色
  16. 	SCORE_COLOR = RGB(187, 173, 160), //计分板颜色
  17. 	NEWGAME_COLOR = RGB(143, 122, 102), //新游戏按钮颜色
  18. 	TWO_ONE = RGB(238, 228, 218), //方格值为2的颜色
  19. 	TWO_TWO = RGB(237, 224, 200), //方格值为4的颜色
  20. 	TWO_THREE = RGB(242, 177, 121), //方格值为8的颜色
  21. 	TWO_FOUR = RGB(245, 149, 99), //方格值为16的颜色
  22. 	TWO_FIVE = RGB(246, 124, 95), //方格值为32的颜色
  23. 	TWO_SIX = RGB(246, 94, 59), //方格值为64的颜色
  24. 	TWO_SEVEN = RGB(237, 207, 114), //方格值为128的颜色
  25. 	TWO_EIGHT = RGB(237, 204, 97), //方格值为256的颜色
  26. 	TWO_NINE = RGB(237, 200, 80), //方格值为512的颜色
  27. 	TWO_TEN = RGB(237, 197, 63), //方格值为1024的颜色
  28. 	TWO_ELEVEN = RGB(237, 194, 46), //方格值为2048的颜色
  29. };
  30. color arr[12] = { BLANK_GRID, TWO_ONE, TWO_TWO, TWO_THREE, TWO_FOUR, TWO_FIVE, TWO_SIX, TWO_SEVEN, TWO_EIGHT, TWO_NINE, TWO_TEN, TWO_ELEVEN, }; //枚举颜色数组
  31. int map[MAX_SIZE][MAX_SIZE]; //定义一个数组，用于存储游戏区域数据，全局变量自动初始化为零
  32. int score; //定义全局变量得分值，会被打印在得分板上
  33.  
  34. //随机数产生函数
  35. void createNum();
  36.  
  37. //游戏初始化函数
  38. void gameInit();
  39.  
  40.  
  41. //游戏界面函数
  42. void gameView();
  43.  
  44.  
  45. //游戏移动函数
  46. void moveUp(); //上移
  47.  
  48. void moveDown(); //下移
  49.  
  50. void moveLeft(); //左移
  51.  
  52. void moveRight(); //右移
  53.  
  54. //胜负判定函数
  55. int isWin();
  56.  
  57. //胜利/失败界面函数
  58. void winOrLoseView(int det);
  59.  
  60. //定义主函数
  61. int main(void)
  62. {
  63. 	//创建游戏窗口，尺寸为500 * 700
  64. 	initgraph(GAME_ZONE + 200, GAME_ZONE);    //创建游戏窗口
  65. 	//设置背景（方格间距）颜色  
  66.  
  67. 	setbkmode(TRANSPARENT);      //设置窗口为透明色
  68. 	setbkcolor(INTERVRL_COLOR);   //设置背景颜色
  69. 	cleardevice();     //清除背景
  70. 	//打印游戏右侧区域并设置颜色
  71. 	setfillcolor(RIGHT_RECTANGLE);    //设置矩形填充颜色
  72. 	solidrectangle(GAME_ZONE, 0, GAME_ZONE + 200, GAME_ZONE);     //创建游戏额外区域的矩形
  73. 	//打印并设置积分板颜色，并打印对应字体
  74. 	setfillcolor(SCORE_COLOR);             //设置游戏界面右侧的颜色
  75. 	solidroundrect(530, 40, 670, 100, 5, 5); //得分板的左上和右下坐标分别为(530，40), (670，100)   创建得分板
  76. 	settextcolor(RGB(238, 228, 218));        //设置字体颜色
  77. 	settextstyle(30, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0); //设置文字大小和字体
  78. 	outtextxy(565, 40, "SCORE");      //出入文字
  79. 	//打印New Gme按钮以及字体并设置字体颜色和格式
  80. 	setfillcolor(NEWGAME_COLOR);          //设置新游戏按钮区域背景颜色
  81. 	solidroundrect(525, 160, 675, 210, 5, 5); //New Game区域的左上和右下坐标分别为(525，160), (675，210)       
  82. 	int btw = textwidth("New Game");     //文字宽距离按钮居中更多距离
  83. 	int bth = textheight("New Game");    //文字高距离按钮居中更多距离
  84. 	settextcolor(WHITE);   //设置文字颜色为白色
  85. 	settextstyle(30, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0);    //设置文字的字体和大小
  86. 	outtextxy(525 + (150 - btw) / 2, 160 + (50 - bth) / 2, "New Game");  //将文字居中放在矩形中
  87. 	gameInit();
  88. 	gameView();    //调用函数
  89. 	ExMessage m; //定义接收键鼠输入的变量
  90.  
  91. 	//开始游戏，用一个恒定循环定义
  92. 	BeginBatchDraw(); //开始批量绘图，防止游戏过程中闪屏
  93. 	while (1)
  94. 	{
  95. 		gameView();
  96. 		//每轮开始时，进行一次胜负判定，若胜负未定则继续游戏，否则调用胜利/失败界面函数
  97. 		int det = isWin();
  98. 		if (det != 0) winOrLoseView(det);
  99. 		//接收键鼠输入
  100. 		m = getmessage(EX_MOUSE | EX_KEY);
  101. 		switch (m.message)
  102. 		{
  103. 		case WM_KEYDOWN: //如果键盘输入wasd或上下左右键，则做出相对应移动指令
  104. 			if (m.vkcode == VK_UP || m.vkcode == 'w' || m.vkcode == 'W') moveUp();
  105. 			if (m.vkcode == VK_DOWN || m.vkcode == 's' || m.vkcode == 'S')moveDown();
  106. 			if (m.vkcode == VK_LEFT || m.vkcode == 'a' || m.vkcode == 'A')moveLeft();
  107. 			if (m.vkcode == VK_RIGHT || m.vkcode == 'd' || m.vkcode == 'D')moveRight();
  108. 			break;
  109. 		case WM_LBUTTONDOWN: //若点击了New game按钮所在区域，则调用gameInit函数，即初始化游戏数据并打印游戏界面
  110. 			if (m.x >= 525 && m.x <= 675 && m.y >= 160 && m.y < 210)
  111. 			{
  112. 				gameInit();
  113. 				break;
  114. 			}
  115. 		}
  116. 		FlushBatchDraw(); //结束批量绘图
  117. 	}
  118.  
  119. 	getchar();
  120. 	return 0;
  121. }
  122.  
  123. void createNum()
  124. {
  125. 	//代码实现
  126. 	while (1)
  127. 	{
  128. 		int ret = 0;
  129. 		int x = rand() % MAX_SIZE;   //创建一个随机数对MAX_SIZE 取余结果坐标为0，1，2，3
  130. 		int y = rand() % MAX_SIZE;   //创建一个随机数对MAX_SIZE 取余结果坐标为0，1，2，3
  131. 		if (map[x][y] == 0) {     //查看随机的坐标是否等于0
  132. 			if (rand() % 10 == 1)    //判断随机数取10余数是否为1，来限制4出现的几率为10%
  133. 			{
  134. 				map[x][y] = 4;
  135. 			}
  136. 			else
  137. 			{
  138. 				map[x][y] = 2;    //否则2出现的几率为90%  
  139. 			}
  140. 			break;
  141. 		}
  142. 	}
  143. }
  144.  
  145. void gameInit()
  146. {
  147. 	//代码实现
  148.  
  149. 	for (int i = 0; i < MAX_SIZE; i++) {
  150. 		for (int j = 0; j < MAX_SIZE; j++) {
  151. 			map[i][j] = 0; //遍历所有方格并初始化为0
  152. 		}
  153. 	}
  154. 	score = 0; //得分初始化为0
  155. 	//设置随机数种子
  156. 	srand(GetTickCount());
  157. 	createNum();
  158. 	createNum();
  159. }
  160.  
  161. void gameView()
  162. {
  163. 	//代码实现
  164.  
  165. 	//打印方格、设置颜色、打印方格值
  166. 	for (int i = 0; i < MAX_SIZE; i++) {      //遍历所以格子起点
  167. 		for (int j = 0; j < MAX_SIZE; j++) {     //遍历所以格子起点
  168. 			int x = j * GRID_W + (j + 1) * INTERVAL;    //起点X坐标
  169. 			int y = i * GRID_W + (i + 1) * INTERVAL;    //起点y坐标 
  170. 			int index = (int)log2((double)map[i][j]);
  171. 			if (map[i][j] == 0) {         //判断当前格子的数字是否为0
  172. 				COLORREF gcolor = arr[0];    //若为0赋值数组中颜色
  173. 				setfillcolor(gcolor); //设置空方格时的颜色
  174. 				solidroundrect(x, y, x + GRID_W, y + GRID_W, 5, 5);  //创建空方格
  175. 			}
  176. 			else { 	               //除方格值为0时，其余情况下打印值
  177. 				COLORREF gcolor = arr[index];
  178. 				setfillcolor(gcolor); //设置不同方格值时的颜色
  179. 				solidroundrect(x, y, x + GRID_W, y + GRID_W, 5, 5);  //创建不同颜色的方格
  180. 				settextstyle(50, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0);   //更改文字颜色大小
  181. 				if (map[i][j] < 8)  settextcolor(RGB(119, 110, 101));    //设置16以下文字的颜色
  182. 				else  settextcolor(WHITE);                             //16以上文字的颜色
  183. 				char snum[10] = "";   //创建一维数组
  184. 				sprintf(snum, "%d", map[i][j]);   //将数字转化成字符串
  185. 				int ntw = textwidth(snum);    //求输出的字的宽
  186. 				int nth = textheight(snum);   //求输出的字的高
  187. 				outtextxy(x + (100 - ntw) / 2, y + (100 - nth) / 2, snum);   //将文字输出
  188. 				//绘制方格值     
  189. 			}
  190. 		}
  191. 	}
  192. 	//将得分转化为字符串打印在得分板上
  193. 	char sscore[10];             //创建数组
  194. 	sprintf(sscore, "%d", score);   //将数字转化成字符串
  195. 	int stw = textwidth(sscore);
  196. 	int sth = textheight(sscore);//数字的宽
  197. 	settextstyle(30, 0, "Microsoft YaHei UI", 0, 0, 1000, 0, 0, 0);  //设置分数的大小的字体
  198. 	settextcolor(WHITE);    //分数的颜色
  199. 	setbkmode(TRANSPARENT);    //透明背景
  200. 	//将分数打印至得分板区域
  201. 	RECT r = { 530, 65, 670, 100 };
  202. 	HRGN rgn = CreateRectRgn(530, 65, 670, 100);
  203. 	setcliprgn(rgn); //设定裁剪区，为计分板区域
  204. 	clearcliprgn(); //每轮游戏结束后，清空计分板，重新打印分数
  205. 	setcliprgn(NULL);
  206. 	drawtext(sscore, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE); //在指定区域打印分数，设置居中
  207. }
  208.  
  209. void moveUp()
  210. {
  211. 	//代码实现
  212. 	bool isMoved = 0;	//是否移动成功
  213. 	for (int i = 0; i < MAX_SIZE; i++)	//遍历列
  214. 	{
  215. 		int now = 0;//标尺位，每一列遍历时都将标尺位调至第一行
  216. 		for (int next = 1; next < MAX_SIZE; next++)	//遍历行，next是now后面的数字
  217. 		{
  218. 			//判断next处是不是0，意思就是除了第一行其他位置是否有数字存在
  219. 			if (map[next][i] != 0)//next处不是0
  220. 			{
  221. 				if (map[now][i] == 0)//出现数字的前方路径上全是0
  222. 				{
  223. 					map[now][i] = map[next][i];//将第一行变成该数字，
  224. 					map[next][i] = 0;//该数字原本的位置置为0
  225. 					isMoved = 1;//成功移动数字，随机在空格位置刷新2或4
  226. 				}
  227. 				else if (map[now][i] == map[next][i])//顺序遍历，标尺位数字和出现数字相同，且中间路径上没有数字
  228. 				{
  229. 					map[now][i] *= 2;//将数字合并，标尺位数字变为原来的二倍
  230. 					score += map[now][i];//方块合成后的得分
  231. 					map[next][i] = 0;//释放原来的数字
  232. 					now++;//标尺位向后一行
  233. 					isMoved = 1;//成功移动数字，随机在空格处刷新2或4
  234. 				}
  235. 				else//标尺位和数字不相等，那就将数字移动到标尺位的后一行，如果本身就在标尺位的后一行，依然可以赋值，但不删除原位置
  236. 				{
  237. 					map[now + 1][i] = map[next][i];//将与标尺位不相同的数字移动到标尺位的后一行
  238. 					if (now + 1 != next)//如果数字就在标尺位的后一行，他俩相邻，就不用执行这一步，因为now+1和next原本就是一个位置他俩原本的数字就相等
  239. 						//如果数字和标尺位中间有空格，就要执行这一步，因为原本的now+1是0，而next原本的数字是一个不为0的数，他俩不相等，要执行这一步进行 next原本位置的删除
  240. 					{
  241. 						map[next][i] = 0;//删除
  242. 						isMoved = 1;//成功移动数字刷新2或4
  243. 					}
  244. 					now++;//标尺位向后一行
  245. 				}
  246. 			}
  247. 		}
  248. 	}
  249. 	if (isMoved)
  250. 	{
  251. 		createNum(); //判定是否产生了移动，若是，则随机空白位置生成一个整数2或4
  252. 	}
  253. 	gameView();  //打印一次游戏界面
  254. }
  255.  
  256. void moveDown()
  257. {
  258. 	//代码实现
  259.  
  260. 	bool isMoved = 0;
  261. 	for (int i = 0; i < MAX_SIZE; i++)//遍历列
  262. 	{
  263. 		int now = MAX_SIZE - 1;
  264. 		for (int next = MAX_SIZE - 2; next >= 0; next--)//遍历行
  265. 		{
  266. 			if (map[next][i] != 0)
  267. 			{
  268. 				if (map[now][i] == 0)
  269. 				{
  270. 					map[now][i] = map[next][i];
  271. 					map[next][i] = 0;
  272. 					isMoved = 1;
  273. 				}
  274. 				else if (map[now][i] == map[next][i])
  275. 				{
  276. 					map[now][i] *= 2;
  277. 					score += map[now][i];
  278. 					map[next][i] = 0;
  279. 					isMoved = 1;
  280. 					now--;
  281. 				}
  282. 				else {
  283. 					map[now - 1][i] = map[next][i];
  284. 					if (now - 1 != next)
  285. 					{
  286. 						map[next][i] = 0;
  287. 						isMoved = 1;
  288. 					}
  289. 					now--;
  290. 				}
  291. 			}
  292. 		}
  293. 	}
  294. 	if (isMoved)
  295. 	{
  296. 		createNum();
  297. 	}
  298. 	gameView();  //打印一次游戏界面
  299. }
  300.  
  301. void moveLeft()
  302. {
  303. 	//代码实现
  304.  
  305. 	bool isMoved = 0;	//是否移动成功
  306. 	for (int i = 0; i < MAX_SIZE; i++)	//遍历行
  307. 	{
  308. 		int now = 0;
  309. 		for (int next = 1; next < MAX_SIZE; next++)	//遍历列
  310. 		{
  311. 			//判断next处是不是0
  312. 			if (map[i][next] != 0)
  313. 			{
  314. 				if (map[i][now] == 0)
  315. 				{
  316. 					map[i][now] = map[i][next];
  317. 					map[i][next] = 0;
  318. 					isMoved = 1;
  319. 				}
  320. 				else if (map[i][now] == map[i][next])
  321. 				{
  322. 					map[i][now] *= 2;
  323. 					score += map[i][now];
  324. 					map[i][next] = 0;
  325. 					now++;
  326. 					isMoved = 1;
  327. 				}
  328. 				else
  329. 				{
  330. 					map[i][now + 1] = map[i][next];
  331. 					if (now + 1 != next)
  332. 					{
  333. 						map[i][next] = 0;
  334. 						isMoved = 1;
  335. 					}
  336. 					now++;
  337. 				}
  338. 			}
  339. 		}
  340. 	}
  341. 	if (isMoved)
  342. 	{
  343. 		createNum();
  344. 	}
  345. 	gameView(); //打印一次游戏界面
  346. }
  347.  
  348. void moveRight()
  349. {
  350. 	//代码实现
  351.  
  352. 	bool isMoved = 0;	//是否移动成功
  353. 	for (int i = 0; i < MAX_SIZE; i++)	//遍历行
  354. 	{
  355. 		int now = MAX_SIZE - 1;
  356. 		for (int next = MAX_SIZE - 2; next >= 0; next--)	//遍历列
  357. 		{
  358. 			//判断next处是不是0
  359. 			if (map[i][next] != 0)
  360. 			{
  361. 				if (map[i][now] == 0)
  362. 				{
  363. 					map[i][now] = map[i][next];
  364. 					map[i][next] = 0;
  365. 					isMoved = 1;
  366. 				}
  367. 				else if (map[i][now] == map[i][next])
  368. 				{
  369. 					map[i][now] *= 2;
  370. 					score += map[i][now];
  371. 					map[i][next] = 0;
  372. 					now--;
  373. 					isMoved = 1;
  374. 				}
  375. 				else
  376. 				{
  377. 					map[i][now - 1] = map[i][next];
  378. 					if (now - 1 != next)
  379. 					{
  380. 						map[i][next] = 0;
  381. 						isMoved = 1;
  382. 					}
  383. 					now--;
  384. 				}
  385. 			}
  386. 		}
  387. 	}
  388. 	if (isMoved)
  389. 	{
  390. 		createNum();
  391. 	}
  392. 	gameView(); //打印一次游戏界面
  393. }
  394.  
  395. int isWin()
  396. {
  397. 	//代码实现
  398.  
  399. 	int ret = 2; //定义判别变量，初始状态为游戏失败
  400.  
  401. 	for (int i = 0; i < MAX_SIZE; i++)  //循环遍历每个数字  
  402. 	{
  403. 		for (int j = 0; j < MAX_SIZE; j++)
  404. 		{
  405. 			if (map[i][j] == 2048) {
  406. 				ret = 1;
  407. 				break;
  408. 			}  //如果有数字2048，改变判别变量，判定为胜利，终中断循环
  409. 			if (map[i][j] == 0) {
  410. 				ret = 0;
  411. 				break;
  412. 			}  //如果还有空方格，说明此时仍可移动，改变判别变量，判定为胜负未定，终止循环
  413. 			if (map[i][j] == map[i][j + 1] || map[i][j] == map[i + 1][j]) {
  414. 				if (i < 3 && j < 3) {
  415. 					ret = 0;
  416. 					break;
  417. 				}
  418. 			}
  419. 			if (i == 3 && j != 3 && map[i][j] == map[i][j + 1]) {
  420. 				ret = 0;
  421. 				break;
  422. 			}
  423. 			if (j == 3 && i != 3 && map[i][j] == map[i + 1][j]) {
  424. 				ret = 0;
  425. 				break;
  426. 			}  //如果在不符合前两个if的情形下，且对任意在游戏区域内的方块，其右侧和下侧的方块至少有一个与其相等，则改变判别变量判定为胜负未定，中断循环
  427. 		}
  428. 	}
  429.  
  430. 	return ret; //否则判定游戏失败
  431. }
  432.  
  433. void winOrLoseView(int det)
  434. {
  435. 	//代码实现
  436.  
  437. 	//接收isWin返回的参数，若为1打印胜利字样，为2打印失败字样
  438. 	HWND window = GetHWnd();          //获取窗口句柄
  439. 	if (det == 1)     //胜利判定
  440. 	{
  441. 		MessageBox(window, "You won the game!", "提示", MB_OK);  //打印提示
  442. 		gameInit();  //新开始游戏
  443. 	}
  444. 	else if (det == 2)
  445. 	{   //失败判定
  446. 		MessageBox(window, "Game over!", "提示", MB_OK);  //打印提示
  447. 		gameInit();  //新开始游戏
  448. 	}
  449. }

成品示例：

四、总结

可以看出，整个游戏从构思倒实现还是比较简单的，总代码量也只有450行左右，只是一个功能比较简略、仅仅实现了核心功能和一点点拓展功能的版本，实际上该游戏的可扩展之处还有很多，例如音乐、主菜单、游戏设置、图形界面字体的优化、游戏的特效以及设置更多游戏模式等，这代表着实现从深度到广度的延伸，使得游戏更具有可玩性，广大开发者可自行构思、创造。

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

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

  

闽ICP备14008679号