小遊戲五子連珠消除解決方案

序言

五子連珠，顧名思義就是當有五個相同的球在一條直線上，橫，豎，斜，總共四個方向呈《米》型的消除規則，達到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("\n");
        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("\n");
        }
        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("\n");
        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("\n");
        }
        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個相同的只會消除，然後繼續玩；

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