三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

05-12 1725阅读

㊙️小明博客主页:➡️ 敲键盘的小明 ㊙️

✅关注小明了解更多知识☝️


文章目录

  • 前言
  • 一、三子棋的实现思路
  • 二、三子棋的实现步骤
    • 2.1 先显示游戏的菜单
    • 2.2 游戏的具体实现
      • 2.2.1 棋盘的初始化
      • 2.2.2 展示棋盘
      • 2.2.3 下棋
      • 🔴玩家下棋
      • 🔴电脑下棋
      • 2.2.4 判断棋盘是否满了
      • 2.2.5 判断输赢的状态
      • 三、游戏的优化
        • 3.1 优化电脑下棋判断
          • 3.1.1 判断连续情况的函数
          • 3.1.2 电脑下棋的优化
          • 下棋优化后的效果:
          • 3.2 优化屏幕显示效果
            • 3.2.1 延迟打印优化
            • 3.2.2 清屏优化显示
            • 优化前
            • 优化后
            • 四、最终效果演示
            • 五、源码
              • game.h
              • game.c
              • test.c
              • 完结

                前言

                提示:本篇文章为C语言版的三子棋小游戏的制作,内含超详细讲解和完整源码,以及视频演示,内容如若有误,请联系小明及时更正。

                • 转载请注明原创,谢谢。

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  提示:以下是本篇文章正文内容:

                  超前点播:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  想知道这样的三子棋是怎么做出来的嘛,往下看吧

                  一、三子棋的实现思路

                     三子棋游戏,也称为井字游戏,是一种两人对战的棋类游戏。

                    玩家轮流在棋盘上划线,目标是在横、竖或斜方向上连成三个自己的棋子,从而获胜。

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  实现的思路:

                    在开始编写代码之前,我们需要先规划好游戏整体的思路和实现步骤。这样做可以避免我们在编程过程中走弯路,减少出现错误和问题的概率,所以,让我们先来想一想大致的实现思路:


                  1️⃣ 游戏菜单

                    既然是下三子棋,我们在游戏菜单选择开始游戏后,肯定要先打印棋盘。

                  2️⃣ 打印棋盘

                    棋盘打印之后我们开始下棋,但是下棋又分为玩家(我们)下棋和电脑下棋两个棋手。

                  3️⃣ 玩家下棋

                    我们玩家下棋自然是输入我们想下位置的坐标即可落子。

                  4️⃣电脑下棋

                    电脑下棋我们先弄成随机下棋的形式。

                  5️⃣ 判断胜负

                    我们下棋判断胜负自然是每落子一次就得判断一次输赢,若有结果则停止下棋,然后显示输赢情况。

                  6️⃣ 是否继续

                    我们在下完一局的时候可以再提示一下,是否继续游戏,可以重复玩。

                  7️⃣ 优化

                    电脑随机下棋难免有些死板,我们可以试着优化电脑下棋的思路来优化我们的游戏体验。


                  二、三子棋的实现步骤

                  2.1 先显示游戏的菜单

                    按我们刚才的第一点,先准备一个游戏的菜单让我们选择是否开始游戏:

                  #define _CRT_SECURE_NO_WARNINGS 1
                  #include
                  void menu() 
                  {
                  	printf("***********************\n");
                  	printf("******  1.play  *******\n");
                  	printf("******  0.exit  *******\n");
                  	printf("***********************\n");
                  }
                  int main()
                  {
                  	int input = 0;
                  	menu();
                  	printf("请选择:");
                  	scanf("%d", &input);
                  	
                  	return 0;
                  }
                  

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    当然了,游戏玩完了一局后想要继续玩,我们就可以用循环来实现多次游戏,但是该用哪种循环呢?

                  说到该用哪种循环,我们就该想哪种更适合:

                  1. for循环在循环开始之前就已经知道循环的次数。

                  2. while循环在循环开始之前不知道循环的次数,它会在每次循环结束时检查循环条件。

                  3. do-while循环和while循环类似,但有一个主要区别:do-while循环会先执行一次循环体,然后再检查循环条件。

                    因为我们不知道需要玩几局,我们可能想玩十几局,也可能赢几局后就不玩了,所以for循环肯定不合适,而游戏一开始就需要我们就需要先选择一下菜单,然后进行游戏,按这个逻辑来讲,do-while循环是更为合适的。

                    所以,让我们在原基础上在加一个do-while循环:

                  #define _CRT_SECURE_NO_WARNINGS 1
                  #include
                  void menu() 
                  {
                  	printf("***********************\n");
                  	printf("******  1.play  *******\n");
                  	printf("******  0.exit  *******\n");
                  	printf("***********************\n");
                  }
                  int main()
                  {
                  	int input = 0;
                  	do
                  	{
                  		menu();
                  		printf("请选择:");
                  		scanf("%d", &input);
                  	} while(input);
                  	return 0;
                  }
                  

                  添加do-while循环后的菜单效果:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  用do…while循环后呢,我们的菜单上面说的选择1 玩游戏,0 退出,但是我们上面显示输入2、3等数字也可以进入菜单。我们就需要用选择结构中的switch语句来处理多余数字的输入:

                  #define _CRT_SECURE_NO_WARNINGS 1
                  #include
                  void menu()
                  {
                  	printf("***********************\n");
                  	printf("******  1.play  *******\n");
                  	printf("******  0.exit  *******\n");
                  	printf("***********************\n");
                  }
                  int main()
                  {
                  	int input = 0;
                  	do
                  	{
                  		menu();
                  		printf("请选择:");
                  		scanf("%d", &input);
                  		switch (input)
                  		{
                  		case 1:
                  			printf("玩游戏!\n");
                  			break;
                  		case 0:
                  			printf("退出游戏!\n");
                  			break;
                  		default:
                  			printf("输入错误,请重新输入!!!\n");
                  			break;
                  		}
                  	} while (input);
                  	return 0;
                  }
                  

                  添加选择后的效果:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  最后,我们将 case 1 选项改为一个game()函数来进入游戏即可完成初步框架的制作。

                  2.2 游戏的具体实现

                  2.2.1 棋盘的初始化

                    有了初步的框架,我们就可以开始对棋盘进行初始化,三子棋的棋盘是一个 3×3 (即三行三列)的二维数组。

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  我们写一个循环打印一下:

                  void InitBoard(char board[3][3], int r, int c)
                  {
                  	for (int i = 0; i  
                  

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    我们可以看到三行三列的棋盘已经做好了,但这里的行和列已经被我们写死了!如果后期如果想整改变行和列,需要修改的地方就太多了!所以我们可以写一个 game.c 的文件来存放 实现游戏的相关代码,再写一个 game.h 的文件来存放 游戏所有头文件和函数的声明,用 #define 定义的自符常量来解决这个问题,效果如图:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    然后将实现棋盘打印的代码移动到 game.c 中,在此需要注意的是:一般引用库里面的头文件我们用 如:#include,而引用自己的头文件时用" "引用我们自己的头文件。

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  2.2.2 展示棋盘

                    做完刚才的文件后,我们就该对棋盘进行展示了,我们刚才创建的棋盘只有九宫格的样式,并没有 “ 井 ” 字的棋盘,所以我们需要制作 “ 井 ” 字的线条:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    要实现这个 “ 井 ” 字的线条,就不能像刚才一样直接打印内容,需要打印行和列的线条,我们可以分成这么几个部分实现:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  如上所示,我们可以分开打印:

                   | |   第一行

                  —|—|—  第二行

                   | |   第三行

                  —|—|—  第四行

                   | |   第五行

                  在此基础上可以两行为一组打印:

                   | |   

                  —|—|—  前两组为第一行

                   | |   

                  —|—|—  中间两组为第二行

                   | |   最后一排为第三行

                  void DisplayBoard(char board[ROW][COL], int row, int col)
                  {
                  	int i = 0;
                  	int j = 0;
                  	for (i = 0; i  
                  

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    如上图所示,我们成功的实现了棋盘的打印,但是最后多了一行 “ - - - | - - - | - - - ”,我们可以用 if 语句来判断行数,如果是最后一行则不打印 “ - - - | - - - | - - - ”

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  2.2.3 下棋

                  有了棋盘,我们就可以进行棋盘落子的操作了

                  🔴玩家下棋

                  首先,在 game.h 头文件中声明玩家下棋函数:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    然后在 game.c 文件中实现玩家下棋的代码,我们的玩家不一定都是程序员,所以对于落子坐标来讲,肯定不会按二维数组下标来下棋,所以我们需要将玩家输入的横坐标 x x x 和纵坐标 y y y 减一:

                  void PlayerMove(char board[ROW][COL], int row, int col)
                  {
                  	int x = 0;
                  	int y = 0;
                  	printf("玩家下棋\n");
                  	printf("请输入下棋坐标:");
                  	scanf("%d %d", &x, &y);
                  	if (x = 1 && y = 1)
                  	{
                  		board[x - 1][y - 1] = 'o';
                  	}
                  }
                  

                    此处所下的棋子不能超出棋盘,否则坐标非法重新下;并且下的棋子必须在空格子中,否则坐标备占有重新下,然后在加一个 while 循环可以实现玩家下错棋子之后,还能重新下,直到下正确退出循环:

                  void PlayerMove(char board[ROW][COL], int row, int col)
                  {
                  	int x = 0;
                  	int y = 0;
                  	printf("玩家下棋\n");
                  	
                  	while (1)
                  	{
                  		printf("请输入下棋坐标:");
                  		scanf("%d %d", &x, &y);
                  		if (x = 1 && y = 1)
                  		{
                  			if (board[x - 1][y - 1] == ' ')//为空可以落子
                  			{   //[x-1][y-1]可以让输入的数字变为数组下标
                  				board[x - 1][y - 1] = 'o';
                  				break;
                  			}
                  			else
                  			{
                  				printf("该坐标已占用,请重新输入\n");
                  			}
                  		}
                  		else
                  		{
                  			printf("坐标非法,请重新输入\n");
                  		}
                  	}
                  }
                  

                    当我们在 game.c 中的写完玩家下棋的代码后,需要在 test.c 文件中的game()函数里调用一下:

                  void game()
                  {
                  	//创建棋盘
                  	char board[ROW][COL] = { 0 };
                  	//初始化棋盘
                  	InitBoard(board, ROW, COL);
                  	//打印棋盘
                  	DisplayBoard(board, ROW, COL);
                  	while (1)
                  	{
                  		PlayerMove(board, ROW, COL);//玩家下棋
                  		DisplayBoard(board, ROW, COL);//打印棋盘
                  	}
                  }
                  

                  效果如下面的动图:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  至此,玩家下棋的代码已基本完成。

                  🔴电脑下棋

                    有了玩家下棋的基础,电脑下棋的大致框架也同玩家下棋的代码一致,我们先在 game.h 头文件中写一个电脑玩家下棋:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    玩家下棋时需要修改落子的横纵坐标来符合二维数组,但电脑下棋则不需要修改,我们让电脑随机生成下标即可:

                  //电脑随机下棋
                  void ComputerMove(char board[ROW][COL], int row, int col)
                  {
                  	printf("电脑下棋\n");
                  	int x = 0;
                  	int y = 0;
                  	while (1)
                  	{
                  		x = rand() % row;
                  		y = rand() % col;
                  		if (board[x][y] == ' ')
                  		{
                  			board[x][y] = 'x';
                  			break;
                  		}
                  	}
                  }
                  

                  上面代码因为row和col的值为3,所以 x = rand() % row;和 y = rand() % col;的值一定会在 0~2 之间。

                  rand()会返回一个范围在 0 到RAND_MAX(32767) 之间的伪随机数(整数)。

                  srand种子可使用传入时间戳的方式来确定入口。如:

                  srand((unsigned int)time(NULL));
                  

                  我们可以把个代码写在main()函数里

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  效果显示:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  至此,玩家下棋的代码已基本完成。

                  2.2.4 判断棋盘是否满了

                    在写完双方的落子的代码后,我们可以浅试一手:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    虽然我们还没写判断输赢的代码,但是已经有 Bug 出现了:在棋盘满了之后代码死循环了······

                    兵来将挡,水来土掩。有了问题咱们就解决问题,我们写一个函数来判断棋盘是否有空位置:

                  //判断棋盘是否满了
                  int IsFull(char board[ROW][COL], int row, int col)
                  {
                  	int i = 0;
                  	int j = 0;
                  	for (i = 0; i  
                   
                   

                  有空位置返回 0,无空位置返回 1。当棋盘满时没有输赢时则判平局。

                  2.2.5 判断输赢的状态

                    既然有了平局的出现,我们也就该写输赢判断的代码了,棋盘满了还没有三子连成一条线时为平局 ,但是如果在棋盘满之前有三子成线则是某一方赢了。

                    写一个 IsWin() 函数来判断输赢,在写之前我们可以想一下,如何来判断输赢,都会有哪些情况:

                    1. 玩家赢

                    2. 电脑赢

                    3. 平局

                    4. 游戏继续

                  所以先将 test.c 中的 game() 函数添加判断平局的代码:

                  void game()
                  {
                  	char ret = 0;
                  	//创建棋盘
                  	char board[ROW][COL] = { 0 };
                  	//初始化棋盘
                  	InitBoard(board, ROW, COL);
                  	//打印棋盘
                  	DisplayBoard(board, ROW, COL);
                  	while (1)
                  	{
                  		PlayerMove(board, ROW, COL);//玩家下棋
                  		DisplayBoard(board, ROW, COL);//打印棋盘
                  		//判断输赢
                  		ret = IsWin(board, ROW, COL);
                  		if (ret != 'j')
                  		{
                  			break;
                  		}
                  	
                  		ComputerMove(board, ROW, COL);//电脑下棋
                  		DisplayBoard(board, ROW, COL);//打印棋盘
                  		//判断输赢
                  		ret = IsWin(board, ROW, COL);
                  		if (ret != 'j')
                  		{
                  			break;
                  		}
                  	}
                  }
                  

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    平局的代码写完了,就该写判断玩家赢,还是电脑赢的代码了。

                  void game()
                  {
                  	char ret = 0;
                  	//创建棋盘
                  	char board[ROW][COL] = { 0 };
                  	//初始化棋盘
                  	InitBoard(board, ROW, COL);
                  	//打印棋盘
                  	DisplayBoard(board, ROW, COL);
                  	while (1)
                  	{
                  		PlayerMove(board, ROW, COL);//玩家下棋
                  		DisplayBoard(board, ROW, COL);//打印棋盘
                  		//判断输赢
                  		ret = IsWin(board, ROW, COL);
                  		if (ret != 'j')
                  		{
                  			break;
                  		}
                  	
                  		ComputerMove(board, ROW, COL);//电脑下棋
                  		DisplayBoard(board, ROW, COL);//打印棋盘
                  		//判断输赢
                  		ret = IsWin(board, ROW, COL);
                  		if (ret != 'j')
                  		{
                  			break;
                  		}
                  	}
                  	if (ret == 'o') //玩家棋子为 o
                  	{
                  		printf("玩家赢\n");
                  	}
                  	else if (ret == 'x') //电脑棋子为 x
                  	{
                  		printf("电脑赢\n");
                  	}
                  	else
                  	{
                  		printf("平局\n");
                  	}
                  }
                  

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  至此,game()函数中的判断输赢代码已经写完,我们该在 game.c 文件中实现判断输赢的代码了:

                  首先还是老样子,现在game.h 的头文件里先声明一下:

                  char IsWin(char board[ROW][COL], int row, int col);
                  

                  头文件中的效果为:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  🔴行判断

                    i 从 0 开始,到

                  char IsWin(char board[ROW][COL], int row, int col)
                  {
                  	//行判断
                  	int i = 0;
                  	for (i = 0; i  
                  

                  🔴列判断

                    列的判断和行的判断一样,只不过将数组访问下标的行和列互换:

                  //列判断
                  for (i = 0; i  
                  

                  🔴对角线判断

                    左对角线和右对角线的判断:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  //对角线判断
                  if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
                  {
                  	return board[1][1];
                  }
                  if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
                  {
                  	return board[1][1];
                  }
                  

                  🔴棋盘满了,但没有人赢,输出平局

                  //没有人赢,输出平局
                  if (IsFull(board, row, col) == 1)
                  {
                  	return 'p';
                  }
                  

                  至此,判断输赢的 IsWin() 函数就写完了:

                  //玩家赢-----w
                  //电脑赢-----d
                  //平局-------p    满了返回1,不满返回0
                  //游戏继续---j
                  char IsWin(char board[ROW][COL], int row, int col)
                  {
                  	//行判断
                  	int i = 0;
                  	for (i = 0; i  
                  

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码


                  三、游戏的优化

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    这是我们制作的三子棋游戏,但是由于电脑落子是随机的,这就导致电脑有时回下一些没用的位置,让我们的游戏体验大幅度下降,那么我们该如何优化呢?

                  3.1 优化电脑下棋判断

                  3.1.1 判断连续情况的函数

                    如果是两个真人下棋,会是怎样的场景?肯定是看到有两个棋子成一条线时就要去 堵住第三个位置防止落子!

                    所以我们需要写一个寻找是否有连续情况的函数 find() 来判断是否有两个棋子连在一起, 并且第三子的位置是空的 :

                  //判断连续情况
                  int find(char board[ROW][COL], int row, int col)
                  {
                  	int i = 0;
                  	//行判断
                  	for (i = 0; i  
                  

                  3.1.2 电脑下棋的优化

                    我们优化完拦截玩家下棋的代码后,还需要在电脑下棋的代码里优化一个重要的步骤:那就是 抢占中心点!!!中心点是一个极有利的位置,在玩家下完棋后如果中心点还是空的,则可以让电脑抢占一下中心点,提高胜率。

                  //电脑随机下棋
                  void ComputerMove(char board[ROW][COL], int row, int col)
                  {
                  	printf("电脑下棋\n");
                  	int x = 0;
                  	int y = 0;
                  	//判断中间,抢中心点
                  	if (board[1][1] == ' ')
                  	{
                  		board[1][1] = 'x';
                  	}
                  	else if (find(board, row, col)) //判断是否复合拦截条件,复合进行拦截。
                  	{
                  		;
                  	}
                  	else
                  	{
                  		while (1)
                  		{
                  			x = rand() % row;
                  			y = rand() % col;
                  			if (board[x][y] == ' ')
                  			{
                  				board[x][y] = 'x';
                  				break;
                  			}
                  		}
                  	}
                  }
                  

                  下棋优化后的效果:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                    做到这里已经将整个三子棋游戏优化的非常智能了,但是对于追求完美的我们来讲显示效果还差那么一丢丢。

                  3.2 优化屏幕显示效果

                  3.2.1 延迟打印优化

                    现如今可以看到的是,电脑下棋很快,没有那种对弈时思考的感觉,这时我们可以写一个延迟打印的函数:delay() ,用

                  //延迟打印
                  void delay(int milliseconds)
                  {
                  	int i, j;
                  	for (i = 0; i  
                  

                    这个函数接受一个整数参数milliseconds,表示延迟的毫秒数。函数内部有两个嵌套的for循环,通过循环来消耗时间,从而实现延迟打印的效果。

                    然后我们将这个函数写在电脑下棋后棋盘打印之前:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  还可以写在判断输赢之前,显得机器在判断双方输赢时也在思考

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  我们加了延迟打印后的效果为:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  3.2.2 清屏优化显示

                    由上面的效果可以看出,我们的效果已然极佳。但但但是!我们可以明显的看到所有棋盘都堆积到了一起,显得很乱很杂,我们可以在打印完一个棋盘后清理一次屏幕,使得屏幕看起来更舒适。

                  C语言中,system函数可以用于调用一些DOS命令,比如system(“pause”)可以卡主系统控制台,而另一个常用的system(“cls”)为清屏命令,等于在DOS上使用cls命令。

                  而我们这里用到的就是清屏代码: system(“cls”) ;

                  首先我们在我们下棋之后加上清屏代码清除掉游戏菜单,使得屏幕上只有棋盘,然后在电脑下棋后再加一段清屏代码,省的玩家下棋后的棋盘和电脑下棋后的棋盘重叠:

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  优化前

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

                  优化后

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码


                  四、最终效果演示

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码


                  五、源码

                  已经看到这里的朋友点个关注来波三连支持一下小明好嘛 QAQ

                  game.h

                  #define _CRT_SECURE_NO_WARNINGS 1
                  #include
                  #include
                  #include
                  #define ROW 3 //用define定义的二维数组大小
                  #define COL 3 //在此处可以更方便的修改棋盘的大小
                  //棋盘初始化
                  void InitBoard(char board[ROW][COL], int row, int col);
                  //棋盘打印
                  void DisplayBoard(char board[ROW][COL], int row, int col);
                  //玩家下棋
                  void PlayerMove(char board[ROW][COL], int row, int col);
                  //电脑下棋
                  void ComputerMove(char board[ROW][COL], int row, int col);
                  //判断输赢
                  char IsWin(char board[ROW][COL], int row, int col);
                  

                  game.c

                  #define _CRT_SECURE_NO_WARNINGS 1
                  #include "game.h"
                  void InitBoard(char board[3][3], int row, int col)
                  {
                  	for (int i = 0; i  
                  

                  test.c

                  #define _CRT_SECURE_NO_WARNINGS 1
                  #include "game.c"
                  void menu()
                  {
                  	printf("***********************\n");
                  	printf("******  1.play  *******\n");
                  	printf("******  0.exit  *******\n");
                  	printf("***********************\n");
                  }
                  void game()
                  {
                  	char ret = 0;
                  	//创建棋盘
                  	char board[ROW][COL] = { 0 };
                  	//初始化棋盘
                  	InitBoard(board, ROW, COL);
                  	//打印棋盘
                  	DisplayBoard(board, ROW, COL);
                  	while (1)
                  	{
                  		PlayerMove(board, ROW, COL);//玩家下棋
                  		system("cls");//清屏
                  		DisplayBoard(board, ROW, COL);//打印棋盘
                  		//判断输赢
                  		ret = IsWin(board, ROW, COL);
                  		if (ret != 'j')
                  		{
                  			break;
                  		}
                  	
                  		ComputerMove(board, ROW, COL);//电脑下棋
                  		delay(300000);
                  		system("cls");//清屏
                  		DisplayBoard(board, ROW, COL);//打印棋盘
                  		//判断输赢
                  		ret = IsWin(board, ROW, COL);
                  		if (ret != 'j')
                  		{
                  			break;
                  		}
                  	}
                  	if (ret == 'o') //玩家棋子为 o
                  	{
                  		delay(300000);
                  		printf("玩家赢\n");
                  	}
                  	else if (ret == 'x') //电脑棋子为 x
                  	{
                  		delay(300000);
                  		printf("电脑赢\n");
                  	}
                  	else
                  	{
                  		delay(300000);
                  		printf("平局\n");
                  	}
                  }
                  int main()
                  {
                  	int input = 0;
                  	srand((unsigned int)time(NULL));
                  	do
                  	{
                  		menu();
                  		printf("请选择:");
                  		scanf("%d", &input);
                  		switch (input)
                  		{
                  		case 1:
                  			system("cls");//清屏
                  			game();
                  			delay(500000);
                  			system("cls");//清屏
                  			break;
                  		case 0:
                  			printf("退出游戏!\n");
                  			break;
                  		default:
                  			printf("输入错误,请重新输入!!!\n");
                  			break;
                  		}
                  	} while (input);
                  	return 0;
                  }
                  

                  完结

                  好啦,阅读到这里就已经看完了本期博客的全部内容了

                  三子棋游戏【C语言优化版】---- 超级详细 + 动态演示 + 完整源码

VPS购买请点击我

文章版权声明:除非注明,否则均为主机测评原创文章,转载或复制请以超链接形式并注明出处。

目录[+]