java 贪吃蛇小游戏

已于 2022-07-27 09:25:58 修改
阅读量226 收藏 2
点赞数 3
分类专栏： java后端 文章标签： java 贪吃蛇
于 2018-09-12 14:51:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38151907/article/details/82661394
版权

今天写了一个贪吃蛇的小游戏用来练手，在流程控制方面也没有封装方法进行简化，不过作为锻炼流程控制是很好的。

下面附上自己的源码

  • package com.oracle;

    import java.awt.Graphics;
    import java.awt.Image;
    import java.awt.event.KeyEvent;
    import java.awt.event.KeyListener;
    import java.util.ArrayList;
    import java.util.List;
    import javax.swing.ImageIcon;
    import javax.swing.JFrame;
    import javax.swing.JMenu;
    import javax.swing.JMenuBar;
    import javax.swing.JMenuItem;
    import javax.swing.JPanel;

    public class Game_贪吃蛇2 {
        int tx = 10;
        int ty = 10;
        int tf = 0;// 蛇头方向
        int sts = 0;// 蛇身体数量
        int qx = (((int) (Math.random() * 19)) * 30) + 10;
        int qy = (((int) (Math.random() * 19)) * 30) + 10;
        List<Integer> lx = new ArrayList<>();
        List<Integer> ly = new ArrayList<>();
        boolean death = false;
        窗口 ck = null;
        定时器 ds1 = null;

        Game_贪吃蛇2() {
            ck = new 窗口();
            ck.setSize(5 * 2 + 830, 645 + 2 * 5 + 25);
            ck.setVisible(true);
            ds1 = new 定时器(200);
        }

        class 窗口 extends JFrame {
            菜单 cd = null;
            面板 mb = null;
            键盘监听器 jp = null;

            窗口() {
                jp = new 键盘监听器();
                this.addKeyListener(jp);
                cd = new 菜单();
                this.setJMenuBar(cd);
                mb = new 面板();
                this.add(mb);
                this.repaint();
            }

            class 菜单 extends JMenuBar {
                JMenu dan; // 菜单
                JMenuItem xiang1; // 菜单项

                菜单() {
                    dan = new JMenu("游戏"); // 菜单
                    xiang1 = new JMenuItem("开局"); // 菜单项
                    this.add(dan);
                    dan.add(xiang1);
                }
            }

            class 键盘监听器 implements KeyListener {
                // TODO:键盘处理，可加入KeyEvent.VK_XXX
                public void keyPressed(KeyEvent e) {
                    switch (e.getKeyCode()) {
                    case KeyEvent.VK_LEFT:// 左
                        if (tf != 0)
                            tf = 2;
                        break;
                    case KeyEvent.VK_RIGHT:// 右
                        if (tf != 2)
                            tf = 0;
                        break;
                    case KeyEvent.VK_UP:// 上
                        if (tf != 3)
                            tf = 1;
                        break;
                    case KeyEvent.VK_DOWN:// 下
                        if (tf != 1)
                            tf = 3;
                        break;
                    }
                    repaint();
                }

                public void keyReleased(KeyEvent e) {
                }

                public void keyTyped(KeyEvent e) {
                }
            }

            class 面板 extends JPanel {
                面板() {
                }

                public void paint(Graphics g) {
                    Image tu = (new ImageIcon("贪吃蛇/背景.PNG")).getImage();
                    g.drawImage(tu, 0, 0, null);
                    Image q1 = (new ImageIcon("贪吃蛇/豆.png")).getImage();
                    g.drawImage(q1, qx, qy, null);
                    Image ss = (new ImageIcon("贪吃蛇/身.png")).getImage();
                    for (int i = 0; i < lx.size(); i++) {
                        g.drawImage(ss, (lx.get(i)).intValue(), (ly.get(i)).intValue(), null);
                    }
                    Image st = (new ImageIcon("贪吃蛇/头" + tf + ".png")).getImage();
                    g.drawImage(st, tx, ty, null);
                    Image gameover = (new ImageIcon("贪吃蛇/gameover.png")).getImage();
                    if (death == true) {
                        g.drawImage(gameover, 150, 200, null);
                    }
                }
            }
        }

        class 定时器 implements Runnable// 实现Runnable接口
        {
            Thread xc = null;
            long jianGe;

            定时器(long jianGe) {
                this.jianGe = jianGe;
                xc = new Thread(this);
                xc.start();
            }

            public void run() {
                while (true) {
                    try {
                        xc.sleep(jianGe);
                        if (this == ds1) {
                            if (death == false) {
                                if (tf == 0) {
                                    tx += 30;
                                    if (tx == qx && ty == qy) {
                                        sts++;
                                        lx.add(0, tx - 30);
                                        ly.add(0, ty);
                                        l:while(true){
                                            boolean flag=false;
                                            qx = (((int) (Math.random() * 19)) * 30) + 10;
                                            qy = (((int) (Math.random() * 19)) * 30) + 10;
                                            for(int k=0;k<lx.size();k++){
                                                if(lx.get(k)==qx&&ly.get(k)==qy){
                                                    flag=true;
                                                }
                                            }
                                            if(tx==qx&&ty==qy){
                                                flag=true;
                                            }
                                            if(flag==false){
                                                break l;
                                            }
                                        }
                                    } else if (lx.size() > 0) {
                                        for (int i = lx.size() - 1; i > 0; i--) {
                                            lx.set(i, lx.get(i - 1));
                                        }
                                        lx.set(0, tx - 30);
                                        for (int i = ly.size() - 1; i > 0; i--) {
                                            ly.set(i, ly.get(i - 1));
                                        }
                                        ly.set(0, ty);
                                    }
                                    if (tx > 580) {
                                        death = true;
                                    }
                                    for (int i = 0; i < lx.size(); i++) {
                                        if (tx == lx.get(i) && ty == ly.get(i)) {
                                            death = true;
                                            break;
                                        }
                                    }
                                } else if (tf == 2) {
                                    tx -= 30;
                                    if (tx == qx && ty == qy) {
                                        sts++;
                                        lx.add(0, tx + 30);
                                        ly.add(0, ty);
                                        l:while(true){
                                            boolean flag=false;
                                            qx = (((int) (Math.random() * 19)) * 30) + 10;
                                            qy = (((int) (Math.random() * 19)) * 30) + 10;
                                            for(int k=0;k<lx.size();k++){
                                                if(lx.get(k)==qx&&ly.get(k)==qy){
                                                    flag=true;
                                                }
                                            }
                                            if(tx==qx&&ty==qy){
                                                flag=true;
                                            }
                                            if(flag==false){
                                                break l;
                                            }
                                        }
                                    } else if (lx.size() > 0) {
                                        for (int i = lx.size() - 1; i > 0; i--) {
                                            lx.set(i, lx.get(i - 1));
                                        }
                                        lx.set(0, tx + 30);
                                        for (int i = ly.size() - 1; i > 0; i--) {
                                            ly.set(i, ly.get(i - 1));
                                        }
                                        ly.set(0, ty);
                                    }
                                    if (tx < 10) {
                                        death = true;
                                    }
                                    for (int i = 0; i < lx.size(); i++) {
                                        if (tx == lx.get(i) && ty == ly.get(i)) {
                                            death = true;
                                            break;
                                        }
                                    }
                                } else if (tf == 1) {
                                    ty -= 30;
                                    if (tx == qx && ty == qy) {
                                        sts++;
                                        lx.add(0, tx);
                                        ly.add(0, ty + 30);
                                        l:while(true){
                                            boolean flag=false;
                                            qx = (((int) (Math.random() * 19)) * 30) + 10;
                                            qy = (((int) (Math.random() * 19)) * 30) + 10;
                                            for(int k=0;k<lx.size();k++){
                                                if(lx.get(k)==qx&&ly.get(k)==qy){
                                                    flag=true;
                                                }
                                            }
                                            if(tx==qx&&ty==qy){
                                                flag=true;
                                            }
                                            if(flag==false){
                                                break l;
                                            }
                                        }
                                    } else if (lx.size() > 0) {
                                        for (int i = lx.size() - 1; i > 0; i--) {
                                            lx.set(i, lx.get(i - 1));
                                        }
                                        lx.set(0, tx);
                                        for (int i = ly.size() - 1; i > 0; i--) {
                                            ly.set(i, ly.get(i - 1));
                                        }
                                        ly.set(0, ty + 30);
                                    }
                                    if (ty < 10) {
                                        death = true;
                                    }
                                    for (int i = 0; i < lx.size(); i++) {
                                        if (tx == lx.get(i) && ty == ly.get(i)) {
                                            death = true;
                                            break;
                                        }
                                    }
                                } else if (tf == 3) {
                                    ty += 30;
                                    if (tx == qx && ty == qy) {
                                        sts++;
                                        lx.add(0, tx);
                                        ly.add(0, ty - 30);
                                        l:while(true){
                                            boolean flag=false;
                                            qx = (((int) (Math.random() * 19)) * 30) + 10;
                                            qy = (((int) (Math.random() * 19)) * 30) + 10;
                                            for(int k=0;k<lx.size();k++){
                                                if(lx.get(k)==qx&&ly.get(k)==qy){
                                                    flag=true;
                                                }
                                            }
                                            if(tx==qx&&ty==qy){
                                                flag=true;
                                            }
                                            if(flag==false){
                                                break l;
                                            }
                                        }
                                    } else if (lx.size() > 0) {
                                        for (int i = lx.size() - 1; i > 0; i--) {
                                            lx.set(i, lx.get(i - 1));
                                        }
                                        lx.set(0, tx);
                                        for (int i = ly.size() - 1; i > 0; i--) {
                                            ly.set(i, ly.get(i - 1));
                                        }
                                        ly.set(0, ty - 30);
                                    }
                                    if (ty > 580) {
                                        death = true;
                                    }
                                    for (int i = 0; i < lx.size(); i++) {
                                        if (tx == lx.get(i) && ty == ly.get(i)) {
                                            death = true;
                                            break;
                                        }
                                    }
                                }
                            }
                            ck.repaint();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public static void main(String[] args) {
            new Game_贪吃蛇2();
        }
    }

MIDSUMMER_yy
关注
专栏目录
一个JAVA贪食蛇游戏程序源代码
10-20
JAVA基础课程学习之后完成的一个课程大作业。使用SWING完成界面，可以键盘控制贪食蛇行为
java编程小游戏
12-10
一款利用java编写的简易小游戏，将解压后的文件夹和源代码放入一个项目下即可成功运行
编写一个定时器（通过实现Runnable 接口）
ThinkPet
10-30 1496
package mythread; public class Timer implements Runnable { private Thread t; //定义一个线程 @Override public void run() { try { for (int i = 10; i &gt; 0; i--) { System.out.println( i); //...
java 简单时钟界面_简单的时钟java编程
weixin_42468240的博客
02-13 184
public class 时钟_t{//TODO:变量“声明”在此int shi = 23;int fen = 59;int miao = 55;//-------------------------窗口ck= null;定时器ds1= null;时钟_t(){//TODO:程序初始化在此//-------------------------------ck = new 窗口();//窗口 宽+2...
Java贪吃蛇小游戏
2401_83641180的博客
04-02 1006
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
JAVA贪吃蛇小游戏
weixin_53915541的博客
04-06 241
one package com.wang; /** * 枚举：枚举就是几个固定的常量 */ public enum Direction { UP,DOWN,LEFT,RIGHT } ** two ** package com.wang; import javax.swing.*; import java.awt.*; import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent; import java.util.
Java实现贪吃蛇大作战小游戏（完整版）
陈橘又青的博客
06-20 7万+
用swing技术实现编写一个贪吃蛇大作战小游戏，项目供大家参考学习交流。
java贪吃蛇小游戏（详解）
热门推荐
u011622021的博客
07-23 7万+
目录 1.实现效果： ​​2.游戏玩法 3.需求分析 4.代码实现 1.实现效果： 2.游戏玩法 该游戏用上下左右控制蛇的方向，寻找吃的东西，每吃一口就能得到一定的积分，而且蛇的身子会越吃越长，身子越长玩的难度就越大，不能碰墙，不能咬到自己的身体，更不能咬自己的尾巴，等到了一定的分数，就能过关，然后继续玩下一关。这次我们以一关的实现为例，关卡控制交给读者自行添加。 3.需求分析 ...
java贪吃蛇小游戏实现
fuzekun的博客
11-14 753
Java贪吃蛇的简单实现
java贪吃蛇小游戏程序课程设计.pdf
10-02
Java 贪吃蛇小游戏程序课程设计 Java 贪吃蛇小游戏程序课程设计是基于 Java 语言的游戏开发课程设计，旨在设计和实现一个基本的贪吃蛇小游戏程序。该课程设计的主要目标是通过游戏的设计和实现，提高学生的编程能力...
java贪吃蛇小游戏
03-30
【Java贪吃蛇小游戏】是一款基于Java编程语言开发的经典休闲娱乐项目，它不仅包含了传统贪吃蛇游戏的基本元素，还引入了寻路算法这一高级功能，使得游戏体验更加丰富和智能。下面将详细介绍这款小游戏中的核心知识点...
java贪吃蛇小游戏代码java小游戏源码.zip
06-23
【标题】：Java贪吃蛇小游戏是基于Java编程语言实现的一款经典休闲游戏，它通过源码的形式呈现，供学习者研究和改进。 【描述】：这个压缩包包含的Java源码详细展示了如何利用面向对象的设计思想，实现一个功能完整...
java贪吃蛇小游戏.zip
04-06
java贪吃蛇小游戏.zipjava贪吃蛇小游戏.zipjava贪吃蛇小游戏.zipjava贪吃蛇小游戏.zip java贪吃蛇小游戏.zipjava贪吃蛇小游戏.zipjava贪吃蛇小游戏.zipjava贪吃蛇小游戏.zip java贪吃蛇小游戏.zipjava贪吃蛇小游戏....
Java贪吃蛇小游戏.zip
12-14
Java贪吃蛇小游戏.zipJava贪吃蛇小游戏.zipJava贪吃蛇小游戏.zip Java贪吃蛇小游戏.zipJava贪吃蛇小游戏.zipJava贪吃蛇小游戏.zip Java贪吃蛇小游戏.zipJava贪吃蛇小游戏.zipJava贪吃蛇小游戏.zip Java贪吃蛇小游戏....
java-贪吃蛇小游戏
fantasyfzg的博客
11-16 2173
java GUI编程实现贪吃蛇小游戏
手把手教你做一个Java贪吃蛇小游戏
孙不坚1208
04-24 8102
做一个Java贪吃蛇小游戏的exe应用程序 大家好，我是孙不坚1208，今天给大家分享一下：如何做一个贪吃蛇小游戏的exe应用程序，希望能给需要帮助的朋友带来方便，同时也希望能得到大佬的建议。 思路： 首先你要有一条贪吃蛇，哎，就是玩儿。 1.先用Java敲一个贪吃蛇小游戏的程序。 2.把Java程序打包成jar文件包，把jar包打包成exe应用程序 知道思路以后，接下来按照我的详细步骤走，能少踩坑，别问我怎么知道的！！！ 一、Java“敲一个”贪吃蛇小游戏 废话不多说，本篇主要讲从java项目到exe应
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 529
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 405
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MIDSUMMER_yy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值