三子棋（C语言）

川长思鸟来 2023-10-09 23:52 34阅读 0赞

目录

1.代码结果演示

2.三子棋实现

2.1游戏思路

2.2分步实现

2.2.1分别创建头文件game.h、源文件game.c和test.c

2.2.2创建菜单并实现选择是否玩游戏

2.2.3创建棋盘并完成初始化

2.2.4打印棋盘

2.2.5玩家下棋

2.2.6电脑下棋

2.2.7判断输赢

3.完整代码

game.h

game.c

test.c

1.代码结果演示

84ff12ee143643d8ba3dfaf125fc692e.png

2.三子棋实现

2.1游戏思路

（1）创建菜单选择开始游戏或退出

（2）创建棋盘并完成初始化

（3）打印棋盘

（4）玩家下棋

（5）电脑自动下棋

（6）判断胜负

2.2分步实现

2.2.1分别创建头文件game.h、源文件game.c和test.c

b1112627ff274dd0ac4960d130e2d927.png

game.h ：用于存放自定义函数的声明、引用的标准库头文件等

game.c：用于存放函数的定义

test.c：用于程序测试

2.2.2创建菜单并实现选择是否玩游戏

首先创建菜单提供选项

  1. void menu()//打印菜单
  2. {
  3.     printf("***************************\n");
  4.     printf("*********1. play **********\n");
  5.     printf("*********0. exit **********\n");
  6.     printf("***************************\n");
  8. }

再在main函数中实现选择

  1. void menu()//打印菜单
  2. {
  3.     printf("***************************\n");
  4.     printf("*********1. play **********\n");
  5.     printf("*********0. exit **********\n");
  6.     printf("***************************\n");
  8. }
  11. int main()
  12. {
  13.     int input = 0;
  14.     while (1)
  15.     {
  16.         //打印菜单
  17.         menu();
  18.         printf("请选择:>");
  19.         scanf("%d", &input);
  20.         //判断选择，也可以使用switch
  21.         if (input == 1) 
  22.         {
  23.             printf("三子棋游戏现在开始!\n");
  24.             //game();//玩游戏
  25.         }
  26.         else if (input == 0)
  27.         {
  28.             printf("游戏结束\n");
  29.             break;//退出游戏
  30.         }
  31.         else
  32.         {
  33.             printf("选择错误，请重新选择\n");
  34.         }
  35.     }
  37.     return 0;
  38. }

测试结果

560c0e228d3742ddab535d34cd8fb15a.png

注：在函数实现的每一步都进行测试，能够及时找到错误并改正

2.2.3创建棋盘并完成初始化

在游戏开始时，棋盘上没有任何棋子，因此我们要对棋盘进行初始化，清空棋盘，保证后续游戏的进行

这里我们创建3*3大小的棋盘，对于数组行和列的大小，我们可以选择使用宏定义，若是想要修改行和列的大小，则只需要修改define定义的行列大小

  1. //在game.h中定义行和列的大小
  2. #define ROW 3
  3. #define COL 3

在game()函数中创建棋盘

  1. #inclide "game.h"//记得引自定义头文件
  3. void game()
  4. {
  5.     //创建二维数组用于存放下棋数据
  6.     char board[ROW][COL] = { 0 };
  7.     //初始化棋盘
  8.     InitBoard(board, ROW, COL);
  9. }

接下来我们实现初始化棋盘函数

  1. //初始化棋盘
  2. void InitBoard(char board[ROW][COL], int row, int col)
  3. {
  4.     for (int i = 0; i < row; i++)
  5.     {
  6.         for (int j = 0; j < col; j++)
  7.         {
  8.             board[i][j] = ' ';//将数组中所有元素初始化为空格
  9.         }
  10.     }
  11. }

注：在game.h中定义InitBoard函数，在game.c中实现InitBoard函数

调试结果

0bea819048044d01b8c0ae2d236fadd7.png

2.2.4打印棋盘

