• 初阶三子棋（超详解）

    图片来源于网络

    ✨博客主页：小钱编程成长记
    🎈博客专栏：C语言小游戏

    初阶三子棋

    1.游戏介绍

    1. 三子棋是黑白棋的一种，是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙、井字棋等。
    2. 将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。但是，有很多时候会出现和棋的情况。
      图片来自网络

    2.基本思路

    1. 先实现一个菜单，在菜单里选择游戏开始或退出游戏。
    2. 初始化棋盘，出现可以下棋的位置。
    3. 打印棋盘框架，让玩家能看到棋盘。
    4. 玩家下棋，棋子为x，再次打印棋盘，让玩家时刻都能看到棋盘。
    5. 电脑下棋，棋子为o，再次打印棋盘，让玩家时刻都能看到棋盘。
    6. 判断游戏结束还是继续：
      若三个x连成一条线，则玩家赢，返回X。
      若三个o连成一条线，则电脑赢，返回O。
      若上面三个条件都没满足，则返回C，本局游戏继续。
      判断返回的是什么？若是C，则本局游戏继续，否则本局游戏结束。

    3.实现前的准备

    在本工程中，代码较多，并且有很多自定义函数。我们一般将代码进行拆分，主程序放在test.c源文件中，函数定义放在game.c源文件中，函数声明或宏等放到game.h头文件中。

    将代码拆分的好处：

    1. 多人协作
    2. 代码保护

    4.实现步骤

    4.1 打印菜单

    如果我们想要多次游玩，则菜单要放进循环里，在菜单里选择开始游戏或者退出游戏。
    菜单中的选择我们通常用switch语句，菜单的循环我们通常用do … while循环。

    //test.c
#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");
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    在这里插入图片描述

    4.2 初始化棋盘

    主程序框架写好了，我们现在开始写游戏具体程序。因为棋盘有很多行和列，我们想到二维数组可以表现多行多列。

    注意： 为了可以方便修改棋盘的大小，我们可以用#define定义行和列，并将他们放到game.h头文件，只要在主程序中声明一下gane.h就可以使用头文件中的所有内容。

    因为在下棋前，落棋子的位置都是空的，所以我们用空格初始化。

    //game.h
#include 
//#define定义的标识符常量，方便修改行和列，直接修改棋盘的大小
#define ROW 3
#define COL 3
//初始化棋盘函数在头文件中的声明
void InitBoard(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;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    4.3 打印棋盘

    下面我们开始打印棋盘框架，用 - 和 | 组成框架，我们把一行框架和一行内容组合起来作为一行，那就只需要打印三行，三次循环。最后一行的框架不打印了，看起来更加合理。

    //game.h
//打印棋盘函数在头文件中的声明
void DisplayBoard(char board[ROW][COL], int row, int col);


//game.c
//打印棋盘
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");
	}
}

//test.c
//游戏
#include "game.h"
void game()
{
	int ret = 0;
	char board[ROW][COL];//定义二维数组
	//先初始化，让下棋的位置都变成空格
	InitBoard(board, ROW, COL);
	//然后打印棋盘
	DisplayBoard(board, ROW, COL);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    在这里插入图片描述

    4.4 玩家下棋

    首先玩家下的棋的坐标一定要在我们设置的二维数组的范围内，如果不在则重新输入；
    玩家落棋子的位置之前一定要是空的，若不是空则重新输入；

    //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 x = 0;
	int y = 0;
	printf("玩家请下棋\n");
	while (1)
	{
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (' ' == board[x - 1][y - 1])//玩家通常认为坐标是从（1，1）开始的，写代码时将行和列各-1，玩家输入的（1，1）在程序里就是（0，0），这个问题就解决了。
			{
				board[x - 1][y - 1] = 'X';
				break;
			}
			else
				printf("该坐标已有棋子，请重新输入\n");
		}
		else
			printf("坐标非法，请重新输入\n");
	}
}
//test.c
while(1)
{
	//玩家下棋的函数调用
	playermove(board, ROW, COL);
	//再次打印棋盘
	DisplayBoard(board, ROW, COL);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    在这里插入图片描述

    4.5 电脑下棋

    让电脑下棋需要先让电脑产生随机的坐标，那我们需要用rand产生随机数。
    注意： 只用rand产生的是伪随机数，要想让rand产生真随机数，就需要先用srand为rand产生随机的种子，给srand()的()中输入的是随机数，srand产生的就是随机的种子。时间戳（需要头文件time.h）是一个随着时间的变化而变化的值，给srand()中输入时间戳->srand( (unsigne int)time(NULL) )，得到的就是随机的种子。
    rand和srand都需要头文件stdlib.h

    //game.h
//时间戳的头文件声明
#include 
//rand和srand的头文件声明
#include 
//电脑下棋函数在头文件中的声明
void computermove(char board[ROW][COL], int row, int col);

//game.c
//电脑下棋
void computermove(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	while (1)
	{
		x = rand() % row;//产生0 ~ row-1的真随机数
		y = rand() % col;
		if (' ' == board[x][y])//如果x, y 还和上面的一样-1，那x-1,y-1可能是-1，没有这个下标，会出错
		{
			board[x][y] = 'O';
			break;
		}
	}
}

//test.c
	while (1)
	{
		srand( (unsigned int)time(NULL) );
		//玩家下棋的函数调用
		playermove(board, ROW, COL);
		//再次打印棋盘
		DisplayBoard(board, ROW, COL);
		//电脑下棋
		computermove(board, ROW, COL);
		//再次打印棋盘
		DisplayBoard(board, ROW, COL);
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    =在这里插入图片描述

    4.6 判断本局游戏继续还是结束

    我们来判断有没有一条直线上的三个位置的内容是相同的，并且不等于空。

    • 如果有，则返回这个位置上的内容。若内容为X，则玩家赢，本局游戏结束；若内容为O，则电脑赢，本局游戏结束。
    • 如果没有，则判断棋盘是否已满。若棋盘满了，则为平局，返回Q，本局游戏结束；若棋盘未满，返回C，则本局游戏继续。
    //game.c
//判断游戏继续或结束
//玩家赢--'X'
//电脑赢--'O'
//平局----'Q'
//游戏继续-'C'

//判断棋盘是否已满
static 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;
		}
	}
	return 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[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
	{
		return board[1][1];
	}
	if (IsFull(board, row, col))
	{
		return 'Q';
	}

	return 'C';
}

