Java贪吃蛇

说明：X加速，Z减速，空格暂停，长度无上限直到死为止。

1、Game.java

package game;

import java.awt.BorderLayout;
import javax.swing.JFrame;
import control.Controller;
import grid.Grid;
import mysnake.Food;
import mysnake.Ground;
import mysnake.Snake;
import view.GamePanel;

public class Game {

    public static void main(String[] args) {
        Snake snake = new Snake();
        Food food = new Food();
        GamePanel gamepanel = new GamePanel();
        Ground ground = new Ground();
        Controller controller = new Controller(snake,food,ground,gamepanel);
        JFrame frame = new JFrame("      Snake --- By xxxxxxx      "+ "↑↓←→ : move      Z : decelerate      X : accelerate      Space : pause");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        gamepanel.setSize(Grid.WIDTH*Grid.CELL_SIZE,Grid.HEIGHT*Grid.CELL_SIZE);
        frame.setSize(Grid.WIDTH*Grid.CELL_SIZE+10,Grid.HEIGHT*Grid.CELL_SIZE+35);
        frame.add(gamepanel,BorderLayout.CENTER);
        gamepanel.addKeyListener(controller);
        snake.addListener(controller);
        frame.addKeyListener(controller);
        frame.setVisible(true);
        controller.newGame();
}
}

2、Grid.java

package grid;

public class Grid {
    public static final int CELL_SIZE = 1;
    public static final int WIDTH = 888;
    public static final int HEIGHT = 666;
}

3、Food.java

package mysnake;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Random;
import grid.Grid;

public class Food extends Point{
    private int xx = new Random().nextInt(7);
    public boolean isSnakeEatFood(Snake snake){
        if((((snake.getHead().x*Grid.CELL_SIZE+Grid.CELL_SIZE*10)==this.x*Grid.CELL_SIZE+1*Grid.CELL_SIZE)&&
                (snake.getHead().y>(this.y-Grid.CELL_SIZE*10))&&
                        (snake.getHead().y<(this.y+Grid.CELL_SIZE*10)))||
        (((snake.getHead().x*Grid.CELL_SIZE)==this.x*Grid.CELL_SIZE+9*Grid.CELL_SIZE)&&
                (snake.getHead().y>(this.y-Grid.CELL_SIZE*10))&&
                                (snake.getHead().y<(this.y+Grid.CELL_SIZE*10)))||
        (((snake.getHead().y*Grid.CELL_SIZE+Grid.CELL_SIZE*10)==this.y*Grid.CELL_SIZE+1*Grid.CELL_SIZE)&&
                (snake.getHead().x>(this.x-Grid.CELL_SIZE*10))&&
                   (snake.getHead().x<this.x+Grid.CELL_SIZE*10))||
        (((snake.getHead().y*Grid.CELL_SIZE)==this.y*Grid.CELL_SIZE+9*Grid.CELL_SIZE)&&
                (snake.getHead().x>(this.x-Grid.CELL_SIZE*10))&&
                   (snake.getHead().x<this.x+Grid.CELL_SIZE*10))){
            return true;
    }else{
        return false;
    }
}

    public void drawMe(Graphics g){
        switch(xx){
        case 0:g.setColor(Color.RED);break;
        case 1:g.setColor(Color.ORANGE);break;
        case 2:g.setColor(Color.YELLOW);break;
        case 3:g.setColor(Color.GREEN);break;
        case 4:g.setColor(Color.BLUE);break;
        case 5:g.setColor(Color.CYAN);break;
        case 6:g.setColor(Color.PINK);break;
        }
        g.fill3DRect(x*Grid.CELL_SIZE,y*Grid.CELL_SIZE,Grid.CELL_SIZE*10,Grid.CELL_SIZE*10,true);
    }
    
    public void newFood(Point p){
        this.setLocation(p);
    }
}

4、Ground.java

package mysnake;

import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;
import grid.Grid;

