【C语言】三子棋游戏与多子棋 (保姆级的实现过程)

????write in front????   

????大家好，我是謓泽，希望你看完之后，能对你有所帮助，不足请指正！共同学习交流????

????2021年度博客之星物联网与嵌入式开发TOP5～2021博客之星TOP100～2022博客之星TOP63～作者周榜84﹣作者总榜704～阿里云专家博主 & 阿里云星级博主～掘金优秀创作者⇿InfoQ创作者⇿51CTO红人⇿全网访问量50w+????

????本文由 謓泽 原创 如需转载还请通知⚠

????个人主页－​​謓泽51Ctop的博客​​????

????欢迎各位→点赞???? + 收藏⭐️ + 留言????

????系列专栏－​​謓泽51Ctop的博客_【C语言】从0～1_51CTO博客​​????
✉️我们并非登上我们所选择的舞台，演出并非我们所选择的剧本????

---

 ① 前言

三子棋，想必大家都有玩过吧。没完过的话也可以试着玩一玩，这样对写三子棋这个小游戏的化是会有一个很好的思路的。那么本片博客就来介绍如何实现三子棋小游戏的具体步骤。

---

② 模块化编程 

再说实现三子棋逻辑思路前，我们来说说什么是 模块化编程 吧?

传统方式编程：所有的函数均放在main.c里，若使用的模块比较多，则一个文件内会有很多的代码，不利于代码的组织和管理，而且很影响编程者的思路。

模块化编程：把各个模块的代码放在不同的.c文件里，在.h文件里提供外部可调用函数的声明，其它.c文件想使用其中的代码时，只需要#include "XXX.h"文件即可。使用模块化编程可极大的提高代码的可阅读性、可维护性、可移植性等。

传统方式编程：所有的函数均放在main.c里，若使用的模块比较多，则一个文件内会有很多的代码，不利于代码的组织和管理，而且很影响编程者的思路。

模块化编程：把各个模块的代码放在不同的.c文件里，在.h文件里提供外部可调用函数的声明，其它.c文件想使用其中的代码时，只需要#include "XXX.h"文件即可。使用模块化编程可极大的提高代码的可阅读性、可维护性、可移植性等!

总的来说就是：当你代码比较多的时候，就可以采用模块化编程来完成这个程序。 

---

③ 游戏思路&逻辑

1. 创建菜单函数选择 进入游戏 以及 退出游戏。
2. 首先，初始化 棋盘。
3. 然后，再打印棋盘。注意：一定是要先进行 初始化 然后再 打印棋盘。
4. 玩家下棋，并打印出棋盘（玩家输入行、列坐标方式进行落子，'x' = 玩家落子）
5. 判断玩家是否 赢，判断是否 继续游戏。(字符'c'代表 继续游戏、字符'q'代表 游戏平局)
6. 电脑进行落子下棋(随机位置进行落子，'o' = 电脑落子)
7. 判断③种胜负方式！分别是：玩家赢、电脑赢、以及 平局。
8. 然后，再回到步骤①，是否选择 进入游戏 以及 退出游戏。

④ 实现游戏步骤/过程

---

Ⅰ创建颜色函数

前景色颜色的对应值↓

注意：本代码用了很多的颜色函数。

0=黑色                8=灰色　　
1=蓝色                9=淡蓝色        十六进制        　　                        
2=绿色                10=淡绿色        A        　　
3=湖蓝色              11=淡浅绿色      B　
4=红色                12=淡红色        C　　
5=紫色                13=淡紫色        D        　　
6=黄色                14=淡黄色        E       　　
7=白色                15=亮白色        F

void color(short x) 
{
  if (x >= 0 && x <= 15)
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), x);   
  else
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}

使用颜色函数的好处实际上无非就是让程序运行看上去更加美观、鲜明，实际上没什么实际作用，这点是我们要知道的。 

这里的STD_OUTPUT_HANDLE需要引头文件#include<Windows.h>，才可以进行使用。

---

Ⅱ 菜单界面menu()

菜单界面函数实际上就像是我们的一个界面，就好比是游戏的界面目录，餐馆当中的菜单。一样的道理。这个是库函数就有的我们只需要直接引用下即可。示例代码如下↓ 

