国庆在家用JAVA写了个贪吃蛇

已于 2023-10-04 20:23:45 修改
阅读量218 收藏 2
点赞数 9
文章标签： java 游戏
于 2023-10-04 19:10:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74318393/article/details/133557798
版权

        这两天国庆放假实在无聊，开始几天天天躺床上刷抖音，结果回来的小侄子天天来找我完，（不是来找我玩，是来找我手机玩），想着能不能自己写一个小游戏给他玩，思来想去，想我这种菜鸡也只能写一个最简单的贪吃蛇。

游戏说明

1、上下左右四个方向键控制移动（没了，多了咱写不出）。

2、长按加速移动（假的，如上面1所说）。

游戏效果展示

        做这个游戏找素材真的太难了，找了半天没找到，（是我不知道上哪里去找），最后只好自己找了一堆卡通图片慢慢抠图，才有了上面的那些食物，结果在游戏里面发现展示出来好小，蛇身我是真没找到满意的，最后只有用纯色小方块代替了。右边四个功能显示区也懒得继续写了，以后有时间再来写吧，（因为现在代码真的是屎山）。

        至于我为什么不想写下去了，前面说了，这个游戏本来写个小侄子玩的，连夜写的，第二天让他来玩，结果只玩了几分钟，他就不想玩了。跑去玩微信小程序里面的游戏了，后来准备写的双人模式也放弃了。

        代码是看了黑马的视频后写的，所以思路几乎差不多，只是做了一些美化。

游戏代码详解（bushi）

1、Class Node

定义每一个节点的坐标 x,y ,  color用来判断食物的不同类别了，最开始是有其他用途，后面也懒得改了。

package game;

import java.util.Comparator;
import java.util.Random;

public class Node implements Comparator<Node> {
    private int x;
    private int y;
    private int color;

    Node(){

    }

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

    Node(int x,int y,int color){
        this.x = x;
        this.y = y;
        this.color = color;
    }

    public int getY() {
        return y;
    }

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

    public int getX() {
        return x;
    }

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

    public int getColor() {
        return color;
    }

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

    @Override
    public int compare(Node o1, Node o2) {
        return o1.x - o2.x;
    }
}

2、Class Snake

//设置蛇身
private LinkedList<Node> body;
private HashSet<Node> hashBody;
//当前分数
private double score = 15;
//分数池
private double[] scoreArray = {3,2,2,1,1,1};
//设置默认方向为 向右
private Direction direction = Direction.RIGHT;
private boolean isLiving = true;

        主要就是蛇身，最开始用了个LinkedList想着蛇移动时就是在沿着蛇移动的方向添加一个节点，然后把最后一个节点删除，用LinedList底层链表实现的比较方便，不用大规模对数据进行移动

        Sanke有两个主要方法，move 和 eat

        move里面最开始判断是否撞墙，撞墙了就游戏结束，没有就继续判断是否吃到自己身体，吃到了就把后面的部分删除，蛇身就会变短

        eat方法是吃到食物后对score对应的分数池的分数进行加分，当距离上一次蛇身+1后累加的分数>=3时，在蛇尾部添加一个节点，这里不能添加到头部，我看黑马视频里面直接添加在头部，这样当食物出显在墙边时，对着墙过去吃食物就会直接撞墙，然后就GAMEOVER了

package game;

import java.util.HashSet;
import java.util.LinkedList;

public class Snake {
    //设置蛇身
    private LinkedList<Node> body;
    private HashSet<Node> hashBody;
    //当前分数
    private double score = 15;
    private double[] scoreArray = {3,2,2,1,1,1};
    //设置默认方向为 向右
    private Direction direction = Direction.RIGHT;
    private boolean isLiving = true;

    Snake(){
        initSnake();
    }