在实现棋盘的初始化后，我们要将已初始化的棋盘展现出来，以便玩家下棋

  1. //打印棋盘
  2. void DisplayBoard(char board[ROW][COL], int row, int col)
  3. {
  4.     for (int i = 0; i < row; i++)
  5.     {
  6.         for (int j = 0; j < col; j++)
  7.         {
  8.             printf(" %c ", board[i][j]);
  9.             if (j < col - 1)
  10.             {
  11.                 printf("|");//打印|以隔开相同行的不同棋子
  12.             }
  13.         }
  14.         printf("\n");
  16.         if (i < row - 1)//打印---|---以隔开不同行的棋子
  17.         {
  18.             for (int j = 0; j < col; j++)
  19.             {
  20.                 printf("---");
  21.                 if (j < col - 1)
  22.                 {
  23.                     printf("|");
  24.                 }
  25.             }
  26.             printf("\n");
  27.         }
  28.     }
  29. }

测试结果

6e4808a02d4644cc97b3d23255b2230a.png

2.2.5玩家下棋

在实现玩家下棋时，我们要先接收玩家输入的下棋位置

再判断输入的位置是否在棋盘范围内，是否已有棋子

最后将棋子放入对应位置

  1. //玩家下棋
  2. void PlayerMove(char board[ROW][COL], int row, int col)
  3. {
  5.     int x = 0;
  6.     int y = 0;
  7.     printf("玩家走:>\n");
  8.     while (1)
  9.     {
  10.         printf("请输入坐标（中间以空格隔开）:>");
  11.         scanf("%d %d", &x, &y);
  12.         if ((x > 0 && x <= ROW) && (y > 0 && y <= COL))
  13.         {
  14.             if (board[x - 1][y - 1] == ' ')
  15.             {
  16.                 board[x - 1][y - 1] = '*';
  17.                 break;
  18.             }
  19.             else
  20.             {
  21.                 printf("坐标已被占用，请重新输入!\n");
  22.             }
  23.         }
  24.         else
  25.         {
  26.             printf("输入坐标错误，请重新输入!\n");
  27.         }
  28.     }
  29. }

注：玩家下棋时默认棋盘位置是从1开始的，而不是0

运行结果

9eb988572b9d41b5ab2846079902ec62.png

2.2.6电脑下棋

在实现电脑自动下棋时，我们要生成随机数，并判断生成的坐标是否已有棋子

  1. void ComputerMove(char board[ROW][COL], int row, int col)
  2. {
  3.     int x = 0;
  4.     int y = 0;
  5.     printf("电脑下棋:>\n");
  6.     while (1)
  7.     {
  8.         //在使用rand()时，要引用对应头文件
  9.         //要使用srand((unsigned int)time(NULL))来进行初始化
  10.         x = rand() % row;
  11.         y = rand() % col;
  12.         if (board[x][y] == ' ')
  13.         {
  14.             board[x][y] = '#';
  15.             break;
  16.         }
  17.     }
  18. }

在game.h中引用头文件

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>

在main函数中使用srand

  1. int main()
  2. {
  3.     srand((unsigned int)time(NULL));
  4.     int input = 0;
  5.     while (1)
  6.     {
  7.         //打印菜单
  8.         menu();
  9.         printf("请选择:>");
  10.         scanf("%d", &input);
  11.         if (input == 1) 
  12.         {
  13.             printf("三子棋游戏现在开始!\n");
  14.             game();//玩游戏
  15.         }
  16.         else if (input == 0)
  17.         {
  18.             printf("游戏结束\n");
  19.             break;//退出游戏
  20.         }
  21.         else
  22.         {
  23.             printf("选择错误，请重新选择\n");
  24.         }
  25.     }
  27.     return 0;
  28. }

运行结果

faf712431e684b4094b9e763e179dd10.png

2.2.7判断输赢

在下棋过程中，我们要在玩家和电脑每一步下棋后判断是否有一方胜出，若没有且棋盘未满，则游戏继续

