Java 小游戏-贪吃蛇

Java 在学习 面向对象阶段 对一个小游戏 贪吃蛇项目的分析与理解

开发文档：有两个对象 ：贪吃蛇对象 和 食物(方块) 对象

• 食物(Cell)对象
  • 有两个私有成员变量坐标
    • x(横坐标)
    • y(纵坐标)
• 贪吃蛇(Worm)对象 
  • 有五个静态成员变量
    • DEFAULT_LENGTH 默认贪吃蛇的长度
    • UP 向上
    • DOWN 向下
    • LEFT 向左
    • RIGHT 向右 
  • 私有 变量 currentDirection 当前的运行方向
  • 私有 方块数组

　　贪吃蛇对象动作有 移动 和 碰撞(撞墙 、撞自己、以及吃食物)

• 移动 
• 碰撞 
  • 食物 刷新时 判断 是否和 蛇对象 位置重复  
  • 撞墙  判断赦对象的头部坐标 是否碰撞到围墙
  • 撞自己  遍历自己身体的数组 和头部坐标 判断是否碰撞
  • 吃食物  也就是头部 碰撞到食物对象

Cell  食物 格子类 代码

public class Cell {
    private int x;
    private int y;

    public Cell() {
    }

    public Cell(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

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

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public String toString() {
        return "[" + x + "," + y + "]";
    }
}

Worm贪吃蛇 类代码

public class Worm {
    public static final int DEFAULT_LENGTH = 12;

    private Cell[] cells;

    public static final int UP = 1;
    public static final int DOWN = -1;
    public static final int LEFT = 2;
    public static final int RIGHT = -2;

    private int currentDirection;

    public Worm(){
        cells = new Cell[DEFAULT_LENGTH];
        for (int i = 0; i < cells.length; i++) {
            cells[i] = new Cell(i,0);
        }
        currentDirection = DOWN;
    }

    public boolean contains(int x,int y){
        for (int i = 0; i < cells.length; i++) {
            Cell node = cells[i];
            if (node.getX() == x && node.getY() == y) {
                return true;
            }
        }
        return false;
    }

    /**
     * 1) 计算currentDirection与direction的和, 如果是0表示反向了, 就结束方法返回, 不进行任何动作
     * 2)currentDirection = direction 改变当前的方向, 作为下次运行的方向 3) 判断当前头节点的坐标与食物对象的坐标一致
     * 如果一致说明是吃到食物了 4) 如果吃到食物, 就将cells数组进行扩容 将cells数组内容的每个元素向后移动. 5)
     * 将新头节点插入的头位置cells[0]=newHead 6) 返回是否吃到食物
     */
    public boolean creep(int direction,Cell food){
        if(currentDirection + direction == 0){
            return false;
        }
        currentDirection = direction;
        Cell head = createHead(direction);
        boolean eat = head.getX() == food.getX() && head.getX() == food.getY();
        if(eat){
            cells = Arrays.copyOf(cells,cells.length + 1);
        }
        for (int i = cells.length-1; i >= 1; i--) {
            cells[i] = cells[i - 1];
        }
        cells[0] = head;
        return eat;
    }
    public boolean hit(){
        return hit(currentDirection);
    }
    public boolean hit(int direction){
        if(currentDirection + direction == 0){
            return false;
        }
        Cell head = createHead(direction);
        if(head.getX() <0 || head.getX()>=WormStage.COLS || head.getY() < 0 || head.getY() >= WormStage.ROWS){
            return true;
        }
        for (int i = 0; i < cells.length-1; i++) {
            Cell node = cells[i];
            if(node.getX() == head.getX() && node.getY() == head.getY()){
                return true;
            }
        }
        return false;
    }
    public boolean creep(Cell food){
        return creep(currentDirection,food);
    }
    public void creep(){
        for (int i = cells.length-1; i >=1 ; i--) {
            cells[i] = cells[i-1];
        }
        cells[0] = createHead(currentDirection);
    }
    private Cell createHead(int direction){
        int x = cells[0].getX();
        int y = cells[0].getY();
        switch (direction){
            case DOWN:
                y++;
                break;
            case UP:
                y--;
                break;
            case LEFT:
                x--;
                break;
            case RIGHT:
                x++;
                break;
        }
        return new Cell(x,y);

    }
    public Cell[] getCells(){
        return Arrays.copyOf(cells,cells.length);
    }
    /**
    *  重写toString()
    */
    @Override
    public String toString() {
        return Arrays.toString(cells);
    }
}

主程序WormStage 代码

public class WormStage extends JPanel {
    public static final int ROWS = 35;
    public static final int COLS = 35;
    public static int CELL_SIZE = 10;
    public static Image background;
    public static Image foodImage;
    public static Image cellImage;

