经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C 语言 » 查看文章
C语言三子棋的实现思路到过程详解
来源：jb51　　时间：2023/2/15 9:19:46　　对本文有异议

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

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

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

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

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

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、玩家下棋

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

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

我们将玩家下棋内容放在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）。

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

  • 我们这个判断输赢的函数是有返回值的，返回类型为char；
  • 当返回 ‘*’ 时，玩家胜利；
  • 当返回 ‘#’ 时，电脑胜利；
  • 当返回 ‘Q’ 时，平局；
  • 当返回 ‘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<row-2&&j<col-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<row-1&&j>0&&j<col-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<row-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<col-1&&i>0&&i<row-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<col-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. 	if (flag == 0)
  133. 		return 'Q';
  134. 	return 'C';
  135. }

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

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

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

三、整合三子棋游戏代码

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

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

game.h

  1. #include<stdio.h>
  2. //数组行和列的大小
  3. #define ROW 3
  4. #define COL 3
  5. //初始化数组 
  6. void init_board(char board[ROW][COL],int row,int col);
  7. //打印格式化数组
  8. void print_board(char board[ROW][COL], int row, int col);
  9. //玩家下棋 *
  10. void player_move(char board[ROW][COL], int row, int col);
  11. //电脑下棋 #
  12. void computer_move(char board[ROW][COL], int row, int col);
  13. //判断输赢或者平局
  14. char is_win(char board[ROW][COL], int row, int col);

game.c

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

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

到此这篇关于C语言三子棋的实现思路到过程详解的文章就介绍到这了,更多相关C语言三子棋内容请搜索w3xue以前的文章或继续浏览下面的相关文章希望大家以后多多支持w3xue！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C 语言热门文章

  • 图形学入门(1)——直线生成算法（DDA和Bresenham）
  • 用C语言制作一个最简单的飞机游戏！
  • MODBUS 超时时间计算
  • zabbix wait for 15s seconds 出现原因及调优建议
  • C/C++知识分享：assert()函数
  • 图形学入门(2)——圆弧生成算法（中点画圆法）
  • C 共享内存封装
  • C语言中break与continue的用法和区别详解
  • GStreamer基础教程09 - Appsrc及Appsink
  • 三元组矩阵行列式的计算（用递归）

    • C 语言推荐文章

  • C语言指针易混淆知识点总结
  • 进程间通信
  • 数组降维、函数栈帧、地址空间、可变参数原理剖析
  • 【Learning eBPF-3】一个 eBPF 程序的深入剖析
  • [apue] 进程控制那些事儿
  • 解密C语言选择结构：掌握条件语句与分支逻辑的利器
  • 精通C语言：打造高效便捷的通讯录管理系统
  • c语言实现内存池
  • [数据结构] 数组与特殊矩阵
  • 探索C语言结构体：编程中的利器与艺术

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号