public class Ground{
    private int[][] rocks = new int[Grid.WIDTH][Grid.HEIGHT]; 
    private int xx = new Random().nextInt(7);
    public boolean isSnakeEatRock(Snake snake){
        for(int i=0;i<Grid.WIDTH;i++){
            for(int j=0;j<Grid.HEIGHT;j++){
        if((rocks[i][j]==1)&&
                ((((snake.getHead().x*Grid.CELL_SIZE+Grid.CELL_SIZE*10)==i*Grid.CELL_SIZE+1*Grid.CELL_SIZE)&&
                (snake.getHead().y>(j-Grid.CELL_SIZE*10))&&
                (snake.getHead().y<(j+Grid.CELL_SIZE*10)))||
(((snake.getHead().x*Grid.CELL_SIZE)==i*Grid.CELL_SIZE+9*Grid.CELL_SIZE)&&
        (snake.getHead().y>(j-Grid.CELL_SIZE*10))&&
                        (snake.getHead().y<(j+Grid.CELL_SIZE*10)))||
(((snake.getHead().y*Grid.CELL_SIZE+Grid.CELL_SIZE*10)==j*Grid.CELL_SIZE+1*Grid.CELL_SIZE)&&
        (snake.getHead().x>(i-Grid.CELL_SIZE*10))&&
           (snake.getHead().x<i+Grid.CELL_SIZE*10))||
(((snake.getHead().y*Grid.CELL_SIZE)==j*Grid.CELL_SIZE+9*Grid.CELL_SIZE)&&
        (snake.getHead().x>(i-Grid.CELL_SIZE*10))&&
           (snake.getHead().x<i+Grid.CELL_SIZE*10))))
        {return true;}}}
         return false;
}
    
    public boolean catchfood(Food food){
        for(int i=0;i<Grid.WIDTH;i++){
            for(int j=0;j<Grid.HEIGHT;j++){
        if((rocks[i][j]==1)&&((((food.x*Grid.CELL_SIZE+10*Grid.CELL_SIZE>i*Grid.CELL_SIZE)
                &&(food.x*Grid.CELL_SIZE<(i*Grid.CELL_SIZE+Grid.CELL_SIZE*10)))&&
                ((food.y*Grid.CELL_SIZE+10*Grid.CELL_SIZE>j*Grid.CELL_SIZE)&&
                        (food.y*Grid.CELL_SIZE<(j*Grid.CELL_SIZE+Grid.CELL_SIZE*10))))))
        {return true;}}}
         return false;
}
    
    public Ground(){
        for(int i=0;i<100;i++){
            int a = new Random().nextInt(Grid.WIDTH);
            int b = new Random().nextInt(Grid.HEIGHT);
            if(b<0){b=Grid.HEIGHT-1;}
            if(b+10>=Grid.HEIGHT){b=0;}
            if(a<0){a=Grid.WIDTH-1;}
            if(a+10>=Grid.WIDTH){a=0;}
            rocks[a][b] = 1;
            }
        }
    
    public void drawMe(Graphics g){
        switch(xx){
        case 0:g.setColor(Color.RED);break;
        case 1:g.setColor(Color.ORANGE);break;
        case 2:g.setColor(Color.YELLOW);break;
        case 3:g.setColor(Color.GREEN);break;
        case 4:g.setColor(Color.BLUE);break;
        case 5:g.setColor(Color.CYAN);break;
        case 6:g.setColor(Color.PINK);break;
        }
    for(int x=0;x<Grid.WIDTH;x++){
        for(int y=0;y<Grid.HEIGHT;y++){
            if(rocks[x][y]==1){
                g.fill3DRect(x*Grid.CELL_SIZE,y*Grid.CELL_SIZE,Grid.CELL_SIZE*10,Grid.CELL_SIZE*10,true);
            }
        }
    }
}
}

5、Snake.java

package mysnake;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;
import grid.Grid;

public class Snake {
        
        public Snake(){
            init();
        }
        
        public void init(){
            int x = Grid.WIDTH/2;
            int y = Grid.HEIGHT/2;
            for(int i=0;i<33;i++){
                body.addFirst(new Point(x--,y));
            }
        olddirection = newdirection = LEFT;
        life = true;
        efil = true;
        efil1 = 0;
        threadspeed = 10;
        }
    
        public static final int UP = 0;
        public static final int DOWN = 1;
        public static final int LEFT = 2;
        public static final int RIGHT = 3;
        
