C语言实现小游戏之井字棋

已于 2023-03-17 16:37:46 修改
阅读量5.6k 收藏 99
点赞数 35
分类专栏： 小设计系列 文章标签： c语言
于 2022-10-29 15:12:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjjxjy_2021/article/details/127586085
版权

目录

前言

这是我在学习C语言的过程中自己编写的一个小游戏，现在将自己的思路（主要以流程图形式和代码中的注释表达）和具体代码以及运行结果分享出来以供大家学习参考。

一、井字棋游戏的主流程

主流程的流程图：

d1a32283f03a42d58479d144bd1929d8.png

主函数代码：

int main()
{
	//设置随机值起始值
	srand((unsigned int)time(NULL));
	int input = 0;
	printf("游戏加载中，请耐心等候……\n");
	Sleep(2000);
	do
	{
		menu();//主菜单
		printf("请选择:>\n");//玩家选择
		scanf("%d", &input);
		switch (input)//判断玩家是否进行游戏以及是否输入合法选项
		{
		case 1:
			game();//游戏
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
		}
	} while (input);//do while循环至少进行一次选择。当玩家输入非法字符或者已经进行了一局游戏后可以回到主菜单，询问玩家是否继续玩游戏。
	return 0;
}

二、游戏部分

游戏部分流程图：

a62fb83d319146eab130a927a9fd769c.png

1.游戏函数

游戏程序：

//游戏程序
void game()
{
	int ret1 = Level();
	char ret2 = '\0';
	char board[ROW][COL] = { 0 };
	printf("游戏开始！\n");
	//初始化棋盘的函数
	InitBoard(board, ROW, COL);
	//打印棋盘的函数
	DisplayBoard(board, ROW, COL);
	//下棋
	while (1)//玩家下一步电脑下一步一直到游戏结束（两人中有一人胜利或者平局），才能结束循环
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		//判断是否结束
		ret2 = IsWin(board, ROW, COL);
		if (ret2 != 'C')
		{
			break;
		}
		DisplayBoard(board, ROW, COL);
		//电脑下棋
		//简单（电脑下棋位置完全随机）
		if (1 == ret1)
		{
			ComputerMove1(board, ROW, COL);
		}
		//初级（电脑具有堵住玩家和自己取胜的简单思路）
		else if (2 == ret1)
		{
			ComputerMove2(board, ROW, COL);
		}
		//其他，暂时未优化（期望是电脑的走棋位置更加优化，让电脑也学会做棋）
		else if (3 == ret1)
		{
			printf("正在开发，敬请期待\n");
		}
		//判断是否结束
		ret2 = IsWin(board, ROW, COL);
		if (ret2 != 'C')
		{
			break;
		}
		DisplayBoard(board, ROW, COL);
	}
	if ('*' == ret2)
	{
		printf("玩家赢！\n");
	}
	else if ('#' == ret2)
	{
		printf("电脑赢！\n");
	}
	else
	{
		printf("平局！\n");
	}
	DisplayBoard(board, ROW, COL);
}

主菜单： 

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

游戏难度菜单： 

//选择游戏难度
int Level()
{
	int input = 0;
	int level = 0;
	while (1)
	{
		printf("请选择游戏难度:>\n");
		printf("***********************************\n");
		printf("********      1.简单      *********\n");
		printf("********      2.初级      *********\n");
		printf("******** 3.中级（未开发） *********\n");
		printf("*************敬请期待**************\n");
		printf("***********************************\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			return 1;
			break;
		case 2:
			return 2;
			break;
		case 3:
			return 3;
			break;
		default:
			printf("选择错误，请重新选择:>\n");
			break;
		}
	}
	return 0;
}

2.初始化棋盘

//初始化棋盘
void InitBoard(char board[ROW][COL],int row,int col)
{
	int i = 0;
	int j = 0;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}

3.打印棋盘

//打印棋盘
void DisplayBoard(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++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
			{
				printf("|");
			}
		}
		printf("\n");
		if (i < row - 1)
		{
			for (j = 0; j < col; j++)
			{
				
				printf("---");
				if (j < col - 1)
				{
					printf("|");
				}
			}
			printf("\n");
		}
	}
}

4.玩家下棋

