小游戏五子连珠消除解决方案

序言

五子连珠，顾名思义就是当有五个相同的球在一条直线上，横，竖，斜，总共四个方向呈《米》型的消除规则，达到5个或者5个以上

但是我们的五子连珠不是达到五个就结束，只是连续相同的5个或者5个以上的棋子会被消除同时增加对应的积分；

我们的设计是棋盘上 是 8 * 8 坐标格子，

总共有6总颜色的球，五个独立颜色（色号1-5），一个是彩色叫万能替代球（色号6）；

还有一个附加状态是球有爆炸效果

棋子在棋盘上可以沿着四个方向移动，然后移动到需要移动的地方，所以这里采用A*算法来做格子移动；

如果移动棋子没有可以消除的棋子，棋盘上会随机刷出三个新的球；

设计

 先设计基本棋盘代码，完成基础存储功能 

import java.io.Serializable;

/**
 * @author: Troy.Chen(失足程序员 ， 15388152619)
 * @create: 2020-11-23 22:37
 **/
public class Wzlz implements Serializable {

    private static final long serialVersionUID = 1L;

    /*用于A* 算法的移动寻路导航，*/
    protected int[][] blockCells;
    /*棋盘上每个格子状态*/
    protected Qiu[][] qiuCells;

    public Wzlz() {
        blockCells = new int[8][8];
        qiuCells = new Qiu[8][8];
        for (int z = 0; z < blockCells.length; z++) {
            for (int x = 0; x < blockCells[z].length; x++) {
                blockCells[z][x] = 0;
                qiuCells[z][x] = new Qiu(0, x, z);
            }
        }
    }

    public class Qiu {
        /*1-5是五个颜色的球，6是彩色万能球*/
        private int qiuId;
        private int x;
        private int z;
        private int zhadan;

        public Qiu() {
        }

        public Qiu(int qiuId, int x, int z) {
            this.qiuId = qiuId;
            this.x = x;
            this.z = z;
        }

        public int getQiuId() {
            return qiuId;
        }

        public void setQiuId(int qiuId) {
            this.qiuId = qiuId;
        }

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getZ() {
            return z;
        }

        public void setZ(int z) {
            this.z = z;
        }

        public int getZhadan() {
            return zhadan;
        }

        public void setZhadan(int zhadan) {
            this.zhadan = zhadan;
        }
    }

    public void print() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("==============================================================");
        stringBuilder.append("
");
        for (int z = 0; z < qiuCells.length; z++) {
            for (int x = 0; x < qiuCells[z].length; x++) {
                stringBuilder.append(qiuCells[z][x].getQiuId() + "(" + qiuCells[z][x].getZhadan() + ")" + ", ");
            }
            stringBuilder.append("
");
        }
        stringBuilder.append("==============================================================");
        System.out.println(stringBuilder.toString());
    }
}

初始化一下类，然后看一下棋盘打印

import java.io.Serializable;

/**
 * @author: Troy.Chen(失足程序员 ， 15388152619)
 * @create: 2020-11-23 22:59
 **/
public class WzlzMain implements Serializable {

    private static final long serialVersionUID = 1L;

    public static void main(String[] args) {
        Wzlz wzlzTest = new Wzlz();
        wzlzTest.print();
    }


    public static void test(int[][] cells, Wzlz.Qiu[][] qius, int x, int z, int qiu) {
        /*设置格子阻挡信息*/
        cells[z][x] = 1;
        /*设置球的id*/
        qius[z][x].setQiuId(qiu);
    }
}

棋盘初始化完成；

如何消除棋子；

如何只是横向或者纵向，我们想很多人都知道。

我先看一段简单代码