        private int olddirection,newdirection;
        private LinkedList<Point> body = new LinkedList<Point>();
        private Set<Snakelisten> listener = new HashSet<Snakelisten>();
        private boolean life;
        private boolean efil;
        private int efil1;
        private int threadspeed;
        public Point getHead(){
            return body.getFirst();
        }
        public void move(){
            int x = body.getFirst().x;
            int y = body.getFirst().y;    
            switch(efil1){case 0: 
                if((olddirection+newdirection!=5)&&(olddirection+newdirection!=1)){
                    olddirection = newdirection;
                }
                body.removeLast();
                switch(olddirection){
                case UP:y--;if(y<0){y=Grid.HEIGHT-1;}break;
                case DOWN:y++;if(y+10>=Grid.HEIGHT){y=0;}break;
                case LEFT:x--;if(x<0){x=Grid.WIDTH-1;}break;
                case RIGHT:x++;if(x+10>=Grid.WIDTH){x=0;}break;
                }
                Point newHead = new Point(x,y);
                body.addFirst(newHead);
                break;
                case 1:break;}    
        }
        public void changeDirection(int direction){            
            newdirection = direction;        
        }
        public void eatFood(){
            int x = body.getFirst().x;
            int y = body.getFirst().y;
            for(int i=0;i<10;i++){
            switch(olddirection){
            case UP:y--;if(y<0){y=Grid.HEIGHT-1;}break;
            case DOWN:y++;if(y+10>=Grid.HEIGHT){y=0;}break;
            case LEFT:x--;if(x<0){x=Grid.WIDTH-1;}break;
            case RIGHT:x++;if(x+10>=Grid.WIDTH){x=0;}break;
            }
            Point newHead = new Point(x,y);
            body.addFirst(newHead);}
        }
        public boolean isEatBody(){
            for(int i=22;i<body.size();i++){
            if((((this.getHead().x*Grid.CELL_SIZE+Grid.CELL_SIZE*10)==
                    body.get(i).x*Grid.CELL_SIZE+1*Grid.CELL_SIZE)&&
                    (this.getHead().y>(body.get(i).y-Grid.CELL_SIZE*10))&&
                    (this.getHead().y<(body.get(i).y+Grid.CELL_SIZE*10)))||
    (((this.getHead().x*Grid.CELL_SIZE)==body.get(i).x*Grid.CELL_SIZE+9*Grid.CELL_SIZE)&&
            (this.getHead().y>(body.get(i).y-Grid.CELL_SIZE*10))&&
                            (this.getHead().y<(body.get(i).y+Grid.CELL_SIZE*10)))||
    (((this.getHead().y*Grid.CELL_SIZE+Grid.CELL_SIZE*10)==body.get(i).y*Grid.CELL_SIZE+1*Grid.CELL_SIZE)&&
            (this.getHead().x>(body.get(i).x-Grid.CELL_SIZE*10))&&
               (this.getHead().x<body.get(i).x+Grid.CELL_SIZE*10))||
    (((this.getHead().y*Grid.CELL_SIZE)==body.get(i).y*Grid.CELL_SIZE+9*Grid.CELL_SIZE)&&
            (this.getHead().x>(body.get(i).x-Grid.CELL_SIZE*10))&&
               (this.getHead().x<body.get(i).x+Grid.CELL_SIZE*10))){
                return true;
            }}
            return false;
        }
        public boolean foodcatchsnakebody(Food food){
            for(int i=10;i<body.size();i++)
            {
                if(((food.x*Grid.CELL_SIZE+10*Grid.CELL_SIZE>body.get(i).x*Grid.CELL_SIZE)
                        &&(food.x*Grid.CELL_SIZE<(body.get(i).x*Grid.CELL_SIZE+Grid.CELL_SIZE*10)))&&
                        ((food.y*Grid.CELL_SIZE+10*Grid.CELL_SIZE>body.get(i).y*Grid.CELL_SIZE)&&
                                (food.y*Grid.CELL_SIZE<(body.get(i).y*Grid.CELL_SIZE+Grid.CELL_SIZE*10))))
                            
                return true;
            }
            return false;
        }
        public void drawMe(Graphics g){
            g.setColor(Color.WHITE);
            for(Point i:body){
                g.fill3DRect(i.x*Grid.CELL_SIZE,i.y*Grid.CELL_SIZE,Grid.CELL_SIZE*10,Grid.CELL_SIZE*10,true);
            }
        }
        private class SnakeDriver implements Runnable{

