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

C语言实现三子棋_c语言打印3*3棋盘

作者：Monodyee | 2024-02-23 09:26:25

赞

踩

c语言打印3*3棋盘

目录

一、规则简介

二、游戏逻辑

三、菜单打印

四、棋盘的创建和初始化

五、棋盘打印

六、下棋

6.1 玩家下棋

6.2 电脑下棋

6.3 输赢判断

七、总结

一、规则简介

三子棋是黑白棋的一种。三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙、井字棋等。将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。

二、游戏逻辑

首先，我们需要一个游戏菜单，通过玩家的输入进行不同的操作，这里就可以使用 switch 语句实现；根据玩家的不同选择，有两种走向，选择 1、玩游戏  0、退出  以及选择错误时需要给玩家提示。

我们还希望这个游戏可以一直玩下去，直到玩家主动选择退出，因此这里采用一个循环语句，由于刚刚说了玩家需要输入选择，这里循环的控制可以直接根据玩家选择进行设置，这里我采用的是 do while 循环，大家也可以尝试使用 while 循环。

程序文件主要有三个，分别是：主函数文件test.c；包含游戏主要功能的源文件game.c；用来引用各种头文件，声明函数的头文件game.h 。

  1. int main()
  2. {
  3. 	int input = 0;
  4. 	do
  5. 	{
  6. 		menu();
  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. 			break;
  20. 		}
  21.  
  22. 	} while (input);
  23. 	return 0;
  24. }

三、菜单打印

菜单打印就是简单的输出语句，代码如下：

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

四、棋盘的创建和初始化

菜单打印完后，就进入到我们的游戏主题  game()  函数，首先是棋盘创建及初始化，我们需要打印一个3x3 的棋盘，首先在头文件中定义全局变量，棋盘的行列，这样方便后续更改。

  1. #include <stdio.h>
  2.  
  3.  
  4.  
  5. #define ROW 3  //行
  6. #define COL 3  //列
  1. void game()
  2. {
  3. 	char ret = 0;
  4. 	//生成棋盘
  5. 	char board[ROW][COL] = { 0 };
  6. 	//初始化棋盘
  7. 	initboard(board, ROW, COL);
  8. 	//打印棋盘
  9. 	displayboard(board, ROW, COL);
  10. }

初始化棋盘通过函数  initboard() 实现，由于初始化对象是棋盘，因此函数的参数需要：棋盘本身，棋盘行列，代码如下：

  1. void initboard(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. 			board[i][j] = ' ';
  10. 		}
  11. 	}
  12. }

在没有下棋时，将棋盘每个位置设为空格

五、棋盘打印

棋盘创建及初始化之后，需要打印出来让玩家看到

棋盘有以下特点：三个棋子行，两个分割行，两个分隔列

  1. //   |   |   
  2. //---|---|---
  3. //   |   |   
  4. //---|---|---
  5. //   |   |

通过函数 displayboard() 实现，函数参数同样是 棋盘本身及棋盘行列：

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

这里在打印分割行时设置条件为  i<row-1，j<col-1 因为在棋盘的边缘不需要分割行和分隔列。

打印结果如下：