若玩家赢 -> 函数返回‘*’

若电脑赢 -> 返回’#‘

若平局 -> 返回‘Q’

游戏继续 - > 返回‘C’

  1. char IsWin(char board[ROW][COL], int row, int col)
  2. {
  3.     int i = 0;
  4.     int j = 0;
  5.     int flag = 1;
  7.     for (i = 0; i < row; i++)//判断行是否相等
  8.     {
  9.         flag = 1;
  10.         for (j = 0; j < col; j++)
  11.         {
  12.             if (board[i][j] != board[i][0] || board[i][j] == ' ')//一行的每一个元素是否相同
  13.             {
  14.                 flag = 0;
  15.                 break;
  16.             }
  17.         }
  18.         if (flag == 1)
  19.         {
  20.             return board[i][0];
  21.         }
  22.     }
  24.     for (j = 0; j < col; j++)//判断列是否相等
  25.     {
  26.         flag = 1;
  27.         for (i = 0; i < row; i++)//判断一列的元素是否相同
  28.         {
  29.             if (board[i][j] != board[0][j] || board[i][j] == ' ')
  30.             {
  31.                 flag = 0;
  32.                 break;
  33.             }
  34.         }
  35.         if (flag == 1)
  36.         {
  37.             return board[0][j];
  38.         }
  39.     }
  41.     flag = 1;
  42.     for (i = 0; i < row; i++)//主对角线元素是否相同
  43.     {
  44.         if (board[i][i] != board[0][0] || board[i][i] == ' ')
  45.         {
  46.             flag = 0;
  47.             break;
  48.         }
  49.     }
  50.     if (flag == 1)
  51.     {
  52.         return board[0][0];
  53.     }
  55.     flag = 1;
  56.     for (i = 0, j = col - 1; i < row; i++, j--)//判断副对角线元素是否相同
  57.     {
  58.         if (board[i][j] != board[0][col - 1] || board[i][j] == ' ')
  59.         {
  60.             flag = 0;
  61.             break;
  62.         }
  63.     }
  64.     if (flag == 1)
  65.     {
  66.         return board[0][col - 1];
  68.     }
  70.     //平局
  71.     for (int i = 0; i < row; i++)
  72.     {
  73.         for (int j = 0; j < col; j++)
  74.         {
  75.             if (board[i][j] == ' ')
  76.             {
  77.                 //还有未下棋的坐标，游戏继续
  78.                 return 'C';
  79.             }
  80.         }
  81.     }
  82.     return 'Q';
  83. }

