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

黑白棋_黑白棋csdn

作者：笔触狂放9 | 2024-02-23 09:15:16

赞

踩

黑白棋csdn

目录

一，黑白棋 

二，游戏规则

三，局面记录

四，残局介绍

五，六空格残局

（1）

（2）

（3）

（4）

（5）

（6）

（7）

（8）

（9）

（10）

（11）

（12）

（13）

（14）

（15）

六，双人对战

七，人机对战

​​​​​​​

一，黑白棋 

黑白棋，又叫反棋、奥赛罗棋、苹果棋或翻转棋。黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。它的游戏规则简单，因此上手很容易，但是它的变化又非常复杂。有一种说法是：只需要几分钟学会它，却需要一生的时间去精通它。

二，​​​​​​​游戏规则

1，棋盘

黑白棋的棋盘是一个有8*8方格的棋盘。下棋时将棋下在空格中间，而不是像围棋一样下在交叉点上。开始时在棋盘正中有两白两黑四个棋子交叉放置，黑棋总是先下子。

2，落子

把自己颜色的棋子放在棋盘的空格上，而当自己放下的棋子在横、竖、斜八个方向内有一个自己的棋子，则被夹在中间的全部翻转会成为自己的棋子。夹住的位置上必须全部是对手的棋子，不能有空格。

一步棋可以在数个方向上翻棋，任何被夹住的棋子都必须被翻转过来，棋手无权选择不去翻某个棋子。除非至少翻转了对手的一个棋子，否则就不能落子。如果一方没有合法棋步，也就是说不管他下到哪里，都不能至少翻转对手的一个棋子，那他这一轮只能弃权，而由他的对手继续落子直到他有合法棋步可下。

3，胜负规则

如果一方至少有一步合法棋步可下，他就必须落子，不得弃权。棋局持续下去，直到棋盘填满或者双方都无合法棋步可下，棋子多的胜利，一样多就平局。

三，局面记录

我在玩黑白棋的时候，出现了一些比较有趣的局面：

四，残局介绍

apk下载：资源分享汇总_nameofcsdn的博客-CSDN博客

里面收录了很多残局，来源有：

首先给出残局，都是6个空格的。

比如：

而且都是黑方先走，而且轮到黑方走，而且最后黑方会胜利。

虽然没有明说，但是根据我的感觉，应该是每一步都不能下错，否则就会被AI干掉。

当然，有的时候一步有不止一个最佳选择，但是第一步应该不会。

我会指出应该下哪里，都是在电脑上面试过的，应该没错。

最后我会给出后面的截图，至于和历史上的真实局面是不是一样就不知道了。

五，六空格残局

（1）

现在黑方只能下B7、G2、H2

H1和H8肯定是白方的，黑方要想胜利，就必须得到H2-H7这6个格子。

这里面有涉及到轮空规则，就是说，B7这个地方只有黑方可以下，白方是没法下的。

所以，这一步应该黑方下G2

然后白方、黑方、白方、黑方分别下在H列，只剩下B7

这个时候，白方没法下，还是归黑方下，于是黑方就赢了。

（2）

B7、A8是白方的一大杀招，所以黑方应该抢B7，A8会被白方得到。

A7肯定是白方的，所以要保住A3-A6，黑方必须要得到A1、A2，B1会被白方得到。

为了使得白方下A7的时候获利少，必须在白方下了A7之后才能下A1

所以，这一步应该下A2

最后的结果是

（3）

和（2）一样，这6个位置的分配其实是明显的。

三个角落是黑方的，另外三个位置是白方的。

关键在于顺序，所以这一步黑方应该下A8

最后结果：

（4）

H7只有黑方可以下，在（1）里面的B7也是这样的。

所以H7肯定是留到最后下。

如果下B1的话，白方下A1，貌似不太好。

如果下A7的话，B7就变成了黑方无法下的地方了，肯定是不行的。

所以，这一步应该下B7

