• 三子棋——C语言初阶

    一.游戏思路：

    1. 设计菜单，选择开始游戏(1)还是退出游戏(0)（若是输入数字不再输入范围内，则“选择错误”）
    2. 初始化棋盘
    3. 打印棋盘（步骤二和三不可调换位置）
    4. 玩家下棋（坐标落子）——判断输赢——打印棋盘（行 列）
    5. 电脑下棋（随机落子）——判断输赢——打印棋盘
    6. 游戏的三种状态：玩家赢（*），电脑赢（#），平局（‘Q’），继续（‘C’）
    7. 再回到步骤一（循环）

    二.具体步骤分解

    （1）.创建三个文件（模块化编程使代码更具有条理性）：       
    1. text_01.c：为测试游戏的文件，包含整个游戏的逻辑
    2. game.c：实现函数逻辑的文件
    3. game.h：为头文件，函数声明

                           

    （2）.设计菜单，实现菜单中的选择
    1. 选择1，开始游戏
    2. 选择0，退出游戏
    3. 选择其他的内容，打印“选择错误，请重新选择”；并给予重新选择的机会

    //打印菜单：

    1. menu()//设计菜单
    2. {
    3. 	printf("*******************************\n");
    4. 	printf("*******      1.play     *******\n");
    5. 	printf("*******      0.exit     *******\n");
    6. 	printf("*******************************\n");
    7. }

    //实现菜单运行的基本逻辑：

    1. int main()
    2. {
    3. 	srand((unsigned)time(NULL));//设置随机数的生成起点
    4. 	int input = 0;
    5. 	do 
    6. 	{
    7. 		menu();//打印菜单
    8. 		printf("请选择=>");
    9. 		scanf("%d", &input);
    10. 		switch (input)
    11. 		{
    12. 		case 1:
    13. 			game();
    14. 			break;
    15. 		case 0:
    16. 			printf("退出游戏！\n");
    17. 			break;
    18. 		default:
    19. 			printf("选择错误！请重新选择：\n");
    20. 			break;
    21. 		}
    22. 	} while (input);//非零即真
    23. 	return 0;
    24. }

    （3）.初始化棋盘

    //将棋盘当中的所有格子初始化为空格字符即可

    1. //初始化棋盘;
    2. void InitBoard(char board[ROW][COL], int row, int col)
    3. {
    4. 	int i = 0;
    5. 	int j = 0;
    6. 	for (i = 0; i < row; i++)
    7. 	{
    8. 		for (j = 0; j < col; j++)
    9. 		{
    10. 			board[i][j] = ' ';
    11. 		}
    12. 	}
    13. }

    （4）.打印棋盘

    //第一版：十分局限，只能打印三列

    1. void DisplayBoard(char board[ROW][COL], int row, int col)
    2. {
    3. 	int i = 0;
    4. 	for (i = 0; i < row; i++)
    5. 	{
    6. 		//打印数据
    7. 		printf(" %c | %c | %c \n",board[i][0],board[i][1],board[i][2]);
    8. 		//打印分割信息
    9. 		if (i < row - 1)
    10. 		{
    11. 			printf("---|---|---\n");
    12. 		}
    13. 	}
    14. }

    //第二版：可以打印任意行列的棋盘

    1. //打印棋盘（第二版）
    2. void DisplayBoard(char board[ROW][COL], int row, int col)
    3. {
    4. 	int i = 0;
    5. 	for (i = 0; i < row; i++)
    6. 	{
    7. 		//打印数据
    8. 		int j = 0;
    9. 		for (j = 0; j < col; j++)
    10. 		{
    11. 			printf(" %c ", board[i][j]);
    12. 			if (j < col-1)
    13. 			{
    14. 				printf("|");
    15. 			}
    16. 		}
    17. 		printf("\n");
    18. 		//打印分割信息
    19. 		if (i < row - 1)
    20. 		{
    21. 			int j = 0;
    22. 			for (j = 0; j < col ; j++)
    23. 			{
    24. 				printf("---");
    25. 				if (j < col - 1)
    26. 				{
    27. 					printf("|");
    28. 				}
    29. 			}
    30. 			printf("\n");
    31. 		}
    32. 	}
    33. }

    （5）.玩家下棋
    1. 输入坐标（范围是1~3），先行后列，从上到下，从左到右
    2. 判断坐标范围是否合法，若超出范围，则提示“坐标非法，请重新输入！！！”，并让其再次选择其他坐标
    3. 判断坐标是否被重复占用，若是被占用，则提示“坐标已被占用！！！，请选择其他位置”，并让其再次选择其他坐标

    见代码：

    1. //玩家下棋：
    2. void PlayerMove(char board[ROW][COL], int row, int col)
    3. {
    4. 	int x = 0;
    5. 	int y = 0;
    6. 	printf("玩家下棋=>\n");
    7. 	while (1)
    8. 	{
    9. 		printf("请输入坐标=>\n");
    10. 		scanf("%d %d", &x, &y);
    11. 		//判断坐标范围是否合法
    12. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    13. 		{
    14. 			//判断坐标是否被重复占用
    15. 			if (board[x - 1][y - 1] == ' ')
    16. 			{
    17. 				board[x - 1][y - 1] = '*';
    18. 				break;
    19. 			}
    20. 			else
    21. 			{
    22. 				printf("坐标已被占用！！！，请选择其他位置\n");
    23. 			}
    24. 		}
    25. 		else
    26. 		{
    27. 			printf("坐标非法，请重新输入！！！\n");
    28. 		}
    29. 	}
    30. }

    （6）.电脑下棋
    1. 找出空白的位置
    2. 随机下棋（rand用法，前面文章有详解）
    3. （后续可以再优化代码，让电脑变得更加聪明）

    见代码：

    1. //电脑下棋：（找空白的位置，随机下棋）
    2. void ComputerMove(char board[ROW][COL], int row, int col)
    3. {
    4. 	printf("电脑下棋=>\n");
    5. 	int x = 0;
    6. 	int y = 0;
    7. 	while (1)
    8. 	{
    9. 		x = rand() % row;//生成随机数,范围是0~2
    10. 		y = rand() % col;
    11. 		if (board[x][y] == ' ')
    12. 		{
    13. 			board[x][y] = '#';
    14. 			break;
    15. 		}
    16. 	}
    17. }

    （7）.判断输赢（看返回值）
    1. 玩家赢——'*'
    2. 电脑赢——'#'
    3. 平局——'Q'
    4. 继续——'C'

    //赢的情况：行，列，对角线三个相同的棋相连

    1. int i = 0;
    2. 	for (i = 0; i < row; i++)
    3. 	{
    4. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
    5. 		{
    6. 			return board[i][1];
    7. 		}
    8. 	}
    9.  
    10. 	//列
    11. 	int j = 0;
    12. 	for (j = 0; j < col; j++)
    13. 	{
    14. 		if (board[0][j] == board[1][j] && board[2][j] == board[1][j] && board[1][j] != ' ')
    15. 		{
    16. 			return board[1][j];
    17. 		}
    18. 	}
    19.  
    20. 	//对角线
    21. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
    22. 	{
    23. 		return board[1][1];
    24. 	}
    25. 	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != ' ')
    26. 	{
    27. 		return board[0][2];
    28. 	}

    //平局——判断棋盘是否下满（创建函数）

    1.  
    2. //判断棋盘是否已经排满（函数）
    3. int IsFull(char board[ROW][COL], int row, int col)
    4. {
    5. 	//如果满了返回1
    6. 	//不满返回0
    7. 	int i = 0;
    8. 	int j = 0;
    9. 	for (i = 0; i < row; i++)
    10. 	{
    11. 		for (j = 0; j < col; j++)
    12. 		{
    13. 			if (board[i][j] == ' ')
    14. 			{
    15. 				return 0;
    16. 			}
    17. 		}
    18. 	}
    19. 	return 1;
    20.  }

    三.三子棋简易全码：

    1. text_01.c： 
      1. #define _CRT_SECURE_NO_WARNINGS
      2. #include
      3. #include
      4. #include
      5. #include"game.h"
      6. menu()//设计菜单
      7. {
      8. 	printf("*******************************\n");
      9. 	printf("*******      1.play     *******\n");
      10. 	printf("*******      0.exit     *******\n");
      11. 	printf("*******************************\n");
      12. }
      13. void game()
      14. {
      15. 	char ret = '0';
      16. 	char board[][100] = { 0 };
      17. 	//初始化棋盘的函数
      18. 	InitBoard(board, ROW, COL);//行(row),列（col)
      19. 	DisplayBoard(board, ROW, COL);
      20. 	while (1)
      21. 	{
      22. 		PlayerMove(board, ROW, COL);
      23. 		//判断输赢：
      24. 		ret = IsWin(board, ROW, COL);
      25. 		if (ret != 'C')//说明游戏不再继续
      26. 		{
      27. 			break;
      28. 		}
      29. 		DisplayBoard(board, ROW, COL);
      30. 		ComputerMove(board, ROW, COL);
      31. 		//判断输赢：
      32. 		ret = IsWin(board, ROW, COL);
      33. 		if (ret != 'C')//说明游戏不再继续
      34. 		{
      35. 			break;
      36. 		}
      37. 		DisplayBoard(board, ROW, COL);
      38. 	}
      39. 	if (ret == '*')
      40. 	{
      41. 		printf("玩家胜利！！！\n");
      42. 	}
      43. 	else if (ret == '#')
      44. 	{
      45. 		printf("电脑胜利！！！\n");
      46. 	}
      47. 	else
      48. 	{
      49. 		printf("平局\n");
      50. 	}
      51. 	DisplayBoard(board, ROW, COL);
      52. }
      53. int main()
      54. {
      55. 	srand((unsigned)time(NULL));//设置随机数的生成起点
      56. 	int input = 0;
      57. 	do 
      58. 	{
      59. 		menu();//打印菜单
      60. 		printf("请选择=>");
      61. 		scanf("%d", &input);
      62. 		switch (input)
      63. 		{
      64. 		case 1:
      65. 			game();
      66. 			break;
      67. 		case 0:
      68. 			printf("退出游戏！\n");
      69. 			break;
      70. 		default:
      71. 			printf("选择错误！请重新选择：\n");
      72. 			break;
      73. 		}
      74. 	} while (input);
      75. 	return 0;
      76. }

    2. game.h： 
      1. #pragma once
      2. #define ROW 3
      3. #define COL 3
      4. //初始化棋盘;
      5. void InitBoard(char board[ROW][COL], int row, int col);
      6.  
      7. //打印棋盘：
      8. void DisplayBoard(char board[ROW][COL], int row, int col);
      9.  
      10. //玩家下棋：
      11. void PlayerMove(char board[ROW][COL], int row, int col);
      12.  
      13. //电脑下棋：
      14. void ComputerMove(char board[ROW][COL], int row, int col);
      15.  
      16. //判断输赢：
      17. char IsWin(char board[ROW][COL], int row, int col);

    3. game.c： 
      1. #define _CRT_SECURE_NO_WARNINGS
      2. #include
      3. #include
      4. #include
      5. #include"game.h"
      6. //初始化棋盘;
      7. void InitBoard(char board[ROW][COL], int row, int col)
      8. {
      9. 	int i = 0;
      10. 	int j = 0;
      11. 	for (i = 0; i < row; i++)
      12. 	{
      13. 		for (j = 0; j < col; j++)
      14. 		{
      15. 			board[i][j] = ' ';
      16. 		}
      17. 	}
      18. }
      19.  
      20.  
      21. //打印棋盘(第一版）
      22. // 十分局限，列数已经规定死了
      23. //void DisplayBoard(char board[ROW][COL], int row, int col)
      24. //{
      25. //	int i = 0;
      26. //	for (i = 0; i < row; i++)
      27. //	{
      28. //		//打印数据
      29. //		printf(" %c | %c | %c \n",board[i][0],board[i][1],board[i][2]);
      30. //		//打印分割信息
      31. //		if (i < row - 1)
      32. //		{
      33. //			printf("---|---|---\n");
      34. //		}
      35. //	}
      36. //}
      37.  
      38.  
      39. //打印棋盘（第二版）
      40. void DisplayBoard(char board[ROW][COL], int row, int col)
      41. {
      42. 	int i = 0;
      43. 	for (i = 0; i < row; i++)
      44. 	{
      45. 		//打印数据
      46. 		int j = 0;
      47. 		for (j = 0; j < col; j++)
      48. 		{
      49. 			printf(" %c ", board[i][j]);
      50. 			if (j < col-1)
      51. 			{
      52. 				printf("|");
      53. 			}
      54. 		}
      55. 		printf("\n");
      56. 		//打印分割信息
      57. 		if (i < row - 1)
      58. 		{
      59. 			int j = 0;
      60. 			for (j = 0; j < col ; j++)
      61. 			{
      62. 				printf("---");
      63. 				if (j < col - 1)
      64. 				{
      65. 					printf("|");
      66. 				}
      67. 			}
      68. 			printf("\n");
      69. 		}
      70. 	}
      71. }
      72.  
      73.  
      74. //玩家下棋：
      75. void PlayerMove(char board[ROW][COL], int row, int col)
      76. {
      77. 	int x = 0;
      78. 	int y = 0;
      79. 	printf("玩家下棋=>\n");
      80. 	while (1)
      81. 	{
      82. 		printf("请输入坐标=>\n");
      83. 		scanf("%d %d", &x, &y);
      84. 		//判断坐标范围是否合法
      85. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
      86. 		{
      87. 			//判断坐标是否被重复占用
      88. 			if (board[x - 1][y - 1] == ' ')
      89. 			{
      90. 				board[x - 1][y - 1] = '*';
      91. 				break;
      92. 			}
      93. 			else
      94. 			{
      95. 				printf("坐标已被占用！！！，请选择其他位置\n");
      96. 			}
      97. 		}
      98. 		else
      99. 		{
      100. 			printf("坐标非法，请重新输入！！！\n");
      101. 		}
      102. 	}
      103. }
      104.  
      105.  
      106. //电脑下棋：（找空白的位置，随机下棋）
      107. void ComputerMove(char board[ROW][COL], int row, int col)
      108. {
      109. 	printf("电脑下棋=>\n");
      110. 	int x = 0;
      111. 	int y = 0;
      112. 	while (1)
      113. 	{
      114. 		x = rand() % row;//生成随机数,范围是0~2
      115. 		y = rand() % col;
      116. 		if (board[x][y] == ' ')
      117. 		{
      118. 			board[x][y] = '#';
      119. 			break;
      120. 		}
      121. 	}
      122. }
      123.  
      124.  
      125. //判断棋盘是否已经排满（函数）
      126. int IsFull(char board[ROW][COL], int row, int col)
      127. {
      128. 	//如果满了返回1
      129. 	//不满返回0
      130. 	int i = 0;
      131. 	int j = 0;
      132. 	for (i = 0; i < row; i++)
      133. 	{
      134. 		for (j = 0; j < col; j++)
      135. 		{
      136. 			if (board[i][j] == ' ')
      137. 			{
      138. 				return 0;
      139. 			}
      140. 		}
      141. 	}
      142. 	return 1;
      143.  }
      144.  
      145. //判断输赢：
      146. //1.玩家赢——'*'
      147. //2.电脑赢——'#'
      148. //3.平局——'Q'
      149. //4.继续——'C'
      150. char IsWin(char board[ROW][COL], int row, int col)
      151. {
      152. 	//行
      153. 	int i = 0;
      154. 	for (i = 0; i < row; i++)
      155. 	{
      156. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
      157. 		{
      158. 			return board[i][1];
      159. 		}
      160. 	}
      161.  
      162. 	//列
      163. 	int j = 0;
      164. 	for (j = 0; j < col; j++)
      165. 	{
      166. 		if (board[0][j] == board[1][j] && board[2][j] == board[1][j] && board[1][j] != ' ')
      167. 		{
      168. 			return board[1][j];
      169. 		}
      170. 	}
      171.  
      172. 	//对角线
      173. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
      174. 	{
      175. 		return board[1][1];
      176. 	}
      177. 	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != ' ')
      178. 	{
      179. 		return board[0][2];
      180. 	}
      181. 	//没有人赢，就要判断平局,判断棋盘是否已经下满
      182. 	if (IsFull(board, row, col))
      183. 	{
      184. 		return 'Q';
      185. 	}
      186. 	//游戏继续
      187. 	return 'C';
      188. }

                            

  • 相关阅读:
    RocketMQ的介绍和环境搭建
    全网最全常用Linux命令合集
    都说自己是数据分析师，80%分析结果都是失败的，小心被裁了
    PHP 如何查看php函数源码
    systemverilog 过程控制语句
    【C++特殊类的设计】
    uCharts常用图表组件demo
    正则表达式和grep命令
    【js】日期控件的实现
    公园【百度之星】/图论+dijkstra
  • 原文地址：https://blog.csdn.net/qsl_81/article/details/134417740