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

C语言实现基于EasyX的简单五子棋游戏_c 语言easy 写的游戏

作者：从前慢现在也慢 | 2024-04-04 13:20:04

赞

踩

c 语言easy 写的游戏

目录

游戏效果

主要函数分析

完整代码

下载地址

游戏效果

主要函数分析

1.判断胜负函数（judge()）

从当前位置向四周遍历，如果有五子相连游戏结束

  1. //判断游戏是否结束
  2. void judge() {
  3. 	bool l = true, r = true;
  4. 	int count = 0;
  5.  
  6. 	for (int i = 1; i <= 4; ++i) {
  7. 		if (l && current_y - i >= 0) {
  8. 			if (map[current_x][current_y - i] == current_play) {	//判断左右直线
  9. 				count++;
  10. 			}
  11. 			else {
  12. 				l = false;
  13. 			}
  14. 		}
  15. 		if (r && current_y + i <= n) {
  16. 			if (map[current_x][current_y + i] == current_play) {
  17. 				count++;
  18. 			}
  19. 			else {
  20. 				r = false;
  21. 			}
  22. 		}
  23. 	}
  24. 	if (count >= 4) {
  25. 		isEnd = true;
  26. 		return;
  27. 	}
  28.  
  29. 	l = r = true;
  30. 	count = 0;
  31. 	for (int i = 1; i <= 4; ++i) {
  32. 		if (l && current_x - i >= 0) {
  33. 			if (map[current_x - i][current_y] == current_play) {	//判断上下直线
  34. 				count++;
  35. 			}
  36. 			else {
  37. 				l = false;
  38. 			}
  39. 		}
  40. 		if (r && current_x + i <= n) {
  41. 			if (map[current_x + i][current_y] == current_play) {
  42. 				count++;
  43. 			}
  44. 			else {
  45. 				r = false;
  46. 			}
  47. 		}
  48. 	}
  49. 	if (count >= 4) {
  50. 		isEnd = true;
  51. 		return;
  52. 	}
  53.  
  54. 	l = r = true;
  55. 	count = 0;
  56. 	for (int i = 1; i <= 4; ++i) {	//左上到右下的直线
  57. 		if (l && current_x - i >= 0 && current_y - i >= 0) {
  58. 			if (map[current_x - i][current_y - i] == current_play) {
  59. 				count++;
  60. 			}
  61. 			else {
  62. 				l = false;
  63. 			}
  64. 		}
  65. 		if (r && current_x + i <= n && current_y + i <= n) {
  66. 			if (map[current_x + i][current_y + i] == current_play) {
  67. 				count++;
  68. 			}
  69. 			else {
  70. 				r = false;
  71. 			}
  72. 		}
  73. 	}
  74. 	if (count >= 4) {
  75. 		isEnd = true;
  76. 		return;
  77. 	}
  78.  
  79. 	l = r = true;
  80. 	count = 0;
  81. 	for (int i = 1; i <= 4; ++i) {	//右上到左下的直线
  82. 		if (l && current_x - i >= 0 && current_y + i <= n) {
  83. 			if (map[current_x - i][current_y + i] == current_play) {
  84. 				count++;
  85. 			}
  86. 			else {
  87. 				l = false;
  88. 			}
  89. 		}
  90. 		if (r && current_x + i <= n && current_y - i >= 0) {
  91. 			if (map[current_x + i][current_y - i] == current_play) {
  92. 				count++;
  93. 			}
  94. 			else {
  95. 				r = false;
  96. 			}
  97. 		}
  98. 	}
  99. 	if (count >= 4) {
  100. 		isEnd = true;
  101. 		return;
  102. 	}
  103. }

2.更新棋盘函数(updata())