    private Worm worm;
    private Cell food;

    public WormStage(){
        //如下加载图片的方法，知道即可，图片必须与WormStage.java
        //在同一个包中！
        background = Toolkit.getDefaultToolkit().
                getImage("WormImg/bg.png");
        foodImage = Toolkit.getDefaultToolkit().
                getImage("WormImg/food.png");
        cellImage = Toolkit.getDefaultToolkit().
                getImage("WormImg/cell.png");
        worm = new Worm();
        food = createFood();
    }
    private Cell createFood() {
        int x;
        int y;
        Random r = new Random();
        do {
            x = r.nextInt(COLS);
            y = r.nextInt(ROWS);
        } while (worm.contains(x, y));
        return new Cell(x, y);
    }
    @Override
    public String toString() {
        return "worm:" + worm + "\nfood:" + food;
    }

    @Override
    public void paint(Graphics g) {
        // 填充背景色
        g.drawImage(background, 0, 0, null);
        // 绘制食物
        g.translate(54, 49);
        g.drawImage(foodImage,
                CELL_SIZE * food.getX(), CELL_SIZE * food.getY(), null);
        // 绘制蛇
        Cell[] cells = worm.getCells();
        for (int i = 0; i < cells.length; i++) {
            Cell node = cells[i];
            g.drawImage(cellImage,
                    CELL_SIZE * node.getX(), CELL_SIZE * node.getY(), null);

        }
    }
    public static void main(String[] args) {
        // 启动软件 WormStage.java
        JFrame frame = new JFrame("贪吃蛇");
        WormStage pane = new WormStage();// 面板
        frame.add(pane);// 窗口添加面板
        frame.setSize(470, 480);// 设置窗口的大小
        frame.setLocationRelativeTo(null);// frame居中
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pane.action();// 启动蛇的运行
    }
    private void action() {
        // worm.creep(food);
        // repaint();//swing JPanel 中声明的方法，会尽快的启动
        // 界面的重绘功能，尽快调用paint(g) 方法绘制界面
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                // 爬行控制逻辑
                if (worm.hit()) {
                    worm = new Worm();
                    food = createFood();
                } else {
                    boolean eat = worm.creep(food);
                    if (eat) {
                        food = createFood();
                    }
                }
                repaint();
            }
        }, 0, 1000 / 7);
        // this 就是当前舞台面板
        this.requestFocus();
        this.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                // key 代表哪个按键被按下！
                int key = e.getKeyCode();
                switch (key) {
                    case KeyEvent.VK_UP:// 上箭头按下！
                        creepTo(Worm.UP);
                        break;
                    case KeyEvent.VK_DOWN:// 下箭头按下！
                        creepTo(Worm.DOWN);
                        break;
                    case KeyEvent.VK_LEFT:// 左箭头按下！
                        creepTo(Worm.LEFT);
                        break;
                    case KeyEvent.VK_RIGHT:// 右箭头按下！
                        creepTo(Worm.RIGHT);
                        break;
                }
            }
        });// addKeyListener
    }// action()
    private void creepTo(int direction) {
        if (worm.hit(direction)) {
            worm = new Worm();
            food = createFood();
        } else {
            boolean eat = worm.creep(direction, food);
            if (eat) {
                food = createFood();
            }
        }
        repaint();
    }
}