C语言三子棋(井字棋)与电脑难度提升

已于 2024-01-16 23:14:31 修改
阅读量913 收藏 19
点赞数 15
分类专栏： 小游戏合集 文章标签： c语言 算法 开发语言 游戏
于 2024-01-16 23:11:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq3304968099/article/details/135576231
版权

C语言三子棋与电脑难度提升


大家好，这一篇博客讲的是我对 C语言三字棋 的理解。以下代码使用的是 VS2022环境下的 C语言，如果有错误，还请读者大大们指出。

开始之前准备好 game.h、game.c、test.c文件。

三子棋基础内容实现

界面代码

在game.h中：

#pragma once

#define _CRT_SECURE_NO_WARNINGS

#define ROW 3 // 方便扩展
#define COL 3

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

在test.c中：

#include "game.h"

void menu()
{
	printf("*************************\n");
	printf("**** 1.play   0.exit ****\n");
	printf("*************************\n");
}

void test()
{
	int input = 0;
	srand((unsigned int)time(NULL)); // 为后续的电脑随机下棋准备
	do
	{
		menu();
		printf("请输入:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			//game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误!\n");
		}
	} while (input);
}

int main()
{
	test();
	return 0;
}

初始化与棋盘打印代码

在game.h中：

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

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

在game.c中：

#include "game.h"

void initBoard(char board[ROW][COL], int row, int col)
{
	for (int i = 0; i < row; i++)
		for (int j = 0; j < col; j++)
			board[i][j] = ' ';
}

void display(char board[ROW][COL], int row, int col)
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1) // 打印纵分割线
				printf("|");
		}
		printf("\n");
		if (i < row - 1) // 打印横分割线
		{
			for (int j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
		}
		printf("\n");
	}
}

玩家操作与游戏框架代码

在game.h中：

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

在game.c中：

void playerMove(char board[ROW][COL], int row, int col)
{
	int y, x;
	printf("玩家下棋:>\n");
	while (1)
	{
		printf("请输入坐标:>");
		scanf("%d %d", &y, &x);
		if (x >= 1 && x <= 3 && y >= 1 && y <= 3 && board[y - 1][x - 1] == ' ') // 限定范围
		{
			board[y - 1][x - 1] = '*'; // 这里要对应数组下标
			break;
		}
		else
			printf("坐标非法或被占用,请重新输入\n");
	}
}

在test.c中：

void game()
{
	char board[ROW][COL] = { 0 };
	initBoard(board, ROW, COL);
	display(board, ROW, COL);
}

电脑操作代码

在game.h中：

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

在game.c中：

void computerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int y, x;
	while (1) // 这里使用了随机下棋
	{
		y = rand() % row;
		x = rand() % col;
		if (board[y][x] == ' ') // 是空格才下
		{
			board[y][x] = '#';
			break;
		}
	}
}

游戏输、赢、平局判定

在game.h中：

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

在game.c中：

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

char IsWin(char board[ROW][COL], int row, int col)
{// 检测行、列、对角线棋子情况
	for (int i = 0; i < row; i++) // 行
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
			return board[i][1]; // 若当行三子相同，返回其棋子

	for (int j = 0; j < col; j++) // 列
		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
			return board[1][j];// 若当列三子相同，返回其棋子

	// 对角线
	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))
		return 'Q'; // 字符Q表示棋盘满了
	return 'C'; // 字符C表示下棋正常进行
}

在test.c中：

void game()
{
	char board[ROW][COL] = { 0 };
	char ret = 0; // 接收棋盘下棋的信息
	initBoard(board, ROW, COL);
	display(board, ROW, COL);
	while (1) // 使用循环
	{
		playerMove(board, ROW, COL);
		ret = IsWin(board, ROW, COL); // 接收信息
		display(board, ROW, COL);
		if (ret != 'C') // 若不为正常情况，跳出循环
			break;
		computerMove(board, ROW, COL);
		ret = IsWin(board, ROW, COL);
		display(board, ROW, COL);
		if (ret != 'C')
			break;
	}
	if (ret == '*') // 跳出循环时判断下棋之后的情况
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else if (ret == 'Q')
		printf("平局\n");
}

整体源代码

在game.h中：

#pragma once

#define _CRT_SECURE_NO_WARNINGS

#define ROW 3 // 方便扩展
#define COL 3

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

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

