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

三子棋的代码实现（c语言）_让c语言自动下三子棋的代码

作者：Monodyee | 2024-03-14 11:08:29

赞

踩

让c语言自动下三子棋的代码

前言：

三子棋也就是大家经常说的井字棋，今天用代码实现一下井字棋。

首先井字棋需要有棋盘，玩家与电脑对战，还要有判断输赢的功能。最后实现的效果就像下面的

 图片一样。

将代码模块化

我们将代码分为三个模块，能让我们的代码看上去更加的整洁，在优化和调试起来也更加便利。

游戏菜单

 

 我们打算玩家玩完一局，不过瘾继续玩，所以设置了一个while循环，玩家输入0，会跳出循环。

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

 上面是菜单的函数，主要是为了让主函数更加的简练

  1.  
  2. int main()
  3. {
  4. 	int input=0;
  5.  
  6. 	do
  7. 	{
  8. 		menu();
  9. 		printf("请输入：>");
  10. 		scanf("%d", &input);
  11. 		switch (input)
  12. 		{
  13. 		case 1:
  14. 			printf("开始游戏\n");
  15. 			break;
  16. 		case 0:
  17. 			printf("退出游戏\n");
  18. 			break;
  19. 		default:
  20. 			printf("非法输入，请重新输入\n");
  21. 		}
  22.  
  23. 	} while(input);
  24. 	return 0;
  25. }

 

上图便是菜单的运行图片

 游戏代码的实现

首先游戏分出胜负的条件，不管横竖或者斜着，都要三个连起来，如下图所示：

 有了这个想法我们就去想办法敲代码

game函数

将game函数写进主函数里，输入 1，开始游戏

  1. switch (input)
  2. 		{
  3. 		case 1:
  4. 			printf("开始游戏\n");
  5. 			game();
  6. 			break;
  7. 		case 0:
  8. 			printf("退出游戏\n");
  9. 			break;
  10. 		default:
  11. 			printf("非法输入，请重新输入\n");
  12. 		}
棋盘的实现
  1. 	//为了让棋盘可变，我们在game.h定义二维数组的行和列
  2. char board[ROW ][COL] = { 0 };//ROW和COL在game.h中有定义

 注意define定义格式！！！

初始化棋盘

  1. //初始化棋盘       使其全部成为空格，初始化在game.c中完成
  2. 	Initboard(board, ROW, COL);

初始化棋盘自定义函数，函数的实现在game.c中完成

  1. void Initboard(char board[ROW][COL], int row, int col)
  2. {
  3. 	//将数组中的0，全部初始化位空格
  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. }

在game.h中写好声明

打印棋盘
  1. //打印棋盘
  2. 	Displayboard(board, ROW, COL);

函数在game.c中完成

  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.         int j = 0;
  7.         for (j = 0; j < col; j++)
  8.         {   //打印数据
  9.             printf(" %c ", board[i][j]);
  10.             if (j < col - 1)
  11.             {
  12.                 printf("|");
  13.             }
  14.         }
  15.         printf("\n");//换行
  16.         //打印分割行
  17.         if (i < row - 1)
  18.         {
  19.             for (int j = 0; j < col; j++)
  20.             {
  21.                 printf("---");
  22.                 if (j < col - 1)
  23.                 {
  24.                     printf("|");
  25.                 }
  26.             }
  27.             printf("\n");
  28.         }
  29.     }
  30. }

棋盘格式如图所示，再参考代码，慢慢体会。

玩家下棋

棋盘已经打印好了，那么接下来就到了下棋的时候了，可以选择让玩家先下棋，也可以让电脑先下棋，在这我就先让玩家下棋了。

  1. //玩家下棋
  2. 		Playermove(board, ROW, COL);

函数在game.c中实现

  1. void Playermove(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. 		printf("请输入：>");
  9. 		scanf("%d %d", &x, &y);
  10. 		//坐标合法化的判断
  11. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  12. 		{
  13. 			if (board[x-1][y-1] == ' ')
  14. 			{
  15. 				board[x-1][y-1] = '*';
  16. 				break;
  17. 			}
  18. 			else
  19. 				printf("坐标被占用，请重新输入：");
  20. 		}
  21. 		else
  22. 			printf("坐标非法，请重新输入");
  23.  
  24. 	}