    public static void xiaochu(int[][] cells, Wzlz.Qiu[][] qius) {
        Set<Wzlz.Qiu> qiuSet = new HashSet<>();
        /*消除横线算法*/
        for (int z = 0; z < qius.length; z++) {
            int qiuid = 0;
            List<Wzlz.Qiu> qiuList = new ArrayList<>();
            for (int x = 0; x < qius[z].length; x++) {
                final Wzlz.Qiu qiu = qius[z][x];
                if (qiu.getQiuId() == 0 || (qiuid != 0 && qiu.getQiuId() != 6/*不是万能球*/ && qiu.getQiuId() != qiuid)) {
                    if (qiuList.size() >= 5) {
                        qiuSet.addAll(qiuList);
                    }
                    qiuid = 0;
                    qiuList.clear();
                }

                if (qiu.getQiuId() != 0) {
                    if (qiu.getQiuId() != 6) {
                        /*记录除万能球在内的；连续球的数量*/
                        qiuid = qiu.getQiuId();
                    }
                    qiuList.add(qiu);
                }
            }
            if (qiuList.size() >= 5) {
                qiuSet.addAll(qiuList);
            }
        }
        for (Wzlz.Qiu qiu : qiuSet) {
            qiu.setQiuId(0);
            /*清理阻挡状态*/
            cells[qiu.getZ()][qiu.getX()] = 0;
        }
    }

我们先来看一段消除横线连珠的代码

编写一下测试代码，这段代码折叠一下

    public static void main(String[] args) {
        Wzlz wzlzTest = new Wzlz();
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 0, 0, 3);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 1, 0, 6);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 2, 0, 6);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 3, 0, 3);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 4, 0, 3);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 5, 0, 4);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 6, 0, 4);
        wzlzTest.print();
        xiaochu(wzlzTest.blockCells, wzlzTest.qiuCells);
        wzlzTest.print();
    }

查看一下结果

消除成功；

看到这里，可能还没有发现一个问题

我们修改一下测试代码，我刚才测试代码的第一个球的颜色改为1，把第6个球的颜色改3，也就是2-6是相同的5个颜色

再来看执行效果

可以看出来，棋子并没有被消除；

原因是这段代码是单链循环，

单身我们理想的效果是不是应该是这样？第一个，开始往后找，如果不对，从第二个开始往后找；

所以我们修改递归循环代码

public static void xiaochu(int[][] cells, Wzlz.Qiu[][] qius) {
        Set<Wzlz.Qiu> qiuSet = new HashSet<>();
        /*消除横线算法*/
        for (int z = 0; z < qius.length; z++) {
            for (int x = 0; x < qius[z].length; x++) {
                int qiuid = 0;
                List<Wzlz.Qiu> qiuList = new ArrayList<>();
                for (int x1 = x; x1 < qius[z].length; x1++) {
                    final Wzlz.Qiu qiu = qius[z][x1];
                    if (qiu.getQiuId() == 0 || (qiuid != 0 && qiu.getQiuId() != 6/*不是万能球*/ && qiu.getQiuId() != qiuid)) {
                        if (qiuList.size() >= 5) {
                            qiuSet.addAll(qiuList);
                        }
                        qiuid = 0;
                        qiuList.clear();
                    }

                    if (qiu.getQiuId() != 0) {
                        if (qiu.getQiuId() != 6) {
                            /*记录除万能球在内的；连续球的数量*/
                            qiuid = qiu.getQiuId();
                        }
                        qiuList.add(qiu);
                    }
                }

                if (qiuList.size() >= 5) {
                    qiuSet.addAll(qiuList);
                }
            }
        }
        for (Wzlz.Qiu qiu : qiuSet) {
            qiu.setQiuId(0);
            /*清理阻挡状态*/
            cells[qiu.getZ()][qiu.getX()] = 0;
        }
    }

注意for里面的x和for里面的x1；这两个循环

来看看效果

第2-6个球成功消除；

横线消除，竖线消除其实就是一个道理，只是换一下循环方向就能实现；

暂时就不再赘述；

那么问题和难点在哪里？

其实因为消除规则是《米》字型的，也就是斜线消除；

其实根据刚才写法，找到消除规则和算法并不难；

只需要把x和z坐标都加一取下一个格子就能判断，就不在赘述；

import com.ty.tools.dlog.DLogger;

import java.io.Serializable;

/**
 * @author: Troy.Chen(失足程序员 ， 15388152619)
 * @create: 2020-11-18 10:37
 **/
public class WzlzTest implements Serializable {

    private static final long serialVersionUID = 1L;
    private static final DLogger log = DLogger.getLogger();

