【JAVA小游戏】炸飞机

1、游戏入口

package com.game;

public class AircraftModelTestDriver {
    public static void main(String[] args) {
        BombAirplaneGame game = new BombAirplaneGame();
        game.startGame();
    }
}

2、飞机模型

package com.game;

class AircraftModel {
    int ROW = 4;
    int COLUMN = 5;

    int[] head;
    int[][] position = new int[10][2];

    /**
     * 获取飞机头的坐标
     *
     * @return 飞机头坐标
     */
    public int[] getHead() {
        head = new int[]{position[0][0], position[0][1]};
        return head;
    }

    /**
     * 飞机头向上的飞机整体坐标
     *
     * @return 整体坐标
     */
    public int[][] directionUp() {
        position = NewPosition();
        return position;
    }

    /**
     * 飞机头向下的飞机整体坐标
     *
     * @return 整体坐标
     */
    public int[][] directionDown() {
        position = makeNegate(NewPosition());
        return position;
    }

    /**
     * 飞机头向右的飞机整体坐标
     *
     * @return 整体坐标
     */
    public int[][] directionRight() {
        position = makeExchange(NewPosition());
        return position;
    }

    /**
     * 飞机头向左的飞机整体坐标
     *
     * @return 整体坐标
     */
    public int[][] directionLeft() {
        position = makeExchange(makeNegate(NewPosition()));
        return position;
    }

    /**
     * 通过左下角坐标，更新整个飞机位置坐标
     *
     * @param location："54" 代表 X轴 = 5，Y轴 = 4
     * @return 更新后的飞机位置坐标
     */
    public int[][] updateLocation(String location) {
        for (int i = 0; i < position.length; i++) {
            position[i][0] = position[i][0] + (int) location.charAt(0) - (int) ('0');
            position[i][1] = position[i][1] + (int) location.charAt(1) - (int) ('0');
        }
        return position;
    }

    /**
     * 通过左下角坐标，更新整个飞机位置坐标
     *
     * @param location：{5, 4} 代表 X轴 = 5，Y轴 = 4
     * @return 更新后的飞机位置坐标
     */
    public int[][] updateLocation(int[] location) {
        for (int i = 0; i < position.length; i++) {
            position[i][0] = position[i][0] + location[0];
            position[i][1] = position[i][1] + location[1];
        }
        return position;
    }

    /**
     * 通过左下角坐标，更新整个飞机位置坐标
     *
     * @param location：{5, 4} 代表 X轴 = 5，Y轴 = 4
     * @param data：需要更新的坐标
     * @return 更新后的飞机位置坐标
     */
    public int[][] updateLocation(int[] location, int[][] data) {
        for (int i = 0; i < data.length; i++) {
            data[i][0] = data[i][0] + location[0];
            data[i][1] = data[i][1] + location[1];
        }
        return data;
    }

    /**
     * 随机返回一个方向的飞机模型
     *
     * @return 模型坐标
     */
    public int[][] getRandomLocation() {
        int num = (int) (Math.random() * 4);
        switch (num) {
            case 0:
                position = directionUp();
                break;
            case 1:
                position = directionDown();
                break;
            case 2:
                position = directionLeft();
                break;
            case 3:
                position = directionRight();
                break;
        }
        return position;
    }

    /**
     * 飞机初始坐标
     *
     * @return 飞机初始坐标
     */
    private int[][] NewPosition() {
        return new int[][]{
                {2, 3},
                {0, 2}, {1, 2}, {2, 2}, {3, 2}, {4, 2},
                {2, 1},
                {1, 0}, {2, 0}, {3, 0},
        };
    }

    /**
     * 飞机坐标上下翻转
     *
     * @param data 飞机坐标
     * @return 上下翻转后的坐标
     */
    private int[][] makeNegate(int[][] data) {
        for (int i = 0; i < data.length; i++) {
            data[i][1] = ROW - data[i][1];
        }
        return data;
    }

    /**
     * 飞机坐标左右翻转
     *
     * @param data 飞机坐标
     * @return 左右翻转后的坐标
     */
    private int[][] makeExchange(int[][] data) {
        for (int i = 0; i < data.length; i++) {
            int a = data[i][0];
            int b = data[i][1];
            data[i][0] = b;
            data[i][1] = a;
        }
        return data;
    }
}

3、游戏生成、规则判定、绘制棋盘

package com.game;

import java.util.Scanner;
import java.util.regex.Pattern;

class BombAirplaneGame {
    // 定义三个模型
    AircraftModel airmodel1;
    AircraftModel airmodel2;
    AircraftModel airmodel3;

    // 棋盘 10 × 10
    int SIZE = 10;
    int[][] CHECKERBOARD = new int[SIZE][SIZE];
    int[][] CHECKERBOARD_GUESS = new int[SIZE][SIZE];

    // 击落数量
    int KILL_NUM = 0;

    // 绘制棋盘
    String DRAWCHESSBOARD_1 = "  *-----*-----*-----*-----*-----*-----*-----*-----*-----*-----*";
    String DRAWCHESSBOARD_2 = "     0     1     2     3     4     5     6     7     8     9   ";

    // 输入坐标校验
    Pattern pattern = Pattern.compile("[0-9][0-9]");