上面的思想主要就是，玩家需要输入1-3之间的数字，并且输入的坐标的位置没有被占领，如果输入错误，请重新输入。

玩家下棋我用了‘*’，每次下完棋之后再打印一次棋盘

需要注意的一点是，程序是面向大众的，所以就不要奢求让大家明白数组下标是从0开始的，也就是我们让左上角的坐标为（1 ，1）

 

电脑下棋

电脑下棋，我用到了rand函数，也就是让电脑随即下。rand函数的使用大家可以去MSDN或者http://www.cplusplus.com中看一下使用方法。

rand函数使用前需要先使用srand函数，设置一下起始，为了保证数字的随机，我们又需要引用time函数，值得一提的是srand函数写在何位置需要结合代码需要。

  1.  
  2. 		//电脑下棋
  3. 		Computerboard(board, ROW, COL);

函数同样在game.c中完成

  1. void Computerboard(char board[ROW][COL], int row, int col)
  2. {
  3. 	//电脑随机下
  4. 	printf("电脑下棋\n");
  5. 	int x = 0;
  6. 	int y = 0;
  7. 	while (1)
  8. 	{
  9. 		x = rand() % row;
  10. 		y = rand() % col;//模以row和col是为了让随机值保持在0~2之间
  11. 		if (board[x][y] == ' ')
  12. 		{
  13. 			board[x][y] = '#';
  14. 			break;
  15. 		}
  16. 	}
  17. }

 srand函数如下，在test.c中。

  1. int main()
  2. {
  3. 	srand((unsigned int)time(NULL));//设计随机数起始的

电脑下棋之后再次打印棋盘

判断输赢

一局游戏只有以下四种状态 。

  1. //判断输赢
  2. ret=Iswin(board, ROW, COL);

 

  1. Iswin(char board[ROW][COL], int row, int col)
  2. {
  3. 	//行
  4. 	int i = 0;
  5. 	for (i = 0; i < row; i++)
  6. 	{
  7. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2]&&board[i][0]!=' ')
  8. 		{
  9. 			return board[i][0];
  10. 		}
  11. 	}
  12. 	//列
  13. 	int j = 0;
  14. 	for (j = 0; j < col; j++)
  15. 	{
  16. 		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[0][j] != ' ')
  17. 		{
  18. 			return board[0][j];
  19. 		}
  20. 	}
  21. 	//对角线
  22. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
  23. 	{
  24. 		return board[1][1];
  25. 	}
  26.  
  27. 	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
  28. 	{
  29. 		return board[1][1];
  30. 	}
  31. 	//都没赢，就平局，也就是棋盘满了
  32. 	if (IsFull(board, row, col))
  33. 	{
  34. 		return 'Q';
  35. 	}
  36. 	//游戏继续
  37. 	return 'C';
  38. }

 某一行某一列或者其中一个对角线被*或者#占满则是玩家或者电脑获胜

如果没有发现某一行，某一列或者对角线，并且棋盘满了，那就是平局，所以还需要判断棋盘是否满了

  1. IsFull(char board[ROW][COL], int row, int col)
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	for (i = 0; i < row; i++)
  6. 	{
  7. 		for (j = 0; j < col; j++)
  8. 		{
  9. 			if (board[i][j] == ' ')
  10. 			{
  11. 				return 0;
  12. 			}
  13. 		}
  14. 	}
  15. 	return 1;
  16. }

返回0则是没满，返回1就是满了，用if接收IsFull,若为真则返回Q，说明平局

