【C语言】数组的应用——三子棋

发布于：2022-08-03 ⋅ 阅读:(404) ⋅ 点赞:(0)

1. 创建文件

创建一个头文件game.h：游戏代码的声明（函数声明、符号定义）

创建两个源文件game.c：游戏代码的实现

                            test.c：测试游戏的逻辑

2. 设计游戏大致流程

游戏流程至少执行1次，所以用do while循环。

  1. 打印菜单：1. play 0. exit
  2. 玩家输入1/0选择是否进入游戏
  3. 输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
//test.c
int main()
{
	int input = 0;
	do
	{
		//打印菜单
        menu();
        //玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
        //输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}
//game.h
//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>

3. 设计菜单 

//test.c
//菜单
void menu()
{
	printf("*****************************\n");
	printf("*****  1. play  0. exit *****\n");
	printf("*****************************\n");
}

4. 设计游戏

4.1 创建棋盘

创建3×3的二维数组当作棋盘，在game.h中定义ROW和COL的值均为3，这样如果要修改ROW和COL的值，只需要在game.h中修改即可。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
}
//game.h
//如果要修改ROW和COL的值，只需要修改#define这两行代码即可
#define ROW 3
#define COL 3

4.2 初始化棋盘

遍历二维数组， 令二维数组每个元素都是空格。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
}
//game.c
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
        int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}
//game.h
//初始化棋盘函数声明
void InitBoard(char board[ROW][COL], int row, int col);

4.3 打印棋盘

打印棋子和网格。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
}

打印棋盘函数版本1——容易看懂版：

//game.c
//打印棋盘
void DispalyBoard(char board[ROW][COL], int row, int col)
{
	int i = 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");
	}
}

打印棋盘函数版本2——高大上版：

//game.c
//打印棋盘
void DispalyBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		//打印数据
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		//打印分割信息
		if (i < row - 1)
		{
			int j = 0;
			for (j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
			printf("\n");
		}
	}
}
//game.h
//打印棋盘函数声明
void DispalyBoard(char board[ROW][COL], int row, int col);

棋盘展示：

4.4 下棋

双方下棋过程是无限循环的，直到有一方赢了或平局，跳出循环，结束下棋，所以下棋过程放在while(1)循环内。

玩家的棋子为*，电脑的棋子为#。

4.4.1 玩家下棋

数组的下标是从0开始的，而玩家认为行和列的坐标都是从1开始的，如图所示：

1 2 3
1 棋盘格 棋盘格 棋盘格
2 棋盘格 棋盘格 棋盘格
3 棋盘格 棋盘格 棋盘格

玩家可能会输入被占用的或棋盘外的坐标，此时需要重新下棋，如果一直输入错误，则玩家下棋无限循环，直到输入合法的坐标，跳出循环，结束玩家下棋，所以玩家下棋放在while(1)循环内。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
	}
}
//game.c
//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col)
{
	printf("玩家下棋:>\n");
	while (1)
	{
        int x = 0;
	    int y = 0;
        //输入下棋坐标
		printf("请输入坐标:>");
		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("坐标被占用，不能下棋，请选择其他位置\n");
		}
		else
			printf("坐标非法，请重新输入\n");
	}
}
//game.h
//玩家下棋函数声明
void PlayerMove(char board[ROW][COL], int row, int col);

4.4.2 判断输赢

设计判断输赢函数，返回类型为char型，所以要先创建一个char型变量ret，用于接收返回值。如果行或列或对角线三个棋子相同，则返回棋子（即玩家赢返回*，电脑赢返回#）。平局返回D，继续返回C。如果玩家赢或电脑赢或平局，则跳出循环，结束下棋。

平局即棋盘被占满的情况，设计判断棋盘是否被占满函数，返回类型为int型，被占满返回1，没被占满返回0。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
	}
}
//game.c
//判断输赢
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][1] != ' ')
			return board[i][1];
	}
	//列
	int j = 0;
	for (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 'D';
	//继续
	return 'C';
}
//game.c
//判断输赢函数声明
char IsWin(char board[ROW][COL], int row, int col);
//game.c
//判断棋盘是否被占满
int IsFull(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
    	int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 0;//没被占满返回0
		}
	}
	return 1;//被占满返回1
}

