[苦逼程序员成长之路]3、贪吃蛇游戏

　　贪吃蛇游戏，参考着游戏功能文档写的，有些算法参考了现成的游戏代码，有些算法和想法也是自己想的和设计的，下面先说明下自己对这个游戏的想法：

　　　游戏有三个类：

　　　　Cell：格子类，用语组成格子和食物，因为食物只是一个格子组成，所以不再新建类，new一个Cell代表食物

　　　　Worm：蛇类，实现蛇的基本功能：封装了蛇的动作，包括碰撞检查，吃食物和移动

　　　　WormStage：舞台类，实现整个游戏的功能

　　　　

下面是完整的代码：

格子类：

package com;

import java.awt.Color;
/**格子类，最基本的类*/
public class Cell {
    private int row;
    private int col;
    private Color color;

    public Cell(int row, int col, Color color) {
        super();
        this.row = row;
        this.col = col;
        this.color = color;
    }

    public int getRow() {
        return row;
    }

    public void setRow(int row) {
        this.row = row;
    }

    public int getCol() {
        return col;
    }

    public void setCol(int col) {
        this.col = col;
    }

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Cell [row=" + row + ", col=" + col + "]";
    }

}

Worm类：

package com;

import java.awt.Color;
import java.util.Arrays;

/** 蛇体类，封装了蛇的动作，包括检查碰撞，吃食物和移动 */
public class Worm {
    /** 移动数据 */
    private final int CHANGELEFT = -2;
    private final int CHANGERIGHT = 2;
    private final int CHANGEDOWN = -1;
    private final int CHANGEUP = 1;

    /** 蛇的颜色和蛇的初始长度 */
    private Color wormColor;
    private Cell[] worm;

    /** 构造器，用于初始化 */
    public Worm() {
        worm = new Cell[3];
        wormColor = Color.red;
        for (int i = 0; i < 3; i++) {
            worm[i] = new Cell(5 - i, 10, Color.red);
        }

    }

    /* get方法，用于别的类中调用worm */
    public Cell[] getWorm() {
        return worm;
    }

    /** 判断碰撞算法 */
    public boolean isHit(int changeNum) {
        Cell newHead = newHead(changeNum);
        /* 如果新头不是蛇的第二节就进行碰撞算法 */
        if (newHead.getCol() != worm[1].getCol()
                || newHead.getRow() != worm[1].getRow()) {
            /* 看新头是否超出边界，超出则是发生碰撞 */
            if (newHead.getCol() < 0 || newHead.getCol() > 49
                    || newHead.getRow() < 0 || newHead.getRow() > 49) {
                return true;
            }
            /* 遍历蛇身，与新头比较，看是否重合，如果重合就是发生碰撞 */
            for (Cell cell : worm) {
                if (newHead.getCol() == cell.getCol()
                        && newHead.getRow() == cell.getRow()) {
                    return true;
                }
            }
        }

        return false;
    }

    /** 蛇的移动，传入两个参数，food表示食物，用于判断是否吃到食物，并返回，changeNum表示移动方向，0表示自动前进 */
    public boolean move(Cell food, int changeNum) {
        boolean eat = false;
        Cell newHead = newHead(changeNum);

        if (newHead.getCol() == food.getCol()
                && newHead.getRow() == food.getRow()) {
            worm = Arrays.copyOf(worm, worm.length + 1);

            eat = true;

        }
        /*如果新头不是蛇身的第二节，就移动*/
        if (newHead.getCol() != worm[1].getCol()
                || newHead.getRow() != worm[1].getRow()) {
            for (int i = worm.length - 1; i >= 1; i--) {
                worm[i] = worm[i - 1];
            }
            worm[0] = newHead;

        }
        return eat;

    }
    /**根据传入的参数，新生成一个新头，如果是0就是自动前进的新头*/
    public Cell newHead(int changeNum) {
        Cell newHead = new Cell(-1, -1, wormColor);
        Cell head = worm[0];
        Cell nextCell = worm[1];

        switch (changeNum) {
        case 0:
            newHead.setCol(head.getCol() * 2 - nextCell.getCol());
            newHead.setRow(head.getRow() * 2 - nextCell.getRow());
            break;
        case CHANGELEFT:
            newHead.setCol(head.getCol() - 1);
            newHead.setRow(head.getRow());
            break;
        case CHANGEDOWN:
            newHead.setCol(head.getCol());
            newHead.setRow(head.getRow() + 1);
            break;
        case CHANGEUP:
            newHead.setCol(head.getCol());
            newHead.setRow(head.getRow() - 1);
            break;

        case CHANGERIGHT:
            newHead.setCol(head.getCol() + 1);
            newHead.setRow(head.getRow());
            break;

        }

        return newHead;
    }

}

WormStage类：

package com;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * 游戏的主界面
 * 
 * @author 陈杰
 * 
 */
public class WormStage extends JPanel {
    /** 食物，因为只有一个食物，所以定义为静态的，以后调用方法修改食物的位置，以节省资源 */
    private static Cell food = new Cell(0, 0, Color.green);;
    /** 舞台的长宽和大小的数据，定义为常量 */
    private static final int ROWS = 50;
    private static final int COLS = 50;
    private static final int SIZE = 10;
    /** 贪吃蛇 */
    private Worm worm = new Worm();
    /** 下面是转向用到的数据 */
    private final int CHANGELEFT = -2;
    private final int CHANGERIGHT = 2;
    private final int CHANGEDOWN = -1;
    private final int CHANGEUP = 1;
    /** 分数：已经吃掉的食物总数 */
    public static int score = 0;
    /** 游戏的状态，并没有设置暂停 */
    private static int state;
    private static final int PLAYING = 0;
    private static final int GAMEOVER = 1;
    private static final String[] State = { "", "GameOver" };

