首页 > 软件编程 > C语言 > 200行C语言代码实现简易三子棋游戏

200行C语言代码实现简易三子棋游戏

福牛 5月 13, 2023 13 0

-1

前言

三子棋应该是是我们最早接触到的棋类游戏，用C语言实现三子棋对初学者来说是一种不错的锻炼

编写三子棋只需要用到数组、函数和生成随机数的知识，所以比较适合成为编程学习者编写的第一个小游戏。

一.代码实现

第一部分是源码复制就可以使用，每一个自定义函数在第二部分设计思路中都有详细解释，结合代码实现和设计思路理解会有一个更好的效果

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <stdio.h>
  3. #include<time.h>
  4. #include<stdlib.h>
  5. #define ROW 3
  6. #define COL 3
  7. void reset(char arr[ROW][COL])//将棋盘arr[ROW][COL]数据赋值为空格
  8. {
  9.      for (int i = 0; i < ROW; i++)
  10.      {
  11.          for (int j = 0; j < COL; j++)
  12.          {
  13.              arr[i][j] = ‘ ‘;
  14.          }
  15.      }
  16. }
  17. void dis_play(char arr[ROW][COL])//打印棋盘
  18. {
  19.      for (int i = 0; i < ROW; i++)//for每一次进去，打印一行数组和一条分割线
  20.      { //数组行为:（空格）元素（空格）|（空格）元素（空格）|（空格）元素（空格）
  21.          //分割线为： – – – | – – – | – – –
  22.      for (int j = 0; j < COL; j++)//一行数组
  23.          {
  24.              printf(” %c “, arr[i][j]);
  25.              if (j < COL – 1)//为了美观，最后的“|”不打印
  26.              {
  27.                  printf(“|”);
  28.              }
  29.          }
  30.          printf(“\n”);
  31.          for (int k = 0; k < COL; k++)//一行分割线
  32.          {
  33.              printf(“—“);
  34.              if (k < COL – 1)//为了美观，最后的“|”不打印
  35.              {
  36.                  printf(“|”);
  37.              }
  38.          }
  39.          printf(“\n”);
  40.      }
  41. }
  42. void player_move(char arr[ROW][COL])//玩家下棋
  43. {
  44.      int row = 0, col = 0;
  45.      while (1)
  46.      {
  47.          printf(“玩家下棋，请输入坐标>:”);
  48.          scanf(“%d %d”, &row, &col);
  49.          if (arr[row – 1][col – 1] == ‘ ‘)//判断是否可以下棋
  50.          {
  51.              arr[row – 1][col – 1] = ‘*’;
  52.              break;
  53.          }
  54.          printf(“输入错误，请再次输入\n”);
  55.      }
  56. }
  57. void computer_move(char arr[ROW][COL])//电脑下棋
  58. {
  59.      int row = rand() % ROW;//生成行号
  60.      int col = rand() % COL;//生成列标
  61.      printf(“电脑下棋:>\n”);
  62.      while (1)
  63.      {
  64.          if (arr[row][col] == ‘ ‘)//判断是否可以下棋
  65.          {
  66.              arr[row][col] = ‘#’;
  67.              break;
  68.          }
  69.          row = rand() % ROW;
  70.          col = rand() % COL;
  71.      }
  72. }
  73. int is_full(char arr[ROW][COL])//用于在is_win（）中判断是否为平局
  74. {
  75.      for (int i = 0; i < ROW; i++)
  76.      {
  77.          for (int j = 0; j < COL; j++)
  78.          {
  79.              if (arr[i][j] == ‘ ‘)
  80.                  return 0;
  81.          }
  82.      }
  83.      return 1;
  84. }
  85. char is_win(char arr[ROW][COL])//三子棋胜利无非就三种情况：行相同、列相同和对角线相同。除开胜利还有平局
  86. {
  87.      for (int i = 0; i < ROW; i++)//判断行
  88.      {
  89.          if (arr[i][0] == arr[i][1] && arr[i][1] == arr[i][2] && arr[i][0] != ‘ ‘)
  90.              return arr[i][0];
  91.      }
  92.      for (int i = 0; i < COL; i++)//判断列
  93.      {
  94.          if (arr[0][i] == arr[1][i] && arr[1][i] == arr[2][i] && arr[0][i] != ‘ ‘)
  95.              return arr[0][i];
  96.      }
  97.      //判断对角线
  98.      if (arr[0][0] == arr[1][1] && arr[1][1] == arr[2][2] && arr[0][0] != ‘ ‘)
  99.          return arr[0][0];
  100.      if (arr[0][2] == arr[1][1] && arr[1][1] == arr[2][0] && arr[0][2] != ‘ ‘)
  101.          return arr[0][2];
  102.      //判断平局
  103.      if (is_full(arr))
  104.      {
  105.          return ‘q’;
  106.      }
  107.      //都不满足游戏继续运行 return ‘c’
  108.      return ‘c’;
  109. }
  110. void meau()
  111. {
  112.      printf(“——————\n”);
  113.      printf(“| 1.play |\n”);
  114.      printf(“|—————-|\n”);
  115.      printf(“| 0.exit |\n”);
  116.      printf(“——————\n”);
  117. }
  118. void game()
  119. {
  120.      char arr[ROW][COL];//初始化棋盘
  121.      char ch;
  122.      reset(arr);//将棋盘里每一个元素赋值为空格
  123.      dis_play(arr);
  124.      do
  125.      {
  126.          player_move(arr);
  127.          dis_play(arr);
  128.          ch=is_win(arr);
  129.          if (ch != ‘c’)
  130.          {
  131.              break;
  132.          }
  133.          computer_move(arr);
  134.          dis_play(arr);
  135.          ch=is_win(arr);
  136.          if (ch != ‘c’)
  137.          {
  138.              break;
  139.          }
  140.      } while (1);
  141.      switch (ch)//根据返回字符判断结果
  142.      {
  143.      case ‘#’:
  144.          printf(“电脑胜利\n”); break;
  145.      case ‘*’:
  146.          printf(“玩家胜利\n”); break;
  147.      case ‘q’:
  148.          printf(“平局\n”); break;
  149.      }
  150. }
  151. int main()
  152. {
  153.      srand((unsigned)time(NULL));
  154.      int input = 0;
  155.      do
  156.      {
  157.          meau();
  158.          scanf(“%d”, &input);
  159.          switch (input)
  160.          {
  161.          case 1 :
  162.              game(); break;
  163.          case 0 :
  164.              break;
  165.          default :
  166.              printf(“输入错误\n”);
  167. }
  168.      } while (input);
  169.      return 0;
  170. }