void display(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中：

#include "game.h"

void initBoard(char board[ROW][COL], int row, int col)
{
	for (int i = 0; i < row; i++)
		for (int j = 0; j < col; j++)
			board[i][j] = ' ';
}

void display(char board[ROW][COL], int row, int col)
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1) // 打印纵分割线
				printf("|");
		}
		printf("\n");
		if (i < row - 1) // 打印横分割线
		{
			for (int j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
		}
		printf("\n");
	}
}

void computerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int y, x;
	while (1) // 这里使用了随机下棋
	{
		y = rand() % row;
		x = rand() % col;
		if (board[y][x] == ' ') // 是空格才下
		{
			board[y][x] = '#';
			break;
		}
	}
}

void playerMove(char board[ROW][COL], int row, int col)
{
	int y, x;
	printf("玩家下棋:>\n");
	while (1)
	{
		printf("请输入坐标:>");
		scanf("%d %d", &y, &x);
		if (x >= 1 && x <= 3 && y >= 1 && y <= 3 && board[y - 1][x - 1] == ' ') // 限定范围
		{
			board[y - 1][x - 1] = '*'; // 这里要对应数组下标
			break;
		}
		else
			printf("坐标非法或被占用,请重新输入\n");
	}
}

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

char IsWin(char board[ROW][COL], int row, int col)
{// 检测行、列、对角线棋子情况
	for (int i = 0; i < row; i++) // 行
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
			return board[i][1]; // 若当行三子相同，返回其棋子

	for (int j = 0; j < col; j++) // 列
		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
			return board[1][j];// 若当列三子相同，返回其棋子

	// 对角线
	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))
		return 'Q'; // 字符Q表示棋盘满了
	return 'C'; // 字符C表示下棋正常进行
}

在test.c中：

#include "game.h"

void menu()
{
	printf("*************************\n");
	printf("**** 1.play   0.exit ****\n");
	printf("*************************\n");
}

void game()
{
	char board[ROW][COL] = { 0 };
	char ret = 0; // 接收棋盘下棋的信息
	initBoard(board, ROW, COL);
	display(board, ROW, COL);
	while (1) // 使用循环
	{
		playerMove(board, ROW, COL);
		ret = IsWin(board, ROW, COL); // 接收信息
		display(board, ROW, COL);
		if (ret != 'C') // 若不为正常情况，跳出循环
			break;
		computerMove(board, ROW, COL);
		ret = IsWin(board, ROW, COL);
		display(board, ROW, COL);
		if (ret != 'C')
			break;
	}
	if (ret == '*') // 跳出循环时判断下棋之后的情况
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else if (ret == 'Q')
		printf("平局\n");
}

void test()
{
	int input = 0;
	srand((unsigned int)time(NULL)); // 为后续的电脑随机下棋准备
	do
	{
		menu();
		printf("请输入:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误!\n");
		}
	} while (input);
}

int main()
{
	test();
	return 0;
}

以上是C语言三子棋的基础内容实现。

电脑难度提升

这里使用的是 暴力枚举 的方法，也就是使用循环加判断的方式将各种情况进行分析。
不过，在三子棋3×3对称且有下棋方法的棋盘中大部分枚举的情况是可以省略的。

先创建 computerDifficult.c源文件

三子连接防御

三子连接防御：当玩家下出两个连接的棋子，再下一颗连接成三子就胜利，这里电脑需要阻拦玩家连接成三个棋子。
列的防御
行的防御
对角线的防御
绿色圆为玩家棋子，红色菱形为电脑棋子。这意味着我们需要将所有的行、列、对角线的每个位置进行判断。
在computerDifficult.c中：

#include "game.h"

int difficult(char board[ROW][COL], char set1, char set2)
{
	for (int i = 0; i < 3; i++)
	{
		// 行的防御
		if (board[i][0] == board[i][1] && board[i][0] == set1 && board[i][2] == set2) // 行尾
		{
			board[i][2] = '#';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == set1 && board[i][1] == set2) // 行中
		{
			board[i][1] = '#';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == set1 && board[i][0] == set2) // 行头
		{
			board[i][0] = '#';
			return 1;
		}

		// 列的防御
		if (board[0][i] == board[1][i] && board[0][i] == set1 && board[2][i] == set2) // 列尾
		{
			board[2][i] = '#';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == set1 && board[1][i] == set2) // 列中
		{
			board[1][i] = '#';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == set1 && board[0][i] == set2) // 列头
		{
			board[0][i] = '#';
			return 1;
		}
	}

	// 对角线的防左斜
	if (board[0][0] == board[1][1] && board[1][1] == set1 && board[2][2] == set2) // 对角线左斜下
	{
		board[2][2] = '#';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == set1 && board[1][1] == set2) // 对角线左斜中
	{
		board[1][1] = '#';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == set1 && board[0][0] == set2) // 对角线左斜上
	{
		board[0][0] = '#';
		return 1;
	}

	// 对角线的防右斜
	if (board[0][2] == board[1][1] && board[1][1] == set1 && board[2][0] == set2) // 对角线右斜下
	{
		board[2][0] = '#';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == set1 && board[1][1] == set2) // 对角线右斜中
	{
		board[1][1] = '#';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == set1 && board[0][2] == set2) // 对角线右斜上
	{
		board[0][2] = '#';
		return 1;
	}
	return 0;
}