void menu()
{
  color(0);//Black 黑色
  system("cls");  //清屏.
  color(10);
  printf("|----------三子棋游戏------------|\n");
  printf("|********************************|\n");
  printf("|★★★★★★★★★★★★★★★★|\n");
  printf("|★★   1.开始  0.退出       ★★|\n");
  printf("|★★★★★★★★★★★★★★★★|\n");
  printf("|x = 玩家 -------------- o = 电脑|\n");
  printf("|--------------------------------|\n");
}

注→在这里用到了一个system("cls"); 达到了一个清屏的效果，只有加了这个，你才可以让cmd中的界面全部为黑色。因为我们还在这个清屏指令上＋color(0); 这个代表的是，黑色。 

---

Ⅲ 实现多子棋 

#define ROW 3    // 行
#define COL 3    // 列

使用 #define 宏定义在这里的好处：

1. 方便程序的修改，不用对整个程序进行修改，只需对宏定义上进行修改。
2. 提高程序的运行效率，更加方便模块化。
3. 在三子棋基础上，只需改变宏定义的值，就可以实现多子棋的效果。

假设：我们改成 4 行 4 列 的棋盘。 如????所示：  

---

Ⅳ 棋盘初始化步骤

数组最开始存放的是 空格，达到为打印棋盘做准备的一个初始化棋盘的实现。 

void Initialization(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] = ' ';
    }
  }
}

 实参数组名 行 可以进行省略，但是 列 不能进行省略。小写(row，col)是接收真实的长度。 

---

Ⅴ 打印棋盘格式实现步骤 

打印棋盘，本质上是打印数组的内容。如下所示????：  

void Interface(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)
    {
      for (j = 0; j < col; j++)
      {
        printf("═══");
        if (j < col-1)
        {
          printf("|");
        }
      }
      printf("\n");
    }
  }
  printf("\n");
}

打印棋盘的效果图，如????所示：  

---

Ⅵ 玩家下棋实现步骤

1. 这里的玩家输入坐标，在玩家输入下棋的时候，定义了个静态局部变量，在执行代码的时候。玩游戏的时候会提醒一次， 输入第一个坐标记得空一格！每次进入游戏只有一次，这里主要就是用到了 静态局部变量 就可以保证上一次的值不会被销毁。
2. 由于站在玩家的角度上来说，行&列通常都是以1为第一个的，而我们数组下标访问是从0开始的。所以，我们要从1行1列为第一个进行打印。在程序实现就把输入坐标的值 - 1。
3. 玩家落子需要在棋盘范围内，玩家要在棋盘上空的地方落子，如果输入的坐标不满足要重新输入。

• 'x' = 玩家落子。

void Player_play(char board[ROW][COL], int row, int col)
{
  printf("|--------|\n");
  printf("|玩家下棋|\n");
  printf("|--------|\n");
  while (1)
  {
    int x = 0;
    int y = 0;
    static int j = 1;//延长生明周期,
    while (j)
    {
      color(8);
      printf("--------------------------\n");
      printf("[输入第一个坐标记得空一格!]\n");
      printf("--------------------------\n");
      j--;
      break;
    }
    color(11);
    printf("<请输入坐标>:");
    scanf("%d %d", &x, &y);   
    //站在玩游戏的人角度:行以及列都是从1开始的。
    if (x >= 1 && x <= row && y >= 1 && y <= col)
    {
      //但是程序的实现过程是下标从0开始的。
      if (board[x - 1][y - 1] == ' ')
      {
        board[x - 1][y - 1] = 'x';
        break;
      }
      else
      {
        color(6);
        printf("|==============|\n");
        printf("|该坐标已被占用|\n");
        printf("|==============|\n");
      }
    }
    else
    {
      color(6);
      printf("|====================|\n");
      printf("|坐标非法，请重新输入|\n");
      printf("|====================|\n");
    }
  }
}

---

Ⅶ 电脑下棋实现步骤

1. srand((unsigned)time(NULL)); 要在主函数当中进行使用一次即可！
2. rand() 函数产生的随机数是伪随机数。
3. 这个电脑下的值是在棋盘随机下的，如果你要机智的电脑要可以写算法来跟玩家玩。

• 'o' = 电脑落子。

Ⅷ 判断游戏结果实现输赢

• 玩家赢了 —— ‘x’
• 电脑赢了 —— ‘o’
• 平局的话 —— ‘q’
• 游戏继续 —— ‘c’
• 注意：返回结果的值是字符,所以我们这里要用到字符串 char 来进行返回
• 思路：无非就是判断,行以及列和对角线相不相等,但是不能前面空格也相等。 

