三子棋游戏----C语言版【超级详细 + 视频演示 + 完整源码】


㊙️小明博客主页:➡️ 敲键盘的小明 ㊙️
✅关注小明了解更多知识☝️


文章目录

  • 前言
  • 一、三子棋的实现思路
  • 二、三子棋的实现步骤
    • 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语言版的三子棋小游戏的制作,内含超详细讲解和完整源码,以及视频演示,内容如若有误,请联系小明及时更正。

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

在这里插入图片描述

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

一、三子棋的实现思路

   三子棋游戏,也称为井字游戏,是一种两人对战的棋类游戏。
  玩家轮流在棋盘上划线,目标是在斜方向上连成三个自己的棋子,从而获胜。
在这里插入图片描述


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

1️⃣ 游戏菜单
  既然是下三子棋,我们在游戏菜单选择开始游戏后,肯定要先打印棋盘。
2️⃣ 打印棋盘
  棋盘打印之后我们开始下棋,但是下棋又分为玩家(我们)下棋和电脑下棋两个棋手。
3️⃣ 玩家下棋
  我们玩家下棋自然是输入我们想下位置的坐标即可落子。
4️⃣电脑下棋
  电脑下棋我们先弄成随机下棋的形式。
5️⃣ 判断胜负
  我们下棋判断胜负自然是每落子一次就得判断一次输赢,若有结果则停止下棋,然后显示输赢情况。
6️⃣ 是否继续
  我们在下完一局的时候可以再提示一下,是否继续游戏,可以重复玩。
7️⃣ 优化
  电脑随机下棋难免有些死板,我们可以试着优化电脑下棋的思路来优化我们的游戏体验。

超前点播:
在这里插入图片描述
想知道这样的三子棋是怎么做出来的嘛,往下看吧


二、三子棋的实现步骤

2.1 先显示游戏的菜单

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

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;
}

在这里插入图片描述

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

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

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

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

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

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循环后的菜单效果:

在这里插入图片描述

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

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;
}

添加选择后的效果:
在这里插入图片描述

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

2.2 游戏的具体实现

2.2.1 棋盘的初始化

  有了初步的框架,我们就可以开始对棋盘进行初始化,三子棋的棋盘是一个 3×3 (即三行三列)的二维数组。
在这里插入图片描述
我们写一个循环打印一下:

void InitBoard(char board[3][3], int r, int c)
{
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			board[i][j] = '6';
		}
	}
}

void DisplayBoard(char board[3][3], int r, int c)
{
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			printf(" %c ", board[i][j]);
		}
		printf("\n");
	}
}

void game()
{
	//创建棋盘
	char board[3][3] = { 0 };
	//初始化棋盘
	InitBoard(board, 3, 3);
	//打印棋盘
	DisplayBoard(board, 3, 3);
}

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

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

2.2.2 展示棋盘

  做完刚才的文件后,我们就该对棋盘进行展示了,我们刚才创建的棋盘只有九宫格的样式,并没有 “ 井 ” 字的棋盘,所以我们需要制作 “ 井 ” 字的线条:
在这里插入图片描述
  要实现这个 “ 井 ” 字的线条,就不能像刚才一样直接打印内容,需要打印行和列的线条,我们可以分成这么几个部分实现:
在这里插入图片描述
如上所示,我们可以分开打印:

 | |   第一行
—|—|—  第二行
 | |   第三行
—|—|—  第四行
 | |   第五行

在此基础上可以两行为一组打印:
 | |   
—|—|—  前两组为第一行

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

 | |   最后一排为第三行

void DisplayBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		//先打印数据
		printf(" %c | %c | %c \n",board[i][0],board[i][1],board[i][2]);

		//再打印分隔行
		printf("---|---|---\n");
	}
}

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

在这里插入图片描述

2.2.3 下棋

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

🔴玩家下棋

首先,在 game.h 头文件中声明玩家下棋函数:
在这里插入图片描述
  然后在 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 <= row && x >= 1 && y <= col && 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 <= row && x >= 1 && y <= col && 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);//打印棋盘
	}
}