二.设计思路

main()函数搭建框架

1.main()函数搭建框架：像所有的电脑游戏一样，我们需要一个菜单，通过菜单选择进入游戏和退出游戏，当一盘游戏结束时可以再次选择进入或者退出，菜单用printf()打印就可以解决，循环的进入游戏用do while()循环就可以解决

实现代码如下

  1.      void meau()
  2.      {
  3.      printf(“——————\n”);
  4.      printf(“| 1.play |\n”);
  5.      printf(“|—————-|\n”);
  6.      printf(“| 0.exit |\n”);
  7.      printf(“——————\n”);
  8.      }
  9.      void game()
  10. {
  12. }
  13. int main()
  14. {
  16.  
  17.      int input = 0;
  18.      do
  19.      {
  20.          meau();
  21.          scanf(“%d”, &input);
  22.          switch (input)
  23.          {
  24.          case 1 :
  25.              game(); break;
  26.          case 0 :
  27.              break;
  28.          default :
  29.              printf(“输入错误\n”);
  30.          }
  31.      } while (input);
  33.      return 0;
  34. }

2.当我们进入case 1,运行game（）函数；首先我们需要一个容器来存放我们的游戏数据，此时创建字符二维数组arr[3][3]作为容器，玩家下的棋用“*”表示电脑用”#“表示。因为行和列都为3,后面经常要使用，我们对他进行宏定义一下

  1. #define ROW 3
  2. #define COL 3

dis_play( )函数

》.dis_play( )：我们下棋肯定需要棋盘来显示我们的数据，我们通过构造一个函数dis_play()将数组打印出来来实现这一功能

dis_play()的功能其实就是把arr[ROW][COL]以棋盘形式打印显示出来,需要借助一些特殊字符”|“和”_“辅助打印

  1. #define ROW 3 / 行：3
  2. #define COL 3 / 列：3
  3. void dis_play(char arr[ROW][COL])
  4. {
  5.      for (int i=0;i<ROW;i++) /for每一次进去，打印一行数组和一条分割线
  6.      {
  7.          for (int j = 0; j < COL; j++)//打印数组
  8.          {
  9.              printf(” %c “, arr[i][j]);
  10.              if (j < COL – 1)
  11.              {
  12.                  printf(“|”);
  13.              }
  15.          }
  16.          printf(“\n”);
  17.          for (int k = 0; k < COL; k++)//打印分割线
  18.          {
  19.              printf(“—“);
  20.              if (k < COL – 1)
  21.              {
  22.                  printf(“|”);
  23.              }
  25.          }
  26.          printf(“\n”);
  27.      }
  28. }

初步运行代码，打印棋盘：

-2

reset ( )函数

》reset ( ) ：我们下完一盘棋，还想下该怎么办？这时候我们构造一个函数reset()，将棋盘数组的每一个元素重置为空格

reset()函数，遍历数组，赋值为空格

  1. void reset( char arr[ROW][COL])
  2. {
  3.      for (int i = 0; i < ROW; i++)
  4.      {
  5.          for (int j = 0; j < COL; j++)
  6.          {
  7.              arr[i][j] = ‘ ‘;//赋值空格
  8.          }
  9.      }
  10. }

player_move( )函数