在完成判断输赢函数后，我们在game()函数中实现循环，当一方胜出或平局时结束游戏

  1. void game()
  2. {
  3.     //二维数组用于存放下棋数据
  4.     char board[ROW][COL] = { 0 };
  5.     //初始化棋盘
  6.     InitBoard(board, ROW, COL);
  7.     //打印棋盘
  8.     DisplayBoard(board, ROW, COL);
  9.     char ret = 0;
  10.     while (1)
  11.     {
  12.         //玩家下棋
  13.         PlayerMove(board, ROW, COL);
  14.         //打印棋盘
  15.         DisplayBoard(board, ROW, COL);
  16.         //判断输赢
  17.         ret = IsWin(board, ROW, COL);
  18.         if (ret != 'C')
  19.         {
  20.             break;
  21.         }
  22.         //电脑下棋
  23.         ComputerMove(board, ROW, COL);
  24.         //打印棋盘
  25.         DisplayBoard(board, ROW, COL);
  26.         //判断输赢
  27.         ret = IsWin(board, ROW, COL);
  28.         if (ret != 'C')
  29.         {
  30.             break;
  31.         }
  32.     }

运行结果

d7fde226f2e44adfacd3c3c6e13c77ff.png

3.完整代码

game.h

  1. #pragma once
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <time.h>
  7. #define ROW 3
  8. #define COL 3
  10. void InitBoard(char board[ROW][COL], int row, int col);
  11. void DisplayBoard(char board[ROW][COL], int row, int col);
  12. void PlayerMove(char board[ROW][COL], int row, int col);
  13. char IsWin(char board[ROW][COL], int row, int col);
  14. void ComputerMove(char board[ROW][COL], int row, int col);

game.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  3. #include "game.h"
  5. //初始化棋盘
  6. void InitBoard(char board[ROW][COL], int row, int col)
  7. {
  8.     for (int i = 0; i < row; i++)
  9.     {
  10.         for (int j = 0; j < col; j++)
  11.         {
  12.             board[i][j] = ' ';
  13.         }
  14.     }
  15. }
  17. //打印棋盘
  18. void DisplayBoard(char board[ROW][COL], int row, int col)
  19. {
  20.     for (int i = 0; i < row; i++)
  21.     {
  22.         for (int j = 0; j < col; j++)
  23.         {
  24.             printf(" %c ", board[i][j]);
  25.             if (j < col - 1)
  26.             {
  27.                 printf("|");
  28.             }
  29.         }
  30.         printf("\n");
  32.         if (i < row - 1)
  33.         {
  34.             for (int j = 0; j < col; j++)
  35.             {
  36.                 printf("---");
  37.                 if (j < col - 1)
  38.                 {
  39.                     printf("|");
  40.                 }
  41.             }
  42.             printf("\n");
  43.         }
  44.     }
  45. }
  47. //玩家下棋
  48. void PlayerMove(char board[ROW][COL], int row, int col)
  49. {
  51.     int x = 0;
  52.     int y = 0;
  53.     printf("玩家下棋\n");
  54.     while (1)
  55.     {
  56.         printf("请输入坐标（中间以空格隔开）:>");
  57.         scanf("%d %d", &x, &y);
  58.         if ((x > 0 && x <= ROW) && (y > 0 && y <= COL))
  59.         {
  60.             if (board[x - 1][y - 1] == ' ')
  61.             {
  62.                 board[x - 1][y - 1] = '*';
  63.                 break;
  64.             }
  65.             else
  66.             {
  67.                 printf("坐标已被占用，请重新输入!\n");
  68.             }
  69.         }
  70.         else
  71.         {
  72.             printf("输入坐标错误，请重新输入!\n");
  73.         }
  74.     }
  75. }
  77. //判断输赢
  78. //玩家赢 -- 返回*
  79. //电脑赢 -- 返回#
  80. //平局   -- 返回Q
  81. //继续   -- 返回C
  82. char IsWin(char board[ROW][COL], int row, int col)
  83. {
  84.     int i = 0;
  85.     int j = 0;
  86.     int flag = 1;
  88.     for (i = 0; i < row; i++)//判断行是否相等
  89.     {
  90.         flag = 1;
  91.         for (j = 0; j < col; j++)
  92.         {
  93.             if (board[i][j] != board[i][0] || board[i][j] == ' ')//一行的每一个元素是否相同
  94.             {
  95.                 flag = 0;
  96.                 break;
  97.             }
  98.         }
  99.         if (flag == 1)
  100.         {
  101.             return board[i][0];
  102.         }
  103.     }
  105.     for (j = 0; j < col; j++)//判断列是否相等
  106.     {
  107.         flag = 1;
  108.         for (i = 0; i < row; i++)//判断一列的元素是否相同
  109.         {
  110.             if (board[i][j] != board[0][j] || board[i][j] == ' ')
  111.             {
  112.                 flag = 0;
  113.                 break;
  114.             }
  115.         }
  116.         if (flag == 1)
  117.         {
  118.             return board[0][j];
  119.         }
  120.     }
  122.     flag = 1;
  123.     for (i = 0; i < row; i++)//主对角线元素是否相同
  124.     {
  125.         if (board[i][i] != board[0][0] || board[i][i] == ' ')
  126.         {
  127.             flag = 0;
  128.             break;
  129.         }
  130.     }
  131.     if (flag == 1)
  132.     {
  133.         return board[0][0];
  134.     }
  136.     flag = 1;
  137.     for (i = 0, j = col - 1; i < row; i++, j--)//判断副对角线元素是否相同
  138.     {
  139.         if (board[i][j] != board[0][col - 1] || board[i][j] == ' ')
  140.         {
  141.             flag = 0;
  142.             break;
  143.         }
  144.     }
  145.     if (flag == 1)
  146.     {
  147.         return board[0][col - 1];
  149.     }
  151.     //平局
  152.     for (int i = 0; i < row; i++)
  153.     {
  154.         for (int j = 0; j < col; j++)
  155.         {
  156.             if (board[i][j] == ' ')
  157.             {
  158.                 //还有未下棋的坐标，游戏继续
  159.                 return 'C';
  160.             }
  161.         }
  162.     }
  163.     return 'Q';
  164. }
  166. //电脑下棋
  167. void ComputerMove(char board[ROW][COL], int row, int col)
  168. {
  169.     int x = 0;
  170.     int y = 0;
  171.     printf("电脑下棋:>\n");
  172.     while (1)
  173.     {
  174.         x = rand() % row;
  175.         y = rand() % col;
  176.         if (board[x][y] == ' ')
  177.         {
  178.             board[x][y] = '#';
  179.             break;
  180.         }
  181.     }
  182. }

test.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  3. #include "game.h"
  5. //打印菜单
  6. void menu()
  7. {
  8.     printf("***************************\n");
  9.     printf("*********1. play **********\n");
  10.     printf("*********0. exit **********\n");
  11.     printf("***************************\n");
  13. }
  15. void game()
  16. {
  17.     //二维数组用于存放下棋数据
  18.     char board[ROW][COL] = { 0 };
  19.     //初始化棋盘
  20.     InitBoard(board, ROW, COL);
  21.     //打印棋盘
  22.     DisplayBoard(board, ROW, COL);
  23.     char ret = 0;
  24.     while (1)
  25.     {
  26.         //玩家下棋
  27.         PlayerMove(board, ROW, COL);
  28.         //打印棋盘
  29.         DisplayBoard(board, ROW, COL);
  30.         //判断输赢
  31.         ret = IsWin(board, ROW, COL);
  32.         if (ret != 'C')
  33.         {
  34.             break;
  35.         }
  36.         //电脑下棋
  37.         ComputerMove(board, ROW, COL);
  38.         //打印棋盘
  39.         DisplayBoard(board, ROW, COL);
  40.         //判断输赢
  41.         ret = IsWin(board, ROW, COL);
  42.         if (ret != 'C')
  43.         {
  44.             break;
  45.         }
  46.     }
  48.     if (ret == '*')
  49.     {
  50.         printf("玩家赢!\n");
  51.     }
  52.     else if(ret == '#')
  53.     {
  54.         printf("电脑赢!\n");
  55.     }
  56.     else
  57.     {
  58.         printf("平局\n");
  59.     }
  61. }
  63. int main()
  64. {
  65.     srand((unsigned int)time(NULL));
  66.     int input = 0;
  67.     while (1)
  68.     {
  69.         //打印菜单
  70.         menu();
  71.         printf("请选择:>");
  72.         scanf("%d", &input);
  73.         if (input == 1) 
  74.         {
  75.             printf("三子棋游戏现在开始!\n");
  76.             game();//玩游戏
  77.         }
  78.         else if (input == 0)
  79.         {
  80.             printf("游戏结束\n");
  81.             break;//退出游戏
  82.         }
  83.         else
  84.         {
  85.             printf("选择错误，请重新选择\n");
  86.         }
  87.     }
  89.     return 0;
  90. }

发表评论

表情：
评论列表 （有 0 条评论，34人围观）

还没有评论，来说两句吧...

相关阅读