    private void initSnake(){
        body = new LinkedList<>();
        body.addLast(new Node(20,13));
        body.addLast(new Node(19,13));
        body.addLast(new Node(18,13));
        body.addLast(new Node(17,13));
        body.addLast(new Node(16,13));
        hashBody = new HashSet<>();
        hashBody.add(new Node(20,13));
        hashBody.add(new Node(19,13));
        hashBody.add(new Node(18,13));
        hashBody.add(new Node(17,13));
        hashBody.add(new Node(16,13));

    }

    public double f(){
        return 0.15*score + 10;
    }

    public void move(){
        if(isLiving){
            Node head = body.getFirst();
            switch (direction){
                case UP:
                    body.addFirst(new Node(head.getX(),head.getY()-1));
                    break;
                case DOWN:
                    body.addFirst(new Node(head.getX(),head.getY()+1));
                    break;
                case LEFT:
                    body.addFirst(new Node(head.getX()-1,head.getY()));
                    break;
                case RIGHT:
                    body.addFirst(new Node(head.getX()+1,head.getY()));
                    break;
            }
            body.removeLast();
            //判断是否到达边界
            head = body.getFirst();
            if(head.getX()<=0 || head.getY()<=0 || head.getX()>=59
                    || head.getY()>=39) {
                isLiving = false;
            }
            for(Node node : Data.wall){
                if(node.getY() == head.getY() && node.getX() == head.getX()){
                    isLiving = false;
                    break;
                }
            }

            //判断是否吃到自己身体
            for(int i=1;i<body.size();i++){
                Node node = body.get(i);
                if(head.getX() == node.getX() && head.getY() == node.getY()){
                    score = Math.max(0,score - (body.size()-i) );
                    int len = body.size() - i+1;
                    while(len != 0){
                        len --;
                        body.removeLast();
                    }
                }
            }
        }
    }

    public void eat(Node food){
        score += scoreArray[food.getColor()];
        Node head = body.getFirst();
        Node tail = body.getLast();
        if(head.getX() <= food.getX() && head.getX()+15 >= food.getX()
                && head.getY() <= food.getY() && head.getY()+15 >= food.getY() && score/3 > body.size()){
            Node tail1 = new Node(tail.getX()-1,tail.getY() );
            Node tail2 = new Node(tail.getX()+1,tail.getY() );
            Node tail3 = new Node(tail.getX(),tail.getY()-1 );
            Node tail4 = new Node(tail.getX(),tail.getY()+1 );

            if(!hashBody.contains(tail1) ){
                body.addLast(tail1);
                hashBody.add(tail1);
                return;
            }else if(!hashBody.contains(tail2)){
                body.addLast(tail2);
                hashBody.add(tail2);
                return;
            }else if(!hashBody.contains(tail3)){
                body.addLast(tail3);
                hashBody.add(tail3);
                return;
            }else if(!hashBody.contains(tail4)){
                body.addLast(tail4);
                hashBody.add(tail4);
                return;
            }
        }
    }

    public HashSet<Node> getHashBody() {
        return hashBody;
    }

    public void setHashBody(HashSet<Node> hashBody) {
        this.hashBody = hashBody;
    }

    public boolean isLiving() {
        return isLiving;
    }

    public void setLiving(boolean living) {
        isLiving = living;
    }

    public Direction getDirection() {
        return direction;
    }

    public void setDirection(Direction direction) {
        this.direction = direction;
    }

    public LinkedList<Node> getBody() {
        return body;
    }

    public void setBody(LinkedList<Node> body) {
        this.body = body;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}

3、Class Food

        food类,用的hashset存食物的坐标，想着在判断食物被吃的时候不用遍历直接用contain方法，后面发现不行，也没有去看contain方法源码了，（屎山就让他继续屎下去吧），有一个random方法，随机位置生成食物。

package game;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Random;

public class Food extends Node{
    Random r = new Random();
//    ArrayList<Node> food = new ArrayList<>();
    HashSet<Node> food = new HashSet<>();

    Food(){
        initFood1();
    }