若为0，则说明为假，不返回

  1. if (IsFull(board, row, col))
  2. 	{
  3. 		return 'Q';
  4. 	}

 在game函数中，每次玩家和电脑下完棋，就判断一次输赢，根据IsFull返回值判断输赢平局或者是否继续。判断输赢之后再次打印一下棋盘。

  1. while(1)
  2. 	{
  3. 		//玩家下棋
  4. 		Playermove(board, ROW, COL);
  5. 		ret=Iswin(board, ROW, COL);
  6. 		if (ret != 'C')
  7. 		{
  8. 			break;
  9. 		}
  10. 		//打印棋盘
  11. 		Displayboard(board, ROW, COL);
  12.  
  13. 		//电脑下棋
  14. 		Computerboard(board, ROW, COL);
  15. 		ret=Iswin(board, ROW, COL);
  16. 		if (ret != 'C')
  17. 		{
  18. 			break;
  19. 		}
  20.  
  21. 		//打印棋盘
  22. 		Displayboard(board, ROW, COL);
  23. 	}
  24. 	if (ret == '*')
  25. 		printf("玩家获胜\n");
  26. 	if (ret == '#')
  27. 		printf("电脑获胜\n");
  28. 	if (ret == 'Q')
  29. 		printf("平局\n");
  30. 	Displayboard(board, ROW, COL);
  31.  
  32. }

代码全貌

test.c
  1. #include"game.h"
  2. void menu()
  3. {
  4. 	printf("*****************************\n");
  5. 	printf("***** 1.play    0.exit  *****\n");
  6. 	printf("*****************************\n");
  7. }
  8. void game()
  9. {
  10. 	char ret = 0;
  11. 	//为了让棋盘可变，我们在game.h定义二维数组的行和列
  12. 	char board[ROW ][COL] = { 0 };//ROW和COL在game.h中有定义
  13. 	//初始化棋盘       使其全部成为空格，初始化在game.c中完成
  14. 	Initboard(board, ROW, COL);
  15. 	//打印棋盘
  16. 	Displayboard(board, ROW, COL);
  17. 	//开始下棋
  18. 	while(1)
  19. 	{
  20. 		//玩家下棋
  21. 		Playermove(board, ROW, COL);
  22. 		ret=Iswin(board, ROW, COL);
  23. 		if (ret != 'C')
  24. 		{
  25. 			break;
  26. 		}
  27. 		//打印棋盘
  28. 		Displayboard(board, ROW, COL);
  29.  
  30. 		//电脑下棋
  31. 		Computerboard(board, ROW, COL);
  32. 		ret=Iswin(board, ROW, COL);
  33. 		if (ret != 'C')
  34. 		{
  35. 			break;
  36. 		}
  37.  
  38. 		//打印棋盘
  39. 		Displayboard(board, ROW, COL);
  40. 	}
  41. 	if (ret == '*')
  42. 		printf("玩家获胜\n");
  43. 	if (ret == '#')
  44. 		printf("电脑获胜\n");
  45. 	if (ret == 'Q')
  46. 		printf("平局\n");
  47. 	Displayboard(board, ROW, COL);
  48.  
  49. }
  50. int main()
  51. {
  52. 	srand((unsigned int)time(NULL));//设计随机数起始的
  53.  
  54. 	int input=0;
  55.  
  56. 	do
  57. 	{
  58. 		menu();
  59. 		printf("请输入：>");
  60. 		scanf("%d", &input);
  61. 		switch (input)
  62. 		{
  63. 		case 1:
  64. 			printf("开始游戏\n");
  65. 			game();
  66. 			break;
  67. 		case 0:
  68. 			printf("退出游戏\n");
  69. 			break;
  70. 		default:
  71. 			printf("非法输入，请重新输入\n");
  72. 		}
  73.  
  74. 	} while(input);
  75. 	return 0;
  76. }
