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

Java小游戏练习---超级玛丽代码实现_超级玛丽java游戏代码

作者：AllinToyou | 2024-03-09 17:12:56

赞

踩

超级玛丽java游戏代码

B站教学视频：

01_超级玛丽_创建窗口_哔哩哔哩_bilibili

素材提取：

【超级会员V2】我通过百度网盘分享的文件：Java游戏项目…
链接:百度网盘 请输入提取码
提取码:k6j1
复制这段内容打开「百度网盘APP 即可获取」
百度网盘 请输入提取码
百度网盘为您提供文件的网络备份、同步和分享服务。空间大、速度快、安全稳固，支持教育网加速，支持手机端。注册使用百度网盘即可享受免费存储空间
 

百度网盘 请输入提取码

百度网盘为您提供文件的网络备份、同步和分享服务。空间大、速度快、安全稳固，支持教育网加速，支持手机端。注册使用百度网盘即可享受免费存储空间

 

游戏构造思路：

首先需要创建一个窗口，游戏需要在该窗口中运行，其次我们需要添加游戏中要用到的图片，将其添加到一个专属包中，并在类中实现。（有些物品一样或只用一次，如旗杆，城堡等，普通添加即可；有些如：玛丽，蘑菇敌人等，需要移动以及其他动作，故需要创建列表方便实现不同图片来回使用）。此外，我们还需要给游戏添加背景图，设定游戏的关卡数，以及不同关卡之间的切换。

在以上基础步骤之后，就需要在场景中添加游戏中最关键的两个角色：玛丽和敌人，这两个角色需要运动以及一系列其他操作，因此我们需要分两个类来写，并通过线程来调用。

以下代码中额外添加了一个休眠用来进行判定，在运行之后如果在较长时间（5秒左右）后按下空格键，则敌人类将不会再运动，同时，若在运行开始后，立即按下空格，敌人类会在经历一小段休眠后再进行运动（因为添加了休眠，故经过一小段休眠后才会进行判断）

以上休眠的添加是因为在添加暂停功能时本人无法实现暂停功能而写的一个妥协方案，欢迎各位大佬在评论区提出有关添加暂停功能的方法