效果如下面的动图:
在这里插入图片描述
至此,玩家下棋的代码已基本完成。


🔴电脑下棋

  有了玩家下棋的基础,电脑下棋的大致框架也同玩家下棋的代码一致,我们先在 game.h 头文件中写一个电脑玩家下棋:
在这里插入图片描述
  玩家下棋时需要修改落子的横纵坐标来符合二维数组,但电脑下棋则不需要修改,我们让电脑随机生成下标即可:

//电脑随机下棋
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()函数里
在这里插入图片描述

效果显示:
在这里插入图片描述

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


2.2.4 判断棋盘是否满了

  在写完双方的落子的代码后,我们可以浅试一手:
在这里插入图片描述

  虽然我们还没写判断输赢的代码,但是已经有 Bug 出现了:在棋盘满了之后代码死循环了······
  兵来将挡,水来土掩。有了问题咱们就解决问题,我们写一个函数来判断棋盘是否有空位置:

//判断棋盘是否满了
int IsFull(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
			{
				return 0;//有位置返回 0
			}
		}
	}
	return 1;//棋盘满了返回 1
}

有空位置返回 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;
		}
	}
}

在这里插入图片描述

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

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");
	}
}

在这里插入图片描述

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

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

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

头文件中的效果为:
在这里插入图片描述

🔴行判断

  i 从 0 开始,到 < row(小于3,即0~2下标)时结束,如果三行中的三个元素都一样,则连成一条线,返回三个元素中的一个即可,并且三元素相同时不是三个空值的相等:

char IsWin(char board[ROW][COL], int row, int col)
{
	//行判断
	int i = 0;
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
		{
			return board[i][0]; //三个都相等的话,然后其中一个即可
		}
	}
}

🔴列判断

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

//列判断
for (i = 0; i < col; i++)
{
	if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
	{
		return board[1][i];
	}
}

🔴对角线判断

  左对角线和右对角线的判断:
在这里插入图片描述

//对角线判断
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 < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
		{
			return board[i][0]; //三个都相等的话,然后其中一个即可
		}
	}
	//列判断
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
		{
			return board[1][i];
		}
	}
	//对角线判断
	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';
	}

	//游戏继续
	return 'j';
}

在这里插入图片描述


三、游戏的优化

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

3.1 优化电脑下棋判断

3.1.1 判断连续情况的函数

  如果是两个真人下棋,会是怎样的场景?肯定是看到有两个棋子成一条线时就要去 堵住第三个位置防止落子!
  所以我们需要写一个寻找是否有连续情况的函数 find() 来判断是否有两个棋子连在一起, 并且第三子的位置是空的

//判断连续情况
int find(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//行判断
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][2] == ' ' && board[i][0] != ' ')
		{
			board[i][2] = 'x';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][1] == ' ' && board[i][0] != ' ')
		{
			board[i][1] = 'x';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][0] == ' ' && board[i][1] != ' ')
		{
			board[i][0] = 'x';
			return 1;
		}
	}
	//列判断
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[2][i] == ' ' && board[0][i] != ' ')
		{
			board[2][i] = 'x';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[1][i] == ' ' && board[0][i] != ' ')
		{
			board[1][i] = 'x';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[0][i] == ' ' && board[1][i] != ' ')
		{
			board[0][i] = 'x';
			return 1;
		}
	}
	//对角线判断
	if (board[1][1] == board[0][0] && board[2][2] == ' ' && board[1][1] != ' ')
	{
		board[2][2] = 'x';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[1][1] == ' ' && board[0][0] != ' ')
	{
		board[1][1] = 'x';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[0][0] == ' ' && board[1][1] != ' ')
	{
		board[0][0] = 'x';
		return 1;
	}
	//斜对角线判断
	if (board[0][2] == board[1][1] && board[2][0] == ' ' && board[0][2] != ' ')
	{
		board[2][0] = 'x';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[0][2] == ' ' && board[1][1] != ' ')
	{
		board[0][2] = 'x';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[1][1] == ' ' && board[0][2] != ' ')
	{
		board[1][1] = 'x';
		return 1;
	}
	return 0;
}

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;
			}
		}
	}
}