    private void initFood1(){
        int cnt=0;
        while(true){
            int x = r.nextInt(58) + 1;
            int y = r.nextInt(38) + 1;
            if(!Data.wall.contains(new Node(x,y)) && !Data.wall.contains(new Node(x,y))){
                cnt++;
                food.add(new Node(x,y,r.nextInt(6)));
            }
            if(cnt >= 25){
                break;
            }
        }
    }


    public void random(){
        Node node = new Node();
        Snake snake = new Snake();
        HashSet<Node> hBody = snake.getHashBody();
        boolean flag = true;
        do {
            node.setX(r.nextInt(58) + 1);
            node.setY(r.nextInt(38) + 1);
            node.setColor(r.nextInt(6));

            for(Node node1 : Data.wall){
                if(node1.getX() == node.getX() && node1.getY() == node.getY()){
                    continue;
                }
            }

            food.add(node);
            flag = false;
        }while(flag);
//        System.out.printf("新生成食物坐标：%d %d",x,y,color);
    }
}

        

4、Class Direction

        枚举类，四个方向

package game;

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

5、Class MianFrame

        MainFrame继承了JFrame 类

        常量部分

    public static final int WIN_WIDTH = 1092;
    public static final int WIN_HEIGHT = 635;
    public static final int CELL_LENGTH = 15;
    public static final int MAP_HEIGHT = 600;
    public static final int MAP_WIDTH = 900;

        定义了几个变量

                

    private Direction direction = Direction.RIGHT;
    private JPanel jpanel;
    private Snake snake;
    private Food snakeFood;
    private Timer timer;
    private Data data;

         构造方法

  MainFrame() {
        //初始化窗体
        initJfame();
        //初始化蛇身
        initSnake();
        //初始化食物
        initFood();
        //初始化数据
        initData();
        //初始化棋盘
        initGamePanel();
        //初始化计时器
        initTimer();
        //键盘监听
        setKeyListener();
    }

       构造方法里面的函数实现

         initJframe函数
 private void initJfame() {
        setSize(WIN_WIDTH, WIN_HEIGHT);
        setLocation(80, 80);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
    }

        1、设置窗体长、宽

        2、设置起始位置

        3、窗体关闭时程序运行也结束

        4、设置窗体大小不可变

         initSnake/initData/initFood

         这里就是把对象new出来（为什么要在写一个函数呢，这样看起来有逼格一点）

 private void initSnake() {
        snake = new Snake();
    }

    private void initFood() {
        snakeFood = new Food();
    }

    private void initData() {
        data = new Data();
    }

      initGamePanel

        1、绘制背景

        2、绘制地图，地图放在Data类里面的map中（上面讲到过）

        3、绘制蛇身，蛇头和蛇身颜色做了一下区分

        4、绘制分数

        5、绘制食物

