devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现大鱼吃小鱼游戏（开源）_java大鱼吃小鱼

作者：你好赵伟 | 2024-07-10 03:26:45

赞

踩

java大鱼吃小鱼

前言 ：

游戏参考于B站_【尚学堂】大鱼吃小鱼,主体框架不变，代码稍有改动。

大鱼吃小鱼：又称吞食鱼，是一款动作类小游戏。通过不断的吞吃比自己小的鱼类快速成长，最终成为海洋霸主。

游戏主要Java知识：变量、数据类型、判断语句、循环结构、类的继承、简单窗口创建、图形图片绘制、双缓存技术、鼠标事件、键盘事件。

非常适合在同学Java学习结束后，作为不错的结课作业或者练手项目。

源码已经在文章结束语后打包，有兴趣的同学可以免费下载，创作不易，点个免费的赞支持一下！

运行环境：jdk-17.05

操作方法：w,s,a,d (英文输入法)控制小鱼方向

游戏主要框架：

游戏素材：

游戏代码：

（1）Bg类

  1. import java.awt.*;
  2.  
  3. public class Bg {
  4.     void paintSelf(Graphics g, int fishLevel) {
  5.         g.drawImage(GameUtils.bgimg, 0, 0, null);
  6.         switch (GameWin.state) {
  7.             case 0:
  8.                 GameUtils.drawWord(g, "开始", Color.red, 80, 600, 400);
  9.                 break;
  10.             case 1:
  11.                 GameUtils.drawWord(g, "积分" + GameUtils.count, Color.ORANGE, 50, 200, 120);
  12.                 GameUtils.drawWord(g, "难度" + GameUtils.level, Color.ORANGE, 50, 600, 120);
  13.                 GameUtils.drawWord(g, "等级" + fishLevel, Color.ORANGE, 50, 1000, 120);
  14.                 break;
  15.             case 2:
  16.                 GameUtils.drawWord(g, "积分" + GameUtils.count, Color.ORANGE, 50, 200, 120);
  17.                 GameUtils.drawWord(g, "难度" + GameUtils.level, Color.ORANGE, 50, 600, 120);
  18.                 GameUtils.drawWord(g, "等级" + fishLevel, Color.ORANGE, 50, 1000, 120);
  19.                 GameUtils.drawWord(g, "失败", Color.red, 80, 580, 450);
  20.                 break;
  21.             case 3:
  22.                 GameUtils.drawWord(g, "积分" + GameUtils.count, Color.ORANGE, 50, 200, 120);
  23.                 GameUtils.drawWord(g, "难度" + GameUtils.level, Color.ORANGE, 50, 600, 120);
  24.                 GameUtils.drawWord(g, "等级" + fishLevel, Color.ORANGE, 50, 1000, 120);
  25.                 GameUtils.drawWord(g, "胜利了！", Color.ORANGE, 80, 580, 450);
  26.             case 4:
  27.                 break;
  28.             default:
  29.         }
  30.     }
  31. }

