devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

设计三子棋游戏_三子琪游戏装置电子设计

作者：小桥流水78 | 2024-08-21 01:02:23

赞

踩

三子琪游戏装置电子设计

 

目录

 

一、三子棋游戏

二、游戏实现

1、具体实现说明

2、游戏效果展示

三、具体实现及部分代码

四、完整代码

 game.h部分

text.c部分

game.c部分

一、三子棋游戏

 游戏分为双方对战，双方依次在9宫格棋盘上摆放棋子，率先将自己的三个棋子连成一条线的一方则视为胜利者。

二、游戏实现

这里我们使用C语言进行三子棋的简单实现。三子棋简易棋盘可以抽象成二维数组的平面展示图，在基于二维数组之上，对输出的棋盘进行简单的装饰，优化其输出界面。 

1、具体实现说明

这里我们采用模块化设计

使用模块化设计可以提高代码质量和可靠性，同时也提高代码的可维护性和可升级性

这里我们分三个模块来实现三子棋游戏，分别为：

game.h             //游戏的声明

text.c                //用来测试游戏

game.c             //游戏的实现

1、在屏幕上打印一个游戏初始界面让玩家选择进行游戏或者退出游戏，并且通过循环语句让玩家达到可以重复多次玩游戏的效果

2、 使用函数将数组元素都初始化为空格

3、将棋盘打印出来

4、接受玩家的输入，将玩家下棋位置打印出来，判断胜负情况

5、电脑随机在棋盘上下棋，再将电脑下棋打印出来，判断胜负情况、

2、游戏效果展示

三、具体实现及部分代码

我们先设计一个游戏初始界面：

  1. void menu()
  2. {
  3. 	printf("|--------------------|\n");
  4. 	printf("|  ***  1:play  ***  |\n");
  5. 	printf("|  ***  0:exit  ***  |\n");
  6. 	printf("|--------------------|\n");
  7. }

在text.c文件中写入main()函数，在main()函数中调用text()函数用来实现三子棋游戏。将上面写的初始化界面函数写入text()函数中，且通过switch语句判断玩家输入是否正确

  1. void test()
  2. {
  3. 	int input = 0;
  4. 	do
  5. 	{
  6. 		menu();
  7. 		printf("请选择：");
  8. 		scanf("%d", &input);
  9. 		switch (input)
  10. 		{
  11. 		case 1:
  12. 			game();
  13. 			break;
  14. 		case 0:
  15. 			printf("退出三子棋程序！\n");
  16. 			break;
  17. 		default:
  18. 			printf("输入错误，请重新输入！\n");
  19. 			break;
  20. 		}
  21. 	} while (input);
  22. }

编写一个game()函数，game()函数里面即为三子棋的实现过程

  1. void game()
  2. {
  3. 	char board[ROW][COL] = { 0 }; 
  4. 	Initboard(board, ROW, COL);//初始化函数
  5.  
  6. 	Displayboard(board, ROW, COL);//打印棋盘
  7. 	char ret = 0;
  8. 	while (1)
  9. 	{
  10. 		Playermove(board, ROW, COL);//玩家下棋
  11. 		Displayboard(board, ROW, COL);//打印棋盘
  12. 		ret = Iswin(board, ROW, COL);//判断输赢，并用ret接受
  13. 		if (ret != 'C')
  14. 		{
  15. 			break;//这里的ret为判断输赢函数的返回值，C是自己设定的
  16. 			//在判断输赢函数中，返回C则继续下棋，返回Q则平局
  17. 			//返回 O 则电脑赢，返回 X 则玩家赢
  18. 			//不返回C说明游戏结束，则在下方判断具体结果
  19. 		}
  20.  
  21. 		Computermove(board, ROW, COL);//电脑下棋
  22. 		Displayboard(board, ROW, COL);//打印棋盘
  23. 		ret = Iswin(board, ROW, COL);//判断输赢，并用ret接受
  24. 		if (ret != 'C')
  25. 		{
  26. 			break;
  27. 		}
  28. 	}

首先使用函数将数组元素都初始化为空格

  1. //初始化函数，数组元素都初始化为空格
  2. void Initboard(char board[ROW][COL], int row, int col)
  3. {
  4. 	int i = 0;
  5. 	for (i = 0; i < row; i++)
  6. 	{
  7. 		int j = 0;
  8. 		for (j = 0; j < col; j++)
  9. 		{
  10. 			board[i][j] = ' ';
  11. 		}
  12. 	}
  13. }

接着我们下面的棋盘使用代码打印出来

代码如下：

  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. 		int j = 0;
  8. 		//打印数字行
  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. 			for (j = 0; j < col; j++)
  22. 			{
  23. 				printf("---");
  24. 				if (j < col - 1)
  25. 				{
  26. 					printf("|");
  27. 				}
  28. 			}
  29. 			printf("\n");
  30. 		}
  31. 	}
  32. }