在game.h中：

int difficult(char board[ROW][COL], char set1, char set2);

在game.c中：

void computerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int y, x;

	if (difficult(board, '*', ' ')); // 当防御时返回1，否则返回0。
	else
	{
		while (1) // 这里使用了随机下棋
		{
			y = rand() % row;
			x = rand() % col;
			if (board[y][x] == ' ') // 是空格才下
			{
				board[y][x] = '#';
				break;
			}
		}
	}
}

三子连接攻击

三子连接攻击：当电脑下出两个连接的棋子，再下一颗连接成三子就胜利。

这里只需要将 difficult函数 的参数更改一下。
三子连接攻击
不过要注意，三子连接攻击的优先度应高于三子连接防御，如：
优先度
若到电脑下棋，此时应下3行3列获得胜利。
在game.c中：

void computerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int y, x;
	//        三子连接攻击				 三子连接防御
	if (difficult(board, '#', ' ') || difficult(board, '*', ' ')); // 当防御时返回1，否则返回0。
	else
	{
		while (1) // 这里使用了随机下棋
		{
			y = rand() % row;
			x = rand() % col;
			if (board[y][x] == ' ') // 是空格才下
			{
				board[y][x] = '#';
				break;
			}
		}
	}
}

二子连接

二子连接：当电脑下出一个棋子时，对其进行连接。
通过观察将棋子下在不同位置，其优劣是不同的：
在这里插入图片描述
在中心有四条线可以连接成三子，在角有三条线可以连接成三子，在边有二条线可以连接成三子。
我们可以继续使用 difficult函数 ，不过需要更改函数中的一些代码 和 下棋位置的优先度。
在computerDifficult.c中：

#include "game.h"

int difficult(char board[ROW][COL], char set1, char set2)
{
	// 对角线的防与攻左斜
	if (board[0][0] == board[1][1] && board[1][1] == set1 && board[2][2] == set2) // 对角线左斜下
	{
		board[0][0] == ' ' ? (board[0][0] = '#') : (board[2][2] = '#');
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == set1 && board[1][1] == set2) // 对角线左斜中
	{
		board[0][0] == ' ' ? (board[0][0] = '#') : (board[1][1] = '#');
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == set1 && board[0][0] == set2) // 对角线左斜上
	{
		board[2][2] == ' ' ? (board[2][2] = '#') : (board[0][0] = '#');
		return 1;
	}

	// 对角线的防与攻右斜
	if (board[0][2] == board[1][1] && board[1][1] == set1 && board[2][0] == set2) // 对角线右斜下
	{
		board[0][2] == ' ' ? (board[0][2] = '#') : (board[2][0] = '#');
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == set1 && board[1][1] == set2) // 对角线右斜中
	{
		board[0][2] == ' ' ? (board[0][2] = '#') : (board[1][1] = '#');
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == set1 && board[0][2] == set2) // 对角线右斜上
	{
		board[2][0] == ' ' ? (board[2][0] = '#') : (board[0][2] = '#');
		return 1;
	}

	for (int i = 0; i < 3; i++)
	{
		// 行的防御
		if (board[i][0] == board[i][1] && board[i][0] == set1 && board[i][2] == set2) // 行尾
		{
			board[i][0] == ' ' ? (board[i][0] = '#') : (board[i][2] = '#');
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == set1 && board[i][1] == set2) // 行中
		{
			board[i][0] == ' ' ? (board[i][0] = '#') : (board[i][1] = '#');
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == set1 && board[i][0] == set2) // 行头
		{
			board[i][2] == ' ' ? (board[i][2] = '#') : (board[i][0] = '#');
			return 1;
		}

		// 列的防御
		if (board[0][i] == board[1][i] && board[0][i] == set1 && board[2][i] == set2) // 列尾
		{
			board[0][i] == ' ' ? (board[0][i] = '#') : (board[2][i] = '#');
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == set1 && board[1][i] == set2) // 列中
		{
			board[0][i] == ' ' ? (board[0][i] = '#') : (board[1][i] = '#');
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == set1 && board[0][i] == set2) // 列头
		{
			board[2][i] == ' ' ? (board[2][i] = '#') : (board[0][i] = '#');
			return 1;
		}
	}
	return 0;
}

