简易贪吃蛇小游戏java版

最新推荐文章于 2024-06-10 23:10:14 发布
最新推荐文章于 2024-06-10 23:10:14 发布
阅读量1k 收藏 5
点赞数
文章标签： jav
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36648920/article/details/82763753
版权

package com.java20180917.snake;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.LinkedList;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

/**
 * 1.初始化界面 2.初始化面板 3.面板与界面合并
 * 
 * @author Xiaolei
 *
 */
public class Main extends JFrame implements KeyListener {
    private static final long serialVersionUID = -1803858577233572276L;
    private JPanel jp = null;
    private int fw = 600;
    private int fh = 600;

    private int count = 4;
    private int b_size=20;
    private int se_size = 20;
    private int se_x = 100;
    private int se_y = 200;
    private LinkedList<SE> snake = new LinkedList<SE>();
    private String direction = Constant.UP;
    private String tip = "";
    private String status = "";
    private long speed = 300;
    // 豆子初始化
    private LinkedList<Bean> b = new LinkedList<Bean>();
    
    private int Score;
    
    // 总初始化方法
    private void init() {
        initSnake();
        initPanel();
        initFrame();
        initBean();
        initThread();
    }

    private void initBean() {
        // 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
        int b_x = 20 * Math.round((new Random().nextInt(30)));
        int b_y = 20 * Math.round((new Random().nextInt(30)));
        //如果蛇的列表中不包含豆子的位置                        如果此列表包含指定元素，则返回 true。
        if(!(snake.contains(new SE(b_size, b_x, b_y)))) {
            b.add(new Bean(b_x, b_y, b_size));
        }

    }

    // 如果方面符合条件，就触发该方法，弹出窗口
    private void popup() {
        tip = Constant.TIP;
        status = Constant.STOP;
        int op_result = JOptionPane.showConfirmDialog(jp, "GAME OVER!", "你挂了!", JOptionPane.OK_CANCEL_OPTION,
                JOptionPane.ERROR_MESSAGE);
        if (op_result == 0) {
            // 重新开始游戏
            // 让蛇的运动条件重新开始
            status = "";
            // 把蛇的链表集合清空掉
            snake.clear();
            // 把Game Over字体清空。
            tip = "";
            // 让方块重新向上跑
            direction = Constant.UP;
            // 重新调用方块，初始化蛇
            initSnake();
            speed=300;
            Score=0;
        }
        if (op_result == 2) {
            System.exit(0);
        }
    }

