黑白棋

最新推荐文章于 2022-05-07 11:07:52 发布
最新推荐文章于 2022-05-07 11:07:52 发布
阅读量1.2k 收藏 7
点赞数 2
分类专栏： Unity3D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18408937/article/details/42932957
版权

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

       黑白棋的棋盘是一个有8*8方格的棋盘。下棋时将棋下在空格中间，而不是像围棋一样下在交叉点上。开始时在棋盘正中有两白两黑四个棋子交叉放置，黑棋总是先下子。把自己颜色的棋子放在棋盘的空格上，而当自己放下的棋子在横、竖、斜八个方向内有一个自己的棋子，则被夹在中间的全部翻转会成为自己的棋子。并且，只有在可以翻转棋子的地方才可以下子。

 好了，知道了游戏规则我们如何去实现它呢？首先我们要去构建场景，也就是棋盘。我用64个Cube去创建（虽然很麻烦，但是可以控制Cube的高亮来提示玩家可以下的位置），一个Plane，以及四周的边框。棋子由两个Cylinder组成，一面黑一面白并设成预置物体。场景构建完毕，规则也了解了，接下来该实现了。首先要有一个虚拟棋盘去控制，我用了一个int型二维数组来表示，1表示黑棋 2表示白棋。一个gameobject型二维数组去存棋盘的64个Cube（实现提示），另一个gameobject型二维数组存棋子（控制反转）。高亮的棋盘玩家可以点击，没点击一次返回位置下的位置，在虚拟棋盘中去判断哪些棋子应该反转，之后更换玩家并在虚拟棋盘中计算可以下的位置，之后把这些Cube设成高亮，点击开关开启。这样循环下去，如果第一次没有找到可以下的位置，那么更换玩家，如果第二次没有找到则游戏结束，计算棋子数量决定胜负。

下面是初始化：

void Start ()
	{
		numberChessBoard1 [4, 4] = 1;
		numberChessBoard1 [5, 5] = 1;
		numberChessBoard1 [4, 5] = 2;
		numberChessBoard1 [5, 4] = 2;
		gameObjectChessPiece [4, 4] = c1;
		gameObjectChessPiece [5, 5] = c2;
		gameObjectChessPiece [4, 5] = c3;
		gameObjectChessPiece [5, 4] = c4;
		GameObject[] a = GameObject.FindGameObjectsWithTag ("Cube");
		for (int i = 0; i < 64; i++) {
			for (int j = 0; j < 64; j++) {
				Vector3 p = new Vector3 (-3.5f + (i / 8), -0.4f, 3.5f - (i % 8));
				if (Vector3.Distance (a [j].transform.position, p) < 0.5f) {
					gameObjectChessBoard [i / 8 + 1, i % 8 + 1] = a [j];
				}
			}
		}

	}
玩家的变更以及胜利的判定 

	//玩家变更及胜利判定
	void Win () {

		for (int k = 0; k < 3; k++) {
			alter++;
			//棋盘高亮		
			HighGreen (ref highGreen, numberChessBoard1, ref alter, player);
			
			if (alter == 1) {
				player = player % 2 + 1;
				GameObject.Find ("Text").GetComponent<GUIText>().text = "No way out,Players exchange";
			} else if (alter == 2) {
				int player1 = 0;
				int player2 = 0;
				for (int i = 0; i < 9; i++) {
					for (int j = 0; j < 9; j++) {
						if (numberChessBoard1 [i, j] == 1) {
							player1++;
						}
						if (numberChessBoard1 [i, j] == 2) {
							player2++;
						}
					}
				}
				if (player1 > player2) {
					GameObject.Find ("Text").GetComponent<GUIText>().text = "Black:" + player1 + "  White:" + player2 + "    Winer is black";
				} else if (player1 < player2) {
					GameObject.Find ("Text").GetComponent<GUIText>().text = "Black:" + player1 + "  White:" + player2 + "    Winer is white";
				} else {
					GameObject.Find ("Text").GetComponent<GUIText>().text = "equalize the score";
				}
				
			} else {
				break;
			}
		}
	}