在game.c中：

void computerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int y, x;
	//        三子连接攻击				 三子连接防御					   二子连接
	if (difficult(board, '#', ' ') || difficult(board, '*', ' ') || difficult(board, ' ', '#')); // 当防御时返回1，否则返回0。
	else
	{
		while (1) // 这里使用了随机下棋
		{
			y = rand() % row;
			x = rand() % col;
			if (board[y][x] == ' ') // 是空格才下
			{
				board[y][x] = '#';
				break;
			}
		}
	}
}

当执行二子连接时，此代码优先考虑棋盘的四个角。

开局处理

根据上一部分我们可知电脑下棋位置的优先度应为中心、角、边。
开局时若中心没有棋子，则电脑优先选择，反之选择四个角的其中一个。
在computerDifficult.c中：

int first(char board[3][3])
{
	if (board[1][1] == ' ') // 开局占中心
	{
		board[1][1] = '#';
		return 1;
	}
	else// 开局占四角
	{
		int arr[2] = { 0, 2 };
		int i = arr[rand() % 2];
		int j = arr[rand() % 2];
		if (board[i][j] == ' ')
		{
			board[i][j] = '#';
			return 1;
		}
	}
	return 0;
}

在game.h中：

int first(char board[3][3]);

在game.c中：

void computerMove(char board[ROW][COL], int row, int col, int* firstMove)
{
	printf("电脑下棋\n");
	int y, x;
	//        三子连接攻击				 三子连接防御					   二子连接
	if (difficult(board, '#', ' ') || difficult(board, '*', ' ') || difficult(board, ' ', '#')); // 当防御时返回1，否则返回0。
	else if (*firstMove && first(board)) // 开局 
		*firstMove = 0;
	else
	{
		while (1) // 这里使用了随机下棋
		{
			y = rand() % row;
			x = rand() % col;
			if (board[y][x] == ' ') // 是空格才下
			{
				board[y][x] = '#';
				break;
			}
		}
	}
}

在test.c中：

void game()
{
	int firstMove = 1; // 判断是否是开局
	char board[ROW][COL] = { 0 };
	char ret = 0; // 接收棋盘下棋的信息
	initBoard(board, ROW, COL);
	display(board, ROW, COL);
	while (1) // 使用循环
	{
		playerMove(board, ROW, COL);
		ret = IsWin(board, ROW, COL); // 接收信息
		display(board, ROW, COL);
		if (ret != 'C') // 若不为正常情况，跳出循环
			break;
		computerMove(board, ROW, COL, &firstMove);
		ret = IsWin(board, ROW, COL);
		display(board, ROW, COL);
		if (ret != 'C')
			break;
	}
	if (ret == '*') // 跳出循环时判断下棋之后的情况
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else if (ret == 'Q')
		printf("平局\n");
}

穷举特殊情况

上面针对提升的电脑难度的代码，已经可以保证大部分情况电脑不会输给玩家。
不过还有些情况没有覆盖到，这里我们可以穷举出来。

同边情况

如图：
同边情况
当玩家先手且下出同边情况，由于电脑下棋的优先度导致 1-4 情况无法防御，所以我们需要单独列出。

边角情况

如图：
边角情况
当玩家先手且下出边角情况，由于电脑下棋的优先度并不能防御 2-1、2-2、2-3、2-4 这四种情况，所以我们需要单独列出。

对角情况

如图：
对角情况
当玩家先手且下出对角情况，电脑第二颗棋下在 角 本身就一定防御不住，所以我们需要单独列出。

代码实现

在computerDifficult.c中：

#include "game.h"