            @Override
            public void run() {
                while(life){
                    move();
                    for(Snakelisten i:listener){
                        i.move(Snake.this);
                    }
                    try{Thread.sleep(threadspeed);}
                    catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
                
            }
            
        }
        public void addListener(Snakelisten l){
            if(l!=null){
                this.listener.add(l);
            }
        }
        public void start(){
            new Thread(new SnakeDriver()).start();
        }

        public void die() {
            life = false;
        }
        public void pause(){
            if(efil){
                efil = false;
                efil1 = 1;
            }
            else{
                efil = true;
                efil1 = 0;
            }
        }

        public void acc() {
            if(threadspeed>1)threadspeed--;
        }

        public void slow() {
            if(threadspeed<19)threadspeed++;
        }
}

6、Snakelisten.java

package mysnake;

public interface Snakelisten {
    void move(Snake snake);
}

7、GamePanel.java

package view;

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
import grid.Grid;
import mysnake.Food;
import mysnake.Ground;
import mysnake.Snake;

public class GamePanel extends JPanel{
    
    private Food food;
    private Snake snake;
    private Ground ground;
    
    public void display(Snake snake,Food food,Ground ground){
        this.snake = snake;
        this.food = food;
        this.ground = ground;
        this.repaint();
    }

    @Override
    protected void paintComponent(Graphics g) {
        g.setColor(Color.BLACK);
        g.fillRect(0,0,Grid.WIDTH*Grid.CELL_SIZE,Grid.HEIGHT*Grid.CELL_SIZE);
        if(ground!=null&&snake!=null&&food!=null){
        this.snake.drawMe(g);
        this.ground.drawMe(g);
        this.food.drawMe(g);
        }
    }
    
}

8.Controller.java

package control;

import java.awt.Point;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;
import grid.Grid;
import mysnake.Food;
import mysnake.Ground;
import mysnake.Snake;
import mysnake.Snakelisten;
import view.GamePanel;

public class Controller extends KeyAdapter implements Snakelisten{
    
    private Snake snake;
    private Food food;
    private Ground ground;
    private GamePanel gamepanel;

    public Controller(Snake snake, Food food, Ground ground, GamePanel gamepanel) {
        super();
        this.snake = snake;
        this.food = food;
        this.ground = ground;
        this.gamepanel = gamepanel;
    }

    @Override
    public void keyPressed(KeyEvent e) {
        switch(e.getKeyCode()){
        case KeyEvent.VK_UP:snake.changeDirection(Snake.UP);break;
        }
        switch(e.getKeyCode()){
        case KeyEvent.VK_DOWN:snake.changeDirection(Snake.DOWN);break;
        }
        switch(e.getKeyCode()){
        case KeyEvent.VK_LEFT:snake.changeDirection(Snake.LEFT);break;
        }
        switch(e.getKeyCode()){
        case KeyEvent.VK_RIGHT:snake.changeDirection(Snake.RIGHT);break;
        }
        switch(e.getKeyCode()){
        case KeyEvent.VK_SPACE:snake.pause();break;
        }
        switch(e.getKeyCode()){
        case KeyEvent.VK_X:snake.acc();break;
        }
        switch(e.getKeyCode()){
        case KeyEvent.VK_Z:snake.slow();break;
        }
        
    }

    @Override
    public void move(Snake snake) {
        gamepanel.display(snake, food, ground);
        if(food.isSnakeEatFood(snake)){
            snake.eatFood();
            food.newFood(getPoint());
        }
        if(ground.isSnakeEatRock(snake)){
            snake.die();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.exit(0);
        }
        if(ground.catchfood(food)){
            food.newFood(getPoint());
        }
        if(snake.isEatBody()){
            snake.die();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.exit(0);
        }
        if(snake.foodcatchsnakebody(food)){
            food.newFood(getPoint());
        }
    }
    
    public void newGame(){
        snake.start();
        food.newFood(getPoint());
    }
    
    public Point getPoint(){
        Random random = new Random();
        int x = random.nextInt(Grid.WIDTH);
        int y = random.nextInt(Grid.HEIGHT);
        if(x<0){x=Grid.WIDTH-1;}
        if((x+10)>Grid.WIDTH){x=0;}
        if(y<0){y=Grid.HEIGHT-1;}
        if(y+10>Grid.HEIGHT){y=0;}
        return new Point(x,y);
    }
}