    private void initThread() {
        // 添加线程，让方块跟着键盘的指定方面运动
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if ("".equalsIgnoreCase(status)) {
                        if (snake.getFirst().getSe_x() == b.getFirst().getB_x()
                                && snake.getFirst().getSe_y() == b.getFirst().getB_y()) {
                            //吃掉一个豆子，就把原来的豆子清掉，重新在创建一个豆子
                            b.clear();
                            //新建一个豆子
                            
                            //在蛇方块的尾部增加一个方块
                            snake.add(new SE(se_size, snake.getLast().getSe_x(), snake.getLast().getSe_y()));
                            initBean();
                            Score++;
//                            加速
                            if(Score==5) {
                                speed-=100;
                            }
                            else if(Score==15) {
                                speed-=150;
                            }
                            else if(Score==25) {
                                speed-=200;
                            }
                            
                        }
                        
                        // 判断是否咬到自己(即头部坐标与身体上的任何一个元素的坐标重合)
                        for (int i = 1; i < snake.size(); i++) {
                            if (snake.getFirst().getSe_x() == snake.get(i).getSe_x()
                                    && snake.getFirst().getSe_y() == snake.get(i).getSe_y()) {
                                popup();
                            }
                        }
                        // 操作snake容器中的元素
                        // 移除最后一个
                        snake.removeLast();
                        // 添加一个到头部
                        // 让方块往上走
                        if (direction.equalsIgnoreCase(Constant.UP)) {
                            // 如果新的头部y的坐标出界，提示game over
                            if (snake.getFirst().getSe_y() - se_size < 0) {
                                popup();
                            }
                            //在蛇方块的头部加一个蛇方块
                            snake.addFirst(
                                    new SE(se_size, snake.getFirst().getSe_x(), snake.getFirst().getSe_y() - se_size));
                        }
                        // 让方块往下走
                        if (direction.equalsIgnoreCase(Constant.Down)) {
                            //蛇方块的坐标从左上角开始计算
                            //如果蛇的头部的位置+自身的大小大于窗口总宽度就结束游戏
                            if (snake.getFirst().getSe_y() + se_size > fh) {
                                popup();
                            }
                            snake.addFirst(
                                    new SE(se_size, snake.getFirst().getSe_x(), snake.getFirst().getSe_y() + se_size));
                        }
                        // 让方块往左走
                        if (direction.equalsIgnoreCase(Constant.LEFT)) {
                            // 如果方面的头碰到墙壁就结束游戏，弹窗
                            if (snake.getFirst().getSe_x() - se_size < 0) {
                                popup();
                            }
                            snake.addFirst(
                                    new SE(se_size, snake.getFirst().getSe_x() - se_size, snake.getFirst().getSe_y()));
                        }
                        // 让方块往右走
                        if (direction.equalsIgnoreCase(Constant.RIGHT)) {
                            if (snake.getFirst().getSe_x() + se_size > fw) {
                                popup();
                            }
                            snake.addFirst(
                                    new SE(se_size, snake.getFirst().getSe_x() + se_size, snake.getFirst().getSe_y()));
                        }
                        // 方块动起来后，重画填充
                        jp.repaint();
                        try {
                            Thread.sleep(speed);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }
        }).start();
    }

    private void initSnake() {
        // 创建多个有关联着的SE
        // 添加到snake容器中
        for (int i = 0; i < count; i++) {
            snake.add(new SE(se_size, se_x, se_y + se_size * i));
        }
    }

    private void initPanel() {
        jp = new JPanel() {
            private static final long serialVersionUID = 1L;

            // 在面板中填充方块的初始位置和颜色
            @Override
            public void paint(Graphics g) {
                super.paint(g);
                if (!"".equals(tip)) {
                    g.setColor(Color.red);
                    g.setFont(new Font("", Font.BOLD, 40));
                    g.drawString(tip, 160, 160);
                }
                // 初始化豆子
                for (int i = 0; i < b.size(); i++) {
                    g.setColor(Color.YELLOW);
                    g.fillRect(b.get(i).getB_x(), b.get(i).getB_y(), b.get(i).getB_size(), b.get(i).getB_size());
                }
                for (int i = 0; i < snake.size(); i++) {
                    if (i == 0) {
                        g.setColor(Color.GRAY);
                    } else {
                        g.setColor(Color.BLUE);
                    }
                    g.fill3DRect(snake.get(i).getSe_x(), snake.get(i).getSe_y(), snake.get(i).getSe_size(),
                            snake.get(i).getSe_size(), true);
                }
                Integer a = new Integer(Score);
                g.setColor(Color.ORANGE);
                g.setFont(new Font("", Font.BOLD, 30));
                g.drawString("成绩:"+a.toString(), 460, 50);
            }
        };
        // 设置透明度
        jp.setOpaque(false);
    }

    private void initFrame() {
        // 设置窗口标题
        this.setTitle("测试");
        // 设置窗口大小
        this.setSize(fw, fh);
        // 设置窗口背景颜色
        this.getContentPane().setBackground(Color.black);
//        禁用或启用此框架的装饰。
        this.setUndecorated(true);
        // 把面板放到窗口上
        this.add(jp);
        // 设置窗口可见
        this.setVisible(true);
        // 当前对象具有多重身份 (这是由继承结构决定的)
        // 第一个this --- 窗口对象
        // 第二个this --- 键盘监听器
        this.addKeyListener(this);
        // 把窗口设置在指定的位置
        this.setLocationRelativeTo(null);
    }

    public Main() {
        init();
    }

    public static void main(String[] args) {
        new Main();
    }

    @Override
    public void keyTyped(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void keyPressed(KeyEvent e) {
        // 按下按一个按键 停止虚拟机运行
//        System.out.println(e.getKeyCode());
        // 按下esc键 关停虚拟机

        if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
            System.exit(0);
        }
        // 获取键盘值的上下左右，赋于我的当前对象
        if (!this.direction.equalsIgnoreCase(Constant.LEFT) && e.getKeyCode() == KeyEvent.VK_RIGHT) {
            this.direction = Constant.RIGHT;
        }
        if (!this.direction.equalsIgnoreCase(Constant.RIGHT) && e.getKeyCode() == KeyEvent.VK_LEFT) {
            this.direction = Constant.LEFT;
        }
        if (!this.direction.equalsIgnoreCase(Constant.UP) && e.getKeyCode() == KeyEvent.VK_DOWN) {
            this.direction = Constant.Down;
        }
        if (!this.direction.equalsIgnoreCase(Constant.Down) && e.getKeyCode() == KeyEvent.VK_UP) {
            this.direction = Constant.UP;
        }
        if (e.getKeyCode() == KeyEvent.VK_SPACE) {
            // 先检查status的值 如果是 "" 就修改成 pause 如果是 pause 就改成 ""
            switch (status) {
            case Constant.PAUSE:
                this.status = "";
                break;
            case "":
                this.status = Constant.PAUSE;
                break;
            }
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        // TODO Auto-generated method stub

    }

}