        最后调用 add 方法添加到窗体里面

private void initGamePanel() {
        jpanel = new JPanel() {
            @Override
            public void paint(Graphics g) {
                g.clearRect(0, 0, WIN_WIDTH, WIN_HEIGHT);

                g.drawImage(Data.bgImg, 0, 0, this);

                //绘制地图
                for (Node node : Data.wall) {
                    g.drawImage(Data.brick, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH,
                            CELL_LENGTH, CELL_LENGTH, this);
                }

                //绘制蛇身
                LinkedList<Node> body = snake.getBody();
                boolean flag = true;
                for (Node node : body) {
                    if (flag) {
                        g.setColor(Data.snakeHeadColor);
                        g.fillRect(node.getX() * 15, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH);
                        g.setColor(Data.snakeBodyColor);
                        flag = false;
                        continue;
                    }
                    g.fillRect(node.getX() * 15, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH);

                }


                String str1 = String.valueOf(snake.getScore() - 15);
                String str2 = String.valueOf(snake.getBody().size());

                g.setColor(Data.fontColor);
                g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 22));
                g.drawString("SCORES:" , 920, 42);

                g.drawString(str1, 930, 66);

                g.drawString("LENGTH:",920, 100);
                g.drawString(str2 ,930, 124);


                //绘制食物
                g.setColor(Color.PINK);
                for (Node node : snakeFood.food) {
                    switch (node.getColor()) {
                        case 0:
                            g.drawImage(Data.food1, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 1:
                            g.drawImage(Data.food2, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 2:
                            g.drawImage(Data.food3, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 3:
                            g.drawImage(Data.food4, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 4:
                            g.drawImage(Data.food5, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 5:
                            g.drawImage(Data.food6, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                    }
                }
            }

        };
        add(jpanel);
//        jpanel.setBackground(Color.BLUE);

    }

        initTimer

               new 一个对象，然后重写run方法，run方法里面主要是调用蛇的移动方法，和判断蛇是否吃到食物，最后调用repaint进行重新绘制，最后对蛇的当前状态判断一下，isliving为true的话每隔0.1s调用一下timetask 让run 方法 run 起来

private void initTimer() {
        timer = new Timer();
        TimerTask timertask = new TimerTask() {
            @Override
            public void run() {
                snake.move();

                Node head = snake.getBody().getFirst();

                for (Node node : snakeFood.food) {
                    if (head.getX() == node.getX() && head.getY() == node.getY()) {
                        snake.eat(node);
                        snakeFood.food.remove(node);
                        snakeFood.random();
                        break;
                    }
                }

                jpanel.repaint();
            }
        };
        if (snake.isLiving())
            timer.scheduleAtFixedRate(timertask, 0, 100);
        else {
            System.out.println("撞墙了，GameOver!");
            return;
        }
    }

        setKeyListener 设置键盘监听

        监听上下左右四个方向键

private void setKeyListener() {
        addKeyListener(new KeyAdapter() {
            //            当键盘按下时会自动掉用此方法
            @Override
            public void keyPressed(KeyEvent e) {
//                键盘中每个键都有编号
                switch (e.getKeyCode()) {
                    case KeyEvent.VK_UP://上键
                        if (snake.getDirection() != Direction.DOWN)
                            snake.setDirection(Direction.UP);
                        break;
                    case KeyEvent.VK_DOWN://下键
                        if (snake.getDirection() != Direction.UP)
                            snake.setDirection(Direction.DOWN);
                        break;
                    case KeyEvent.VK_LEFT://左键
                        if (snake.getDirection() != Direction.RIGHT)
                            snake.setDirection(Direction.LEFT);
                        break;
                    case KeyEvent.VK_RIGHT://右键
                        if (snake.getDirection() != Direction.LEFT)
                            snake.setDirection(Direction.RIGHT);
                        break;
                }
            }
        });
    }

完整源码

MainFrame

package game;

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Timer;


public class MainFrame extends JFrame {
    public static final int WIN_WIDTH = 1092;
    public static final int WIN_HEIGHT = 635;
    public static final int CELL_LENGTH = 15;
    public static final int MAP_HEIGHT = 600;
    public static final int MAP_WIDTH = 900;

    private Direction direction = Direction.RIGHT;
    private JPanel jpanel;
    private Snake snake;
    private Food snakeFood;
    private Timer timer;
    private Data data;

    MainFrame() {
        //初始化窗体
        initJfame();
        //初始化蛇身
        initSnake();
        //初始化食物
        initFood();
        //初始化数据
        initData();
        //初始化棋盘
        initGamePanel();
        //初始化计时器
        initTimer();
        //键盘监听
        setKeyListener();
    }


    //        设置键盘监听
    private void setKeyListener() {
        addKeyListener(new KeyAdapter() {
            //            当键盘按下时会自动掉用此方法
            @Override
            public void keyPressed(KeyEvent e) {
//                键盘中每个键都有编号
                switch (e.getKeyCode()) {
                    case KeyEvent.VK_UP://上键
                        if (snake.getDirection() != Direction.DOWN)
                            snake.setDirection(Direction.UP);
                        break;
                    case KeyEvent.VK_DOWN://下键
                        if (snake.getDirection() != Direction.UP)
                            snake.setDirection(Direction.DOWN);
                        break;
                    case KeyEvent.VK_LEFT://左键
                        if (snake.getDirection() != Direction.RIGHT)
                            snake.setDirection(Direction.LEFT);
                        break;
                    case KeyEvent.VK_RIGHT://右键
                        if (snake.getDirection() != Direction.LEFT)
                            snake.setDirection(Direction.RIGHT);
                        break;
                }
            }
        });
    }


    private void initTimer() {
        timer = new Timer();
        TimerTask timertask = new TimerTask() {
            @Override
            public void run() {
                snake.move();

                Node head = snake.getBody().getFirst();

                for (Node node : snakeFood.food) {
                    if (head.getX() == node.getX() && head.getY() == node.getY()) {
                        snake.eat(node);
                        snakeFood.food.remove(node);
                        snakeFood.random();
                        break;
                    }
                }

                jpanel.repaint();
            }
        };
        if (snake.isLiving())
            timer.scheduleAtFixedRate(timertask, 0, 100);
        else {
            System.out.println("撞墙了，GameOver!");
            return;
        }
    }

    private void initSnake() {
        snake = new Snake();
    }

    private void initFood() {
        snakeFood = new Food();
    }

    private void initData() {
        data = new Data();
    }

    private void initGamePanel() {
        jpanel = new JPanel() {
            @Override
            public void paint(Graphics g) {
                g.clearRect(0, 0, WIN_WIDTH, WIN_HEIGHT);

                g.drawImage(Data.bgImg, 0, 0, this);

                //绘制地图
                for (Node node : Data.wall) {
                    g.drawImage(Data.brick, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH,
                            CELL_LENGTH, CELL_LENGTH, this);
                }

                //绘制蛇身
                LinkedList<Node> body = snake.getBody();
                boolean flag = true;
                for (Node node : body) {
                    if (flag) {
                        g.setColor(Data.snakeHeadColor);
                        g.fillRect(node.getX() * 15, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH);
                        g.setColor(Data.snakeBodyColor);
                        flag = false;
                        continue;
                    }
                    g.fillRect(node.getX() * 15, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH);

                }


                String str1 = String.valueOf(snake.getScore() - 15);
                String str2 = String.valueOf(snake.getBody().size());

                g.setColor(Data.fontColor);
                g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 22));
                g.drawString("SCORES:" , 920, 42);

                g.drawString(str1, 930, 66);

                g.drawString("LENGTH:",920, 100);
                g.drawString(str2 ,930, 124);


                //绘制食物
                g.setColor(Color.PINK);
                for (Node node : snakeFood.food) {
                    switch (node.getColor()) {
                        case 0:
                            g.drawImage(Data.food1, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 1:
                            g.drawImage(Data.food2, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 2:
                            g.drawImage(Data.food3, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 3:
                            g.drawImage(Data.food4, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 4:
                            g.drawImage(Data.food5, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                        case 5:
                            g.drawImage(Data.food6, node.getX() * CELL_LENGTH, node.getY() * CELL_LENGTH, CELL_LENGTH, CELL_LENGTH, this);
                            break;
                    }
                }
            }

        };
        add(jpanel);
//        jpanel.setBackground(Color.BLUE);

    }

    private void initJfame() {
        setSize(WIN_WIDTH, WIN_HEIGHT);
        setLocation(80, 80);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
    }

    public static void main(String[] args) {
        new MainFrame().setVisible(true);
    }
}

Node

package game;

import java.util.Comparator;
import java.util.Random;

public class Node implements Comparator<Node> {
    private int x;
    private int y;
    private int color;

    Node(){

    }

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

    Node(int x,int y,int color){
        this.x = x;
        this.y = y;
        this.color = color;
    }

    public int getY() {
        return y;
    }

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

    public int getX() {
        return x;
    }

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

    public int getColor() {
        return color;
    }

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

    @Override
    public int compare(Node o1, Node o2) {
        return o1.x - o2.x;
    }
}

food

package game;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Random;

public class Food extends Node{
    Random r = new Random();
//    ArrayList<Node> food = new ArrayList<>();
    HashSet<Node> food = new HashSet<>();

    Food(){
        initFood1();
    }

    private void initFood1(){
        int cnt=0;
        while(true){
            int x = r.nextInt(58) + 1;
            int y = r.nextInt(38) + 1;
            if(!Data.wall.contains(new Node(x,y)) && !Data.wall.contains(new Node(x,y))){
                cnt++;
                food.add(new Node(x,y,r.nextInt(6)));
            }
            if(cnt >= 25){
                break;
            }
        }
    }


    public void random(){
        Node node = new Node();
        Snake snake = new Snake();
        HashSet<Node> hBody = snake.getHashBody();
        boolean flag = true;
        do {
            node.setX(r.nextInt(58) + 1);
            node.setY(r.nextInt(38) + 1);
            node.setColor(r.nextInt(6));

            for(Node node1 : Data.wall){
                if(node1.getX() == node.getX() && node1.getY() == node.getY()){
                    continue;
                }
            }

            food.add(node);
            flag = false;
        }while(flag);
//        System.out.printf("新生成食物坐标：%d %d",x,y,color);
    }
}

Snake

package game;

import java.util.HashSet;
import java.util.LinkedList;

public class Snake {
    //设置蛇身
    private LinkedList<Node> body;
    private HashSet<Node> hashBody;
    //当前分数
    private double score = 15;
    private double[] scoreArray = {3,2,2,1,1,1};
    //设置默认方向为 向右
    private Direction direction = Direction.RIGHT;
    private boolean isLiving = true;

    Snake(){
        initSnake();
    }

    private void initSnake(){
        body = new LinkedList<>();
        body.addLast(new Node(20,13));
        body.addLast(new Node(19,13));
        body.addLast(new Node(18,13));
        body.addLast(new Node(17,13));
        body.addLast(new Node(16,13));
        hashBody = new HashSet<>();
        hashBody.add(new Node(20,13));
        hashBody.add(new Node(19,13));
        hashBody.add(new Node(18,13));
        hashBody.add(new Node(17,13));
        hashBody.add(new Node(16,13));

    }

    public double f(){
        return 0.15*score + 10;
    }

    public void move(){
        if(isLiving){
            Node head = body.getFirst();
            switch (direction){
                case UP:
                    body.addFirst(new Node(head.getX(),head.getY()-1));
                    break;
                case DOWN:
                    body.addFirst(new Node(head.getX(),head.getY()+1));
                    break;
                case LEFT:
                    body.addFirst(new Node(head.getX()-1,head.getY()));
                    break;
                case RIGHT:
                    body.addFirst(new Node(head.getX()+1,head.getY()));
                    break;
            }
            body.removeLast();
            //判断是否到达边界
            head = body.getFirst();
            if(head.getX()<=0 || head.getY()<=0 || head.getX()>=59
                    || head.getY()>=39) {
                isLiving = false;
            }
            for(Node node : Data.wall){
                if(node.getY() == head.getY() && node.getX() == head.getX()){
                    isLiving = false;
                    break;
                }
            }




            //判断是否吃到自己身体
            for(int i=1;i<body.size();i++){
                Node node = body.get(i);
                if(head.getX() == node.getX() && head.getY() == node.getY()){
                    score = Math.max(0,score - (body.size()-i) );
                    int len = body.size() - i+1;
                    while(len != 0){
                        len --;
                        body.removeLast();
                    }
                }
            }
        }
    }

    public void eat(Node food){
        score += scoreArray[food.getColor()];
        Node head = body.getFirst();
        Node tail = body.getLast();
        if(head.getX() <= food.getX() && head.getX()+15 >= food.getX()
                && head.getY() <= food.getY() && head.getY()+15 >= food.getY() && score/3 > body.size()){
            Node tail1 = new Node(tail.getX()-1,tail.getY() );
            Node tail2 = new Node(tail.getX()+1,tail.getY() );
            Node tail3 = new Node(tail.getX(),tail.getY()-1 );
            Node tail4 = new Node(tail.getX(),tail.getY()+1 );

            if(!hashBody.contains(tail1) ){
                body.addLast(tail1);
                hashBody.add(tail1);
                return;
            }else if(!hashBody.contains(tail2)){
                body.addLast(tail2);
                hashBody.add(tail2);
                return;
            }else if(!hashBody.contains(tail3)){
                body.addLast(tail3);
                hashBody.add(tail3);
                return;
            }else if(!hashBody.contains(tail4)){
                body.addLast(tail4);
                hashBody.add(tail4);
                return;
            }
        }
    }

    public HashSet<Node> getHashBody() {
        return hashBody;
    }

    public void setHashBody(HashSet<Node> hashBody) {
        this.hashBody = hashBody;
    }

    public boolean isLiving() {
        return isLiving;
    }

    public void setLiving(boolean living) {
        isLiving = living;
    }

    public Direction getDirection() {
        return direction;
    }

    public void setDirection(Direction direction) {
        this.direction = direction;
    }

    public LinkedList<Node> getBody() {
        return body;
    }

    public void setBody(LinkedList<Node> body) {
        this.body = body;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}

Direction

package game;

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

某驾校的程序员
关注
  • 9
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
用JAVA写一段贪吃蛇游戏的代码
xiaoyuedake的博客
02-24 692
用JAVA写一段贪吃蛇游戏的代码
java写贪吃蛇安卓_eclipse开发Android小程序：实现贪吃蛇部分功能
weixin_33213367的博客
02-28 2235
网络111 葛鹏贪吃蛇又名贪食蛇，是一款经典的小游戏。玩家使用方向键操控一条长长的蛇不断吞下豆子，同时蛇身随着吞下的豆子不断变长，当蛇头撞到蛇身或障壁时游戏结束。贪吃蛇最初为人们所知的是诺基亚手机附带的一个小游戏，它伴随着诺基亚手机走向世界。现在的贪吃蛇出现了许多衍生版本，并被移植到各种平台上。但我今天所实现的功能是蛇的移动与增长。知识点：1.理解android应用的基本架构，面向对象的思想，以及...
用JAVA写一个贪吃蛇的代码
weixin_42594419的博客
02-19 404
我很乐意为你编写一段贪吃蛇的JAVA代码： public class SnakeGame { public static void main(String[] args) { // 创建一个SnakeGame对象 SnakeGame game = new SnakeGame(); // 设置游戏界面的大小，如果没有参数，默认界面大小为20*20 ga...
Java实现贪吃蛇大作战小游戏（完整版）
热门推荐
陈橘又青的博客
06-20 6万+
用swing技术实现编写一个贪吃蛇大作战小游戏，项目供大家参考学习交流。
用java写一个贪吃蛇小游戏（源码在最后）
weixin_47678894的博客
06-26 2万+
涉及技能：GUI中的组件： 7.1 窗口 7.2 弹窗 7.3 面板 7.4 文本框 7.5 列表框 7.6 按钮 7.7 图片 7.8 交互的事件：监听事件（鼠标事件，键盘事件）GUI技术，不流行了！！！界面太简单粗糙！！已经被淘汰了，为什么还学？注意： 学的是 思想！！！小蛇素材图像素为25*25，因此在对应xy轴上的数值也以25为步长。 1.打开IDEA工具，新建一个模块module。 2.选择java，点next。 3.取一个名字叫TestSnake，然后点击finish。 4.打开新建好的T
Java贪吃蛇全代码
guyu的博客
04-26 3万+
用Java编写精典小游戏——贪吃蛇！ 前言   我想贪吃蛇应该是不少90后和00后的童年（我本人是01年的），回想起从前偷偷拿着我爹的诺基亚在被窝里玩贪吃蛇，不禁感慨万分，时间飞逝，没想到10年后的我也可以自己做一个贪吃蛇了。       该程序主要实现了以下功能：   1.按空格开始游戏、暂停游戏或重新开始游戏。   2.方向键控制蛇移动的方向。   3.蛇吃掉食物可以增长，并增加游戏分数（不会加快游戏速度）。   4.蛇咬到自己会结束游戏。   5.蛇撞到游戏区域外会结束游戏。      接下来放
Java 写的贪吃蛇游戏 带详细设计报告 功能非常齐全 完整源码
bangxiecode的博客
02-25 2480
Java开发的贪吃蛇游戏，完整源码，直接下载。 主要功能如下： 1. 利用方向键来改变蛇的运行方向。 2. 空格键暂停或继续游戏，并在随机的地方产生食物。 3. 可以通过设置区域的设置按钮来改变游戏的背景颜色,游戏中蛇的蛇头颜色,蛇身颜色,食物颜色以及石头的颜色. 4. 通过按键来调节蛇的移动速度,来增加游戏的难度. 5. 在面板上添加不同的地图布局,来使游戏更加好玩. 6. 吃到食物就变成新的蛇体，碰到障碍物石头或自身则游戏结束，否则正常运行 7. 动态获取游戏的积分
JAVA实现贪吃蛇游戏
遇安的博客
05-06 3682
最近在学GUI，然后又有读者希望我写一下相关的实战。刚好我又在B站上找到了一个关于GUI的学习视频，然后里面又刚好有这个实战，我便写了下来。注：代码来源为B站的一个up主：狂神。 游戏主启动类： import javax.swing.*; //游戏主启动类 public class startGame { public static void main(String[] args) { JFrame frame=new JFrame(); frame..
Java小游戏之贪吃蛇
suiyishiguang的博客
05-16 4252
Java小游戏之贪吃蛇
java swing实现贪吃蛇
misaka_00001的博客
10-20 657
java swing实现贪吃蛇
java写的贪吃蛇小游戏，跟着b站up主学的.zip
10-14
java写的贪吃蛇小游戏，跟着b站up主学的.zipjava写的贪吃蛇小游戏，跟着b站up主学的.zip java写的贪吃蛇小游戏，跟着b站up主学的.zipjava写的贪吃蛇小游戏，跟着b站up主学的.zip java写的贪吃蛇小游戏，跟着b站up主...
java小游戏 贪吃蛇 java小游戏 贪吃蛇
06-23
java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 贪吃蛇java小游戏 ...
用Java写的贪吃蛇小游戏
03-06
《用Java写的贪吃蛇小游戏》是一款基于Java编程语言开发的简单娱乐项目，旨在帮助具有Java基础知识的学习者提升编程技能并了解游戏开发的基本原理。在Java编程领域，贪吃蛇游戏是一个经典的教学案例，它涵盖了面向...
用java写的贪吃蛇小游戏.zip
09-11
【标题】"用Java写的贪吃蛇小游戏"是一款基于Java编程语言开发的简单娱乐软件，它将经典的贪吃蛇游戏移植到了计算机平台。这个项目展示了Java语言在游戏开发中的应用，同时也为初学者提供了一个很好的学习示例。 ...
java写的贪吃蛇游戏.zip
07-19
java课程设计大作业，java、算法练手项目，适合初学java、数据结构的同学拿来学习研究，基于java、GUI开发的小游戏，程序都经过测试，可以直接运行，资源含程序运行所需的源码、资源文件等全部数据，有需要的可放心...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2189
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 2551
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2817
linux上datax 安装以及使用
操作系统原子操作
最新发布
zzt_is_me的博客
08-28 1108
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java写个贪吃蛇脚本
09-10
贪吃蛇是一个经典的小游戏，在Java中编写一个贪吃蛇脚本可以通过以下步骤实现。 首先，我们需要创建一个窗口来显示游戏界面。我们可以使用Java的Swing库来创建一个窗口，并在窗口中绘制游戏界面。 接下来，我们...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值