接下来就是让玩家和电脑轮流输入想要下棋的位置，并且在每一步下棋之后判断胜负情况。        即将玩家和电脑下棋的位置上面的空格替换成分别代表玩家和电脑棋子的字符

玩家下棋：

  1. //玩家下棋
  2. void Playermove(char board[ROW][COL], int row, int col)
  3. {
  4. 	int x = 0;  
  5. 	int y = 0;  
  6. 	while (1)
  7. 	{
  8. 		printf("玩家下棋：\n");
  9. 		printf("请输入想要下棋的坐标：");
  10. 		scanf("%d %d", &x, &y);
  11. 		if (x >= 1 && x <= ROW && y >= 1 && y <= COL && board[x - 1][y - 1] == ' ') //坐标合法
  12. 		{
  13. 			board[x - 1][y - 1] = 'X';
  14. 			break;
  15. 		}
  16. 		else //坐标非法
  17. 		{
  18. 			printf("坐标错误，请重新输入！\n");
  19. 		}
  20. 	}
  21. }

 在玩家下棋的过程中需要判断即将要下棋的位置是否已经被使用过，若使用过则需要重新输入一个坐标

电脑下棋：

  1. //电脑下棋
  2. void Computermove(char board[ROW][COL], int row, int col)
  3. {
  4. 	int x = 0;//0~row-1
  5. 	int y = 0;//0~col-1
  6.  
  7. 	while (1)
  8. 	{
  9. 		x = rand() % row;//rand()  函数会随机生成0~32767之间的数字
  10. 		y = rand() % col;//rand()  %row和col即随机生成0~2，
  11. 		if (board[x][y] == ' ')
  12. 		{
  13. 			printf("电脑下棋：\n");
  14. 			board[x][y] = 'O';
  15. 			break;
  16. 		}
  17. 	}
  18. }

电脑下棋需使用rand函数，生成0~2的随机数字，即可以随机生成九宫格里面的坐标 

判断输赢部分

  1. //判断是否平局
  2. //下满棋盘返回1，未下满则返回0
  3. int Isfull(char board[ROW][COL], int row, int col)
  4. {
  5. 	int i = 0;
  6. 	for (i = 0; i < row; i++)
  7. 	{
  8. 		int j = 0;
  9. 		for (j = 0; j < col; j++)
  10. 		{
  11. 			if (board[i][j] == ' ')
  12. 			{
  13. 				return 0;
  14. 			}
  15. 		}
  16. 	}
  17. 	return 1;
  18. }
  19.  
  20. //判断输赢
  21. char Iswin(char board[ROW][COL], int row, int col)
  22. {
  23. 	int i = 0;
  24. 	//判断行
  25. 	for (i = 0; i < row; i++)
  26. 	{
  27. 		if (board[i][0] == board[i][1] && board[i][0] == board[i][2] && board[i][0] != ' ')
  28. 		{
  29. 			return board[i][0];
  30. 		}
  31. 	}
  32.  
  33. 	//判断列
  34. 	for (i = 0; i < col; i++)
  35. 	{
  36. 		if (board[0][i] == board[1][i] && board[0][i] == board[2][i] && board[0][i] != ' ')
  37. 		{
  38. 			return board[0][i];
  39. 		}
  40. 	}
  41.  
  42. 	//判断对角线
  43. 	if (board[0][0] == board[1][1] && board[0][0] == board[2][2] && board[0][0] != ' ')
  44. 	{
  45. 		return board[0][0];
  46. 	}
  47. 	if (board[0][2] == board[1][1] && board[0][2] == board[2][0] && board[0][2] != ' ')
  48. 	{
  49. 		return board[0][2];
  50. 	}
  51.  
  52. 	//判断是否平局
  53. 	if (Isfull(board, ROW, COL) == 1)
  54. 	{
  55. 		return 'Q';
  56. 	}
  57.  
  58. 	//若都不满足上方条件语句，则表示继续游戏
  59. 	return 'C';
  60. }