    /** 在舞台上，不包括蛇体位置，通过修改col和row随机产生一个食物 */
    private void randomFood() {
        int col;
        int row;
        Random r = new Random();
        /* 在舞台内随机指定一个食物的位置，直到产生的位置不在蛇身上 */
        do {
            col = r.nextInt(COLS);
            row = r.nextInt(ROWS);
        } while (insideWorm(row, col));
        /* 设置食物的位置 */
        food.setCol(col);
        food.setRow(row);

    }

    /** 判断是否在蛇身上：用于随机产生食物判断 */
    private boolean insideWorm(int row, int col) {
        for (Cell cell : worm.getWorm()) {
            if (cell.getRow() == row && cell.getCol() == col)
                return true;
        }

        return false;
    }

    /** 重写paint方法 */
    public void paint(Graphics g) {
        paintStage(g);// 画出背景
        paintFood(g);// 画出食物
        paintWorm(g);// 画出蛇
        paintState(g);// 画出游戏状态
        paintScore(g);// 画出分数
    }

    /** 分数的绘制方法 */
    private void paintScore(Graphics g) {
        String str = "得分：" + score;
        String len = "贪吃蛇长度：" + worm.getWorm().length;
        g.setColor(Color.black);
        Font font = g.getFont();
        Font f = new Font(font.getName(), font.getStyle(), 15);
        g.setFont(f);
        g.drawString(str, 325, 540);
        g.drawString(len, 325, 580);

    }

    /** 游戏状态的绘制方法 */
    private void paintState(Graphics g) {
        g.setColor(Color.white);
        Font font = g.getFont();
        Font f = new Font(font.getName(), font.getStyle(), 60);
        g.setFont(f);

        g.drawString(State[state], 100, 200);
    }

    /** 蛇的绘制方法 */
    private void paintWorm(Graphics g) {
        /* 利用for循环，遍历蛇的所有组成cell并画出 */
        for (Cell cell : worm.getWorm()) {
            g.setColor(cell.getColor());
            g.fillRect(cell.getCol() * SIZE, cell.getRow() * SIZE, SIZE, SIZE);
            g.setColor(Color.black);
            g.drawRect(cell.getCol() * SIZE, cell.getRow() * SIZE, SIZE, SIZE);

        }

    }

    /** 食物的绘制方法 */
    private void paintFood(Graphics g) {
        g.setColor(food.getColor());
        g.fillRect(food.getCol() * SIZE, food.getRow() * SIZE, SIZE, SIZE);

    }

    /** 背景的绘制方法 */
    private void paintStage(Graphics g) {
        g.setColor(Color.black);
        g.fillRect(0, 0, 500, 500);

        g.setColor(Color.white);
        g.fillRect(0, 500, 500, 100);
        g.setColor(Color.black);
        g.drawRect(0, 500, 499, 99);
        g.drawRect(0, 500, 299, 99);
        Font font = g.getFont();
        Font f = new Font(font.getName(), font.getStyle(), 15);
        g.setFont(f);
        g.drawString("↑←↓→控制移动，[S]重新开始", 20, 540);
        g.drawString("[Q]退出游戏", 30, 580);

    }


    /** 封装移动和转向方法，如果传入0，则前进 */
    private void moveAction(int changeNum) {
        
            
            /* 判断是否发生碰撞 */
            if (worm.isHit(changeNum)) {
                /* 碰撞就结束游戏 */
                state = GAMEOVER;

            } else {
                /* 否则，转向并判断是否吃到食物 */
                if (worm.move(food, changeNum)) {
                    /* 如果吃到就加分并随机产生一个食物 */
                    score++;
                    randomFood();
                }
            }
        
    }


    
    /** action方法，整个游戏的控制方法 */
    private void action() throws Exception {
        /* 新建一个蛇 */
        worm = new Worm();
        /* 随机产生一个食物 */
        randomFood();

        /* 键盘控制：Q退出游戏；上下左右方向键控制蛇的移动；如果游戏结束，S重新开始游戏 */
        KeyListener l = new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                int key = e.getKeyCode();

                if (key == KeyEvent.VK_Q) {

                    System.exit(0);
                }
                /* 添加return，使得游戏结束，只有S键有效 */
                if (state == GAMEOVER) {
                    if (key == KeyEvent.VK_S) {
                        restart();
                    }
                    return;
                }

                switch (key) {
                case KeyEvent.VK_LEFT:
                    moveAction(CHANGELEFT);

                    break;

                case KeyEvent.VK_RIGHT:
                    moveAction(CHANGERIGHT);

                    break;

                case KeyEvent.VK_UP:
                    moveAction(CHANGEUP);

                    break;

                case KeyEvent.VK_DOWN:

                    moveAction(CHANGEDOWN);

                    break;

                }

                repaint();
            }

        };
        this.addKeyListener(l);
        this.requestFocus();
        /* 死循环控制蛇的自动前进 */
        while (true) {
            if (state == PLAYING) {
                moveAction(0);

            }

            repaint();
            Thread.sleep(500);

        }
    }

    /** 重新开始方法 */
    protected void restart() {
        /* 状态更改为PLAYING，new一个新的蛇，随机产生一个食物 */
        state = PLAYING;
        worm = new Worm();
        randomFood();

    }

    /** main方法，画出框体，面板并调用action方法启动游戏 */
    public static void main(String[] args) throws Exception {
        JFrame frame = new JFrame();
        WormStage wormStage = new WormStage();
        frame.setSize(500, 600);

        frame.add(wormStage);
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setUndecorated(true);
        frame.setVisible(true);
        wormStage.action();

    }

}