• C语言第十课(下)：优化井字棋游戏

    目录

    前言：

    一、优手着棋判定：

            1.防守型着棋优化：

            2.进攻型着棋优化：

    二、界面格式优化：

            1.Sleep休眠语句：

            2.system语句：

    三、优化后最终全部代码：

            1.头文件game.h:

            2.函数功能文件game.h：

            3.程序主体文件test.c：

    四、总结：

    前言：

            在上一篇文章中，我和各位小伙伴们一起，通过使用我们前面学习的C语言知识，编写出了一个基础版的井字棋游戏。不过我们也发现，作为基础版的井字棋游戏，它存在着很多缺陷，而在本文中，我们将要对基础版井字棋进行着棋、界面两个方面的优化。

    一、优手着棋判定：

            1.防守型着棋优化：

            对于一个程序的优化，首先我们应当对其功能缺陷进行优化，而在基础版井字棋中，最大的功能缺陷便是电脑在进行着棋时，没有进行着棋优手判定，在玩家着棋后不会对玩家的进攻性着棋进行围堵，于是这里的优化便是要尝试解决这个问题。

            电脑着棋的优化，主要在于其着棋时应当对当前场上的局势进行判断，倘若在玩家横向、纵向、斜向三个方向上出现两子连子，且第三个位置上仍为空时，就应当在第三个空位上进行着棋以实现对玩家的拦截。

            原理大致了解之后，我们来研究一下具体情况的实现。首先判定应当分为三个方向，即横向，纵向与斜向。而在每个方向上，根据规则连成三子即为胜利可以得出，当下一步即将出现胜利情况时，就应当进行阻止。

            以横向为例，会出现三种情况，即在一行中前两个位置相同而第三个位置空缺，此时应当着棋于位置三；第二种情况是在一行中后两个位置相同而首位置空缺，此时应当着棋于位置一；第三种情况为一三位置相同而中间位置空缺，此时则应当着棋于中间位置。

            则纵向与斜向原理也相同。根据我们整理出来的拦截原理，我们可以轻松地写出优手拦截的程序代码：

    1. {
    2. 	int i = 0;
    3. 	//遍历行优手判断：
    4. 	for (i = 0; i < row; i++)
    5. 	{
    6. 		if (board[i][0] == board[i][1] && board[i][0] == '*' && board[i][2] == ' ')
    7. 		{
    8. 			board[i][2] = 'O';
    9. 			return 1;
    10. 		}
    11. 		if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
    12. 		{
    13. 			board[i][0] = 'O';
    14. 			return 1;
    15. 		}
    16. 		if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
    17. 		{
    18. 			board[i][1] = 'O';
    19. 			return 1;
    20. 		}
    21. 	}
    22. 	//遍历列优手判断：
    23. 	for (i = 0; i < col; i++)
    24. 	{
    25. 		if (board[0][i] == board[1][i] && board[0][i] == '*' && board[2][i] == ' ')
    26. 		{
    27. 			board[2][i] = 'O';
    28. 			return 1;
    29. 		}
    30. 		if (board[1][i] == board[2][i] && board[1][i] == '*' && board[0][i] == ' ')
    31. 		{
    32. 			board[0][i] = 'O';
    33. 			return 1;
    34. 		}
    35. 		if (board[0][i] == board[2][i] && board[0][i] == '*' && board[1][i] == ' ')
    36. 		{
    37. 			board[1][i] = 'O';
    38. 			return 1;
    39. 		}
    40. 	}
    41. 	//右斜对角线优手判断：
    42. 	if (board[0][0] == board[1][1] && board[0][0] == '*' && board[2][2] == ' ')
    43. 	{
    44. 		board[2][2] = 'O';
    45. 		return 1;
    46. 	}
    47. 	if (board[0][0] == board[2][2] && board[0][0] == '*' && board[1][1] == ' ')
    48. 	{
    49. 		board[1][1] = 'O';
    50. 		return 1;
    51. 	}
    52. 	if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
    53. 	{
    54. 		board[0][0] = 'O';
    55. 		return 1;
    56. 	}
    57. 	//左斜对角线优手判断：
    58. 	if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
    59. 	{
    60. 		board[2][0] = 'O';
    61. 		return 1;
    62. 	}
    63. 	if (board[1][1] == board[2][0] && board[1][1] == '*' && board[0][2] == ' ')
    64. 	{
    65. 		board[0][2] = 'O';
    66. 		return 1;
    67. 	}
    68. 	if (board[0][2] == board[2][0] && board[0][2] == '*' && board[1][1] == ' ')
    69. 	{
    70. 		board[1][1] = 'O';
    71. 		return 1;
    72. 	}
    73. 	return 0;
    74. }

            如此，优手判断模块就完成了，接着我们只需要让电脑在着棋时进行判断，若是符合优手的着棋便进行优手着棋，若没有出现需要拦截的情况，再根据我们之前定义的随机值确定着棋坐标：

    1. void computer_move(char board[ROW][COL], int row, int col)
    2. {
    3. 	printf("电脑正在着棋！\n");
    4. 	if (computer_better_move(board, row, col))
    5. 	{
    6. 		;
    7. 	}
    8. 	else
    9. 	{
    10. 		while (1)
    11. 		{
    12. 			int x = rand() % row;
    13. 			int y = rand() % col;
    14. 			if (board[x][y] == ' ')
    15. 			{
    16. 				board[x][y] = 'O';
    17. 				break;
    18. 			}
    19. 		}
    20. 	}
    21. }

            这里的执行逻辑是，if 语句的判断条件为函数“ 优手判断的返回值 ”。在优手判断函数中，若符合优手着棋的条件，便进行优手着棋，同时返回值为1，此时电脑着棋函数中的if语句判断为真，随机着棋便不再进行；若局面情况均不符合优手着棋情况，不进行优手着棋则右手判断函数返回值为0，电脑着棋函数中if语句判断为假，执行随机着棋操作。

            2.进攻型着棋优化：

            以上即为井字棋游戏的防守型着棋优化。我们还可以对电脑的进攻进行优化，即在进行防守判断前先进行判断，若电脑方已有连字或隔子，即拥有直接获胜条件时，走出进攻型着棋。

            原理很简单且与防守相同，不过这次的着棋优化判断对象为电脑自己的着棋，只需对防守着棋优化稍加改动即可：

    1. int computer_Better_move(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][0] == 'O' && board[i][2] == ' ')
    8. 		{
    9. 			board[i][2] = 'O';
    10. 			return 1;
    11. 		}
    12. 		if (board[i][1] == board[i][2] && board[i][1] == 'O' && board[i][0] == ' ')
    13. 		{
    14. 			board[i][0] = 'O';
    15. 			return 1;
    16. 		}
    17. 		if (board[i][0] == board[i][2] && board[i][0] == 'O' && board[i][1] == ' ')
    18. 		{
    19. 			board[i][1] = 'O';
    20. 			return 1;
    21. 		}
    22. 	}
    23. 	//遍历列优手判断：
    24. 	for (i = 0; i < col; i++)
    25. 	{
    26. 		if (board[0][i] == board[1][i] && board[0][i] == 'O' && board[2][i] == ' ')
    27. 		{
    28. 			board[2][i] = 'O';
    29. 			return 1;
    30. 		}
    31. 		if (board[1][i] == board[2][i] && board[1][i] == 'O' && board[0][i] == ' ')
    32. 		{
    33. 			board[0][i] = 'O';
    34. 			return 1;
    35. 		}
    36. 		if (board[0][i] == board[2][i] && board[0][i] == 'O' && board[1][i] == ' ')
    37. 		{
    38. 			board[1][i] = 'O';
    39. 			return 1;
    40. 		}
    41. 	}
    42. 	//右斜对角线优手判断：
    43. 	if (board[0][0] == board[1][1] && board[0][0] == 'O' && board[2][2] == ' ')
    44. 	{
    45. 		board[2][2] = 'O';
    46. 		return 1;
    47. 	}
    48. 	if (board[0][0] == board[2][2] && board[0][0] == 'O' && board[1][1] == ' ')
    49. 	{
    50. 		board[1][1] = 'O';
    51. 		return 1;
    52. 	}
    53. 	if (board[1][1] == board[2][2] && board[1][1] == 'O' && board[0][0] == ' ')
    54. 	{
    55. 		board[0][0] = 'O';
    56. 		return 1;
    57. 	}
    58. 	//左斜对角线优手判断：
    59. 	if (board[0][2] == board[1][1] && board[0][2] == 'O' && board[2][0] == ' ')
    60. 	{
    61. 		board[2][0] = 'O';
    62. 		return 1;
    63. 	}
    64. 	if (board[1][1] == board[2][0] && board[1][1] == 'O' && board[0][2] == ' ')
    65. 	{
    66. 		board[0][2] = 'O';
    67. 		return 1;
    68. 	}
    69. 	if (board[0][2] == board[2][0] && board[0][2] == 'O' && board[1][1] == ' ')
    70. 	{
    71. 		board[1][1] = 'O';
    72. 		return 1;
    73. 	}
    74. 	return 0;
    75. }

            定义出进攻型着棋优化后，我们同样对电脑着棋函数进行改动：

    1. void computer_move(char board[ROW][COL], int row, int col)
    2. {
    3. 	printf("电脑正在着棋！\n");
    4. 	if (computer_Better_move(board, row, col))
    5. 	{
    6. 		;
    7. 	}
    8. 	else
    9. 	{
    10. 		if (computer_better_move(board, row, col))
    11. 		{
    12. 			;
    13. 		}
    14. 		else
    15. 		{
    16. 			while (1)
    17. 			{
    18. 				int x = rand() % row;
    19. 				int y = rand() % col;
    20. 				if (board[x][y] == ' ')
    21. 				{
    22. 					board[x][y] = 'O';
    23. 					break;
    24. 				}
    25. 			}
    26. 		}
    27. 	}
    28. }

            其实现逻辑与防守型着棋优化完全一致，不同的是此处采用了嵌套判断，先进行进攻型判断，没有进攻条件时进行防守，既没有进攻条件也无需进行防守时，再进行随机着棋。

            至此，我们关于井字棋的着棋优化就完成了。

    二、界面格式优化：

           我们目前写出的代码，运行起来后是这样的：

            这样一大串的打印形式，使得我们的界面看起来非常的不美观，那么有没有办法能够使得我们的界面看起来整洁一些呢？答案是，有。 

            我们可以通过使用下面两个语句来实现对界面的优化：

            1.Sleep休眠语句：

    Sleep(num);

            它的作用是， 使程序在延长预定时间后继续执行下一个步骤，设置休眠时间的方式是修改Sleep后方括号内的参数num的数值，单位为毫秒。

            要注意的是该语句在使用时，需要引用头文件Windows.h：

    #include

            2.system语句：

    int system(const char * command)

            该函数功能为执行 dos(windows系统) 或 shell(Linux/Unix系统) 命令，参数字符串command为命令名。另，在windows系统下参数字符串不区分大小写。

            我们一般情况下使用的系统为Windows系统，故针对Windows系统进行说明。在windows系统中，system函数直接在控制台调用一个command命令。

            该函数语句在使用时需引用头文件stdlib.h：

    #include

            在这里对我们的井字棋游戏界面进行优化时需要用到的命令是：

    system("cls");

            这个命令的作用通俗来讲就是“ 清屏 ”，使用该函数命令，可以实现将之前打印在屏幕上的内容进行清空，并继续打印接下来的内容。运用在我们的程序中，就可以实现在每一个步骤完成后进行清屏，再继续执行接下来的步骤。

            通过灵活的结合使用上面的两种语句，我们可以使我们的游戏程序界面变得简洁而流畅。

    三、优化后最终全部代码：

            1.头文件game.h:

    1. #pragma once
    2.  
    3. #define ROW 3
    4. #define COL 3
    5. //进行宏定义，好处是进行游戏修改时不需要对每个参数都进行修改
    6.  
    7. #include
    8. #include
    9. #include
    10. #include
    11. //因为此头文件会被引用，故在此头文件中引用的其它头文件也会被包含引用
    12.  
    13. //头文件中进行函数的声明：
    14. void init_board(char board[ROW][COL], int row, int col);
    15. void print_board(char board[ROW][COL], int row, int col);
    16. void player_move(char board[ROW][COL], int row, int col);
    17. int computer_better_move(char board[ROW][COL], int row, int col);
    18. void computer_move(char board[ROW][COL], int row, int col);
    19. char is_win(char board[ROW][COL], int row, int col);

            2.函数功能文件game.h：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "game.h"
    4.  
    5. //棋盘初始化（使无着棋位置均使用空格占位）：
    6. void init_board(char board[ROW][COL], int row, int col)
    7. {
    8. 	int i = 0;
    9. 	for (i = 0; i < row; i++)
    10. 	{
    11. 		int j = 0;
    12. 		for (j = 0; j < col; j++)
    13. 		{
    14. 			board[i][j] = ' ';
    15. 		}
    16. 	}
    17. }
    18.  
    19. //打印棋盘：
    20. void print_board(char board[ROW][COL], int row, int col)
    21. {
    22. 	int i = 0;
    23. 	for (i = 0; i < row; i++)
    24. 	{
    25. 		int j = 0;
    26. 		for (j = 0; j < col; j++)
    27. 		{
    28. 			printf("   %c   ", board[i][j]);
    29. 			if (j < col - 1)
    30. 			{
    31. 				printf("|");
    32. 			}
    33. 		}
    34. 		printf("\n");
    35. 		if (i < row - 1)
    36. 		{
    37. 			for (j = 0; j < col; j++)
    38. 			{
    39. 				printf("-------");
    40. 				if (j < col - 1)
    41. 				{
    42. 					printf("|");
    43. 				}
    44. 			}
    45. 			printf("\n");
    46. 		}
    47. 	}
    48. }
    49.  
    50. //玩家着棋：
    51. void player_move(char board[ROW][COL], int row, int col)
    52. {
    53. 	while (1)
    54. 	{
    55. 		int x, y;
    56. 		x = y = 0;
    57. 		printf("请着棋：\n");
    58. 		printf("您想下在第几行：");
    59. 		scanf("%d", &x);
    60. 		Sleep(1000);
    61. 		printf("您想下在第几列：");
    62. 		scanf("%d", &y);
    63. 		Sleep(500);
    64. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    65. 		{
    66. 			if (board[x - 1][y - 1] == ' ')
    67. 			{
    68. 				board[x - 1][y - 1] = '*';
    69. 				system("cls");
    70. 				break;
    71. 			}
    72. 			else
    73. 			{
    74. 				system("cls");
    75. 				printf("这个位置已经有棋子了喔！请重新输入！\n");
    76. 				Sleep(1500);
    77. 				system("cls");
    78. 				print_board(board, ROW, COL);
    79. 			}
    80. 		}
    81. 		else
    82. 		{
    83. 			system("cls");
    84. 			printf("输入坐标有误，请重新输入！\n");
    85. 			Sleep(1500);
    86. 			system("cls");
    87. 			print_board(board, ROW, COL);
    88. 		}
    89. 	}
    90. }
    91.  
    92. //电脑防守型着棋优手判定：
    93. int computer_better_move(char board[ROW][COL], int row, int col)
    94. {
    95. 	int i = 0;
    96. 	//遍历行优手判断：
    97. 	for (i = 0; i < row; i++)
    98. 	{
    99. 		if (board[i][0] == board[i][1] && board[i][0] == '*' && board[i][2] == ' ')
    100. 		{
    101. 			board[i][2] = 'O';
    102. 			return 1;
    103. 		}
    104. 		if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
    105. 		{
    106. 			board[i][0] = 'O';
    107. 			return 1;
    108. 		}
    109. 		if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
    110. 		{
    111. 			board[i][1] = 'O';
    112. 			return 1;
    113. 		}
    114. 	}
    115. 	//遍历列优手判断：
    116. 	for (i = 0; i < col; i++)
    117. 	{
    118. 		if (board[0][i] == board[1][i] && board[0][i] == '*' && board[2][i] == ' ')
    119. 		{
    120. 			board[2][i] = 'O';
    121. 			return 1;
    122. 		}
    123. 		if (board[1][i] == board[2][i] && board[1][i] == '*' && board[0][i] == ' ')
    124. 		{
    125. 			board[0][i] = 'O';
    126. 			return 1;
    127. 		}
    128. 		if (board[0][i] == board[2][i] && board[0][i] == '*' && board[1][i] == ' ')
    129. 		{
    130. 			board[1][i] = 'O';
    131. 			return 1;
    132. 		}
    133. 	}
    134. 	//右斜对角线优手判断：
    135. 	if (board[0][0] == board[1][1] && board[0][0] == '*' && board[2][2] == ' ')
    136. 	{
    137. 		board[2][2] = 'O';
    138. 		return 1;
    139. 	}
    140. 	if (board[0][0] == board[2][2] && board[0][0] == '*' && board[1][1] == ' ')
    141. 	{
    142. 		board[1][1] = 'O';
    143. 		return 1;
    144. 	}
    145. 	if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
    146. 	{
    147. 		board[0][0] = 'O';
    148. 		return 1;
    149. 	}
    150. 	//左斜对角线优手判断：
    151. 	if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
    152. 	{
    153. 		board[2][0] = 'O';
    154. 		return 1;
    155. 	}
    156. 	if (board[1][1] == board[2][0] && board[1][1] == '*' && board[0][2] == ' ')
    157. 	{
    158. 		board[0][2] = 'O';
    159. 		return 1;
    160. 	}
    161. 	if (board[0][2] == board[2][0] && board[0][2] == '*' && board[1][1] == ' ')
    162. 	{
    163. 		board[1][1] = 'O';
    164. 		return 1;
    165. 	}
    166. 	return 0;
    167. }
    168.  
    169. //电脑进攻型着棋判定：
    170. int computer_Better_move(char board[ROW][COL], int row, int col)
    171. {
    172. 	int i = 0;
    173. 	//遍历行优手判断：
    174. 	for (i = 0; i < row; i++)
    175. 	{
    176. 		if (board[i][0] == board[i][1] && board[i][0] == 'O' && board[i][2] == ' ')
    177. 		{
    178. 			board[i][2] = 'O';
    179. 			return 1;
    180. 		}
    181. 		if (board[i][1] == board[i][2] && board[i][1] == 'O' && board[i][0] == ' ')
    182. 		{
    183. 			board[i][0] = 'O';
    184. 			return 1;
    185. 		}
    186. 		if (board[i][0] == board[i][2] && board[i][0] == 'O' && board[i][1] == ' ')
    187. 		{
    188. 			board[i][1] = 'O';
    189. 			return 1;
    190. 		}
    191. 	}
    192. 	//遍历列优手判断：
    193. 	for (i = 0; i < col; i++)
    194. 	{
    195. 		if (board[0][i] == board[1][i] && board[0][i] == 'O' && board[2][i] == ' ')
    196. 		{
    197. 			board[2][i] = 'O';
    198. 			return 1;
    199. 		}
    200. 		if (board[1][i] == board[2][i] && board[1][i] == 'O' && board[0][i] == ' ')
    201. 		{
    202. 			board[0][i] = 'O';
    203. 			return 1;
    204. 		}
    205. 		if (board[0][i] == board[2][i] && board[0][i] == 'O' && board[1][i] == ' ')
    206. 		{
    207. 			board[1][i] = 'O';
    208. 			return 1;
    209. 		}
    210. 	}
    211. 	//右斜对角线优手判断：
    212. 	if (board[0][0] == board[1][1] && board[0][0] == 'O' && board[2][2] == ' ')
    213. 	{
    214. 		board[2][2] = 'O';
    215. 		return 1;
    216. 	}
    217. 	if (board[0][0] == board[2][2] && board[0][0] == 'O' && board[1][1] == ' ')
    218. 	{
    219. 		board[1][1] = 'O';
    220. 		return 1;
    221. 	}
    222. 	if (board[1][1] == board[2][2] && board[1][1] == 'O' && board[0][0] == ' ')
    223. 	{
    224. 		board[0][0] = 'O';
    225. 		return 1;
    226. 	}
    227. 	//左斜对角线优手判断：
    228. 	if (board[0][2] == board[1][1] && board[0][2] == 'O' && board[2][0] == ' ')
    229. 	{
    230. 		board[2][0] = 'O';
    231. 		return 1;
    232. 	}
    233. 	if (board[1][1] == board[2][0] && board[1][1] == 'O' && board[0][2] == ' ')
    234. 	{
    235. 		board[0][2] = 'O';
    236. 		return 1;
    237. 	}
    238. 	if (board[0][2] == board[2][0] && board[0][2] == 'O' && board[1][1] == ' ')
    239. 	{
    240. 		board[1][1] = 'O';
    241. 		return 1;
    242. 	}
    243. 	return 0;
    244. }
    245.  
    246. //电脑着棋：
    247. //随机生成坐标，只要没有被占用，就着棋
    248. void computer_move(char board[ROW][COL], int row, int col)
    249. {
    250. 	printf("电脑正在着棋！\n");
    251. 	Sleep(1000);
    252. 	if (computer_Better_move(board, row, col))
    253. 	{
    254. 		;
    255. 	}
    256. 	else
    257. 	{
    258. 		if (computer_better_move(board, row, col))
    259. 		{
    260. 			;
    261. 		}
    262. 		else
    263. 		{
    264. 			while (1)
    265. 			{
    266. 				int x = rand() % row;
    267. 				int y = rand() % col;
    268. 				if (board[x][y] == ' ')
    269. 				{
    270. 					board[x][y] = 'O';
    271. 					break;
    272. 				}
    273. 			}
    274. 		}
    275. 	}
    276. 	system("cls");
    277. }
    278. 	
    279.  
    280. //平局判定：
    281. int is_full(char board[ROW][COL], int row, int col)
    282. {
    283. 	int i = 0;
    284. 	for (i = 0; i < row; i++)
    285. 	{
    286. 		int j = 0;
    287. 		for (j = 0; j < col; j++)
    288. 		{
    289. 			if (board[i][j] == ' ')
    290. 			{
    291. 				return 0;
    292. 			}
    293. 		}
    294. 	}
    295. 	return 1;
    296. }
    297.  
    298. //胜利判定：
    299. char is_win(char board[ROW][COL], int row, int col)
    300. {
    301. 	int i = 0;
    302. 	for (i = 0; i < row; i++)
    303. 		//判断每行
    304. 	{
    305. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
    306. 		{
    307. 			return board[i][0];
    308. 			//返回赢家
    309. 		}
    310. 	}
    311. 	for (i = 0; i < col; i++)
    312. 		//判断每列
    313. 	{
    314. 		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
    315. 		{
    316. 			return board[0][i];
    317. 			//返回赢家
    318. 		}
    319. 	}
    320. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
    321. 	{
    322. 		return board[1][1];
    323. 	}
    324. 	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
    325. 	{
    326. 		return board[1][1];
    327. 	}
    328. 	if (is_full(board, row, col) == 1)
    329. 	{
    330. 		return 'Q';
    331. 	}
    332. 	return 'C';
    333. }

            3.程序主体文件test.c：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "game.h"
    4. //引用自定头文件
    5.  
    6. void menu()
    7. {
    8. 	printf("************************\n");
    9. 	printf("************************\n");
    10. 	printf("**** 欢迎游玩三子棋 ****\n");
    11. 	printf("****     请选择     ****\n");
    12. 	printf("****   1.开始游戏   ****\n");
    13. 	printf("****   0.退出游戏   ****\n");
    14. 	printf("************************\n");
    15. 	printf("************************\n");
    16. }
    17.  
    18. void game()
    19. {
    20. 	char board[ROW][COL];
    21. 	//创建九宫格数组，用于处理着棋
    22. 	char ret = 0;
    23. 	//定义字符，用于判断输赢后跳出着棋循环
    24. 	init_board(board, ROW, COL);
    25. 	//将数组与行列数传递给封装函数进行初始化
    26. 	print_board(board, ROW, COL);
    27. 	//将初始化完成的棋盘进行打印
    28. 	while (1)
    29. 	{
    30. 		player_move(board, ROW, COL);
    31. 		//玩家进行着棋
    32. 		print_board(board, ROW, COL);
    33. 		ret = is_win(board, ROW, COL);
    34. 		if (ret != 'C')
    35. 		{
    36. 			break;
    37. 		}
    38. 		//判断输赢
    39. 		computer_move(board, ROW, COL);
    40. 		//电脑进行着棋
    41. 		print_board(board, ROW, COL);
    42. 		ret = is_win(board, ROW, COL);
    43. 		if (ret != 'C')
    44. 		{
    45. 			break;
    46. 		}
    47. 	}
    48. 	system("cls");
    49. 	if (ret == '*')
    50. 	{
    51. 		printf("恭喜玩家获得胜利！\n");
    52. 		Sleep(2000);
    53. 	}
    54. 	else if (ret == 'O')
    55. 	{
    56. 		printf("很遗憾，电脑取得了胜利。\n");
    57. 		Sleep(2000);
    58. 	}
    59. 	else if (ret == 'Q')
    60. 	{
    61. 		printf("棋逢对手！战至平局！\n");
    62. 		Sleep(2000);
    63. 	}
    64. 	system("cls");
    65. }
    66.  
    67.  
    68. void test()
    69. {
    70. 	srand((unsigned int)time(NULL));
    71. 	//用时间戳来生成随机数，用于电脑着棋位置判断
    72. 	int input = 0;
    73. 	do
    74. 	{
    75. 		menu();
    76. 		printf("请您进行选择：");
    77. 		scanf("%d", &input);
    78. 		switch (input)
    79. 		{
    80. 		case 1:
    81. 			Sleep(500);
    82. 			system("cls");
    83. 			game();
    84. 			break;
    85. 		case 0:
    86. 			break;
    87. 		default:
    88. 			printf("输入错误，请重新输入！\n");
    89. 			break;
    90. 		}
    91. 	} while (input);
    92. }
    93.  
    94. int main()
    95. {
    96. 	test();
    97.  
    98. 	return 0;
    99. }

    四、总结：

            当我们完成以上优化后，一个游戏程序的雏形就完成了，我们对其功能和界面都进行了相当程度的优化。但是我们对于一个程序的优化过程，不仅仅如此而已，在以后的学习过程中，我们会学到更多知识，到时候我们还可以使用更高深的知识来对我们的游戏程序进行更深层次的优化。

            到这里我们今天的学习过程就告一段落啦，各位小伙伴们下去以后一定要多看多敲多理解，牢固的将知识掌握才是我们的最终目的！靠自己的力量一步步跨过泥泞，才能离想要的生活越来越近，人生中最好的贵人，永远是努力的自己！

            新人初来乍到，辛苦各位小伙伴们动动小手，三连走一走 ~ ~ ~  最后，本文仍有许多不足之处，欢迎各位看官老爷随时私信批评指正！

  • 相关阅读:
    Java应用工程结构
    Qt+FFmpeg+opengl从零制作视频播放器-4.音频解码
    Python爬取电影信息：Ajax介绍、爬取案例实战 + MongoDB存储
    【DW组队学习—动手学数据分析】第二章：第四节数据可视化
    跨链协议支持Sui的资产所有权理念，助力资产在不同链之间流通
    理解JVM
    22-9-16学习笔记
    [附源码]计算机毕业设计JAVAjsp-室内田径馆预约管理系统
    Fabric.js 使用自定义字体
    【AGC】如何查询AppGallery客户端日志
  • 原文地址：https://blog.csdn.net/weixin_59392935/article/details/127904387