下棋优化后的效果:

在这里插入图片描述

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

3.2 优化屏幕显示效果

3.2.1 延迟打印优化

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

//延迟打印
void delay(int milliseconds)
{
	int i, j;
	for (i = 0; i < milliseconds; i++)
	{
		for (j = 0; j < 10000; j++)
		{
			// 空循环,用于消耗一定的时间
		}
	}
}

  这个函数接受一个整数参数milliseconds,表示延迟的毫秒数。函数内部有两个嵌套的for循环,通过循环来消耗时间,从而实现延迟打印的效果。
  然后我们将这个函数写在电脑下棋后棋盘打印之前:

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

3.2.2 清屏优化显示

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

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

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

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

在这里插入图片描述

优化前

在这里插入图片描述

优化后

在这里插入图片描述


四、最终效果演示

在这里插入图片描述


五、源码


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

game.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<time.h>
#include<stdlib.h>

#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 < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}

//void DisplayBoard(char board[3][3], int r, int c)
//{
//	for (int i = 0; i < r; i++)
//	{
//		for (int j = 0; j < c; j++)
//		{
//			printf(" %c ", board[i][j]);
//		}
//		printf("\n");
//	}
//}

void DisplayBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		//先打印数据
		printf(" %c | %c | %c \n",board[i][0],board[i][1],board[i][2]);

		//再打印分隔行
		if (i < row - 1)
		{
			printf("---|---|---\n");
		}
	}
}

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 <= row && x >= 1 && y <= col && 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");
		}
	}
}

//判断连续情况
int find(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//行判断
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][2] == ' ' && board[i][0] != ' ')
		{
			board[i][2] = 'x';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][1] == ' ' && board[i][0] != ' ')
		{
			board[i][1] = 'x';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][0] == ' ' && board[i][1] != ' ')
		{
			board[i][0] = 'x';
			return 1;
		}
	}
	//列判断
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[2][i] == ' ' && board[0][i] != ' ')
		{
			board[2][i] = 'x';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[1][i] == ' ' && board[0][i] != ' ')
		{
			board[1][i] = 'x';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[0][i] == ' ' && board[1][i] != ' ')
		{
			board[0][i] = 'x';
			return 1;
		}
	}
	//对角线判断
	if (board[1][1] == board[0][0] && board[2][2] == ' ' && board[1][1] != ' ')
	{
		board[2][2] = 'x';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[1][1] == ' ' && board[0][0] != ' ')
	{
		board[1][1] = 'x';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[0][0] == ' ' && board[1][1] != ' ')
	{
		board[0][0] = 'x';
		return 1;
	}
	//斜对角线判断
	if (board[0][2] == board[1][1] && board[2][0] == ' ' && board[0][2] != ' ')
	{
		board[2][0] = 'x';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[0][2] == ' ' && board[1][1] != ' ')
	{
		board[0][2] = 'x';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[1][1] == ' ' && board[0][2] != ' ')
	{
		board[1][1] = 'x';
		return 1;
	}
	return 0;
}

//电脑随机下棋
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;
			}
		}
	}
}

//判断棋盘是否满了
int IsFull(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
			{
				return 0;//有位置返回 0
			}
		}
	}
	return 1;//棋盘满了返回 1
}

//玩家赢-----w
//电脑赢-----d
//平局-------p    满了返回1,不满返回0
//游戏继续---j
char IsWin(char board[ROW][COL], int row, int col)
{
	//行判断
	int i = 0;
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
		{
			return board[i][0]; //三个都相等的话,然后其中一个即可
		}
	}
	//列判断
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
		{
			return board[1][i];
		}
	}
	//对角线判断
	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';
	}

	//游戏继续
	return 'j';
}

//延迟打印
void delay(int milliseconds)
{
	int i, j;
	for (i = 0; i < milliseconds; i++)
	{
		for (j = 0; j < 10000; j++)
		{
			// 空循环,用于消耗一定的时间
		}
	}
}

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;
}

完结

