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

C语言：三子棋（玩家vs电脑阻拦 + 先手后手）

作者：2023面试高手 | 2024-03-14 11:06:04

赞

踩

C语言：三子棋（玩家vs电脑阻拦 + 先手后手）

目录

 1.前言

2.准备文件

 3.游戏的菜单

 4.游戏过程 

4.1游戏的准备

4.2棋盘的设置

4.3双方的对弈 

1.玩家下棋

2.电脑下棋

4.4判断输赢 

4.5先手后手

5.完整代码展示 

game.h

game.c

text.c

6.运行测试

  7.结语

 1.前言

  三子棋是一种益智游戏，井字棋。游戏分为双方对战，双方依次在9宫格上摆放棋子，率先将自己的三个棋子走一条线就视为胜利，摆满未分出胜负就算平局。

                                e08f7cd6573b49b0a5af651bf36a32e1.jpeg

2.准备文件

该项目分为三个文件：

  1. 1.game.h//函数的声明、头文件存放
  2. 2.game.c//游戏的实现、函数的定义
  3. 3.text.c//游戏的逻辑

 3.游戏的菜单

游戏开始前，我们要在游戏给予玩家一些提示，以便便玩家知道游戏操作，菜单有以下要求：

1.开始游戏

2.退出游戏

3.错误输入情况下给予提示

考虑到游戏的多次游玩，所以我们使用do...while的形式给予玩家多次游玩体验，同时swicth的使用可以满足游戏选项。

下面是代码和运行展示：

  1.  #define _CRT_SECURE_NO_WARNINGS 1
  2. void manu()
  3. {
  4. 	printf("******************\n");
  5. 	printf("******1.play******\n");
  6. 	printf("******0.exit******\n");
  7. 	printf("******************\n");
  8. }
  9. void game()
  10. {
  11. 	printf("三子棋");
  12. }
  13. int main()
  14. {
  15. 	int input = 0;
  16. 	do		
  17. 	{
  18. 		
  19. 		menu();
  20. 		printf("请选择>:");
  21. 		switch (input)
  22. 		{
  23. 		case 1:
  24. 			break;
  25. 		case 2:
  26. 			prinrtf("退出游戏\n");
  27. 			break;
  28. 		case 3:
  29. 			printf("选择错误，请重新选择\n");
  30. 			break;
  31. 		}
  32. 		
  33. 	} while ();
  34.  
  35. 	return 0;
  36. }

 17565f1580c14055a8d7c091f577e55f.png

 4.游戏过程 

提示

1.代码主要侧重于游戏功能的实现，有些代码在接下来不会展示，但在最后会将三个文件的代码全部展示，有需求的直接下滑到到代码展示即可。

2.文件的头文件全部放入game.h是为了方便其他文件，这样不用在每个区域声明头文件，而自建头文件我们需要使用#include"game.h"。

 3.#define _CRT_SECURE_NO_WARNINGS 1的使用是为了忽略vs中scanf的警告。

4.1游戏的准备

先将棋盘的行和列进行定义，方便代码的编程与修改（game.h）。

  1. #pragma once
  2. #include<stdio.h>
  3. #define ROW 3
  4. #define COL 3

4.2棋盘的设置

有了行和列，还要进行初始化棋盘并适当美化，方便玩家观看和操作，我们可以把棋盘简化成这样。

                                                        ab62ae6a0dd34c83ba6322e17ad343a4.png

 要达成以上的效果，我们可以分为两部分，一部分打印3*3二维数组，另一部分负责打印棋盘。用game1（）（先手）和game2（）（后手）函数调用，介绍以game1（）函数为主。

  1. void game1()
  2. {
  3. 	char ret = 0;
  4. 	char board[ROW][COL];
  5. 	Init_board(board ,ROW,COL);//初始化棋盘
  6. 	Display_board(board, ROW, COL);
  7. }

 初始化数组负责棋盘的空白部分，我们打印空白即可。

  1. void Init_board(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.为了棋盘的美观和观看，我们使用空格数据空格（ %c ）将棋盘撑大。

2.   ---     和       |       对应行和列都少一。

  1. void Display_board(char board[ROW][COL], int row, int col)
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	
  6. 	for (i = 0; i < ROW; i++)
  7. 	{
  8. 		for (j = 0; j < COL; j++)
  9. 		{
  10. 			printf(" %c ", board[i][j]);
  11. 			if (j < COL - 1)//最后一列没有
  12. 				printf("|");
  13. 		}
  14.  
  15. 		printf("\n");//打印完|换行
  16. 		if (i < ROW - 1)//最后一行没有
  17. 		{
  18. 			int j = 0;
  19. 			for (j = 0; j < COL; j++)
  20. 			{
  21. 				printf("---");
  22. 				if (j < COL - 1)
  23. 					printf("|");
  24. 			}
  25.  
  26.  
  27. 		}
  28. 		printf("\n");//打印完---换行
  29. 	}
  30. }