接口：

package com.java20180917.snake;
/**
 * 常量接口
 * @author Xiaolei
 *
 */
public interface Constant {
    /**
     *方向常量
     */
    public static final String UP = "up";
    public static final String Down = "down";
    public static final String LEFT = "left";
    public static final String RIGHT = "right";
    public static final String TIP = "GAME OVER !";
    public static final String STOP = "stop";//停止
    public static final String PAUSE = "pause";//暂停
}
 

蛇类：

package com.java20180917.snake;

import java.io.Serializable;
/**
 * 蛇身体关节元素  实体类
 * @author Xiaolei
 *
 */
public class SE implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 4103030147063529932L;
    private int se_size;
    private int se_x;
    private int se_y;
    public SE(int se_size, int se_x, int se_y) {
        super();
        this.se_size = se_size;
        this.se_x = se_x;
        this.se_y = se_y;
    }
    public SE() {
        super();
        // TODO Auto-generated constructor stub
    }
    public int getSe_size() {
        return se_size;
    }
    public void setSe_size(int se_size) {
        this.se_size = se_size;
    }
    public int getSe_x() {
        return se_x;
    }
    public void setSe_x(int se_x) {
        this.se_x = se_x;
    }
    public int getSe_y() {
        return se_y;
    }
    public void setSe_y(int se_y) {
        this.se_y = se_y;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
    @Override
    public String toString() {
        return "SE [se_size=" + se_size + ", se_x=" + se_x + ", se_y=" + se_y + "]";
    }
    
    
}

豆子类：

package com.java20180917.snake;


public class Bean {
    private int b_x;
    private int b_y;
    private int b_size;
    public Bean() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Bean(int b_x, int b_y, int b_size) {
        super();
        this.b_x = b_x;
        this.b_y = b_y;
        this.b_size = b_size;
    }
    public int getB_x() {
        return b_x;
    }
    public void setB_x(int b_x) {
        this.b_x = b_x;
    }
    public int getB_y() {
        return b_y;
    }
    public void setB_y(int b_y) {
        this.b_y = b_y;
    }
    public int getB_size() {
        return b_size;
    }
    public void setB_size(int b_size) {
        this.b_size = b_size;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + b_size;
        result = prime * result + b_x;
        result = prime * result + b_y;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Bean other = (Bean) obj;
        if (b_size != other.b_size)
            return false;
        if (b_x != other.b_x)
            return false;
        if (b_y != other.b_y)
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Bean [b_x=" + b_x + ", b_y=" + b_y + ", b_size=" + b_size + "]";
    }
    
}
 

 

 

 

 