好啦,阅读到这里就已经看完了本期博客的全部内容了
在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/520762.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

二叉树进阶——手撕二叉搜索树

troop主页&#xff1a;troop 手撕二叉搜索树 1.二叉搜索树的定义2.实现&#xff08;非递归&#xff09;补充结构2.1查找2.2插入2.3删除&#xff08;重要&#xff09;情况1(无孩子&&一个孩子&#xff09; 3.二叉搜索树的应用3.1K模型3.2KV模型3.2.1KV模型的实现 总结二叉…

RUST语言值所有权之内存复制与移动

1.RUST中每个值都有一个所有者,每次只能有一个所有者 String::from函数会为字符串hello分配一块内存 内存示例如下: 在内存分配前调用s1正常输出 在分配s1给s2后调用报错 因为s1分配给s2后,s1的指向自动失效 s1被move到s2 s1自动释放 字符串克隆使用

I2C驱动实验:读取AP3216C设备中寄存器的数据

一. 简介 经过前面几篇文章的学习&#xff0c;已经完成了I2C驱动框架&#xff0c;字符设备驱动框架&#xff0c;编写了 读写 I2C设备中寄存器的数据的代码&#xff0c;文章如下&#xff1a; I2C驱动实验&#xff1a;实现读/写I2C设备寄存器的函数-CSDN博客 本文在此基础上&a…

C#开发中一些常用的工具类分享

一、配置文件读写类 用于在开发时候C#操作配置文件读写信息 1、工具类 ReadIni 代码 using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Runtime.InteropServices; using System.Text; using System.Threading.Tasks;namesp…

不同设备使用同一个Git账号

想要在公司和家里的电脑上用同一个git账号来pull, push代码 1. 查看原设备的用户名和邮箱 第1种方法&#xff0c; 依次输入 git config user.name git config user.email第2种方法&#xff0c; 输入 cat ~/.gitconfig2. 配置新设备的用户名和邮箱 用户名和邮箱与原设备保持…

高效学习方法:冥想背诵,看一句念一句,再每个词分析位置及语法等合理性,忘记哪个词再看猜下为什么会忘,跟自己的表达哪里不一样。

原则&#xff1a;易学则易行&#xff0c;则效果最好。《易经》 你提到的这种学习方法结合了多种记忆和理解技巧&#xff0c;可以帮助提高学习效率。下面是对这种方法的一个详细解释和一些建议&#xff1a; 冥想背诵&#xff1a;通过冥想来集中注意力&#xff0c;可以帮助你在没…

数据如何才能供得出、流得动、用得好、还安全

众所周知&#xff0c;数据要素已经列入基本生产要素&#xff0c;同时成立国家数据局进行工作统筹。目前数据要素如何发挥其价值&#xff0c;全国掀起了一浪一浪的热潮。 随着国外大语言模型的袭来&#xff0c;国内在大语言模型领域的应用也大放异彩&#xff0c;与此同时&#x…

使用YOLOv8训练自己的【目标检测】数据集

文章目录 1.收集数据集1.1 使用开源已标记数据集1.2 爬取网络图像1.3 自己拍摄数据集1.4 使用数据增强生成数据集1.5 使用算法合成图像 2.标注数据集2.1确认标注格式2.2 开始标注 3.划分数据集4.配置训练环境4.1获取代码4.2安装环境 5.训练模型5.1新建一个数据集yaml文件5.2预测…

java中的正则表达式和异常

正则表达式&#xff1a; 作用一&#xff1a;用来校验数据格式是否合法 作用二&#xff1a;在文本中查找满足要求的内容 不用正则表达式&#xff1a;检验QQ号是否合法&#xff0c;要求全部是数字&#xff0c;长度在6-20&#xff0c;不能以0开头 public class test {public stat…

手机扫码查看视频如何实现?扫描二维码在线看视频的制作技巧

现在的学校或者幼儿园会需要拍摄学生的视频&#xff0c;然后展示给其他人查看&#xff0c;为了能够方便用户能够快速的获取文件内容&#xff0c;所以经常会通过生成视频二维码的方法&#xff0c;将二维码分享之后手机扫码来获取视频内容&#xff0c;有效提升用户获取内容的体验…

