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

用c语言实现简易三子棋

作者：知新_RL | 2024-05-21 22:38:32

赞

踩

用c语言实现简易三子棋

本篇适用于C语言初学者。

目录

完整代码： 

分步介绍：

声明：

代码主体部分：

模块功能实现：

完整代码： 

  1. #include<stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. #define ROW 3
  6. #define COL 3
  7.  
  8. void InitBorad(char borad[ROW][COL], int row, int col);
  9.  
  10. void DisplayBorad(char borad[ROW][COL], int row, int col);
  11.  
  12. void PlayerMove(char borad[ROW][COL], int row, int col);
  13.  
  14. void ComputerMove(char borad[ROW][COL], int row, int col);
  15.  
  16. char IsWin(char borad[ROW][COL], int row, int col);
  17.  
  18.  
  19. void InitBorad(char borad[ROW][COL], int row, int col)
  20. {
  21. 	int i = 0;
  22. 	for (i = 0; i < row; i++)
  23. 	{
  24. 		int j = 0;
  25. 		for (j = 0; j < col; j++)
  26. 		{
  27. 			borad[i][j] = ' ';
  28. 		}
  29. 	}
  30. }
  31.  
  32. void DisplayBorad(char borad[ROW][COL], int row, int col)
  33. {
  34. 	int i = 0;
  35. 	for (i = 0; i < row; i++)
  36. 	{
  37. 		int j = 0;
  38. 		for (j = 0; j < col; j++)
  39. 		{
  40. 			printf(" %c ", borad[i][j]);
  41. 			if(j < col - 1)
  42. 				printf("|");
  43. 		}
  44. 		printf("\n");
  45. 		
  46. 		if (i < row - 1)
  47. 		{
  48. 			for (j = 0; j < col; j++)
  49. 			{
  50. 				printf("---");
  51. 				if (j < col - 1)
  52. 					printf("|");
  53. 			}
  54. 		}
  55. 		printf("\n");
  56. 	}
  57. }
  58.  
  59. void PlayerMove(char borad[ROW][COL], int row, int col)
  60. {
  61. 	int x = 0;
  62. 	int y = 0;
  63. 	while (1)
  64. 	{
  65. 		printf("玩家下棋:>");
  66. 		scanf("%d %d", &x, &y);
  67. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  68. 		{
  69. 			if (borad[x - 1][y - 1] == ' ')
  70. 			{
  71. 				borad[x - 1][y - 1] = '*';
  72. 				break;
  73. 			}
  74. 			else
  75. 			{
  76. 				printf("该位置已被占有，请重新选择!\n");
  77. 			}
  78. 		}
  79. 		else
  80. 		{
  81. 			printf("输入错误，请重新选择！\n");
  82. 		}
  83. 	}
  84. }
  85.  
  86. void ComputerMove(char borad[ROW][COL], int row, int col)
  87. {
  88. 	printf("电脑下棋:>\n");
  89. 	while (1)
  90. 	{
  91. 		int x = rand() % row;
  92. 		int y = rand() % col;
  93. 		if (borad[x][y] == ' ')
  94. 		{
  95. 			borad[x][y] = '#';
  96. 			break;
  97. 		}
  98. 	}
  99. }
  100.  
  101. //'*'玩家赢
  102. //'#'电脑赢
  103. //'C'继续游戏
  104. //'Q'平局
  105. //char IsWin(char borad[ROW][COL], int row, int col)
  106. //{
  107. //	int i = 0;
  108. //	for (i = 0; i < row; i++)
  109. //	{
  110. //		if (borad[i][0] == borad[i][1] && borad[i][1] == borad[i][2] && borad[i][0] != ' ')
  111. //			return borad[i][0];
  112. //	}
  113. //	for (i = 0; i < col; i++)
  114. //	{
  115. //		if (borad[0][i] == borad[1][i] && borad[1][i] == borad[2][i] && borad[0][i] != ' ')
  116. //			return borad[0][i];
  117. //	}
  118. //	if (borad[0][0] == borad[1][1] && borad[1][1] == borad[2][2] && borad[0][0] != ' ')
  119. //		return borad[0][0];
  120. //	if (borad[0][2] == borad[1][1] && borad[1][1] == borad[2][0] && borad[0][2] != ' ')
  121. //		return borad[0][2];
  122. //	for (i = 0; i < row; i++)
  123. //	{
  124. //		int j = 0;
  125. //		for (j = 0; j < col; j++)
  126. //		{
  127. //			if (borad[i][j] == ' ')
  128. //				return 'C';
  129. //		}
  130. //	}
  131. //	return 'Q';
  132. //}
  133.  
  134. //判断优化
  135. char IsWin(char borad[ROW][COL], int row, int col)
  136. {
  137. 	int i = 0;
  138. 	int flag = 1;
  139. 	//行
  140. 	for (i = 0; i < row; i++)
  141. 	{
  142. 		flag = 1;
  143. 		int n = 0;
  144. 		if (borad[i][0] != ' ')
  145. 		{
  146. 			while (n < row - 1)
  147. 			{
  148. 				if (borad[i][n] != borad[i][n + 1])
  149. 				{
  150. 					flag = 0;
  151. 					break;
  152. 				}
  153. 				n++;
  154. 			}
  155. 			if (flag)
  156. 				return borad[i][0];
  157. 		}
  158. 	}
  159. 	//列
  160. 	for (i = 0; i < col; i++)
  161. 	{
  162. 		flag = 1;
  163. 		int n = 0;
  164. 		if (borad[0][i] != ' ')
  165. 		{
  166. 			while (n < col - 1)
  167. 			{
  168. 				if (borad[n][i] != borad[n + 1][i])
  169. 				{
  170. 					flag = 0;
  171. 					break;
  172. 				}
  173. 				n++;
  174. 			}
  175. 			if (flag)
  176. 				return borad[0][i];
  177. 		}
  178. 	}
  179.  
  180. 	//左对角线
  181. 	if (borad[0][0] != ' ')
  182. 	{
  183. 		flag = 1;
  184. 		int n = 0;
  185. 		while (n < row - 1)
  186. 		{
  187. 			if (borad[n][n] != borad[n + 1][n + 1])
  188. 			{
  189. 				flag = 0;
  190. 				break;
  191. 			}
  192. 			n++;
  193.  
  194. 		}
  195. 		if (flag)
  196. 			return borad[0][0];
  197. 	}
  198. 	//右对角线
  199. 	int r = 0;
  200. 	int c = col - 1;
  201. 	if (borad[r][c] != ' ')
  202. 	{
  203. 		flag = 1;
  204. 		while (r < row - 1)
  205. 		{
  206. 			if (borad[r][c] != borad[r + 1][c - 1])
  207. 			{
  208. 				flag = 0;
  209. 				break;
  210. 			}
  211. 			r++;
  212. 			c--;
  213. 		}
  214. 		if (flag)
  215. 			return borad[r][c];
  216. 	}
  217. 	//继续
  218. 	for (i = 0; i < row; i++)
  219. 	{
  220. 		int j = 0;
  221. 		for (j = 0; j < col; j++)
  222. 		{
  223. 			if (borad[i][j] == ' ')
  224. 				return 'C';
  225. 		}
  226. 	}
  227. 	//平局
  228. 	return 'Q';
  229. }
  230.  
  231.  
  232. void menu()
  233. {
  234. 	printf("**********************************\n");
  235. 	printf("**********    1.play   ***********\n");
  236. 	printf("**********    0.exit   ***********\n");
  237. 	printf("**********************************\n");
  238. }
  239.  
  240.  
  241. void game()
  242. {
  243. 	char borad[ROW][COL] = { 0 };
  244. 	char ch = 0;
  245. 	//初始化
  246. 	InitBorad(borad, ROW, COL);
  247. 	//打印棋盘
  248. 	DisplayBorad(borad, ROW, COL);
  249. 	//玩家下棋
  250. 	while (1)
  251. 	{
  252. 		//玩家下棋
  253. 		PlayerMove(borad, ROW, COL);
  254. 		DisplayBorad(borad, ROW, COL);
  255. 		//判断
  256. 		ch = IsWin(borad, ROW, COL);
  257. 		if (ch != 'C')
  258. 			break;
  259. 		//电脑下棋
  260. 		ComputerMove(borad, ROW, COL);
  261. 		DisplayBorad(borad, ROW, COL);
  262. 		ch = IsWin(borad, ROW, COL);
  263. 		if (ch != 'C')
  264. 			break;
  265. 	}
  266. 	if (ch == '*')
  267. 		printf("玩家赢！\n");
  268. 	else if (ch == '#')
  269. 		printf("电脑赢！\n");
  270. 	else if (ch == 'Q')
  271. 		printf("平局！\n");
  272. }
  273.  
  274. int main()
  275. {
  276. 	int input = 0;
  277. 	srand((unsigned int)time(NULL));
  278. 	do
  279. 	{
  280. 		menu();
  281. 		printf("请选择:>");
  282. 		scanf("%d", &input);
  283. 		switch (input)
  284. 		{
  285. 		case 1:
  286. 			game();
  287. 			break;
  288. 		case 0:
  289. 			printf("退出游戏！\n");
  290. 			break;
  291. 		default:
  292. 			printf("输入错误，请重新选择!\n");
  293. 			break;
  294. 		}
  295. 	} while (input);
  296.  
  297. 	return 0;
  298. }