（2）Enamy类

  1. import java.awt.*;
  2.  
  3. //敌方鱼父类
  4. public class Enamy {
  5.     //定义图片
  6.     Image img;
  7.  
  8.     //物体坐标
  9.     int x;
  10.     int y;
  11.     int width;
  12.     int height;
  13.  
  14.     //移动速度
  15.     int speed;
  16.  
  17.     //方向
  18.     int dir = 1;
  19.  
  20.     //类型
  21.     int type;
  22.  
  23.     //分值
  24.     int count;
  25.  
  26.     //绘制自身方法
  27.     public void paintSelf(Graphics g) {
  28.         g.drawImage(img, x, y, width, height, null);
  29.     }
  30.  
  31.     //获取自身矩形，用于碰撞检测
  32.     public Rectangle getRec() {
  33.         return new Rectangle(x, y, width - 45, height - 30);
  34.     }
  35. }
  36.  
  37. //敌方鱼左类
  38. class Enamy_1_L extends Enamy {
  39.     Enamy_1_L() {
  40.         this.x = -45;
  41.         this.y = (int) (Math.random() * 980);
  42.         this.width = 40;
  43.         this.height = 55;
  44.         this.speed = 1;
  45.         this.count = 1;
  46.         this.type = 1;
  47.         this.img = GameUtils.enamyl_1img;
  48.     }
  49.  
  50.     @Override
  51.     public Rectangle getRec() {
  52.         return new Rectangle(x, y, width, height);
  53.     }
  54. }
  55.  
  56. //敌方鱼右类
  57. class Enamy_1_R extends Enamy_1_L {
  58.     Enamy_1_R() {
  59.         this.x = 1400;
  60.         dir = -1;
  61.         this.img = GameUtils.enamyr_1img;
  62.     }
  63. }
  64.  
  65. class Enamy_2_L extends Enamy {
  66.     Enamy_2_L() {
  67.         this.x = -100;
  68.         this.y = (int) (Math.random() * 900 + 100);
  69.         this.width = 180;
  70.         this.height = 80;
  71.         this.speed = 5;
  72.         this.count = 3;
  73.         this.type = 2;
  74.         this.img = GameUtils.enamyl_2img;
  75.     }
  76. }
  77.  
  78. class Enamy_2_R extends Enamy_2_L {
  79.     Enamy_2_R() {
  80.         this.x = 1400;
  81.         dir = -1;
  82.         this.img = GameUtils.enamyr_2img;
  83.     }
  84. }
  85.  
  86. class Enamy_3_L extends Enamy {
  87.     Enamy_3_L() {
  88.         this.x = -300;
  89.         this.y = (int) (Math.random() * 980);
  90.         this.width = 250;
  91.         this.height = 150;
  92.         this.speed = 3;
  93.         this.count = 10;
  94.         this.type = 3;
  95.         this.img = GameUtils.enamyl_3img;
  96.     }
  97. }
  98.  
  99. class Enamy_3_R extends Enamy_3_L {
  100.     Enamy_3_R() {
  101.         this.x = 1400;
  102.         dir = -1;
  103.         this.img = GameUtils.enamyr_3img;
  104.     }
  105. }
  106.  
  107. class Enamy_Boss extends Enamy {
  108.     Enamy_Boss() {
  109.         this.x = -1200;
  110.         this.y = (int) (Math.random() * 700 + 100);
  111.         this.width = 250;
  112.         this.height = 200;
  113.         this.speed = 80;
  114.         this.type = 10;
  115.         this.img = GameUtils.bossimg;
  116.     }
  117. }

（3）GameUtils类

  1. import java.awt.*;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4.  
  5. public class GameUtils {
  6.  
  7.     //方向
  8.     static boolean UP = false;
  9.     static boolean DOWN = false;
  10.     static boolean LEFT = false;
  11.     static boolean RIGHT = false;
  12.  
  13.     //分数
  14.     static int count = 0;
  15.  
  16.     //关卡等级
  17.     static int level = 0;
  18.  
  19.     //背景图
  20.     public static Image bgimg = Toolkit.getDefaultToolkit().createImage("src/images/sea.jpg");
  21.  
  22.     //敌方鱼类集合
  23.     public static List<Enamy> EnamyList = new ArrayList<>();
  24.  
  25.     //敌方鱼类
  26.     public static Image enamyl_1img = Toolkit.getDefaultToolkit().createImage("src/images/enemyFish/fish1_r.gif");
  27.     public static Image enamyr_1img = Toolkit.getDefaultToolkit().createImage("src/images/enemyFish/fish1_l.gif");
  28.     public static Image enamyl_2img = Toolkit.getDefaultToolkit().createImage("src/images/enemyFish/fish2_r.png");
  29.     public static Image enamyr_2img = Toolkit.getDefaultToolkit().createImage("src/images/enemyFish/fish2_l.png");
  30.     public static Image enamyl_3img = Toolkit.getDefaultToolkit().createImage("src/images/enemyFish/fish3_r.gif");
  31.     public static Image enamyr_3img = Toolkit.getDefaultToolkit().createImage("src/images/enemyFish/fish3_l.gif");
  32.     public static Image bossimg = Toolkit.getDefaultToolkit().createImage("src/images/enemyFish/boss.gif");
  33.  
  34.     //我方鱼类
  35.     public static Image MyFishimg_L = Toolkit.getDefaultToolkit().createImage("src/images/myFish/myfish_left.gif");
  36.     public static Image MyFishimg_R = Toolkit.getDefaultToolkit().createImage("src/images/myFish/myfish_right.gif");
  37.  
  38.     //绘制文字的工具类
  39.     public static void drawWord(Graphics g, String str, Color color, int size, int x, int y) {
  40.         g.setColor(color);
  41.         g.setFont(new Font("宋体", Font.BOLD, size));
  42.         g.drawString(str, x, y);
  43.     }
  44. }