根据键盘输入改变棋盘状态，同时如果按下空格下棋时则进行胜负判断。

  1. //更新棋盘
  2. void updata(BYTE vkcode) {
  3.     if (vkcode == 0x41) {   //A键
  4.         if (current_y - 1 >= 0) {
  5.             current_y -= 1;
  6.         }
  7.     }
  8.     else if (vkcode == 0x44) {//D
  9.         if (current_y + 1 <= n) {
  10.             current_y += 1;
  11.         }
  12.     }
  13.     else if (vkcode == 0x57) {//W
  14.         if (current_x - 1 >= 0) {
  15.             current_x -= 1;
  16.         }
  17.     }
  18.     else if (vkcode == 0x53) {//S
  19.         if (current_x + 1 <= n) {
  20.             current_x += 1;
  21.         }
  22.     }
  23.     else if (vkcode == VK_SPACE) {//空格
  24.         if (!map[current_x][current_y]) {
  25.             map[current_x][current_y] = current_play;
  26. 			judge();
  27.             current_play = 3 - current_play;
  28.         }
  29.     }
  30. }

3.绘制函数(draw())

绘制棋盘

  1. //绘制
  2. void draw() {
  3.  
  4. 	//背景
  5. 	putimage(0, 0, &bk);
  6.  
  7.     //绘制棋盘
  8.     setlinecolor(BLACK);
  9.     for (int i = 0; i <= n; ++i) {
  10.         line(x, y + i * chess_len, x + n * chess_len, y + i * chess_len);
  11.         line(x + i * chess_len, y, x + i * chess_len, y + n * chess_len);
  12.     }
  13.  
  14.     //在当前位置绘制红色框框
  15.     setlinecolor(RED);
  16.     rectangle(x + current_y * chess_len - chess_len / 2, y + current_x * chess_len - chess_len / 2,
  17.         x + current_y * chess_len + chess_len / 2, y + current_x * chess_len + chess_len / 2);
  18.  
  19.     //绘制棋子
  20.     for (int i = 0; i <= n; ++i) {
  21.         for (int j = 0; j <= n; ++j) {
  22.             if (map[i][j] == 1) {
  23.                 putTranspareImage(NULL, x + j * chess_len - 14, y + i * chess_len - 14, &white);
  24.             }
  25.             else if (map[i][j] == 2) {
  26.                 putTranspareImage(NULL, x + j * chess_len - 14, y + i * chess_len - 14, &black);
  27.             }
  28.         }
  29.     }
  30.     setlinecolor(BLACK);
  31.     rectangle(550, 50, 750, 350);
  32.     setbkmode(TRANSPARENT);
  33.     settextcolor(BLACK);
  34.     settextstyle(50, 0, L"宋体");
  35.     outtextxy(575, 50, L"出棋方");
  36.     if (current_play == 1) {
  37.         setfillcolor(WHITE);
  38.     }
  39.     else if (current_play == 2) {
  40.         setfillcolor(BLACK);
  41.     }
  42.     solidcircle(650, 200, 80);
  43. }