分步介绍：

声明：

  1. #include<stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. //定义表示符常量分别表示行（ROW）和列（COL）
  6. #define ROW 3
  7. #define COL 3
  8. //初始化棋盘
  9. void InitBorad(char borad[ROW][COL], int row, int col);
  10. //打印棋盘
  11. void DisplayBorad(char borad[ROW][COL], int row, int col);
  12. //玩家移动
  13. void PlayerMove(char borad[ROW][COL], int row, int col);
  14. //电脑移动
  15. void ComputerMove(char borad[ROW][COL], int row, int col);
  16. //判断输赢实现
  17. char IsWin(char borad[ROW][COL], int row, int col);

代码主体部分：

  1. //游戏菜单
  2. void menu()
  3. {
  4. 	printf("**********************************\n");
  5. 	printf("**********    1.play   ***********\n");
  6. 	printf("**********    0.exit   ***********\n");
  7. 	printf("**********************************\n");
  8. }
  9.  
  10.  
  11. void game()
  12. {
  13.     //定义一个模拟棋盘的二维数组
  14. 	char borad[ROW][COL] = { 0 };
  15.  
  16. 	char ch = 0;
  17. 	//调用函数初始化棋盘（二维数组）
  18. 	InitBorad(borad, ROW, COL);
  19. 	//调用函数打印棋盘（二维数组）
  20. 	DisplayBorad(borad, ROW, COL);
  21. 	while (1)
  22. 	{
  23. 		//调用函数玩家下棋
  24. 		PlayerMove(borad, ROW, COL);
  25. 		DisplayBorad(borad, ROW, COL);
  26. 		//进行输赢判断
  27. 		ch = IsWin(borad, ROW, COL);
  28.         //C表示继续游戏                        
  29. 		if (ch != 'C')
  30. 			break;
  31. 		//调用函数电脑下棋
  32. 		ComputerMove(borad, ROW, COL);
  33.         //进行输赢判断
  34. 		DisplayBorad(borad, ROW, COL);
  35. 		ch = IsWin(borad, ROW, COL);
  36. 		if (ch != 'C')
  37. 			break;
  38. 	}
  39.     // * 表示玩家赢
  40. 	if (ch == '*')
  41. 		printf("玩家赢！\n");
  42.     // # 表示电脑赢
  43. 	else if (ch == '#')
  44. 		printf("电脑赢！\n");
  45.     //Q表示平局
  46. 	else if (ch == 'Q')
  47. 		printf("平局！\n");
  48. }
  49. //主函数（程序入口）
  50. int main()
  51. {
  52.     //存储选择的变量
  53. 	int input = 0;
  54.     //使用time()库（time.h）函数和srand()库（stdlib.h）函数确定随机数生成起点,将time()返回值强制转换成无符号整型（unsigned int）。
  55. 	srand((unsigned int)time(NULL));
  56. 	do
  57. 	{
  58.         //打印游戏菜单
  59. 		menu();
  60.         //选择开始游戏或者退出游戏
  61. 		printf("请选择:>");
  62. 		scanf("%d", &input);
  63. 		switch (input)
  64. 		{
  65. 		case 1:
  66. 			game();
  67. 			break;
  68. 		case 0:
  69. 			printf("退出游戏！\n");
  70. 			break;
  71. 		default :
  72. 			printf("输入错误，请重新选择!\n");
  73. 			break;
  74. 		}
  75. 	} while (input);
  76.  
  77. 	return 0;
  78. }