六、下棋

 棋盘生成后就可以开下棋了，由于需要循环下棋，这里也采用循环语句控制：

  1. void game()
  2. {
  3. 	char ret = 0;
  4. 	//生成棋盘
  5. 	char board[ROW][COL] = { 0 };
  6. 	//初始化棋盘
  7. 	initboard(board, ROW, COL);
  8. 	//打印棋盘
  9. 	displayboard(board, ROW, COL);
  10.     //下棋
  11. 	while (1)
  12. 	{
  13. 		//玩家下
  14. 		player(board, ROW, COL);
  15. 		//打印
  16. 		displayboard(board, ROW, COL);
  17. 		//判断输赢
  18. 		ret = win(board, ROW, COL);
  19. 		if (ret != 'c')
  20. 			break;
  21. 		//电脑下
  22. 		com(board, ROW, COL);
  23. 		displayboard(board, ROW, COL);
  24. 		//判断
  25. 		ret = win(board, ROW, COL);
  26. 		if (ret != 'c')
  27. 			break;
  28. 	}

 下棋又分为玩家下棋以及电脑下棋，并且每次下棋后，希望能够打印出来让玩家看见。此外，每次下棋，无论玩家还是电脑，都有可能使得游戏结束，可能是玩家赢也可能电脑赢，也可能平局，因此每次下棋后还需要判断游戏的输赢

6.1 玩家下棋

玩家下棋时，通过玩家输入棋盘坐标确定下棋的位置.

注意：玩家输入的坐标是从1-3，但棋盘生成是通过数组完成，因此在代码中坐标是从 0-2

在玩家下棋时，要判断该位置是否已经有棋子，或者是否在棋盘范围内，如果不符合上述条件要求玩家重下，因此这里也需要循环

玩家下棋的代码：

  1. void player(char board[ROW][COL], int row, int col)
  2. {
  3. 	int x = 0;
  4. 	int y = 0;
  5. 	scanf("%d %d", &x, &y);
  6. 	while (1)
  7. 	{
  8. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  9. 		{
  10. 			if (board[x - 1][y - 1] == ' ')
  11. 			{
  12. 				board[x - 1][y - 1] = '*';
  13. 				break;
  14. 			}
  15. 			else
  16. 				printf("该坐标被占用,重新输入\n");
  17. 		}
  18. 		else
  19. 		{
  20. 			printf("输入错误，重新输入\n");
  21. 		}
  22. 	}
  23. }

6.2 电脑下棋

电脑下棋要比玩家更简单一些，这里我们通过生成随机数让电脑在棋盘上随机下子

随机数生成需要用到 rand() 和 srand() 函数，同时通过时间戳来设置随机数的起点，因此在头文件 game.h 中需要加上相应的头文件

  1. #include <stdio.h>
  2. #include <stdlib.h> //rand  srand
  3. #include <time.h>   //time
  4.  
  5. #define ROW 3  //行
  6. #define COL 3  //列

由于 srand 只使用一次，所有我们在 game 函数循环的外面进行 srand 

  1. void game()
  2. {
  3. 	char ret = 0;
  4. 	//生成棋盘
  5. 	char board[ROW][COL] = { 0 };
  6. 	//初始化棋盘
  7. 	initboard(board, ROW, COL);
  8. 	//打印棋盘
  9. 	displayboard(board, ROW, COL);
  10.  
  11. 	srand((unsigned int)time(NULL)); //随机数起点设置
  12. 	
  13.     while (1)
  14. 	{
  15. 		//玩家下
  16. 		player(board, ROW, COL);
  17. 		//打印
  18. 		displayboard(board, ROW, COL);
  19. 		//判断输赢
  20. 		ret = win(board, ROW, COL);
  21. 		if (ret != 'c')
  22. 			break;
  23. 		//电脑下
  24. 		com(board, ROW, COL);
  25. 		displayboard(board, ROW, COL);
  26. 		//判断
  27. 		ret = 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
  36. 		printf("平局\n");
  37. }

通过随机数对行列分别取余，控制随机数范围在 0-2

电脑下棋代码如下：

  1. void com(char board[ROW][COL], int row, int col)
  2. {
  3. 	while (1)
  4. 	{
  5. 		int x = rand() % row;
  6. 		int y = rand() % col;
  7. 		if (board[x][y] == ' ')
  8. 		{
  9. 			board[x][y] = '#';
  10. 			break;
  11. 		}
  12. 	}
  13. }

6.3 输赢判断

获胜共有三种方式，横向，竖向，对角组成一线，以及在棋盘下满时若无人获胜则平局

这里通过不同的返回值来确定输赢及平局

返回 * ：玩家获胜

返回 #：电脑获胜

返回 c：无人获胜，且棋盘未满，继续游戏

返回 q：棋盘满了，平局

代码如下：

  1. char 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 < row; i++)
  14. 	{
  15. 		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
  16. 		{
  17. 			return board[0][1];
  18. 		}
  19. 	}
  20. 	//对角
  21. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ')
  22. 	{
  23. 		return board[0][0];
  24. 	}
  25. 	if (full(board, ROW, COL) == 1)
  26. 		return 'q';
  27. 	return 'c';
  28. }