//玩家回合
void PlayerMove(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	printf("到玩家下棋！\n");
	printf("玩家请输入要下棋的坐标(例如：1 1）:>");
	while (1)
	{
		scanf("%d %d", &x, &y);
		//坐标范围是否合法的判断
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (' ' == board[x - 1][y - 1])//判断玩家所选择的坐标是否已经被占
			{
				board[x - 1][y - 1] = '*';//玩家在进行游戏时默认坐标是行为1到3，列为1到3。这与数组的下标从0开始不同，因此要将玩家输入的值进行-1的处理才能达到效果。
				break;
			}
			else
			{
				printf("该坐标已经被占，请重新选择:>");
			}
		}
		else
		{
			printf("输入坐标非法，请重新输入:>");
		}
	}
}

5.电脑下棋（两个难度等级）

第一个等级：

//第一版，随机落下一子（简单）
void ComputerMove1(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	while (1)
	{
		int n = 0;
		int m = 0;
		n = rand() % row;//0-2
		m = rand() % col;
		if (board[n][m] == ' ')
		{
			board[n][m] = '#';
			break;
		}
	}
}

第二个等级：

//优化版
//电脑落子有三种可能：
//①下一步可以胜利（在自己有两个棋子相连的情况下落下一子达成三连）
//②堵住对方快要胜利的棋子（未出现①时，若对方出现两子相连的情况及时堵住）
//③随机落下一枚棋子（在①②都未出现时，在棋盘中“随机落下一子”，要保证该位置周围八个位置有对方棋子，避免成为“废棋”）
//以上三种情况优先级由高到低

//改良后，第二版（初级）
int  ComputerMove2(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("电脑下棋\n");
	//模拟人类思考时间
	Sleep(2000);
	//情况①
	//行判断：
	for (int i = 0; i < ROW; i++)
	{
		if (board[i][0] == board[i][1] && ' ' == board[i][2] && '#' == board[i][0])
		{
			board[i][2] = '#';
			return 0;
		}
		if (board[i][0] == board[i][2] && ' ' == board[i][1] && '#' == board[i][0])
		{
			board[i][1] = '#';
			return 0;
		}
		if (board[i][1] == board[i][2] && ' ' == board[i][0] && '#' == board[i][1])
		{
			board[i][0] = '#';
			return 0;
		}
	}
	//列判断
	for (int j = 0; j < COL; j++)
	{
		if (board[0][j] == board[1][j] && ' ' == board[2][j] && '#' == board[1][j])
		{
			board[2][j] = '#';
			return 0;
		}
		if (board[0][j] == board[2][j] && ' ' == board[1][j] && '#' == board[2][j])
		{
			board[1][j] = '#';
			return 0;
		}
		if (board[1][j] == board[2][j] && ' ' == board[0][j] && '#' == board[2][j])
		{
			board[0][j] = '#';
			return 0;
		}
	}
	//对角线判断
	if (board[0][0] == board[1][1] && ' ' == board[2][2] && '#' == board[0][0])
	{
		board[2][2] = '#';
		return 0;
	}
	if (board[0][0] == board[2][2] && ' ' == board[1][1] && '#' == board[0][0])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][2] == board[1][1] && ' ' == board[1][1] && '#' == board[2][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[0][2] == board[1][1] && ' ' == board[2][0] && '#' == board[0][2])
	{
		board[2][0] = '#';
		return 0;
	}
	if (board[0][2] == board[2][0] && ' ' == board[1][1] && '#' == board[0][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][0] == board[1][1] && ' ' == board[0][2] && '#' == board[2][0])
	{
		board[0][2] = '#';
		return 0;
	}

	//情况②
	//行判断：
	for (int i = 0; i < ROW; i++)
	{
		if (board[i][0] == board[i][1] && ' ' == board[i][2] && '*' == board[i][0])
		{
			board[i][2] = '#';
			return 0;
		}
		if (board[i][0] == board[i][2] && ' ' == board[i][1] && '*' == board[i][0])
		{
			board[i][1] = '#';
			return 0;
		}
		if (board[i][1] == board[i][2] && ' ' == board[i][0] && '*' == board[i][1])
		{
			board[i][0] = '#';
			return 0;
		}
	}
	//列判断
	for (int j = 0; j < COL; j++)
	{
		if (board[0][j] == board[1][j] && ' ' == board[2][j] && '*' == board[1][j])
		{
			board[2][j] = '#';
			return 0;
		}
		if (board[0][j] == board[2][j] && ' ' == board[1][j] && '*' == board[2][j])
		{
			board[1][j] = '#';
			return 0;
		}
		if (board[1][j] == board[2][j] && ' ' == board[0][j] && '*' == board[2][j])
		{
			board[0][j] = '#';
			return 0;
		}
	}
	//对角线判断
	if (board[0][0] == board[1][1] && ' ' == board[2][2] && '*' == board[0][0])
	{
		board[2][2] = '#';
		return 0;
	}
	if (board[0][0] == board[2][2] && ' ' == board[1][1] && '*' == board[0][0])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][2] == board[1][1] && ' ' == board[1][1] && '*' == board[2][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[0][2] == board[1][1] && ' ' == board[2][0] && '*' == board[0][2])
	{
		board[2][0] = '#';
		return 0;
	}
	if (board[0][2] == board[2][0] && ' ' == board[1][1] && '*' == board[0][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][0] == board[1][1] && ' ' == board[0][2] && '*' == board[2][0])
	{
		board[0][2] = '#';
		return 0;
	}
	//情况③
	else
	{
		int n = 0;
		int m = 0;
		while (1)
		{
			n = rand() % row;
			m = rand() % col;
			int ret = IsHave(board, row, col, n, m);
			if (' ' == board[n][m] && ret)
			{
				board[n][m] = '#';
				break;
			}
		}
	}
	return 0;
}