char Iswin(char board[ROW][COL], int row, int col)
{
  int a = 0;
  int b = 0;
  //判断三行
  for (a = 0; a < row; a++)
  {
    if (board[a][0] == board[a][1] && board[a][1] == board[a][2] && board[a][0] != ' ')
    {
      return board[a][0];//返回电脑赢,还是玩家赢。
    }
  }
  //判断三列
  for (b = 0; b < col; b++)
  {
    if (board[0][b] == board[1][b] && board[1][b] == board[2][b] && board[0][b] != ' ')
    {
      return board[1][b];
    }
  }
  //判断对角线
  if (board[0][0] == board[1][1] && board[0][0] == board[2][2] && board[0][0] != ' ')
  {
    return board[1][1];
  }
  if (board[0][2] == board[1][1] && board[0][2] == board[2][0] && board[0][2] != ' ')
  {
    return board[1][1];
  }
  //判断平局:其实就是看你的棋盘满了没有,当你棋盘的格子都下完了还没有结果的话,那么自然就是平局了。
  if (1 == Isfull(board, ROW, COL))
  {
    return 'q';
  }
  return 'c';
}

---

Ⅸ Isfull()函数的实现过程 

上述 判断游戏结果实现输赢 当中的函数 Isfull()，功能：判断是否平局。

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;//当棋盘满了的话,返回值1,也就是执行return 'q'(平局)
}

---

⑤ 结果演示

一、玩家胜利

二、电脑胜利 

三、游戏平局 

---

⑥ 模块化代码实现

1、test.c

测试游戏的逻辑。

#include"game.h"

void menu()
{
  color(0);//Black 黑色
  system("cls");  //清屏.
  color(10);
  printf("|----------三子棋游戏------------|\n");
  printf("|********************************|\n");
  printf("|★★★★★★★★★★★★★★★★|\n");
  printf("|★★   1.开始  0.退出       ★★|\n");
  printf("|★★★★★★★★★★★★★★★★|\n");
  printf("|x = 玩家 -------------- o = 电脑|\n");
  printf("|--------------------------------|\n");
}
void game()
{
  printf(" ---------\n");
  printf("|PLAY GAME|\n");
  printf(" ---------\n");
  printf("\n");
  //创建二维数组
  char board[ROW][COL] = { 0 };
  //初始化棋盘
  Initialization(board, ROW, COL);
  //打印棋盘
  Interface(board, ROW, COL);

  int ret = 0;
  while (1)
  {
    Player_play(board, ROW, COL);//玩家下棋
    Interface(board, ROW, COL);  //打印棋盘
    //判断玩家赢 游戏
    ret = Iswin(board, ROW, COL);

    if (ret != 'c')//判断是否游戏继续
    {
      break;     
    }
    Computer_play(board, ROW, COL);//电脑下棋
    Interface(board, ROW, COL);    //打印棋盘

    //判断电脑赢 游戏
    ret = Iswin(board, ROW, COL);

    if (ret != 'c')
    {
      break;     
    }
  }
  if (ret == 'x')
  {
    printf("玩家赢!\n");
    printf("|-----------------------|\n");
    printf("|休息5s嘟嘟嘟(/*·ω·)/|\n");
    printf("|-----------------------|\n");
    Sleep(5000);
  }
  else if (ret == 'o')
  {
    printf("电脑赢!\n");
    printf("|-----------------------|\n");
    printf("|休息5s嘟嘟嘟(/*·ω·)/|\n");
    printf("|-----------------------|\n");
    Sleep(5000);
  }
  else
  {
    printf("平局!\n");
    printf("|-----------------------|\n");
    printf("|休息5s嘟嘟嘟(/*·ω·)/|\n");
    printf("|-----------------------|\n");
    Sleep(5000);
  }
}
void test()
{
  int input = 0;
  do
  {
    menu();
    srand((unsigned int)time(NULL));
    color(5);
    printf("|════════════════|");
    printf("\n请输入上方的数字:");
    color(11);
    scanf("%d", &input);
    switch (input)
    {
    case 1:
      game();
      break;
    case 0:
      printf("|════════|");
      printf("|退出游戏|");
      printf("|════════|");
      break;
    default:
      printf("|═════════════════════════════|\n");
      printf("|由于你输入错误罚你5s不能玩(→_→)|\n");
      printf("|═════════════════════════════|\n");
      Sleep(5000);
    }
  } while (input);
}

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

2、game.h