四、完整代码

 game.h部分

  1. #pragma once
  2.  
  3. #include <stdio.h>
  4. #include <time.h>
  5. #include <stdlib.h>
  6.  
  7. #define ROW 3//行
  8. #define COL 3//列
  9.  
  10.  
  11.  
  12. //初始化函数
  13. void Initboard(char board[ROW][COL], int row, int col);
  14.  
  15. //打印棋盘
  16. void Displayboard(char board[ROW][COL], int row, int col);
  17.  
  18. //玩家下棋
  19. void Playermove(char board[ROW][COL], int row, int col);
  20.  
  21. //电脑下棋
  22. void Computermove(char board[ROW][COL], int row, int col);
  23.  
  24. //判断输赢
  25. char Iswin(char board[ROW][COL], int row, int col);

text.c部分

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include <stdio.h>
  4. #include "game.h"
  5.  
  6. void menu()
  7. {
  8. 	printf("|--------------------|\n");
  9. 	printf("|  ***  1:play  ***  |\n");
  10. 	printf("|  ***  0:exit  ***  |\n");
  11. 	printf("|--------------------|\n");
  12. }
  13.  
  14. void game()
  15. {
  16. 	char board[ROW][COL] = { 0 }; 
  17. 	Initboard(board, ROW, COL);//初始化函数
  18.  
  19. 	Displayboard(board, ROW, COL);//打印棋盘
  20. 	char ret = 0;
  21. 	while (1)
  22. 	{
  23. 		Playermove(board, ROW, COL);//玩家下棋
  24. 		Displayboard(board, ROW, COL);//打印棋盘
  25. 		ret = Iswin(board, ROW, COL);//判断输赢，并用ret接受
  26. 		if (ret != 'C')
  27. 		{
  28. 			break;//这里的ret为判断输赢函数的返回值，C是自己设定的
  29. 			//在判断输赢函数中，返回C则继续下棋，返回Q则平局
  30. 			//返回 O 则电脑赢，返回 X 则玩家赢
  31. 			//不返回C说明游戏结束，则在下方判断具体结果
  32. 		}
  33.  
  34. 		Computermove(board, ROW, COL);//电脑下棋
  35. 		Displayboard(board, ROW, COL);//打印棋盘
  36. 		ret = Iswin(board, ROW, COL);//判断输赢，并用ret接受
  37. 		if (ret != 'C')
  38. 		{
  39. 			break;
  40. 		}
  41. 	}
  42.  
  43. 	if (ret == 'Q')
  44. 	{
  45. 		printf("平局！\n");
  46. 	}
  47.  
  48. 	if (ret == 'X')
  49. 	{
  50. 		printf("玩家赢！\n");
  51. 	}
  52.  
  53. 	if (ret == 'O')
  54. 	{
  55. 		printf("电脑赢！\n");
  56. 	}
  57. }
  58.  
  59.  
  60. void test()
  61. {
  62. 	int input = 0;
  63. 	do
  64. 	{
  65. 		menu();
  66. 		srand((unsigned int)time(NULL));
  67. 		printf("请选择：");
  68. 		scanf("%d", &input);
  69. 		switch (input)
  70. 		{
  71. 		case 1:
  72. 			game();
  73. 			break;
  74. 		case 0:
  75. 			printf("退出三子棋程序！\n");
  76. 			break;
  77. 		default:
  78. 			printf("输入错误，请重新输入！\n");
  79. 			break;
  80. 		}
  81. 	} while (input);
  82. }
  83.  
  84. int main()
  85. {
  86. 	test();
  87. 	return 0;
  88. }