（4）GameWin类

  1. package com.mzy;
  2.  
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.event.KeyAdapter;
  6. import java.awt.event.KeyEvent;
  7. import java.awt.event.MouseAdapter;
  8. import java.awt.event.MouseEvent;
  9.  
  10. public class GameWin extends JFrame {
  11.  
  12.     /**
  13.      * 游戏状态 0未开始,1游戏中,2通关失败,3通关成功,4暂停,5重新开始
  14.      */
  15.  
  16.     //定义游戏默认状态
  17.     static int state = 0;
  18.  
  19.     //双缓存图片
  20.     Image offScreenImage;
  21.  
  22.     //窗口宽高
  23.     int width = 1320;
  24.     int height = 780;
  25.  
  26.     //计数器
  27.     double random;
  28.     int time = 0;
  29.  
  30.     //背景对象
  31.     Bg bg = new Bg();
  32.  
  33.     //敌方鱼类
  34.     Enamy enamy = new Enamy_1_L();
  35.  
  36.     //我方鱼类
  37.     MyFish myFish = new MyFish();
  38.  
  39.     //boss鱼类
  40.     Enamy boss;
  41.  
  42.     //是否生成boss
  43.     boolean isboss = false;
  44.  
  45.     /**
  46.      * 游戏操作方法
  47.      */
  48.     public void launch() {
  49.  
  50.         Music audioPlayWave = new Music("src/皇家萌卫.wav");
  51.         audioPlayWave.start();
  52.         @SuppressWarnings("unused")
  53.         int musicOpenLab = 1;
  54.  
  55.         //界面布局
  56.         this.setVisible(true);
  57.         this.setSize(width, height);
  58.         this.setLocationRelativeTo(null);
  59.         this.setTitle("大鱼吃小鱼");
  60.         this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  61.  
  62.         //开始或者失败后重新游戏
  63.         this.addMouseListener(new MouseAdapter() {
  64.             @Override
  65.             public void mouseClicked(MouseEvent e) {
  66.                 super.mouseClicked(e);
  67.                 if (e.getButton() == 1 && state == 0) {
  68.                     state = 1;
  69.                     repaint();
  70.                 }
  71.                 if (e.getButton() == 1 && (state == 2 || state == 3)) {
  72.                     reGame();
  73.                     state = 1;
  74.                 }
  75.             }
  76.         });
  77.  
  78.         //键盘移动我方鱼类
  79.         this.addKeyListener(new KeyAdapter() {
  80.             @Override //按压
  81.             public void keyPressed(KeyEvent e) {
  82.                 super.keyPressed(e);
  83.                 if (e.getKeyCode() == 87) {
  84.                     GameUtils.UP = true;
  85.                 }
  86.                 if (e.getKeyCode() == 83) {
  87.                     GameUtils.DOWN = true;
  88.                 }
  89.                 if (e.getKeyCode() == 65) {
  90.                     GameUtils.LEFT = true;
  91.                 }
  92.                 if (e.getKeyCode() == 68) {
  93.                     GameUtils.RIGHT = true;
  94.                 }
  95.                 if (e.getKeyCode() == 32) {
  96.                     switch (state) {
  97.                         case 1:
  98.                             state = 4;
  99.                             GameUtils.drawWord(getGraphics(), "游戏暂停！", Color.red, 50, 580, 450);
  100.                             break;
  101.                         case 4:
  102.                             state = 1;
  103.                             break;
  104.                     }
  105.                 }
  106.             }
  107.  
  108.             @Override //抬起
  109.             public void keyReleased(KeyEvent e) {
  110.                 if (e.getKeyCode() == 87) {
  111.                     GameUtils.UP = false;
  112.                 }
  113.                 if (e.getKeyCode() == 83) {
  114.                     GameUtils.DOWN = false;
  115.                 }
  116.                 if (e.getKeyCode() == 65) {
  117.                     GameUtils.LEFT = false;
  118.                 }
  119.                 if (e.getKeyCode() == 68) {
  120.                     GameUtils.RIGHT = false;
  121.                 }
  122.             }
  123.         });
  124.  
  125.         //线程操纵游戏帧率
  126.         while (true) {
  127.             repaint();
  128.             time++;
  129.             try {
  130.                 Thread.sleep(40);
  131.             } catch (InterruptedException e) {
  132.                 e.printStackTrace();
  133.             }
  134.         }
  135.  
  136.     }
  137.  
  138.     /**
  139.      * 游戏阶段绘制鱼类
  140.      */
  141.     @Override
  142.     public void paint(Graphics g) {
  143.         //双缓存加载图片
  144.         offScreenImage = createImage(width, height);
  145.         Graphics gImage = offScreenImage.getGraphics();
  146.         bg.paintSelf(gImage, myFish.level);
  147.  
  148.         switch (state) {
  149.             case 0:
  150.                 break;
  151.             case 1:
  152.                 myFish.paintSelf(gImage);
  153.                 logic();
  154.                 for (Enamy enamy : GameUtils.EnamyList) {
  155.                     enamy.paintSelf(gImage);
  156.                 }
  157.                 if (isboss) {
  158.                     boss.x = boss.x + boss.dir * boss.speed;
  159.                     boss.paintSelf(gImage);
  160.                     if (boss.x < 0) {
  161.                         gImage.setColor(Color.red);
  162.                         gImage.fillRect(boss.x, boss.y + 100, 2400, boss.height / 20);
  163.                     }
  164.                 }
  165.                 break;
  166.             case 2:
  167.                 for (Enamy enamy : GameUtils.EnamyList) {
  168.                     enamy.paintSelf(gImage);
  169.                 }
  170.                 if (isboss) {
  171.                     boss.paintSelf(gImage);
  172.                 }
  173.                 break;
  174.             case 3:
  175.                 myFish.paintSelf(gImage);
  176.                 break;
  177.             case 4:
  178.                 return;
  179.             default:
  180.         }
  181.         g.drawImage(offScreenImage, 0, 0, null);
  182.     }
  183.  
  184.     /**
  185.      * 游戏关卡难度逻辑
  186.      */
  187.     void logic() {
  188.         //关卡难度
  189.         if (GameUtils.count < 5) {
  190.             GameUtils.level = 0;
  191.         } else if (GameUtils.count < 15) {
  192.             GameUtils.level = 1;
  193.         } else if (GameUtils.count < 40) {
  194.             GameUtils.level = 2;
  195.         } else if (GameUtils.count < 75) {
  196.             GameUtils.level = 3;
  197.         } else if (GameUtils.count > 150) {
  198.             state = 3;
  199.         }
  200.  
  201.         //我方鱼升级
  202.         if (29 < GameUtils.count && GameUtils.count < 79) {
  203.             myFish.level = 2;
  204.         } else if (GameUtils.count > 79) {
  205.             myFish.level = 3;
  206.         }
  207.  
  208.         //阶段生成敌方鱼
  209.         random = Math.random();
  210.         switch (GameUtils.level) {
  211.             case 3:
  212.                 if (time % 120 == 0) {
  213.                     boss = new Enamy_Boss();
  214.                     isboss = true;
  215.                 }
  216.             case 2:
  217.                 if (time % 120 == 0) {
  218.                     if (random < 0.5) {
  219.                         enamy = new Enamy_3_L();
  220.                     } else {
  221.                         enamy = new Enamy_3_R();
  222.                     }
  223.                 }
  224.                 GameUtils.EnamyList.add(enamy);
  225.             case 1:
  226.                 if (time % 60 == 0) {
  227.                     if (random < 0.5) {
  228.                         enamy = new Enamy_2_L();
  229.                     } else {
  230.                         enamy = new Enamy_2_R();
  231.                     }
  232.                 }
  233.                 GameUtils.EnamyList.add(enamy);
  234.             case 0:
  235.                 if (time % 10 == 0) {
  236.                     if (random < 0.5) {
  237.                         enamy = new Enamy_1_L();
  238.                     } else {
  239.                         enamy = new Enamy_1_R();
  240.                     }
  241.                 }
  242.                 GameUtils.EnamyList.add(enamy);
  243.                 break;
  244.             default:
  245.         }
  246.  
  247.         //生成敌方鱼
  248.         for (Enamy enamy : GameUtils.EnamyList) {
  249.             enamy.x = enamy.x + enamy.dir * enamy.speed;
  250.  
  251.             //boss鱼碰撞检测
  252.             if (isboss) {
  253.                 if (boss.getRec().intersects(enamy.getRec())) {
  254.                     enamy.x = -200;
  255.                     enamy.y = -200;
  256.                 }
  257.                 if (boss.getRec().intersects(myFish.getRec())) {
  258.                     state = 2;
  259.                 }
  260.             }
  261.  
  262.             //我方鱼与敌方鱼碰撞检测
  263.             if (myFish.getRec().intersects(enamy.getRec())) {
  264.                 if (myFish.level >= enamy.type) {
  265.                     enamy.x = -200;
  266.                     enamy.y = -200;
  267.                     GameUtils.count += enamy.count;
  268.                 } else {
  269.                     state = 2;
  270.                 }
  271.             }
  272.         }
  273.     }
  274.  
  275.     public static void main(String[] args) {
  276.         GameWin gameWin = new GameWin();
  277.         gameWin.launch();
  278.  
  279.  
  280.     }
  281.  
  282.     //重新开始
  283.     void reGame() {
  284.         GameUtils.EnamyList.clear();
  285.         time = 0;
  286.         myFish.level = 1;
  287.         GameUtils.count = 0;
  288.         myFish.x = 650;
  289.         myFish.y = 400;
  290.         myFish.width = 45;
  291.         myFish.height = 45;
  292.         boss = null;
  293.         isboss = false;
  294.     }
  295.  
  296. }