    public static void main(String[] args) {
        int mx = 7;
        int x = 0;
        int z = 0;
        /* todo         正方形的左上方的三角形 ↙↙↙↙            */
        while (true) {
            int z1 = z;
            int x1 = x;
            while (true) {
                System.out.print("[" + x1 + "," + z1 + "]");
                x1--;
                z1++;
                if (x1 < 0 || z1 > mx) {
                    break;
                }
            }
            System.out.println();
            if (x < 7) {
                x++;
            } else if (z <= mx) {
                z++;
            }

            if (x >= mx && z > mx) {
                break;
            }
        }
        System.out.println("=================================================================");
        x = 7;
        z = 0;
        /*    todo        从左边一直往右边斜 ↘↘↘↘            */
        while (true) {
            int z1 = z;
            int x1 = x;
            while (true) {
                System.out.print("[" + x1 + "," + z1 + "]");
                x1++;
                z1++;
                if (x1 > mx || z1 > mx) {
                    break;
                }
            }
            System.out.println();
            if (x > 0) {
                x--;
            } else if (z <= mx) {
                z++;
            }
            if (z > mx && x <= 0) {
                break;
            }
        }
        System.exit(0);
    }

}

这是寻找格子的基本算法，愿意的可以打开看看；

如果说这不是重点那么什么才是重点？

其实上面的代码不知道你们发现了没有；其实是再一次移动棋子后去调用执行查找的，每一次都要重新组装棋子。

其实我们是不是可以一次性把棋子组装完成？

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * @author: Troy.Chen(失足程序员 ， 15388152619)
 * @create: 2020-11-23 22:37
 **/
public class Wzlz implements Serializable {

    private static final long serialVersionUID = 1L;

    /*用于A* 算法的移动寻路导航，*/
    protected int[][] blockCells;
    /*棋盘上每个格子状态*/
    protected Qiu[][] qiuCells;
    /*纵横交错的排列*/
    protected List<List<Wzlz.Qiu>> qiuLines = new LinkedList<>();


    public Wzlz() {
        blockCells = new int[8][8];
        qiuCells = new Qiu[8][8];
        for (int z = 0; z < blockCells.length; z++) {
            for (int x = 0; x < blockCells[z].length; x++) {
                blockCells[z][x] = 0;
                qiuCells[z][x] = new Qiu(0, x, z);
            }
        }
        resetHangline();
    }

    /**
     * 四个方向的组装
     */
    public void resetHangline() {
        if (qiuCells == null || qiuCells.length < 1) {
            return;
        }
        qiuLines = new ArrayList<>();
        /* todo    组装 横着的行数据 → */
        for (int z = 0; z < qiuCells.length; z++) {
            List<Wzlz.Qiu> line = new LinkedList<>();
            for (int x = 0; x < qiuCells[z].length; x++) {
                line.add(qiuCells[z][x]);
            }
            qiuLines.add(line);
        }

        /* todo    组装 竖着的行数据 → */
        for (int x = 0; x < qiuCells[0].length; x++) {
            List<Wzlz.Qiu> line = new LinkedList<>();
            for (int z = 0; z < qiuCells.length; z++) {
                line.add(qiuCells[z][x]);
            }
            qiuLines.add(line);
        }

        int mx = qiuCells.length - 1;
        int x = 0;
        int z = 0;
        /* todo    组装  正方形的左上方的三角形 ↙↙↙↙            */
        while (true) {
            int z1 = z;
            int x1 = x;
            List<Wzlz.Qiu> line = new LinkedList<>();
            while (true) {
                line.add(qiuCells[z1][x1]);
//                System.out.print("[" + x1 + "," + z1 + "]");
                x1--;
                z1++;
                if (x1 < 0 || z1 > mx) {
                    break;
                }
            }
            qiuLines.add(line);
//            System.out.println();
            if (x < 7) {
                x++;
            } else if (z <= mx) {
                z++;
            }
            if (x >= mx && z > mx) {
                break;
            }
        }

        x = qiuCells.length - 1;
        z = 0;
        /*    todo        从左边一直往右边斜 ↘↘↘↘            */
        while (true) {
            int z1 = z;
            int x1 = x;
            List<Wzlz.Qiu> line = new LinkedList<>();
            while (true) {
//                System.out.print("[" + x1 + "," + z1 + "]");
                line.add(qiuCells[z1][x1]);
                x1++;
                z1++;
                if (x1 > mx || z1 > mx) {
                    break;
                }
            }
            qiuLines.add(line);
//            System.out.println();
            if (x > 0) {
                x--;
            } else if (z <= mx) {
                z++;
            }
            if (z > mx && x <= 0) {
                break;
            }
        }
        for (Iterator<List<Wzlz.Qiu>> integerIterator = qiuLines.iterator(); integerIterator.hasNext(); ) {
            List<Wzlz.Qiu> next = integerIterator.next();
            if (next.size() < 5) {
                integerIterator.remove();
            }
        }
    }