第二个等级中判断所选位置周围八个位置是否有玩家的棋子 ：

//判断该位置周围的八个位置是否有玩家的棋子
//如果有,则返回 1
//如果没有，则返回 0
int IsHave(char board[ROW][COL], int row, int col,int x,int y)
{
	if ('*' == board[x - 1][y - 1] || '*' == board[x - 1][y] || '*' == board[x - 1][y + 1] ||
		'*' == board[x][y - 1] || '*' == board[x][y] || '*' == board[x][y + 1] ||
		'*' == board[x + 1][y - 1] || '*' == board[x + 1][y] || '*' == board[x + 1][y + 1])
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

6.判断游戏是否结束

//如果电脑胜利就返回'#'
//如果玩家胜利就返回'*'
//如果平局就返回'Q'
//打印出结果。
//如果有以上一种情况就break结束循环
//如果没有就继续返回'C'

//无论电脑还是玩家胜利的情况只有：
//①行一样
//②列一样
//③对角线一样
char IsWin(char board[ROW][COL], int row, int col)
{
	//有一方赢了
	//行判断：
	int i = 0;
	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];
		}
	}
	//列判断：
	int j = 0;
	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];
	}
	//平局
	else if (IsDraw(board,row,col))
		return 'Q';
	//继续
	else
		return 'C';
}

判断是否为平局： 

//是否是平局:平局返回1，否则返回0
int IsDraw(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			if (' ' == board[i][j])
				return 0;
		}
	}
	return 1;
}

三、 运行展示

演示时我选择了改良版的难度

14c511bdc3cf41db84a8a2c862a02757.png

fca32d0a35ab4f2c9cf9d77c7a4c917b.png

7fb39fb80a794bf4a81fc31df30a1b24.png

 从图中可以看到在我故意走偏的情况下，电脑是成功赢了这一局游戏。

四、源码展示

为了方便阅读代码，我将这个程序的代码分为了三个部分（三个文件）。

为了方便大家的使用和优化，我将整个代码放在下文：

game.h(游戏代码的实现)

//游戏代码的声明(函数声明，符号定义)
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<Windows.h>
//通过宏定义行数和列数之后再改进代码，进一步实现五子棋、N子棋时，也只需要改变宏定义处的内容非常的方便。
#define ROW 3#define ROW 3
#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  ComputerMove1(char board[ROW][COL], int row, int col);
//初级
int  ComputerMove2(char board[ROW][COL],int row,int col);

//判断该位置周围的八个位置是否有玩家的棋子
//如果有,则返回 1
//如果没有，则返回 0
int IsHave(char board[ROW][COL], int row, int col, int x, int y);

//判断是否胜利
char IsWin(char board[ROW][COL], int row, int col);

//是否是平局
int IsDraw(char board[ROW][COL], int row, int col);

test.c(菜单和主函数，测试游戏的逻辑)