4.3双方的对弈 

1.玩家下棋

1.给予玩家操作方下棋提醒，玩家棋子用   *    标识。

2.要求玩家输入棋盘坐标，并对错误坐标和已经占用的坐标进行提醒。

3.注意棋盘和数组的关联，我们以玩家的视角认为棋盘数组的[0][0]为第一行第一列，所以要对数组进行减一处理。

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

2.电脑下棋

1.电脑下棋要求阻拦玩家，这里只是简易版的下棋，所以我们在棋盘上取随机值即可。

2.随机值要用到rand,srand,time函数，其中rand()%3需要取余保证在棋盘（数组内）。他们的使用需要#include<time.h>   #include<stdlib.h> 两个头文件（放在game.h）。

3.电脑下棋用  #  表示。

  1. void Computer_move(char board[ROW][COL], int row, int col)
  2. {
  3. 	printf("\n电脑下棋\n");
  4.  
  5. 	int x = 0;
  6. 	int y = 0;
  7. 	while (1)
  8. 	{
  9. 		x = rand() % ROW;//取余保证在区域内
  10. 		y = rand() % COL;
  11. 		if (board[x][y] == ' ')
  12. 		{
  13. 			board[x][y] = '#';
  14. 			break;
  15. 		}
  16. 	}
  17. }

这只是简易版，如果想要智能阻拦玩家和赢过玩家，我们还需要对代码进行更改。

1.判断主对角线和直线上的棋子是否已经有两个相同棋子，进行阻拦或者赢下比赛。