int defense(char board[ROW][COL])
{
	// 同边情况
	if (board[2][1] == '*' && board[1][2] == '*')
	{
		board[2][2] = '#';
		return 1;
	}
	// 边角情况
	if ((board[1][0] == '*' && board[2][2] == '*') || (board[2][1] == '*' && board[0][0] == '*'))
	{
		board[2][0] = '#';
		return 1;
	}
	if ((board[2][1] == '*' && board[0][2] == '*') || (board[1][2] == '*' && board[2][0] == '*'))
	{
		board[2][2] = '#';
		return 1;
	}
	// 对角情况
	if ((board[0][0] == '*' && board[2][2] == '*') || (board[0][2] == '*' && board[2][0] == '*'))
	{
		board[0][1] = '#';
		return 1;
	}
	return 0;
}

int difficult(char board[ROW][COL], char set1, char set2)
{
	if (set1 == ' ' && set2 == '#') // 当为二子连接时
		if (defense(board)) // 对特殊情况穷举
			return 1;
	// 对角线的防与攻左斜
	if (board[0][0] == board[1][1] && board[1][1] == set1 && board[2][2] == set2) // 对角线左斜下
	{
		board[0][0] == ' ' ? (board[0][0] = '#') : (board[2][2] = '#');
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == set1 && board[1][1] == set2) // 对角线左斜中
	{
		board[0][0] == ' ' ? (board[0][0] = '#') : (board[1][1] = '#');
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == set1 && board[0][0] == set2) // 对角线左斜上
	{
		board[2][2] == ' ' ? (board[2][2] = '#') : (board[0][0] = '#');
		return 1;
	}
	// 对角线的防与攻右斜
	if (board[0][2] == board[1][1] && board[1][1] == set1 && board[2][0] == set2) // 对角线右斜下
	{
		board[0][2] == ' ' ? (board[0][2] = '#') : (board[2][0] = '#');
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == set1 && board[1][1] == set2) // 对角线右斜中
	{
		board[0][2] == ' ' ? (board[0][2] = '#') : (board[1][1] = '#');
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == set1 && board[0][2] == set2) // 对角线右斜上
	{
		board[2][0] == ' ' ? (board[2][0] = '#') : (board[0][2] = '#');
		return 1;
	}
	for (int i = 0; i < 3; i++)
	{
		// 行的防御
		if (board[i][0] == board[i][1] && board[i][0] == set1 && board[i][2] == set2) // 行尾
		{
			board[i][0] == ' ' ? (board[i][0] = '#') : (board[i][2] = '#');
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == set1 && board[i][1] == set2) // 行中
		{
			board[i][0] == ' ' ? (board[i][0] = '#') : (board[i][1] = '#');
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == set1 && board[i][0] == set2) // 行头
		{
			board[i][2] == ' ' ? (board[i][2] = '#') : (board[i][0] = '#');
			return 1;
		}
		// 列的防御
		if (board[0][i] == board[1][i] && board[0][i] == set1 && board[2][i] == set2) // 列尾
		{
			board[0][i] == ' ' ? (board[0][i] = '#') : (board[2][i] = '#');
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == set1 && board[1][i] == set2) // 列中
		{
			board[0][i] == ' ' ? (board[0][i] = '#') : (board[1][i] = '#');
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == set1 && board[0][i] == set2) // 列头
		{
			board[2][i] == ' ' ? (board[2][i] = '#') : (board[0][i] = '#');
			return 1;
		}
	}
	return 0;
}

提升难度后的整体源代码

在game.h中：

#pragma once

#define _CRT_SECURE_NO_WARNINGS

#define ROW 3 // 方便扩展
#define COL 3

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

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

void display(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);

int difficult(char board[ROW][COL], char set1, char set2);

int first(char board[3][3]);

在game.c中：

#include "game.h"

void initBoard(char board[ROW][COL], int row, int col)
{
	for (int i = 0; i < row; i++)
		for (int j = 0; j < col; j++)
			board[i][j] = ' ';
}

void display(char board[ROW][COL], int row, int col)
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1) // 打印纵分割线
				printf("|");
		}
		printf("\n");
		if (i < row - 1) // 打印横分割线
		{
			for (int j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
		}
		printf("\n");
	}
}

void computerMove(char board[ROW][COL], int row, int col, int* firstMove)
{
	printf("电脑下棋\n");
	int y, x;
	//        三子连接攻击				 三子连接防御					   二子连接
	if (difficult(board, '#', ' ') || difficult(board, '*', ' ') || difficult(board, ' ', '#')); // 当防御时返回1，否则返回0。
	else if (*firstMove && first(board)) // 开局 
		*firstMove = 0;
	else
	{
		while (1) // 这里使用了随机下棋
		{
			y = rand() % row;
			x = rand() % col;
			if (board[y][x] == ' ') // 是空格才下
			{
				board[y][x] = '#';
				break;
			}
		}
	}
}