最后：

黑方下完B1之后还可以下H7，然后就赢了。

（5）

这一局，黑方应该抢夺H8，所以应该下H6

最后下A7就赢了

（6）

黑方要抢夺A1-A7以及A1-G1，所以第一步应该下A7

最后白方无子可下，轮到黑方下。

（7）

这个局面还是比较好分析的，A6和A7是白方无法下的，所以黑方应该控制好，最后连续2步下这里。

这一步只能下A1或者G1

为了使得最后一步白方被轮空，黑方可以多下一步，黑方D4、E3、F2需要全部获得

所以应该先下A1再下G1

最后就是这样，黑方下了A6之后还可以下A7，于是就胜利了。

（8）

这里的A8和B7都对白方非常重要，但是黑方这一步是没法下的。

所以说，要想在这2个位置能落下一字，这一步必须下H1

黑方下了H1之后，白方无法同时得到A8和B7，这一步反而2个位置都不下，下H8

H8对白方其实也很重要，但是黑方最开始是不可能下这个地方的，但是现在的话，白方必须先把H8得到了。

这一步，黑方很明显是下H2了

（9）

G8其实是白方无法下的地方，好好利用这一点就可以吃掉B8-G8

B7和G7白方如果下了，除非顶点已经被占了，否则黑方就可以吃掉对角线。

所以，这一步黑方应该下B7，然后白方会下G7

吃掉对角线，白方会下A8

到了这个时候，G7仍然是白方无法下的，所以黑方可以下2个子，然后胜利。

（10）

 A1是白方和黑方都无法下的，H1和H2是白方无法下的，虽然黑方可以下这2个地方，不过显然没什么好处。

所以黑方应该下B7，然后白方只能下G7

黑方这一步应该下H8，然后白方无子可下

黑方此时可以下H1和H2，显然应该下H1，然后白方只能下H2

最后黑方下A1，就胜利了。

（11）

这个局面非常有意思，6个格子都是白方无法下的地方。

无论黑方下哪里，白方都将有地方可以下。

但是，仔细思考的话可以发现，黑方是有办法让白方轮空的。

这一步黑方应该下A8，然后白方就只能下A7

只有下H8才能使白方轮空，而且H8对黑方本来就非常重要。

所以这一步黑方下H8。

现在，黑方下H6就胜利了。

如果下G7的话，反而被白方轮空了，结果自然是失败。

（12）

 A2-A7最后肯定是白方的，副对角线A8-H1是黑方的。

所以黑方这一步，不仅要考虑如何得到副对角线A8-H1，还要保住C7-E7

也就是说，要先等白方下了A7之后，黑方才能下A8

在这之前，黑方要先占领H1

H1这一步不能直接下，要先下G1或者H2，下完之后下一步就是下H1

所以，这一步应该下H5，否则如果直接下G1或者H2的话，就连H1都占领不了。

黑方下H5之后，白方只能下A7

因为要占领H1，所以只能下G1

黑方下H1之后，白方被轮空，黑方继续下A8就胜利了。

（13）

这个局面实在是非常有趣啊！

黑方可以下A2不能下A1，只有等白方下了A2之后才能下A1。

反过来，白方可以下A2不能下A1，只有等黑方下了A2之后才能下A1。

对于H1和G2，情况是一样的。

所以这一步黑方应该下H7，然后白方没法下H8，就只能下A2或者G2

这2种情况，结果其实是一样的。

最后一步白方被轮空。

（14）

为了保住第8行，这一步黑方当然应该下F8

黑方下了F8之后，白方可以下G8、B7、A7

下G8没什么意义，为了得到第7行，这一步白方应该下A7，因为下了A7之后黑方肯定是不会下B7的

黑方自然是不会下B7。

这一步有个诀窍，如果白方下B7之后，黑方再下G8就可以得到莫大的好处。

所以这一步应该下A8