2.当电脑操控时，棋盘出现玩家和电脑都在棋盘上都有两颗棋子，电脑优先将自己棋子连成一条线。

  1. static int computer_plan(char board[ROW][COL], int row, int col, char ch)//ch为'#'是进行下棋，ch为'*'时进行阻拦
  2. {
  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. 			//判断第一个和第二个的元素电脑是否已下棋，对第三个元素进行下棋/阻拦
  11. 			if (board[i][0] == board[i][1] && board[i][0] == ch && board[i][2] == ' ')
  12. 			{
  13. 				board[i][2] = '#';
  14. 				return 1;
  15. 			}
  16. 			//判断第一个和第三个的元素电脑是否已下棋，对第二个元素进行下棋/阻拦
  17. 			if (board[i][0] == board[i][2] && board[i][0] == ch && board[i][1] == ' ')
  18. 			{
  19. 				board[i][1] = '#';
  20. 				return 1;
  21. 			}
  22. 			//判断第二个和第三个的元素电脑是否已下棋，对第一个元素进行下棋/阻拦
  23. 			if (board[i][1] == board[i][2] && board[i][1] == ch && board[i][0] == ' ')
  24. 			{
  25. 				board[i][0] = '#';
  26. 				return 1;
  27. 			}
  28. 		}
  29. 	}
  30. 	//列
  31. 	for (i = 0; i < row; i++)
  32. 	{
  33. 		int j = 0;
  34. 		for (j = 0; j < col; j++)
  35. 		{
  36. 			//第一和第二个已下，下/阻拦第三个
  37. 			if (board[0][j] == board[1][j] && board[0][j] == ch && board[2][j] == ' ')
  38. 			{
  39. 				board[2][j] = '#';
  40. 				return 1;
  41. 			}
  42. 			//第一和第三个已下，下/阻拦第二个
  43. 			if (board[0][j] == board[2][j] && board[0][j] == ch && board[1][j] == ' ')
  44. 			{
  45. 				board[1][j] = '#';
  46. 				return 1;
  47. 			}
  48. 			//第二和第三个已下，下/阻拦第一个
  49. 			if (board[1][j] == board[2][j] && board[1][j] == ch && board[0][j] == ' ')
  50. 			{
  51. 				board[0][j] = '#';
  52. 				return 1;
  53. 			}
  54. 		}
  55. 	}
  56. 	//主对角线
  57. 	if (board[0][0] == board[1][1] && board[1][1] == ch && board[2][2] == ' ')//落子/阻拦主对角线第三个元素
  58. 	{
  59. 		board[2][2] = '#';
  60. 		return 1;
  61. 	}
  62. 	if (board[0][0] == board[2][2] && board[0][0] == ch && board[1][1] == ' ')//落子/阻拦主对角线第二个元素
  63. 	{
  64. 		board[1][1] = '#';
  65. 		return 1;
  66. 	}
  67. 	if (board[1][1] == board[2][2] && board[1][1] == ch && board[0][0] == ' ')//落子/阻拦主对角线第一个元素
  68. 	{
  69. 		board[0][0] = '#';
  70. 		return 1;
  71. 	}
  72. 	//副对角线
  73. 	if (board[0][2] == board[1][1] && board[0][2] == ch && board[2][0] == ' ')//落子/阻拦副对角线第三个元素
  74. 	{
  75. 		board[2][0] = '#';
  76. 		return 1;
  77. 	}
  78. 	if (board[0][2] == board[2][0] && board[0][2] == ch && board[1][1] == ' ')//落子/阻拦副对角线第二个元素
  79. 	{
  80. 		board[1][1] = '#';
  81. 		return 1;
  82. 	}
  83. 	if (board[1][1] == board[2][0] && board[1][1] == ch && board[0][2] == ' ')//落子/阻拦副对角线第一个元素
  84. 	{
  85. 		board[0][2] = '#';
  86. 		return 1;
  87. 	}
  88. 	return 0;//若无法赢棋或无法阻拦，返回0
  89. }
  90.  
  91. void Computer_move(char board[ROW][COL], int row, int col)
  92. {
  93. 	printf("\n电脑下棋\n");
  94. 	int sign1 = 0;
  95. 	int sign2 = 0;
  96. 	sign1 = computer_plan(board, ROW, COL, '#');//电脑赢棋
  97. 	if (sign1 == 0)
  98. 	{
  99. 		sign1 = computer_plan(board, ROW, COL, '*');//对玩家进行阻拦
  100. 		if (sign2 == 0)
  101. 		{
  102. 			int x = 0;
  103. 			int y = 0;
  104. 			while (1)
  105. 			{
  106.  
  107. 				x = rand() % ROW;//取余保证在区域内
  108. 				y = rand() % COL;
  109. 				if (board[x][y] == ' ')
  110. 				{
  111. 					board[x][y] = '#';
  112. 					break;
  113. 				}
  114. 			}
  115. 		}
  116. 	}
  117. 	
  118. }

4.4判断输赢 

//玩家赢--"*"
//电脑赢--"#"
//平局  --"Q"
//继续  --"C"

1.赢下游戏，分为四种情况，行、列、主对角线、副对角线所占元素均相同且不为空。
2.遍历棋盘中所有棋格，如果发现已经全部满有棋子，平局。
3.如果输赢和平局并不满足，则游戏继续。

  1. //玩家赢--"*"
  2. //电脑赢--"#"
  3. //平局  --"Q"
  4. //继续  --"C"
  5. char is_win(char board[ROW][COL], int row, int col)
  6. {
  7. 	int i = 0;
  8. 	for (i = 0; i < ROW; i++)
  9. 	{
  10. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2]&&board[i][1]!=' ')
  11. 		{
  12. 			return board[i][0];
  13. 		}
  14. 		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board [1][i]!= ' ')
  15. 		{
  16. 			return board[0][i];
  17. 		}
  18. 		if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
  19. 		{
  20. 			return board[1][1];
  21. 		}
  22. 		if (board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
  23. 		{
  24. 			return board[1][1];
  25. 		}	
  26. 	}
  27. 	if (is_full(board, row, col))
  28. 	{
  29. 		return 'Q';
  30. 	}
  31. 	//判断平局
  32. 	return 'C';
  33. }

