当前位置：首页 » 《关注互联网》 » 正文

【Java】GUI实现贪吃蛇_woodwhale的博客

19 人参与  2022年01月18日 18:14  分类 : 《关注互联网》  评论

点击全文阅读


【Java】GUI实现贪吃蛇

前言

我们在做这个小游戏之前，得确保自己的AWT和Swing有一定的基础，并且会写一些简单的逻辑操作。这些都会在后面写的时候体现出来。

狂神老师从这里开始讲贪吃蛇的

我们在看视频的时候都知道，视频是一帧一帧播放的，一般我们看动画的帧率是每秒24帧。

我们在GUI中实现帧率的，通过不断刷新实现

此外，我们要通过键盘监听来监听键盘的上下左右操作来控制小蛇的移动

还需要通过定时器Timer来实现

文章中的贪吃蛇代码源码已经给出了，这里还有一份我自己构建的jar包，下载地址

1、构建静态页面

效果如下：

image-20210923210215886

我们创建一个游戏启动类，一个图片资源类，一个面板类

其中游戏启动类用于启动这个JFrame，图片资源就是用来加载图片资源的，面板就是用来放顶部的背景和小蛇存在的区域的

  • 游戏启动类

    package top.woodwhale.snake;

import javax.swing.*;

// 游戏的主启动类
public class StartGame {
    public static void main(String[] args) {
        JFrame frame = new JFrame();

        frame.setBounds(10,10,900,720);
        frame.setResizable(false);      // 设置窗口大小不变
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.add(new GamePanel());     // 增加游戏面板
        frame.setVisible(true);
    }
}

  • 资源类

    package top.woodwhale.snake;

import javax.swing.*;
import java.net.URL;

public class Data {

    // 相对路径和绝对路径都可以使用
    public static URL headerURL = Data.class.getResource("statics/img/header.png");
    public static ImageIcon header = new ImageIcon(headerURL);

    public static URL upRUL = Data.class.getResource("statics/img/up.png");
    public static ImageIcon up = new ImageIcon(upRUL);

    public static URL downURL = Data.class.getResource("statics/img/down.png");
    public static ImageIcon down = new ImageIcon(downURL);

    public static URL leftURL = Data.class.getResource("statics/img/left.png");
    public static ImageIcon left = new ImageIcon(leftURL);

    public static URL rightURL = Data.class.getResource("statics/img/right.png");
    public static ImageIcon right = new ImageIcon(rightURL);

    public static URL bodyURL = Data.class.getResource("statics/img/body.png");
    public static ImageIcon body = new ImageIcon(bodyURL);

    public static URL foodURL = Data.class.getResource("statics/img/food.png");
    public static ImageIcon food = new ImageIcon(foodURL);

}

  • 游戏面板类

    package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;

// 游戏面板
public class GamePanel extends JPanel {
    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

    }
}

2、构建小蛇位置

这一部分，我们在GamePanel类中添加了一些小蛇的信息，来绘制小蛇，并且对小蛇的属性进行定义。

效果如下：

image-20210923212713541

代码：

package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;

// 游戏面板
public class GamePanel extends JPanel {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始

    public GamePanel() {
        init();     // 初始化
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        if (dictionary.equals("R")) {
            Data.right.paintIcon(this,g,snakeX[0],snakeY[0]);   // 蛇头向右边
        } else if (dictionary.equals("L")) {
            Data.left.paintIcon(this,g,snakeX[0],snakeY[0]);    // 蛇头向左边
        } else if (dictionary.equals("U")) {
            Data.up.paintIcon(this,g,snakeX[0],snakeY[0]);      // 蛇头向上边
        } else {
            Data.down.paintIcon(this,g,snakeX[0],snakeY[0]);    // 蛇头向下边
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }
}

3、监听键盘操作

我们仍然是在GamePanel类中实现键盘监听操作，我们直接让这个类使用KeyListener接口，重写三个键盘监听方法就可以实现键盘监听了

我们需要第一步做的就是按下空格开始/暂停，使用键盘监听空格键，如果按下了空格，那么我们就让游戏状态取反

package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始

    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        if (dictionary.equals("R")) {
            Data.right.paintIcon(this,g,snakeX[0],snakeY[0]);   // 蛇头向右边
        } else if (dictionary.equals("L")) {
            Data.left.paintIcon(this,g,snakeX[0],snakeY[0]);    // 蛇头向左边
        } else if (dictionary.equals("U")) {
            Data.up.paintIcon(this,g,snakeX[0],snakeY[0]);      // 蛇头向上边
        } else {
            Data.down.paintIcon(this,g,snakeX[0],snakeY[0]);    // 蛇头向下边
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            isStart = !isStart;     // 去反
            repaint();
        }
    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }
}

4、定时器使小蛇移动

在这一节中，我们要通过Timer类实现定时器，不断刷新、重画，让小蛇动起来，并且给小蛇监听键盘的上下左右

package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    int preX;		// 改变方向时记录的坐标X
    int preY;		// 改变方向时记录的坐标Y

    // 定时器
    Timer timer;

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer = new Timer(150,this);   // 监听this对象，按照1000ms执行一次
        timer.start();  // 游戏一开始定时器开始
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边

                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边

                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边

                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边

                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            isStart = !isStart;     // 去反
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart) {
            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}