#define _CRT_SECURE_NO_WARNINGS
//三子棋游戏
//测试游戏的逻辑
#include"game.h"
//游戏菜单
void menu()
{
	printf("*******************************\n");
	printf("**********  1.play  ***********\n");
	printf("**********  0.exit  ***********\n");
	printf("*******************************\n");
}
//选择游戏难度
int Level()
{
	int input = 0;
	int level = 0;
	while (1)
	{
		printf("请选择游戏难度:>\n");
		printf("***********************************\n");
		printf("********      1.简单      *********\n");
		printf("********      2.初级      *********\n");
		printf("******** 3.中级（未开发） *********\n");
		printf("*************敬请期待**************\n");
		printf("***********************************\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			return 1;
			break;
		case 2:
			return 2;
			break;
		case 3:
			return 3;
			break;
		default:
			printf("选择错误，请重新选择:>\n");
			break;
		}
	}
	return 0;
}
//游戏程序
void game()
{
	int ret1 = Level();
	char ret2 = '\0';
	char board[ROW][COL] = { 0 };
	printf("游戏开始！\n");
	//初始化棋盘的函数
	InitBoard(board, ROW, COL);
	//打印棋盘的函数
	DisplayBoard(board, ROW, COL);
	//下棋
	while (1)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		//判断是否结束
		ret2 = IsWin(board, ROW, COL);
		if (ret2 != 'C')
		{
			break;
		}
		DisplayBoard(board, ROW, COL);
		//电脑下棋
		//简单（电脑下棋位置完全随机）
		if (1 == ret1)
		{
			ComputerMove1(board, ROW, COL);
		}
		//初级（电脑具有堵住玩家和自己取胜的简单思路）
		else if (2 == ret1)
		{
			ComputerMove2(board, ROW, COL);
		}
		//其他，暂时未优化（期望是电脑的走棋位置更加优化，让电脑也学会做棋）
		else if (3 == ret1)
		{
			printf("正在开发，敬请期待\n");
		}
		//判断是否结束
		ret2 = IsWin(board, ROW, COL);
		if (ret2 != 'C')
		{
			break;
		}
		DisplayBoard(board, ROW, COL);
	}
	if ('*' == ret2)
	{
		printf("玩家赢！\n");
	}
	else if ('#' == ret2)
	{
		printf("电脑赢！\n");
	}
	else
	{
		printf("平局！\n");
	}
	DisplayBoard(board, ROW, COL);
}
int main()
{
	//设置随机值起始值
	srand((unsigned int)time(NULL));
	int input = 0;
	printf("游戏加载中，请耐心等候……\n");
	Sleep(2000);
	do
	{
		menu();
		printf("请选择:>\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
		}
	} while (input);
	return 0;
}

game.h(游戏代码的声明(函数声明，符号定义))

#define _CRT_SECURE_NO_WARNINGS
//游戏代码的实现
#include"game.h"
//初始化棋盘
void InitBoard(char board[ROW][COL],int row,int col)
{
	int i = 0;
	int j = 0;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}