4.5先手后手

玩家先手时我们需要打印一个棋盘，方便玩家观察落子。

                                                          ab62ae6a0dd34c83ba6322e17ad343a4.png

  1. void game1()//先手
  2. {
  3. 	char ret = 0;
  4. 	char board[ROW][COL];
  5. 	Init_board(board ,ROW,COL);//初始化棋盘
  6. 	Display_board(board, ROW, COL);//打印棋盘
  7. 	
  8. 	//下棋
  9. 	while(1)
  10. 	{
  11. 		playmove(board, ROW, COL);
  12. 		Display_board(board, ROW, COL);
  13. 		ret = is_win(board, ROW, COL);//判断输赢
  14. 		if (ret != 'C')
  15. 		{
  16. 			break;
  17. 		}
  18. 		Computer_move(board, ROW, COL);
  19. 		Display_board(board, ROW, COL);
  20. 		ret = is_win(board, ROW, COL);
  21. 		//判断输赢
  22. 		if (ret != 'C')
  23. 		{
  24. 			break;
  25. 		}
  26. 		
  27. 	}
  28. 	if (ret == '*')
  29. 	{
  30. 		printf("玩家赢\n");
  31. 	}
  32. 	else if (ret == '#')
  33. 	{
  34. 		printf("电脑赢\n");
  35. 	}
  36. 	else
  37. 		printf("平局\n");
  38.  
  39.  
  40. }

后手时由于电脑先下所以不必打印初始化棋盘，稍加改变即可。

                                                        aac1ad423efe4f5b9608687660cf30a3.png

  1. void game2()//后手
  2. {
  3. 	char ret = 0;
  4. 	char board[ROW][COL];//初始化棋盘；
  5. 	Init_board(board, ROW, COL);
  6.  
  7. 	
  8. 	while (1)
  9. 	{
  10. 		Computer_move(board, ROW, COL);
  11. 		Display_board(board, ROW, COL);
  12. 		ret = is_win(board, ROW, COL);
  13. 		if (ret != 'C')
  14. 		{
  15. 			break;
  16. 		}
  17. 		playmove(board, ROW, COL);
  18. 		Display_board(board, ROW, COL);
  19. 		ret = is_win(board, ROW, COL);//判断输赢
  20. 		if (ret != 'C')
  21. 		{
  22. 			break;
  23. 		}
  24.  
  25. 	}
  26. 	if (ret == '*')
  27. 	{
  28. 		printf("玩家赢\n");
  29. 	}
  30. 	else if (ret == '#')
  31. 	{
  32. 		printf("电脑赢\n");
  33. 	}
  34. 	else
  35. 		printf("平局\n");
  36.  
  37.  
  38. }

5.完整代码展示 

game.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<time.h>
  4. #include<stdlib.h>
  5. #define ROW 3
  6. #define COL 3 
  7. //初始棋盘
  8. void Init_board(char board[ROW][COL], int row, int col);
  9. //打印棋盘
  10. void Display_board(char board[ROW][COL], int row, int col);
  11. //玩家下棋
  12. void playmove(char board[ROW][COL], int row, int col);
  13. //电脑下棋
  14. void Computer_move(char board[ROW][COL], int row, int col);
  15. //判断输赢结果
  16. char is_win(char board[ROW][COL], int row, int col);