完整代码

  1. #include <graphics.h>
  2. #include <vector>
  3. #include <conio.h>
  4. #include <ctime>
  5. #include <cmath>
  6. #include<Windows.h>
  7. #pragma comment( lib, "MSIMG32.LIB")
  8. const int n = 15;
  9.  
  10. const int x = 50;
  11. const int y = 50;
  12.  
  13. int chess_len = 30;//棋子长度
  14.  
  15. int current_x = 0;//当前坐标
  16. int current_y = 0;
  17.  
  18. int current_play = 1;//当前下棋角色，1表示白棋，2表示黑棋
  19. IMAGE bk;//背景图片
  20. IMAGE white;//白棋
  21. IMAGE black;//黑棋
  22. int map[n + 1][n + 1] = { 0 };//棋盘数组
  23. bool isEnd = false;//游戏结束标志
  24.  
  25. void putTranspareImage(IMAGE* target, int x, int y, IMAGE* source)
  26. {
  27.     /*在屏幕上显示透明贴图函数*/
  28.     HDC targetDc = GetImageHDC(target);
  29.     HDC sourceDc = GetImageHDC(source);
  30.     int w = (*source).getwidth();
  31.     int h = (*source).getheight();
  32.  
  33.     // 结构体的第三个成员表示额外的透明度，0 表示全透明，255 表示不透明。
  34.     BLENDFUNCTION bf = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
  35.     //使用 Windows GDI 函数实现半透明位图
  36.     AlphaBlend(targetDc, x, y, w, h, sourceDc, 0, 0, w, h, bf);
  37. }
  38.  
  39. //判断游戏是否结束
  40. void judge() {
  41. 	bool l = true, r = true;
  42. 	int count = 0;
  43.  
  44. 	for (int i = 1; i <= 4; ++i) {
  45. 		if (l && current_y - i >= 0) {
  46. 			if (map[current_x][current_y - i] == current_play) {	//判断左右直线
  47. 				count++;
  48. 			}
  49. 			else {
  50. 				l = false;
  51. 			}
  52. 		}
  53. 		if (r && current_y + i <= n) {
  54. 			if (map[current_x][current_y + i] == current_play) {
  55. 				count++;
  56. 			}
  57. 			else {
  58. 				r = false;
  59. 			}
  60. 		}
  61. 	}
  62. 	if (count >= 4) {
  63. 		isEnd = true;
  64. 		return;
  65. 	}
  66.  
  67. 	l = r = true;
  68. 	count = 0;
  69. 	for (int i = 1; i <= 4; ++i) {
  70. 		if (l && current_x - i >= 0) {
  71. 			if (map[current_x - i][current_y] == current_play) {	//判断上下直线
  72. 				count++;
  73. 			}
  74. 			else {
  75. 				l = false;
  76. 			}
  77. 		}
  78. 		if (r && current_x + i <= n) {
  79. 			if (map[current_x + i][current_y] == current_play) {
  80. 				count++;
  81. 			}
  82. 			else {
  83. 				r = false;
  84. 			}
  85. 		}
  86. 	}
  87. 	if (count >= 4) {
  88. 		isEnd = true;
  89. 		return;
  90. 	}
  91.  
  92. 	l = r = true;
  93. 	count = 0;
  94. 	for (int i = 1; i <= 4; ++i) {	//左上到右下的直线
  95. 		if (l && current_x - i >= 0 && current_y - i >= 0) {
  96. 			if (map[current_x - i][current_y - i] == current_play) {
  97. 				count++;
  98. 			}
  99. 			else {
  100. 				l = false;
  101. 			}
  102. 		}
  103. 		if (r && current_x + i <= n && current_y + i <= n) {
  104. 			if (map[current_x + i][current_y + i] == current_play) {
  105. 				count++;
  106. 			}
  107. 			else {
  108. 				r = false;
  109. 			}
  110. 		}
  111. 	}
  112. 	if (count >= 4) {
  113. 		isEnd = true;
  114. 		return;
  115. 	}
  116.  
  117. 	l = r = true;
  118. 	count = 0;
  119. 	for (int i = 1; i <= 4; ++i) {	//右上到左下的直线
  120. 		if (l && current_x - i >= 0 && current_y + i <= n) {
  121. 			if (map[current_x - i][current_y + i] == current_play) {
  122. 				count++;
  123. 			}
  124. 			else {
  125. 				l = false;
  126. 			}
  127. 		}
  128. 		if (r && current_x + i <= n && current_y - i >= 0) {
  129. 			if (map[current_x + i][current_y - i] == current_play) {
  130. 				count++;
  131. 			}
  132. 			else {
  133. 				r = false;
  134. 			}
  135. 		}
  136. 	}
  137. 	if (count >= 4) {
  138. 		isEnd = true;
  139. 		return;
  140. 	}
  141. }
  142.  
  143. //更新棋盘
  144. void updata(BYTE vkcode) {
  145.     if (vkcode == 0x41) {   //A键
  146.         if (current_y - 1 >= 0) {
  147.             current_y -= 1;
  148.         }
  149.     }
  150.     else if (vkcode == 0x44) {//D
  151.         if (current_y + 1 <= n) {
  152.             current_y += 1;
  153.         }
  154.     }
  155.     else if (vkcode == 0x57) {//W
  156.         if (current_x - 1 >= 0) {
  157.             current_x -= 1;
  158.         }
  159.     }
  160.     else if (vkcode == 0x53) {//S
  161.         if (current_x + 1 <= n) {
  162.             current_x += 1;
  163.         }
  164.     }
  165.     else if (vkcode == VK_SPACE) {//空格
  166.         if (!map[current_x][current_y]) {
  167.             map[current_x][current_y] = current_play;
  168. 			judge();
  169.             current_play = 3 - current_play;
  170.         }
  171.     }
  172. }
  173.  
  174. //绘制
  175. void draw() {
  176.  
  177. 	//背景
  178. 	putimage(0, 0, &bk);
  179.  
  180.     //绘制棋盘
  181.     setlinecolor(BLACK);
  182.     for (int i = 0; i <= n; ++i) {
  183.         line(x, y + i * chess_len, x + n * chess_len, y + i * chess_len);
  184.         line(x + i * chess_len, y, x + i * chess_len, y + n * chess_len);
  185.     }
  186.  
  187.     //在当前位置绘制红色框框
  188.     setlinecolor(RED);
  189.     rectangle(x + current_y * chess_len - chess_len / 2, y + current_x * chess_len - chess_len / 2,
  190.         x + current_y * chess_len + chess_len / 2, y + current_x * chess_len + chess_len / 2);
  191.  
  192.     //绘制棋子
  193.     for (int i = 0; i <= n; ++i) {
  194.         for (int j = 0; j <= n; ++j) {
  195.             if (map[i][j] == 1) {
  196.                 putTranspareImage(NULL, x + j * chess_len - 14, y + i * chess_len - 14, &white);
  197.             }
  198.             else if (map[i][j] == 2) {
  199.                 putTranspareImage(NULL, x + j * chess_len - 14, y + i * chess_len - 14, &black);
  200.             }
  201.         }
  202.     }
  203.     setlinecolor(BLACK);
  204.     rectangle(550, 50, 750, 350);
  205.     setbkmode(TRANSPARENT);
  206.     settextcolor(BLACK);
  207.     settextstyle(50, 0, L"宋体");
  208.     outtextxy(575, 50, L"出棋方");
  209.     if (current_play == 1) {
  210.         setfillcolor(WHITE);
  211.     }
  212.     else if (current_play == 2) {
  213.         setfillcolor(BLACK);
  214.     }
  215.     solidcircle(650, 200, 80);
  216. }
  217.  
  218. int main() {
  219.     loadimage(&bk, L"back.jpg");
  220.     loadimage(&white, L"bai.png", 28, 28);
  221.     loadimage(&black, L"hei.png", 28, 28);
  222.     initgraph(800, 600);
  223.     ExMessage msg;
  224.     BeginBatchDraw();
  225.     while (!isEnd) {
  226.  
  227.         if (peekmessage(&msg, EM_KEY)) {
  228.             if (msg.message == WM_KEYUP) {
  229.                 updata(msg.vkcode);
  230.             }
  231.         }
  232.         draw();
  233.         FlushBatchDraw();
  234.         Sleep(10);
  235.         cleardevice();
  236.     }
  237.  
  238. 	MessageBox(GetHWnd(), current_play == 1 ? L"游戏结束，黑棋获胜！" : L"游戏结束，白棋获胜！", L"Game Over", MB_OK);
  239.     EndBatchDraw();
  240. }

下载地址

图片资源和完整项目下载链接

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/358864
推荐阅读
相关标签

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

  

闽ICP备14008679号