棋盘是否高亮 需要对每一个棋子进行遍历，并依次判定其上、下、左、右、左上、左下、右上、右下 

	//棋盘高亮
	void HighGreen (ref int[,] highGreen, int[,] numberChessBoard1, ref int alter, int player)
	{
		for (int i = 1; i < 9; i++) {
			for (int j = 1; j < 9; j++) {
				if (numberChessBoard1 [i, j] == player) {
					
					//right
					for (int k = i - 1; k >= 1; k--) {
						if (numberChessBoard1 [k, j] == player) {
							break;
						} else if (numberChessBoard1 [k, j] == 0) {
							if (numberChessBoard1 [k + 1, j] == player % 2 + 1) {
								highGreen [k, j] = 1;
								alter = 0;
							}
							break;
						}
					}
					//left
					for (int k = i + 1; k <= 8; k++) {
						if (numberChessBoard1 [k, j] == player) {
							break;
						} else if (numberChessBoard1 [k, j] == 0) {
							if (numberChessBoard1 [k - 1, j] == player % 2 + 1) {
								highGreen [k, j] = 1;
								alter = 0;
							}
							break;
						}
					}
					//up
					for (int k = j + 1; k <= 8; k++) {
						if (numberChessBoard1 [i, k] == player) {
							break;
						} else if (numberChessBoard1 [i, k] == 0) {
							if (numberChessBoard1 [i, k - 1] == player % 2 + 1) {
								highGreen [i, k] = 1;
								alter = 0;
							}
							break;
						}
					}
					//down
					for (int k = j - 1; k >= 1; k--) {
						if (numberChessBoard1 [i, k] == player) {
							break;
						} else if (numberChessBoard1 [i, k] == 0) {
							if (numberChessBoard1 [i, k + 1] == player % 2 + 1) {
								highGreen [i, k] = 1;
								alter = 0;
							}
							break;
						}
					}
					//rightUp
					for (int k = i + 1; k <= 8; k++) {
						if (j - k + i <= 0 || j - k + i >= 9) {
							break;
						}
						if (numberChessBoard1 [k, j - k + i] == player) {
							break;
						} else if (numberChessBoard1 [k, j - k + i] == 0) {
							if (numberChessBoard1 [k - 1, j - k + i + 1] == player % 2 + 1) {
								highGreen [k, j - k + i] = 1;
								alter = 0;
							}
							break;
						}
					}
					//rightDown
					for (int k = i + 1; k <= 8; k++) {
						if (j - i + k <= 0 || j - i + k >= 9) {
							break;
						}
						if (numberChessBoard1 [k, j - i + k] == player) {
							break;
						} else if (numberChessBoard1 [k, j - i + k] == 0) {
							if (numberChessBoard1 [k - 1, j - i + k - 1] == player % 2 + 1) {
								highGreen [k, j - i + k] = 1;
								alter = 0;
							}
							break;
						}
					}
					//leftUp
					for (int k = i - 1; k > 0; k--) {
						if (j - i + k <= 0 || j - i + k >= 9) {
							break;
						}
						if (numberChessBoard1 [k, j - i + k] == player) {
							break;
						} else if (numberChessBoard1 [k, j - i + k] == 0) {
							if (numberChessBoard1 [k + 1, j - i + k + 1] == player % 2 + 1) {
								highGreen [k, j - i + k] = 1;
								alter = 0;
							}
							break;
						}
					}
					//leftUp
					for (int k = i - 1; k > 0; k--) {
						if (j - k + i <= 0 || j - k + i >= 9) {
							break;
						}
						if (numberChessBoard1 [k, j - k + i] == player) {
							break;
						} else if (numberChessBoard1 [k, j - k + i] == 0) {
							if (numberChessBoard1 [k + 1, j - k + i - 1] == player % 2 + 1) {
								highGreen [k, j - k + i] = 1;
								alter = 0;
							}
							break;
						}
					}
				}
			}
		}

		StartCoroutine ("ChessBoard");
	}

	//高亮延迟
	IEnumerator ChessBoard ()
	{
		yield return new WaitForSeconds (0.6f);
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (highGreen [i, j] == 1) {
					gameObjectChessBoard [i, j].GetComponent<Renderer> ().material = green;
					gameObjectChessBoard [i, j].GetComponent<Play> ().play = true;
					if (player != 2 || !ai) {
						highGreen [i, j] = 0;
					}
				}
			}
		}
		
	}