（5）Music类

  1. package com.mzy;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5.  
  6. import javax.sound.sampled.AudioFormat;
  7. import javax.sound.sampled.AudioInputStream;
  8. import javax.sound.sampled.AudioSystem;
  9. import javax.sound.sampled.DataLine;
  10. import javax.sound.sampled.FloatControl;
  11. import javax.sound.sampled.LineUnavailableException;
  12. import javax.sound.sampled.SourceDataLine;
  13. import javax.sound.sampled.UnsupportedAudioFileException;
  14.  
  15. public class Music extends Thread {
  16.     private String fileName;
  17.     private final int EXTERNAL_BUFFER_SIZE = 524288;
  18.  
  19.     public Music(String wavFile) {
  20.         this.fileName = wavFile;
  21.     }
  22.  
  23.     @SuppressWarnings("unused")
  24.     public void run() {
  25.         System.out.println("音乐播放");
  26.         File soundFile = new File(fileName); // 播放音乐的文件名
  27.         if (!soundFile.exists()) {
  28.             System.err.println("Wave file not found:" + fileName);
  29.             return;
  30.         }
  31.         while (true) { // 设置循环播放
  32.             AudioInputStream audioInputStream = null; // 创建音频输入流对象
  33.             try {
  34.                 audioInputStream = AudioSystem.getAudioInputStream(soundFile); // 创建音频对象
  35.             } catch (UnsupportedAudioFileException e1) {
  36.                 e1.printStackTrace();
  37.                 return;
  38.             } catch (IOException e1) {
  39.                 e1.printStackTrace();
  40.                 return;
  41.             }
  42.             AudioFormat format = audioInputStream.getFormat(); // 音频格式
  43.             SourceDataLine auline = null; // 源数据线
  44.             DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
  45.             try {
  46.                 auline = (SourceDataLine) AudioSystem.getLine(info);
  47.                 auline.open(format);
  48.             } catch (LineUnavailableException e) {
  49.                 e.printStackTrace();
  50.                 return;
  51.             } catch (Exception e) {
  52.                 e.printStackTrace();
  53.                 return;
  54.             }
  55.             if (auline.isControlSupported(FloatControl.Type.PAN)) {
  56.                 FloatControl pan = (FloatControl) auline.getControl(FloatControl.Type.PAN);
  57.             }
  58.             auline.start();
  59.             int nBytesRead = 0;
  60.             byte[] abData = new byte[EXTERNAL_BUFFER_SIZE];
  61.             try {
  62.                 while (nBytesRead != -1) {
  63.                     nBytesRead = audioInputStream.read(abData, 0, abData.length);
  64.                     if (nBytesRead >= 0)
  65.                         auline.write(abData, 0, nBytesRead);
  66.                 }
  67.             } catch (IOException e) {
  68.                 e.printStackTrace();
  69.                 return;
  70.             } finally {
  71.                 auline.drain();
  72. // auline.close();
  73.             }
  74.         }
  75.     }
  76. }