game.c

  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. 	int j = 0;
  10. 	for (i = 0; i < ROW; i++)
  11. 	{
  12. 		for (j = 0; j < COL; j++)
  13. 		{
  14. 			board[i][j] = ' ';
  15. 		} 
  16. 	}
  17. }
  18.  
  19. void Display_board(char board[ROW][COL], int row, int col)
  20. {
  21. 	int i = 0;
  22. 	int j = 0;
  23. 	
  24. 	for (i = 0; i < ROW; i++)
  25. 	{
  26. 		for (j = 0; j < COL; j++)
  27. 		{
  28. 			printf(" %c ", board[i][j]);
  29. 			if (j < COL - 1)//最后一列没有
  30. 				printf("|");
  31. 		}
  32.  
  33. 		printf("\n");//打印完|换行
  34. 		if (i < ROW - 1)//最后一行没有
  35. 		{
  36. 			int j = 0;
  37. 			for (j = 0; j < COL; j++)
  38. 			{
  39. 				printf("---");
  40. 				if (j < COL - 1)
  41. 					printf("|");
  42. 			}
  43.  
  44.  
  45. 		}
  46. 		printf("\n");//打印完---换行
  47. 	}
  48. }
  49.  
  50. void playmove(char board[ROW][COL], int row, int col)
  51. {
  52. 	int x = 0;
  53. 	int y = 0;
  54. 	printf("\n玩家下棋\n");
  55. 	while (1)
  56. 	{
  57. 		printf("请输入下棋的坐标>:");
  58. 		scanf("%d %d", &x, &y);
  59. 		getchar();
  60. 		if (0 <= x && x <= ROW && 0 <= y && y<=COL)
  61. 		{
  62. 			if (board[x - 1][y - 1] == ' ')
  63. 			{
  64. 				board[x - 1][y - 1] = '*';
  65. 				break;
  66. 			}
  67. 			else
  68. 				printf("该坐标被占用,请输入其他坐标\n");
  69. 		}
  70. 		else
  71. 			printf("坐标错误，请重新输入\n");
  72. 	}
  73.  
  74. }
  75.  
  76. static int computer_plan(char board[ROW][COL], int row, int col, char ch)//ch为'#'进行下棋，ch为'*'进行阻拦
  77. {
  78. 	//检查电脑能否获得胜利/阻拦玩家
  79. 	int i = 0;
  80. 	for (i = 0; i < row; i++)
  81. 	{
  82. 		int j = 0;
  83. 		for (j = 0; j < col; j++)
  84. 		{
  85. 			//判断第一个和第二个的元素电脑是否已下棋，对第三个元素进行下棋/阻拦
  86. 			if (board[i][0] == board[i][1] && board[i][0] == ch && board[i][2] == ' ')
  87. 			{
  88. 				board[i][2] = '#';
  89. 				return 1;
  90. 			}
  91. 			//判断第一个和第三个的元素电脑是否已下棋，对第二个元素进行下棋/阻拦
  92. 			if (board[i][0] == board[i][2] && board[i][0] == ch && board[i][1] == ' ')
  93. 			{
  94. 				board[i][1] = '#';
  95. 				return 1;
  96. 			}
  97. 			//判断第二个和第三个的元素电脑是否已下棋，对第一个元素进行下棋/阻拦
  98. 			if (board[i][1] == board[i][2] && board[i][1] == ch && board[i][0] == ' ')
  99. 			{
  100. 				board[i][0] = '#';
  101. 				return 1;
  102. 			}
  103. 		}
  104. 	}
  105. 	//列
  106. 	for (i = 0; i < row; i++)
  107. 	{
  108. 		int j = 0;
  109. 		for (j = 0; j < col; j++)
  110. 		{
  111. 			//第一和第二个已下，下/阻拦第三个
  112. 			if (board[0][j] == board[1][j] && board[0][j] == ch && board[2][j] == ' ')
  113. 			{
  114. 				board[2][j] = '#';
  115. 				return 1;
  116. 			}
  117. 			//第一和第三个已下，下/阻拦第二个
  118. 			if (board[0][j] == board[2][j] && board[0][j] == ch && board[1][j] == ' ')
  119. 			{
  120. 				board[1][j] = '#';
  121. 				return 1;
  122. 			}
  123. 			//第二和第三个已下，下/阻拦第一个
  124. 			if (board[1][j] == board[2][j] && board[1][j] == ch && board[0][j] == ' ')
  125. 			{
  126. 				board[0][j] = '#';
  127. 				return 1;
  128. 			}
  129. 		}
  130. 	}
  131. 	//主对角线
  132. 	if (board[0][0] == board[1][1] && board[1][1] == ch && board[2][2] == ' ')//落子/阻拦主对角线第三个元素
  133. 	{
  134. 		board[2][2] = '#';
  135. 		return 1;
  136. 	}
  137. 	if (board[0][0] == board[2][2] && board[0][0] == ch && board[1][1] == ' ')//落子/阻拦主对角线第二个元素
  138. 	{
  139. 		board[1][1] = '#';
  140. 		return 1;
  141. 	}
  142. 	if (board[1][1] == board[2][2] && board[1][1] == ch && board[0][0] == ' ')//落子/阻拦主对角线第一个元素
  143. 	{
  144. 		board[0][0] = '#';
  145. 		return 1;
  146. 	}
  147. 	//副对角线
  148. 	if (board[0][2] == board[1][1] && board[0][2] == ch && board[2][0] == ' ')//落子/阻拦副对角线第三个元素
  149. 	{
  150. 		board[2][0] = '#';
  151. 		return 1;
  152. 	}
  153. 	if (board[0][2] == board[2][0] && board[0][2] == ch && board[1][1] == ' ')//落子/阻拦副对角线第二个元素
  154. 	{
  155. 		board[1][1] = '#';
  156. 		return 1;
  157. 	}
  158. 	if (board[1][1] == board[2][0] && board[1][1] == ch && board[0][2] == ' ')//落子/阻拦副对角线第一个元素
  159. 	{
  160. 		board[0][2] = '#';
  161. 		return 1;
  162. 	}
  163. 	return 0;//若无法赢棋或无法阻拦，返回0
  164. }
  165.  
  166. void Computer_move(char board[ROW][COL], int row, int col)
  167. {
  168. 	printf("\n电脑下棋\n");
  169. 	int sign1 = 0;
  170. 	int sign2 = 0;
  171. 	sign1 = computer_plan(board, ROW, COL, '#');//电脑赢棋
  172. 	if (sign1 == 0)
  173. 	{
  174. 		sign1 = computer_plan(board, ROW, COL, '*');//对玩家进行阻拦
  175. 		if (sign2 == 0)
  176. 		{
  177. 			int x = 0;
  178. 			int y = 0;
  179. 			while (1)
  180. 			{
  181.  
  182. 				x = rand() % ROW;//取余保证在区域内
  183. 				y = rand() % COL;
  184. 				if (board[x][y] == ' ')
  185. 				{
  186. 					board[x][y] = '#';
  187. 					break;
  188. 				}
  189. 			}
  190. 		}
  191. 	}
  192. 	
  193. }
  194. static int is_full(char board[ROW][COL], int row, int col)
  195. {
  196. 	int i = 0;
  197. 	int j = 0;
  198. 	for (i = 0; i < ROW; i++)
  199. 	{
  200. 		for (j = 0; j < COL; j++)
  201. 		{
  202. 			if (board[i][j] == ' ')
  203. 				return 0;
  204. 		}
  205. 	}
  206. 	return 1;
  207. }
  208. //玩家赢--"*"
  209. //电脑赢--"#"
  210. //平局  --"Q"
  211. //继续  --"C"
  212. char is_win(char board[ROW][COL], int row, int col)
  213. {
  214. 	int i = 0;
  215. 	for (i = 0; i < ROW; i++)
  216. 	{
  217. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2]&&board[i][1]!=' ')
  218. 		{
  219. 			return board[i][0];
  220. 		}
  221. 		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board [1][i]!= ' ')
  222. 		{
  223. 			return board[0][i];
  224. 		}
  225. 		if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
  226. 		{
  227. 			return board[1][1];
  228. 		}
  229. 		if (board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
  230. 		{
  231. 			return board[1][1];
  232. 		}	
  233. 	}
  234. 	if (is_full(board, row, col))
  235. 	{
  236. 		return 'Q';
  237. 	}
  238. 	//判断平局
  239. 	return 'C';
  240. }

