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

C语言基础：三子棋小游戏的C语言实现（超详解释+源码）_c语言 三子棋游戏

作者：煮酒与君饮 | 2024-07-31 15:26:04

赞

踩

c语言 三子棋游戏

友友们好，今天和大家一起做一个简单的C语言小游戏——三子棋小游戏。

 游戏规则如下：

       游戏分为双方对战，双方依次在9宫格棋盘上摆放棋子，先连成三棋一线者视为胜利；棋盘被摆满棋子仍未分出胜利，视为平局。

目录

实现思路

1、制作游戏菜单

2、构建基本逻辑结构

3、实现游戏内容

·初始化一个二维数组用来存放数据

·打印棋盘

·实现玩家下棋

·实现电脑下棋

·判断输赢

4、组装实现游戏

5、游戏运行

实现思路

       首先，制作一个游戏菜单，构建整个游戏的基本逻辑结构，然后进入游戏的制作。首先玩家在九宫格的合法范围下棋，而后电脑下棋，在下棋的同时要判断游戏是否结束，如果结束需要判断哪方胜利或者平局。

       接下来我们就以这个基本思路来进行代码的实现。
 

1、制作游戏菜单

首先，我们要制作一个游戏菜单。我们用一个简易的函数来实现他。

  1. void menu()
  2. {
  3. 	printf("**************************\n");
  4. 	printf("****   三子棋小游戏   ****\n");
  5. 	printf("****     1、play      ****\n");
  6. 	printf("****     0、exit      ****\n");
  7. 	printf("**************************\n");
  8. 	//输入1开始游戏，输入0退出游戏
  9. }

我们在主函数中可以调用这个函数来实现打印菜单的目的。

2、构建基本逻辑结构

制作完菜单后，我们需要构建这个游戏的基本逻辑结构。

首先需要明确我们的需求： 1、我们可以通过输入 1 / 0 来选择开始或结束游戏

                                            2、如果一把玩完不过瘾，我们可以通过选择来再玩一把

· 我们运用分支语句的知识来实现第一个需求。

       在这里我使用switch语句，定义一个整型来存放输入的数字，如果输入的数字是 1 ，则提示“开始游戏”；如果输入的数字是 0 ，则提示“结束游戏”；如果输入了 1/0 以外的数字，则我们提醒他输错了，重新输入。

· 我们通过循环来实现第二个需求。

       在这里我使用do... while() 循环，将定义的整型放在（） 里作为判断条件。当我们输入 1 ，为非0，判断为真，游戏继续；当我们输入 0 ，判断为假，游戏结束；当我们输入 1/0  以外的数字，为非0，判断为真，可以继续循环让我们重新判断。

  1. int main()
  2. {
  3. 	int input;
  4. 	//先输入一个input判断要不要进入游戏，将其也设为循环的判断条件
  5. 	do {
  6. 		menu();
  7. 		printf("请输入->");
  8. 		scanf("%d", &input);
  9. 		switch (input)
  10. 		{
  11. 		case 1:
  12. 			printf("开始游戏\n");
  13. 			game();
  14. 			//如果输入1，说明要玩游戏，封装一个game函数来包含游戏内容
  15. 			break;
  16. 		case 0:
  17. 			printf("退出游戏\n");
  18. 			break;
  19. 		default:
  20. 			printf("输错啦，请重新输入\n");
  21. 			break;
  22. 		}
  23. 	} while (input);
  24.  
  25. 	return 0;
  26. }

从代码运行结果来看，满足了我们提出的两点需求。 

3、实现游戏内容

我们封装一个game()函数来实现游戏内容。

首先需要明确我们的需求：1、初始化一个二维数组用来存放数据

                                           2、打印棋盘

                                           3、实现玩家下棋

                                           4、实现电脑下棋

                                           5、判断输赢

·初始化一个二维数组用来存放数据

       首先我们需要创建一个3*3的二维数组，将其先初始化为空格。我们在game函数中再封装一个函数来实现这一功能。这个函数我们需要给他传参 数组，数组的行数与列数给他，然后才有足够的信息能将数组的每一个元素都初始化。

  1. //为了后期修改方便，我们将数组的行数定义为ROW 列数定义为COL
  2. //这样子后期想修改成4*4 5*5 的棋盘，只需修改定义的值就好，非常方便
  3.  
  4. #define ROW 3
  5. #define COL 3
  6.  
  7. void InitBoard(char board[ROW][COL], int  row, int col)
  8. {
  9. 	int i = 0;
  10. 	int j = 0;
  11. 	for (i = 0; i < row; i++)
  12. 	{
  13. 		for (j = 0; j < col; j++)
  14. 		{
  15. 			board[i][j] = ' ';      //将数组的每个元素初始化为空格
  16. 		}
  17. 	}
  18. }

