gamelogic.java

扫雷游戏

//package games;

package BomeGame;
import java.util.Random;

import java.lang.Math;

class gamelogic {

    /**表示一个10*10的棋盘*/

    private int[][] pan = new int[10][10];

    private Random random;//一个随机变量,主要作用是用来指定哪些位置为地雷

    private int BombNum = 0; //统计地雷总数

    /**游戏是否结束*/

    private boolean GameOver;

    public gamelogic(Random radom){
        this.random = random;
    }

    /**初始化数组,生成地图*/

    public void InitArray() {
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                pan[i][j] = 0;
            }
        }

        RandomArray();
        CountBomb();
        BombNum = Bomb();
    }


    /**统计地雷总数
    * @return int 返回地雷总数 */

    private int Bomb() {
        int count = 0;
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                if (pan[i][j] == 20) {
                    count += 1;
                }
            }
        }

        return count;
    }


    /**随机决定地雷的位置*/

    private void RandomArray() {
        int i, j, k;

        random = new Random();
        // 这里不一定有15个
        for (int r = 0; r < 15; r++) {
            k= Math.abs(random.nextInt()) % 64;
            i = k / 8;
            j = k % 8;
            this.pan[i][j] = 20; //指定该位置为地雷
        }
    }


    /**统计棋盘上的数据*/

    private void CountBomb() {
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                int count = 0;

                //当需要检测的单元格本身无地雷的情况下,统计周围的地雷个数
                if (pan[i][j] != 20) {
                    if ( (i - 1 >= 0) && (j - 1 >= 0)) {
                        if (pan[i - 1][j - 1] == 20) {
                            count += 1; //检测左上方空格是否是地雷
                        }
                    }

                    if ( (i - 1 >= 0)) {
                        if (pan[i - 1][j] == 20) {
                            count += 1; //检测上方空格是否为地雷
                        }
                    }

                    if ( (i - 1 >= 0) && (j + 1 <= 7)) {
                        if (pan[i - 1][j + 1] == 20) {
                            count += 1; //检测右上方是否为地雷
                        }
                    }

                    if ( (j - 1 >= 0)) {
                        if (pan[i][j - 1] == 20) {
                            count += 1; //检测左边是否为地雷
                        }
                    }

                    if ( (i >= 0) && (j + 1 <= 7)) {
                        if (pan[i][j + 1] == 20) {
                            count += 1; //右边
                        }
                    }

                    if ( (j - 1 >= 0) && (i + 1 <= 7)) {
                        if (pan[i + 1][j - 1] == 20) {
                            count += 1; //左下
                        }
                    }

                    if ( (i + 1 <= 7)) {
                        if (pan[i + 1][j] == 20) {
                            count += 1; //下
                        }
                    }

                    if ( (j + 1 <= 7) && (i + 1 <= 7)) {
                        if (pan[i + 1][j + 1] == 20) {
                            count += 1; //右下
                        }
                    }

                    pan[i][j] = count;
                }
            }
        }
    }
    /**检测已经被揭开的位置总和

    * @return 返回被揭开的数量 */

    private int countOpen() {
        int count = 0;
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                if (pan[i][j] < 20 && pan[i][j] > 9) {
                    count += 1;
                }
            }
        }

        return count;
    }



    /**检测是否胜利

    * @return 是否胜利boolean值 */

    public boolean isWin() {

        // System.out.println(BombNum +""+ countOpen());
        if ( (BombNum + countOpen()) == 64) {
            this.GameOver = true;
            return true;
        }
        else {
            return false;
        }
    }

    /**选中棋盘上的位置,并翻开

    * @param matrix 位置 */

    public void openpan(int matrix) {
        switch (getBomb(matrix)) {
            case 20: //当选中的位置为地雷,游戏结束
                setGameOver();
                break;
            case 0:
                isNull(matrix); //当选中的位置为空,则翻开周围的地图
                break;
            default:
                this.isNotNull(matrix); //否则,翻开当前位置,并作上翻开的标记
        }
    }

    /**当选中的位置为空,则翻开周围的地图

    * @param matrix 位置 */

    private void isNull(int matrix) {
        int i, j;
        i = matrix / 8;
        j = matrix % 8;

        if (pan[i][j] < 9) {
            pan[i][j] += 10;
        }

        if ( (i - 1 >= 0) && (j - 1 >= 0)) { //检测左上方空格是否是空
            if (pan[i - 1][j - 1] == 0) {
                isNull( (i - 1) * 8 + (j - 1));
            }
            if (pan[i - 1][j - 1] < 9) {
                pan[i - 1][j - 1] += 10;
            }
        }


    if ( (i - 1 >= 0)) { //检测上方空格是否为空
            if (pan[i - 1][j] == 0) {
                isNull( (i - 1) * 8 + j);
            }
            if (pan[i - 1][j] < 9) {
                pan[i - 1][j] += 10;
            }
        }

        if ( (i - 1 >= 0) && (j + 1 <= 7)) { //检测右上方是否为空
            if (pan[i - 1][j + 1] == 0) {
                isNull( (i - 1) * 8 + (j + 1));
            }
            if (pan[i - 1][j + 1] < 9) {
                pan[i - 1][j + 1] += 10;
            }
        }

        if ( (j - 1 >= 0)) { //检测左边是否为空
            if (pan[i][j - 1] == 0) {
                isNull(i * 8 + (j - 1));
            }
            if (pan[i][j - 1] < 9) {
                pan[i][j - 1] += 10;
            }
        }

        if ( (i >= 0) && (j + 1 <= 7)) { //右边
            if (pan[i][j + 1] == 0) {
                isNull(i * 8 + (j + 1));
            }
            if (pan[i][j + 1] < 9) {
                pan[i][j + 1] += 10;
            }
        }

        if ( (j - 1 >= 0) && (i + 1 <= 7)) { //左下
            if (pan[i + 1][j - 1] == 0) {
                isNull( (i + 1) * 8 + (j - 1));
            }
            if (pan[i + 1][j - 1] < 9) {
                pan[i + 1][j - 1] += 10;
            }
        }

        if ( (i + 1 <= 7)) { //下
            if (pan[i + 1][j] == 0) {
                isNull( (i + 1) * 8 + j);
            }
            if (pan[i + 1][j] < 9) {
                pan[i + 1][j] += 10;
            }
        }
       if ( (j + 1 <= 7) && (i + 1 <= 7)) { //右下
            if (pan[i + 1][j + 1] == 0) {
                isNull( (i + 1) * 8 + (j + 1));
            }
            if (pan[i + 1][j + 1] < 9) {
                pan[i + 1][j + 1] += 10;
            }
        }
    }



    /**选中棋盘上的位置,并翻开当前位置

    * @param matrix 位置 */

    private void isNotNull(int matrix) {
        int i, j;
        i = matrix / 8;
        j = matrix % 8;
        pan[i][j] += 10;
    }


    /**取得指定位置的数据

    * @param matrix 位置

    * @return int 数据 */

    public int getBomb(int matrix) {
        int i, j;
        i = matrix / 8;
        j = matrix % 8;
        return this.pan[i][j];
    }


    /**检测游戏是否结束

    * @return boolean 游戏是否结束的状态 */

    public boolean isGameOver() {
        return GameOver;
    }


    /**设置游戏结束 */

    private void setGameOver() {
        GameOver = true;
    }


    /**开新局*/

    public void setNewGame() {
        this.GameOver = false;
    }


    /**指定位置是否被揭开

    * @param matrix 位置

    * @return boolean 返回是否可以被揭开 */

    public boolean isFree(int matrix) {
        int i, j;
        i = matrix / 8;
        j = matrix % 8;
        return pan[i][j] < 8 || pan[i][j] == 20;
    }

}