【C语言练习项目】三子棋

超过光速c

三子棋游戏！！
三个文件，先直接贴上来。

test_.c  文件的内容

1. /**
   
2. * @file test_.c
   
3. * @date 2021-08-24
   
4. *
   
5. * 三子棋
   
6. *
   
7. */
   
8. 
   
9. #include "game_3.h"
   
10. #include "game_3.c"
    
11. 
    
12. void menu(){
    
13.     printf("****************************************************************\n");
    
14.     printf("**************** 1.Play    0.exit  ******************\n");
    
15.     printf("****************************************************************\n");
    
16. 
    
17. }
    
18. 
    
19. // 游戏的整个算法实现
    
20. void game_3(){
    
21.     char ret;
    
22.     // 数组-存放走出的棋盘信息
    
23.     char board[ROW][COL] = {0};  // 全部空格，初始化一下棋盘，即初始化数组
    
24.     // 初始化棋盘
    
25.     InitBoard(board, ROW, COL);
    
26. 
    
27.     // 打印棋盘
    
28.     DisplayBoard(board, ROW, COL);
    
29. 
    
30.     //下棋
    
31.     while(1){
    
32.         // 玩家下棋
    
33.         PlayerMove(board, ROW, COL);
    
34.         DisplayBoard(board, ROW, COL);
    
35.         // 判断玩家是否赢
    
36.         ret = IsWin(board, ROW, COL);
    
37.         if(ret != 'C') {
    
38.             break;
    
39.         }
    
40.         // 电脑下棋
    
41.         ComputerMove(board, ROW, COL);
    
42.         DisplayBoard(board, ROW, COL);
    
43.         // 判断电脑是否赢
    
44.         ret = IsWin(board, ROW, COL);
    
45.         if(ret != 'C') {
    
46.             break;
    
47.         }
    
48.     }
    
49.     if (ret == '*')
    
50.     {
    
51.         printf("玩家赢了\n");
    
52.     }
    
53.     else if (ret == '#')
    
54.     {
    
55.         printf("电脑赢了\n");
    
56.     }
    
57.     else
    
58.     {
    
59.         printf("平局！\n");
    
60.     }
    
61. 
    
62. 
    
63. }
    
64. 
    
65. 
    
66. void test_(){
    
67.     int input=0;
    
68.     // 随机存储生成器
    
69.     srand((unsigned int)time(NULL));
    
70. 
    
71.     do{
    
72.         menu();
    
73.         printf("请选择 : >> ");
    
74.         scanf("%d",&input);
    
75.         switch(input){
    
76.             case 1:
    
77.                 game_3();
    
78.                 // printf("开始游戏！\n");
    
79.                 break;
    
80.             case 0:
    
81.                 printf("退出游戏！\n");
    
82.                 break;
    
83.             default:
    
84.                 printf("输入错误，请重新输入：");
    
85.                 break;
    
86.         }
    
87.     }while(input);
    
88. }
    
89. 
    
90. int main(){
    
91. 
    
92.     test_();
    
93. 
    
94.     printf("\n");
    
95.     return 0;
    
96. }

复制代码

game_3.c 文件内容

1. #include "game_3.h"
   
2. 
   
3. 
   
4. // 实现初始化
   
5. void InitBoard(char board[ROW][COL], int row, int col){
   
6.     int i=0;
   
7.     int j=0;
   
8.     for(i=0;i<row;i++){
   
9.         for(j=0;j<col;j++){
   
10.             board[i][j] = ' ';
    
11.         }
    
12.     }
    
13. 
    
14. }
    
15. 
    
16. // 实现打印棋盘
    
17. void DisplayBoard(char board[ROW][COL], int row, int col){
    
18.     int i = 0;
    
19.     int j = 0;
    
20.     for(i=0;i<row;i++){
    
21.         // 1.打印第一行数据
    
22.         for(j=0;j<col;j++){
    
23.             printf(" %c ",board[i][j]);
    
24.             if(j < col-1) printf("|");
    
25.         }
    
26.         printf("\n");
    
27.         // printf(" %c | %c | %c \n",board[i][0], board[i][1], board[i][2]);
    
28.         // 2.打印分割行
    
29. 
    
30.         if(i < row-1){
    
31.             for(j=0;j<col;j++){
    
32.             printf("---");
    
33.             if(j < col-1) printf("|");
    
34.             }
    
35. 
    
36.             printf("\n");
    
37.         }
    
38.             // printf("---|---|---\n");
    
39.     }
    
40. }
    
41. 
    
42. // 实现玩家下棋
    
43. void PlayerMove(char board[ROW][COL], int row, int col){
    
44.     int x=0, y=0;
    
45. 
    
46.     printf("玩家走：> \n");
    
47.     while(1){
    
48.         printf("请输入要下的坐标：>");
    
49.         scanf("%d%d",&x,&y);
    
50.         getchar();
    
51. 
    
52.         // 判断x和y输入的合法性
    
53.         if(x>=1 && x<=ROW && y>=1 && y<=COL){
    
54.             if(board[x-1][y-1] == ' '){
    
55.                 board[x-1][y-1] = '*';
    
56.                 break;
    
57.             }
    
58.             else{
    
59.                 printf("坐标被占用\n");
    
60.             }
    
61.         }
    
62.         else
    
63.         {
    
64.             printf("坐标非法，请重新输入！");
    
65.         }
    
66.     }
    
67. 
    
68. }
    
69. 
    
70. // 实现电脑下棋
    