关于游戏包含的函数声明，符号声明头文件的包含以及宏定义。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdlib.h>
#include<Windows.h>
#include<stdio.h>
//行 列
#define ROW 3
#define COL 3

void color(short x);
void Initialization(char board[ROW][COL], int row, int col);
void Interface(char board[ROW][COL], int row, int col);
void Player_play(char baord[ROW][COL], int row, int col);
void Computer_play(char board[ROW][COL], int row, int col);
char Iswin(char board[ROW][COL], int row, int col);

3、game.c 

游戏和相关函数实现。

#include"game.h"
//自定义函根据参数改变颜色 
void color(short x) 
{
  if (x >= 0 && x <= 15)//参数在0-15的范围颜色
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), x);  //只有一个参数，改变字体颜色 
  else//默认的颜色白色
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}
//棋盘初始化实现步骤
void Initialization(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] = ' ';
    }
  }
}
//打印棋盘格式实现步骤
void Interface(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)
    {
      for (j = 0; j < col; j++)
      {
        printf("═══");
        if (j < col-1)
        {
          printf("|");
        }
      }
      printf("\n");
    }
  }
  printf("\n");
}
//玩家下棋实现步骤
void Player_play(char board[ROW][COL], int row, int col)
{
  printf("|--------|\n");
  printf("|玩家下棋|\n");
  printf("|--------|\n");
  while (1)
  {
    int x = 0;
    int y = 0;
    static int j = 1;//延长生明周期,
    while (j)
    {
      color(8);
      printf("--------------------------\n");
      printf("[输入第一个坐标记得空一格!]\n");
      printf("--------------------------\n");
      j--;
      break;
    }
    color(11);
    printf("<请输入坐标>:");
    scanf("%d %d", &x, &y);   
    //站在完游戏的人角度:行以及列都是从1开始的。
    if (x >= 1 && x <= row && y >= 1 && y <= col)
    {
      //但是程序的实现过程是下标从0开始的。
      if (board[x - 1][y - 1] == ' ')
      {
        board[x - 1][y - 1] = 'x';
        break;
      }
      else
      {
        color(6);
        printf("|==============|\n");
        printf("|该坐标已被占用|\n");
        printf("|==============|\n");
      }
    }
    else
    {
      color(6);
      printf("|====================|\n");
      printf("|坐标非法，请重新输入|\n");
      printf("|====================|\n");
    }
  }
}
//电脑下棋实现步骤
void Computer_play(char board[ROW][COL], int row, int col)
{
  int x = 0;
  int y = 0;
  color(9);
  printf("电脑走/：>: \n");
  while (1)
  {
    x = rand() % row;
    y = rand() % col;
    if (board[x][y] == ' ')
    {
      board[x][y] = 'o';
      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;//不满,棋盘还有多余格子。
      }
    }
  }
  return 1;//当棋盘满了的话,返回值1,也就是执行return 'q'(平局)
}
//判断游戏结果的实现输赢
//玩家赢了 —— ‘x’
//电脑赢了 —— ‘o’
//平局的话 —— ‘q’
//游戏继续 —— ‘c’
//注意:返回结果的值是字符,所以我们这里要用到字符串char来进行返回
//思路:无非就是判断,行以及列和对角线相不相等,但是不能前面空格也相等。
char Iswin(char board[ROW][COL], int row, int col)
{
  int a = 0;
  int b = 0;
  //判断三行
  for (a = 0; a < row; a++)
  {
    if (board[a][0] == board[a][1] && board[a][1] == board[a][2] && board[a][0] != ' ')
    {
      return board[a][0];//返回电脑赢,还是玩家赢。
    }
  }
  //判断三列
  for (b = 0; b < col; b++)
  {
    if (board[0][b] == board[1][b] && board[1][b] == board[2][b] && board[0][b] != ' ')
    {
      return board[1][b];
    }
  }
  //判断对角线
  if (board[0][0] == board[1][1] && board[0][0] == board[2][2] && board[0][0] != ' ')
  {
    return board[1][1];
  }
  if (board[0][2] == board[1][1] && board[0][2] == board[2][0] && board[0][2] != ' ')
  {
    return board[1][1];
  }
  //判断平局:其实就是看你的棋盘满了没有,当你棋盘的格子都下完了还没有结果的话,那么自然就是平局了。
  if (1 == Isfull(board, ROW, COL))
  {
    return 'q';
  }
  return 'c';
}