（6）MyFish类

  1. import java.awt.*;
  2.  
  3. public class MyFish {
  4.     //图片
  5.     Image img = GameUtils.MyFishimg_L;
  6.  
  7.     //坐标
  8.     int x = 650;
  9.     int y = 400;
  10.     int width = 45;
  11.     int height = 45;
  12.  
  13.     //移动速度
  14.     int speed = 20;
  15.  
  16.     //等级
  17.     int level = 1;
  18.  
  19.     //移动
  20.     void logic() {
  21.         if (GameUtils.UP) {
  22.             y = y - speed;
  23.         }
  24.         if (GameUtils.DOWN) {
  25.             y = y + speed;
  26.         }
  27.         if (GameUtils.LEFT) {
  28.             x = x - speed;
  29.             img = GameUtils.MyFishimg_L;
  30.         }
  31.         if (GameUtils.RIGHT) {
  32.             x = x + speed;
  33.             img = GameUtils.MyFishimg_R;
  34.         }
  35.     }
  36.  
  37.     //绘制自身方法
  38.     public void paintSelf(Graphics g) {
  39.         logic();
  40.         g.drawImage(img, x, y, width + GameUtils.count, height + GameUtils.count, null);
  41.     }
  42.  
  43.     //获取自身矩形方法，用于碰撞检测
  44.     public Rectangle getRec() {
  45.         return new Rectangle(x, y, width + GameUtils.count, height + GameUtils.count);
  46.     }
  47. }

结束语：

游戏还有很多缺陷地方，比如我方鱼可以离开界面，敌方鱼在离开界面后没有及时清除，游戏玩法过于简单。都需要小伙伴们自己去改进，挖掘。

游戏源码下载解压后，注意打开项目的文件夹位置，出现报错，游戏界面白屏等问题，都可以私信帮忙解决。

源码：

链接：https://pan.baidu.com/s/1QyuhE1KaM_RupqLpUkr1JA 
提取码：2czk

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/804633
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号