“Network”游戏棋人机对弈的设计与实现（二）—判断步骤是否合法

最新推荐文章于 2023-09-23 23:44:32 发布
最新推荐文章于 2023-09-23 23:44:32 发布
阅读量795 收藏
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaobohello1987/article/details/46376165
版权

人机对弈之前，计算机首先需要具备能够判断双方所走的步骤是否合法的功能，这里使用棋盘类GameBoard来实现相关的功能。

首先将对弈的棋盘看成是一个8*8的二维数组，每一个单元格对应一个数组下标，并且单元格中存储该单元格中棋子的颜色。棋盘模型如图所示：


棋盘类的总体代码：

package gameboard;

public class GameBoard {
	 public final static int BLACK = -1;
	 public final static int WHITE = 1;
	 public final static int EMPTY = 0;
	 private int[][] gameBoard = new int[8][8];
	 private int blackNum,whiteNum;
	 public GameBoard(){
		 blackNum = 0;
		 whiteNum = 0;
		 for(int i = 0; i < gameBoard.length; i++){
			 for(int j = 0; j < gameBoard[0].length; j++){
				 gameBoard[i][j] = EMPTY;
			 }
		 }
	 }
	 //将棋盘指定格子设置成指定颜色
	 public void setBoard(int x, int y, int color){
		 gameBoard[x][y] = color;
		 if(color == BLACK && blackNum < 10){
			 blackNum++;
		 }else if(color == WHITE && whiteNum < 10){
			 whiteNum++;
		 }
	 }
	 public int getGameBoard(int hIndex, int vIndex){
		 return gameBoard[hIndex][vIndex];
	 }
	 //判断步骤是否合法
	 public boolean isLeagleMove(int hIndex, int vIndex, int color){
		 boolean isLeagle = true;
		 //与该棋子（x,y）相邻棋子的个数
		 int adjacentNumber = 0;
		 int adjacentHIndex = -1;
		 int adjacentVIndex = -1;
		 //查看位置是否被占用以及黑白的goal area
		 if(gameBoard[hIndex][vIndex] != 0 || 
				 (color == WHITE && (vIndex == 0 || vIndex == 7)) || 
				 (color == BLACK && (hIndex == 0 || hIndex ==7)) ||
				 (hIndex == 0 && vIndex == 0) ||
				 (hIndex == 7 && vIndex == 0) ||
				 (hIndex == 0 && vIndex == 7) ||
				 (hIndex == 7 && vIndex == 7)){
			 isLeagle = false;
		 //判断将要放的位置是否有相邻的棋子，如果有相邻两个以上的棋子则位置不合法，若只有一个相邻的棋子，则继续判断，若没有相邻棋子，则位置合法
		 }else{
			 gameBoard[hIndex][vIndex] = color;
			 //internal area
			 if(hIndex != 0 && vIndex != 0 && hIndex != 7 && vIndex != 7){
				 for(int x = hIndex - 1; x <= hIndex + 1; x++){
					 if(gameBoard[x][vIndex - 1] == gameBoard[hIndex][vIndex]){
						 adjacentNumber++;
						 if(adjacentNumber >= 2){
							 //在返回前 ，将棋盘还原
							 gameBoard[hIndex][vIndex] = EMPTY;
							 return false;
						 }
						 adjacentHIndex = x;
						 adjacentVIndex = vIndex - 1;
					 }
					 if(gameBoard[x][vIndex + 1] == gameBoard[hIndex][vIndex]){
						 adjacentNumber++;
						 if(adjacentNumber >= 2){
							 
							 gameBoard[hIndex][vIndex] = EMPTY;
							 return false;
						 }
						 adjacentHIndex = x;
						 adjacentVIndex = vIndex + 1;
					 }
				 }
				 if(gameBoard[hIndex - 1][vIndex] == gameBoard[hIndex][vIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
					 adjacentHIndex = hIndex - 1;
					 adjacentVIndex = vIndex;
				 }
				 if(gameBoard[hIndex + 1][vIndex] == gameBoard[hIndex][vIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
					 adjacentHIndex = hIndex + 1;
					 adjacentVIndex = vIndex;
				 }
		 //white left goal area
		 }else if(hIndex == 0){
			 for(int y = vIndex - 1; y <= vIndex + 1; y++){
				 if(gameBoard[1][y] == gameBoard[hIndex][vIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
					 adjacentHIndex = 1;
					 adjacentVIndex = y;
				 }
			 }
			 if(gameBoard[0][vIndex - 1] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = 0;
				 adjacentVIndex = vIndex - 1;
			 }
			 if(gameBoard[0][vIndex + 1] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = 0;
				 adjacentVIndex = vIndex + 1;
			 }
		 //white right goal area
		 }else if(hIndex == 7){
			 for(int y = vIndex - 1; y <= vIndex + 1; y++){
				 if(gameBoard[6][y] == gameBoard[hIndex][vIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
					 adjacentHIndex = 6;
					 adjacentVIndex = y;
				 }
			 }
			 if(gameBoard[7][vIndex - 1] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = 7;
				 adjacentVIndex = vIndex - 1;
			 }
			 if(gameBoard[7][vIndex + 1] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = 7;
				 adjacentVIndex = vIndex + 1;
			 }
		 //black top goal area
		 }else if(vIndex == 0){
			 for(int x = hIndex - 1; x <= hIndex + 1; x++){
				 if(gameBoard[x][1] == gameBoard[hIndex][vIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
					 adjacentHIndex = x;
					 adjacentVIndex = 1;
				 }
			 }
			 if(gameBoard[hIndex - 1][0] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = hIndex - 1;
				 adjacentVIndex = 0;
			 }
			 if(gameBoard[hIndex + 1][0] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = hIndex + 1;
				 adjacentVIndex = 0;
			 }
		 //black bottom goal area
		 }else if(vIndex == 7){
			 for(int x = hIndex - 1; x <= hIndex + 1; x++){
				 if(gameBoard[x][6] == gameBoard[hIndex][vIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
					 adjacentHIndex = x;
					 adjacentVIndex = 6;
				 }
			 }
			 if(gameBoard[hIndex - 1][7] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = hIndex - 1;
				 adjacentVIndex = 7;
			 }
			 if(gameBoard[hIndex + 1][7] == gameBoard[hIndex][vIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
				 adjacentHIndex = hIndex + 1;
				 adjacentVIndex = 7;
			 }
		 }
		}
		//check the adjacent node to see whether it has two adjacent node
		if(adjacentHIndex != -1){
			adjacentNumber = 0;
			if(adjacentHIndex != 0 && adjacentVIndex != 0 && adjacentHIndex != 7 && adjacentVIndex != 7){
				 for(int x = adjacentHIndex - 1; x <= adjacentHIndex + 1; x++){
					 if(gameBoard[x][adjacentVIndex - 1] == gameBoard[adjacentHIndex][adjacentVIndex]){
						 adjacentNumber++;
						 if(adjacentNumber >= 2){
							 gameBoard[hIndex][vIndex] = EMPTY;
							 return false;
						 }
					 }
					 if(gameBoard[x][adjacentVIndex + 1] == gameBoard[adjacentHIndex][adjacentVIndex]){
						 adjacentNumber++;
						 if(adjacentNumber >= 2){
							 gameBoard[hIndex][vIndex] = EMPTY;
							 return false;
						 }
					 }
				 }
				 if(gameBoard[adjacentHIndex - 1][adjacentVIndex] == gameBoard[adjacentHIndex][adjacentVIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
				 }
				 if(gameBoard[adjacentHIndex + 1][adjacentVIndex] == gameBoard[adjacentHIndex][adjacentVIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
				 }
		 //white left goal area
		 }else if(adjacentHIndex == 0){
			 for(int y = adjacentVIndex - 1; y <= adjacentVIndex + 1; y++){
				 if(gameBoard[1][y] == gameBoard[adjacentHIndex][adjacentVIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
				 }
			 }
			 if(gameBoard[0][adjacentVIndex - 1] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
			 if(gameBoard[0][adjacentVIndex + 1] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
		 //white right goal area
		 }else if(adjacentHIndex == 7){
			 for(int y = adjacentVIndex - 1; y <= adjacentVIndex + 1; y++){
				 if(gameBoard[6][y] == gameBoard[adjacentHIndex][adjacentVIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
				 }
			 }
			 if(gameBoard[7][adjacentVIndex - 1] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
			 if(gameBoard[7][adjacentVIndex + 1] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
		 //black top goal area
		 }else if(adjacentVIndex == 0){
			 for(int x = adjacentHIndex - 1; x <= adjacentHIndex + 1; x++){
				 if(gameBoard[x][1] == gameBoard[adjacentHIndex][adjacentVIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
				 }
			 }
			 if(gameBoard[adjacentHIndex - 1][0] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
			 if(gameBoard[adjacentHIndex + 1][0] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
		 //black bottom goal area
		 }else if(adjacentVIndex == 7){
			 for(int x = adjacentHIndex - 1; x <= adjacentHIndex + 1; x++){
				 if(gameBoard[x][6] == gameBoard[adjacentHIndex][adjacentVIndex]){
					 adjacentNumber++;
					 if(adjacentNumber >= 2){
						 gameBoard[hIndex][vIndex] = EMPTY;
						 return false;
					 }
				 }
			 }
			 if(gameBoard[adjacentHIndex - 1][7] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
			 if(gameBoard[adjacentHIndex + 1][7] == gameBoard[adjacentHIndex][adjacentVIndex]){
				 adjacentNumber++;
				 if(adjacentNumber >= 2){
					 gameBoard[hIndex][vIndex] = EMPTY;
					 return false;
				 }
			 }
		 }
		}
//		gameBoard[hIndex][vIndex] = EMPTY;
		return isLeagle;
	 }
	 public int getBlackNum(){
		 return blackNum;
	 }
	 public int getWhiteNum(){
		 return whiteNum;
	 }
	 public void addWhiteNum(){
		 whiteNum++;
	 }
	 public void addBlackNum(){
		 blackNum++;
	 }
	 //将指定坐标点还原
	 public void undo(int hIndex, int vIndex) {
		this.setBoard(hIndex, vIndex, EMPTY);
	}
}
这其中的核心方法是isLeagleMove(int hIndex,int vIndex, int color);其中hIndex与vIndex分别是将要放置的棋子位置的横纵坐标，color为棋子颜色。本人采用的策略是首先判断（hIndex,vIndex）处是否有其他棋子，以及(hIndex,vIndex)是否属于其中一方的老家，如是，则另一方不可以将棋子放在这里。最后还需要判断（hIndex,vIndex)是否是四个顶点，如果是四个顶点，不是合法步骤。这些都是在方法的第一个if语句中实现的。

这个方法的难点是判断将（hIndex,vIndex)放入color颜色棋子后会不会与棋盘上的其他棋子构成cluster（也就是（一）中的（6）规则）。这里分两种情况考虑，即（hIndex，vIndex)是边界点与非边界点两种情况。两种情况下遍历周围棋子的坐标不同，边界点情况下相邻单元格有5个，非边界点情况下相邻单元格有8个。采用adjacentNumber来记录相邻的棋子数，如果在遍历过程中发现adjacentNumber已经大于2，则此时已经构成了cluster，该步骤不合法。若遍历结束后发现adjacentNumber等于1，这说明有一个相邻节点，但此时不能确定是否构成了cluster，因为与（hIndex,vIndex)相邻的那个节点也有可能与其他节点构成cluster,这种情况如图红框所示，因此还需要继续判断与(hIndex,vIndex)相邻的那个单元格的adjacentNumber，如果它的adjacentNumber=2，则该步骤也不合法，若adjacentNumber=1，则合法。具体见代码实现。最后需要注意的是判断完成后需要把单元格还原。因为这里只是判断，并没有真正落下棋子。



gaobohello1987
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【完整版】基于JAVA的五子棋游戏系统设计与实现.doc
05-30
基于JAVA的五子棋游戏系统设计与实现 专 业 电子信息工程 学 生 董永杰 指导老师 曾玉 摘 要 目前，随着计算机网络的的开展，以计算机技术和网络技术为核心的现代网络技术已经 在现实生活和消费中得到了广泛的使用，...
关于中国象棋中走字合法性判断的算法（有我用TC2.0写的算法）
along3000的专栏
03-03 3612
对于中国象棋，每一个字都有自己的规则，正所谓无规矩不成方圆。棋盘先设定好，a:array[1..10][1..9] of MapStruct;是个二维数组，每个单元符全自定义的棋盘结构不要定义一个棋字结构int StepJudge(int oldx,int oldy,int nowx,int nowy)/* oldx,oldy           棋字原来位置 *//* oldx,
“Network”游戏棋人机对弈的设计与实现（三）—让计算机走出合法步骤
gaobohello1987的专栏
06-05 915
计算机能够判断步骤是否合法后，就可以让计算机走出合法的步骤了。
五子棋设计与实现
qq_61141142的博客
09-23 252
但是对于系统的架构，却完全是自己的事情，几千上万行的代码需要通过合适的方法组织起来，使程序员编写代码更加有条理，更加符合软件工程的标准，这才是最重要的。本程序的套接字派生自MFC的CAsyncSocket类[6]，CTable的这三个成员函数就分别提供了对套接字[7]回调事件OnAccept、OnConnect、OnReceive的实际处理，其中尤以Receive成员函数重要，它之中包含了对所有网络消息（参见“消息机制”一节）的分发处理。另外，在发送这个消息之后，主界面上的某些元素将不再响应用户的操作。
为何谷歌围棋AI AlphaGo可能会把李世石击溃
热门推荐
张俊林的博客
02-03 1万+
谷歌DeepMind开发的人工智能围棋程序AlphaGo以5:0的压倒性优势击败了欧洲围棋冠军、专业二段棋手Fan Hui，这是最近一周来最火爆的新闻了。16年3月份AlphaGo会和最近10年平均成绩表现最优秀的韩国九段、世界冠军李世石进行对弈，这无疑也是最吸引眼球的一场人机世纪大战，如果此役AlphaGo获胜，这意味着人工智能真正里程碑式的胜利，从此起码在智力博弈类游戏范围内，碳基体人类将无法抵挡硅基类机器的狂风骤雨，不知这是该令人惊恐还是令人兴奋呢？
基于Qt Creator实现中国象棋人机对战， c++实现.zip
最新发布
04-22
Signal & Slot机制是Qt中实现对象间事件驱动通信的核心方式。信号代表对象状态变化或事件发生，槽则是响应这些信号的可调用实体。这种松耦合的通信方式简化了异步编程和事件处理。 QML与Qt Quick： QML是一种...
基于WSN的矿井监控系统网关设计与实现
01-20
摘 要： 实现了一种多功能的网关系统，可完成无线传感器网络WSN与Internet网络的互联，同时具有模糊定位、IP语音通信以及智能人机接口等功能，并对其硬件组成、软件设计和对外接口等方面进行了深入阐述。...
分析车载防盗报警设计与实现
01-20
汽车工业在发达国家的经济发展中，起着重要支柱的作用：①在产值和销售收入中，汽车工业占较大比重。②汽车工业的发展必然会推动许多相关工业部门的...　LIN（Local Interconnect Network）是一种低成本的串行通讯网
10G网络处理器驱动软件的设计与实现
12-10
网络处理核心从传统的基于GPP（General Purpose Processor）的设计到基于ASIC（Application Specific Integrated Circuit）的设计再到基于网络处理器NP（Network Processor）的设计，不断向着高性能和高灵活性的方向...
一维Peak finding 算法
gaobohello1987的专栏
05-12 6193
介绍一维数组的两种peak finding算法及其复杂度
递归实现逆转数组（Java实现）
gaobohello1987的专栏
10-20 2603
public class ReverseArray { public static void swap(int[] A, int a, int b){ int temp; temp = A[a]; A[a] = A[b]; A[b] = temp; } public static void reverseArray(int A[], int start, int end)
RunLengthEncoding与普通图像间的相互转换
gaobohello1987的专栏
12-23 2194
有些大图像直接存储会很浪费磁盘空间，因此可以将普通图像转换成RunLengthEncoding编码，以压缩存储空间。将图像看成是一个二维数组，数组的每个元素代表图像的一个像素，其中存储了R（Red）、G（Green）、B（Blue）的具体值。RunLengthEncoding就是首先将图像的每行像素连接到一起，形成一个长的一维数组。然后将相邻的具有相同RGB值的像素合并到一块存储。例如下图是一个图
使用递归求数组最大值（java实现）
gaobohello1987的专栏
10-20 1378
public class FindMax { static int max; public static int compare(int a, int b){ if(a > b){ return a; } return b; } public static int findMax(int[] A, int endIndex, int addtion){ if(en
PriorityQueue的BinaryHeap实现
gaobohello1987的专栏
01-22 1378
PriorityQueue（优先队列）有很多应用场景，例如去听一场音乐会，假如票已经都卖完了，但是还有许多没票的人在排队等是否有人退票，如果有人退票，那么系统就需要把这张票分类给优先级最高的那个排队者（这里的优先级可以是排队的时间，或者交的钱多少等，这里的优先级条件对应priorityqueue中的key）。 PriorityQueue的实现方法有多种，包括SortedList，UnSorted
两种双向链表的首项插入与删除效率比较
gaobohello1987的专栏
12-26 1176
这里说的两种双向链表是指带“sentinel”与不带“sentinel”的，其中带"sentinel"的多了一个"sentinel"节点，以空间换取了时间。两种链表如下图： 1.不带sentinel的： 下面是构造方法以及在首项插入和删除方法，从代码中可以看出没有sentinel的DList在插入时需要处理链表为空的情况，删除的时候需要处理链表为空以及链表只有一个元素的情况，比较麻烦。
排序算法（二）—归并排序（Merge sort)
gaobohello1987的专栏
06-12 692
Merge sort首先将需要排序的序列拆分成单独的可排序对象，然后将这些可排序对象两两进行归并，直到把它们再合并为一个排序好的序列为止。 Merge sort不是in place排序，但是将Merge sort应用于链表（list)和数组的时候，两者的空间复杂度是不同的。应用于链表的时候空间复杂度更低。因此Merge sort更适用于链表。 本文采用非递归的方式来实现Merge sort在队
Sobel图像边界检测算法实现
gaobohello1987的专栏
11-28 670
实现算法有两个核心算法，一是为了处理边界的reflected方法，为了将原图像的边界点reflecte出来。另一个是实现Sobel算法的方法：具体见下边源码： 首先是reflect方法： public PixImage reflect(){ int width = this.getWidth(); int height = this.getHeight(); int new
DQN算法实现九宫格人机对弈代码
05-20
下面是使用Deep Q-Network (DQN)算法实现九宫格人机对弈的代码示例： ```python import numpy as np import random from keras.models import Sequential from keras.layers import Dense from keras.optimizers ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值