//打印棋盘
void DisplayBoard(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++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
			{
				printf("|");
			}
		}
		printf("\n");
		if (i < row - 1)
		{
			for (j = 0; j < col; j++)
			{
				
				printf("---");
				if (j < col - 1)
				{
					printf("|");
				}
			}
			printf("\n");
		}
	}
}
//玩家回合
void PlayerMove(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	printf("到玩家下棋！\n");
	printf("玩家请输入要下棋的坐标(例如：1 1）:>");
	while (1)
	{
		scanf("%d %d", &x, &y);
		//坐标范围是否合法的判断
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (' ' == board[x - 1][y - 1])
			{
				board[x - 1][y - 1] = '*';
				break;
			}
			else
			{
				printf("该坐标已经被占，请重新选择:>");
			}
		}
		else
		{
			printf("输入坐标非法，请重新输入:>");
		}
	}
}
//判断该位置周围的八个位置是否有玩家的棋子
//如果有,则返回 1
//如果没有，则返回 0
int IsHave(char board[ROW][COL], int row, int col,int x,int y)
{
	if ('*' == board[x - 1][y - 1] || '*' == board[x - 1][y] || '*' == board[x - 1][y + 1] ||
		'*' == board[x][y - 1] || '*' == board[x][y] || '*' == board[x][y + 1] ||
		'*' == board[x + 1][y - 1] || '*' == board[x + 1][y] || '*' == board[x + 1][y + 1])
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

//电脑回合
//优化版
//电脑落子有三种可能：
//①下一步可以胜利（在自己有两个棋子相连的情况下落下一子达成三连）
//②堵住对方快要胜利的棋子（未出现①时，若对方出现两子相连的情况及时堵住）
//③随机落下一枚棋子（在①②都未出现时，在棋盘中“随机落下一子”，要保证该位置周围八个位置有对方棋子，避免成为“废棋”）
//以上三种情况优先级由高到低

//第一版，随机落下一子（简单）
void ComputerMove1(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	while (1)
	{
		int n = 0;
		int m = 0;
		n = rand() % row;//0-2
		m = rand() % col;
		if (board[n][m] == ' ')
		{
			board[n][m] = '#';
			break;
		}
	}
}

//改良后，第二版（初级）
int  ComputerMove2(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("电脑下棋\n");
	//模拟人类思考时间
	Sleep(2000);
	//情况①
	//行判断：
	for (int i = 0; i < ROW; i++)
	{
		if (board[i][0] == board[i][1] && ' ' == board[i][2] && '#' == board[i][0])
		{
			board[i][2] = '#';
			return 0;
		}
		if (board[i][0] == board[i][2] && ' ' == board[i][1] && '#' == board[i][0])
		{
			board[i][1] = '#';
			return 0;
		}
		if (board[i][1] == board[i][2] && ' ' == board[i][0] && '#' == board[i][1])
		{
			board[i][0] = '#';
			return 0;
		}
	}
	//列判断
	for (int j = 0; j < COL; j++)
	{
		if (board[0][j] == board[1][j] && ' ' == board[2][j] && '#' == board[1][j])
		{
			board[2][j] = '#';
			return 0;
		}
		if (board[0][j] == board[2][j] && ' ' == board[1][j] && '#' == board[2][j])
		{
			board[1][j] = '#';
			return 0;
		}
		if (board[1][j] == board[2][j] && ' ' == board[0][j] && '#' == board[2][j])
		{
			board[0][j] = '#';
			return 0;
		}
	}
	//对角线判断
	if (board[0][0] == board[1][1] && ' ' == board[2][2] && '#' == board[0][0])
	{
		board[2][2] = '#';
		return 0;
	}
	if (board[0][0] == board[2][2] && ' ' == board[1][1] && '#' == board[0][0])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][2] == board[1][1] && ' ' == board[1][1] && '#' == board[2][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[0][2] == board[1][1] && ' ' == board[2][0] && '#' == board[0][2])
	{
		board[2][0] = '#';
		return 0;
	}
	if (board[0][2] == board[2][0] && ' ' == board[1][1] && '#' == board[0][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][0] == board[1][1] && ' ' == board[0][2] && '#' == board[2][0])
	{
		board[0][2] = '#';
		return 0;
	}

	//情况②
	//行判断：
	for (int i = 0; i < ROW; i++)
	{
		if (board[i][0] == board[i][1] && ' ' == board[i][2] && '*' == board[i][0])
		{
			board[i][2] = '#';
			return 0;
		}
		if (board[i][0] == board[i][2] && ' ' == board[i][1] && '*' == board[i][0])
		{
			board[i][1] = '#';
			return 0;
		}
		if (board[i][1] == board[i][2] && ' ' == board[i][0] && '*' == board[i][1])
		{
			board[i][0] = '#';
			return 0;
		}
	}
	//列判断
	for (int j = 0; j < COL; j++)
	{
		if (board[0][j] == board[1][j] && ' ' == board[2][j] && '*' == board[1][j])
		{
			board[2][j] = '#';
			return 0;
		}
		if (board[0][j] == board[2][j] && ' ' == board[1][j] && '*' == board[2][j])
		{
			board[1][j] = '#';
			return 0;
		}
		if (board[1][j] == board[2][j] && ' ' == board[0][j] && '*' == board[2][j])
		{
			board[0][j] = '#';
			return 0;
		}
	}
	//对角线判断
	if (board[0][0] == board[1][1] && ' ' == board[2][2] && '*' == board[0][0])
	{
		board[2][2] = '#';
		return 0;
	}
	if (board[0][0] == board[2][2] && ' ' == board[1][1] && '*' == board[0][0])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][2] == board[1][1] && ' ' == board[1][1] && '*' == board[2][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[0][2] == board[1][1] && ' ' == board[2][0] && '*' == board[0][2])
	{
		board[2][0] = '#';
		return 0;
	}
	if (board[0][2] == board[2][0] && ' ' == board[1][1] && '*' == board[0][2])
	{
		board[1][1] = '#';
		return 0;
	}
	if (board[2][0] == board[1][1] && ' ' == board[0][2] && '*' == board[2][0])
	{
		board[0][2] = '#';
		return 0;
	}
	//情况③
	else
	{
		int n = 0;
		int m = 0;
		while (1)
		{
			n = rand() % row;
			m = rand() % col;
			int ret = IsHave(board, row, col, n, m);
			if (' ' == board[n][m] && ret)
			{
				board[n][m] = '#';
				break;
			}
		}
	}
	return 0;
}

