• C语言学习-数组应用-三子棋（4.1）

    目录

    三子棋的设计思路：

    1. 游戏菜单功能的实现

    2. 游戏功能具体实现

     2.1 棋盘的初始化与打印

    2.2 玩家与电脑对战的实现

    2.3 判断胜负平局的实现

    3. 三子棋源码

    写在最后：

    三子棋的设计思路：

    我们创建三个文件拆分三子棋的实现过程：

    一个测试文件（test.c）游戏实现文件（game.c）头文件（game.h）

    我们先对测试文件进行编辑。

    1. 游戏菜单功能的实现

    在 test.c 中写一个主函数：

    1. int main()//主函数尽量放的东西少一点
    2. {
    3. 	test();//可以通过创建一个函数实现其他功能
    4. 	return 0;
    5. }

    我们通过刚刚创建的 test 函数实现一些功能：

    1. 玩一把不过瘾，在玩一把

    2. 创建游戏菜单

    3. 创建游戏实现函数

    1. void test()
    2. {
    3. 	int choice = 0;
    4. 	do  //我们使用一个do while循环，如果玩一把三子棋不过瘾，可以再玩一把
    5. 	{
    6. 		menu();
    7. 		printf("请选择:>");
    8. 		scanf("%d", &choice);//接收玩家输入的值
    9. 		switch (choice)
    10. 		{
    11. 		case 1:
    12. 			printf("三子棋游戏开始\n");
    13. 			game();//我们将游戏的实现分装成一个函数
    14. 			break;
    15. 		case 0:
    16. 			printf("游戏已退出\n");
    17. 			break;
    18. 		default:
    19. 			printf("输入错误，请重新输入\n");
    20. 			break;
    21. 	}
    22. 	} while (choice);
    23. }

    这是我们的游戏菜单：

    1. void menu()//打印游戏菜单界面
    2. {
    3. 	printf("***************************************\n");
    4. 	printf("*****  开始游戏：1    退出游戏：0  *****\n");
    5. 	printf("***************************************\n");
    6.  
    7. }

    写到这里，我们可以先测试一下代码运行的结果：

    这样，我们就完成了菜单逻辑的制作

    2. 游戏功能具体实现

    接下来我们要具体实现函数 game 。

     2.1 棋盘的初始化与打印

    实现思路：

    首先，我们需要记录玩家和电脑的落子情况

     通过分析，能落子的地方有九个，

    我们可以通过创建一个3*3的数组对其进行记录。

    我们在头文件中用#define定义常量，便于日后观察或修改

     再在测试文件中引用：

    1. #include "game.h"//引用自己的头文件
    2.  
    3. void game()//三子棋的实现
    4. {
    5. 	char board[ROW][COL];//存放玩家或电脑的落子情况
    6. }

    接下来我们需要让落子位置初始化，并将三子棋的棋盘打印出来：

    我们将初始化和棋盘打印这两个步骤分装成两个函数并在 game.c 中实现：

     为了能够使用这两个函数，我们需要在头文件中声明：

    1. void init_board(char board[ROW][COL], int row, int col);
    2. void print_board(char board[ROW][COL], int row, int col);

    初始化棋盘的具体实现：

    1. void init_board(char board[ROW][COL], int row, int col)
    2. {
    3. 	int i = 0;
    4. 	for (i = 0; i < row; i++)
    5. 	{
    6. 		int j = 0;
    7. 		for (j = 0; j < col; j++)
    8. 		{
    9. 			board[i][j] = ' ';//将落子位置初始化成空格
    10. 		}
    11. 	}
    12. }

    打印棋盘的具体实现：

    1.  
    2. 	void print_board(char board[ROW][COL], int row, int col)
    3. 	{
    4. 		int i = 0;
    5. 		for (i = 0; i < col; i++)
    6. 		{
    7. 			printf("  %d ", i + 1);//添加纵坐标
    8. 		}
    9. 		printf("\n");
    10. 		for (i = 0; i < row; i++)
    11. 		{
    12. 			int j = 0;
    13. 			printf("%d", i + 1);//添加横坐标
    14. 			for (j = 0; j < col; j++)
    15. 			{
    16. 				printf(" %c ", board[i][j]);//打印三行，每行三个 %c 
    17. 				if (j < col - 1)//井字棋的棋盘只需要中间两排竖着的分割线
    18. 				{
    19. 					printf("|");//打印三行，每行两个‘|’
    20. 				}
    21. 			}
    22. 			printf("\n");
    23. 			if (i < row - 1)//只需要两行分割线
    24. 			{
    25. 				printf(" ");//对齐
    26. 				for (j = 0; j < col; j++)
    27. 				{
    28. 					printf("---");//打印两行，每行三个‘---’
    29. 					if (j < col - 1)
    30. 					{
    31. 						printf("|");//打印两行，每行两个‘|’
    32. 					}
    33. 				}
    34. 			}
    35. 			printf("\n");
    36. 		}
    37. 	}

    最后呈现的结果是这样的：

    2.2 玩家与电脑对战的实现

     接下来就是下棋了，我们把下棋分为两步：

    1. 玩家回合

    2. 电脑回合

    并且每次下完把棋盘打印出来：

    然后将函数在头文件中声明，在 game.c 中实现：

    声明：

    1. void player_move(char board[ROW][COL], int row, int col);
    2. void computer_move(char board[ROW][COL], int row, int col);

     玩家回合的实现：

    1. 	void player_move(char board[ROW][COL], int row, int col)
    2. 	{
    3. 		printf("玩家回合\n");
    4. 		while (1)
    5. 		{
    6. 			printf("请输入要下的坐标:>");
    7. 			int x = 0;
    8. 			int y = 0;
    9. 			scanf("%d %d", &x, &y);
    10. 			//坐标合法（在棋盘中）
    11. 			if (x >= 1 && x <= row && y >= 1 && y <= col)
    12. 			{
    13. 				if (board[x - 1][y - 1] == ' ')//坐标是空的
    14. 				{
    15. 					board[x - 1][y - 1] = '*';
    16. 					break;//选择成功后就跳出循环
    17. 				}
    18. 				else
    19. 				{
    20. 					printf("那个位置已经被占了，请重新选择\n");
    21. 				}
    22. 			}
    23. 			else
    24. 			{
    25. 				printf("你选的坐标不在棋盘内，请重新选择\n");
    26. 			}
    27. 		}
    28. 	}

    电脑回合的实现：

    1. 	void computer_move(char board[ROW][COL], int row, int col)
    2. 	{
    3. 		printf("电脑回合\n");
    4. 		while (1)
    5. 		{
    6. 			int x = rand() % row;//生成随机数
    7. 			int y = rand() % col;
    8.  
    9. 			if (board[x][y] == ' ')
    10. 			{
    11. 				board[x][y] = '#';
    12. 				break;
    13. 			}
    14. 		}
    15. 	}

    生成随机数时：

    现在就到了最后一步，

    2.3 判断胜负平局的实现

    判断输赢：

    1. void game()//三子棋的实现
    2. {
    3. 	char ret = 0;//我们通过返回字符判断输赢
    4. 	char board[ROW][COL];//存放玩家或电脑的落子情况
    5.  
    6. 	init_board(board, ROW, COL);//初始化棋盘
    7. 	print_board(board, ROW, COL);//打印棋盘
    8.  
    9. 	while (1)//创建一个循环，直到分出胜负或平局再跳出
    10. 	{
    11. 		player_move(board, ROW, COL);//玩家下
    12. 		print_board(board, ROW, COL);
    13.  
    14. 		ret = is_win(board, ROW, COL);
    15. 		if (ret != 'C')//判断游戏是否继续
    16. 		{
    17. 			break;//当ret不等于C时，跳出循环，判断输赢
    18. 		}
    19.  
    20. 		computer_move(board, ROW, COL);//电脑下
    21. 		print_board(board, ROW, COL);
    22.  
    23. 		ret = is_win(board, ROW, COL);
    24. 		if (ret != 'C')
    25. 		{
    26. 			break;
    27. 		}
    28. 	}
    29. 	    //判断输赢
    30. 	if (ret == '*')
    31. 	{
    32. 		printf("你赢了\n");
    33. 	}
    34. 	else if (ret == '#')
    35. 	{
    36. 		printf("电脑获胜\n");
    37. 	}
    38. 	else if (ret == 'Q')
    39. 		{
    40. 			printf("平局\n");
    41. 		}
    42. }

    这样，当ret返回 * 是玩家获胜，返回 # 时电脑获胜，都不返回则平局。

    接下来需要实现 is_win 函数：

    （实现函数时，别忘了在头文件中声明哦）

    1. 	char is_win(char board[ROW][COL], int row, int col)
    2. 	{
    3. 		int i = 0;
    4. 		//判断三行
    5. 		for (i = 0; i < row; i++)
    6. 		{
    7. 			if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
    8. 			{
    9. 				return board[i][0];
    10. 			}
    11. 		}
    12. 		//判断三列
    13. 		for (i = 0; i < col; i++)
    14. 		{
    15. 			if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
    16. 			{
    17. 				return board[0][i];
    18. 			}
    19. 		}
    20. 		//判断对角线
    21. 		if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
    22. 		{
    23. 			return board[1][1];
    24. 		}
    25. 		if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
    26. 		{
    27. 			return board[1][1];
    28. 		}
    29. 	}

    还有平局的情况，可以再分装成一个函数实现：

    1. //平局
    2. 		if (is_full(board, row, col) == 1)//判断棋盘是否满了
    3. 		{
    4. 			return 'Q';
    5. 		}
    6. 		return 'C';

    函数 is_full 的实现：

    1. 	int is_full(char board[ROW][COL], int row, int col)
    2. 	{
    3. 		int i = 0;
    4. 		int j = 0;
    5. 		for (i = 0; i < row; i++)
    6. 		{
    7. 			for (j = 0; j < col; j++)
    8. 			{
    9. 				if (board[i][j] == ' ')
    10. 				{
    11. 					return 0;
    12. 				}
    13. 			}
    14. 		}
    15. 		return 1;
    16. 	}

    现在，三子棋就做完了，我们一起赢一把看看效果：

     学会了吗？

    快去试试吧!

    3. 三子棋源码

    这里是源码：

    1. test.c 文件：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "game.h"//引用自己的头文件
    4.  
    5. void menu()//打印游戏菜单界面
    6. {
    7. 	printf("***************************************\n");
    8. 	printf("*****  开始游戏：1   退出游戏：0  *****\n");
    9. 	printf("***************************************\n");
    10.  
    11. }
    12.  
    13. void game()//三子棋的实现
    14. {
    15. 	char ret = 0;//我们通过返回字符判断输赢
    16. 	char board[ROW][COL];//存放玩家或电脑的落子情况
    17.  
    18. 	init_board(board, ROW, COL);//初始化棋盘
    19. 	print_board(board, ROW, COL);//打印棋盘
    20.  
    21. 	while (1)//创建一个循环，直到分出胜负或平局再跳出
    22. 	{
    23. 		player_move(board, ROW, COL);//玩家下
    24. 		print_board(board, ROW, COL);
    25.  
    26. 		ret = is_win(board, ROW, COL);
    27. 		if (ret != 'C')//判断游戏是否继续
    28. 		{
    29. 			break;//当ret不等于C时，跳出循环，判断输赢
    30. 		}
    31.  
    32. 		computer_move(board, ROW, COL);//电脑下
    33. 		print_board(board, ROW, COL);
    34.  
    35. 		ret = is_win(board, ROW, COL);
    36. 		if (ret != 'C')
    37. 		{
    38. 			break;
    39. 		}
    40. 	}
    41. 	    //判断输赢
    42. 	if (ret == '*')
    43. 	{
    44. 		printf("你赢了\n");
    45. 	}
    46. 	else if (ret == '#')
    47. 	{
    48. 		printf("电脑获胜\n");
    49. 	}
    50. 	else if (ret == 'Q')
    51. 		{
    52. 			printf("平局\n");
    53. 		}
    54. }
    55.  
    56. void test()
    57. {
    58. 	srand((unsigned int)time(NULL));//通过时间戳生成随机数
    59. 	int choice = 0;
    60. 	do  //我们使用一个do while循环，如果玩一把三子棋不过瘾，可以再玩一把
    61. 	{
    62. 		menu();
    63. 		printf("请选择:>");
    64. 		scanf("%d", &choice);//接收玩家输入的值
    65. 		switch (choice)
    66. 		{
    67. 		case 1:
    68. 			printf("三子棋游戏开始：\n");
    69. 			game();//我们将游戏的实现分装成一个函数
    70. 			break;
    71. 		case 0:
    72. 			printf("游戏已退出\n");
    73. 			break;
    74. 		default:
    75. 			printf("输入错误，请重新输入\n");
    76. 			break;
    77. 	}
    78. 	} while (choice);
    79. }
    80.  
    81. int main()//主函数尽量放的东西少一点
    82. {
    83. 	test();//可以通过创建一个函数实现其他功能
    84. 	return 0;
    85. }

    2. game.h 文件：

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6.  
    7. #define ROW 3 
    8. #define COL 3
    9.  
    10. void init_board(char board[ROW][COL], int row, int col);
    11. void print_board(char board[ROW][COL], int row, int col);
    12.  
    13. void player_move(char board[ROW][COL], int row, int col);
    14. void computer_move(char board[ROW][COL], int row, int col);
    15.  
    16. char  is_win(char board[ROW][COL], int row, int col);

    3. game.c 文件：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "game.h"
    4.  
    5. void init_board(char board[ROW][COL], int row, int col)
    6. {
    7. 	int i = 0;
    8. 	for (i = 0; i < row; i++)
    9. 	{
    10. 		int j = 0;
    11. 		for (j = 0; j < col; j++)
    12. 		{
    13. 			board[i][j] = ' ';//将落子位置初始化成空格
    14. 		}
    15. 	}
    16. }
    17.  
    18. 	void print_board(char board[ROW][COL], int row, int col)
    19. 	{
    20. 		int i = 0;
    21. 		for (i = 0; i < col; i++)
    22. 		{
    23. 			printf("  %d ", i + 1);//添加纵坐标
    24. 		}
    25. 		printf("\n");
    26. 		for (i = 0; i < row; i++)
    27. 		{
    28. 			int j = 0;
    29. 			printf("%d", i + 1);//添加横坐标
    30. 			for (j = 0; j < col; j++)
    31. 			{
    32. 				printf(" %c ", board[i][j]);//打印三行，每行三个 %c 
    33. 				if (j < col - 1)//井字棋的棋盘只需要中间两排竖着的分割线
    34. 				{
    35. 					printf("|");//打印三行，每行两个‘|’
    36. 				}
    37. 			}
    38. 			printf("\n");
    39. 			if (i < row - 1)//只需要两行分割线
    40. 			{
    41. 				printf(" ");//对齐
    42. 				for (j = 0; j < col; j++)
    43. 				{
    44. 					printf("---");//打印两行，每行三个‘---’
    45. 					if (j < col - 1)
    46. 					{
    47. 						printf("|");//打印两行，每行两个‘|’
    48. 					}
    49. 				}
    50. 			}
    51. 			printf("\n");
    52. 		}
    53. 	}
    54.  
    55. 	void player_move(char board[ROW][COL], int row, int col)
    56. 	{
    57. 		printf("玩家回合\n");
    58. 		while (1)
    59. 		{
    60. 			printf("请输入要下的坐标:>");
    61. 			int x = 0;
    62. 			int y = 0;
    63. 			scanf("%d %d", &x, &y);
    64. 			//坐标合法（在棋盘中）
    65. 			if (x >= 1 && x <= row && y >= 1 && y <= col)
    66. 			{
    67. 				if (board[x - 1][y - 1] == ' ')//坐标是空的
    68. 				{
    69. 					board[x - 1][y - 1] = '*';
    70. 					break;//选择成功后就跳出循环
    71. 				}
    72. 				else
    73. 				{
    74. 					printf("那个位置已经被占了，请重新选择\n");
    75. 				}
    76. 			}
    77. 			else
    78. 			{
    79. 				printf("你选的坐标不在棋盘内，请重新选择\n");
    80. 			}
    81. 		}
    82. 	}
    83.  
    84. 	void computer_move(char board[ROW][COL], int row, int col)
    85. 	{
    86. 		printf("电脑回合\n");
    87. 		while (1)
    88. 		{
    89. 			int x = rand() % row;//生成随机数
    90. 			int y = rand() % col;
    91.  
    92. 			if (board[x][y] == ' ')
    93. 			{
    94. 				board[x][y] = '#';
    95. 				break;
    96. 			}
    97. 		}
    98. 	}
    99.  
    100. 	int is_full(char board[ROW][COL], int row, int col)
    101. 	{
    102. 		int i = 0;
    103. 		int j = 0;
    104. 		for (i = 0; i < row; i++)
    105. 		{
    106. 			for (j = 0; j < col; j++)
    107. 			{
    108. 				if (board[i][j] == ' ')
    109. 				{
    110. 					return 0;
    111. 				}
    112. 			}
    113. 		}
    114. 		return 1;
    115. 	}
    116.  
    117. 	char is_win(char board[ROW][COL], int row, int col)
    118. 	{
    119. 		int i = 0;
    120. 		//判断三行
    121. 		for (i = 0; i < row; i++)
    122. 		{
    123. 			if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
    124. 			{
    125. 				return board[i][0];
    126. 			}
    127. 		}
    128. 		//判断三列
    129. 		for (i = 0; i < col; i++)
    130. 		{
    131. 			if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
    132. 			{
    133. 				return board[0][i];
    134. 			}
    135. 		}
    136. 		//判断对角线
    137. 		if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
    138. 		{
    139. 			return board[1][1];
    140. 		}
    141. 		if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
    142. 		{
    143. 			return board[1][1];
    144. 		}
    145. 		//平局
    146. 		if (is_full(board, row, col) == 1)//判断棋盘是否满了
    147. 		{
    148. 			return 'Q';
    149. 		}
    150. 		return 'C';
    151. 	}

    写在最后：

    以上就是本篇文章的内容了，感谢你的阅读。

    如果喜欢本文的话，欢迎点赞和评论，写下你的见解。

    如果想和我一起学习编程，不妨点个关注，我们一起学习，一同成长。

    之后我还会输出更多高质量内容，欢迎收看

  • 相关阅读:
    项目版本号大小比较，找出最大版本号
    MySQL 教程：MySQL IN 语句（高级）
    【Python零基础入门篇 · 27】：文件操作
    centos 部署java环境，拷贝jar包并运行
    OpenCV自学笔记十一：形态学操作（一）
    Spring源码解析——Spring事务是怎么通过AOP实现的？
    非关系型数据库（NoSQL）——redis
    docker搭建nginx
    Kotlin 协程 (7/7篇) - 在Android中的使用
    lintcode 553 · 炸弹袭击【中等 数组+bfs+模拟】
  • 原文地址：https://blog.csdn.net/Locky136/article/details/127696187