void playerMove(char board[ROW][COL], int row, int col)
{
	int y, x;
	printf("玩家下棋:>\n");
	while (1)
	{
		printf("请输入坐标:>");
		scanf("%d %d", &y, &x);
		if (x >= 1 && x <= 3 && y >= 1 && y <= 3 && board[y - 1][x - 1] == ' ') // 限定范围
		{
			board[y - 1][x - 1] = '*'; // 这里要对应数组下标
			break;
		}
		else
			printf("坐标非法或被占用,请重新输入\n");
	}
}

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

char IsWin(char board[ROW][COL], int row, int col)
{// 检测行、列、对角线棋子情况
	for (int i = 0; i < row; i++) // 行
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
			return board[i][1]; // 若当行三子相同，返回其棋子

	for (int j = 0; j < col; j++) // 列
		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
			return board[1][j];// 若当列三子相同，返回其棋子

	// 对角线
	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))
		return 'Q'; // 字符Q表示棋盘满了
	return 'C'; // 字符C表示下棋正常进行
}

在test.c中：

#include "game.h"

void menu()
{
	printf("*************************\n");
	printf("**** 1.play   0.exit ****\n");
	printf("*************************\n");
}

void game()
{
	int firstMove = 1; // 判断是否是开局
	char board[ROW][COL] = { 0 };
	char ret = 0; // 接收棋盘下棋的信息
	initBoard(board, ROW, COL);
	display(board, ROW, COL);
	while (1) // 使用循环
	{
		playerMove(board, ROW, COL);
		ret = IsWin(board, ROW, COL); // 接收信息
		display(board, ROW, COL);
		if (ret != 'C') // 若不为正常情况，跳出循环
			break;
		computerMove(board, ROW, COL, &firstMove);
		ret = IsWin(board, ROW, COL);
		display(board, ROW, COL);
		if (ret != 'C')
			break;
	}
	if (ret == '*') // 跳出循环时判断下棋之后的情况
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else if (ret == 'Q')
		printf("平局\n");
}

void test()
{
	int input = 0;
	srand((unsigned int)time(NULL)); // 为后续的电脑随机下棋准备
	do
	{
		menu();
		printf("请输入:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误!\n");
		}
	} while (input);
}

int main()
{
	test();
	return 0;
}

在computerDifficult.c中：

#include "game.h"

int defense(char board[ROW][COL])
{
	// 同边情况
	if (board[2][1] == '*' && board[1][2] == '*')
	{
		board[2][2] = '#';
		return 1;
	}
	// 边角情况
	if ((board[1][0] == '*' && board[2][2] == '*') || (board[2][1] == '*' && board[0][0] == '*'))
	{
		board[2][0] = '#';
		return 1;
	}
	if ((board[2][1] == '*' && board[0][2] == '*') || (board[1][2] == '*' && board[2][0] == '*'))
	{
		board[2][2] = '#';
		return 1;
	}
	// 对角情况
	if ((board[0][0] == '*' && board[2][2] == '*') || (board[0][2] == '*' && board[2][0] == '*'))
	{
		board[0][1] = '#';
		return 1;
	}
	return 0;
}