PTA C 1050 螺旋矩阵(思路与优化)

本题要求将给定的 N 个正整数按非递增的顺序&#xff0c;填入“螺旋矩阵”。所谓“螺旋矩阵”&#xff0c;是指从左上角第 1 个格子开始&#xff0c;按顺时针螺旋方向填充。要求矩阵的规模为 m 行 n 列&#xff0c;满足条件&#xff1a;mn 等于 N&#xff1b;m≥n&#xff1b;且…

160.相交链表

题目描述 解题思路 ————看评论区大神的思路———— 设「第一个公共节点」为 node &#xff0c;「链表 headA」的节点数量为 aaa &#xff0c;「链表 headB」的节点数量为 bbb &#xff0c;「两链表的公共尾部」的节点数量为 ccc &#xff0c;则有&#xff1a; 头节点 …

CSS设置字体样式

目录 前言&#xff1a; 1.font-family&#xff1a; 2.font-style&#xff1a; 3.font-weight&#xff1a; 4.font-size&#xff1a; 5.font-variant&#xff1a; 6.font&#xff1a; 前言&#xff1a; 在网页中字体是重要的组成部分&#xff0c;使用好字体可以让网页更…

第一次在msf控制台中运行search命令提示Module database cache not built yet问题解决

0x00 问题描述 在新装的kali虚拟机中使用msfconsole执行search命令时提示Module database cache not built yet问题&#xff0c;显然&#xff0c;是我们相关的数据库缓存存在问题。 故障现象&#xff1a; 0x01 启动数据库服务 msf中的search功能是基于postgresql来实现的&am…

python学习25:python中的元组(tuple)

python中的元组(tuple) 1.什么是元组&#xff1f; 元组也是容器数据类型的一种&#xff0c;同列表几乎是一样的&#xff0c;都是可以在里面封装多个&#xff0c;不同类型的元素在内&#xff1b;与列表最大的不同就是&#xff1a; 元组一旦被定义&#xff0c;就不能修改 2.元组…

物理层习题及其相关知识(谁看谁不迷糊呢)

1. 对于带宽为50k Hz的信道&#xff0c;若有4种不同的物理状态来表示数据&#xff0c;信噪比为20dB 。&#xff08;1&#xff09; 按奈奎斯特定理&#xff0c;信道的最大传输数据速率是多少&#xff1f;&#xff08;2&#xff09; 按香农定理&#xff0c;信道的最大传输数据速度…

Java设计模式—享元(FlyWeight)模式

享元模式&#xff08;Flyweight&#xff09;&#xff0c;运用共享技术有效地支持大量细粒度的对象 public abstract class Piece {protected PieceColor m_color;protected PiecePos m_pos;public Piece(PieceColor color ,PiecePos pos){m_color color;m_pos pos;}public ab…

Java笔试总结

. 操作系统中关于竞争和死锁的关系下面描述正确的是&#xff1f; A 竞争一定会导致死锁 B 死锁一定由竞争引起 C 竞争可能引起死锁 D 预防死锁可以防止竞争 答案: C 进程的控制信息和描述信息存放在()。 A JCB B PCB C AFT D SFT 答案: B 当系统发生抖动&#xff08;thrash…

元宇宙虚拟空间的场景的渲染(五)

前言 该文章主要讲元宇宙虚拟空间的场景的渲染&#xff0c;基本核心技术点&#xff0c;不多说&#xff0c;直接引入正题。 场景的渲染 下面第二个图中的代码是一个循环渲染逻辑&#xff0c;首先getDelta 获取2次时间的时间间隔&#xff0c;requestAnimationFrame请求我们的一…

Qt Creator 界面

&#x1f40c;博主主页&#xff1a;&#x1f40c;​倔强的大蜗牛&#x1f40c;​ &#x1f4da;专栏分类&#xff1a;QT❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 目录 一、认识 Qt Creator 界面 1、总览 2、左边栏 3、代码编辑区 4、UI设计界面 5、构建区 一、认识 …