game.c
  1. #include "game.h"
  2. void Initboard(char board[ROW][COL], int row, int col)
  3. {
  4. 	//将数组中的0，全部初始化位空格
  5. 	int i = 0;
  6. 	int j = 0;
  7. 	for (i = 0; i < row; i++)
  8. 	{
  9. 		for (j = 0; j < col; j++)
  10. 		{
  11. 			board [i][j] = ' ';
  12. 		}
  13. 	}
  14. }
  15. void Displayboard(char board[ROW][COL], int row, int col) 
  16. {
  17. 	int i = 0;
  18. 	for (i = 0; i < row; i++)
  19. 	{
  20. 		int j = 0;
  21. 		for (j = 0; j < col; j++)
  22. 		{   //打印数据
  23. 			printf(" %c ", board[i][j]);
  24. 			if (j < col - 1)
  25. 			{
  26. 				printf("|");
  27. 			}
  28. 		}
  29. 		printf("\n");//换行
  30. 		//打印分割行
  31. 		if (i < row - 1)
  32. 		{
  33. 			for (int j = 0; j < col; j++)
  34. 			{
  35. 				printf("---");
  36. 				if (j < col - 1)
  37. 				{
  38. 					printf("|");
  39. 				}
  40. 			}
  41. 			printf("\n");
  42. 		}
  43. 	}
  44. }
  45. void Playermove(char board[ROW][COL], int row, int col)
  46. {
  47. 	int x = 0;
  48. 	int y = 0;
  49. 	printf("开始下棋：\n");
  50. 	while (1)
  51. 	{
  52. 		printf("请输入：>");
  53. 		scanf("%d %d", &x, &y);
  54. 		//坐标合法化的判断
  55. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  56. 		{
  57. 			if (board[x-1][y-1] == ' ')
  58. 			{
  59. 				board[x-1][y-1] = '*';
  60. 				break;
  61. 			}
  62. 			else
  63. 				printf("坐标被占用，请重新输入：");
  64. 		}
  65. 		else
  66. 			printf("坐标非法，请重新输入");
  67.  
  68. 	}
  69. }
  70. void Computerboard(char board[ROW][COL], int row, int col)
  71. {
  72. 	//电脑随机下
  73. 	printf("电脑下棋\n");
  74. 	int x = 0;
  75. 	int y = 0;
  76. 	while (1)
  77. 	{
  78. 		x = rand() % row;
  79. 		y = rand() % col;
  80. 		if (board[x][y] == ' ')
  81. 		{
  82. 			board[x][y] = '#';
  83. 			break;
  84. 		}
  85. 	}
  86. }
  87. IsFull(char board[ROW][COL], int row, int col)
  88. {
  89. 	int i = 0;
  90. 	int j = 0;
  91. 	for (i = 0; i < row; i++)
  92. 	{
  93. 		for (j = 0; j < col; j++)
  94. 		{
  95. 			if (board[i][j] == ' ')
  96. 			{
  97. 				return 0;
  98. 			}
  99. 		}
  100. 	}
  101. 	return 1;
  102. }
  103. //每次玩家和电脑下完棋之后都要判断是否游戏结束
  104. Iswin(char board[ROW][COL], int row, int col)
  105. {
  106. 	//行
  107. 	int i = 0;
  108. 	for (i = 0; i < row; i++)
  109. 	{
  110. 		if (board[i][0] == board[i][1] && board[i][1] == board[i][2]&&board[i][0]!=' ')
  111. 		{
  112. 			return board[i][0];
  113. 		}
  114. 	}
  115. 	//列
  116. 	int j = 0;
  117. 	for (j = 0; j < col; j++)
  118. 	{
  119. 		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[0][j] != ' ')
  120. 		{
  121. 			return board[0][j];
  122. 		}
  123. 	}
  124. 	//对角线
  125. 	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
  126. 	{
  127. 		return board[1][1];
  128. 	}
  129.  
  130. 	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
  131. 	{
  132. 		return board[1][1];
  133. 	}
  134. 	//都没赢，就平局，也就是棋盘满了
  135. 	if (IsFull(board, row, col))
  136. 	{
  137. 		return 'Q';
  138. 	}
  139. 	//游戏继续
  140. 	return 'C';
  141. }
game.h
  1. #pragma once
  2.  
  3. #include<stdio.h>
  4. #define ROW 3
  5. #define COL  3
  6. //初始化棋盘
  7. void Initboard(char board[ROW][COL], int row, int col);
  8. //打印棋盘
  9. void Displayboard(char board[ROW][COL], int row, int col);
  10. //玩家下棋
  11. void Playermove(char board[ROW][COL], int row, int col);
  12. //电脑下棋
  13. void Computerboard(char board[ROW][COL], int row, int col);
  14. //判断输赢
  15. Iswin(char board[ROW][COL], int row, int col);

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

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

  

闽ICP备14008679号