5、判断小蛇吃果子

如何判断小蛇吃到果子呢？果子应该在哪里生成呢？

  • 小蛇头和果子坐标重合就是吃到果子了
  • 果子用随机数生成
  • 如果果子生成在小蛇身体里，就重新生成
  • 每次吃完一次果子，果子没消失，而是坐标转移
package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.Collectors;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    int preX;       // 改变方向时记录的坐标X
    int preY;       // 改变方向时记录的坐标Y
    int foodX;      // 食物的X坐标
    int foodY;      // 食物的Y坐标
    Random random = new Random();   // 随即器
    Timer timer = new Timer(100,this);   // 定时器，监听this对象，按照100ms执行一次

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];  // 刚开始的时候，记录刚开始的脑袋坐标
        randomFood();   // 随机食物
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer.start();  // 游戏一开始定时器开始
    }

    public void randomFood() {
        foodX = 25 + 25 * random.nextInt(34);   // 随机食物
        foodY = 75 + 25 * random.nextInt(24);   // 随机食物
        java.util.List<Integer> tmpX = Arrays.stream(snakeX).boxed().collect(Collectors.toList());
        java.util.List<Integer> tmpY = Arrays.stream(snakeY).boxed().collect(Collectors.toList());
        // 如果食物在身体里，就刷新
        if (tmpX.contains(foodX) || tmpY.contains(foodY)) {
            randomFood();
        }
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边
                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边
                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边
                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边
                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 画食物
        Data.food.paintIcon(this,g,foodX,foodY);

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            isStart = !isStart;     // 去反
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart) {

            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇的头吃到食物就变长
            if (snakeY[0] == foodY && snakeX[0] == foodX) {
                length++;
                snakeX[length-1] = snakeX[length-2];
                snakeY[length-1] = snakeY[length-2];
                randomFood();
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}

6、游戏失败判断

小蛇的头与身体任意部分的坐标重合，就是失败

package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.Collectors;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    boolean isFail;           // 是否失败
    int preX;       // 改变方向时记录的坐标X
    int preY;       // 改变方向时记录的坐标Y
    int foodX;      // 食物的X坐标
    int foodY;      // 食物的Y坐标
    int score;      // 积分
    Random random = new Random();   // 随即器
    Timer timer = new Timer(150,this);   // 定时器，监听this对象，按照150ms执行一次

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        score = 0;                          // 初始积分为0
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];  // 刚开始的时候，记录刚开始的脑袋坐标
        randomFood();   // 随机食物
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer.start();  // 游戏一开始定时器开始
    }

    // 随机食物
    public void randomFood() {
        foodX = 25 + 25 * random.nextInt(34);   // 随机食物
        foodY = 75 + 25 * random.nextInt(24);   // 随机食物
        java.util.List<Integer> tmpX = Arrays.stream(snakeX).boxed().collect(Collectors.toList());
        java.util.List<Integer> tmpY = Arrays.stream(snakeY).boxed().collect(Collectors.toList());
        // 如果食物在身体里，就刷新
        if (tmpX.contains(foodX) || tmpY.contains(foodY)) {
            randomFood();
        }
    }

    // 失败判定，碰到自己就失败
    public void isGameOver() {
        for (int i = 1; i < length; i++) {
            if (snakeY[0] == snakeY[i] && snakeX[0] == snakeX[i]) {
                isFail = true;
                break;
            }
        }
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 画积分
        g.setColor(Color.orange);
        g.setFont(new Font("Chilanka",Font.BOLD,18));
        g.drawString("Length : " + length,750,30);
        g.drawString("Score : " + score,750,55);

        // 画食物
        Data.food.paintIcon(this,g,foodX,foodY);

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边
                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边
                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边
                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边
                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start !",250,400);
        }

        if (isFail) {
            g.setColor(Color.red);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Failed ! Space Again ?!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            if (isFail) {   // 失败了重新开始
                isFail = false;
                init();
            } else {    // 否则就是暂停、开始
                isStart = !isStart;     // 去反
            }
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart && !isFail) {

            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇的头吃到食物就变长
            if (snakeY[0] == foodY && snakeX[0] == foodX) {
                score += 10;    // 每吃一个分数加10
                length++;       // 每吃一个长度加1
                snakeX[length-1] = snakeX[length-2];
                snakeY[length-1] = snakeY[length-2];
                randomFood();
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }


            // 失败判定，碰到自己就失败
            isGameOver();

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}

总结

所有源码：

image-20210924113951107

Data类

package top.woodwhale.snake;

import javax.swing.*;
import java.net.URL;

public class Data {

    // 相对路径和绝对路径都可以使用
    public static URL headerURL = Data.class.getResource("statics/img/header.png");
    public static ImageIcon header = new ImageIcon(headerURL);

    public static URL upRUL = Data.class.getResource("statics/img/up.png");
    public static ImageIcon up = new ImageIcon(upRUL);

    public static URL downURL = Data.class.getResource("statics/img/down.png");
    public static ImageIcon down = new ImageIcon(downURL);