智能AI（其实谈不上智能啦，没写什么算法 知识单纯的随机而已 算法等有时间再写吧~） 

	//智能AI
	IEnumerator AiPlay () {
		yield return new WaitForSeconds (0.5f);
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (highGreen[i,j] == 1) {
					way.Add(i * 10 + j);
				}
			}
		}
		if (ai == true && player == 2) {
			int r = Random.Range(0,way.Count);
			gameObjectChessBoard [way[r] / 10,way[r] % 10].GetComponent<Play> ().aiPlay = true;
			m =  way[r] / 10;
			n = way[r] % 10;
			way.Clear();
		}
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				highGreen [i, j] = 0;
			}
		}
	}

更新虚拟棋盘 同样对返回的位置的 上、下、左、右、左上、左下、右上、右下进行判断 

	//更新虚拟棋盘
	void Renovate () {

		for (int k = m - 1; k >= 1; k--) {
			if (numberChessBoard1 [k, n] == 0) {
				break;
			} else if (numberChessBoard1 [k, n] == player % 2 + 1) {
				if (numberChessBoard1 [k + 1, n] == player) {
					for (int i = k + 1; i < m; i++) {
						numberChessBoard1 [i, n] = player % 2 + 1;
					}
				}
				break;
			}
		}
	
		for (int k = m + 1; k <= 8; k++) {
			if (numberChessBoard1 [k, n] == 0) {
				break;
			} else if (numberChessBoard1 [k, n] == player % 2 + 1) {
				if (numberChessBoard1 [k - 1, n] == player) {
					for (int i = k - 1; i > m; i--) {
						numberChessBoard1 [i, n] = player % 2 + 1;
					}
				}
				break;
			}
		}
		
		
		for (int k = n + 1; k <= 8; k++) {
			if (numberChessBoard1 [m, k] == 0) {
				break;
			} else if (numberChessBoard1 [m, k] == player % 2 + 1) {
				if (numberChessBoard1 [m, k - 1] == player) {
					for (int i = k - 1; i > n; i--) {
						numberChessBoard1 [m, i] = player % 2 + 1;
					}
				}
				break;
			}
		}
		
		
		for (int k = n - 1; k >= 1; k--) {
			if (numberChessBoard1 [m, k] == 0) {
				break;
			} else if (numberChessBoard1 [m, k] == player % 2 + 1) {
				if (numberChessBoard1 [m, k + 1] == player) {
					for (int i = k + 1; i < n; i++) {
						numberChessBoard1 [m, i] = player % 2 + 1;
					}
				}
				break;
			}
		}
		
		
		for (int k = m + 1; k <= 8; k++) {
			if (n - k + m <= 0 || n - k + m >= 9) {
				break;
			}
			if (numberChessBoard1 [k, n - k + m] == 0) {
				break;
			} else if (numberChessBoard1 [k, n - k + m] == player % 2 + 1) {
				if (numberChessBoard1 [k - 1, n - k + m + 1] == player) {
					for (int i = k - 1; i > m; i--) {
						numberChessBoard1 [i, n - i + m] = player % 2 + 1;
					}
				}
				break;
			}
		}
		
		
		for (int k = m + 1; k <= 8; k++) {
			if (n - m + k <= 0 || n - m + k >= 9) {
				break;
			}
			if (numberChessBoard1 [k, n - m + k] == 0) {
				break;
			} else if (numberChessBoard1 [k, n - m + k] == player % 2 + 1) {
				if (numberChessBoard1 [k - 1, n - m + k - 1] == player) {
					for (int i = k - 1; i > m; i--) {
						numberChessBoard1 [i, n - m + i] = player % 2 + 1;
					}
				}
				break;
			}
		}
		
		for (int k = m - 1; k > 0; k--) {
			if (n - m + k <= 0 || n - m + k >= 9) {
				break;
			}
			if (numberChessBoard1 [k, n - m + k] == 0) {
				break;
			} else if (numberChessBoard1 [k, n - m + k] == player % 2 + 1) {
				if (numberChessBoard1 [k + 1, n - m + k + 1] == player) {
					for (int i = k + 1; i < m; i++) {
						numberChessBoard1 [i, n - m + i] = player % 2 + 1;
					}
				}
				break;
			}
		}
		
		for (int k = m - 1; k > 0; k--) {
			if (n - k + m <= 0 || n - k + m >= 9) {
				break;
			}
			if (numberChessBoard1 [k, n - k + m] == 0) {
				break;
			} else if (numberChessBoard1 [k, n - k + m] == player % 2 + 1) {
				if (numberChessBoard1 [k + 1, n - k + m - 1] == player) {
					for (int i = k + 1; i < m; i++) {
						numberChessBoard1 [i, n - i + m] = player % 2 + 1;
					}
				}
				break;
			}
		}
	}