//test.c
while (1)
{
	srand((unsigned int)time(NULL));//产生随机的种子，用于rand产生真随机数
	//玩家下棋的函数调用
	playermove(board, ROW, COL);
	//再次打印棋盘
	DisplayBoard(board, ROW, COL);

	//判断游戏继续或结束
	ret = IsWin(board, ROW, COL);
	if ('C' != ret)
	{
		break;
	}

	//电脑下棋
	computermove(board, ROW, COL);
	//再次打印棋盘
	DisplayBoard(board, ROW, COL);
	
	//判断游戏继续或结束
	ret = IsWin(board, ROW, COL);
	if ('C' != ret)
	{
		break;
	}
}
if ('X' == ret)
{
	printf("玩家赢，本局游戏结束。\n");
}
else if ('O' == ret)
{
	printf("电脑赢，本局游戏结束。\n");
}
else if ('Q' == ret)
{
	printf("平局，本局游戏结束。\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98

    在这里插入图片描述

    4.7 优化棋盘的显示

    玩家和电脑每次落子时，上一次落子的棋盘并未消失。这会使打印的棋盘越来越多，不美观。
    我们可以在每次落子后都清空一次屏幕，这样屏幕就只会显示一个棋盘，更加美观。
    使用system(“cls”)可以清空屏幕，需要头文件stdlib.h

    在这里插入图片描述
    在这里插入图片描述

    5.游戏代码

    game.h

    #define _CRT_SECURE_NO_WARNINGS

#include 
//时间戳的头文件声明
#include 
//rand和srand和system("cls")的头文件声明
#include 
//#define定义的标识符常量，方便修改行和列，直接修改棋盘的大小
#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 compu

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    game.c

    #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 (i = 0; i < row; i++)
	{
		for (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");
	while (1)
	{
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (' ' == board[x - 1][y - 1])//玩家通常认为坐标是从（1，1）开始的，写代码时将行和列各-1，玩家输入的（1，1）在程序里就是（0，0），这个问题就解决了。
			{
				board[x - 1][y - 1] = 'X';
				break;
			}
			else
				printf("该坐标已有棋子，请重新输入\n");
		}
		else
			printf("坐标非法，请重新输入\n");
	}
}

//电脑下棋
void computermove(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	while (1)
	{
		x = rand() % row;//产生0 ~ row-1的真随机数
		y = rand() % col;
		if (' ' == board[x][y])//如果x, y 还和上面的一样-1，那x-1,y-1可能是-1，没有这个下标，会出错
		{
			board[x][y] = 'O';
			break;
		}
	}
}


//判断游戏继续或结束
//玩家赢--'X'
//电脑赢--'O'
//平局----'Q'
//游戏继续-'C'

//判断棋盘是否已满
static 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;
		}
	}
	return 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[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
	{
		return board[1][1];
	}
	if (IsFull(board, row, col))
	{
		return 'Q';
	}

	return 'C';
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147

    test.c
    随机数的种子不需要每局都获取，所以我们可以把它放进main函数里。

    #define _CRT_SECURE_NO_WARNINGS

#include "game.h"

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

void game()
{
	int ret = 0;
	char board[ROW][COL];//定义二维数组
	//先初始化，让下棋的位置都变成空格
	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 ('C' != ret)
		{
			break;
		}

		//电脑下棋
		computermove(board, ROW, COL);
		//清屏
		system("cls");
		//再次打印棋盘
		DisplayBoard(board, ROW, COL);
		
		//判断游戏继续或结束
		ret = IsWin(board, ROW, COL);
		if ('C' != ret)
		{
			break;
		}
	}
	if ('X' == ret)
	{
		printf("玩家赢，本局游戏结束。\n");
	}
	else if ('O' == ret)
	{
		printf("电脑赢，本局游戏结束。\n");
	}
	else if ('Q' == ret)
	{
		printf("平局，本局游戏结束。\n");
	}
}

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));//产生随机的种子，用于rand产生真随机数
	do
	{
		menu();
		printf("请输入:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("游戏开始\n");
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90

    6.总结

    好啦，这就是初阶三子棋的全部内容了，大家可以跟着操作起来，一起进步。由于我目前能力有限，写的三子棋代码还是有很大的优化空间，比如不能随意更改棋盘的大小，电脑下棋不够智能等。大家有什么问题也可以在评论区多多交流，感谢大家的阅读！

  • 相关阅读:
    SQL sever中函数(2)
    Python 的安装
    C语言编程常见错误
    【无标题】
    ISCTF新生赛(引用传递&简单社工)
    科目三:左转弯
    解决Windows 10更新安装失败的问题
    【linux-centos7下KVM安装相关文档】
    C# TCP Server服务端多线程监听RFID读卡器客户端上传的读卡数据
    【C语言】入门——结构体
  • 原文地址：https://blog.csdn.net/xue_bian_cheng_/article/details/132487995