代码实现：

 MyFrame类：

  1. package com.sxt;
  2.  
  3. import javazoom.jl.decoder.JavaLayerException;
  4.  
  5. import javax.swing.*;
  6. import java.awt.*;
  7. import java.awt.event.KeyEvent;
  8. import java.awt.event.KeyListener;
  9. import java.io.FileNotFoundException;
  10. import java.util.ArrayList;
  11. import java.util.List;
  12.  
  13. import static java.lang.Thread.sleep;
  14.  
  15. //创建窗口需要继承JFrame类,
  16. //添加键盘监听，需要该类实现KeyListener接口，并重写其中抽象方法
  17. public class MyFrame extends JFrame implements KeyListener,Runnable {
  18.     //用于储存所有的背景,定义一个列表用于存储背景
  19.     private List<BackGround> allBg = new ArrayList<>();
  20.     //用于储存当前背景 , 用于记录当前场景
  21.     private BackGround nowBg = new BackGround();
  22.     //用于双缓存,创建了一个变量
  23.     private Image offScreenImage = null;
  24.     //马里奥对象
  25.     private Mario mario = new Mario();
  26.     //定义线程对象用于实现马里奥的运动
  27.     private Thread thread = new Thread(this);
  28.     static boolean isStart = false;
  29.  
  30.  
  31.     //创建该类的空参构造
  32.     public MyFrame() {
  33.         //设置窗口大小
  34.         this.setSize(800, 600);
  35.         //设置窗口居中显示
  36.         this.setLocationRelativeTo(null);
  37.         //设置窗口可见性
  38.         this.setVisible(true);
  39.         //设置窗口关闭键
  40.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  41.         //设置窗口大小不可变
  42.         this.setResizable(false);
  43.         //给窗口对象添加键盘监听
  44.         this.addKeyListener(this);
  45.         //设置窗口名称
  46.         this.setTitle("超级马里奥");
  47.         //初始化图片
  48.         StaticValue.init();
  49.         //初始化马里奥
  50.         mario = new Mario(10, 355);
  51.         //创建全部的场景,一共有三个场景，因此需要用for循环来创建
  52.         for (int i = 1; i <= 3; i++) {
  53.             //要传入两个参数:当前关卡数i和是否为最后一关的布尔变量
  54.             //要用三目运算符进行判断，判断这时的i是否是第三关
  55.             allBg.add(new BackGround(i, i == 3 ? true : false));
  56.         }
  57.         //将第一个背景设置为当前场景
  58.         nowBg = allBg.get(0);
  59.         mario.setBackGround(nowBg);
  60.         //绘制图像
  61.         repaint();
  62.         //启动线程并调用start方法
  63.         thread.start();//绘制图像开始时同步播放音乐
  64.         try {
  65.             new Music();
  66.         } catch (FileNotFoundException e) {
  67.             e.printStackTrace();
  68.         } catch (JavaLayerException e) {
  69.             e.printStackTrace();
  70.         }
  71.     }
  72.     //重写一下paint方法
  73.  
  74.     @Override
  75.     public void paint(Graphics g) {
  76.         //首先要判断，判断变量是否为null
  77.         if (offScreenImage == null) {
  78.             offScreenImage = createImage(800, 600);
  79.         }
  80.         //定义Graphics(画笔)对象
  81.         Graphics graphics = offScreenImage.getGraphics();
  82.         //调用graphics的fillRect方法对我们的图像进行填充
  83.         graphics.fillRect(0, 0, 800, 600);
  84.         //绘制背景，调用graphics的drawImage方法，将当前背景图像进行绘画
  85.         //此时是将图像绘制到了缓冲区上
  86.         graphics.drawImage(nowBg.getBgImage(), 0, 0, this);
  87.  
  88.         //绘制敌人
  89.         for (Enemy e : nowBg.getEnemyList()) {
  90.             graphics.drawImage(e.getShow(), e.getX(), e.getY(), this);
  91.         }
  92.  
  93.         //绘制障碍物
  94.         for (Obstacle ob : nowBg.getObstacleList()) {
  95.             graphics.drawImage(ob.getShow(), ob.getX(), ob.getY(), this);
  96.         }
  97.         //绘制城堡
  98.         graphics.drawImage(nowBg.getTower(), 620, 270, this);
  99.         //绘制旗杆
  100.         graphics.drawImage(nowBg.getGan(), 500, 220, this);
  101.         //绘制马里奥
  102.         graphics.drawImage(mario.getShow(), mario.getX(), mario.getY(), this);
  103.         //添加分数
  104.         Color c = graphics.getColor();
  105.         graphics.setColor(Color.BLACK);
  106.         graphics.setFont(new Font("黑体", Font.BOLD, 25));
  107.         graphics.drawString("当前分数为:" + mario.getScore(), 300, 100);
  108.         if (isStart == false) {
  109.             graphics.setFont(new Font("宋体", Font.BOLD, 25));
  110.             graphics.drawString("按下空格开始游戏", 270, 160);
  111.         }
  112.  
  113.         //还原画笔颜色
  114.         graphics.setColor(c);
  115.  
  116.         //接下来将缓冲区的图片绘制到窗口中，调用g.drawImage方法
  117.         g.drawImage(offScreenImage, 0, 0, this);
  118.     }
  119.  
  120.     public static void main(String[] args) {
  121.         MyFrame myFrame = new MyFrame();
  122.     }
  123.  
  124.  
  125.     @Override
  126.     public void keyTyped(KeyEvent e) {
  127.  
  128.     }
  129.  
  130.     //当键盘按下按键时调用
  131.     @Override
  132.     public void keyPressed(KeyEvent e) {
  133.  
  134.         if (isStart == false) {
  135.             if (e.getKeyCode() == 32) {
  136.                 isStart = true;
  137.             }
  138.         } else {
  139.             //向右移动
  140.             if (e.getKeyCode() == 39) {
  141.                 mario.rightMove();
  142.             }
  143.             //向左移动
  144.             if (e.getKeyCode() == 37) {
  145.                 mario.leftMove();
  146.             }
  147.             //跳跃
  148.             if (e.getKeyCode() == 38) {
  149.                 mario.jump();
  150.             }
  151.         }
  152.         }
  153.         //当键盘松开按键时调用
  154.         @Override
  155.         public void keyReleased (KeyEvent e) {
  156.             //向左停止
  157.             if (isStart == true) {
  158.                 if (e.getKeyCode() == 37) {
  159.                     mario.leftStop();
  160.                 }
  161.                 //向右停止
  162.                 if (e.getKeyCode() == 39) {
  163.                     mario.rightStop();
  164.                     //接下来让MyFrame类来实现Runnable接口并且重写抽象方法
  165.                 }
  166.             }
  167.         }
  168.  
  169.         @Override
  170.         public void run () {
  171.             //写一个死循环，在循环里调用repaint()方法,用于重新绘制我们的图像
  172.             while (true) {
  173.                 repaint();
  174.                 //让线程休眠
  175.                 try {
  176.                     sleep(50);
  177.                     //判断此时马里奥是否移动到了最右端，是的话则要进行场景的切换
  178.                     //当前窗口大小为800，马里奥宽度为25
  179.                     if (mario.getX() >= 775) {
  180.                         //满足就要切换当前场景，在这里可以调用now的sort，他表示第几关，索引为1和2
  181.                         nowBg = allBg.get(nowBg.getSort());
  182.                         //将当前场景对象传递给马里奥类
  183.                         mario.setBackGround(nowBg);
  184.                         mario.setX(10);
  185.                         mario.setY(355);
  186.                     }
  187.                     //判断马里奥是否死亡
  188.                     if (mario.isDeath()) {
  189.                         JOptionPane.showMessageDialog(this, "马里奥死亡，游戏失败");
  190.                         System.exit(0);
  191.                     }
  192.                     //判断游戏是否结束,即判断mario的isOK是否为true,若true则游戏结束
  193.                     if (mario.isOK()) {
  194.                         JOptionPane.showMessageDialog(this, "恭喜你！通关了");
  195.                         System.exit(0);
  196.                     }
  197.                 } catch (InterruptedException e) {
  198.                     e.printStackTrace();
  199.                 }
  200.             }
  201.         }
  202.     }