棋子的反转 

	//棋子翻转
	void Flip () {

		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (gameObjectChessPiece [j, i] != null && ((numberChessBoard1 [i, j] - 1) * 180 - gameObjectChessPiece [j, i].transform.eulerAngles.z > -10 && (numberChessBoard1 [i, j] - 1) * 180 - gameObjectChessPiece [j, i].transform.eulerAngles.z < 10)) {
					gameObjectChessPiece [j, i].GetComponent<Flip> ().flip = true;
				}
			}
		}
	}

以上方法在UpDate中调用即可 除此之外 棋盘的每个Cube上都有相同的脚本 

	void Update () {
		player = GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().player;
		gameObjectChessBoard = GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().gameObjectChessBoard;
		if (aiPlay) {
			Playing ();
			aiPlay = false;
		}

	}

	void OnMouseDown() {
		if (play && !aiPlay) {
			Playing();
		}
	}
	void Playing () {
		GameObject a = Instantiate(p,coordinate,Quaternion.Euler(180 * player,0,0)) as GameObject;
		GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().gameObjectChessPiece[n,m] = a;
		for (int i = 1; i < 9; i++) {
			for (int j = 1; j < 9; j++) {
				gameObjectChessBoard[i,j].GetComponent<Renderer>().material = blackGreen;
				gameObjectChessBoard[i,j].GetComponent<Play>().play = false;
			}
		}
		GameObject.Find ("Text").GetComponent<GUIText>().text = "";
		GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().m = m;
		GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().n = n;
		GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().numberChessBoard1[m,n] = player;
		GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().player = player % 2 + 1;
		GameObject.Find ("Script").GetComponent<BlackAndWhiteChess> ().play= true;
	}
}

棋子上会有反转简本 用一个bool变量控制。

注：棋子的数组好像定义反了0.0 懒得去改了就这样吧~ 