    public class Qiu {
        /*1-5是五个颜色的球，6是彩色万能球*/
        private int qiuId;
        private int x;
        private int z;
        private int zhadan;

        public Qiu() {
        }

        public Qiu(int qiuId, int x, int z) {
            this.qiuId = qiuId;
            this.x = x;
            this.z = z;
        }

        public int getQiuId() {
            return qiuId;
        }

        public void setQiuId(int qiuId) {
            this.qiuId = qiuId;
        }

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getZ() {
            return z;
        }

        public void setZ(int z) {
            this.z = z;
        }

        public int getZhadan() {
            return zhadan;
        }

        public void setZhadan(int zhadan) {
            this.zhadan = zhadan;
        }
    }

    public void print() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("==============================================================");
        stringBuilder.append("
");
        for (int z = 0; z < qiuCells.length; z++) {
            for (int x = 0; x < qiuCells[z].length; x++) {
                stringBuilder.append(qiuCells[z][x].getQiuId() + "(" + qiuCells[z][x].getZhadan() + ")" + ", ");
            }
            stringBuilder.append("
");
        }
        stringBuilder.append("==============================================================");
        System.out.println(stringBuilder.toString());
    }
}

于是有了以上代码，第一次初始化就把横线，纵向，斜线的连线全部组装完成

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * @author: Troy.Chen(失足程序员 ， 15388152619)
 * @create: 2020-11-23 22:59
 **/
public class WzlzMain implements Serializable {

    private static final long serialVersionUID = 1L;

    public static void main(String[] args) {
        Wzlz wzlzTest = new Wzlz();
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 0, 0, 1);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 1, 1, 6);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 2, 2, 6);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 3, 3, 3);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 4, 4, 3);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 5, 5, 3);
        test(wzlzTest.blockCells, wzlzTest.qiuCells, 6, 6, 4);
        wzlzTest.print();
        xiaochu(wzlzTest.blockCells, wzlzTest.qiuLines);
        wzlzTest.print();
    }


    public static void test(int[][] cells, Wzlz.Qiu[][] qius, int x, int z, int qiu) {
        /*设置格子阻挡信息*/
        cells[z][x] = 1;
        /*设置球的id*/
        qius[z][x].setQiuId(qiu);
    }

    public static void xiaochu(int[][] cells, List<List<Wzlz.Qiu>> qiuLines) {
        Set<Wzlz.Qiu> xiaochu = new HashSet<>();
        for (List<Wzlz.Qiu> line : qiuLines) {
            for (int i = 0; i < line.size(); i++) {
                int qid = 0;
                List<Wzlz.Qiu> list = new ArrayList<>();
                for (int k = i; k < line.size(); k++) {
                    Wzlz.Qiu qiu = line.get(k);
                    if (qiu.getQiuId() == 0 || (qid != 0 && qid != qiu.getQiuId() && qiu.getQiuId() != 6)) {
                        if (list.size() >= 5) {
                            /*todo 前面都是连续相同的*/
                            xiaochu.addAll(list);
                        }
                        /*到这里就表示没有相同的棋子需要清理*/
                        qid = 0;
                        list.clear();
                    }
                    if (qiu.getQiuId() > 0) {
                        if (qiu.getQiuId() != 6) {
                            qid = qiu.getQiuId();
                        }
                        list.add(qiu);
                    }
                }
                if (list.size() >= 5) {
                    /*先查找最后消除*/
                    xiaochu.addAll(list);
                }
            }
        }
        for (Wzlz.Qiu qiu : xiaochu) {
            qiu.setQiuId(0);
            /*球阻挡清空*/
            cells[qiu.getZ()][qiu.getX()] = 0;
        }
    }

}

调整消除代码，这样每次获取连线代码都变得简单清晰

总结：

其实网上算法很多；但是基本都是一次性的，也就是说他们是正中的五子棋，因为只要有五个连珠的棋子就结束了需要重新来；

但是我们这个变种的。有5个相同的只会消除，然后继续玩；

所以算法稍稍不同，但是基本也是大同小异；