text.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. void game1()//先手
  12. {
  13. 	char ret = 0;
  14. 	char board[ROW][COL];
  15. 	Init_board(board ,ROW,COL);//初始化棋盘
  16. 	Display_board(board, ROW, COL);//打印棋盘
  17. 	
  18. 	//下棋
  19. 	while(1)
  20. 	{
  21. 		playmove(board, ROW, COL);
  22. 		Display_board(board, ROW, COL);
  23. 		ret = is_win(board, ROW, COL);//判断输赢
  24. 		if (ret != 'C')
  25. 		{
  26. 			break;
  27. 		}
  28. 		Computer_move(board, ROW, COL);
  29. 		Display_board(board, ROW, COL);
  30. 		ret = is_win(board, ROW, COL);
  31. 		//判断输赢
  32. 		if (ret != 'C')
  33. 		{
  34. 			break;
  35. 		}
  36. 		
  37. 	}
  38. 	if (ret == '*')
  39. 	{
  40. 		printf("玩家赢\n");
  41. 	}
  42. 	else if (ret == '#')
  43. 	{
  44. 		printf("电脑赢\n");
  45. 	}
  46. 	else
  47. 		printf("平局\n");
  48.  
  49.  
  50. }
  51. void game2()//后手
  52. {
  53. 	char ret = 0;
  54. 	char board[ROW][COL];//初始化棋盘；
  55. 	Init_board(board, ROW, COL);
  56.  
  57. 	
  58. 	while (1)
  59. 	{
  60. 		Computer_move(board, ROW, COL);
  61. 		Display_board(board, ROW, COL);
  62. 		ret = is_win(board, ROW, COL);
  63. 		if (ret != 'C')
  64. 		{
  65. 			break;
  66. 		}
  67. 		playmove(board, ROW, COL);
  68. 		Display_board(board, ROW, COL);
  69. 		ret = is_win(board, ROW, COL);//判断输赢
  70. 		if (ret != 'C')
  71. 		{
  72. 			break;
  73. 		}
  74.  
  75. 	}
  76. 	if (ret == '*')
  77. 	{
  78. 		printf("玩家赢\n");
  79. 	}
  80. 	else if (ret == '#')
  81. 	{
  82. 		printf("电脑赢\n");
  83. 	}
  84. 	else
  85. 		printf("平局\n");
  86.  
  87.  
  88. }
  89. int main()
  90. {
  91. 	int a = 0;
  92. 	int input = 0;
  93. 	srand((unsigned int)time(NULL));
  94. 	do		
  95. 	{
  96. 		menu();
  97. 		printf("请选择>:");
  98. 		scanf("%d", &input);
  99. 		switch (input)
  100. 		{
  101. 		case 1:
  102. 			
  103. 			printf("\n请选择先后手>:1.先手  2.后手\n");
  104. 			scanf("%d", &a);
  105. 			if (a == 1)
  106. 			{
  107. 				game1();
  108. 			}
  109. 			if (a == 2)
  110. 			{
  111. 				game2();
  112. 			}
  113. 			else
  114. 				printf("请重新输入\n");
  115. 			break;
  116. 		case 2:
  117. 			printf("\n退出游戏\n");
  118. 			break;
  119. 		case 3:
  120. 			printf("\n选择错误，请重新选择\n");
  121. 			break;
  122. 		}
  123. 		
  124. 	} while (input);
  125.  
  126. 	return 0;
  127. }

6.运行测试

                                         0976236d4dbf42468200636adfae4a8d.gif

  7.结语

 到这里，一个简易的三子棋就这样做成功了。我们的电脑也不是人工智障了，不思考一下还真的赢不了电脑。

好了这次的c语言三子棋就到这里了，如果觉得我写的不错，还请一键三连。

如果嫌复制粘贴麻烦可以点此链接，从我的gitee仓库直接下载。

我是₯㎕星空&繁华，一名c语言的初学者，我们下期见！

    5db0f4c557ed43dba104b153027f9444.jpeg

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

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

  

闽ICP备14008679号