    /**
     * 游戏入口
     */
    public void startGame() {
        // 实例化 三个飞机初始模型
        airmodel1 = new AircraftModel();
        airmodel2 = new AircraftModel();
        airmodel3 = new AircraftModel();

        // 获取飞机随机方向，与模型方位，输出棋盘坐标
        do {
            checkerboardLayout(airmodel1);
            checkerboardLayout(airmodel2);
            checkerboardLayout(airmodel3);
        } while (!aircraftModelToCheckerBoard(airmodel1, airmodel2, airmodel3));

        // 画出棋盘
//        printCheckerBoard();
        int n = 1;
        while (true) {
            // 先画出坐标
            printCheckerBoardGuess();
            // 输入猜想的坐标
            String coordinate = "";
            while (!pattern.matcher(coordinate).matches()) {
                System.out.print("请输入一个 00~99 的位置坐标（" + n + "）：");
                Scanner input= new Scanner(System.in);
                coordinate = input.next();
            }
            n++;

            // 写入猜想坐标
            if (writeGuessPosition(coordinate)) {
                System.out.flush();
                if (KILL_NUM == 3) {
                    break;
                }
            }
        }
        // 画出棋盘
        printCheckerBoardGuess();
        System.out.println("游戏结束~ 共猜想 " + n + " 次！");
        printCheckerBoard();

    }

    /**
     * 随机获取一个模型左下角坐标，然后根据坐标生成一个方向随机的模型，然后输出到棋盘
     * @param airmodel 飞机模型
     */
    public void checkerboardLayout(AircraftModel airmodel) {
        do {
            // 棋盘内 随机三个位置 作为飞机模型左下角坐标
            int[] coordinate = getRandomList();
            // 获取飞机随机方向，结合模型方位，输出棋盘坐标
            airmodel.updateLocation(coordinate, airmodel.getRandomLocation());
        } while (!boundaryJudgment(airmodel.position));
        // 打印坐标信息
//        printList(airmodel);
    }

    /**
     * 把全部模型位置写入棋盘，如果位置有重叠，则返回false，反之返回true并写入棋盘
     * @param airmodels 模型类表
     * @return 无重叠，返回true；有重叠，返回false
     */
    public boolean aircraftModelToCheckerBoard(AircraftModel... airmodels) {
        int[][] checkerboard = new int[SIZE][SIZE];
        for (AircraftModel airmodel : airmodels) {
            for (int[] i : airmodel.position) {
                if (checkerboard[i[0]][i[1]] == 0) {
                    checkerboard[i[0]][i[1]] = 1;
                } else {
                    return false;
                }
            }
            checkerboard[airmodel.getHead()[0]][airmodel.getHead()[1]] = 2;
        }
        CHECKERBOARD = checkerboard;
        return true;
    }

    /**
     * 判断输入坐标是否超出索引
     * @param data 方位坐标
     * @return 超出索引，返回false；反之，返回true
     */
    public boolean boundaryJudgment(int[][] data) {
        for (int[] i : data) {
            try {
                int j = CHECKERBOARD[i[0]][i[1]];
            } catch (ArrayIndexOutOfBoundsException e) {
                return false;
            }
        }
        return true;
    }

    /**
     * 输入坐标命中情况，未命中标记’1‘；命中非头部标记’2‘；命中头部标记’3‘
     * @param coordinate 坐标
     * @return 坐标重复 或者 异常，返回false；反之，返回true
     */
    public boolean writeGuessPosition(String coordinate) {
        int y = (int) coordinate.charAt(0) - (int) ('0');
        int x = (int) coordinate.charAt(1) - (int) ('0');
        try {
            if (CHECKERBOARD_GUESS[x][y] != 0) {
                System.out.println("重复坐标！请重新输出！");
                return false;
            }

            switch (CHECKERBOARD[x][y]) {
                case 0:
                    CHECKERBOARD_GUESS[x][y] = 1;
//                    System.out.println("MISS!");
                    break;
                case 1:
                    CHECKERBOARD_GUESS[x][y] = 2;
//                    System.out.println("HIT!");
                    break;
                case 2:
                    CHECKERBOARD_GUESS[x][y] = 3;
                    KILL_NUM++;
//                    System.out.println("KILL!");
                    break;
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("坐标异常！请重新输出！");
            return false;
        }
        return true;
    }

    /**
     * 随机获取两个 0~9 的整数，组成数组输出
     * @return 两个整数的数组
     */
    public int[] getRandomList() {
        int[] nums = new int[2];
        nums[0] = (int) (Math.random() * 10);
        nums[1] = (int) (Math.random() * 10);
        return nums;
    }

    /**
     * 棋盘布局图输出
     */
    public void printCheckerBoard() {
        System.out.println(DRAWCHESSBOARD_1);
        for (int i = CHECKERBOARD.length - 1; i >= 0; i--) {
            StringBuilder printText = new StringBuilder(i + " *");
            for (int j = 0; j < CHECKERBOARD[i].length; j++) {
                switch (CHECKERBOARD[i][j]) {
                    case 0:
                        printText.append("     |");
                        break;
                    case 1:
                        printText.append("  ●  |");
                        break;
                    case 2:
                        printText.append("  ✪  |");
                        break;
                }
            }
            System.out.println(printText);
            System.out.println(DRAWCHESSBOARD_1);
        }
        System.out.println(DRAWCHESSBOARD_2);
    }

    /**
     * 猜测结果图输出
     */
    public void printCheckerBoardGuess() {
        System.out.println(DRAWCHESSBOARD_1);
        for (int i = CHECKERBOARD_GUESS.length - 1; i >= 0; i--) {
            StringBuilder printText = new StringBuilder(i + " *");
            for (int j = 0; j < CHECKERBOARD_GUESS[i].length; j++) {
                switch (CHECKERBOARD_GUESS[i][j]) {
                    case 0:
                        printText.append("     |");
                        break;
                    case 1:
                        printText.append("  △  |");
                        break;
                    case 2:
                        printText.append("  ●  |");
                        break;
                    case 3:
                        printText.append("  ✪  |");
                        break;
                }
            }
            System.out.println(printText);
            System.out.println(DRAWCHESSBOARD_1);
        }
        System.out.println(DRAWCHESSBOARD_2);
    }
}