超级玛丽源码及素材

• 游戏效果截图
• 源码:
• • Class1:demon.java
  • Class2:MyFrame.java
  • Class3:Mario.java
  • Class4:Enemy.java
  • Class5:StaticValue
  • Class6:Music.java
• 素材:

游戏效果截图

源码:

Class1:demon.java

public class demon {
    public static void main(String[] args){
     new MyFrame();
    }

}

Class2:MyFrame.java

import javazoom.jl.decoder.JavaLayerException;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

public class MyFrame extends JFrame implements KeyListener,Runnable{

    //用于储存所有的背景
    private List<BackGround> allBg = new ArrayList<>();
    //用于储存当前的背景
    private BackGround nowBg = new BackGround();
    //用于双缓存
    private Image offScreenImage = null;
    //马里奥对象
    private Mario mario = new Mario();
    //定义一个线程对象，用于实现马里奥的运动
    private Thread thread = new Thread(this);
    boolean isOk =false;
    public MyFrame(){
        //Login login = new Login("lining");
            //设置窗口的大小
            this.setSize(800,600);
            //设置窗口居中显示
            this.setLocationRelativeTo(null);
            //设置窗口的可见性
            this.setVisible(true);
            //设置点击窗口上的关闭键，结束程序
            this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            //设置窗口大小不变
            this.setResizable(false);
            //向窗口对象添加键盘监听器
            this.addKeyListener((KeyListener) this);
            //设置窗口名称
            this.setTitle("SuperMario");
            //初始化图片
            StaticValue.init();
            //初始化马里奥
            mario = new Mario(10,365);
            //创建全部的场景
            for(int i=1;i<=3;i++){
                allBg.add(new BackGround(i,i==3?true:false));

            }
            //将第一个场景设置为当前场景
            nowBg = allBg.get(0);
            mario.setBackGround(nowBg);
            JOptionPane.showMessageDialog(this,"靓仔你好，请开始你的表演");
            //绘制图像
            repaint();
            thread.start();
            try {
                new Music();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (JavaLayerException e) {
                e.printStackTrace();
            }

        }



    @Override
    public void paint(Graphics g) {
        if(offScreenImage == null){
            offScreenImage = createImage(800,600);
        }
        Graphics graphics = offScreenImage.getGraphics();
        graphics.fillRect(0,0,800,600);
        //绘制背景
        graphics.drawImage(nowBg.getBaImage(),0,0,this);
        //绘制敌人
        for(Enemy e:nowBg.getEnemyList())
        {
            graphics.drawImage(e.getShow(),e.getX(),e.getY(),this);
        }
        //绘制障碍物
        for(Obstacle ob:nowBg.getObstacleList())
        {
            graphics.drawImage(ob.getShow(), ob.getX(), ob.getY(), this);
        }
        //绘制城堡
        graphics.drawImage(nowBg.getTower(),600,130,this);
        //绘制旗杆
        graphics.drawImage(nowBg.getGan(),500,220,this);
        //绘制马里奥
        graphics.drawImage(mario.getShow(), mario.getX(), mario.getY(), this);
        //绘制分数
        Color c = graphics.getColor();
        graphics.setColor(Color.red);
        graphics.setFont(new Font("宋体",Font.BOLD,40));
        graphics.drawString("当前的分数为"+mario.getScore(),300,100);
        graphics.setColor(Color.yellow);
        //将图像绘制到窗口中
        g.drawImage(offScreenImage,0,0,this);
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {
        //向右移动
        if(e.getKeyCode() == 39)
            mario.rightMove();
        //向左移动
        if(e.getKeyCode() == 37)
            mario.leftMove();
        //跳跃
        if(e.getKeyCode() == 38)
        {
            mario.jump();
        }

    }

    @Override
    public void keyReleased(KeyEvent e) {
        //向左停止
        if(e.getKeyCode() == 37)
            mario.leftStop();
        //向右停止
        if(e.getKeyCode() == 39)
            mario.rightStop();

    }

    @Override
    public void run() {
        while(true)
        {
            repaint();
            try {
                Thread.sleep(50);
                if(mario.getX() >= 775)
                {
                    nowBg = allBg.get(nowBg.getSort());
                    mario.setBackGround(nowBg);
                    mario.setX(10);
                    mario.setY(365);
                }
                //判断马里奥是否死亡
                if(mario.isDeath())
                {
                    JOptionPane.showMessageDialog(this,"不好意思，靓仔你挂了");
                    System.exit(0);

                }
                //判断游戏是否结束了
                if(mario.isOK())
                {
                    JOptionPane.showMessageDialog(this,"恭喜靓仔通关了");
                    System.exit(0);
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Class3:Mario.java

import java.awt.image.BufferedImage;
import java.awt.image.BufferedImage;

public class Mario implements Runnable{
    /**
     *
     */
    //用于表示横纵坐标
    private int x;
    private int y;
    //用于表示当前状态
    private String status;
    //用于显示当前状态对应的图像
    private BufferedImage show = null;
    //定义一个BackGround对象，用来获取障碍物的信息
    private BackGround backGround = new BackGround();
    //用来实现马里奥的动作
    private Thread thread = null;
    //马里奥的移动速度
    private int xSpeed;
    //马里奥的跳跃速度
    private int ySpeed;
    //定义一个索引
    private int index;
    //表示马里奥上升的时间
    private int upTime = 0;
    //用于判断马里奥是否走到了城堡的门口
    private boolean isOK;
    //用于判断马里奥是否死亡
    private boolean isDeath = false;
    //表示分数
    private int score = 0;
    public Mario()
    {

    }
    public Mario(int x, int y)
    {
        this.x = x;
        this.y = y;
        show = StaticValue.stand_R;//初始向右站立
        this.status = "stand--right";
        thread = new Thread(this);
        thread.start();
    }
    //马里奥死亡的方法
    public void death()
    {
        isDeath = true;
    }
    //马里奥向左移动
    public void leftMove()
    {
        //改变速度
        xSpeed = -5;
        //判断马里奥是否碰到了旗子
        if(backGround.isReach())
            xSpeed = 0;
        //判断马里奥是否处于空中
        if(status.indexOf("jump")!=-1)
            status = "jump--left";
        else
            status = "move--left";
    }
    //马里奥向右移动
    public void rightMove()
    {
        //改变速度
        xSpeed = 5;
        //判断马里奥是否碰到了旗子
        if(backGround.isReach())
            xSpeed = 0;
        //判断马里奥是否处于空中
        if(status.indexOf("jump")!=-1)
            status = "jump--right";
        else
            status = "move--right";
    }
    //马里奥向左停止
    public void leftStop()
    {
        //改变速度
        xSpeed = 0;
        //判断马里奥是否处于空中
        if(status.indexOf("jump")!=-1)
            status = "jump--left";
        else
            status = "stop--left";
    }
    //马里奥向右停止
    public void rightStop()
    {
        //改变速度
        xSpeed = 0;
        //判断马里奥是否处于空中
        if(status.indexOf("jump")!=-1)
            status = "jump--right";
        else
            status = "stop--right";
    }
    //马里奥跳跃
    public void jump()
    {
        if(status.indexOf("jump")==-1)
        {
            if(status.indexOf("left")!=-1)
                status = "jump--left";
            else
                status = "jump--right";
            ySpeed = -10;
            upTime = 7;
        }
        //判断马里奥是否碰到了旗子
        if(backGround.isReach())
            ySpeed = 0;
    }
    //马里奥下落
    public void fall()
    {
        if(status.indexOf("left")!=-1)
            status = "jump--left";
        else
            status = "jump--right";
        ySpeed = 10;

    }

    @Override
    public void run() {
        while(true)
        {
            //判断是否处于障碍物上
            boolean onObstacle = false;
            //判断是否可以往右走
            boolean canRight = true;
            //判断是否可以往左走
            boolean canLeft = true;
            //判断马里奥是否到达旗杆位置
            if(backGround.isFlag() && this.x>500)
            {
                this.backGround.setReach(true);
                //判断旗子是否下落完成
                if(this.backGround.isBase())
                {
                    status = "move--left";
                    if(x<690)
                    {
                        x+=5;
                    }
                    else
                    {
                        isOK =true;
                    }
                }
                else
                {
                    if(y<385)
                    {
                        xSpeed = 0;
                        this.y += 5;
                        status = "jump--right";
                    }
                    if(y>385)
                    {
                        xSpeed = 0;
                        this.y += 5;
                        status = "stop--right";
                    }
                }
            }
            else {

                //遍历当前场景里所有的障碍物
                for (int i = 0; i < backGround.getObstacleList().size(); i++) {
                    Obstacle ob = backGround.getObstacleList().get(i);
                    //判断马里奥是否处于障碍物上
                    if (ob.getY() == this.y + 25 && (ob.getX() > this.x - 30 && ob.getX() < this.x + 25)) {
                        onObstacle = true;
                    }
                    //判断是否跳起来顶到砖块
                    if ((ob.getY() >= this.y - 30 && ob.getY() <= this.y - 20) && (ob.getX() > this.x - 30 && ob.getX() < this.x + 25)) {
                        if (ob.getType() == 0) {
                            backGround.getObstacleList().remove(ob);
                            score += 1;
                        }
                        upTime = 0;

                    }
                    //判断是否可以往右走
                    if (ob.getX() == this.x + 25 && (ob.getY() > this.y - 30 && ob.getY() < this.y + 25)) {
                        canRight = false;
                    }
                    //判断是否可以往左走
                    if (ob.getX() == this.x - 30 && (ob.getY() > this.y - 30 && ob.getY() < this.y + 25)) {
                        canLeft = false;
                    }
                }
                //判断马里奥是否碰到敌人或者踩死蘑菇敌人
                for(int i = 0;i<backGround.getEnemyList().size();i++)
                {
                    Enemy e = backGround.getEnemyList().get(i);
                    if(e.getY() == this.y + 20&&(e.getX()-25<=this.x&&e.getX()+35>=this.x))
                    {
                        if(e.getType() == 1)
                        {
                            e.death();
                            score += 2;
                            upTime = 3;
                            ySpeed = -10;
                        }
                        else if(e.getType() == 2)
                        {
                            //马里奥死亡
                            death();
                        }
                    }
                    if((e.getX()+35>this.x&&e.getX() - 25 <this.x)&&(e.getY()+35>this.y&&e.getY()-20<this.y))
                    {
                        //马里奥死亡
                        death();
                    }
                }
                //进行马里奥跳跃的操作
                if (onObstacle && upTime == 0) {
                    if (status.indexOf("left") != -1) {
                        if (xSpeed != 0)
                            status = "move--left";
                        else
                            status = "stop--left";
                    } else {
                        if (xSpeed != 0)
                            status = "move--right";
                        else
                            status = "stop--right";
                    }
                } else {
                    if (upTime != 0)
                        upTime--;
                    else
                        fall();
                    y += ySpeed;
                }
            }
            if(canLeft && xSpeed<0||canRight && xSpeed>0)
            {
                x+= xSpeed;
                //判断马里奥是否到了最左边
                if(x<0)
                    x = 0;
            }
            //判断当前是否是移动状态
            if(status.contains("move"))
            {
                index = index == 0?1:0;
            }
            //判断是否向左移动
            if("move--left".equals(status))
            {
                show = StaticValue.run_L.get(index);
            }
            //判断是否向右移动
            if("move--right".equals(status))
            {
                show = StaticValue.run_R.get(index);
            }
            //判断是否向左停止
            if("stop--left".equals(status))
                show = StaticValue.stand_L;
            //判断是否向右停止
            if("stop--right".equals(status))
                show = StaticValue.stand_R;
            //判断是否向左跳跃
            if("jump--left".equals(status))
            {
                show = StaticValue.jump_L;
            }
            //判断是否向右跳跃
            if("jump--right".equals(status))
            {
                show = StaticValue.jump_R;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public int getX() {
        return x;
    }
    public void setX(int x){
        this.x = x;
    }

    public int getY() {
        return y;
    }
    public void setY(int y){
        this.y = y;
    }

    public BufferedImage getShow() {
        return show;
    }
    public void setShow(BufferedImage show){
        this.show = show;
    }

    public void setBackGround(BackGround backGround) {
        this.backGround = backGround;
    }

    public boolean isOK() {
        return isOK;
    }

    public boolean isDeath() {
        return isDeath;
    }

    public int getScore() {
        return score;
    }
}

Class4:Enemy.java

import java.awt.image.BufferedImage;
import java.awt.image.BufferedImage;

public class Enemy implements Runnable{


    //储存当前坐标
    private int x;

    private int y;

    //储存敌人类型
    private int type;
    //判断敌人运动的方向
    private boolean fact_to =true;

    //用于显示敌人的当前图像
    private BufferedImage show;
    //定义一个背景对象
    private BackGround bg;
    //食人花运动的极限范围
    private int max_up = 0;
    private int max_down = 0;
    //定义线程对象
    private Thread thread = new Thread(this);
    //定义当前图片的状态
    private int image_type = 0;
    //蘑菇敌人的构造函数
    public Enemy(int x, int y, boolean fact_to, int type, BackGround bg)
    {
        this.x = x;
        this.y = y;
        this.fact_to = fact_to;
        this.type = type;
        this.bg = bg;
        show = StaticValue.mogu.get(0);
        thread.start();
    }
    //食人花敌人的构造函数
    public Enemy(int x, int y, boolean fact_to, int type, int max_up, int max_down, BackGround bg)
    {
        this.x = x;
        this.y = y;
        this.fact_to = fact_to;
        this.type = type;
        this.max_down = max_down;
        this.max_up = max_up;
        this.bg = bg;
        show = StaticValue.flower.get(0);
        thread.start();
    }
    //死亡方法
    public void death()
    {
        show = StaticValue.mogu.get(2);//蘑菇敌人死亡时的图片
        this.bg.getEnemyList().remove(this);
    }

    @Override
    public void run() {
        while(true) {
            //判断是否是蘑菇敌人
            if (type == 1) {
                if (fact_to) {
                    this.x -= 2;
                } else {
                    this.x += 2;
                }
                image_type = image_type == 1 ? 0 : 1;
                show = StaticValue.mogu.get(image_type);
            }
            //定义两个布尔变量
            boolean canLeft = true;
            boolean canRight = true;
            for (int i = 0; i < bg.getObstacleList().size(); i++)
            {
                Obstacle ob1 = bg.getObstacleList().get(i);
                //判断是否可以右走
                if(ob1.getX() == this.x + 36&&(ob1.getY()+65>this.y&&ob1.getY()-35<this.y))
                {
                    canRight = false;
                }
                //判断是否可以左走
                if(ob1.getX() == this.x - 36&&(ob1.getY()+65>this.y&&ob1.getY()-35<this.y))
                {
                    canLeft = false;
                }
            }
            if(fact_to&&!canLeft || this.x==0)
            {
                fact_to=false;
            }
            else if(!(fact_to)&&!(canRight) || this.x==764)
            {
                fact_to = true;
            }
            //判断是否是食人花敌人
            if(type == 2)
            {
                if(fact_to)
                {
                    this.y -= 2;
                }
                else
                {
                    this.y += 2;
                }
                image_type = image_type == 1 ? 0 : 1;

                //食人花是否到达极限位置
                if(fact_to && (this.y == max_up)){
                    fact_to = false;
                }
                if((!fact_to)&&(this.y == max_down)){
                    fact_to = true;
                }
                show = StaticValue.flower.get(image_type);
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
    public BufferedImage getShow() {
        return show;
    }
    public int getType() {
        return type;
    }

}

Class5:StaticValue

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class StaticValue {
    //背景
    public static BufferedImage bg=null;
    public static BufferedImage bg2=null;
    //马里奥向左跳跃
    public static BufferedImage jump_L=null;
    //马里奥向右跳跃
    public static BufferedImage jump_R=null;
    //马里奥向左站立
    public static BufferedImage stand_L=null;
    //马里奥向右站立
    public static BufferedImage stand_R=null;
    //城堡
    public static BufferedImage tower=null;
    //旗杆
    public static BufferedImage gan=null;
    //障碍物
    public static List<BufferedImage> obstacle = new ArrayList<>();
    //马里奥向左跑
    public static List<BufferedImage> run_L = new ArrayList<>();
    //马里奥向右跑
    public static List<BufferedImage> run_R = new ArrayList<>();
    //蘑菇敌人
    public static List<BufferedImage> mogu = new ArrayList<>();
    //食人花敌人
    public static List<BufferedImage> flower = new ArrayList<>();
    //路径的前缀，方便后续使用
    public static String path ="data";
    //初始化方法
    public static void init(){

        try {
            //加载背景图片
            bg = ImageIO.read(new File("data/bg.png"));
            bg2 = ImageIO.read(new File("data/bg.png"));
            //加载马里奥向左站立
            stand_L = ImageIO.read(new File("data/32.png"));

            //加载马里奥向右站立
            stand_R = ImageIO.read(new File("data/32.png"));

            //加载城堡
            tower = ImageIO.read(new File("data/chengbao.png"));

            //加载旗杆
            gan = ImageIO.read(new File("data/gan.png"));

            //加载马里奥向左跳跃
            jump_L = ImageIO.read(new File("data/s_mario_run1_L.png"));
            //加载马里奥向右跳跃
            jump_R = ImageIO.read(new File("data/s_mario_run1_L.png"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        //加载马里奥左跑
        for(int i=1;i<3;i++){
            try {
                run_L.add(ImageIO.read(new File("data/s_mario_run"+i+"_L.png")));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //加载马里奥右跑
        for(int i=1;i<3;i++){
            try {
                run_R.add(ImageIO.read(new File("data/s_mario_run"+i+"_L.png")));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //加载障碍物
        try {
            obstacle.add(ImageIO.read(new File("data/no_no_stone.png")));
            obstacle.add(ImageIO.read(new File("data/soli_up.png")));
            obstacle.add(ImageIO.read(new File("data/soli_base.png")));
        } catch (IOException e) {
            e.printStackTrace();
        }
        //加载水管
        for(int i=1;i<=4;i++){
            try {
                obstacle.add(ImageIO.read(new File("data/guan"+i+".png")));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //加载不可破坏的砖块和旗子
        try {
            obstacle.add(ImageIO.read(new File("data/stonezhuan.png")));
            obstacle.add(ImageIO.read(new File("data/flag.png")));
        } catch (IOException e) {
            e.printStackTrace();
        }
        //加载蘑菇敌人
        for(int i=1;i<=3;i++){
            try {
                mogu.add(ImageIO.read(new File("data/mogu"+i+".png")));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //加载食人花敌人
        for(int i=1;i<=2;i++){
            try {
                flower.add(ImageIO.read(new File("data/flower"+i+".png")));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Class6:Music.java

import javazoom.jl.decoder.JavaLayerException;
import javazoom.jl.player.Player;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Music {
    public Music() throws FileNotFoundException, JavaLayerException {
        Player player;
        String str = System.getProperty("user.dir")+"/src/Music/mus.mp3";
        BufferedInputStream name = new BufferedInputStream(new FileInputStream(str));
        player = new Player(name);
        player.play();

    }
}

素材:

有需要可私聊.
2022.1.23.13:23