这一步白方应该下B7，不然C7-F7就得不到了。

这里，黑方下G7就可以得到莫大的好处了。

最后白方只能下H8

黑方胜

（15）

首先，第1列肯定是黑方的，H列肯定是白方的。

所以，G1是黑方下，H1和H8是白方下，这毋庸置疑。

所以第一步只能下G7

这里白方肯定是下H8

如果黑方下G1的话，白方只要下G8黑方就无子可下，所以这里黑方只能下G8

最后结果：

黑方胜，33:31

六，双人对战

这一章，我介绍一下用c++写一个黑白棋游戏的时候，需要注意的几个难点。

我的这个代码只支持单机双人对战，所以双方必须在一起运行这个程序，交替利用键盘输入下棋的位置。

支持人机对战的代码在下一章，那里面还加入了一点新功能，而且指出了本章中代码的bug并且改正过来了。

游戏开始界面：

功能：提示双方棋子数，提示该睡下棋，提示并在棋盘中显示哪些位置可以下棋

容错性：输入的列不区分大小写，如果输入错误则重新输入

缺陷：不支持悔棋

开发黑白棋游戏要注意三种情况：

（1）如果甲方下棋之后乙方无法下棋，则甲方可以继续下棋。

也就是说，有的时候一方可以连续下很多步。

我的测试：

白方下完4A之后，还是该白方下：

测试通过

（2）如果棋盘还没下满，但是双方都无法下子，那么游戏结束

我的测试：

白方下8E之后游戏结束：

测试通过

（3）如果一方的棋子全部被吃掉，则游戏结束

我的测试：

黑方下1G之后：

测试通过

所有的代码都在一个cpp文件中，只有120行