4.4.3 打印棋盘

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
        //打印棋盘
		DispalyBoard(board, ROW, COL);
	}
}

4.4.4 电脑下棋

电脑在空格子随机下棋，需要在循环内使用rand()函数，循环外使用srand((unsigned int)time(NULL))使每次生成的随机数序列都是不同的。

rand()函数是一个库函数，可以产生0-32767的随机数，头文件是stdlib.h。rand在产生随机数前，需要系统提供的生成伪随机数序列的种子，根据种子值产生随机数。如果种子没有变化，每次调用rand()函数生成的伪随机数序列都是一样的。

srand(unsigned int seed)通过参数seed改变系统提供的种子值，头文件是stdlib.h。通常可以利用系统时间来改变系统的种子值，即srand((unsigned int)time(NULL))。

rand()放在循环内，srand()放在循环外。

time()函数返回当前时间的Unix时间戳，头文件是time.h。Unix时间戳是指从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数。

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

int main()
{
	srand((unsigned int)time(NULL));//设置随机数种子
	int input = 0;
	do
	{
		//打印菜单
        menu();
        //玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
        //输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}
//game.c
//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋:>\n");
	while (1)
	{
		int x = rand() % row;//0~2
		int y = rand() % col;//0~2
		if (board[x][y] == ' ')
		{
			board[x][y] = '#';
			break;
		}
	}
}
//game.h
//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//电脑下棋函数声明
void ComputerMove(char board[ROW][COL], int row, int col);

4.4.5 判断输赢

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

4.4.6 打印棋盘

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

4.5 打印结果并打印棋盘

//test.c
//游戏
void game()
{
	//创建棋盘
	char board[ROW][COL] = { 0 };
	//初始化棋盘
	InitBoard(board, ROW, COL);
	//打印棋盘
	DispalyBoard(board, ROW, COL);
	//下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
		//电脑下棋
		ComputerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
	}
	//打印结果
	if (ret == '*')
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else
		printf("平局\n");
	//打印棋盘
	DispalyBoard(board, ROW, COL);
}

5. 完整代码

game.h：

#pragma once//预处理指令，保证头文件只能被编译一次

//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//如果要修改ROW和COL的值，只需要修改#define这两行代码即可
#define ROW 3
#define COL 3

//初始化棋盘函数声明
void InitBoard(char board[ROW][COL], int row, int col);
//打印棋盘函数声明
void DispalyBoard(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)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}

//打印棋盘1
//void DispalyBoard(char board[ROW][COL], int row, int col)
//{
//	int i = 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");
//	}
//}

//打印棋盘2
void DispalyBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		//打印数据
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		//打印分割信息
		if (i < row - 1)
		{
			int j = 0;
			for (j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
			printf("\n");
		}
	}
}

//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col)
{
	printf("玩家下棋:>\n");
	while (1)
	{
		int x = 0;
		int y = 0;
		//输入下棋坐标
		printf("请输入坐标:>");
		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("坐标被占用，不能下棋，请选择其他位置\n");
		}
		else
			printf("坐标非法，请重新输入\n");
	}
}

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

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

//判断输赢
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][1] != ' ')
			return board[i][1];
	}
	//列
	int j = 0;
	for (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 'D';
	//继续
	return '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 };
	//初始化棋盘
	InitBoard(board, ROW, COL);
	//打印棋盘
	DispalyBoard(board, ROW, COL);
	//下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
		//电脑下棋
		ComputerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
	}
	//打印结果
	if (ret == '*')
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else
		printf("平局\n");
	//打印棋盘
	DispalyBoard(board, ROW, COL);
}

int main()
{
	int input = 0;
	do
	{
		//打印菜单
		menu();
		//玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
		//输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}

运行结果：

本文含有隐藏内容，请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布