在java的道路上一去不复返
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
简易版贪吃蛇小游戏（Java）
04-15
【标题】"简易版贪吃蛇小游戏（Java）"是一个基于Java编程语言开发的经典小游戏，旨在教授初学者如何利用Java的基本语法和控制结构实现游戏逻辑。这个游戏的核心是通过用户输入来控制蛇移动，同时在屏幕上生成食物，...
java实现游戏-简易贪吃蛇
07-30
这是一个使用java实现的简单小游戏，简易贪吃蛇。 ——————————————————————————————————————— 功能尚不完善，但是可以作为基础参考，适合初学者。 欢迎大家下载，资源免费，...
简易贪吃蛇小游戏java版_用GUI实现java版贪吃蛇小游戏
weixin_42127835的博客
02-24 148
本文实例为大家分享了java版贪吃蛇小游戏的具体代码，供大家参考，具体内容如下项目结构新建一个JFrame窗口,作为程序入口public class GameStart{public static void main(String[] args) {JFrame jFrame = new JFrame();jFrame.setBounds(100,100,900,720);jFrame.setDe...
简易贪吃蛇小游戏java版_利用java实现一个简单的贪吃蛇小游戏
weixin_33421411的博客
02-24 94
GUI编程实现贪吃蛇小游戏1、编写主方法实现启动类2、准备好素材图片，编写数据类3、代码主体部分：在panel面板上实现游戏初始化，键盘和事件的监听等功能4、代码运行效果图5、GitHub源码链接1、编写主方法实现启动类import javax.swing.*;//主启动类public class StartGame {public static void main(String[] args) ...
java课程设计大作业 2048小游戏（设计实现文档+源代码）
m0_73546099的博客
06-10 500
在完成一次靠左移动后，接下来的双重循环使用来合并小方格中数字相同的元素的，把他们相加并放到靠左的方格中，同样外循环是用来控制行数，内循环控制列数，在内循环中加了一个判断条件，当列数加1小于4时（因为只需循环到第三列即可完成该操作），同时该列与该列+1的那一列的元素值相等且它们都不等于0时，即可进行合并操作，合并后，把该列的值置为两元素相加的结果，并把该列+1列置为0，然后把统计是否移动了的计数器进行一个自增操作。
JavaGUI 简易版贪吃蛇小游戏
一切随缘的博客
01-08 3781
我们需要什么，我们就创建什么类：我们需要一个蛇，于是创建了一个Snake类，然后蛇又是由一个个的节点组成，于是我们又创建了Node类，以此类推，我们又创建了Apple类…我们要做的就是继承GameEngine，实现updateLogic,renderUI方法。面向对象思想（指的是程序的最小单位是对象。一开始我们可以画上网格线，方便程序的编写。做这个小游戏，主要是学习一下游戏制作的基本逻辑，加深对面向对象的理解。其实游戏就是逻辑判断，页面更新的死循环。添加游戏关卡，蛇移动的速度越来越快。
Java简易小游戏贪吃蛇（Java实战）
weixin_71766825的博客
07-20 5233
Java初学者实战篇，贪吃蛇小游戏（简易版）
java实现简易贪吃蛇小游戏
weixin_48598155的博客
07-21 788
贪吃蛇整体思路代码实现游戏窗体类节点类蛇类食物类方向枚举类开始游戏类运行效果截图 整体思路 初始化 画一个游戏背景框，生成蛇和食物 蛇的生成 定义节点类Node 定义蛇类Snake，其中成员变量body表示蛇的身体，由节点的链表集合组成，初始方向为左。 蛇的移动实现是通过在头节点前面生成一个节点，然后删除尾节点。 蛇吃食物长大是在头节点前面生成一个节点。 食物的生成 定义食物类Food，继承节点类Node，通过Random类随机生成食物。 键盘监听 通过 碰撞检测 蛇的头节点超出背景框范围，或碰到蛇身体上
java做贪吃蛇网络版_java实现简易贪吃蛇游戏
weixin_31786973的博客
02-27 234
本文实例为大家分享了java实现贪吃蛇游戏的具体代码，供大家参考，具体内容如下1.封装贪吃蛇身体，抽象出贪吃蛇结点类Node，结点用ArrayList存储import java.awt.*;public class Node {private int x;private int y;public Node(int x, int y) {this.x = x;this.y = y;}public N...
python快速实现简易贪吃蛇小游戏
ASS-ASH的博客
10-19 3710
对原代码结构进行了进一步规范化，且原运行结果是死亡之后等待两秒结束游戏自动退出游戏窗 ，改为游戏结束之后，手动点击屏幕或者右上角X键退出游戏；并增加了移动变速，初始速度为10，当积分达到50则速度为15，积分60速度20，积分70速度30，积分80速度40，飞一般的感觉。另外还有一种名为“贪吃蛇”钻井测井技术，是运用旋转导向系统、随钻测井系统等的油气田定向钻井、随钻测井技术，可完成海上“丛式井”和复杂油气层的开采需求，大幅降低油气田开发综合成本。）游戏是一款休闲益智类游戏，有PC和手机等多平台版本。
java swing简易小游戏_java swing 实现贪吃蛇小游戏
weixin_28870939的博客
02-26 346
import java.awt.*;import javax.swing.*;import java.awt.event.*;import java.util.*;class Snak extends KeyAdapter implements ActionListener{JFrame jframe=new JFrame("贪吃蛇");Panel jpanel=new Panel();JPane...
Java游戏-贪吃蛇
m0_54570435的博客
04-20 3259
现在越来越多的游戏涌入我们的视野，丰富和影响着我们的生活。从技术上来讲，贪吃蛇的设计工作复杂且富有挑战性，它包含的内容多，设计的知识广泛，与图形界面的联系大，包括界面的显示和不断刷新等，在设计的时候，要运用到各方面的知识，这对于我的编程逻辑以及专业认知是有很大帮助的。功能：首先进行画面设计进行绘制窗口，分为游戏界面，再然后进行蛇的构造，在进行食物的构造，在游戏的过程中，进行蛇的移动的功能，蛇吃食物，和食物的重新生成的功能，和蛇的死亡判定，和在游戏中相关提示语的绘制，和进行关数的参加，和通关条件的判断。
Python简易贪吃蛇小游戏
10-19
Python简易贪吃蛇小游戏
小游戏项目：简易贪吃蛇
07-08
- **简易贪吃蛇**：此项目旨在通过创建一个简单的贪吃蛇游戏，让学习者掌握基础的游戏开发流程及Python编程技巧。该项目利用了Python及其游戏开发库Pygame。 #### 二、项目环境准备 1. **Python安装**： - 推荐...
简易的贪吃蛇小游戏
07-17
【贪吃蛇小游戏详解】 贪吃蛇小游戏是一个经典的计算机程序，深受编程初学者的喜爱，它可以帮助初学者巩固基础，理解游戏编程的基本逻辑。这个小游戏基于Java语言开发，是学习Java核心编程后的一个理想实践项目。 ...
基于Matlab的模糊PID控制系统设计及仿真.pdf
08-05
基于Matlab的模糊PID控制系统设计及仿真
黑马头条，黑马头条，黑马头条
08-05
黑马头条，黑马头条，黑马头条
基于ppo算法的计算卸载策略研究python
08-05
ppo算法 基于ppo算法的计算卸载策略研究 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
SQLTools插件下载与使用说明
最新发布
08-05
1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值