int difficult(char board[ROW][COL], char set1, char set2)
{
	if (set1 == ' ' && set2 == '#') // 当为二子连接时
		if (defense(board)) // 对特殊情况穷举
			return 1;
	// 对角线的防与攻左斜
	if (board[0][0] == board[1][1] && board[1][1] == set1 && board[2][2] == set2) // 对角线左斜下
	{
		board[0][0] == ' ' ? (board[0][0] = '#') : (board[2][2] = '#');
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == set1 && board[1][1] == set2) // 对角线左斜中
	{
		board[0][0] == ' ' ? (board[0][0] = '#') : (board[1][1] = '#');
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == set1 && board[0][0] == set2) // 对角线左斜上
	{
		board[2][2] == ' ' ? (board[2][2] = '#') : (board[0][0] = '#');
		return 1;
	}
	// 对角线的防与攻右斜
	if (board[0][2] == board[1][1] && board[1][1] == set1 && board[2][0] == set2) // 对角线右斜下
	{
		board[0][2] == ' ' ? (board[0][2] = '#') : (board[2][0] = '#');
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == set1 && board[1][1] == set2) // 对角线右斜中
	{
		board[0][2] == ' ' ? (board[0][2] = '#') : (board[1][1] = '#');
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == set1 && board[0][2] == set2) // 对角线右斜上
	{
		board[2][0] == ' ' ? (board[2][0] = '#') : (board[0][2] = '#');
		return 1;
	}
	for (int i = 0; i < 3; i++)
	{
		// 行的防御
		if (board[i][0] == board[i][1] && board[i][0] == set1 && board[i][2] == set2) // 行尾
		{
			board[i][0] == ' ' ? (board[i][0] = '#') : (board[i][2] = '#');
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == set1 && board[i][1] == set2) // 行中
		{
			board[i][0] == ' ' ? (board[i][0] = '#') : (board[i][1] = '#');
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == set1 && board[i][0] == set2) // 行头
		{
			board[i][2] == ' ' ? (board[i][2] = '#') : (board[i][0] = '#');
			return 1;
		}
		// 列的防御
		if (board[0][i] == board[1][i] && board[0][i] == set1 && board[2][i] == set2) // 列尾
		{
			board[0][i] == ' ' ? (board[0][i] = '#') : (board[2][i] = '#');
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == set1 && board[1][i] == set2) // 列中
		{
			board[0][i] == ' ' ? (board[0][i] = '#') : (board[1][i] = '#');
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == set1 && board[0][i] == set2) // 列头
		{
			board[2][i] == ' ' ? (board[2][i] = '#') : (board[0][i] = '#');
			return 1;
		}
	}
	return 0;
}

int first(char board[3][3])
{
	if (board[1][1] == ' ') // 开局占中心
	{
		board[1][1] = '#';
		return 1;
	}
	else// 开局占四角
	{
		int arr[2] = { 0, 2 };
		int i = arr[rand() % 2];
		int j = arr[rand() % 2];
		if (board[i][j] == ' ')
		{
			board[i][j] = '#';
			return 1;
		}
	}
	return 0;
}

结语

以上针对电脑难度提升的代码，个人觉得电脑应该不会出现输的情况了。当然，若读者测试出此电脑还是有问题，可以私信或评论区告知我。

谢谢阅读