·打印棋盘

我们先清楚棋盘的格式为：

                                                     

       棋盘由数据行和分割行组成，数据行是一个元素+一个 ' | ' ，分割行是由 '---'  + ' | ' 组成；且数据行的末尾没有 ' | ' ，最后一行不需要分割行。封装一个函数来实现以上功能。

  1. void Print(char board[ROW][COL], int  row, int col)
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	int z = 0;
  6. 	//弄清楚棋盘构成
  7. 	for (i = 0; i < row; i++)
  8. 	{
  9. 		//打印一行数和 '|'
  10. 		for (j = 0; j < col; j++)
  11. 		{
  12. 			printf(" %c ",board[i][j]);
  13. 			if (j < col - 1)  //最后一位不需要打印 '|'
  14. 				printf("|");
  15. 		}
  16. 		printf("\n");  //由数据行转为分割行
  17.  
  18. 		if (i < row - 1)  //当不是最后一行时，打印分割行
  19. 		{
  20. 			for (z = 0; z < col; z++)
  21. 			{
  22. 				printf("---");
  23. 				if (z < col - 1)  //最后一位不需要打印 '|'
  24. 				{
  25. 					printf("|");
  26. 				}
  27. 			}
  28. 		}
  29. 		printf("\n");  //由分割行转为数据行
  30. 	}
  31. }

从代码运行结果来看，我们成功实现了将其初始化为空格且将棋盘打印。 

·实现玩家下棋

       首先玩家下棋需要下在棋盘中的合法位置，如果玩家下在棋盘外或者下棋的位置已被占用，我们需要给出相应的提示。然后玩家给出的是棋盘的坐标位置，我们应该将其-1，和数组位置对应。我们封装一个函数，在game函数中调用来实现该功能。

  1. //玩家下棋
  2. void PlayerMove(char board[ROW][COL], int  row, int col)
  3. {
  4. 	//玩家下棋的位置改为*
  5. 	printf("请输入下棋的坐标->");
  6. 	while (1)//当玩家输入合法的坐标位置后跳出
  7. 	{
  8. 		int x = 0;
  9. 		int y = 0;
  10. 		scanf("%d %d", &x, &y);
  11.         //判断坐标位置是否合法，并给出相应提示
  12. 		if (x > 0 && x <= row && y > 0 && y <= col)
  13. 		{
  14. 			if (board[x - 1][y - 1] == ' ')
  15. 			{
  16. 				board[x - 1][y - 1] = '*';
  17. 				break;
  18. 			}
  19. 			else
  20. 				printf("坐标已被占用，请重新输入\n");
  21. 		}
  22. 		else
  23. 		{
  24. 			printf("坐标错误，请重新输入\n");
  25. 		}
  26. 	}
  27. }

·实现电脑下棋

       实现玩家下棋后，需要电脑与其对弈，我们可以用rand函数来生成随机值来作为电脑下棋的坐标。电脑下棋也需要注意，下棋的坐标需要是一个合法坐标，我们可以将生成坐标的过程放进循环里，当电脑下棋的坐标为合法坐标时跳出循环。我们封装一个函数，在game函数中调用来实现该功能。

  1. //电脑下棋
  2. void ComputerMove(char board[ROW][COL], int  row, int col)
  3. {
  4.     //电脑下棋的位置改为#
  5. 	do {
  6. 		int x = rand() % row;  //确保生成的坐标在数组下标范围内
  7. 		int y = rand() % col;
  8. 		if (board[x][y] == ' ')
  9. 		{
  10. 			board[x][y] = '#';
  11. 			break;
  12. 		}
  13. 	} while (1);
  14. }

       注意：

       C语言中提供了一个rand函数可以帮我们生成随机数，返回值为int 整型，返回的值就是一个随机数。但rand函数生成的是伪随机数，返回的随机值并不完全随机。

                    

       rand函数在生成随机数之前，要使用srand函数设置随机数的生成器。srand()括号中放置类似于生成随机数的种子，种子固定了生成的随机数也是固定的。所以我们要使括号中的值为随机变化的，才能使产生的数值为随机值。

       在我们的计算机中，时间是时刻在发生变化的，如果能将时间传入srand中，那么就可以实现真正的随机。这个时候我们可以使用time函数来解决这个问题。

   

       time函数可以返回一个时间戳，时间戳是一串数字， 是随着时间在不断变化的 。在使用时我们需要调用二者的头文件。
 