BackGround类：

  1. package com.sxt;
  2.  
  3. import java.awt.image.BufferedImage;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6.  
  7. public class BackGround {
  8.     //当前场景要实现的图像，该对象用于显示当前场景的图片,赋初值为null
  9.     private BufferedImage bgImage=null; //在bgImage上设置getter方法
  10.     //记录当前是第几个场景,储存当前是第几关
  11.     private int sort;
  12.     //判断是否是最后一个场景
  13.     private boolean flag;
  14.     //创建一个列表用于存放所有的障碍物
  15.     private List<Obstacle>obstacleList=new ArrayList<>();
  16.     //用于存放所有敌人
  17.     private List<Enemy>enemyList=new ArrayList<>();
  18.     //用于显示旗杆
  19.     private BufferedImage gan=null;
  20.     //用于显示城堡
  21.     private BufferedImage tower=null;
  22.     //判断马里奥是否到达旗杆位置
  23.     private boolean isReach=false;
  24.     //判断旗子是否落地
  25.     private boolean isBase=false;
  26.     //创建空参构造
  27.     public BackGround(){
  28.     }
  29.     public BackGround(int sort,boolean flag){
  30.         this.sort=sort;
  31.         this.flag=flag;
  32.  
  33.         if (flag){
  34.             bgImage=StaticValue.bg2;     //旗帜——最后一关背景
  35.         }else{
  36.             bgImage=StaticValue.bg;     //第一关和第二关背景
  37.             //下一步生成getter方法
  38.         }
  39.         //判断是否为第一关
  40.         if (sort==1){
  41.             //绘制第一关的地面，上地面type=1,下地面type=2，
  42.             // 窗口横坐标为800，一个地面为30
  43.             for (int i=0;i<27;i++){
  44.                 obstacleList.add(new Obstacle(i*30,420,1,this));
  45.             }
  46.             for (int j=0;j<=120;j+=30){
  47.                 for (int i=0;i<27;i++){
  48.                     obstacleList.add(new Obstacle(i*30,570-j,2,this));
  49.                 }
  50.             }
  51.             //绘制砖块A
  52.             for (int i=120;i<=150;i+=30){
  53.                  obstacleList.add(new Obstacle(i,300,7,this));
  54.                  //括号里是:横坐标，纵坐标，类型，this这个背景。
  55.             }
  56.             //绘制砖块B~~F
  57.             for(int i=300;i<=570;i+=30){
  58.                 if (i==360||i==390||i==480||i==510||i==540) {
  59.                     obstacleList.add(new Obstacle(i,300,7,this));
  60.                 }else {
  61.                     obstacleList.add(new Obstacle(i,300,0,this));
  62.                 }
  63.             }
  64.             //绘制砖块G
  65.             for(int i=420;i<=450;i+=30){
  66.                 obstacleList.add(new Obstacle(i,240,7,this));
  67.             }
  68.             //绘制水管
  69.             for (int i=360;i<=600;i+=25){
  70.                 if (i==360){
  71.                     obstacleList.add(new Obstacle(620,i,3,this));
  72.                     obstacleList.add(new Obstacle(645,i,4,this));
  73.                 }else{
  74.                     obstacleList.add(new Obstacle(620,i,5,this));
  75.                     obstacleList.add(new Obstacle(645,i,6,this));
  76.                     //接下来实现Obstacle列表的getter方法
  77.                 }
  78.             }
  79.             //绘制第一关的蘑菇敌人
  80.             enemyList.add(new Enemy(580,385,true,1,this));
  81.             enemyList.add(new Enemy(300,385,true,1,this));
  82.             enemyList.add(new Enemy(100,385,true,1,this));
  83.             enemyList.add(new Enemy(400,385,true,1,this));
  84.             enemyList.add(new Enemy(400,265,true,1,this));
  85.             //绘制第一关的食人花敌人
  86.             enemyList.add(new Enemy(635,420,true,2,328,428,this));
  87.         }
  88.         //判断是否为第二关
  89.         if(sort==2){
  90.             //直接复制第一关的，三关的地砖一样
  91.             //绘制第二关的地面，上地面type=1,下地面type=2，
  92.             // 窗口横坐标为800，一个地面为30
  93.             for (int i=0;i<27;i++){
  94.                 obstacleList.add(new Obstacle(i*30,420,1,this));
  95.             }
  96.             for (int j=0;j<=120;j+=30){
  97.                 for (int i=0;i<27;i++){
  98.                     obstacleList.add(new Obstacle(i*30,570-j,2,this));
  99.                 }
  100.             }
  101.             //绘制第一个水管，复制第一关的过来改一下坐标即可
  102.             for (int i=360;i<=600;i+=25) {
  103.                 if (i == 360) {
  104.                     obstacleList.add(new Obstacle(60, i, 3, this));
  105.                     obstacleList.add(new Obstacle(85, i, 4, this));
  106.                 } else {
  107.                     obstacleList.add(new Obstacle(60, i, 5, this));
  108.                     obstacleList.add(new Obstacle(85, i, 6, this));
  109.                 }
  110.             }
  111.             //第二根水管
  112.             for (int i=330;i<=600;i+=25) {
  113.                 if (i == 330) {
  114.                     obstacleList.add(new Obstacle(620, i, 3, this));
  115.                     obstacleList.add(new Obstacle(645, i, 4, this));
  116.                 } else {
  117.                     obstacleList.add(new Obstacle(620, i, 5, this));
  118.                     obstacleList.add(new Obstacle(645, i, 6, this));
  119.                 }
  120.             }
  121.             //绘制砖块C
  122.             obstacleList.add(new Obstacle(300,330,0,this));
  123.             //绘制砖块B,E,G
  124.             for (int i=270;i<=330;i+=30){
  125.                 if (i==270||i==330){
  126.                     obstacleList.add(new Obstacle(i,360,0,this));
  127.                 }else{
  128.                     obstacleList.add(new Obstacle(i,360,7,this));
  129.                 }
  130.             }
  131.             //绘制砖块A,D,F,H,I
  132.             for (int i=240;i<=360;i+=30){
  133.                 if (i==240||i==360){
  134.                     obstacleList.add(new Obstacle(i,390,0,this));
  135.                 }else{
  136.                     obstacleList.add(new Obstacle(i,390,7,this));
  137.                 }
  138.             }
  139.             //绘制妨碍1砖块
  140.             obstacleList.add(new Obstacle(240,300,0,this));
  141.  
  142.             //绘制空1~4砖块
  143.             for (int i=360;i<=540;i+=60){
  144.                 obstacleList.add(new Obstacle(i,270,7,this));
  145.             }
  146.             //绘制第二关的第一个蘑菇敌人
  147.             enemyList.add(new Enemy(200,385,true,1,this));
  148.             //绘制第二个蘑菇敌人
  149.             enemyList.add(new Enemy(500,385,true,1,this));
  150.             //第三个
  151.             enemyList.add(new Enemy(400,205,true,1,this));
  152.             //绘制第二关第一个食人花敌人
  153.             enemyList.add(new Enemy(75,420,true,2,328,418,this));
  154.             //绘制第二个食人花敌人
  155.             enemyList.add(new Enemy(635,420,true,2,298,388,this));
  156.         }
  157.         //判断是否为第三关
  158.         if (sort==3) {
  159.             //绘制地面
  160.             //绘制第三关的地面，上地面type=1,下地面type=2，
  161.             // 窗口横坐标为800，一个地面为30
  162.             for (int i = 0; i < 27; i++) {
  163.                 obstacleList.add(new Obstacle(i * 30, 420, 1, this));
  164.             }
  165.             for (int j = 0; j <= 120; j += 30) {
  166.                 for (int i = 0; i < 27; i++) {
  167.                     obstacleList.add(new Obstacle(i * 30, 570 - j, 2, this));
  168.                 }
  169.             }
  170.             //绘制第三个背景的A~O砖块
  171.             int temp=290;
  172.             for (int i=390;i>=270;i-=30){
  173.                 for (int j=temp;j<=410;j+=30){
  174.                     obstacleList.add(new Obstacle(j,i,7,this));
  175.                 }
  176.                 temp+=30;
  177.             }
  178.             //绘制第三个背景的P~R砖块
  179.             temp=60;
  180.             for (int i=390;i>=360;i-=30){
  181.                 for (int j=temp;j<=90;j+=30){
  182.                     obstacleList.add(new Obstacle(j,i,7,this));
  183.                 }
  184.                 temp+=30;
  185.             }
  186.             //绘制旗杆
  187.             gan=StaticValue.gan;
  188.             //绘制城堡
  189.             tower=StaticValue.tower;
  190.             //添加旗子到旗杆上
  191.             obstacleList.add(new Obstacle(515,220,8,this));
  192.             //接下来生成旗杆和城堡的getter方法
  193.  
  194.             //绘制第三关蘑菇敌人
  195.             enemyList.add(new Enemy(150,385,true,1,this));
  196.         }
  197.  
  198.     }
  199.  
  200.     public BufferedImage getBgImage() {
  201.         return bgImage;
  202.     }
  203.  
  204.     public int getSort() {
  205.         return sort;
  206.     }
  207.  
  208.     public boolean isFlag() {
  209.         return flag;
  210.     }
  211.     public List<Obstacle> getObstacleList() {
  212.         return obstacleList;
  213.     }
  214.  
  215.     public BufferedImage getGan() {
  216.         return gan;
  217.     }
  218.  
  219.     public BufferedImage getTower() {
  220.         return tower;
  221.     }
  222.  
  223.     public boolean isReach() {
  224.         return isReach;
  225.     }
  226.  
  227.     public void setReach(boolean reach) {
  228.         isReach = reach;
  229.     }
  230.  
  231.     public boolean isBase() {
  232.         return isBase;
  233.     }
  234.  
  235.     public void setBase(boolean base) {
  236.         isBase = base;
  237.     }
  238.  
  239.     public List<Enemy> getEnemyList() {
  240.         return enemyList;
  241.     }
  242. }