这里在判断棋盘是否满时，又另外封装了一个函数，通过返回值判读棋盘是否满了

返回1：满了

返回0：未满

  1. int 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. 				return 0;
  11. 		}
  12. 	}
  13. 	return 1;
  14. }

由于输赢判断函数有返回值，所以在 game 函数中需要一个变量接受该返回值，最后通过判断该变量的值确定输赢：

  1. void game()
  2. {
  3. 	char ret = 0;//用于接收输赢判断函数返回值的变量
  4. 	
  5.     //生成棋盘
  6. 	char board[ROW][COL] = { 0 };
  7. 	//初始化棋盘
  8. 	initboard(board, ROW, COL);
  9. 	//打印棋盘
  10. 	displayboard(board, ROW, COL);
  11. 	
  12.     srand((unsigned int)time(NULL));//随机数起点设置
  13. 	
  14.     while (1)
  15. 	{
  16. 		//玩家下
  17. 		player(board, ROW, COL);
  18. 		//打印
  19. 		displayboard(board, ROW, COL);
  20. 		//判断输赢
  21. 		ret = win(board, ROW, COL);
  22. 		if (ret != 'c')
  23. 			break;
  24. 		//电脑下
  25. 		com(board, ROW, COL);
  26. 		displayboard(board, ROW, COL);
  27. 		//判断
  28. 		ret = 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
  37. 		printf("平局\n");
  38. }

七、总结

至此，三子棋的基本功能都完成了，我们来看下各个文件中的代码：

首先是头文件 game.h ：

  1. # define _CRT_SECURE_NO_WARNINGS 1
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <time.h>
  5. #define ROW 3
  6. #define COL 3
  7.  
  8. void menu();
  9.  
  10. void game();
  11.  
  12. void initboard(char board[ROW][COL], int row, int col);
  13.  
  14. void displayboard(char board[ROW][COL], int row, int col);
  15.  
  16. void player(char board[ROW][COL], int row, int col);
  17.  
  18. char win(char board[ROW][COL], int row, int col);
  19.  
  20. void com(char board[ROW][COL], int row, int col);

游戏文件 game.c：

  1. # define _CRT_SECURE_NO_WARNINGS 1
  2. #include "game.h"
  3. void menu()
  4. {
  5. 	printf("**********************\n");
  6. 	printf("*****  1.play  *******\n");
  7. 	printf("*****  0.exit  *******\n");
  8. 	printf("**********************\n");
  9. }
  10.  
  11. //   |   |   
  12. //---|---|---
  13. //   |   |   
  14. //---|---|---
  15. //   |   |   
  16.  
  17. void initboard(char board[ROW][COL], int row, int col)
  18. {
  19. 	int i = 0;
  20. 	int j = 0;
  21. 	for (i = 0; i < ROW; i++)
  22. 	{
  23. 		for (j = 0; j < COL; j++)
  24. 		{
  25. 			board[i][j] = ' ';
  26. 		}
  27. 	}
  28. }
  29.  
  30. void displayboard(char board[ROW][COL], int row, int col)
  31. {
  32. 	int i = 0;
  33. 	int j = 0;
  34. 	for (i = 0; i < row; i++)
  35. 	{
  36. 		//棋子行
  37. 		for (j = 0; j < col; j++)
  38. 		{
  39. 			printf(" %c ", board[i][j]);
  40. 			if (j < col - 1)
  41. 				printf("|");
  42. 		}
  43. 		printf("\n");
  44. 		//分隔行
  45. 		if (i < row - 1)
  46. 		{
  47. 			for (j = 0; j < col; j++)
  48. 			{
  49. 				printf("---");
  50. 				if (j < col - 1)
  51. 					printf("|");
  52. 			}
  53. 		}
  54. 		printf("\n");
  55. 	}
  56. }
  57.  
  58. void player(char board[ROW][COL], int row, int col)
  59. {
  60. 	int x = 0;
  61. 	int y = 0;
  62. 	scanf("%d %d", &x, &y);
  63. 	while (1)
  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. 				printf("该坐标被占用,重新输入\n");
  74. 		}
  75. 		else
  76. 		{
  77. 			printf("输入错误，重新输入\n");
  78. 		}
  79. 	}
  80. }
  81.  
  82. int full(char board[ROW][COL], int row, int col)
  83. {
  84. 	int i = 0;
  85. 	int j = 0;
  86. 	for (i = 0; i < row; i++)
  87. 	{
  88. 		for (j = 0; j < col; j++)
  89. 		{
  90. 			if (board[i][j] == ' ')
  91. 				return 0;
  92. 		}
  93. 	}
  94. 	return 1;
  95. }
  96.  
  97. char win(char board[ROW][COL], int row, int col)
  98. {
  99. 	int i = 0;
  100. 	//横行
  101. 	for (i = 0; i < row; i++)
  102. 	{
  103. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
  104. 		{
  105. 			return board[i][0];
  106. 		}
  107. 	}
  108. 	//竖行
  109. 	for (i = 0; i < row; i++)
  110. 	{
  111. 		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
  112. 		{
  113. 			return board[0][1];
  114. 		}
  115. 	}
  116. 	//对角
  117. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ')
  118. 	{
  119. 		return board[0][0];
  120. 	}
  121. 	if (full(board, ROW, COL) == 1)
  122. 		return 'q';
  123. 	return 'c';
  124. }
  125.  
  126. void com(char board[ROW][COL], int row, int col)
  127. {
  128. 	while (1)
  129. 	{
  130. 		int x = rand() % row;
  131. 		int y = rand() % col;
  132. 		if (board[x][y] == ' ')
  133. 		{
  134. 			board[x][y] = '#';
  135. 			break;
  136. 		}
  137. 	}
  138. }
  139.  
  140. void game()
  141. {
  142. 	char ret = 0;
  143. 	//生成棋盘
  144. 	char board[ROW][COL] = { 0 };
  145. 	//初始化棋盘
  146. 	initboard(board, ROW, COL);
  147. 	//打印棋盘
  148. 	displayboard(board, ROW, COL);
  149. 	srand((unsigned int)time(NULL));
  150. 	while (1)
  151. 	{
  152. 		//玩家下
  153. 		player(board, ROW, COL);
  154. 		//打印
  155. 		displayboard(board, ROW, COL);
  156. 		//判断输赢
  157. 		ret = win(board, ROW, COL);
  158. 		if (ret != 'c')
  159. 			break;
  160. 		//电脑下
  161. 		com(board, ROW, COL);
  162. 		displayboard(board, ROW, COL);
  163. 		//判断
  164. 		ret = win(board, ROW, COL);
  165. 		if (ret != 'c')
  166. 			break;
  167. 	}
  168. 	if (ret == '*')
  169. 		printf("玩家赢\n");
  170. 	else if (ret == '#')
  171. 		printf("电脑赢\n");
  172. 	else
  173. 		printf("平局\n");
  174. }

主函数文件 test.c：

  1. # define _CRT_SECURE_NO_WARNINGS 1
  2. #include "game.h"
  3.  
  4.  
  5. int main()
  6. {
  7. 	int input = 0;
  8. 	do
  9. 	{
  10. 		menu();
  11. 		printf("请选择>:");
  12. 		scanf("%d", &input);
  13. 		switch (input)
  14. 		{
  15. 		case 1:
  16. 			game();
  17. 			break;
  18. 		case 0:
  19. 			printf("游戏退出\n");
  20. 			break;
  21. 		default:
  22. 			printf("选择错误，重新选择\n");
  23. 			break;
  24. 		}
  25.  
  26. 	} while (input);
  27. 	return 0;
  28. }

现在让我们来试试游戏吧：

 

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

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

  

闽ICP备14008679号