71. void ComputerMove(char board[ROW][COL], int row, int col){
    
72.     int x=0;
    
73.     int y=0;
    
74.     printf("电脑走！\n");
    
75. 
    
76.     while(1){
    
77.         x = rand() % row;
    
78.         y = rand() % col;
    
79.         
    
80.         if(board[x][y] == ' '){
    
81.             board[x][y] = '#';
    
82.             break;
    
83.         }
    
84.     }
    
85. }
    
86. 
    
87. 
    
88. // 满了返回1，没满返回0
    
89. int IsFull(char board[ROW][COL], int row, int col)
    
90. {
    
91.     for(int j=0;j<row;j++)
    
92.     {
    
93.         for(int i=0;i<col;i++)
    
94.         {
    
95.             if(board[i][j] == ' ')
    
96.             {
    
97.                 return 0; // 没满
    
98.             }
    
99.         }
    
100.     }
     
101.     return 1; // 满了
     
102. }
     
103. 
     
104. // 实现判断输赢
     
105. char IsWin(char board[ROW][COL], int row, int col){
     
106.     // 判断行
     
107.     for(int i = 0; i < row; i++){
     
108.         if(board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
     
109.         {
     
110.             return board[i][1];
     
111.         }
     
112.     }
     
113. 
     
114.     // 判断列
     
115.     for(int i = 0; i < col; i++){
     
116.         if(board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
     
117.         {
     
118.             return board[1][i];
     
119.         }
     
120.     }
     
121. 
     
122.     // 判断交叉
     
123.     if(board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
     
124.     {
     
125.         return board[1][1];
     
126.     }
     
127.     if(board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
     
128.     {
     
129.         return board[1][1];
     
130.     }
     
131. 
     
132.     // 判断平局
     
133.     if(1 == IsFull(board, ROW, COL))
     
134.     {
     
135.         return 'Q';
     
136.     }
     
137.     return 'C';
     
138. }
     

复制代码

game_3.h 文件内容

1. #define ROW 3
   
2. #define COL 3
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <time.h>
   
7. 
   
8. // #include "game_3.c"
   
9. 
   
10. // 声明
    
11. void InitBoard(char board[ROW][COL], int row, int col);
    
12. void DisplayBoard(char board[ROW][COL], int row, int col);
    
13. void PlayerMove(char board[ROW][COL], int row, int col);
    
14. void ComputerMove(char board[ROW][COL], int row, int col);
    
15. 
    
16. 
    
17. // 告诉我门四种游戏状态，玩家赢 * 、电脑赢 #、平局 Q、继续 C
    
18. char IsWin(char board[ROW][COL], int row, int col);
    
19. 
    
20. 
    
21. /**
    
22. * 整体逻辑回顾
    
23. *
    
24. * 1、游戏便于循环玩，所以将所有操作包含在一个 do while 循环内
    
25. *  -- 先打印选择目录，用户选择输入 1开始游戏，0退出游戏（退出循环）
    
26. *  -- 对输入有一个检验，若输入错误则提示用户重新输入
    
27. * 2、游戏的操作
    
28. *  -- 用一个二维数组来存储棋盘
    
29. *  -- 初始化棋盘，再将棋盘打印出来。利用for循环将棋盘拆分成每一个单独的元素进行遍历打印，更加的灵活
    
30. *  -- 用户下棋：提示用户输入坐标，检验输入的坐标有效性，1、是否输入错误数值；2、输入坐标是否被占用。将坐标数组添加*号
    
31. *  -- 电脑下棋：使用随机数值，检验坐标是否被占用。将坐标数组添加#号       随机存储生成器不理解？
    
32. *  -- 每次走一步后将棋盘打印输出，观察走棋后的结果
    
33. * 3、判断输赢
    
34. *  -- 横、纵、交叉的坐标数组内相等，且任意一个坐标不等于‘ ’值（棋盘初始化为' '空值），就返回此前坐标数组内的符号，返回*则玩家赢，返回#则电脑赢
    
35. *  -- 检验棋盘空格数。循环遍历检验每一个坐标数组，若满则返回为平局，若未满则继续游戏
    
36. *
    
37. *
    
38. * 学得：
    
39. * C语言，随机存储生成器，随机数的使用
    
40. * rand() 函数包含于 <stdlib.h> 头文件中【random() 函数不是一个标准函数，无法再VC/VS等编译器通过。】
    
41. * rand() 会随机产生一个位于 0～RAND_MAX(至少是32767)之间的整数
    
42. * 伪随机数，根据电脑启动时而定，则不再变化。随机存储生成器：srand((unsigned)time(NULL))，根据时间进行随机产生新的数值
    
43. * 随机数的范围设定：
    
44. * rand() % 10 即 0～9
    
45. * rand() % 51 + 13 即 13～63。rand()%51 即0～50，+13则是 0+13～50+13 即 13～63
    
46. *
    
47. * 连续随机数的产生
    
48. * 用for循环产生的都是一样的随机数
    
49. * for(int i=0; i<10; i++)
    
50. * {
    
51. *      srand((unsigned)time(NULL));
    
52. *      a[i] = rand() % 100;
    
53. *      printf("%d", a[i]);
    
54. * }
    
55. *
    
56. *
    
57. * 关于头文件 #include "" 和 <> 的区别用法，调取其他文件的函数
    
58. * <> : 到库里面寻找头文件
    
59. * "" : 优先到当前目录下寻找，找不到再到库里面取找。尽量优先使用，减少寻找所占用的资源。
    
60. */

复制代码

效果是这样的：

yobdc

学习

burntlime

学习