所以在主函数中：

  1. #include<stdio.h>
  2. #include<stdlib.h>    //srand函数的头文件
  3. #include<time.h>      //time函数的头文件
  4. int main()
  5. {
  6. 	srand(time);
  7. 	
  8.     //.....
  9.  
  10. 	return 0;
  11. }

这样就能实现电脑与玩家的对弈：

    

·判断输赢

       在玩家和电脑对弈时，还需要对走的每一步来判断是不是游戏结束。且如果棋盘空间满了还没有结束，会导致没有地方再下棋，导致程序崩溃。所以我们需要写一个函数，在每走一步棋后都判断游戏进程，如果有一方胜利则游戏结束，并给出对应提示；如果平局，则游戏结束，并给出对应提示；如果游戏没结束，就继续游戏。我们封装一个函数，在game函数中调用来实现该功能。

-----------------------------

判断输赢
玩家胜利返回 *
电脑胜利返回 #
游戏继续返回C
平局返回P

-----------------------------

  1. char Iswin(char board[ROW][COL], int  row, int col)
  2. {
  3. 	//判断哪个棋子胜利
  4. 	int i = 0;
  5. 	for (i = 0; i < row; i++)  //某一行都相同
  6. 	{
  7. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
  8. 		{
  9. 			return board[i][1];  //谁胜利返回谁的字符
  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[1][i] != ' ')
  16. 		{
  17. 			return board[1][i];   //谁胜利返回谁的字符
  18. 		}
  19. 	}
  20.  
  21.     //对角线相同
  22. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
  23. 	{
  24. 		return board[1][1];   //谁胜利返回谁的字符
  25. 	}
  26.  
  27.     //对角线相同
  28. 	if (board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
  29. 	{
  30. 		return board[1][1];   //谁胜利返回谁的字符
  31. 	}
  32.  
  33.  
  34. }

       用以上的代码内容可以判断棋盘内是否有某行、某列、某对角相同，并返回对应的字符。但如果不是以上情况，还有可能是棋盘满了但未分出胜负为平局；也可能是棋盘未满，也没有一方胜利，游戏继续。

       我们给出一个Isfull函数来判断棋盘是否满了。

  1. int Isfull(char board[ROW][COL], int  row, int col)
  2. {
  3. 	int x = 0;
  4. 	int y = 0;
  5. 	for (x = 0; x < row; x++)
  6. 	{
  7. 		for (y = 0; y < col; y++)
  8. 		{
  9. 			if (board[x][y] == ' ')//证明还没满
  10. 				return 0;
  11. 		}
  12. 	}
  13. 	return 1;
  14. }

并在判断输赢函数Iswin中调用它

  1. char Iswin(char board[ROW][COL], int  row, int col)
  2. {
  3. 	//......
  4.  
  5.  
  6. 	//判断棋盘满了没
  7. 	if (Isfull(board, ROW, COL))  //如果棋盘满了会返回1，则进入if语句，表示平局
  8. 		return 'P';            
  9. 	return 'C';     //如果棋盘未满则返回C 表示游戏继续
  10.  
  11. }

由此我们就成功实现了判断输赢函数的功能

4、组装实现游戏

我们将3中的内容都封装在game函数中，那么如何运用以上函数实现游戏呢？

       1、首先我们需要实现玩家与电脑的对弈

       2、下一步棋后需打印出来

       3、每下一步棋判断游戏进程，并给出相应反应

       4、判断谁输谁赢

       我们可以像主函数中一样，使用循环来实现，判断游戏未结束就继续循环，判断游戏结束就跳出循环。

  1. void game()
  2. {
  3. 	char ret;
  4. 	char board[ROW][COL];
  5. 	//初始化一个二维数组
  6. 	//刚开始的时候，数组的内容应该全是空格
  7. 	InitBoard(board, ROW, COL);
  8.  
  9. 	//打印棋盘
  10. 	Print(board, ROW, COL);
  11.  
  12. 	//开始下棋
  13. 	//玩家下完电脑下，如果判断游戏结束就跳出循环，没有结束就继续循环
  14. 	while (1)
  15. 	{
  16. 		//玩家下棋
  17. 		PlayerMove(board, ROW, COL);
  18. 		Print(board, ROW, COL);
  19.  
  20. 		//判断输赢
  21. 		ret = Iswin(board, ROW, COL);  //用一个字符接受判断输赢函数的返回值
  22. 		if (ret != 'C')
  23. 			break;
  24.  
  25. 		//电脑下棋
  26. 		ComputerMove(board, ROW, COL);
  27. 		Print(board, ROW, COL);
  28.  
  29.         //判断输赢
  30. 		ret = Iswin(board, ROW, COL);
  31. 		if (ret != 'C')
  32. 	        break;
  33. 	}
  34.  
  35. 	//当跳出循环后，判断是谁嬴
  36.  
  37. 	if (ret == '*')   //玩家胜利，给出相应提示
  38. 		printf("恭喜您胜利啦！\n");
  39. 	else if (ret == '#')   //电脑胜利，给出相应提示
  40. 		printf("很遗憾，您输了...\n");
  41. 	else                       //平局，给出相应提示
  42. 		printf("平局\n");
  43.  
  44. }

再在主函数中调用game函数，即可实现游戏。

  1. //三子棋游戏
  2. #include<stdio.h>
  3. #include<stdlib.h>    //srand函数的头文件
  4. #include<time.h>      //time函数的头文件
  5. #define ROW 3
  6. #define COL 3
  7. void menu()
  8. {
  9. 	printf("**************************\n");
  10. 	printf("****   三子棋小游戏   ****\n");
  11. 	printf("****     1、play      ****\n");
  12. 	printf("****     0、exit      ****\n");
  13. 	printf("**************************\n");
  14. 	//输入1开始游戏，输入0退出游戏
  15. }
  16.  
  17. //初始化数组
  18. void InitBoard(char board[ROW][COL], int  row, int col)
  19. {
  20. 	int i = 0;
  21. 	int j = 0;
  22. 	for (i = 0; i < row; i++)
  23. 	{
  24. 		for (j = 0; j < col; j++)
  25. 		{
  26. 			board[i][j] = ' ';
  27. 		}
  28. 	}
  29. }
  30.  
  31. //打印数组
  32. void Print(char board[ROW][COL], int  row, int col)
  33. {
  34. 	int i = 0;
  35. 	int j = 0;
  36. 	int z = 0;
  37. 	//弄清楚棋盘构成
  38. 	for (i = 0; i < row; i++)
  39. 	{
  40. 		//打印一行数和|
  41. 		for (j = 0; j < col; j++)
  42. 		{
  43. 			printf(" %c ",board[i][j]);
  44. 			if (j < col - 1)
  45. 				printf("|");
  46. 		}
  47. 		printf("\n");
  48. 		if (i < row - 1)//当不是最后一行时，打印
  49. 		{
  50. 			for (z = 0; z < col; z++)
  51. 			{
  52. 				printf("---");
  53. 				if (z < col - 1)
  54. 				{
  55. 					printf("|");
  56. 				}
  57. 			}
  58. 		}
  59. 		printf("\n");
  60. 	}
  61. }
  62.  
  63. //玩家下棋
  64. void PlayerMove(char board[ROW][COL], int  row, int col)
  65. {
  66. 	//玩家下棋的位置改为*
  67. 	printf("请输入下棋的坐标->");
  68. 	while (1)
  69. 	{
  70. 		int x = 0;
  71. 		int y = 0;
  72. 		scanf("%d %d", &x, &y);
  73. 		if (x > 0 && x <= row && y > 0 && y <= col)
  74. 		{
  75. 			if (board[x - 1][y - 1] == ' ')
  76. 			{
  77. 				board[x - 1][y - 1] = '*';
  78. 				break;
  79. 			}
  80. 			else
  81. 				printf("坐标已被占用，请重新输入\n");
  82. 		}
  83. 		else
  84. 		{
  85. 			printf("坐标错误，请重新输入\n");
  86. 		}
  87. 	}
  88. }
  89.  
  90.  
  91. //电脑下棋
  92. void ComputerMove(char board[ROW][COL], int  row, int col)
  93. {
  94. 	do {
  95. 		int x = rand() % row;
  96. 		int y = rand() % col;
  97. 		if (board[x][y] == ' ')
  98. 		{
  99. 			board[x][y] = '#';
  100. 			break;
  101. 		}
  102. 	} while (1);
  103. }
  104.  
  105. //判断棋盘是否满了
  106. int Isfull(char board[ROW][COL], int  row, int col)
  107. {
  108. 	int x = 0;
  109. 	int y = 0;
  110. 	for (x = 0; x < row; x++)
  111. 	{
  112. 		for (y = 0; y < col; y++)
  113. 		{
  114. 			if (board[x][y] == ' ')//证明还没满
  115. 				return 0;
  116. 		}
  117. 	}
  118. 	return 1;
  119. }
  120.  
  121. //判断输赢
  122. // 玩家胜利返回 *
  123. //电脑胜利返回 #
  124. //游戏继续返回C
  125. //平局返回P
  126. char Iswin(char board[ROW][COL], int  row, int col)
  127. {
  128. 	//判断哪个棋子胜利
  129. 	int i = 0;
  130. 	for (i = 0; i < row; i++)
  131. 	{
  132. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
  133. 		{
  134. 			return board[i][1];
  135. 		}
  136. 	}
  137.  
  138. 	for (i = 0; i < col; i++)
  139. 	{
  140. 		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
  141. 		{
  142. 			return board[1][i];
  143. 		}
  144. 	}
  145.  
  146. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
  147. 	{
  148. 		return board[1][1];
  149. 	}
  150.  
  151. 	if (board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
  152. 	{
  153. 		return board[1][1];
  154. 	}
  155.  
  156.  
  157. 	//判断棋盘满了没
  158. 	if (Isfull(board, ROW, COL))
  159. 		return 'P';
  160. 	return 'C';
  161.  
  162. }
  163.  
  164. //构建game函数
  165. void game()
  166. {
  167. 	char ret;
  168. 	char board[ROW][COL];
  169. 	//初始化一个二维数组
  170. 	//刚开始的时候，数组的内容应该全是空格
  171. 	InitBoard(board, ROW, COL);
  172.  
  173. 	//打印棋盘
  174. 	Print(board, ROW, COL);
  175.  
  176. 	//开始下棋
  177. 	//玩家下完电脑下，如果判断游戏结束就跳出循环，没有结束就继续循环
  178. 	while (1)
  179. 	{
  180. 		//玩家下棋
  181. 		PlayerMove(board, ROW, COL);
  182. 		Print(board, ROW, COL);
  183.  
  184. 		//判断输赢
  185. 		ret = Iswin(board, ROW, COL);  //用一个字符接受判断输赢函数的返回值
  186. 		if (ret != 'C')
  187. 			break;
  188.  
  189. 		//电脑下棋
  190. 		ComputerMove(board, ROW, COL);
  191. 		Print(board, ROW, COL);
  192.  
  193. 		//判断输赢
  194. 		ret = Iswin(board, ROW, COL);
  195. 		if (ret != 'C')
  196. 			break;
  197. 	}
  198.  
  199. 	//当跳出循环后，判断是谁嬴
  200.  
  201. 	if (ret == '*')   //玩家胜利，给出相应提示
  202. 		printf("恭喜您胜利啦！\n");
  203. 	else if (ret == '#')   //电脑胜利，给出相应提示
  204. 		printf("很遗憾，您输了...\n");
  205. 	else                       //平局，给出相应提示
  206. 		printf("平局\n");
  207.  
  208. }
  209.  
  210. int main()
  211. {
  212. 	srand(time);
  213. 	int input;
  214. 	//先输入一个input判断要不要进入游戏，将其也设为循环的判断条件
  215. 	do {
  216. 		menu();
  217. 		printf("请输入->");
  218. 		scanf("%d", &input);
  219. 		switch (input)
  220. 		{
  221. 		case 1:
  222. 			game();
  223. 			//如果输入1，说明要玩游戏，封装一个game函数来包含游戏内容
  224. 			break;
  225. 		case 0:
  226. 			printf("退出游戏\n");
  227. 			break;
  228. 		default:
  229. 			printf("输错啦，请重新输入\n");
  230. 			break;
  231. 		}
  232. 	} while (input);
  233.  
  234. 	return 0;
  235. }

5、游戏运行

        

以上就是 C语言基础：三子棋小游戏的C语言实现（超详解释+源码）的全部内容啦，希望对你有帮助！

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

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

  

闽ICP备14008679号