自己写的人机对战，思路是给每个未下的棋子进行评分，活二、活三、冲四等分别代表不同分数，取最高分数进行落子
简单写了个前端页面，大家可以玩玩看
https://www.linzhehao.cn/gobang/single
下面是Java的核心代码及用法
一、示例用法
public class MyTest {
public static void main(String[] args) {
// 初始化服务
ComputerService service = new ComputerService();
// 设置玩家的数字(1或2)，不设置的话默认是1
// 如果设置成1，电脑就是2，如果设置成2，电脑就是1
service.setPlayerType(1);
// 构造一个15*15的二维数组棋盘
Integer[][] checkBox = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
// 让电脑下一颗棋子保存到r对象
R r = service.getResult(checkBox);
// 如果电脑获胜
if("电脑获胜".equals(r.getState())) {
// 输出电脑下的棋子
System.out.println(r);
System.out.println(r.getState());
}
// 如果玩家获胜
else if ("玩家获胜".equals(r.getState())) {
System.out.println(r.getState());
} else {
// 输出电脑下的棋子
System.out.println(r);
}
}
}二、机器人代码
import java.util.*;
public class ComputerService {
// 临时储存分数
private int count1;
private int count2;
private int count3;
private int count4;
private int count5;
// 电脑五子
private int computerFive = 1000;
// 玩家五子
private int playerFive = 980;
// 电脑活四
private int computerActiveFour = 900;
// 电脑冲四
private int computerChongFour = 800;
// 玩家活四
private int playerActiveFour = 600;
// 玩家冲四
private int playerChongFour = 450;
// 电脑活三
private int computerActiveThree = 350;
// 玩家活三
private int playerActiveThree = 300;
// 电脑眠三
private int computerSleepThree = 200;
// 玩家眠三
private int playerSleepThree = 150;
// 玩家多个活二
private int playerManyActiveTwo = 100;
// 电脑活二
private int computerActiveTwo = 50;
// 周围有棋子
private int hasAround = 10;
private int[][] scores = new int[15][15]; // 分数
public int x, y; // 当前的x和y值
private Integer[][] checkBox;
private RegularFactory factory = new RegularFactory();
// 判断电脑是黑棋还是白棋
private enum Type {
black(1), white(2);
private int num;
Type(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
// 人类和电脑的颜色
private Type player = Type.black;
private Type computer = Type.white;
/**
* 设置玩家的类型
* @param type 1或2
*/
public void setPlayerType(int type) {
player = type == 1 ? Type.black : Type.white;
computer = type == 2 ? Type.black : Type.white;
}
/**
* 获取结果
* @param checkBox 棋盘数据
* @return 电脑下的坐标
*/
public R getResult(Integer[][] checkBox) {
this.checkBox = checkBox;
factory.setCheckBox(checkBox);
long startTime = System.currentTimeMillis();
// 如果玩家胜利
R playerIsWin = playerIsWin();
if(playerIsWin != null) {
return playerIsWin;
}
// 如果电脑胜利
R computerIsWin = computerIsWin();
if(computerIsWin != null) {
return computerIsWin;
}
// 获取分数
int maxScore = -1; // 最大分数
for(int i=0;i<15;i++) {
for(int j=0;j<15;j++) {
scores[i][j] = getScore(i, j);
// 统计最大分数
if(scores[i][j] > maxScore) {
maxScore = scores[i][j];
}
}
}
// 统计所有最大分数的坐标
List<R> maxR = new ArrayList<>();
for(int i=0;i<15;i++) {
for(int j=0;j<15;j++) {
if(scores[i][j] == maxScore) {
maxR.add(new R(i, j));
}
}
}
// 输出每一步的棋盘信息和分数信息
// output();
// 随机返回一个R
int random = new Random().nextInt(maxR.size());
long stopTime = System.currentTimeMillis();
System.out.println("计算完成，耗时" + (stopTime - startTime) + "毫秒");
return maxR.get(random);
}
/**
* 打分
* @param x x轴
* @param y y轴
* @return 分数
*/
private int getScore(int x, int y) {
this.x = x;
this.y = y;
// 如果已经下了棋子
if(checkBox[x][y] != 0) {
return -1;
}
// 电脑成为五子
if(becomeFive(computer.getNum(), x, y, true)) {
return computerFive;
}
// 玩家成为五子
if(becomeFive(player.getNum(), x, y, true)) {
return playerFive;
}
// 电脑活四
count1 = becomeActiveFour(computer.getNum());
if(count1 > 0) {
// 电脑冲四
count2 = becomeChongFour(computer.getNum());
if(count2 > 0) {
// 电脑活三
count3 = becomeActiveThree(computer.getNum());
if(count3 > 0) {
// 电脑眠三
count4 = becomeSleepThree(computer.getNum());
if(count4 > 0) {
// 电脑活二
count5 = becomeActiveTwo(computer.getNum());
if(count5 > 0) {
return computerActiveFour + count1 + count2 + count3 + count4 + count5;
}
return computerActiveFour + count1 + count2 + count3 + count4;
}
// 电脑活二
count4 = becomeActiveTwo(computer.getNum());
if(count4 > 0) {
return computerActiveFour + count1 + count2 + count3 + count4;
}
return computerActiveFour + count1 + count2 + count3;
}
// 电脑眠三
count3 = becomeSleepThree(computer.getNum());
if(count3 > 0) {
// 电脑活二
count5 = becomeActiveTwo(computer.getNum());
if(count5 > 0) {
return computerActiveFour + count1 + count2 + count3 + count4 + count5;
}
return computerActiveFour + count1 + count2 + count3;
}
// 电脑活二
count3 = becomeActiveTwo(computer.getNum());
if(count3 > 0) {
return computerActiveFour + count1 + count2 + count3;
}
return computerActiveFour + count1 + count2;
}
// 电脑活三
count2 = becomeActiveThree(computer.getNum());
if(count2 > 0) {
// 电脑眠三
count3 = becomeSleepThree(computer.getNum());
if(count3 > 0) {
// 电脑活二
count4 = becomeActiveTwo(computer.getNum());
if(count4 > 0) {
return computerActiveFour + count1 + count2 + count3 + count4;
}
return computerActiveFour + count1 + count2 + count3;
}
// 电脑活二
count3 = becomeActiveTwo(computer.getNum());
if(count3 > 0) {
return computerActiveFour + count1 + count2 + count3;
}
return computerActiveFour + count1 + count2;
}
// 电脑眠三
count2 = becomeSleepThree(computer.getNum());
if(count2 > 0) {
// 电脑活二
count3 = becomeActiveTwo(computer.getNum());
if(count3 > 0) {
return computerActiveFour + count1 + count2 + count3;
}
return computerActiveFour + count1 + count2;
}
// 电脑活二
count2 = becomeActiveTwo(computer.getNum());
if(count2 > 0) {
return computerActiveFour + count1 + count2;
}
return computerActiveFour + count1;
}
// 电脑冲四
count1 = becomeChongFour(computer.getNum());
if(count1 > 0) {
// 电脑活三
count2 = becomeActiveThree(computer.getNum());
if(count2 > 0) {
// 电脑眠三
count3 = becomeSleepThree(computer.getNum());
if(count3 > 0) {
// 电脑活二
count4 = becomeActiveTwo(computer.getNum());
if(count4 > 0) {
return computerChongFour + count1 + count2 + count3 + count4;
}
return computerChongFour + count1 + count2 + count3;
}
// 电脑活二
count3 = becomeActiveTwo(computer.getNum());
if(count3 > 0) {
return computerChongFour + count1 + count2 + count3;
}
return computerChongFour + count1 + count2;
}
// 电脑眠三
count2 = becomeSleepThree(computer.getNum());
if(count2 > 0) {
// 电脑活二
count3 = becomeActiveTwo(computer.getNum());
if(count3 > 0) {
return computerChongFour + count1 + count2 + count3;
}
return computerChongFour + count1 + count2;
}
// 电脑活二
count2 = becomeActiveTwo(computer.getNum());
if(count2 > 0) {
return computerChongFour + count1 + count2;
}
return computerChongFour + count1;
}
// 玩家活四
count1 = becomeActiveFour(player.getNum());
if(count1 > 0) {
// 玩家冲四
count2 = becomeChongFour(player.getNum());
if(count2 > 0) {
// 玩家活三
count3 = becomeActiveThree(player.getNum());
if(count3 > 0) {
// 玩家眠三
count4 = becomeSleepThree(player.getNum());
if(count4 > 0) {
// 玩家活二
count5 = becomeActiveTwo(player.getNum());
if(count5 > 0) {
return playerActiveFour + count1 + count2 + count3 + count4 + count5;
}
return playerActiveFour + count1 + count2 + count3 + count4;
}
// 玩家活二
count4 = becomeActiveTwo(player.getNum());
if(count4 > 0) {
return playerActiveFour + count1 + count2 + count3 + count4;
}
return playerActiveFour + count1 + count2 + count3;
}
// 玩家眠三
count3 = becomeSleepThree(player.getNum());
if(count3 > 0) {
// 玩家活二
count5 = becomeActiveTwo(player.getNum());
if(count5 > 0) {
return playerActiveFour + count1 + count2 + count3 + count4 + count5;
}
return playerActiveFour + count1 + count2 + count3;
}
// 玩家活二
count3 = becomeActiveTwo(player.getNum());
if(count3 > 0) {
return playerActiveFour + count1 + count2 + count3;
}
return playerActiveFour + count1 + count2;
}
// 玩家活三
count2 = becomeActiveThree(player.getNum());
if(count2 > 0) {
// 玩家眠三
count3 = becomeSleepThree(player.getNum());
if(count3 > 0) {
// 玩家活二
count4 = becomeActiveTwo(player.getNum());
if(count4 > 0) {
return playerActiveFour + count1 + count2 + count3 + count4;
}
return playerActiveFour + count1 + count2 + count3;
}
// 玩家活二
count3 = becomeActiveTwo(player.getNum());
if(count3 > 0) {
return playerActiveFour + count1 + count2 + count3;
}
return playerActiveFour + count1 + count2;
}
// 玩家眠三
count2 = becomeSleepThree(player.getNum());
if(count2 > 0) {
// 玩家活二
count3 = becomeActiveTwo(player.getNum());
if(count3 > 0) {
return playerActiveFour + count1 + count2 + count3;
}
return playerActiveFour + count1 + count2;
}
// 玩家活二
count2 = becomeActiveTwo(player.getNum());
if(count2 > 0) {
return playerActiveFour + count1 + count2;
}
return playerActiveFour + count1;
}
// 玩家冲四
count1 = becomeChongFour(player.getNum());
if(count1 > 0) {
// 玩家活三
count2 = becomeActiveThree(player.getNum());
if(count2 > 0) {
// 玩家眠三
count3 = becomeSleepThree(player.getNum());
if(count3 > 0) {
// 玩家活二
count4 = becomeActiveTwo(player.getNum());
if(count4 > 0) {
return playerChongFour + count1 + count2 + count3 + count4;
}
return playerChongFour + count1 + count2 + count3;
}
// 玩家活二
count3 = becomeActiveTwo(player.getNum());
if(count3 > 0) {
return playerChongFour + count1 + count2 + count3;
}
return playerChongFour + count1 + count2;
}
// 玩家眠三
count2 = becomeSleepThree(player.getNum());
if(count2 > 0) {
// 电脑活二
count3 = becomeActiveTwo(player.getNum());
if(count3 > 0) {
return playerChongFour + count1 + count2 + count3;
}
return playerChongFour + count1 + count2;
}
// 玩家活二
count2 = becomeActiveTwo(player.getNum());
if(count2 > 0) {
return playerChongFour + count1 + count2;
}
return playerChongFour + count1;
}
// 电脑活三
count1 = becomeActiveThree(computer.getNum());
if(count1 > 0) {
// 电脑眠三
count2 = becomeSleepThree(computer.getNum());
if(count2 > 0) {
// 电脑活二
count3 = becomeActiveTwo(computer.getNum());
if(count3 > 0) {
return computerActiveThree + count1 + count2 + count3;
}
return computerActiveThree + count1 + count2;
}
// 电脑活二
count2 = becomeActiveTwo(computer.getNum());
if(count2 > 0) {
return computerActiveThree + count1 + count2;
}
return computerActiveThree + count1;
}
// 玩家活三
count1 = becomeActiveThree(player.getNum());
if(count1 > 0) {
// 玩家眠三
count2 = becomeSleepThree(player.getNum());
if(count2 > 0) {
// 玩家活二
count3 = becomeActiveTwo(player.getNum());
if(count3 > 0) {
return playerActiveThree + count1 + count2 + count3;
}
return playerActiveThree + count1 + count2;
}
// 玩家活二
count2 = becomeActiveTwo(player.getNum());
if(count2 > 0) {
return playerActiveThree + count1 + count2;
}
return playerActiveThree + count1;
}
// 电脑眠三
count1 = becomeSleepThree(computer.getNum());
if(count1 > 0) {
// 电脑活二
count2 = becomeActiveTwo(computer.getNum());
if(count2 > 0) {
return computerSleepThree + count1 + count2;
}
return computerSleepThree + count1;
}
// 玩家眠三
count1 = becomeSleepThree(player.getNum());
if(count1 > 0) {
// 电脑活二
count2 = becomeActiveTwo(player.getNum());
if(count2 > 0) {
return playerSleepThree + count1 + count2;
}
return playerSleepThree + count1;
}
// 玩家多个活二
count1 = becomeActiveTwo(player.getNum());
if(count1 > 1) {
return playerManyActiveTwo + count1;
}
// 电脑活二
count1 = becomeActiveTwo(computer.getNum());
if(count1 > 0) {
return computerActiveTwo + count1;
}
// 如果玩家有棋子
if(hasAround(player.getNum())) {
return hasAround;
}
return 0;
}
// 判断周围是否有对方的棋子
private boolean hasAround(int user) {
// 所有周围的坐标
R[] surrounding = new R[] {
new R(x - 1, y),
new R(x + 1, y),
new R(x, y - 1),
new R(x, y + 1),
new R(x - 1, y - 1),
new R(x - 1, y + 1),
new R(x + 1, y - 1),
new R(x + 1, y + 1)
};
// 遍历这些坐标
for(R surround: surrounding) {
// 如果坐标存在
if(piecesIsExists(user, surround)) {
return true;
}
}
return false;
}
// 成为活二
private int becomeActiveTwo(int user) {
factory.setCheckBox(checkBox);
factory.set(user, x, y);
factory.addRegular(new Integer[]{-2}, new Integer[]{-3, -1, +1});
factory.addRegular(new Integer[]{-1}, new Integer[]{-3, -2, +1});
factory.addRegular(new Integer[]{-1}, new Integer[]{-2, +1, +2});
factory.addRegular(new Integer[]{+1}, new Integer[]{-2, -1, +2});
factory.addRegular(new Integer[]{+1}, new Integer[]{-1, +2, +3});
factory.addRegular(new Integer[]{+2}, new Integer[]{-1, +1, +3});
return getCount();
}
// 成为眠三
private int becomeSleepThree(int user) {
factory.setCheckBox(checkBox);
factory.set(user, x, y);
factory.addRegular(new Integer[]{-1, -2}, new Integer[]{-3, -4}, +1);
factory.addRegular(new Integer[]{+1, -1}, new Integer[]{-2, -3}, +2);
factory.addRegular(new Integer[]{+1, +2}, new Integer[]{-1, -2}, +3);
factory.addRegular(new Integer[]{-2, -3}, new Integer[]{-1, -4}, +1);
factory.addRegular(new Integer[]{-1, -3}, new Integer[]{-2, -4}, +1);
factory.addRegular(new Integer[]{-2, +1}, new Integer[]{-1, -3}, +2);
factory.addRegular(new Integer[]{-1, +2}, new Integer[]{-2, +1}, +3);
factory.addRegular(new Integer[]{-2, -3}, new Integer[]{-1, -4}, -4);
factory.addRegular(new Integer[]{-1, -3}, new Integer[]{-2, -4}, -4);
factory.addRegular(new Integer[]{-2, +1}, new Integer[]{-1, -3}, -3);
factory.addRegular(new Integer[]{-1, +2}, new Integer[]{-2, +1}, -2);
return getCount();
}
// 成为活三
private int becomeActiveThree(int user) {
factory.set(user, x, y);
factory.addRegular(new Integer[]{-2, -1}, new Integer[]{-3, +1});
factory.addRegular(new Integer[]{-1, +1}, new Integer[]{-2, +2});
factory.addRegular(new Integer[]{+1, +2}, new Integer[]{-1, +3});
factory.addRegular(new Integer[]{-3, -2}, new Integer[]{-4, -1, +1});
factory.addRegular(new Integer[]{-3, -1}, new Integer[]{-4, -2, +1});
factory.addRegular(new Integer[]{+3, +2}, new Integer[]{+4, +1, -1});
factory.addRegular(new Integer[]{+3, +1}, new Integer[]{+4, +2, -1});
factory.addRegular(new Integer[]{-2, +1}, new Integer[]{-3, +2, -1});
factory.addRegular(new Integer[]{-1, +2}, new Integer[]{-2, +1, +3});
List<Boolean> rowResult = factory.getRowResult();
List<Boolean> columnResult = factory.getColumnResult();
List<Boolean> leftResult = factory.getLeftResult();
List<Boolean> rightResult = factory.getRightResult();
// 统计数量
int count = 0;
// count += hasTrue(rowResult);
// count += hasTrue(columnResult);
// count += hasTrue(leftResult);
// count += hasTrue(rightResult);
count += rowResult.get(0) || rowResult.get(1) || rowResult.get(2) ? 3 : (rowResult.get(3) || rowResult.get(4) || rowResult.get(5) || rowResult.get(6) || rowResult.get(7) || rowResult.get(8) ? 2 : 0);
count += columnResult.get(0) || columnResult.get(1) || columnResult.get(2) ? 3 : (columnResult.get(3) || columnResult.get(4) || columnResult.get(5) || columnResult.get(6) || columnResult.get(7) || columnResult.get(8) ? 2 : 0);
count += leftResult.get(0) || leftResult.get(1) || leftResult.get(2) ? 3 : (leftResult.get(3) || leftResult.get(4) || leftResult.get(5) || leftResult.get(6) || leftResult.get(7) || leftResult.get(8) ? 2 : 0);
count += rightResult.get(0) || rightResult.get(1) || rightResult.get(2) ? 3 : (rightResult.get(3) || rightResult.get(4) || rightResult.get(5) || rightResult.get(6) || rightResult.get(7) || rightResult.get(8) ? 2 : 0);
return count;
}
// 判断电脑是否胜利
private R computerIsWin() {
for(int i=0;i<15;i++) {
for(int j=0;j<15;j++) {
if(checkBox[i][j] == 0 && becomeFive(computer.getNum(), i, j, true)) {
return new R("电脑获胜", i, j);
}
}
}
return null;
}
// 判断玩家是否胜利
private R playerIsWin() {
for(int i=0;i<15;i++) {
for(int j=0;j<15;j++) {
if(checkBox[i][j] == player.getNum() && becomeFive(player.getNum(), i, j, false)) {
return new R("玩家获胜", i, j);
}
}
}
return null;
}
// 成为冲四
private int becomeChongFour(int user) {
factory.set(user, x, y);
factory.addRegular(new Integer[]{-3, -2, -1}, new Integer[]{-4}, +1);
factory.addRegular(new Integer[]{-3, -2, -1}, new Integer[]{+1}, -4);
factory.addRegular(new Integer[]{-2, -1, +1}, new Integer[]{-3}, +2);
factory.addRegular(new Integer[]{-2, -1, +1}, new Integer[]{+2}, -3);
factory.addRegular(new Integer[]{-1, +1, +2}, new Integer[]{-2}, +3);
factory.addRegular(new Integer[]{-1, +1, +2}, new Integer[]{+3}, -2);
factory.addRegular(new Integer[]{+1, +2, +3}, new Integer[]{-1}, +4);
factory.addRegular(new Integer[]{+1, +2, +3}, new Integer[]{+4}, -1);
return getCount();
}
// 成为活四的数量
private int becomeActiveFour(int user) {
factory.setCheckBox(checkBox);
factory.set(user, x, y);
factory.addRegular(new Integer[]{-3, -2, -1}, new Integer[]{-4, +1});
factory.addRegular(new Integer[]{-2, -1, +1}, new Integer[]{-3, +2});
factory.addRegular(new Integer[]{-1, +1, +2}, new Integer[]{-2, +3});
factory.addRegular(new Integer[]{+1, +2, +3}, new Integer[]{-1, +4});
int count = 0;
count += hasTrue(factory.getRowResult());
count += hasTrue(factory.getColumnResult());
count += hasTrue(factory.getLeftResult());
count += hasTrue(factory.getRightResult());
return count;
}
/**
* 成为五子或更多
* @param scoring true：用来打分，false：用来判断输赢
*/
private boolean becomeFive(int user, int x, int y, boolean scoring) {
// 假设棋子已下
if(scoring) {
checkBox[x][y] = user;
}
// 横向判断
for(int i=0;i<=y;i++) {
for(int j=14;j>=y;j--) {
List<R> rList = new ArrayList<>();
for(int k=i;k<=j;k++) {
rList.add(new R(x, k));
}
boolean has = piecesIsExists(user, rList.toArray(new R[]{}));
if(has && rList.size() >= 5) {
if(scoring) {
checkBox[x][y] = 0;
}
return true;
}
}
}
// 竖向判断
for(int i=0;i<=x;i++) {
for(int j=14;j>=x;j--) {
List<R> rList = new ArrayList<>();
for(int k=i;k<=j;k++) {
rList.add(new R(k, y));
}
boolean has = piecesIsExists(user, rList.toArray(new R[]{}));
if(has && rList.size() >= 5) {
if(scoring) {
checkBox[x][y] = 0;
}
return true;
}
}
}
// 右斜判断
{
// 取出起始点的坐标
R start = new R(x, y);
while(start.getX() != 0 && start.getY() != 0) {
start.increase(-1, -1);
}
// 取出终点坐标
R stop = new R(x, y);
while(stop.getX() != 14 && stop.getY() != 14) {
stop.increase(1, 1);
}
// 开始判断
for(int i1=start.getX(),i2=start.getY();i1<=x;i1++,i2++) {
for(int j1=stop.getX(),j2=stop.getY();j1>=x;j1--,j2--) {
List<R> rList = new ArrayList<>();
for(int k1=i1,k2=i2;k1<=j1;k1++,k2++) {
rList.add(new R(k1, k2));
}
boolean has = piecesIsExists(user, rList.toArray(new R[]{}));
//System.out.println(new R(i1, i2) + "-" + new R(j1, j2) + ": " + has);
if(has && rList.size() >= 5) {
if(scoring) {
checkBox[x][y] = 0;
}
return true;
}
}
}
}
// 左斜判断
{
// 取出起点的坐标
R start = new R(x, y);
while(start.getX() != 0 && start.getY() != 14) {
start.increase(-1, 1);
}
// 取出终点坐标
R stop = new R(x, y);
while(stop.getX() != 14 && stop.getY() != 0) {
stop.increase(1, -1);
}
for(int i1=start.getX(),i2=start.getY();i1<=x;i1++,i2--) {
for(int j1=stop.getX(),j2=stop.getY();j1>=x;j1--,j2++) {
List<R> rList = new ArrayList<>();
for(int k1=i1,k2=i2;k1<=j1;k1++,k2--) {
rList.add(new R(k1, k2));
}
boolean has = piecesIsExists(user, rList.toArray(new R[]{}));
//System.out.println(new R(i1, i2) + "-" + new R(j1, j2) + ": " + has);
if(has && rList.size() >= 5) {
if(scoring) {
checkBox[x][y] = 0;
}
return true;
}
}
}
}
if(scoring) {
checkBox[x][y] = 0;
}
return false;
}
// 输出
private void output() {
// 输出棋盘
for(int i=0;i<15;i++) {
System.out.print("{");
for(int j=0;j<15;j++) {
System.out.print(checkBox[j][i]);
if(j != 14) {
System.out.print(", ");
}
}
System.out.println("},");
}
System.out.println();
// 输出坐标
for(int i=0;i<15;i++) {
for (int j = 0; j < 15; j++) {
System.out.print(scores[j][i] + "\t");
}
System.out.println("\n");
}
}
/**
* 是否有true
* @param resultList 要统计的集合
* @return 如果有true返回1，如果没有则返回0
*/
private int hasTrue(List<Boolean> resultList) {
for(Boolean b: resultList) {
if(b) {
return 1;
}
}
return 0;
}
/**
* 统计数量
* @return
*/
private int getCount() {
int count = 0;
count += hasTrue(factory.getRowResult());
count += hasTrue(factory.getColumnResult());
count += hasTrue(factory.getLeftResult());
count += hasTrue(factory.getRightResult());
return count;
}
/**
* 判断这些棋子是否都存在
* @param user 用户，用来比较
* @param pieces 棋子的坐标
* @return 是否都存在
*/
private boolean piecesIsExists(int user, R... pieces) {
for(R piece: pieces) {
// 如果是边缘或者越界
if(piece.getX() < 0 || piece.getX() > 14 || piece.getY() < 0 || piece.getY() > 14) {
return false;
}
// 如果和用户的棋子不一致
if(!checkBox[piece.getX()][piece.getY()].equals(user)) {
return false;
}
}
return true;
}
}
class RegularFactory {
private Integer[][] checkBox;
private int user, x, y;
// 横向判断
private List<R[]> rowsIsExists = new ArrayList<>();
private List<R[]> rowsIsEmpty = new ArrayList<>();
private List<R> rowsIsPlayerOrBounds = new ArrayList<>();
// 竖向判断
private List<R[]> columnsIsExists = new ArrayList<>();
private List<R[]> columnsIsEmpty = new ArrayList<>();
private List<R> columnsIsPlayerOrBounds = new ArrayList<>();
// 左斜判断
private List<R[]> leftIsExists = new ArrayList<>();
private List<R[]> leftIsEmpty = new ArrayList<>();
private List<R> leftIsPlayerOrBounds = new ArrayList<>();
// 右斜判断
private List<R[]> rightIsExists = new ArrayList<>();
private List<R[]> rightIsEmpty = new ArrayList<>();
private List<R> rightIsPlayOrBounds = new ArrayList<>();
// 初始化工厂
public RegularFactory() {
}
public RegularFactory(Integer[][] checkBox, int user, int x, int y) {
this.checkBox = checkBox;
this.user = user;
this.x = x;
this.y = y;
}
// 设置棋盘
public void setCheckBox(Integer[][] checkBox) {
this.checkBox = checkBox;
}
// 设置坐标
public void set(int user, int x, int y) {
this.user = user;
this.x = x;
this.y = y;
clearList();
}
// 清除所有集合
public void clearList() {
rowsIsExists.clear();
columnsIsExists.clear();
leftIsExists.clear();
rightIsExists.clear();
rowsIsEmpty.clear();
columnsIsEmpty.clear();
leftIsEmpty.clear();
rightIsEmpty.clear();
rowsIsPlayerOrBounds.clear();
columnsIsPlayerOrBounds.clear();
leftIsPlayerOrBounds.clear();
rightIsPlayOrBounds.clear();
}
// 添加规则
public void addRegular(Integer[] yExists, Integer[] yEmpty) {
R[] rowsExists = new R[yExists.length];
R[] rowsEmpty = new R[yEmpty.length];
R[] columnsExists = new R[yExists.length];
R[] columnsEmpty = new R[yEmpty.length];
R[] leftExists = new R[yExists.length];
R[] leftEmpty = new R[yEmpty.length];
R[] rightExists = new R[yExists.length];
R[] rightEmpty = new R[yEmpty.length];
for(int i=0;i<yExists.length;i++) {
rowsExists[i] = new R(x, y + yExists[i]);
columnsExists[i] = new R(x + yExists[i], y);
leftExists[i] = new R(x + yExists[i], y - yExists[i]);
rightExists[i] = new R(x + yExists[i], y + yExists[i]);
}
rowsIsExists.add(rowsExists);
columnsIsExists.add(columnsExists);
leftIsExists.add(leftExists);
rightIsExists.add(rightExists);
for(int i=0;i<yEmpty.length;i++) {
rowsEmpty[i] = new R(x, y + yEmpty[i]);
columnsEmpty[i] = new R(x + yEmpty[i], y);
leftEmpty[i] = new R(x + yEmpty[i], y - yEmpty[i]);
rightEmpty[i] = new R(x + yEmpty[i], y + yEmpty[i]);
}
rowsIsEmpty.add(rowsEmpty);
columnsIsEmpty.add(columnsEmpty);
leftIsEmpty.add(leftEmpty);
rightIsEmpty.add(rightEmpty);
}
// 添加规则
public void addRegular(Integer[] yExists, Integer[] yEmpty, Integer yPlayerOrBounds) {
addRegular(yExists, yEmpty);
addRegular(yPlayerOrBounds);
// 相反方向再添加一次规则
for(int i=0;i<yExists.length;i++) {
yExists[i] = -yExists[i];
}
for(int i=0;i<yEmpty.length;i++) {
yEmpty[i] = -yEmpty[i];
}
yPlayerOrBounds = -yPlayerOrBounds;
// 第二次添加规则
addRegular(yExists, yEmpty);
addRegular(yPlayerOrBounds);
}
// 只添加玩家或边界规则
private void addRegular(Integer yPlayerOrBounds) {
rowsIsPlayerOrBounds.add(new R(x, y + yPlayerOrBounds));
columnsIsPlayerOrBounds.add(new R(x + yPlayerOrBounds, y));
leftIsPlayerOrBounds.add(new R(x + yPlayerOrBounds, y - yPlayerOrBounds));
rightIsPlayOrBounds.add(new R(x + yPlayerOrBounds, y + yPlayerOrBounds));
}
// 获取行结果
public List<Boolean> getRowResult() {
List<Boolean> rowResult = new ArrayList<>();
for(int i=0;i<rowsIsExists.size();i++) {
boolean row;
if(!rowsIsPlayerOrBounds.isEmpty()) {
row = piecesIsExists(user, rowsIsExists.get(i)) && piecesIsEmpty(rowsIsEmpty.get(i)) && pieceIsPlayerOrBounds(user, rowsIsPlayerOrBounds.get(i));
} else {
row = piecesIsExists(user, rowsIsExists.get(i)) && piecesIsEmpty(rowsIsEmpty.get(i));
}
rowResult.add(row);
}
return rowResult;
}
// 获取列结果
public List<Boolean> getColumnResult() {
List<Boolean> columnResult = new ArrayList<>();
for(int i=0;i<columnsIsExists.size();i++) {
boolean column;
if(!columnsIsPlayerOrBounds.isEmpty()) {
column = piecesIsExists(user, columnsIsExists.get(i)) && piecesIsEmpty(columnsIsEmpty.get(i)) && pieceIsPlayerOrBounds(user, columnsIsPlayerOrBounds.get(i));
} else {
column = piecesIsExists(user, columnsIsExists.get(i)) && piecesIsEmpty(columnsIsEmpty.get(i));
}
columnResult.add(column);
}
return columnResult;
}
// 获取左斜结果
public List<Boolean> getLeftResult() {
List<Boolean> leftResult = new ArrayList<>();
for(int i=0;i<leftIsExists.size();i++) {
boolean left;
if(!leftIsPlayerOrBounds.isEmpty()) {
left = piecesIsExists(user, leftIsExists.get(i)) && piecesIsEmpty(leftIsEmpty.get(i)) && pieceIsPlayerOrBounds(user, leftIsPlayerOrBounds.get(i));
} else {
left = piecesIsExists(user, leftIsExists.get(i)) && piecesIsEmpty(leftIsEmpty.get(i));
}
leftResult.add(left);
}
return leftResult;
}
// 获取右斜结果
public List<Boolean> getRightResult() {
List<Boolean> rightResult = new ArrayList<>();
for(int i=0;i<rightIsExists.size();i++) {
boolean right;
if(!rightIsPlayOrBounds.isEmpty()) {
right = piecesIsExists(user, rightIsExists.get(i)) && piecesIsEmpty(rightIsEmpty.get(i)) && pieceIsPlayerOrBounds(user, rightIsPlayOrBounds.get(i));
} else {
right = piecesIsExists(user, rightIsExists.get(i)) && piecesIsEmpty(rightIsEmpty.get(i));
}
rightResult.add(right);
}
return rightResult;
}
/**
* 判断这些棋子是否都存在
* @param user 用户，用来比较
* @param pieces 棋子的坐标
* @return 是否都存在
*/
private boolean piecesIsExists(int user, R... pieces) {
for(R piece: pieces) {
// 如果是边缘或者越界
if(piece.getX() < 0 || piece.getX() > 14 || piece.getY() < 0 || piece.getY() > 14) {
return false;
}
// 如果和用户的棋子不一致
if(!checkBox[piece.getX()][piece.getY()].equals(user)) {
return false;
}
}
return true;
}
/**
* 判断这些棋子是否都为空
* @param pieces 棋子的坐标
* @return 是否都为空
*/
private boolean piecesIsEmpty(R... pieces) {
for(R piece: pieces) {
// 如果是边缘或者越界
if(piece.getX() < 0 || piece.getX() > 14 || piece.getY() < 0 || piece.getY() > 14) {
return false;
}
// 如果不为空
if(!checkBox[piece.getX()][piece.getY()].equals(0)) {
return false;
}
}
return true;
}
/**
* 判断棋子是否是对方或者边界
* @param piece 棋子的坐标
* @retur 结果
*/
private boolean pieceIsPlayerOrBounds(int user, R piece) {
int contraryUser = user == 1 ? 2 : 1; // 对手的颜色
// 如果越界
if(piece.getX() < 0 || piece.getX() > 14 || piece.getY() < 0 || piece.getY() > 14) {
return true;
}
// 如果是玩家
return checkBox[piece.getX()][piece.getY()].equals(contraryUser);
}
}
//机器人返回的数据
class R {
private String state = "返回成功";
private Integer x;
private Integer y;
public R() {
}
public R(String state, Integer x, Integer y) {
this.state = state;
this.x = x;
this.y = y;
}
public R(Integer x, Integer y) {
this.x = x;
this.y = y;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public Integer getX() {
return x;
}
public void setX(Integer x) {
this.x = x;
}
public Integer getY() {
return y;
}
public void setY(Integer y) {
this.y = y;
}
// 增加
public void increase(int x, int y) {
if(this.x != null) {
this.x += x;
}
if(this.y != null) {
this.y += y;
}
}
@Override
public String toString() {
return "R{" +
"x=" + x +
", y=" + y +
'}';
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
