贪吃蛇之于程序员就像巴大蝴之于小智

　　对的，出了新手村就不用了的那种。

　　惯例发包，还是加了rr3，明明根本没人下。

　　里面三个文件，一个是纯打包的jar，一个是能能运行的jar，一个是能运行的exe，我测试没问题，运行不了请检查环境变量和人品。

　　不过按照习惯，最后还是会把所有代码直接发出来的。

　　第一次用了下枚举类，还是挺简单的，百度随便搜两篇博客就懂了，用起来也挺智能，最重要的是用1234来表示方向太low了。

　　像这样：

public enum Orientation {UP, DOWN, LEFT, RIGHT}

　　之后用起来直接当常量引用就行了(比如Orientation.UP)，不过数据类型是Orientation要注意。

　　我之前一直不敢写这玩意是因为我不知道怎么用格子来表示坐标，直到今天才知道我想多了，格子的左上角就是坐标，剩下的是格子边长的事。

　　

　　我觉得自己的代码已经挺好看的了，反正比网上某些一个java文件搞定一切的要好一点。

　　还有一个bug，之前也看到别人有。

　　描述一下的话就是我模拟贪吃蛇移动的延迟使用的线程睡眠方法，像这样：

Thread.sleep(100)

　　这带来了一个什么问题呢，就是，虽然我在程序里做了判断，不允许玩家往后退，但是如果你手够快，能在线程睡着的这段时间里连续改两次方向，从结果来说就是往后退了。

　　举个例子：

　　　　蛇正在往右走，你按了方向左，这没有任何作用，因为我加了判断，阻止你这么做。

　　　　但是你在100毫秒内先按上，方向就变成了上，但是因为线程还在睡，所以蛇的位置没有更新，这时你又按了左，这样是允许的，因为你是从上变成左，并不是掉头。

　　　　结果就是蛇开始往左跑，如果蛇身只有两节，那就是自由掉头，如果大于二，蛇会咬到自己的第三节身体导致游戏失败。

　　……我也不知道该怎么解决这个bug……以后再说……

　　就敲着这段字的时间里我发现了一个问题，我是直接实现KeyListener接口的，这个是我抄人家的我错了。

　　我的做法是做成内部类然后继承KeyAdapter的，直接用接口会多出来两个用不着的方法，太难看了。

　　但是懒得重新打包，也不想更新版本号了，一会下边发的代码会是新版本的代码。

　　一个下午加上一个晚上搞定一个贪吃蛇，我还是有点进步的。

package snake;

/** 
 * 枚举类。
 * 定义了四个方向。
 * 
 * @author mlxy
 * @version 1.0
 */
public enum Orientation {
    UP, DOWN, LEFT, RIGHT
}

package snake;

/**
 * 运行类。
 * 内容很简单，初始化框架。
 * 
 * @author mlxy
 * @version 1.0
 */
public class Run {
    public static void main(String[] args) {
        new MainFrame();
    }
}

package snake;

import javax.swing.JFrame;

/**
 * 主框架类。
 * 初始化框架内容和相关属性。
 * 
 * @author mlxy
 * @version 1.0
 */
public class MainFrame extends JFrame {
    private static final long serialVersionUID = 3693516591938222507L;
    GamePad gamePad;
    
    MainFrame() {
        this.gamePad = new GamePad();
        this.add(gamePad);
        this.setResizable(false);
        this.pack();
        
        this.setTitle("Snake");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
        this.setVisible(true);
    }
}

package snake;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

import javax.swing.JPanel;

/** 
 * 游戏面板类。
 * 用变量存储了游戏分数，蛇的引用，食物的引用。
 * 还包括了游戏进行中所需要的所有方法。
 * 实现了Runnable接口，用以将自身作为一个线程启动。
 * 包含了一个内部类作为监听器，用以监听玩家的键盘输入。
 * 
 * @author mlxy
 * @version 1.0
 */
public class GamePad extends JPanel implements Runnable {
    private static final long serialVersionUID = -6102074989461150615L;
    int point;
    Snake snake;
    Food food;
    
    /** 常量，游戏面板的边长。*/
    static int SIDELEN_OF_PAD = 500;
    /** 常量，一个格子的边长。*/
    static int SIDELEN_OF_GRID = 10;
    