game.c部分

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include "game.h"
  4.  
  5.  
  6. //初始化函数，数组元素都初始化为空格
  7. void Initboard(char board[ROW][COL], int row, int col)
  8. {
  9. 	int i = 0;
  10. 	for (i = 0; i < row; i++)
  11. 	{
  12. 		int j = 0;
  13. 		for (j = 0; j < col; j++)
  14. 		{
  15. 			board[i][j] = ' ';
  16. 		}
  17. 	}
  18. }
  19.  
  20. //打印棋盘
  21. void Displayboard(char board[ROW][COL], int row, int col)
  22. {
  23. 	int i = 0;
  24. 	for (i = 0; i < row; i++)
  25. 	{
  26. 		int j = 0;
  27. 		//打印数字行
  28. 		for (j = 0; j < col; j++)
  29. 		{
  30. 			printf(" %c ", board[i][j]);
  31. 			if (j < col - 1)
  32. 			{
  33. 				printf("|");
  34. 			}
  35. 		}
  36. 		printf("\n");
  37. 		//打印分隔行
  38. 		if (i < row - 1)
  39. 		{
  40. 			for (j = 0; j < col; j++)
  41. 			{
  42. 				printf("---");
  43. 				if (j < col - 1)
  44. 				{
  45. 					printf("|");
  46. 				}
  47. 			}
  48. 			printf("\n");
  49. 		}
  50. 	}
  51. }
  52.  
  53.  
  54. //玩家下棋
  55. void Playermove(char board[ROW][COL], int row, int col)
  56. {
  57. 	int x = 0;  
  58. 	int y = 0;  
  59. 	while (1)
  60. 	{
  61. 		printf("玩家下棋：\n");
  62. 		printf("请输入想要下棋的坐标：");
  63. 		scanf("%d %d", &x, &y);
  64. 		if (x >= 1 && x <= ROW && y >= 1 && y <= COL && board[x - 1][y - 1] == ' ') //坐标合法
  65. 		{
  66. 			board[x - 1][y - 1] = 'X';
  67. 			break;
  68. 		}
  69. 		else //坐标非法
  70. 		{
  71. 			printf("坐标错误，请重新输入！\n");
  72. 		}
  73. 	}
  74. }
  75.  
  76.  
  77.  
  78. //电脑下棋
  79. void Computermove(char board[ROW][COL], int row, int col)
  80. {
  81. 	int x = 0;//0~row-1
  82. 	int y = 0;//0~col-1
  83.  
  84. 	while (1)
  85. 	{
  86. 		x = rand() % row;//rand()  函数会随机生成0~32767之间的数字
  87. 		y = rand() % col;//rand()  %row和col即随机生成0~2，
  88. 		if (board[x][y] == ' ')
  89. 		{
  90. 			printf("电脑下棋：\n");
  91. 			board[x][y] = 'O';
  92. 			break;
  93. 		}
  94. 	}
  95. }
  96.  
  97. //判断是否平局
  98. //下满棋盘返回1，未下满则返回0
  99. int Isfull(char board[ROW][COL], int row, int col)
  100. {
  101. 	int i = 0;
  102. 	for (i = 0; i < row; i++)
  103. 	{
  104. 		int j = 0;
  105. 		for (j = 0; j < col; j++)
  106. 		{
  107. 			if (board[i][j] == ' ')
  108. 			{
  109. 				return 0;
  110. 			}
  111. 		}
  112. 	}
  113. 	return 1;
  114. }
  115.  
  116. //判断输赢
  117. char Iswin(char board[ROW][COL], int row, int col)
  118. {
  119. 	int i = 0;
  120. 	//判断行
  121. 	for (i = 0; i < row; i++)
  122. 	{
  123. 		if (board[i][0] == board[i][1] && board[i][0] == board[i][2] && board[i][0] != ' ')
  124. 		{
  125. 			return board[i][0];
  126. 		}
  127. 	}
  128.  
  129. 	//判断列
  130. 	for (i = 0; i < col; i++)
  131. 	{
  132. 		if (board[0][i] == board[1][i] && board[0][i] == board[2][i] && board[0][i] != ' ')
  133. 		{
  134. 			return board[0][i];
  135. 		}
  136. 	}
  137.  
  138. 	//判断对角线
  139. 	if (board[0][0] == board[1][1] && board[0][0] == board[2][2] && board[0][0] != ' ')
  140. 	{
  141. 		return board[0][0];
  142. 	}
  143. 	if (board[0][2] == board[1][1] && board[0][2] == board[2][0] && board[0][2] != ' ')
  144. 	{
  145. 		return board[0][2];
  146. 	}
  147.  
  148. 	//判断是否平局
  149. 	if (Isfull(board, ROW, COL) == 1)
  150. 	{
  151. 		return 'Q';
  152. 	}
  153.  
  154. 	//若都不满足上方条件语句，则表示继续游戏
  155. 	return 'C';
  156. }

以上就是三子棋函数的实现途径，如果诸位有什么不懂的地方，可以一起在评论区探讨解决

That's it.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/1009195
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号