• 我写了个”不贪吃蛇“小游戏

    前言

    我写的这个”贪吃蛇“和小时候玩的”贪吃蛇“有点不一样，以往的”贪吃蛇“吃了食物蛇身就会变长，而我写的这个吃了“食物”蛇身会变短，并且胜利条件就是“把蛇变没”，嘻嘻~

    这里的“食物”其实是“药丸”，初始时，蛇身很长，你要通过食用“药丸”，来让自己的身体变短，直到自己消失不见，你就获胜了。

    “药丸”共有三种，分别为“红色药丸、蓝色药丸、绿色药丸”，对应分值“5分、2分、1分”，蛇吃了“药丸”会减掉对应分值数量的身体，并累计分值。

    代码

    蛇、药丸的抽象

    坐标 Point.java

    记录横纵坐标值。

    1. package cn.xeblog.snake.model;
    2.  
    3. import java.util.Objects;
    4.  
    5. /**
    6.  * 坐标
    7.  *
    8.  * @author anlingyi
    9.  * @date 2022/8/2 3:35 PM
    10.  */
    11. public class Point {
    12.  
    13.     public int x;
    14.  
    15.     public int y;
    16.  
    17.     public Point(int x, int y) {
    18.         this.x = x;
    19.         this.y = y;
    20.     }
    21.  
    22.     @Override
    23.     public boolean equals(Object o) {
    24.         if (this == o) return true;
    25.         if (o == null || getClass() != o.getClass()) return false;
    26.         Point point = (Point) o;
    27.         return x == point.x && y == point.y;
    28.     }
    29.  
    30.     @Override
    31.     public int hashCode() {
    32.         return Objects.hash(x, y);
    33.     }
    34.  
    35.     @Override
    36.     public String toString() {
    37.         return "Point{" +
    38.                 "x=" + x +
    39.                 ", y=" + y +
    40.                 '}';
    41.     }
    42.  
    43. }
    44. 复制代码

    移动方向 Direction.java

    提供上、下、左、右四个移动方向的枚举。

    1. package cn.xeblog.snake.model;
    2.  
    3. /**
    4.  * @author anlingyi
    5.  * @date 2022/8/2 5:25 PM
    6.  */
    7. public enum Direction {
    8.     UP,
    9.     DOWN,
    10.     LEFT,
    11.     RIGHT
    12. }
    13.  
    14. 复制代码

    蛇 Snake.java

    存储蛇身坐标信息，提供蛇身移动、移除蛇尾坐标、获取蛇头、蛇尾坐标、蛇身长度等方法。

    这里讲一下蛇移动的实现原理：游戏开始时，会固定一个移动方向，蛇会一直朝着这个方向移动，我们可以通过方向键改变蛇的移动方向，蛇的移动其实就是将蛇身的坐标移动一下位置，比如蛇身长度（不包含蛇头）为6，移动时，只需将蛇身位置为5的坐标移到位置为6的坐标去，位置为4的坐标移动到位置为5的坐标去，简单来说就是将前一个的坐标换到它后面一个去，这是蛇身的移动，蛇头的移动需要单独计算，如果是上下方向移动，那就是对y坐标的加减操作，向上运动需要减一个蛇身的高度，向下则与之相反，需要加一个蛇身的高度，左右运动同理。

    1. package cn.xeblog.snake.model;
    2.  
    3. import java.util.List;
    4.  
    5. /**
    6.  * 蛇
    7.  *
    8.  * @author anlingyi
    9.  * @date 2022/8/2 3:32 PM
    10.  */
    11. public class Snake {
    12.  
    13.     public static int width = 10;
    14.  
    15.     public static int height = 10;
    16.  
    17.     /**
    18.      * 蛇身坐标列表
    19.      */
    20.     public List body;
    21.  
    22.     public Snake(List body) {
    23.         this.body = body;
    24.     }
    25.  
    26.     /**
    27.      * 添加蛇身坐标
    28.      *
    29.      * @param x
    30.      * @param y
    31.      */
    32.     public void add(int x, int y) {
    33.         this.body.add(new Point(x * width, y * height));
    34.     }
    35.  
    36.     /**
    37.      * 移除蛇尾坐标
    38.      */
    39.     public void removeLast() {
    40.         int size = size();
    41.         if (size == 0) {
    42.             return;
    43.         }
    44.  
    45.         this.body.remove(size - 1);
    46.     }
    47.  
    48.     /**
    49.      * 获取蛇头坐标
    50.      *
    51.      * @return
    52.      */
    53.     public Point getHead() {
    54.         if (size() > 0) {
    55.             return this.body.get(0);
    56.         }
    57.  
    58.         return null;
    59.     }
    60.  
    61.     /**
    62.      * 获取蛇尾坐标
    63.      *
    64.      * @return
    65.      */
    66.     public Point getTail() {
    67.         int size = size();
    68.         if (size > 0) {
    69.             return this.body.get(size - 1);
    70.         }
    71.  
    72.         return null;
    73.     }
    74.  
    75.     /**
    76.      * 蛇身长度
    77.      *
    78.      * @return
    79.      */
    80.     public int size() {
    81.         return this.body.size();
    82.     }
    83.  
    84.     /**
    85.      * 蛇移动
    86.      *
    87.      * @param direction 移动方向
    88.      */
    89.     public void move(Direction direction) {
    90.         if (size() == 0) {
    91.             return;
    92.         }
    93.  
    94.         for (int i = this.size() - 1; i > 0; i--) {
    95.             // 从蛇尾开始向前移动
    96.             Point point = this.body.get(i);
    97.             Point nextPoint = this.body.get(i - 1);
    98.             point.x = nextPoint.x;
    99.             point.y = nextPoint.y;
    100.         }
    101.  
    102.         // 蛇头移动
    103.         Point head = getHead();
    104.         switch (direction) {
    105.             case UP:
    106.                 head.y -= height;
    107.                 break;
    108.             case DOWN:
    109.                 head.y += height;
    110.                 break;
    111.             case LEFT:
    112.                 head.x -= width;
    113.                 break;
    114.             case RIGHT:
    115.                 head.x += width;
    116.                 break;
    117.         }
    118.     }
    119.  
    120. }
    121. 复制代码

    药丸 Pill.java

    存储“药丸“的坐标、类型信息。

    1. package cn.xeblog.snake.model;
    2.  
    3. /**
    4.  * 药丸
    5.  *
    6.  * @author anlingyi
    7.  * @date 2022/8/2 4:49 PM
    8.  */
    9. public class Pill {
    10.  
    11.     public static int width = 10;
    12.  
    13.     public static int height = 10;
    14.  
    15.     /**
    16.      * 坐标
    17.      */
    18.     public Point point;
    19.  
    20.     /**
    21.      * 药丸类型
    22.      */
    23.     public PillType pillType;
    24.  
    25.     public enum PillType {
    26.         /**
    27.          * 红色药丸
    28.          */
    29.         RED(5),
    30.         /**
    31.          * 蓝色药丸
    32.          */
    33.         BLUE(2),
    34.         /**
    35.          * 绿色药丸
    36.          */
    37.         GREEN(1),
    38.         ;
    39.  
    40.         /**
    41.          * 分数
    42.          */
    43.         public int score;
    44.  
    45.         PillType(int score) {
    46.             this.score = score;
    47.         }
    48.     }
    49.  
    50.     public Pill(int x, int y, PillType pillType) {
    51.         this.point = new Point(x * width, y * height);
    52.         this.pillType = pillType;
    53.     }
    54.  
    55. }
    56. 复制代码

    游戏界面

    初始化一些信息，比如游戏界面的宽高、定时器、一些状态标识（是否停止游戏、游戏是否胜利）、监听一些按键事件（空格键开始/暂停游戏、四个方向键控制蛇移动的方向），绘制游戏画面。

    当检测到游戏开始时，初始化蛇、“药丸”的位置信息，然后启动定时器每隔一段时间重新绘制游戏画面，让蛇可以动起来。

    当检测到蛇咬到自己或者是蛇撞墙时，游戏状态将会被标记为“游戏失败”，绘制游戏结束画面，并且定时器停止，如果蛇身为0，则游戏结束，游戏状态标记为“游戏胜利”。

    1. package cn.xeblog.snake.ui;
    2.  
    3. import cn.xeblog.snake.model.Direction;
    4. import cn.xeblog.snake.model.Pill;
    5. import cn.xeblog.snake.model.Point;
    6. import cn.xeblog.snake.model.Snake;
    7.  
    8. import javax.swing.*;
    9. import java.awt.*;
    10. import java.awt.event.*;
    11. import java.util.ArrayList;
    12. import java.util.Collections;
    13. import java.util.Random;
    14.  
    15. /**
    16.  * @author anlingyi
    17.  * @date 2022/8/2 3:51 PM
    18.  */
    19. public class SnakeGameUI extends JPanel implements ActionListener {
    20.  
    21.     /**
    22.      * 宽度
    23.      */
    24.     private int width;
    25.  
    26.     /**
    27.      * 高度
    28.      */
    29.     private int height;
    30.  
    31.  
    32.     /**
    33.      * 蛇
    34.      */
    35.     private Snake snake;
    36.  
    37.     /**
    38.      * 药丸
    39.      */
    40.     private Pill pill;
    41.  
    42.     /**
    43.      * 移动方向
    44.      */
    45.     private Direction direction;
    46.  
    47.     /**
    48.      * 停止游戏标记
    49.      */
    50.     private boolean stop;
    51.  
    52.     /**
    53.      * 游戏状态 0.初始化 1.游戏胜利 2.游戏失败
    54.      */
    55.     private int state = -1;
    56.  
    57.     /**
    58.      * 定时器
    59.      */
    60.     private Timer timer;
    61.  
    62.     /**
    63.      * 移动速度
    64.      */
    65.     private int speed = 100;
    66.  
    67.     /**
    68.      * 分数
    69.      */
    70.     private int score;
    71.  
    72.     /**
    73.      * 特殊药丸列表
    74.      */
    75.     private ArrayList specialPill;
    76.  
    77.     public SnakeGameUI(int width, int height) {
    78.         this.width = width;
    79.         this.height = height;
    80.         this.timer = new Timer(speed, this);
    81.         this.stop = true;
    82.  
    83.         initPanel();
    84.     }
    85.  
    86.     /**
    87.      * 初始化
    88.      */
    89.     private void init() {
    90.         this.score = 0;
    91.         this.state = 0;
    92.         this.stop = true;
    93.         this.timer.setDelay(speed);
    94.  
    95.         initSnake();
    96.         initPill();
    97.         generatePill();
    98.         repaint();
    99.     }
    100.  
    101.     /**
    102.      * 初始化游戏面板
    103.      */
    104.     private void initPanel() {
    105.         this.setPreferredSize(new Dimension(this.width, this.height));
    106.         this.addKeyListener(new KeyAdapter() {
    107.             @Override
    108.             public void keyPressed(KeyEvent e) {
    109.                 if (stop && e.getKeyCode() != KeyEvent.VK_SPACE) {
    110.                     return;
    111.                 }
    112.  
    113.                 switch (e.getKeyCode()) {
    114.                     case KeyEvent.VK_UP:
    115.                         if (direction == Direction.DOWN) {
    116.                             break;
    117.                         }
    118.  
    119.                         direction = Direction.UP;
    120.                         break;
    121.                     case KeyEvent.VK_DOWN:
    122.                         if (direction == Direction.UP) {
    123.                             break;
    124.                         }
    125.  
    126.                         direction = Direction.DOWN;
    127.                         break;
    128.                     case KeyEvent.VK_LEFT:
    129.                         if (direction == Direction.RIGHT) {
    130.                             break;
    131.                         }
    132.  
    133.                         direction = Direction.LEFT;
    134.                         break;
    135.                     case KeyEvent.VK_RIGHT:
    136.                         if (direction == Direction.LEFT) {
    137.                             break;
    138.                         }
    139.  
    140.                         direction = Direction.RIGHT;
    141.                         break;
    142.                     case KeyEvent.VK_SPACE:
    143.                         if (state != 0) {
    144.                             init();
    145.                         }
    146.  
    147.                         stop = !stop;
    148.                         if (!stop) {
    149.                             timer.start();
    150.                         }
    151.                         break;
    152.                 }
    153.             }
    154.         });
    155.     }
    156.  
    157.     /**
    158.      * 初始化蛇
    159.      */
    160.     private void initSnake() {
    161.         this.direction = Direction.LEFT;
    162.         int maxX = this.width / Snake.width;
    163.         int maxY = this.height / Snake.height;
    164.  
    165.         this.snake = new Snake(new ArrayList<>());
    166.         this.snake.add(maxX - 2, 3);
    167.         this.snake.add(maxX - 1, 3);
    168.         this.snake.add(maxX - 1, 2);
    169.         this.snake.add(maxX - 1, 1);
    170.         for (int i = maxX - 1; i > 0; i--) {
    171.             this.snake.add(i, 1);
    172.         }
    173.         for (int i = 1; i < maxY - 1; i++) {
    174.             this.snake.add(1, i);
    175.         }
    176.         for (int i = 1; i < maxX - 1; i++) {
    177.             this.snake.add(i, maxY - 2);
    178.         }
    179.     }
    180.  
    181.     /**
    182.      * 初始化药丸
    183.      */
    184.     private void initPill() {
    185.         this.specialPill = new ArrayList<>();
    186.         for (int i = 0; i < 5; i++) {
    187.             this.specialPill.add(Pill.PillType.RED);
    188.         }
    189.         for (int i = 0; i < 10; i++) {
    190.             this.specialPill.add(Pill.PillType.BLUE);
    191.         }
    192.  
    193.         Collections.shuffle(specialPill);
    194.     }
    195.  
    196.     /**
    197.      * 生成药丸
    198.      */
    199.     private void generatePill() {
    200.         // 是否获取特殊药丸
    201.         boolean getSpecialPill = new Random().nextInt(6) == 3;
    202.         Pill.PillType pillType;
    203.         if (getSpecialPill && this.specialPill.size() > 0) {
    204.             // 生成特殊药丸
    205.             int index = new Random().nextInt(this.specialPill.size());
    206.             pillType = this.specialPill.get(index);
    207.             this.specialPill.remove(index);
    208.         } else {
    209.             // 生成绿色药丸
    210.             pillType = Pill.PillType.GREEN;
    211.         }
    212.  
    213.         // 随机坐标
    214.         int x = new Random().nextInt(this.width / Pill.width - 1);
    215.         int y = new Random().nextInt(this.height / Pill.height - 1);
    216.         this.pill = new Pill(x, y, pillType);
    217.     }
    218.  
    219.     @Override
    220.     protected void paintComponent(Graphics g) {
    221.         super.paintComponent(g);
    222.  
    223.         Graphics2D g2 = (Graphics2D) g;
    224.         g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    225.         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    226.  
    227.         g2.setColor(new Color(66, 66, 66));
    228.         g2.fillRect(0, 0, this.width, this.height);
    229.  
    230.         if (this.snake != null) {
    231.             // 画蛇
    232.             g2.setColor(new Color(255, 255, 255));
    233.             for (int i = this.snake.size() - 1; i >= 0; i--) {
    234.                 Point point = this.snake.body.get(i);
    235.                 if (i == 0) {
    236.                     // 蛇头
    237.                     g2.setColor(new Color(255, 92, 92));
    238.                 } else {
    239.                     g2.setColor(new Color(215, 173, 173));
    240.                 }
    241.  
    242.                 g2.fillRect(point.x, point.y, Snake.width, Snake.height);
    243.             }
    244.         }
    245.  
    246.         if (this.pill != null) {
    247.             // 画药丸
    248.             Color pillColor;
    249.             switch (this.pill.pillType) {
    250.                 case RED:
    251.                     pillColor = new Color(255, 41, 41);
    252.                     break;
    253.                 case BLUE:
    254.                     pillColor = new Color(20, 250, 243);
    255.                     break;
    256.                 default:
    257.                     pillColor = new Color(97, 255, 113);
    258.                     break;
    259.             }
    260.  
    261.             g2.setColor(pillColor);
    262.             g2.fillOval(pill.point.x, pill.point.y, Pill.width, Pill.height);
    263.         }
    264.  
    265.         if (state > 0) {
    266.             // 显示游戏结果
    267.             String tips = "游戏失败！";
    268.             if (state == 1) {
    269.                 tips = "游戏胜利！";
    270.             }
    271.             g2.setFont(new Font("", Font.BOLD, 20));
    272.             g2.setColor(new Color(208, 74, 74));
    273.             g2.drawString(tips, this.width / 3, this.height / 3);
    274.  
    275.             g2.setFont(new Font("", Font.PLAIN, 18));
    276.             g2.setColor(Color.WHITE);
    277.             g2.drawString("得分：" + this.score, this.width / 2, this.height / 3 + 50);
    278.         }
    279.  
    280.         if (stop) {
    281.             g2.setFont(new Font("", Font.PLAIN, 18));
    282.             g2.setColor(Color.WHITE);
    283.             g2.drawString("按空格键开始/暂停游戏！", this.width / 4, this.height - 50);
    284.         }
    285.     }
    286.  
    287.     @Override
    288.     public void actionPerformed(ActionEvent e) {
    289.         // 是否吃药
    290.         boolean isAte = false;
    291.         if (!this.stop) {
    292.             // 移动蛇
    293.             this.snake.move(this.direction);
    294.             Point head = this.snake.getHead();
    295.             if (head.equals(this.pill.point)) {
    296.                 // 吃药了
    297.                 isAte = true;
    298.                 // 药丸分数
    299.                 int getScore = this.pill.pillType.score;
    300.                 // 累计分数
    301.                 this.score += getScore;
    302.                 for (int i = 0; i < getScore; i++) {
    303.                     // 移除蛇尾
    304.                     this.snake.removeLast();
    305.                     if (this.snake.size() == 0) {
    306.                         // 游戏胜利
    307.                         this.state = 1;
    308.                         this.stop = true;
    309.                         break;
    310.                     }
    311.                 }
    312.  
    313.                 pill = null;
    314.                 if (this.score % 10 == 0) {
    315.                     int curSpeed = this.timer.getDelay();
    316.                     if (curSpeed > 30) {
    317.                         // 加速
    318.                         this.timer.setDelay(curSpeed - 10);
    319.                     }
    320.                 }
    321.             }
    322.  
    323.             if (state == 0) {
    324.                 // 判断蛇有没有咬到自己或是撞墙
    325.                 int maxWidth = this.width - this.snake.width;
    326.                 int maxHeight = this.height - this.snake.height;
    327.                 boolean isHitWall = head.x > maxWidth || head.x < 0 || head.y > maxHeight || head.y < 0;
    328.                 boolean isBiting = false;
    329.                 for (int i = this.snake.size() - 1; i > 0; i--) {
    330.                     if (head.equals(this.snake.body.get(i))) {
    331.                         isBiting = true;
    332.                         break;
    333.                     }
    334.                 }
    335.  
    336.                 if (isHitWall || isBiting) {
    337.                     // 游戏失败
    338.                     this.state = 2;
    339.                     this.stop = true;
    340.                 }
    341.             }
    342.         }
    343.  
    344.         if (this.stop) {
    345.             this.timer.stop();
    346.         } else if (isAte) {
    347.             // 重新生成药丸
    348.             generatePill();
    349.         }
    350.  
    351.         repaint();
    352.     }
    353.  
    354. }
    355. 复制代码

    启动类

    游戏启动入口。

    1. package cn.xeblog.snake;
    2.  
    3. import cn.xeblog.snake.ui.SnakeGameUI;
    4.  
    5. import javax.swing.*;
    6.  
    7. /**
    8.  * 启动游戏
    9.  *
    10.  * @author anlingyi
    11.  * @date 2022/8/2 3:41 PM
    12.  */
    13. public class StartGame {
    14.  
    15.     public static void main(String[] args) {
    16.         JFrame frame = new JFrame();
    17.         frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    18.         frame.setVisible(true);
    19.         frame.setResizable(false);
    20.         frame.setTitle("不贪吃蛇");
    21.         frame.setSize(400, 320);
    22.         frame.setLocationRelativeTo(null);
    23.         JPanel gamePanel = new SnakeGameUI(400, 300);
    24.         frame.add(gamePanel);
    25.         gamePanel.requestFocus();
    26.     }
    27.  
    28. }
    29. 复制代码

    游戏演示

     

     

    最后

    刚开始蛇身很长，蛇身移动缓慢，后面会随着得分的越来越高，蛇身会移动的越来越快，看着挺容易，真玩起来，还真有“亿”点难，目前我玩了好几把，没有赢过，最开始那张图就是我目前的最高分了，嘻嘻~

  • 相关阅读:
    硬件设计哪些事-PCB设计那些事
    Jmeter接口测试简易步骤
    Socks5代理与网络安全：保护隐私、绕过限制与爬虫应用
    web基础与HTTP协议
    docker部署elk
    Golang基本命令操作
    Vue前端项目安装及相关问题解决
    指针变量和地址
    SpringBoot原理-自动配置-案例（自定义starter分析）
    数据卷(Data Volumes)&dockerfile
  • 原文地址：https://blog.csdn.net/YYniannian/article/details/126134577