• 三子棋小游戏思路及代码实现的详解

    标题：猜数字小游戏

    作者：@Ggggggtm

    寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景

    文章目录：

    一、三子棋小游戏的简单介绍

    二、三子棋的思路及代码实现 

    1、打印游戏菜单

    2、选择是否开始游戏

    3、创建并且初始化棋盘

    3.1、创建棋盘

    3.2、初始化棋盘

    4、打印格式化棋盘

    5、玩家下棋

    6、电脑下棋

    7、判断是否玩家或者电脑赢

    三、整合三子棋游戏代码

    game.h

    game.c

    test.c

    一、三子棋小游戏的简单介绍

      要说大家都很熟悉的一个小游戏，三子棋算是其中一个了。相信大家都玩过三子棋小游戏，在这里我还是给大家介绍简单的游戏规则：

    1. 一次只能下一个棋子；
    2. 玩家下完棋子后，电脑下棋子；
    3. 不能再重复的位置上下棋子；
    4. 不管是玩家还是电脑，谁先达到三个棋子连接在一起的时候获胜；
    5. 三个棋子的连接包括：横三个、竖三个、斜三个。

      当然，熟悉规则后我们会有一个大概的了解了，那么三子棋游戏的思路及代码到底是怎么实现的呢？接下来我给大家一一详细解析一下。

    二、三子棋的思路及代码实现 

    1、打印游戏菜单

      我们实现游戏之前，应该想到先给玩家提供一个菜单。这个菜单的功能就是帮助用户选择是否要开始游戏。菜单的实现我们可以单独自定义一个函数，我们用到菜单的时候调用此函数即可。

    1. void meau()
    2. {
    3. 	printf("*********************\n");
    4. 	printf("*****  1.play   *****\n");
    5. 	printf("*****  0.exit   *****\n");
    6. 	printf("*********************\n");
    7. }

      通过上面的代码我们可以很容易看出，选择‘1’是开始游戏，选择‘0’是退出游戏。  

    2、选择是否开始游戏

       提到选择，我们这里可以联想到switch-case语句。由上面的菜单可知：选择‘1’是开始游戏，选择‘0’是退出游戏。当然我们不能排除不小心输入错误，所以这里我们还要考虑到选择错误的情况下要给出相应的提示。当选择错误时，给出提示且重新选择，同时再把菜单打印出，提供玩家选择。那怎么实现重新选择呢？我们这里其实可以使用do-while()语句。我们先来看一下代码的实现。

    1. void test()
    2. {
    3. 	int input = 0;
    4. 	do
    5. 	{
    6. 		meau();
    7. 		printf("请选择是否要开始游戏：");
    8. 		scanf("%d", &input);
    9. 		switch (input)
    10. 		{
    11. 		case 1:
    12. 			game();  //开始三子棋游戏
    13. 			break;
    14. 		case 0:
    15. 			printf("退出游戏\n");
    16. 			break;
    17. 		default:
    18. 			printf("选择错误\n");
    19. 		}
    20. 	} while (input);
    21. }
      我们看上面的代码是放在的一个自定义的test()函数中，我们只要再主函数中调用一下即可。上面的代码很巧妙，当我们输入‘1’的时候，开始游戏。当游戏结束时，循环继续。其实是实现了一个玩完一局可以反复玩的效果。当我们输入‘0’的时候，循环结束，就是相当于结束游戏了。当我们输入错误时，循环仍然继续，再次打印菜单提供我们选择。这也是 do-while()语句的巧妙之处。

    3、创建并且初始化棋盘

    3.1、创建棋盘

       创建棋盘很简单，我们这里需要的是一个二维数组。那么棋盘的大小呢？我们首先想到的是3x3的棋盘——char board[3][3]。那要是想改成5x5的棋盘呢？我们是把整个工程中的board[3][3]改成board[5][5]吗？这样太麻烦了，当然也不现实。这里我们可以引用#define 定义的标识符常量。这时候我们可以写成char board[ROW][COL]。改变大小的时候只需要改变#define 定义的标识符常量的值就行。

    1. #define ROW 3
    2. #define COL 3
    3. char board[ROW][COL];

    3.2、初始化棋盘

      我们这里将初始化棋盘放在一个init_board(board, ROW, COL)函数中。为什么要初始化棋盘呢？当我们不初始化的时候，期盼中的每个位置放的是‘\0’。而我们想要得到的棋盘是一个空棋盘，这样的话更加有利于玩家操作下棋。空棋盘看起开也比较整洁。我们看一下初始化代码的实现。 

    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. }

    4、打印格式化棋盘

      当我们初始化完棋盘后，我们就应该把棋盘打印出来让玩家看到并且选择要下棋的位置。这里我们先来看打印棋盘。打印出来的棋盘应该格式鲜明，每个位置独立分开，而不是一片空白。我们先看一下棋盘的格式：

    3x3
    5x5

       通过上面的两个图，我们就可以建立一个大概的打印棋盘的思路了。其实我们可以把”_ _ _|_ _ _|_ _ _“看作我们要打印的第一行内容，但是要注意最后一行是”      |      |      “。打印的思路有了，把打印棋盘内容放在print_board(board, ROW, COL)函数中。我们来看一下代码的实现。

    1. void print_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. 			printf(" %c ", board[i][j]);
    10. 			if (j < col - 1)
    11. 				printf("|");
    12. 		}
    13. 		printf("\n");
    14. 		if (i < row - 1)
    15. 		{
    16. 			for (j = 0; j < row; j++)
    17. 			{
    18. 				printf("---");
    19. 				if (j < col - 1)
    20. 					printf("|");
    21. 			}
    22. 		}
    23. 		printf("\n");
    24. 	}
    25. }

    5、玩家下棋

      当我们把棋盘打印出来后，这时候就要提示玩家选择下棋了。我们采用的是坐标的形式让玩家进行选择下棋位置。这里要有几点要注意的事项

    1. 玩家选择的位置就是所看到的位置，跟代码中的数组下标访问还是有所差距的；
    2. 玩家输入的坐标后，要判断该坐标是否已经被占用，也就是不能重复在同一个位置上下棋；
    3. 玩家输入坐标后，要判断坐标是否合法，不合法的话要给出提示，并且重新输入。
    4. 当玩家输入的坐标合法后，电脑玩家进行下棋；
    5. 玩家下完棋后要再次调用打印棋盘函数print_board(board, ROW, COL)，使玩家更方便的观看已经下棋的位置；
    6. 我们把玩家下的坐标用 ‘ * ’ 来代表。

      我们将玩家下棋内容放在player_move(board, ROW, COL)函数中，我们来看一下玩家下棋的代码实现。

    1. void player_move(char board[ROW][COL], int row, int col)
    2. {
    3. 	int x = 0;
    4. 	int y = 0;
    5. 	printf("请选择你要下棋的坐标：");
    6. 	while (1)
    7. 	{
    8. 		scanf("%d %d", &x, &y);
    9. 		if ((x >= 1 && x <= row) && (y >= 1 && y <= col))
    10. 		{
    11. 			if (board[x - 1][y - 1] == ' ')
    12. 			{
    13. 				board[x - 1][y - 1] = '*';
    14. 				break;
    15. 			}
    16. 			else
    17. 			{
    18. 				printf("该坐标已经被占有，请重新选择：");
    19. 			}
    20. 		}
    21. 		else
    22. 		{
    23. 			printf("该坐标非法，请输入合法坐标:");
    24. 		}
    25. 	}
    26. }

    6、电脑下棋

       玩家下棋后，就该电脑下棋了。电脑下棋其实就是随机下棋。当然电脑下棋也是不能重复在同一个位置上下棋，且是合法的。提到随机，我们就因该联想到rand()函数和srand()函数，在这里我就不详细介绍这两个函数的使用方法了，在之前的猜数字小游戏中有详细的解释，可以去了解一下。电脑下完棋后也要调用打印棋盘函数print_board(board, ROW, COL)，使玩家更方便的观看已经下棋的位置。我们把玩家下的坐标用 ‘ # ’ 来代表。把电脑下棋代码放在computer_move(board, ROW, COL)函数中。那我们来看一下电脑下棋的代码实现。

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

    7、判断是否玩家或者电脑赢

      其实，每当玩家或者电脑下完一次棋后，我们都需要判断一下是否有赢的。如果没有赢的，我们就进行反复下棋。如果有赢的，我们就停止下棋，并输出”玩家赢“或者”电脑赢“。我们同时还要想到是否为平局，如果为平局的话，就输出”平局“。判断输赢的函数我们定义成char is_win(board[ROW][COL], ROW, COL）。

     判断输赢函数返回值注意：

    1. 我们这个判断输赢的函数是有返回值的，返回类型为char；
    2. 当返回 ‘*’ 时，玩家胜利；
    3. 当返回 ‘#’ 时，电脑胜利；
    4. 当返回 ‘Q’ 时，平局；
    5. 当返回 ‘C’ 时，游戏继续。

      当我们在编写输赢函数时，我们要注意不能数组越界访问。我们先来看一下判断输赢函数的实现。

    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. 		int j = 0;
    8. 		for (j = 0; j < col; j++)
    9. 		{
    10. 			if (j == 0)
    11. 			{
    12. 				if ((board[i][0] == board[i][1]) && (board[i][1] == board[i][2]) && (board[i][1] != ' '))
    13. 					return board[i][0];
    14. 			}
    15. 			else if (j == 1)
    16. 			{
    17. 				if ((board[i][0] == board[i][1]) && (board[i][1] == board[i][2]) && (board[i][1] != ' ')
    18. 					|| (board[i][1] == board[i][2]) && (board[i][2] == board[i][23]) && (board[i][1] != ' '))
    19. 					return board[i][1];
    20. 			}
    21. 			else if (j == col - 1)
    22. 			{
    23. 				if ((board[i][j] == board[i][j - 1]) && (board[i][j - 1] == board[i][j - 2]) && (board[i][j] != ' '))
    24. 					return board[i][j];
    25. 			}
    26. 			else if (j == col - 2)
    27. 			{
    28. 				if ((board[i][j] == board[i][j - 1]) && (board[i][j - 1] == board[i][j - 2]) && (board[i][j] != ' ')
    29. 					|| (board[i][j] == board[i][j - 1]) && (board[i][j] == board[i][j + 1]) && (board[i][j] != ' '))
    30. 				return board[i][j];
    31. 			}
    32. 			else
    33. 			{
    34. 				if ((board[i][j] == board[i][j - 1]) && (board[i][j - 1] == board[i][j - 2]) && (board[i][j] != ' ')
    35. 					|| (board[i][j] == board[i][j - 1]) && (board[i][j] == board[i][j + 1]) && (board[i][j] != ' ')
    36. 					|| (board[i][j] == board[i][j + 1]) && (board[i][j + 1] == board[i][j + 2]) && (board[i][j] != ' '))
    37. 					return board[i][j];
    38. 			}
    39. 		}
    40. 	}
    41. 	//判断列
    42. 	int j = 0;
    43. 	for (j = 0; j < col; j++)
    44. 	{
    45. 		for (i = 0; i < row; i++)
    46. 		{
    47. 			if (i == 0)
    48. 			{
    49. 				if ((board[0][j] == board[1][j]) && (board[1][j] == board[2][j]) && (board[1][j] != ' '))
    50. 					return board[0][j];
    51. 			}
    52. 			else if (i == 1)
    53. 			{
    54. 				if ((board[0][j] == board[1][j]) && (board[1][j] == board[2][j]) && (board[1][j] != ' ')
    55. 					|| (board[1][j] == board[2][j]) && (board[2][j] == board[3][j]) && (board[1][j] != ' '))
    56. 					return board[1][j];
    57. 			}
    58. 			else if (i == row - 1)
    59. 			{
    60. 				if ((board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i - 2][j]) && (board[i][j] != ' '))
    61. 					return board[i][j];
    62. 			}
    63. 			else if (i == row - 2)
    64. 			{
    65. 				if ((board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i - 2][j]) && (board[i][j] != ' ')
    66. 					|| (board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i + 1][j]) && (board[i][j] != ' '))
    67. 					return board[i][j];
    68. 			}
    69. 			else
    70. 			{
    71. 				if ((board[i][j] == board[i + 1][j]) && (board[i + 1][j] == board[i + 2][j]) && (board[i][j] != ' ')
    72. 					|| (board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i + 1][j]) && (board[i][j] != ' ')
    73. 					|| (board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i - 2][j]) && (board[i][j] != ' '))
    74. 					return board[i][j];
    75. 			}
    76. 		}
    77. 	}
    78. 	//判断主对角线
    79. 	for (i = 0; i < row; i++)
    80. 	{
    81. 		for (j = 0; j < col; j++)
    82. 		{
    83. 			if (i-2&&j-2)
    84. 			{
    85. 				if((board[i][j] == board[i + 1][j + 1] && board[i][j] == board[i + 2][j + 2] && board[i][j] != ' '))
    86. 					return board[i][j];
    87. 			}
    88. 			if (i>0&&i-1&&j>0&&j-1)
    89. 			{
    90. 				if ((board[i][j] == board[i + 1][j + 1] && board[i][j] == board[i - 1][j - 1] && board[i][j] != ' '))
    91. 					return board[i][j];
    92. 			}
    93. 			if (i >1&&j>1)
    94. 			{
    95. 				if ((board[i][j] == board[i - 1][j - 1] && board[i][j] == board[i - 2][j - 2] && board[i][j] != ' '))
    96. 					return board[i][j];
    97. 			}
    98. 		}
    99. 	}
    100. 	//判断次对角线
    101. 	for (i = 0; i < row; i++)
    102. 	{
    103. 		for (j = 0; j < col; j++)
    104. 		{
    105. 			if (i-2&&j>1)
    106. 			{
    107. 				if ((board[i][j] == board[i + 1][j - 1] && board[i][j] == board[i + 2][j - 2] && board[i][j] != ' '))
    108. 					return board[i][j];
    109. 			}
    110. 			if (j>0&&j-1&&i>0&&i-1)
    111. 			{
    112. 				if ((board[i][j] == board[i - 1][j + 1] && board[i][j] == board[i + 1][j - 1] && board[i][j] != ' '))
    113. 					return board[i][j];
    114. 			}
    115. 			if (i>1&&j-2)
    116. 			{
    117. 				if ((board[i][j] == board[i - 1][j + 1] && board[i][j] == board[i - 2][j + 2] && board[i][j] != ' '))
    118. 					return board[i][j];
    119. 			}
    120. 		}
    121. 	}
    122. 	//判断平局
    123. 	int flag = 0;
    124. 	for (i = 0; i < row; i++)
    125. 	{
    126. 		for (j = 0; j < col; j++)
    127. 		{
    128. 			if (board[i][j] == ' ')
    129. 				flag = 1;
    130. 				
    131. 		}
    132. 	}
    133. 	if (flag == 0)
    134. 		return 'Q';
    135. 	return 'C';
    136. }

       我们这里再看一下反复调用玩家下棋player_move(board, ROW, COL)函数和电脑下棋computer_move(board, ROW, COL)函数和打印棋盘函数print_board(board, ROW, COL)函数到终止循环的代码。反复调用这几个函数也就是实现了反复下棋的效果。如果没有赢的，我们就进行反复下棋。如果有赢的或者平局，我们就停止下棋。我们来看代码实现。

    1.  
    2. 	while (1)
    3. 	{
    4. 		//玩家下棋
    5. 		player_move(board, ROW, COL);
    6. 		print_board(board, ROW, COL);
    7. 		//判断是否结束 
    8. 		// * 玩家胜利
    9. 		// # 电脑胜利
    10. 		// Q 平局
    11. 		// C 继续游戏
    12. 		ret=is_win(board, ROW, COL);
    13. 		if (ret != 'C')
    14. 			break;
    15. 		//电脑下棋
    16. 		computer_move(board, ROW, COL);
    17. 		print_board(board, ROW, COL);
    18. 		ret = is_win(board, ROW, COL);
    19. 		if (ret != 'C')
    20. 			break;
    21. 	}

      综上就是我整个三子棋游戏实现的思路了。总体来说还是比较简单的。我们把上面的代码整合一下来看。

    三、整合三子棋游戏代码

      由于代码量相对来说有一点多，所以我们就将函数的声明的定义分开，这样有利于提高代码的可读性，同时会保持一个良好的思路，且方便编写代码。

      我们将函数的声明放在单独的一个game.h的头文件，函数的实现放在一个单独的game.c源文件，函数的主方法及调用放在另一个单独的test.c源文件。

    game.h

    1. #include
    2.  
    3. //数组行和列的大小
    4. #define ROW 3
    5. #define COL 3
    6.  
    7.  
    8. //初始化数组 
    9. void init_board(char board[ROW][COL],int row,int col);
    10. //打印格式化数组
    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. //电脑下棋 #
    15. void computer_move(char board[ROW][COL], int row, int col);
    16. //判断输赢或者平局
    17. char is_win(char board[ROW][COL], int row, int col);

    game.c

    1. #include "game.h"
    2.  
    3.  
    4. void init_board(char board[ROW][COL], int row, int col)
    5. {
    6. 	int i = 0;
    7. 	for (i = 0; i < row; i++)
    8. 	{
    9. 		int j = 0;
    10. 		for (j = 0; j < col; j++)
    11. 		{
    12. 			board[i][j] = ' ';
    13. 		}
    14. 	}
    15. }
    16.  
    17. void print_board(char board[ROW][COL], int row, int col)
    18. {
    19. 	int i = 0;
    20. 	for (i = 0; i < row; i++)
    21. 	{
    22. 		int j = 0;
    23. 		for (j = 0; j < col; j++)
    24. 		{
    25. 			printf(" %c ", board[i][j]);
    26. 			if (j < col - 1)
    27. 				printf("|");
    28. 		}
    29. 		printf("\n");
    30. 		if (i < row - 1)
    31. 		{
    32. 			for (j = 0; j < row; j++)
    33. 			{
    34. 				printf("---");
    35. 				if (j < col - 1)
    36. 					printf("|");
    37. 			}
    38. 		}
    39. 		printf("\n");
    40. 	}
    41. }
    42.  
    43. void player_move(char board[ROW][COL], int row, int col)
    44. {
    45. 	int x = 0;
    46. 	int y = 0;
    47. 	printf("请选择你要下棋的坐标：");
    48. 	while (1)
    49. 	{
    50. 		scanf("%d %d", &x, &y);
    51. 		if ((x >= 1 && x <= row) && (y >= 1 && y <= col))
    52. 		{
    53. 			if (board[x - 1][y - 1] == ' ')
    54. 			{
    55. 				board[x - 1][y - 1] = '*';
    56. 				break;
    57. 			}
    58. 			else
    59. 			{
    60. 				printf("该坐标已经被占有，请重新选择：");
    61. 			}
    62. 		}
    63. 		else
    64. 		{
    65. 			printf("该坐标非法，请输入合法坐标:");
    66. 		}
    67. 	}
    68. }
    69.  
    70. void computer_move(char board[ROW][COL], int row, int col)
    71. {
    72. 	printf("电脑下棋：\n");
    73. 	while (1)
    74. 	{
    75. 		int x = rand() % 3;
    76. 		int y = rand() % 3;
    77. 		if (board[x][y] == ' ')
    78. 		{
    79. 			board[x][y] = '#';
    80. 			break;
    81. 		}
    82. 	}
    83. }
    84.  
    85. char is_win(char board[ROW][COL], int row, int col)
    86. {
    87. 	int i = 0;
    88. 	//判断行
    89. 	for (i = 0; i < row; i++)
    90. 	{
    91. 		int j = 0;
    92. 		for (j = 0; j < col; j++)
    93. 		{
    94. 			if (j == 0)
    95. 			{
    96. 				if ((board[i][0] == board[i][1]) && (board[i][1] == board[i][2]) && (board[i][1] != ' '))
    97. 					return board[i][0];
    98. 			}
    99. 			else if (j == 1)
    100. 			{
    101. 				if ((board[i][0] == board[i][1]) && (board[i][1] == board[i][2]) && (board[i][1] != ' ')
    102. 					|| (board[i][1] == board[i][2]) && (board[i][2] == board[i][23]) && (board[i][1] != ' '))
    103. 					return board[i][1];
    104. 			}
    105. 			else if (j == col - 1)
    106. 			{
    107. 				if ((board[i][j] == board[i][j - 1]) && (board[i][j - 1] == board[i][j - 2]) && (board[i][j] != ' '))
    108. 					return board[i][j];
    109. 			}
    110. 			else if (j == col - 2)
    111. 			{
    112. 				if ((board[i][j] == board[i][j - 1]) && (board[i][j - 1] == board[i][j - 2]) && (board[i][j] != ' ')
    113. 					|| (board[i][j] == board[i][j - 1]) && (board[i][j] == board[i][j + 1]) && (board[i][j] != ' '))
    114. 				return board[i][j];
    115. 			}
    116. 			else
    117. 			{
    118. 				if ((board[i][j] == board[i][j - 1]) && (board[i][j - 1] == board[i][j - 2]) && (board[i][j] != ' ')
    119. 					|| (board[i][j] == board[i][j - 1]) && (board[i][j] == board[i][j + 1]) && (board[i][j] != ' ')
    120. 					|| (board[i][j] == board[i][j + 1]) && (board[i][j + 1] == board[i][j + 2]) && (board[i][j] != ' '))
    121. 					return board[i][j];
    122. 			}
    123. 		}
    124. 	}
    125. 	//判断列
    126. 	int j = 0;
    127. 	for (j = 0; j < col; j++)
    128. 	{
    129. 		for (i = 0; i < row; i++)
    130. 		{
    131. 			if (i == 0)
    132. 			{
    133. 				if ((board[0][j] == board[1][j]) && (board[1][j] == board[2][j]) && (board[1][j] != ' '))
    134. 					return board[0][j];
    135. 			}
    136. 			else if (i == 1)
    137. 			{
    138. 				if ((board[0][j] == board[1][j]) && (board[1][j] == board[2][j]) && (board[1][j] != ' ')
    139. 					|| (board[1][j] == board[2][j]) && (board[2][j] == board[3][j]) && (board[1][j] != ' '))
    140. 					return board[1][j];
    141. 			}
    142. 			else if (i == row - 1)
    143. 			{
    144. 				if ((board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i - 2][j]) && (board[i][j] != ' '))
    145. 					return board[i][j];
    146. 			}
    147. 			else if (i == row - 2)
    148. 			{
    149. 				if ((board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i - 2][j]) && (board[i][j] != ' ')
    150. 					|| (board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i + 1][j]) && (board[i][j] != ' '))
    151. 					return board[i][j];
    152. 			}
    153. 			else
    154. 			{
    155. 				if ((board[i][j] == board[i + 1][j]) && (board[i + 1][j] == board[i + 2][j]) && (board[i][j] != ' ')
    156. 					|| (board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i + 1][j]) && (board[i][j] != ' ')
    157. 					|| (board[i][j] == board[i - 1][j]) && (board[i - 1][j] == board[i - 2][j]) && (board[i][j] != ' '))
    158. 					return board[i][j];
    159. 			}
    160. 		}
    161. 	}
    162. 	//判断主对角线
    163. 	for (i = 0; i < row; i++)
    164. 	{
    165. 		for (j = 0; j < col; j++)
    166. 		{
    167. 			if (i-2&&j-2)
    168. 			{
    169. 				if((board[i][j] == board[i + 1][j + 1] && board[i][j] == board[i + 2][j + 2] && board[i][j] != ' '))
    170. 					return board[i][j];
    171. 			}
    172. 			if (i>0&&i-1&&j>0&&j-1)
    173. 			{
    174. 				if ((board[i][j] == board[i + 1][j + 1] && board[i][j] == board[i - 1][j - 1] && board[i][j] != ' '))
    175. 					return board[i][j];
    176. 			}
    177. 			if (i >1&&j>1)
    178. 			{
    179. 				if ((board[i][j] == board[i - 1][j - 1] && board[i][j] == board[i - 2][j - 2] && board[i][j] != ' '))
    180. 					return board[i][j];
    181. 			}
    182. 		}
    183. 	}
    184. 	//判断次对角线
    185. 	for (i = 0; i < row; i++)
    186. 	{
    187. 		for (j = 0; j < col; j++)
    188. 		{
    189. 			if (i-2&&j>1)
    190. 			{
    191. 				if ((board[i][j] == board[i + 1][j - 1] && board[i][j] == board[i + 2][j - 2] && board[i][j] != ' '))
    192. 					return board[i][j];
    193. 			}
    194. 			if (j>0&&j-1&&i>0&&i-1)
    195. 			{
    196. 				if ((board[i][j] == board[i - 1][j + 1] && board[i][j] == board[i + 1][j - 1] && board[i][j] != ' '))
    197. 					return board[i][j];
    198. 			}
    199. 			if (i>1&&j-2)
    200. 			{
    201. 				if ((board[i][j] == board[i - 1][j + 1] && board[i][j] == board[i - 2][j + 2] && board[i][j] != ' '))
    202. 					return board[i][j];
    203. 			}
    204. 		}
    205. 	}
    206. 	//判断平局
    207. 	int flag = 0;
    208. 	for (i = 0; i < row; i++)
    209. 	{
    210. 		for (j = 0; j < col; j++)
    211. 		{
    212. 			if (board[i][j] == ' ')
    213. 				flag = 1;
    214. 				
    215. 		}
    216. 	}
    217. 	if (flag == 0)
    218. 		return 'Q';
    219. 	return 'C';
    220. }

    test.c

    1. #include "game.h"
    2. void game()
    3. {
    4. 	char ret = 0;
    5. 	srand(time(NULL));
    6. 	char board[ROW][COL];
    7. 	//初始化数组 全为空格
    8. 	init_board(board, ROW, COL);
    9. 	//打印格式化数组
    10. 	print_board(board, ROW, COL);
    11.  
    12. 	while (1)
    13. 	{
    14. 		//玩家下棋
    15. 		player_move(board, ROW, COL);
    16. 		print_board(board, ROW, COL);
    17. 		//判断是否结束 
    18. 		// * 玩家胜利
    19. 		// # 电脑胜利
    20. 		// Q 平局
    21. 		// C 继续游戏
    22. 		ret=is_win(board, ROW, COL);
    23. 		if (ret != 'C')
    24. 			break;
    25. 		//电脑下棋
    26. 		computer_move(board, ROW, COL);
    27. 		print_board(board, ROW, COL);
    28. 		ret = is_win(board, ROW, COL);
    29. 		if (ret != 'C')
    30. 			break;
    31. 	}
    32. 	if (ret == '*')
    33. 		printf("恭喜玩家取得胜利！\n");
    34. 	else if (ret == '#')
    35. 		printf("电脑取得胜利。\n");
    36. 	else if (ret == 'Q')
    37. 		printf("平局了哦。\n");
    38. }
    39. void meau()
    40. {
    41. 	printf("*********************\n");
    42. 	printf("*****  1.play   *****\n");
    43. 	printf("*****  0.exit   *****\n");
    44. 	printf("*********************\n");
    45. }
    46. void test()
    47. {
    48. 	int input = 0;
    49. 	do
    50. 	{
    51. 		meau();
    52. 		printf("请选择是否要开始游戏：");
    53. 		scanf("%d", &input);
    54. 		switch (input)
    55. 		{
    56. 		case 1:
    57. 			game();
    58. 			break;
    59. 		case 0:
    60. 			printf("退出游戏\n");
    61. 			break;
    62. 		default:
    63. 			printf("选择错误\n");
    64. 		}
    65. 	} while (input);
    66. }
    67. int main()
    68. {
    69. 	test();
    70. 	return 0;
    71. }

      希望这篇文章能给你带来一个很好的理解，对你有所帮助，感谢阅读。

      后续会一直更新的哦。

  • 相关阅读:
    log4j漏洞原理分析&复现&检测&复盘
    目标检测的方法
    【Linux】解决缓存锁问题：无法获得锁 /var/lib/dpkg/lock-frontend
    实时大数据流处理技术：Spark Streaming与Flink的深度对比
    运动耳机也有降噪？飞利浦降噪真无线耳机A7507开箱
    橘子学Mybatis02之基本对象前置了解
    ​数据库原理及应用上机（实验二 SQL数据定义功能实验）
    简易开发一个app
    spring boot+ vue位置信息大数据综合管理平台源码
    CSDN课程推荐:《ARMv8/ARMv9架构学习》系列课程上线-56节18小时
  • 原文地址：https://blog.csdn.net/weixin_67596609/article/details/127752405