完整代码：

  1. #include<iostream>
  2. #include <stdlib.h> 
  3. using namespace std;
  4.  
  5. int list[8][8] = { 0 };   //棋盘状态,1是黑子，2是白子，0是空的
  6. int p=1;	//现在该谁下，1是黑方，2是白方
  7. const int dr[8] = { 0, 0, 1, 1, 1, -1, -1, -1 },dc[8] = { 1, -1, 0, 1, -1, 0, 1, -1 };//8个方向向量
  8.  
  9. bool playOK(int r, int c, int dr, int dc)					//判断某个格子的某个方向能否下子
  10. {
  11. 	if (list[r][c] != 0)return false;
  12. 	int tr = r, tc = c;                  //tr和tc分别表示该点通过行和列往特定方向移动后的坐标
  13. 	while (tr + dr >= 0 && tr + dr < 8 && tc + dc >= 0 && tc + dc < 8 && list[tr + dr][tc + dc] == 3 - p)
  14. 	{		//循环遍历，未到达边界或者右边的棋子是对方的则循环继续，否则循环退出
  15. 		tr += dr, tc += dc;    //移动坐标
  16. 	}
  17. 	//若使循环退出的那一格里，是对方的棋子，则(r,c)可落子，否则不可落子
  18. 	if (tr == r && tc == c)return false;		//难点，这一句不可少
  19. 	if (tr + dr >= 0 && tr + dr < 8 && tc + dc >= 0 && tc + dc < 8 && list[tr + dr][tc + dc] == p)return true;
  20. 	return false;
  21. }
  22.  
  23. bool OK(int r, int c)					//判断某个格子能否下子
  24. {
  25. 	if (list[r][c])return false;
  26. 	for (int i = 0; i < 8; i++)  //只要一个方向满足可以下的条件，就可以下
  27. 		if (playOK(r, c, dr[i], dc[i]))return true;   //调用
  28. 	return false;
  29. }
  30.  
  31. int num(int k)  //统计棋子数目，1是黑子，2是白子
  32. {
  33. 	int s = 0;
  34. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (list[i][j] == k)s++;
  35. 	return s;
  36. }
  37.  
  38. void display()  //显示棋盘和棋子
  39. {
  40. 	system("cls");
  41. 	for (int i = 0; i < 8; i++)
  42. 	{
  43. 		if (!i)
  44. 		{
  45. 			cout << "    ";
  46. 			for (int j = 0; j < 8; j++)cout << char('A' + j) << "    ";
  47. 			cout << endl;
  48. 		}
  49. 		cout << i + 1 << "  ";
  50. 		for (int j = 0; j < 8; j++)
  51. 		{			
  52. 			if (list[i][j] == 2)cout << "○";else if (list[i][j] == 1)cout << "●";
  53. 			else if (OK(i, j))cout <<"？";else	cout << " .";    //调用
  54. 			cout << "   ";
  55. 		}
  56. 		cout << endl<<endl;
  57. 	}	
  58. 	cout << "黑方：" << num(1) << "      白方：" << num(2)<<"       轮到";  //调用
  59. 	if (p == 1)cout << "黑方下\n"; else cout << "白方下\n";
  60. 	cout << "候选项:";
  61. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (OK(i, j))    //调用
  62. 		cout << "  " << char('1' + i) << char('A' + j);
  63. }
  64.  
  65. void init()  //初始化
  66. {
  67. 	list[3][3] = list[4][4] = 2;
  68. 	list[3][4] = list[4][3] = 1;
  69. 	display();  //调用
  70. }
  71.  
  72. bool end_()  //判断游戏是否结束
  73. {
  74. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (OK(i, j))return false;   //调用
  75. 	p = 3 - p;			//改变p的2个地方之一
  76. 	display();         //难点，这一句不可少     //调用
  77. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (OK(i, j))return false;  //调用
  78. 	cout << "\n游戏结束\n";
  79. 	if (num(1) < num(2))cout << "白方胜利";
  80. 	else if (num(1)>num(2))cout << "黑方胜利";
  81. 	else cout << "平局";
  82. 	return true;
  83. }
  84.  
  85. void turn(int tr, int tc, int dr, int dc)  //吃子函数play()的一个方向
  86. {
  87. 	if (!playOK(tr, tc, dr, dc))return;  //难点，这一句不可少     //调用
  88. 	while (tr + dr >= 0 && tr + dr < 8 && tc + dc >= 0 && tc + dc < 8 && list[tr + dr][tc + dc] == 3 - p)
  89. 	{
  90. 		list[tr + dr][tc + dc] = p; //在该处换掉棋子的颜色
  91. 		tr += dr, tc += dc;
  92. 	}
  93. }
  94.  
  95. void play()		//落下一个子
  96. {
  97. 	cout << "\n输入行（1-8）和列（A-H）" << endl;
  98. 	char x, y;
  99. 	cin >> x >> y;
  100. 	int r = x - '1', c = y - 'a';
  101. 	if (y>'A' && y < 'Z')c = y - 'A';
  102. 	if (!OK(r, c))  //调用
  103. 	{
  104. 		cout << "ERROR!";
  105. 		return;		
  106. 	}
  107. 	for (int i = 0; i < 8; i++)turn(r, c, dr[i], dc[i]);
  108. 	list[r][c] = p;
  109. 	p = 3 - p;		//改变p的2个地方之一
  110. 	display();			//调用
  111. }
  112.  
  113. int main()
  114. {
  115. 	system("color f0");//白底黑字
  116. 	init();
  117. 	while (!end_())play();
  118. 	system("pause>nul");
  119. 	return 0;
  120. }

七，人机对战

在本章中，我加入了人机对战的功能，并完善了代码。