加载图片的StaticValue类：

  1. package com.sxt;
  2.  
  3. import javax.imageio.ImageIO;
  4. import java.awt.image.BufferedImage;
  5. import java.io.File;
  6. import java.io.IOException;
  7. import java.nio.Buffer;
  8. import java.util.ArrayList;
  9. import java.util.List;
  10.  
  11. //常量类
  12. public class StaticValue {
  13.     //定义需要用到的变量
  14.     //背景
  15.     public static BufferedImage bg=null;  //前两个场景
  16.     public static BufferedImage bg2=null;  //第三关场景
  17.     //马里奥向左跳跃
  18.     public static BufferedImage jump_L=null;
  19.     //马里奥向右跳跃
  20.     public static BufferedImage Jump_R=null;
  21.     //马里奥向左站立
  22.     public static BufferedImage stand_L=null;
  23.     //马里奥向右站立
  24.     public static BufferedImage stand_R=null;
  25.     //城堡
  26.     public static BufferedImage tower=null;
  27.     //旗杆
  28.     public static BufferedImage gan=null;
  29.     //障碍物，较多，需要列表
  30.     public static List<BufferedImage> obstacle=new ArrayList<>();
  31.     //马里奥向左跑
  32.     public static List<BufferedImage> run_L=new ArrayList<>();
  33.     //马里奥向右跑
  34.     public static List<BufferedImage> run_R=new ArrayList<>();
  35.     //蘑菇敌人
  36.     public static List<BufferedImage> mogu=new ArrayList<>();
  37.     //食人花敌人
  38.     public static List<BufferedImage> flower=new ArrayList<>();
  39.     //获取路径, 定义path变量,除了照片的名字以外前缀一直都一样，因此定义出来路径方便调用
  40.     public static String path=System.getProperty("user.dir")+"/src/images/";
  41.  
  42.     //初始化方法
  43.     public static void init(){
  44.         //利用ImageIO流的read方法,注意在read处捕获异常all+enter
  45.         try {
  46.             //加载背景图片
  47.             bg= ImageIO.read(new File(path+"bg.png"));
  48.             bg2=ImageIO.read(new File(path+"bg2.png"));
  49.             //加载玛丽向左站立
  50.             stand_L=ImageIO.read(new File(path+"stand_L.png"));
  51.             //加载玛丽向右站立
  52.             stand_R=ImageIO.read(new File(path+"stand_R.png"));
  53.             //加载马里奥向左跳跃
  54.             jump_L=ImageIO.read(new File(path+"jump1_l.png"));
  55.             //加载马里奥向右跳跃
  56.             Jump_R=ImageIO.read(new File(path+"Jump1_R.png"));
  57.             //加载城堡
  58.             tower=ImageIO.read(new File(path+"tower.png"));
  59.             //加载旗杆
  60.             gan=ImageIO.read(new File(path+"gan.png"));
  61.         } catch (IOException e) {
  62.             e.printStackTrace();
  63.         }
  64.         //加载马里奥向左跑
  65.         for (int i=1;i<=2;i++){
  66.             //向列表中添加
  67.             try {
  68.                 run_L.add(ImageIO.read(new File(path+"run"+i+"_L.png")));
  69.             } catch (IOException e) {
  70.                 e.printStackTrace();
  71.             }
  72.         }
  73.         //加载马里奥向右跑
  74.         for (int i=1;i<=2;i++){
  75.             //向列表中添加
  76.             try {
  77.                 run_R.add(ImageIO.read(new File(path+"run"+i+"_R.png")));
  78.             } catch (IOException e) {
  79.                 e.printStackTrace();
  80.             }
  81.         }
  82.  
  83.         try {
  84.             //加载障碍物,上下地面
  85.             obstacle.add(ImageIO.read(new File(path+"brick.png")));
  86.             obstacle.add(ImageIO.read(new File(path+"soil_up.png")));
  87.             obstacle.add(ImageIO.read(new File(path+"soil_base.png")));
  88.         } catch (IOException e) {
  89.             e.printStackTrace();
  90.         }
  91.         //加载水管
  92.         for (int i=1;i<=4;i++) {
  93.             try {
  94.                 obstacle.add(ImageIO.read(new File(path+"pipe"+i+".png")));
  95.             } catch (IOException e) {
  96.                 e.printStackTrace();
  97.             }
  98.         }
  99.         //加载不可破坏的砖块和旗子
  100.         try {
  101.             obstacle.add(ImageIO.read(new File(path+"brick2.png")));
  102.             obstacle.add(ImageIO.read(new File(path+"flag.png")));
  103.         } catch (IOException e) {
  104.             e.printStackTrace();
  105.         }
  106.         //加载蘑菇敌人
  107.         for(int i=1;i<=3;i++){
  108.             try {
  109.                 mogu.add(ImageIO.read(new File(path+"fungus"+i+".png")));
  110.             } catch (IOException e) {
  111.                 e.printStackTrace();
  112.             }
  113.         }

Obstacle类：该类设置了到旗子处后的后续操作

  1. package com.sxt;
  2.  
  3. import java.awt.image.BufferedImage;
  4.  
  5. public class Obstacle implements Runnable{  //让该类实现Runnable方法，并重写其抽象方法
  6.     //用于表示坐标
  7.     private int x;
  8.     private int y;
  9.     //用于记录障碍物类型
  10.     private int type;
  11.     //用于显示图像
  12.     private BufferedImage show=null;
  13.     //定义当前的场景对象
  14.     private BackGround bg=null;
  15.     //定义一个线程对象，用于完成旗子下落的过程
  16.     private Thread thread=new Thread(this);
  17.     //创建带参构造函数
  18.     public Obstacle(int x,int y,int type,BackGround bg){
  19.         //赋值
  20.         this.x=x;
  21.         this.y=y;
  22.         this.type=type;
  23.         this.bg=bg;
  24.         show=StaticValue.obstacle.get(type);    //初始化show，得到该类型的障碍物图像
  25.         //下一步，生成这四个变量的getter方法
  26.         //如果是旗子的话，启动线程
  27.         if (type==8){
  28.             thread.start();
  29.         }
  30.     }
  31.  
  32.     public int getX() {
  33.         return x;
  34.     }
  35.  
  36.     public int getY() {
  37.         return y;
  38.     }
  39.  
  40.     public int getType() {
  41.         return type;
  42.     }
  43.  
  44.     public BufferedImage getShow() {
  45.         return show;
  46.     }
  47.  
  48.     @Override
  49.     public void run() {
  50.         while(true){    //一个死循环
  51.             //让线程休眠，休眠时间:50毫秒
  52.             if (this.bg.isReach()) {  //判断马里奥是否到达旗子位置
  53.             if (this.y<374){          //判断此时旗子是否落到了地上
  54.                 this.y+=5;            //若没有，则让旗子慢慢下降
  55.             }else{
  56.                 this.bg.setBase(true);//将isBase设置为true，表示旗子已经成功落地
  57.             }
  58.             }
  59.             try {
  60.                 Thread.sleep(50);
  61.             } catch (InterruptedException e) {
  62.                 e.printStackTrace();
  63.             }
  64.         }
  65.     }
  66. }

Strong类：

  1. package com.sxt;
  2.  
  3. import java.awt.image.BufferedImage;
  4.  
  5. public class Strong implements Runnable{
  6.  
  7.     //储存食物坐标
  8.     private int x,y;
  9.     //显示图像
  10.     private BufferedImage show;
  11.     //定义一个背景对象
  12.     private BackGround bg;
  13.     //实现线程对象
  14.     private Thread thread=new Thread(this);
  15.     public Strong(int x,int y,BackGround bg){
  16.         this.x=x;
  17.         this.y=y;
  18.         this.bg=bg;
  19.  
  20.     }
  21.     @Override
  22.     public void run() {
  23.  
  24.     }
  25. }

Mario类：

  1. package com.sxt;
  2.  
  3. import jdk.nashorn.internal.ir.SplitReturn;
  4.  
  5. import java.awt.image.BufferedImage;
  6.  
  7. public class Mario implements Runnable{
  8.     //用于表示横纵坐标
  9.     private int x;
  10.     private int y;
  11.     //用于表示当前状态
  12.     private String status;
  13.     //用于显示当前状态对应的图像
  14.     private BufferedImage show=null;
  15.     //定义一个BackGround对象来获取障碍物信息
  16.     private BackGround backGround=new BackGround();
  17.  
  18.     //创建线程对象用来实现马里奥动作
  19.     private Thread thread=null;
  20.     //马里奥移动速度
  21.     private int xSpeed;
  22.     //马里奥跳跃速度
  23.     private int ySpeed;
  24.     //定义一个索引，用于取得马里奥的运动图像
  25.     private int index;
  26.     //表示马里奥的上升时间
  27.     private int upTime=0;
  28.     //判断马里奥是否走到了城堡门口
  29.     private boolean isOK;
  30.     //用于判断马里奥是否死亡
  31.     private boolean isDeath=false;
  32.     //设置积分
  33.     private int score=0;
  34.     public Mario(){
  35.     }
  36.     public Mario(int x,int y){
  37.         this.x=x;
  38.         this.y=y;
  39.         show=StaticValue.stand_R;
  40.         this.status="stand--right"; //下一步使马里奥类实现Runnable接口并重写其中的抽象方法
  41.         //初始化线程
  42.         thread=new Thread(this);
  43.         //启动线程
  44.         thread.start();
  45.     }
  46.     //马里奥死亡的方法
  47.     public void death(){
  48.         isDeath=true;
  49.     }
  50.     //向左移动
  51.     public void leftMove(){
  52.         //改变速度
  53.         xSpeed=-5;
  54.         //判断马里奥是否碰到了旗子
  55.         if (backGround.isReach()){          //若是，则马里奥不可再移动
  56.             xSpeed=0;
  57.         }
  58.         //判断马里奥是否在空中
  59.         if (status.indexOf("jump")!=-1){
  60.             status="jump--left";
  61.         }else{
  62.             status="move--left";
  63.         }
  64.     }
  65.     //向右移动
  66.     public void rightMove(){
  67.         xSpeed=5;
  68.         //判断马里奥是否碰到了旗子
  69.         if (backGround.isReach()){          //若是，则马里奥不可再移动
  70.             xSpeed=0;
  71.         }
  72.         if (status.indexOf("jump")!=-1){
  73.             status="jump--right";
  74.         }else{
  75.             status="move--right";
  76.         }
  77.     }
  78.     //向左停止
  79.     public void leftStop(){
  80.         xSpeed=0;
  81.         if(status.indexOf("jump")!=-1) {
  82.             status="jump--left";
  83.         }else{
  84.             status="stop--left";
  85.         }
  86.     }
  87.     //向右停止
  88.     public void rightStop(){
  89.         xSpeed=0;
  90.         if(status.indexOf("jump")!=-1) {
  91.             status="jump--right";
  92.         }else{
  93.             status="stop--right";
  94.         }
  95.     }
  96.     //马里奥跳跃
  97.     public void jump() {
  98.         //判断是否是跳跃状态,判断status调用它的indexOF方法
  99.         if (status.indexOf("jump")==-1) {
  100.             //判断方向，不等于-1则方向向左
  101.             if (status.indexOf("left")!=-1){
  102.                 status="jump--left";
  103.             }else{
  104.                 status="jump--right";
  105.             }
  106.             //改变下降速度向上跳跃y值减少
  107.             ySpeed=-10;
  108.             //设置向上跳的高度
  109.             upTime=7;       //向上跳一下70
  110.         }
  111.             //判断马里奥是否碰到了旗子
  112.             if (backGround.isReach()){          //若是，则马里奥不可再移动
  113.                 ySpeed=0;
  114.             }
  115.     }
  116.     //马里奥下落
  117.     public void fall(){
  118.         //下落时可能是从障碍物上掉下也可能是跳起后落下
  119.         if (status.indexOf("left")!=-1){
  120.             status="jump--left";
  121.         }else{
  122.             status="jump--right";
  123.         }
  124.         //下落时速度应该是正的，因为y值要++
  125.         ySpeed=10;
  126.     }
  127.     @Override
  128.     public void run() {
  129.         while (true){
  130.             //判断是否处于障碍物上
  131.             boolean onObstacle=false;
  132.             //判断是否可以向右走
  133.             boolean canRight=true;
  134.             //判断是否可以向左走
  135.             boolean canLeft=true;
  136.             //判断马里奥是否到达旗杆位置
  137.             if (backGround.isFlag()&&this.x>=500){
  138.                 //setReach设置为true，表明此刻马里奥到达了旗杆的位置
  139.                 this.backGround.setReach(true);
  140.                 //判断旗子是否下落完成
  141.                 if (this.backGround.isBase()){
  142.                     status="move--right";       //若是，则让马里奥开始向城堡移动
  143.                     if (x<690){         //判断马里奥是否到了城堡中间
  144.                         x+=5;
  145.                     }else {             //马里奥已经到了城堡处
  146.                         isOK=true;      //表示马里奥已经走到了城堡处
  147.                     }
  148.                 }else {                 //如果旗子没有下落完成
  149.                     if (y<395){         //判断马里奥是否在空中
  150.                         xSpeed=0;
  151.                         this.y+=5;      //让马里奥逐渐下落
  152.                         status="jump--right";       //改变状态
  153.                     }
  154.                     if (y>395){         //判断马里奥是否落到了地上，大于则说明已经到了地上，不该再下降
  155.                         this.y=395;
  156.                         status="stop--right";   //设置状态：向右站立
  157.                     }
  158.                 }
  159.             }else {
  160.                 //遍历当前场景中的所有障碍物
  161.                 for (int i = 0; i < backGround.getObstacleList().size(); i++) {
  162.                     //定义临时变量储存当前障碍物
  163.                     Obstacle ob = backGround.getObstacleList().get(i);
  164.                     //判断马里奥是否处于障碍物上
  165.                     if (ob.getY() == this.y + 25 && (ob.getX() > this.x - 30 && ob.getX() < this.x + 25)) {
  166.                         onObstacle = true;
  167.                     }
  168.                     //判断是否跳起来顶到砖块
  169.                     if ((ob.getY() >= this.y - 30 && ob.getY() <= this.y - 20)
  170.                             && (ob.getX() > this.x - 30 && ob.getX() < this.x + 25)) {
  171.                         //判断此时顶到的砖块类型是否是普通砖块(0),若是则移除
  172.                         if (ob.getType() == 0) {
  173.                             //如果是则调用backGround.getObstacleList().remove()方法将ob移出去
  174.                             backGround.getObstacleList().remove(ob);
  175.                             //破坏砖块+1分
  176.                             score+=1;
  177.                         }
  178.                         upTime = 0;   //使马里奥顶到砖块后立刻下落
  179.                     }
  180.                     //判断是否可以向右走
  181.                     if (ob.getX() == this.x + 25 && (ob.getY() > this.y - 30 && ob.getY() < this.y + 25)) {
  182.                         //如果符合该判断条件，则说明马里奥右侧有障碍物，无法往右走，将canRight置为false
  183.                         canRight = false;
  184.                     }
  185.  
  186.                     //判断是否可以往左走
  187.                     if (ob.getX() == this.x - 30 && (ob.getY() > this.y - 30 && ob.getY() < this.y + 25)) {
  188.                         canLeft = false;
  189.                     }
  190.                 }
  191.  
  192.                 //判断马里奥是否碰到敌人死亡或者踩死蘑菇敌人
  193.                 //通过for循环来遍历每一个敌人
  194.                 for (int i=0;i<backGround.getEnemyList().size();i++){
  195.                     Enemy e=backGround.getEnemyList().get(i);       //用e来储存我们当前的敌人
  196.                     //判断马里奥是否位于敌人的头上
  197.                     if (e.getY()==this.y+20&&(e.getX()-25<=this.x&&e.getX()+35>=this.x)){
  198.                         //判断是蘑菇敌人还是食人花敌人
  199.                         if (e.getType()==1){
  200.                             e.death();
  201.                             score+=2;
  202.                             upTime=3;
  203.                             ySpeed=-10;
  204.                         }else if (e.getType()==2){
  205.                             //马里奥死亡
  206.                             death();
  207.                         }
  208.                     }
  209.                     //碰到敌人，马里奥死亡
  210.                     if ((e.getX()+35>this.x&&e.getX()-25<this.x)
  211.                             &&(e.getY()+35>this.y&&e.getY()-20<this.y)){
  212.                         death();
  213.                     }
  214.                 }
  215.  
  216.                 //进行马里奥跳跃的操作
  217.                 //先判断马里奥此时是否在障碍物上
  218.                 if (onObstacle && upTime == 0) {
  219.                     if (status.indexOf("left") != -1) {
  220.                         if (xSpeed != 0) {
  221.                             status = "move--left";
  222.                         } else {
  223.                             status = "stop--left";
  224.                         }
  225.                     } else {
  226.                         if (xSpeed != 0) {
  227.                             status = "move--right";
  228.                         } else {
  229.                             status = "stop--right";
  230.                         }
  231.                     }
  232.                 } else {
  233.                     //如果不符合上个外层条件，则说明此时马里奥处于上升阶段
  234.                     if (upTime != 0) {
  235.                         upTime--;
  236.                     } else {
  237.                         //不是，则说明到了最高点，该下落了
  238.                         fall();
  239.                     }
  240.                     //改变坐标值
  241.                     y += ySpeed;
  242.                 }
  243.             }
  244.             if ((canLeft&&xSpeed<0)||(canRight&&xSpeed>0)){
  245.                 x+=xSpeed;
  246.                 //判断马里奥是否到了最左边
  247.                 if(x<0){
  248.                     x=0;
  249.                 }
  250.             }
  251.             //判断当前是否是移动状态
  252.             if (status.contains("move")){
  253.                 index=index==0?1:0;
  254.             }
  255.             //判断是否向左移动
  256.             if("move--left".equals(status)){
  257.                 show=StaticValue.run_L.get(index);
  258.             }
  259.             //判断是否向右移动
  260.             if ("move--right".equals(status)){
  261.                 show=StaticValue.run_R.get(index);
  262.             }
  263.             //判断是否向左停止
  264.             if ("stop--left".equals(status)){
  265.                 show=StaticValue.stand_L;
  266.             }
  267.             //判断是否向右停止
  268.             if ("stop--right".equals(status)){
  269.                 show=StaticValue.stand_R;
  270.             }
  271.             //判断是否向左跳跃
  272.             if("jump--left".equals(status)){
  273.                 show=StaticValue.jump_L;
  274.             }
  275.             //判断是否向右跳跃
  276.             if ("jump--right".equals(status)){
  277.                 show=StaticValue.Jump_R;
  278.             }
  279.             //设置线程休眠50毫秒
  280.             try {
  281.                 Thread.sleep(50);
  282.             } catch (InterruptedException e) {
  283.                 e.printStackTrace();
  284.             }
  285.  
  286.         }
  287.     }
  288.  
  289.     public int getX() {
  290.         return x;
  291.     }
  292.  
  293.     public int getY() {
  294.         return y;
  295.     }
  296.  
  297.     public BufferedImage getShow() {
  298.         return show;
  299.     }
  300.  
  301.     public void setShow(BufferedImage show){
  302.         this.show=show;
  303.     }
  304.  
  305.     public void setBackGround(BackGround backGround) {
  306.         this.backGround = backGround;
  307.     }
  308.  
  309.     public void setX(int x) {
  310.         this.x = x;
  311.     }
  312.  
  313.     public void setY(int y) {
  314.         this.y = y;
  315.     }
  316.  
  317.     public boolean isOK() {
  318.         return isOK;
  319.     }
  320.  
  321.     public boolean isDeath() {
  322.         return isDeath;
  323.     }
  324.  
  325.     public int getScore() {
  326.         return score;
  327.     }
  328. }

Enemy（敌人类）：

  1. package com.sxt;
  2.  
  3. import javax.xml.ws.BindingType;
  4. import java.awt.image.BufferedImage;
  5.  
  6. import static java.lang.Thread.sleep;
  7.  
  8. public class Enemy implements Runnable{
  9.     //储存当前坐标
  10.     private int x,y;
  11.     //储存敌人类型
  12.     private final int type;
  13.     //判断敌人的运动方向
  14.     private boolean face_to=true;
  15.     //用于显示敌人当前的图像
  16.     private BufferedImage show;
  17.     //定义一个背景对象
  18.     private final BackGround bg;
  19.     //食人花运动的极限范围
  20.     private int max_up=0;
  21.     private int max_down=0;
  22.     //实现线程对象,用于实现食人花和蘑菇的运动
  23.     private final Thread thread=new Thread(this);
  24.     //定义当前图片的状态
  25.     private int image_type=0;
  26.  
  27. //    创建MyFrame对象
  28. //    MyFrame myFrame = new MyFrame();
  29.  
  30.     //蘑菇敌人的构造函数
  31.     public Enemy(int x, int y,boolean face_to,int type,BackGround bg){
  32.         this.x=x;
  33.         this.y=y;
  34.         this.face_to=face_to;
  35.         this.type=type;
  36.         this.bg=bg;
  37.         show=StaticValue.mogu.get(0);
  38.         thread.start();     //调用start方法实现线程
  39.     }
  40.     //食人花敌人的构造函数
  41.     public Enemy(int x,int y,boolean face_to,int type,int max_up,int max_down,BackGround bg){
  42.         this.x=x;
  43.         this.y=y;
  44.         this.face_to=face_to;
  45.         this.type=type;
  46.         this.max_up=max_up;
  47.         this.max_down=max_down;
  48.         this.bg=bg;
  49.         show=StaticValue.flower.get(0);
  50.         thread.start();
  51.     }
  52.  
  53.     //死亡方法
  54.     public void death(){
  55.         show=StaticValue.mogu.get(2);   //蘑菇敌人死亡时的图片
  56.         this.bg.getEnemyList().remove(this);
  57.     }
  58.     public int getX(){
  59.         return x;
  60.     }
  61.     public int getY(){
  62.         return y;
  63.     }
  64.     public BufferedImage getShow() {
  65.         return show;
  66.     }
  67.     public int getType(){
  68.         return type;
  69.     }
  70.  
  71.     @Override
  72.     public void run() {
  73.         try {
  74.             sleep(2000);
  75.         } catch (InterruptedException e) {
  76.             throw new RuntimeException(e);
  77.         }
  78.         if (MyFrame.isStart == true) {
  79.  
  80.             while (true) {
  81.                 //判断是否是蘑菇敌人，type是蘑菇敌人
  82.                 if (type == 1) {
  83.                     if (face_to) {       //true是向左移动，false时向右移动
  84.                         this.x -= 2;
  85.                     } else {
  86.                         this.x += 2;
  87.                     }
  88.                     //使用三目运算符
  89.                     image_type = image_type == 1 ? 0 : 1;
  90.                     show = StaticValue.mogu.get(image_type);
  91.                 }
  92.                 //定义两个布尔变量
  93.                 boolean canLeft = true;
  94.                 boolean canRight = true;
  95.                 //通过for循环来遍历每一个障碍物
  96.                 for (int i = 0; i < bg.getObstacleList().size(); i++) {
  97.                     Obstacle ob1 = bg.getObstacleList().get(i);
  98.                     //判断是否可以向右走
  99.                     if (ob1.getX() == this.x + 36 && (ob1.getY() + 65 > this.y && ob1.getY() - 35 < this.y)) {
  100.                         //如果符合该判断条件则说明敌人右侧有障碍物，那么它就无法右走
  101.                         canRight = false;
  102.                     }
  103.  
  104.                     //判断是否可以左走
  105.                     if (ob1.getX() == this.x - 36 && (ob1.getY() + 65 > this.y && ob1.getY() - 35 < this.y)) {
  106.                         canLeft = false;
  107.                     }
  108.                 }
  109.                 if (face_to && !canLeft || this.x == 0) {       //判断是否是向左走且碰到了障碍物或是走到了屏幕最左侧
  110.                     face_to = false;
  111.                 } else if ((!face_to) && (!canRight) || this.x == 764) {
  112.                     face_to = true;
  113.                 }
  114.                 //判断敌人是否是食人花敌人
  115.                 if (type == 2) {
  116.                     if (face_to) {
  117.                         this.y -= 2;
  118.                     } else {
  119.                         this.y += 2;
  120.                     }
  121.                     image_type = image_type == 1 ? 0 : 1;
  122.                     //判断食人花是否到达极限位置
  123.                     if (face_to && (this.y == max_up)) {
  124.                         face_to = false;
  125.                     }
  126.                     if ((!face_to) && (this.y == max_down)) {
  127.                         face_to = true;
  128.                     }
  129.                     show = StaticValue.flower.get(image_type);
  130.                 }
  131.                 try {
  132.                     sleep(50);
  133.                 } catch (InterruptedException e) {
  134.                     e.printStackTrace();
  135.                 }
  136.             }
  137.        }        
  138.  }
  139.  
  140.     }
  141.  
  142.

Music类：

  1. package com.sxt;
  2.  
  3. import javazoom.jl.decoder.JavaLayerException;
  4. import javazoom.jl.player.Player;
  5.  
  6. import java.io.BufferedInputStream;
  7. import java.io.FileInputStream;
  8. import java.io.FileNotFoundException;
  9. public class Music {
  10.     public Music() throws FileNotFoundException, JavaLayerException {
  11.         Player player;
  12.         String str=System.getProperty("user.dir")+"/src/Music/music.wav";//拼接路径，寻找音乐
  13.             BufferedInputStream name=new BufferedInputStream(new FileInputStream(str));//读取音乐
  14.             player=new Player(name);//实例化对象。同上一步都需要抛出异常
  15.             player.play();//调用方法播放音乐
  16.     }
  17. }

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

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

  

闽ICP备14008679号