    GamePad() {
        // 设置偏好大小，+1是为了能看到边界线，因为边界线宽1像素。
        this.setPreferredSize(new Dimension(SIDELEN_OF_PAD + 1, SIDELEN_OF_PAD + 1));
        
        this.setBackground(Color.WHITE);
        this.addKeyListener(new PlayerInputListener());
        
        // 取得焦点，否则无法读取键盘输入。
        this.setFocusable(true);
        this.requestFocus();
        
        // 初始化三个变量。
        point = 0;
        snake = new Snake();
        food = new Food(snake);
        
        // 启动线程。
        new Thread(this).start();
    }
    
    // 绘制面板内容。
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        drawBorder(g);
        drawPoints(g);
        drawFood(g);
        drawSnake(g);
    }
    
    /** 绘制边界线。*/
    void drawBorder(Graphics g) {
        g.setColor(Color.GREEN);
        g.drawRect(0, 0, SIDELEN_OF_PAD, SIDELEN_OF_PAD);
        g.setColor(Color.BLACK);
    }
    
    /** 绘制分数字符。*/
    void drawPoints(Graphics g) {
        g.setColor(Color.RED);
        g.drawString("Points: " + point, 10, 20);
        g.setColor(Color.BLACK);
    }
    
    /** 绘制蛇身。*/
    void drawSnake(Graphics g) {
        g.setColor(Color.BLUE);
        
        // 以蛇身各节所在格子数乘以每格边长求得坐标并依次绘制。
        for (int i = 0; i < snake.getLength(); i++) {
            g.fillRect(snake.getX(i) * SIDELEN_OF_GRID, snake.getY(i) * SIDELEN_OF_GRID,
                    SIDELEN_OF_GRID, SIDELEN_OF_GRID);
        }
        g.setColor(Color.BLACK);
    }
    
    /** 绘制食物。*/
    void drawFood(Graphics g) {
        g.setColor(Color.MAGENTA);
        
        // 以食物所在格子数乘以每格边长求得坐标并绘制。
        g.fillOval(food.getX() * SIDELEN_OF_GRID, food.getY() * SIDELEN_OF_GRID,
                SIDELEN_OF_GRID, SIDELEN_OF_GRID);
    }
    
    /** 向前方移动蛇身。*/
    void moveSnake() {
        //先根据蛇身长度将蛇身顺次移一格。
        for (int i = snake.getLength() - 1; i > 0; i--) {
            snake.setX(i, snake.getX(i-1));
            snake.setY(i, snake.getY(i-1));
        }
        
        // 根据蛇头朝向决定蛇头出现在哪个方向的格子里。
        switch (snake.getOrientation()) {
        case UP:
            snake.setY(0, snake.getY(0) - 1);
            break;
        case DOWN:
            snake.setY(0, snake.getY(0) + 1);
            break;
        case LEFT:
            snake.setX(0, snake.getX(0) - 1);
            break;
        case RIGHT:
            snake.setX(0, snake.getX(0) + 1);
            break;
        default:
            break;
        }
    }
    
    /** 接收一个方向参数，改变方向。*/
    void turn(Orientation orientation) {
        // 如果输入的方向是后方，则直接跳出方法，蛇不应该后退。
        switch (orientation) {
        case UP:
            if (snake.getOrientation() == Orientation.DOWN) {return;}
            break;
        case DOWN:
            if (snake.getOrientation() == Orientation.UP) {return;}
            break;
        case LEFT:
            if (snake.getOrientation() == Orientation.RIGHT) {return;}
            break;
        case RIGHT:
            if (snake.getOrientation() == Orientation.LEFT) {return;}
            break;
        }
        
        snake.setOrientation(orientation);
    }
    
    
    
    /** 进食并改变蛇身长度，之后重新建一个食物。*/
    void eat() {
        snake.setLength(snake.getLength() + 1);
        point += 100;
        
        food = new Food(snake);
    }
    
    /** 运行函数。*/
    public void run() {
        while (true) {
            // 进行各项判断之后移动。
            if (isOutOfBound()) {System.exit(0);}
            if (isSelfBiting()) {System.exit(0);}
            if (isOnFood()) {eat();}
            moveSnake();
            
            // 重绘面板并睡眠，睡眠时长随分数增加而缩短，最小20毫秒。
            repaint();
            int sleepTime = 200 - point / 10;
            if (sleepTime <= 20) {sleepTime = 20;}
            try {
                Thread.sleep(sleepTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /** 出边界检查。*/
    boolean isOutOfBound() {
        int gridsOneSide = GamePad.SIDELEN_OF_PAD / GamePad.SIDELEN_OF_GRID;
        if (snake.getX(0) < 0 || snake.getX(0) >= gridsOneSide) {
            return true;
        }
        if (snake.getY(0) < 0 || snake.getY(0) >= gridsOneSide) {
            return true;
        }
        return false;
    }
    
    /** 自噬检查。*/
    boolean isSelfBiting() {
        for (int i = 1; i < snake.getLength(); i++) {
            if (snake.getX(i) == snake.getX(0) && snake.getY(i) == snake.getY(0)) {
                return true;
            }
        }
        return false;
    }
    
    /** 进食检查。*/
    boolean isOnFood() {
        if (snake.getX(0) == food.getX() && snake.getY(0) == food.getY()) {
            return true;
        }
        return false;
    }
    
    /** 
     * 按键监听器。
     * 处理玩家的键盘输入。
     * 
     * @author mlxy
     * @version 1.0
     */
    class PlayerInputListener extends KeyAdapter {
        @Override
        public void keyPressed(KeyEvent e) {
            switch (e.getKeyCode()) {
            case KeyEvent.VK_UP:
                turn(Orientation.UP);
                break;
            case KeyEvent.VK_DOWN:
                turn(Orientation.DOWN);
                break;
            case KeyEvent.VK_LEFT:
                turn(Orientation.LEFT);
                break;
            case KeyEvent.VK_RIGHT:
                turn(Orientation.RIGHT);
                break;
            case KeyEvent.VK_ESCAPE:
                System.exit(0);
                break;
            default:
                break;
            }
        }
    }
}

package snake;

/** 
 * 食物类。
 * 定义了食物的坐标，内部存储了对蛇的引用以判断生成位置是否在蛇身上。
 * 
 * @author mlxy
 * @version 1.0
 */
public class Food {
    Snake snake;
    
    // 食物所在格子数，并非坐标。
    private int x;
    private int y;
    
    Food(Snake snake) {
        this.snake = snake;
        
        // 随机初始化食物坐标。
        int gridsOneSide = GamePad.SIDELEN_OF_PAD / GamePad.SIDELEN_OF_GRID;
        
        outerWhile: while (true) {
            x = 1 + (int) (Math.random() * (gridsOneSide - 2));
            y = 1 + (int) (Math.random() * (gridsOneSide - 2));
            
            // 如果和蛇身重合就重新生成。
            for (int i = 0; i < snake.getLength(); i++) {
                if (snake.getX(i) == x && snake.getY(i) == y) {
                    continue outerWhile;
                }
            }
            
            // 生成完成，跳出。
            break;
        }
    }

    public int getX() {return x;}
    public int getY() {return y;}
}

package snake;

/** 
 * 蛇类。
 * 定义了蛇头的朝向，蛇的长度，以及蛇身各节所在的坐标。
 * 
 * @author mlxy
 * @version 1.0
 */
public class Snake {
    private Orientation orientation;
    
    private int length;
    
    // 蛇身各节所在的格子数，并非坐标。
    private int[] x;
    private int[] y;
    
    Snake() {
        // 初始化朝向和长度。
        orientation = Orientation.RIGHT;
        length = 2;
        
        // 用游戏面板总格子数初始化数组大小。
        int numberOfGrid = (int) Math.pow(GamePad.SIDELEN_OF_PAD / GamePad.SIDELEN_OF_GRID, 2);
        x = new int[numberOfGrid];
        y = new int[numberOfGrid];
        
        // 初始化最初的蛇身位置。
        int gridsOneSide = GamePad.SIDELEN_OF_PAD / GamePad.SIDELEN_OF_GRID;
        x[1] = gridsOneSide / 2 + 1;
        y[1] = gridsOneSide / 2;
        x[0] = gridsOneSide / 2;
        y[0] = gridsOneSide / 2;
    }
    
    int getLength() {return length;}
    void setLength(int newLength) {this.length = newLength;}
    
    int getX(int index) {return x[index];}
    int getY(int index) {return y[index];}
    
    public void setX(int index, int x) {this.x[index] = x;}
    public void setY(int index, int y) {this.y[index] = y;}
    
    public Orientation getOrientation() {return orientation;}
    public void setOrientation(Orientation orientation) {this.orientation = orientation;}
}