》player_move( )：玩家下棋，不能随便下，下过的地方不能下，我们构造一个player_move()函数完成这一功能

player_move( )函数功能其实就是为数组arr[ROW][COL]赋值，数组元素为空格的地方就是可以下棋的地方
输入坐标时，和我们程序员思维不同，正常人认为行是从1开始而不是从0开始，玩家输入的数据需要减1才能正常赋值

  1. void player_move(char arr[ROW][COL])
  2. {
  3.      int row = 0, col = 0;
  4.      while (1)
  5.      {
  6.          printf(“玩家下棋，请输入坐标>:”);
  7.          scanf(“%d %d”, &row, &col);
  8.          if (arr[row–1][col–1] == ‘ ‘)
  9.          {
  10.              arr[row–1][col–1] = ‘*’;
  11.              break;
  12.          }
  13.          printf(“输入错误，请再次输入\n”);
  14.      }
  15. }

玩家下棋

-3

computer_move()函数

》computre_move（）电脑下棋，为了更容易实现我们这里让他再棋盘上随机下，需要生成随机数的知识，我们需要构造一个函数

使用头文件#include<stdlib.h>中的rand()函数可以生成一个0~32767的伪随机数，但使用rand()前先要使用srand()设置伪随机数起点
起点只要写一次，我们将srand((unsigned)time(NULL))定义在主函数，此处是一种固定的写法，time（）函数需要引<time.h>头文件

将rand()%3即%ROW可以生产0、1、2这三个随机数，可以用来做数组的行号和列标

  1. int main()
  2. {
  3.      srand((unsigned)time(NULL));/设置起点的固定写法
  4.      int input = 0;
  5.      do
  6.      {
  7.          meau();
  8.          scanf(“%d”, &input);
  9.          switch (input)
  10.          {
  11.          case 1 :
  12.              game(); break;
  13.          case 0 :
  14.              break;
  15.          default :
  16.              printf(“输入错误\n”);
  17.          }
  18.      } while (input);
  19.      return 0;
  20. }
  21. void computer_move(char arr[ROW][COL])
  22. {
  23.      int row = rand() % ROW ;//利用随机数生成行号列标
  24.      int col = rand() % COL ;
  25.      printf(“电脑下棋:>\n”);
  26.      while (1)
  27.      {
  28.          if (arr[row][col] == ‘ ‘)//判断是否为空格
  29.          {
  30.              arr[row][col] = ‘#’;
  31.              break;
  32.          }
  33.          row = rand() % ROW;
  34.          col = rand() % COL;
  35.      }
  36. }

电脑下棋

-4

is_win()函数

》is_win()光下棋也不行，每当玩家或电脑下一步棋必须有东西来判断到底是玩家赢了还是电脑赢了还是平局还是继续，我们构造is_win()函数完成这一功能

is_win()函数功能最后是返回一个字符，电脑赢返回”#”,玩家赢返回”*“，平局返回”q“，以上情况都不符合就返回”c“(continue)
三子棋胜利无非就三种情况：行相同、列相同和对角线相同我们用for和if语句就可以判断
平局的情况其实就是棋盘满了，我们构造一个is_fuii（）函数，棋盘满了，该函数返回1否则返回0；

  1. int is_full(char arr[ROW][COL])
  2. {
  3.      for (int i = 0; i < ROW; i++)
  4.      {
  5.          for (int j = 0; j < COL; j++)
  6.          {
  7.              if (arr[i][j] == ‘ ‘)/棋盘还有空格则return 0
  8.                  return 0;
  9.          }
  10.      }
  11.      return 1;
  12. }
  13. char is_win(char arr[ROW][COL]) /is_win()函数
  14. {
  15.      for (int i = 0; i < ROW; i++)/判断是否有行相同
  16.      {
  17.          if (arr[i][0] == arr[i][1] && arr[i][1] == arr[i][2] && arr[i][0] != ‘ ‘)
  18. return arr[i][0];
  19.      }
  20.      for (int i = 0; i <COL; i++)/判断是否有列相同
  21.      {
  22.          if (arr[0][i] == arr[1][i] && arr[1][i] == arr[2][i] && arr[0][i] != ‘ ‘)
  23.              return arr[0][i];
  24.      }
  25.      /判断对角线是否相同
  26.      if (arr[0][0] == arr[1][1] && arr[1][1] == arr[2][2] && arr[0][0] != ‘ ‘)
  27.          return arr[0][0];
  28.      if (arr[0][2] == arr[1][1] && arr[1][1] == arr[2][0] && arr[0][2] != ‘ ‘)
  29.          return arr[0][2];
  30.      if (1==is_full(arr))/is_full()返回1则return ‘q‘
  31.      {
  32.          return ‘q‘;
  33.      }
  34.          return ‘c‘;/都不满足，return ‘c’
  35. }

总结

到此这篇关于200行C语言代码实现简易三子棋游戏的文章就介绍到这了,更多相关C语言三子棋游戏内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论