//是否是平局:平局返回1，否则返回0
int IsDraw(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			if (' ' == board[i][j])
				return 0;
		}
	}
	return 1;
}
//如果电脑胜利就返回'#'
//如果玩家胜利就返回'*'
//如果平局就返回'Q'
//打印出结果。
//如果有以上一种情况就break结束循环
//如果没有就继续返回'C'

//无论电脑还是玩家胜利的情况只有：
//①行一样
//②列一样
//③对角线一样
char IsWin(char board[ROW][COL], int row, int col)
{
	//有一方赢了
	//行：
	int i = 0;
	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];
		}
	}
	//列：
	int j = 0;
	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];
	}
	//平局
	else if (IsDraw(board,row,col))
		return 'Q';
	//继续
	else
		return 'C';
}

总结

 以上就是今天要讲的内容，本文简单的展示了井字棋小游戏的C语言实现，作者编写代码的思路以及具体代码都在文章中。当然这个井字棋小游戏还有很大的优化空间，后期作者也会进一步对它进行优化，如果您有什么好的想法或者建议也可以向作者提出。

本文的作者也只是一个正在学习C语言等编程知识的萌新，若这篇文章中有哪些不正确的内容，请在评论区向作者指出（也可以私信作者），欢迎大佬们指点，也欢迎其他正在学习C语言的萌新和作者进行交流。

最后，如果本篇文章对你有所启发的话，也希望可以支持支持作者，后续作者也会定期更新学习记录。谢谢大家！

be24932364ba4da0b66df629d767dfc4.gif