    public static URL leftURL = Data.class.getResource("statics/img/left.png");
    public static ImageIcon left = new ImageIcon(leftURL);

    public static URL rightURL = Data.class.getResource("statics/img/right.png");
    public static ImageIcon right = new ImageIcon(rightURL);

    public static URL bodyURL = Data.class.getResource("statics/img/body.png");
    public static ImageIcon body = new ImageIcon(bodyURL);

    public static URL foodURL = Data.class.getResource("statics/img/food.png");
    public static ImageIcon food = new ImageIcon(foodURL);

}

StartGame类

package top.woodwhale.snake;

import javax.swing.*;

// 游戏的主启动类
public class StartGame {
    public static void main(String[] args) {
        JFrame frame = new JFrame();

        frame.setBounds(10,10,900,720);
        frame.setResizable(false);      // 设置窗口大小不变
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.add(new GamePanel());     // 增加游戏面板
        frame.setVisible(true);
    }
}

GamePanel类

package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.Collectors;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    boolean isFail;           // 是否失败
    int preX;       // 改变方向时记录的坐标X
    int preY;       // 改变方向时记录的坐标Y
    int foodX;      // 食物的X坐标
    int foodY;      // 食物的Y坐标
    int score;      // 积分
    Random random = new Random();   // 随即器
    Timer timer = new Timer(150,this);   // 定时器，监听this对象，按照150ms执行一次

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        score = 0;                          // 初始积分为0
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];  // 刚开始的时候，记录刚开始的脑袋坐标
        randomFood();   // 随机食物
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer.start();  // 游戏一开始定时器开始
    }

    // 随机食物
    public void randomFood() {
        foodX = 25 + 25 * random.nextInt(34);   // 随机食物
        foodY = 75 + 25 * random.nextInt(24);   // 随机食物
        java.util.List<Integer> tmpX = Arrays.stream(snakeX).boxed().collect(Collectors.toList());
        java.util.List<Integer> tmpY = Arrays.stream(snakeY).boxed().collect(Collectors.toList());
        // 如果食物在身体里，就刷新
        if (tmpX.contains(foodX) || tmpY.contains(foodY)) {
            randomFood();
        }
    }

    // 失败判定，碰到自己就失败
    public void isGameOver() {
        for (int i = 1; i < length; i++) {
            if (snakeY[0] == snakeY[i] && snakeX[0] == snakeX[i]) {
                isFail = true;
                break;
            }
        }
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 画积分
        g.setColor(Color.orange);
        g.setFont(new Font("Chilanka",Font.BOLD,18));
        g.drawString("Length : " + length,750,30);
        g.drawString("Score : " + score,750,55);

        // 画食物
        Data.food.paintIcon(this,g,foodX,foodY);

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边
                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边
                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边
                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边
                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start !",250,400);
        }

        if (isFail) {
            g.setColor(Color.red);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Failed ! Space Again ?!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            if (isFail) {   // 失败了重新开始
                isFail = false;
                init();
            } else {    // 否则就是暂停、开始
                isStart = !isStart;     // 去反
            }
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart && !isFail) {

            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇的头吃到食物就变长
            if (snakeY[0] == foodY && snakeX[0] == foodX) {
                score += 10;    // 每吃一个分数加10
                length++;       // 每吃一个长度加1
                snakeX[length-1] = snakeX[length-2];
                snakeY[length-1] = snakeY[length-2];
                randomFood();
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }


            // 失败判定，碰到自己就失败
            isGameOver();

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}

点击全文阅读


本文链接：http://zhangshiyu.com/post/33504.html

蛇头  监听  坐标  
<< 上一篇 下一篇 >>

  • 评论（0）
  • 赞助本站

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最新文章

  • 林柒薇宋延桉小说全文免费阅读穿到八零年代和司令丈夫离婚那天全文免费阅读
  • 好看的妻子嫁作他人妇，我和女儿不认小说-妻子嫁作他人妇，我和女儿不认最新章节阅读
  • 《七零：那两口子万人嫌，太发癫了》完整版-盛春香裴清远在线全文阅读
  • 最新小说被山里糙汉追着满地跑主角闵小小闵烨全文在线阅读
  • 李慕云陶金辉全文小说最新章节阅读李慕云陶金辉
  • 《看到三十年后的联姻生活，我决定离婚》颜雯程绛-小说txt全文阅读
  • 长公主她风华正茂无弹窗在线阅读
  • 你敢说话，我就敢质疑主角是李云初张景小说百度云全文完整版阅读
  • 娶资助的贫困生当晚，她和竹马一起入洞房小说(完结)-安枫符垚无删减阅读
  • 心机女插足后，她和相亲对象闪婚了（全本）姜初棠夏芝芝完整章节列表免费阅读
  • 被撞流产后，我选择离婚小说百度云完整章节列表免费阅读
  • 沈糯周钦然《老公白月光在我家别墅养胎》全章节免费阅读

    关于我们 | 我要投稿 | 免责申明

    Copyright © 2020-2022 ZhangShiYu.com Rights Reserved.豫ICP备2022013469号-1