D子宇
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑白棋c语言 贪心AI
03-29
c语言实现黑白棋AI，贪心算法 字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数字数
简易黑白棋
08-28
一个魔方的简易模拟, 主要是设计数据结构相关的知识, swing 等等
2022年xtu程序设计实践3
qq_41739081的博客
05-07 1498
xtu程序设计实践3
[Python] 黑白棋（翻转棋）小游戏
BENULL的博客
05-22 4492
[Python] 黑白棋（翻转棋）小游戏 游戏介绍 黑白棋(Reversi or Othello)在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。 规则 黑白棋的每颗棋子由黑白两色组成，一面白，一面黑。每次落子，把本方颜色的棋子放在棋盘的空格上，若在横、竖、斜八个方向的任一方向上有本方棋子，则被夹在中间的对手棋子全部翻转为本方棋子颜色;并且仅在可以翻转棋 子的地方才能落子。如果一方至少有一步合法棋步可下，他就必须落子，不得弃权。 棋盘已满或双方都没有棋子可下时棋局结束，以棋
BlackAndWhiteChess
AlphaCat的博客
03-17 181
txt写的思路，未测试 public class BlackAndWhiteChess { int large=10; int unChessed=-1; int black=0; int white=1; public void playGame() { int[][] data=new int[large][large]; data=initialData(da...
xtu 1369 Black White Chess
weixin_45727188的博客
11-25 676
Black White Chess 题目描述 一个4×4的格子棋盘，每个格子上有白棋或者黑棋，我们可以做下面三种操作： 把同一行的棋子翻转（白变成黑，黑变成白） 把同一列的棋子翻转 把一个2×2的格子里的棋子翻转 求最少多少步操作，我们可以得到全部是黑的或者全部是白的棋局。 输入 第一行是一个整数T(1≤T≤100000)，表示样例的个数。 以后每行一个样例，每行是一个16位的二进制码，依次表示从第1行到第4行的棋局。 输出 每行输出一个样例的结果，如果无法达到目标，输出“-1”。 样例输入 5 00000
javascript人机博弈--黑白棋
jslang的专栏
07-01 5704
最近，在研究计算机人工智能中人机博弈的一些算法，用javascript写了个人机对战的 黑白棋 游戏。 放上来大家帮忙测试一下，看看棋力强度怎么样，有没有bug，走昏招之类的。 这程序主要在研究搜索算法，包括：alpha-beta算法，迭代加深搜索，历史启发，置换表和MTD(f)算法等。 程序中的估价函数，权重设置的不大理想，可能还需要改进，要是都没问题的话我会放出全
黑白棋剪枝版_黑白棋_
10-01
黑白棋游戏，当黑棋或者白棋占满整个棋盘，则占满棋盘的一方子获胜
16黑白棋_黑白棋源码_
09-29
黑白棋的源码，能人和机器对弈。分为工程文件、源码文件、窗体文件三个部分
黑白棋代码
06-08
在QT平台下实现黑白棋游戏，可进行人人对战，人机对战，并提供了网络对战的接口。
黑白棋（win32实现）
08-06
以黑白棋为例，做的一个win32的小游戏。 压缩包里是详细代码，项目是vs2010的，其他IDE请自行创建项目然后添加源文件。 详细介绍可以参考我的博客：http://blog.csdn.net/zilaishuichina/article/details/38235313 注：代码仅供学习交流使用，请勿用于其他用途。
java实现的黑白棋
04-06
自己实现的黑白棋！！
黑白棋 （python）
10-31
以前大一的作业，正好看见就上传给大家使用，就是可能算起来有点慢，希望不要介意
黑白棋小程序
06-27
基于QT编写的黑白棋小程序，拥有主界面，人对人游戏界面，人机游戏界面，游戏规则界面。资源包括程序发布文件，QT项目文档。
黑白棋游戏
06-27
基于Qt5.5.1的GUI小项目：黑白棋游戏（主要实现了吃子的算法逻辑以及简单的机器下子的算法逻辑）
黑白棋状态转换
cq947820606的博客
11-28 712
黑白棋（状态改变） 时限：1000ms内存限制：10000K总时限：3000ms 描述： 相信大家已经对黑白棋很熟悉了，下面我们来编写一个状态转移的模块。即当你下完一个子后，棋盘的状态会发成相应的改变，这里我们需要你输出棋盘改变后的状态。 输入： 对于本题，首先读入的是当前棋盘的状态，共8行，每行8个数字，1代表白棋，2代表黑棋,0代表为空格（未下子）。第9行有3
基于蒙特卡洛树搜索的黑白棋对弈python源码+数据集.zip
08-18
【资源说明】 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程...基于蒙特卡洛树搜索的黑白棋对弈python源码+数据集.zip
C++黑白棋游戏
03-15
内容索引:VC/C++源码,游戏编程,黑白棋　很不错的一款C++开发的黑白棋游戏，对游戏编程的朋友比较有用，可以作参考。
vs2019黑白棋盘
最新发布
12-25
黑白棋盘的对战过程中，玩家需要不断地分析局势，预测对手的下一步棋，同时制定自己的进攻和防守策略。通过不断地感受对局的变化和对手的思路，玩家可以提升自己的棋艺水平，从而在对局中取得更多的胜利。 在vs2019...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值