codeJinger
关注
  • 35
    点赞
  • 踩
  • 99
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
C语言实现井字棋游戏(双人模式和人机对战模式)
08-16
整体游戏是基于C语言，其中包括easyX的图形界面编程。因为作者的经验和能力问题，整体代码可能比较繁琐，但是涉及的编程知识偏基础，目前没有涉及指针，结构体等。游戏功能比较完整，也比较易懂，应该比较适合C语言...
C语言井字棋.zip
02-19
希望大家互相学习，天天向上，不足之处请在评论区点出。 本资源属于纯学习资源，切勿用于商业用途。刚上传积分为0，上升的话请留言我修改回来！
C语言实现井字棋
热门推荐
shinamashiro_的博客
11-09 1万+
一、游戏逻辑 1.游戏菜单 我们都知道，每打开一个游戏，首先出现在你面前的就是一个菜单，所以我们需要先有一个菜单。 由于游戏只需要简单的开始或退出，所以游戏菜单由1和0来选择进入游戏和退出游戏。 2.3x3二维数组和棋盘的打印 接着我们需要有一个3x3的二维数组用来存放每个棋盘格的落子情况，然后再实现棋盘在运行时的打印，产生视觉效果。 3.实现人与电脑的回合制 有了棋盘之后，就是实现玩家和电脑的交替下棋。玩家或电脑每下一步棋，就对棋局进行判断是继续进行还是结束。 4.对结果进行判定 ..
C语言编写井字棋游戏
FlippedSQ的博客
05-19 2178
该项目为使用 C 语言编写基于控制台的井字棋游戏。玩家使用“*”作为棋子，电脑使用“#”作为棋子，两个实体轮流下棋，第一个完成三个棋子连成一线的玩家获胜。若棋盘已满且没有玩家获胜，游戏成平局。该游戏为基础井字棋游戏，AI 算法为随机下棋。该井字棋游戏是一个基础版，但可以通过该参考代码了解到一些基本的 C 语言操作，如循环嵌套、判断语句和数组等。当然，该游戏也有一些可以改进的地方。比如，可以考虑添加更加智能的 AI，提高游戏难度和趣味性。
python——井字棋游戏——代码（全）
最新发布
2301_76794217的博客
04-23 2570
文章下面有井字棋全部代码和如何与上一篇登入界面进行连接。
用C语言模拟实现井字棋游戏
zhanlongsiqu的博客
01-18 356
在game.h里编写函数声明、包含game.c和test.c中需要用到的头文件、定义标识符，当我们在game.c和test.c中需要用到某些函数、头文件、标识符时，我们只要在game.c和test.c中包含我们自己写的game.h就可以了。下面展示的是game.h和test.c：。1、在游戏函数中先定义一个用来存放数据的字符型二维数组，再初始化棋盘、显示棋盘，然后将“玩家下棋、显示（打印）棋盘、判断输赢、电脑随机下棋、显示（打印）棋盘、判断输赢”按照固定的顺序写入while循环中，最后用if语句判断输赢。
【游戏】—— 设计井字棋的程序完整代码
chenxiyuehh的博客
10-22 2743
头文件game.h #define _CRT_SECURE_NO_WARNINGS #ifndef GAME_H #define GAME_H #include &amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;time.h&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;stdlib.h&amp;amp;
C语言之井字棋
m0_73495584的博客
11-13 930
井字棋也叫三子棋
井字棋游戏(C语言).pdf
09-30
井字棋游戏(C语言).pdf
用C语言实现三子棋小游戏
08-08
三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙、井字棋等。将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。但是，有很多时候会出现和棋的情况。 1...
人机对战，人人对战皆可选择。C语言实现代码井字棋
06-18
适合初学者学习，彩色版。电脑随机下子，双人小游戏，欢迎下载
井字棋用C语言写的源代码
11-26
井字棋又称一字棋、三字棋.此资源非原创.
c语言写的井字棋游戏
11-26
在我们大一的时候，我们小组三个一起写的井字棋游戏，全部都是基于c语言写的井字棋小游戏！
用C语言编写的井字棋小游戏
11-26
用C语言编写的井字棋小游戏。初学者没事的时候可以看看，又不先进的地方请交流！！
HTML5井字棋
11-21
可以作为学习html5的好demo，是一个大家都喜欢玩的井字棋游戏，感兴趣的可以下载下来玩
小游戏 井字棋源代码
11-06
随便 #include <iostream> #include <string> using namespace std; typedef char chess[10]; typedef int temparr[10]; chess arr; temparr brr; int number,suc,n3,c3,n2,c2,n1,c1; void inarrdata(chess a) { a[1]='1';a[2]='2';a[3]='3'; a[4]='4';a[5]='5';a[6]='6'; a[7]='7';a[8]='8';a[9]='9'; }
C语言保姆级教学实现井字棋（附源码与教程）
fmsaier的博客
10-08 479
想必大家小时候都玩过井字棋，如今让我们尝试将井字棋的规则拆分化解，并使用C语言进行编程构造。
三子棋（井字棋）游戏-C语言超详细解析！（附源代码）
qq_58802755的博客
07-27 4471
一、开始写游戏之前，我们要注意： （这样写便于修改，提高代码可读性） 首先是自己最先创建，包含主函数的.c文件，例如在此游戏中是test.c。 我们通常会新建一个头文件，例如此游戏新建game.h，此头文件通常用来完成函数声明、头文件的引用、宏定义变量。 新建一个.c文件，例如在此游戏新建game.c，编写涉及到的功能函数实现。 二、思路 我们可以先编写让玩家进行输入（决定是否进行游戏，例如：进行输入1，不进行输入0，（这里运用switch语句进行判断选择））。 如果用户输入1，则我们进入游戏。
【C语言】三子棋（井字棋）的实现
心之王者的博客
07-28 1196
三子棋游戏的简单实现
用c语言写一个井字棋小游戏
03-25
这个代码实现了一个简单的井字棋小游戏，首先打印出初始的空棋盘，然后轮流让两个玩家下棋。每次下棋时，程序会提示用户输入想要落子的行和列，如果该位置已经有棋子则会提示用户重新输入。在每次下棋之后，程序会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

codeJinger

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值