模块功能实现：

  1. //利用嵌套循环实现对棋盘（二维数组）的初始化，初始化为空格
  2. void InitBorad(char borad[ROW][COL], int row, int col)
  3. {
  4. 	int i = 0;
  5. 	for (i = 0; i < row; i++)
  6. 	{
  7. 		int j = 0;
  8. 		for (j = 0; j < col; j++)
  9. 		{
  10. 			borad[i][j] = ' ';
  11. 		}
  12. 	}
  13. }
  14. //利用嵌套循环实现对棋盘的打印
  15. void DisplayBorad(char borad[ROW][COL], int row, int col)
  16. {
  17. 	int i = 0;
  18. 	for (i = 0; i < row; i++)
  19. 	{
  20. 		int j = 0;
  21. 		for (j = 0; j < col; j++)
  22. 		{
  23. 			printf(" %c ", borad[i][j]);
  24. 			if(j < col - 1)
  25. 				printf("|");
  26. 		}
  27. 		printf("\n");
  28. 		
  29. 		if (i < row - 1)
  30. 		{
  31. 			for (j = 0; j < col; j++)
  32. 			{
  33. 				printf("---");
  34. 				if (j < col - 1)
  35. 					printf("|");
  36. 			}
  37. 		}
  38. 		printf("\n");
  39. 	}
  40. }
  41. //玩家下棋实现细节
  42. void PlayerMove(char borad[ROW][COL], int row, int col)
  43. {
  44. 	int x = 0;
  45. 	int y = 0;
  46. 	while (1)
  47. 	{
  48. 		printf("玩家下棋:>");
  49.         //输入想要下棋地方的坐标：行从1开始，列从1开始（数组下标从0开始，因此需要对输入数据减1）
  50. 		scanf("%d %d", &x, &y);
  51.         //对输入信息所对应的坐标进行判断和处理
  52. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  53. 		{
  54. 			if (borad[x - 1][y - 1] == ' ')
  55. 			{
  56. 				borad[x - 1][y - 1] = '*';
  57. 				break;
  58. 			}
  59. 			else
  60. 			{
  61. 				printf("该位置已被占有，请重新选择!\n");
  62. 			}
  63. 		}
  64. 		else
  65. 		{
  66. 			printf("输入错误，请重新选择！\n");
  67. 		}
  68. 	}
  69. }
  70. //电脑下棋实现细节
  71. void ComputerMove(char borad[ROW][COL], int row, int col)
  72. {
  73. 	printf("电脑下棋:>\n");
  74. 	while (1)
  75. 	{
  76.         //代码主体部分已通过srand()设置随机数生成起点，此处调用rand()库（stdlib.h）函数生成两个随机数，分别作为二维数组的行下标和列下标
  77. 		int x = rand() % row;
  78. 		int y = rand() % col;
  79.         //对坐标进行判断和处理
  80. 		if (borad[x][y] == ' ')
  81. 		{
  82. 			borad[x][y] = '#';
  83. 			break;
  84. 		}
  85. 	}
  86. }
  87.  
  88. //'*'玩家赢
  89. //'#'电脑赢
  90. //'C'继续游戏
  91. //'Q'平局
  92. //此注释内容为原始判断方法实现内容
  93. //char IsWin(char borad[ROW][COL], int row, int col)
  94. //{
  95. //	int i = 0;
  96. //	for (i = 0; i < row; i++)
  97. //	{
  98. //		if (borad[i][0] == borad[i][1] && borad[i][1] == borad[i][2] && borad[i][0] != ' ')
  99. //			return borad[i][0];
  100. //	}
  101. //	for (i = 0; i < col; i++)
  102. //	{
  103. //		if (borad[0][i] == borad[1][i] && borad[1][i] == borad[2][i] && borad[0][i] != ' ')
  104. //			return borad[0][i];
  105. //	}
  106. //	if (borad[0][0] == borad[1][1] && borad[1][1] == borad[2][2] && borad[0][0] != ' ')
  107. //		return borad[0][0];
  108. //	if (borad[0][2] == borad[1][1] && borad[1][1] == borad[2][0] && borad[0][2] != ' ')
  109. //		return borad[0][2];
  110. //	for (i = 0; i < row; i++)
  111. //	{
  112. //		int j = 0;
  113. //		for (j = 0; j < col; j++)
  114. //		{
  115. //			if (borad[i][j] == ' ')
  116. //				return 'C';
  117. //		}
  118. //	}
  119. //	return 'Q';
  120. //}
  121.  
  122. //判断优化
  123. //'*'玩家赢
  124. //'#'电脑赢
  125. //'C'继续游戏
  126. //'Q'平局
  127. char IsWin(char borad[ROW][COL], int row, int col)
  128. {
  129. 	int i = 0;
  130. 	int flag = 1;
  131. 	//行的判断实现
  132.     //循环遍历行
  133. 	for (i = 0; i < row; i++)
  134. 	{
  135.         //作为实现判断依据的变量，假设游戏已经结束。
  136. 		flag = 1;
  137.  
  138.         //作为遍历一行内容的变量
  139. 		int n = 0;
  140. 		if (borad[i][0] != ' ')
  141. 		{
  142. 			while (n < row - 1)
  143. 			{
  144. 				if (borad[i][n] != borad[i][n + 1])
  145. 				{
  146.                     //如果本行三个落棋地方不一样，置flag变量为0，表示游戏未结束
  147. 					flag = 0;
  148. 					break;
  149. 				}
  150. 				n++;
  151. 			}
  152.             //如果游戏结束，返回达成胜利条件坐标所存的字符作为判断玩家or电脑赢的依据
  153. 			if (flag)
  154. 				return borad[i][0];
  155. 		}
  156. 	}
  157. 	//列
  158.     //具体实现细节同行
  159. 	for (i = 0; i < col; i++)
  160. 	{
  161. 		flag = 1;
  162. 		int n = 0;
  163. 		if (borad[0][i] != ' ')
  164. 		{
  165. 			while (n < col - 1)
  166. 			{
  167. 				if (borad[n][i] != borad[n + 1][i])
  168. 				{
  169. 					flag = 0;
  170. 					break;
  171. 				}
  172. 				n++;
  173. 			}
  174.             //如果游戏结束，返回达成胜利条件坐标所存的字符作为判断玩家or电脑赢的依据
  175. 			if (flag)
  176. 				return borad[0][i];
  177. 		}
  178. 	}
  179.  
  180. 	//左对角线
  181.     //左对角线规律：行加一，列加一。   剩余实现原理同行
  182. 	if (borad[0][0] != ' ')
  183. 	{
  184. 		flag = 1;
  185. 		int n = 0;
  186. 		while (n < row - 1)
  187. 		{
  188. 			if (borad[n][n] != borad[n + 1][n + 1])
  189. 			{
  190. 				flag = 0;
  191. 				break;
  192. 			}
  193. 			n++;
  194.  
  195. 		}
  196.         //如果游戏结束，返回达成胜利条件坐标所存的字符作为判断玩家or电脑赢的依据
  197. 		if (flag)
  198. 			return borad[0][0];
  199. 	}
  200. 	//右对角线
  201.     //右对角线规律：开始时行为零（数组）列为col - 1，此后行加一，列减一，直至行为数组下标最大值或者列为0。  剩余实现原理同行
  202. 	int r = 0;
  203. 	int c = col - 1;
  204. 	if (borad[r][c] != ' ')
  205. 	{
  206. 		flag = 1;
  207. 		while (r < row - 1)
  208. 		{
  209. 			if (borad[r][c] != borad[r + 1][c - 1])
  210. 			{
  211. 				flag = 0;
  212. 				break;
  213. 			}
  214. 			r++;
  215. 			c--;
  216. 		}
  217.         //如果游戏结束，返回达成胜利条件坐标所存的字符作为判断玩家or电脑赢的依据
  218. 		if (flag)
  219. 			return borad[r][c];
  220. 	}
  221. 	//继续
  222.     //前面判断并未生效，因此说明此时未有赢家诞生，对数组进行遍历，看看是否还有可以落棋的地方来判断是否游戏继续或者平局
  223. 	for (i = 0; i < row; i++)
  224. 	{
  225. 		int j = 0;
  226. 		for (j = 0; j < col; j++)
  227. 		{
  228.             //如果有 ' ' 证明有地方可以落棋，返回 'C' 表示游戏继续 
  229. 			if (borad[i][j] == ' ')
  230. 				return 'C';
  231. 		}
  232. 	}
  233. 	//平局
  234.     //如果上述判断均未生效，且遍历数组发现没有可以落棋的坐标返回'Q'表示平局
  235. 	return 'Q';
  236. }

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

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

  

闽ICP备14008679号