完整代码：

  1. #include "stdafx.h"
  2. #include<iostream>
  3. #include <stdlib.h> 
  4. #include<windows.h>
  5. using namespace std;
  6.  
  7. int list[8][8] = { 0 };   //棋盘状态,1是黑子，2是白子，0是空的
  8. int p = 1, aip = 0, air, aic, lastr = 0, lastc = 0;	//p是现在该谁下，1是黑方，2是白方
  9. int p1, p2, p3, p4, temp1[8][8], temp2[8][8], temp3[8][8], temp4[8][8];//4层博弈对应的AI分数和棋局
  10. const int dr[8] = { 0, 0, 1, 1, 1, -1, -1, -1 }, dc[8] = { 1, -1, 0, 1, -1, 0, 1, -1 };//8个方向向量
  11. int book[65]; //棋谱
  12. const int no = 1000;//AI的分数不可能达到的上界值
  13. const int prio[8][8] =
  14. {                       //prio是每个位置的优先级，数值越高越好
  15. 	{ 80, -20, 8, 6, 6, 8, -20, 80 },
  16. 	{ -20, -20, 0, -1, -1, 0, -20, -20 },
  17. 	{ 8, 0, 3, 5, 5, 3, 0, 8 },
  18. 	{ 6, -1, 5, 1, 1, 5, -1, 6 },
  19. 	{ 6, -1, 5, 1, 1, 5, -1, 6 },
  20. 	{ 8, 0, 3, 5, 5, 3, 0, 8 },
  21. 	{ -20, -20, 0, -1, -1, 0, -20, -20 },
  22. 	{ 80, -20, 8, 6, 6, 8, -20, 80 }
  23. };
  24.  
  25. bool playOK(int r, int c, int dr, int dc)					//判断某个格子的某个方向能否下子
  26. {
  27. 	if (list[r][c] != 0)return false;
  28. 	int tr = r, tc = c;                  //tr和tc分别表示该点通过行和列往特定方向移动后的坐标
  29. 	while (tr + dr >= 0 && tr + dr < 8 && tc + dc >= 0 && tc + dc < 8 && list[tr + dr][tc + dc] == 3 - p)
  30. 	{		//循环遍历，未到达边界或者右边的棋子是对方的则循环继续，否则循环退出
  31. 		tr += dr, tc += dc;    //移动坐标
  32. 	}
  33. 	//若使循环退出的那一格里，是对方的棋子，则(r,c)可落子，否则不可落子
  34. 	if (tr == r && tc == c)return false;		//难点，这一句不可少
  35. 	if (tr + dr >= 0 && tr + dr < 8 && tc + dc >= 0 && tc + dc < 8 && list[tr + dr][tc + dc] == p)return true;
  36. 	return false;
  37. }
  38.  
  39. bool OK(int r, int c)					//判断某个格子能否下子
  40. {
  41. 	if (list[r][c])return false;
  42. 	for (int i = 0; i < 8; i++)  //只要一个方向满足可以下的条件，就可以下
  43. 	if (playOK(r, c, dr[i], dc[i]))return true;   //调用
  44. 	return false;
  45. }
  46.  
  47. int num(int k)  //统计棋子数目，1是黑子，2是白子
  48. {
  49. 	int s = 0;
  50. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (list[i][j] == k)s++;
  51. 	return s;
  52. }
  53.  
  54. void display()  //显示棋盘和棋子
  55. {
  56. 	system("cls");
  57. 	for (int i = 0; i < 8; i++)
  58. 	{
  59. 		if (!i)
  60. 		{
  61. 			cout << "    ";
  62. 			for (int j = 0; j < 8; j++)cout << char('A' + j) << "    ";
  63. 			cout << endl;
  64. 		}
  65. 		cout << i + 1 << "  ";
  66. 		for (int j = 0; j < 8; j++)
  67. 		{
  68. 			if (list[i][j] == 2)cout << "○"; else if (list[i][j] == 1)cout << "●";
  69. 			else if (OK(i, j))cout << "？"; else	cout << " .";    //调用
  70. 			cout << "   ";
  71. 		}
  72. 		cout << endl << endl;
  73. 	}
  74. 	cout << "黑方：" << num(1) << "      白方：" << num(2) << "       轮到";  //调用
  75. 	if (p == 1)cout << "黑方下\n"; else cout << "白方下\n";
  76. 	cout << "候选项:";
  77. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (OK(i, j))    //调用
  78. 		cout << "  " << char('1' + i) << char('A' + j);
  79. 	cout << "\n最后一个落子位置是" << lastr + 1 << char(lastc + 'A');
  80. }
  81.  
  82. void init()  //初始化
  83. {
  84. 	list[3][3] = list[4][4] = 2;
  85. 	list[3][4] = list[4][3] = 1;
  86. 	while (aip != 1 && aip != 2 && aip != 3)
  87. 	{
  88. 		cout << "选择\n1，人机对战，AI先\n2，人机对战，玩家先\n3，双人对战\n";
  89. 		cin >> aip;
  90. 	}
  91. 	display();  //调用
  92. }
  93.  
  94. bool end_()  //判断游戏是否结束
  95. {
  96. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (OK(i, j))return false;   //调用
  97. 	p = 3 - p;			//改变p的2个地方之一
  98. 	for (int i = 0; i < 8; i++)for (int j = 0; j < 8; j++)if (OK(i, j))return false;  //调用
  99. 	display();
  100. 	cout << "\n游戏结束\n";
  101. 	if (num(1) < num(2))cout << "白方胜利";    //调用
  102. 	else if (num(1)>num(2))cout << "黑方胜利";    //调用
  103. 	else cout << "平局";
  104. 	return true;
  105. }
  106.  
  107.  
  108. void turn(int tr, int tc, int dr, int dc)  //吃子函数play()的一个方向
  109. {
  110. 	if (!playOK(tr, tc, dr, dc))return;  //难点，这一句不可少     //调用
  111. 	while (tr + dr >= 0 && tr + dr < 8 && tc + dc >= 0 && tc + dc < 8 && list[tr + dr][tc + dc] == 3 - p)
  112. 	{
  113. 		list[tr + dr][tc + dc] = p; //在该处换掉棋子的颜色
  114. 		tr += dr, tc += dc;
  115. 	}
  116. }
  117.  
  118. void play(int r, int c)
  119. {
  120. 	lastr = r, lastc = c;
  121. 	for (int i = 0; i < 8; i++)turn(r, c, dr[i], dc[i]);     //调用
  122. 	list[r][c] = p;
  123. 	book[num(1) + num(2)] = r * 8 + c;     //调用
  124. 	p = 3 - p;		//改变p的2个地方之一
  125. }
  126.  
  127. int getPoint()
  128. {
  129. 	int point = 0;
  130. 	for (int i1 = 0; i1<8; i1++)for (int j1 = 0; j1<8; j1++)
  131. 	{
  132. 		if (list[i1][j1] == aip)point += prio[i1][j1];   //若是ai的子，则加上该位置的积分
  133. 		if (list[i1][j1] == 3 - aip) point -= prio[i1][j1];   //若是玩家的子，则减去该位置的积分
  134. 	}
  135. 	return point;
  136. }
  137.  
  138. void AI3()//函数里面会改变p，但是调用函数不会改变p
  139. {
  140. 	p4 = no;
  141. 	for (int iiii = 0; iiii < 8; iiii++)for (int jjjj = 0; jjjj < 8; jjjj++)  //第四层
  142. 	{
  143. 		if (!OK(iiii, jjjj))continue;  //调用
  144. 		for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)temp4[i][j] = list[i][j];
  145. 		play(iiii, jjjj);//调用
  146. 		p = 3 - p;
  147. 		if (p4 > getPoint())p4 = getPoint();//调用
  148. 		for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)list[i][j] = temp4[i][j];
  149. 	}
  150. 	if (p4 == no)p4 = getPoint();  //调用
  151. 	if (p3 < p4)p3 = p4;
  152. }
  153. void AI2()//函数里面会改变p，但是调用函数不会改变p
  154. {
  155. 	p3 = -no;
  156. 	for (int iii = 0; iii < 8; iii++)for (int jjj = 0; jjj < 8; jjj++)  //第三层
  157. 	{
  158. 		if (!OK(iii, jjj))continue; //调用
  159. 		for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)temp3[i][j] = list[i][j];
  160. 		play(iii, jjj);//调用
  161. 		AI3();
  162. 		p = 3 - p;
  163. 		for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)list[i][j] = temp3[i][j];
  164. 	}
  165. 	if (p3 == -no)
  166. 	{
  167. 		p = 3 - p;
  168. 		AI3();
  169. 		p = 3 - p;
  170. 	}
  171. 	if (p2 > p3)p2 = p3;
  172. }
  173. void AI()  //函数里面会改变p，但是调用函数不会改变p
  174. {
  175. 	p1 = -no;
  176. 	for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)  //第一层
  177. 	{
  178. 		if (!OK(i, j))continue;   //调用
  179. 		for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)temp1[i][j] = list[i][j];
  180. 		play(i, j);//调用
  181. 		p2 = no;
  182. 		for (int ii = 0; ii < 8; ii++)for (int jj = 0; jj < 8; jj++)  //第二层
  183. 		{
  184. 			if (!OK(ii, jj))continue;   //调用
  185. 			for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)temp2[i][j] = list[i][j];
  186. 			play(ii, jj);//调用
  187. 			AI3();  //调用
  188. 			p = 3 - p;
  189. 			for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)list[i][j] = temp2[i][j];
  190. 		}
  191. 		if (p2 == no)
  192. 		{
  193. 			p = 3 - p;
  194. 			AI2();  //调用
  195. 			p = 3 - p;
  196. 		}
  197. 		if (p1 < p2)p1 = p2, air = i, aic = j;   //难点，如果调用AI函数却1次都没有执行这条语句，那么AI就会下错位置
  198. 		p = 3 - p;
  199. 		for (int i = 0; i<8; i++)for (int j = 0; j<8; j++)list[i][j] = temp1[i][j];
  200. 	}
  201. }
  202.  
  203. void go()		//落下一个子
  204. {
  205. 	display();			//调用
  206. 	if (p == aip)
  207. 	{
  208. 		AI();//调用
  209. 		play(air, aic);//调用
  210. 		Sleep(1000);
  211. 		return;
  212. 	}
  213. 	cout << "\n输入落子位置：行（1-8）和列（A-H）    输入00查看棋谱" << endl;
  214. 	char x, y;
  215. 	cin >> x >> y;
  216. 	if (x == '0')
  217. 	{
  218. 		for (int i = 5; i <= num(1) + num(2); i++)cout << "  " << book[i] / 8 + 1 << char(book[i] % 8 + 'A');
  219. 		cout << "\n按任意键退出";
  220. 		system("pause>nul");
  221. 		return;
  222. 	}
  223. 	int r = x - '1', c = y - 'a';
  224. 	if (y >= 'A' && y < 'Z')c = y - 'A';
  225. 	if (!OK(r, c))  //调用
  226. 	{
  227. 		cout << "ERROR!";
  228. 		return;
  229. 	}
  230. 	play(r, c);		//调用
  231. }
  232.  
  233. int main()
  234. {
  235. 	system("color f0");//白底黑字
  236. 	init();
  237. 	while (!end_())go();
  238. 	system("pause>nul");
  239. 	return 0;
  240. }

AI的算法是分析四层的博弈树，即考虑 AI-玩家-AI-玩家 轮流下完4步之后可能出现的所有情况。

对每个局面赋予一个值point，用来表示该局面对AI的有利程度，玩家总是尽量使得point小，而AI总是尽量使得point大。至于如何计算point，有一个专门完成该工作的函数getPoint()
计算的方法比较简陋，直接对每个格子赋予一个权值prio，然后用AI的所有格子权值之和减掉玩家的所有格子权值之和即可。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号