瞌睡不来
关注
  • 15
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【C语言实现五子棋、三子棋人机对战，包含电脑人工智能对战（可攻可守）】（非标题党）
qq_64318258的博客
08-14 3419
C语言实现的五子棋、三子棋人机对战（通用），包含人工智能，电脑智能应对可攻可守，棋盘大小，游戏规则自由。
c语言三子棋的项目源代码.zip
10-18
本项目源代码——"c语言三子棋的项目源代码.zip"就是一个很好的实例，它展示了如何用C语言来编写一个简单的三子棋游戏。下面我们将详细探讨这个项目的知识点。 1. **基本结构**：任何程序都有其基本的结构，三子棋...
C语言实现井字棋
热门推荐
shinamashiro_的博客
11-09 1万+
一、游戏逻辑 1.游戏菜单 我们都知道，每打开一个游戏，首先出现在你面前的就是一个菜单，所以我们需要先有一个菜单。 由于游戏只需要简单的开始或退出，所以游戏菜单由1和0来选择进入游戏和退出游戏。 2.3x3二维数组和棋盘的打印 接着我们需要有一个3x3的二维数组用来存放每个棋盘格的落子情况，然后再实现棋盘在运行时的打印，产生视觉效果。 3.实现人与电脑的回合制 有了棋盘之后，就是实现玩家和电脑的交替下棋。玩家或电脑每下一步棋，就对棋局进行判断是继续进行还是结束。 4.对结果进行判定 ..
【C语言游戏】井字棋游戏（电脑下棋算法优化）
芥末虾的博客
09-06 2495
项目功能： 1. 玩家电脑轮流先手 2. 优化了电脑下棋的算法，实现智能落子 3. 优化游戏界面，提高游戏体验
C语言实现小游戏之井字棋
一只小卷毛的博客
10-29 5770
这是我在学习C语言的过程中自己编写的一个小游戏——井字棋，现在将自己的思路（主要以流程图形式和代码中的注释表达）和具体代码以及运行结果分享出来以供大家学习参考。
鹏哥C语言复习——三子棋
2302_80297338的博客
02-12 1456
本文对三子棋游戏所有功能实现进行了详细讲解，敬请阅读
C语言实现井字棋游戏（含算法优化）
qq_64690314的博客
11-10 1838
C语言实现井字棋游戏
C语言实现三子棋游戏（可改成五子棋）
ZHA_123的博客
07-29 832
这一次我们要写一个三子棋游戏，其实就是井字棋。主要需要用到的知识有这些：1.多文件实现项目2.模块化编程。
C语言实现井字棋（对二维数组的应用）
csm_77的博客
11-17 1331
文章目录 前言 一、游戏的准备阶段 1.打印游戏菜单：menu（） 2.保证游戏循环进行 二、数组的定义和初始化 1.数组的定义 2.数组的初始化：init_board（） 三、游戏过程（循环） 1.玩家下棋:gamer_move() 2.打印井字棋棋盘:print_board() 3.判断输赢:is_win（） 4.电脑下棋：computer_move（） 5.打印井字棋棋盘（重复引用函数即可） 6.判断输赢（重复引用函数即可） 四、游戏试运行 五、对程序的优化
C语言第十课：编写井字棋游戏（综合练习1）
weixin_59392935的博客
11-15 2524
在前面的九课中，我们学习了C语言程序的各个重要组成部分，结合往期文末的一些练习，想必现在大家对于知识已经有了不错的掌握，本文我将带领各位小伙伴们运用我们之前学过的知识，使用标准工程格式来写出我们的第一个小游戏——井字棋。
C语言实现简单三子棋程序
08-27
本资源主要介绍了使用C语言实现简单三子棋程序的方法，包括数组的初始化、棋盘的打印、电脑和玩家的走棋、输赢的判断等。通过阅读本资源，读者可以学习到C语言的编程技巧和逻辑思维方法。 1. 数组的初始化 在C语言...
C语言三子棋实现全代码.zip
02-05
《C语言实现三子棋全代码解析》 在IT领域，C语言作为一种基础且强大的编程语言，被广泛用于系统开发、软件工程以及教学实践中。本篇文章将深入探讨一个基于C语言实现的三子棋游戏，这既是C语言学习者的一个经典小...
井字棋游戏C语言实现
04-28
井字棋游戏的C语言实现，两方玩家可以玩井字棋printf("请输入操作前的数字代号：\n1：新游戏\n2：退出\n"); scanf_s("%d", &op); if (op == 2) break; else if (op == 1) new_game(); else { ...
C语言实现三子棋
08-25
C语言实现三子棋 C语言实现三子棋是指通过C语言编程实现三子棋游戏的功能。三子棋是一种简单的棋盘游戏，玩家通过下棋子来赢得游戏。下面是C语言实现三子棋的详细知识点： 1. 数组的应用：在C语言实现三子棋中，...
华为OD机试(C卷,200分)- 二叉树计算
欢迎来到我的博客~
07-20 605
6、递归处理左区间右区间并计算每个节点的childSum，新树的每个节点的值 = 其左右子树的所有节点值之和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。请由该二叉树生成一个新的二叉树，它满足其树中的每个节点将包含原始树中的左子树和右子树的和。2行整数，第1行表示二叉树的中序遍历，第2行表示二叉树的前序遍历，以空格分割。1行整数，表示求和树的中序遍历，以空格分割。输出 0 3 0 7 0 2 0。2、前序数组第一个元素为根节点。1、前序数组为0，空节点。
Windows图形界面(GUI)-DLG-C/C++ - 状态栏(StatusBar)
最新发布
0xCC说逆向
07-20 271
【代码】Windows图形界面(GUI)-DLG-C/C++ - 状态栏(StatusBar)
【C语言】条件运算符详解 - 《 A ? B : C 》
EleganceJiaBao的博客
07-16 504
条件运算符（也称为三元运算符）是C语言中唯一的三元运算符。它通常用于替代简单的 if-else 语句。条件运算符的语法如下：
学懂C语言（十）： C语言位运算符（按位与、按位或、左移、右移、异或、取反）的计算过程和底层原理
martian665的专栏
07-20 319
C语言位运算符（按位与、按位或、左移、右移、异或、取反）的计算过程和底层原理
C语言实现井字棋对决：人机大战
本文档主要介绍了如何用C语言实现一个井字棋游戏。井字棋，也称为 Tic Tac Toe，是一种简单的策略游戏，玩家轮流在3x3的格子中放置棋子，先在横、竖或斜线上完成三个棋子连线者获胜。C语言版本的井字棋程序设计包含...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值