Server

    1. import javax.swing.*;
    2. import java.awt.*;
    3. import java.awt.event.KeyEvent;
    4. import java.awt.event.KeyListener;
    5. import java.io.ByteArrayOutputStream;
    6. import java.io.ObjectOutputStream;
    7. import java.net.DatagramPacket;
    8. import java.net.DatagramSocket;
    9. import java.net.InetAddress;
    10. import java.util.ArrayList;
    11. import java.util.List;
    14. /*
    15.  *
    16.  *   执行类
    17.  *
    18.  *
    19.  * */
    21. //窗口包
    22. public class MyFrameC extends JFrame implements KeyListener, Runnable {
    25.     //给游戏背景添加上图片
    26.     //用于存储所有的背景、
    27.     private List<Background> allBg = new ArrayList<>();
    28.     //用于存储当前背景
    29.     private Background nowBg = new Background();
    30.     //用于双缓存
    31.     //把要显示的东西全部绘制在一张'图片'上(内存开辟),然后再把这张'图片'一次性显示到屏幕上~
    32.     private Image offScreenImage = null;
    34.     //马力对象
    35.     public static Mario mario = new Mario();
    37.     public static Mario mario2 = new Mario();
    39.     //定义一个全局变量x,y
    40.     public static int x, y;
    42.     //接收数据
    43.     DatagramSocket ds;
    45.     //发送数据
    46.     DatagramPacket dp;
    49.     //坐标类
    50.     public static MarioXY marioXY = new MarioXY(50,330);
    52.     private int a;
    53.     private int state;
    55.     //定义一个线程对象，用于实现马力的运动
    56.     private Thread thread = new Thread(this);
    57.     static String str;
    58.     static Integer i;
    60.     //空参构造方法
    61.     //在创建对象的时候就把窗口创建出来
    62.     public MyFrameC() {
    64.         //给MarioXY赋值
    65.         marioXY = new MarioXY(20, 330);
    67.         //设置窗口大小为800 * 600
    68.         this.setSize(1000, 600);
    70.         //设置窗口居中显示
    71.         this.setLocationRelativeTo(null);
    73.         //设置窗口的可见性
    74.         this.setVisible(true);
    76.         //设置点击窗口上的关闭键,结束程序
    77.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    79.         //设置窗口大小不可变
    80.         this.setResizable(false);
    82.         //向窗口对象添加键盘监听器 这里我们需要继承一个接口KeyListener
    83.         this.addKeyListener(this);
    85.         //设置窗口名称
    86.         this.setTitle("超级马力");
    88.         //调用静态初始化方法 初始化图片
    89.         StaticValue.init();
    91.         //初始化马力对象
    92.         mario = new Mario(marioXY.getX(), marioXY.getY(), marioXY);
    94.         //创建全部的场景 使用for循环
    95.         for (int i = 1; i <= 3; i++) {
    96.             //判断是否是第三关 传入i值
    97.             allBg.add(new Background(i, i == 3 ? true : false));
    98.         }
    99.         //设置第一个场景
    100.         nowBg = allBg.get(0);
    102.         //将第一个场景传给马力对象
    103.         mario.setBackground(nowBg);
    106.         //接收对象
    107.        /* new Thread(() -> {
    108.             try {
    109.                 ds = new DatagramSocket(8888);
    110.                 byte[] bytes = new byte[1024];
    111.                 while (true) {
    112.                     dp = new DatagramPacket(bytes, bytes.length);
    113.                     ds.receive(dp);
    115.                     //反序列化
    116.                     ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
    117.                     ObjectInputStream oi = new ObjectInputStream(bais);
    118.                     marioXY = (MarioXY) oi.readObject();
    119.                 }
    120.             } catch (Exception e) {
    121.                 e.printStackTrace();
    122.             }
    123.         }).start();*/
    126.         //发送对象
    129.         thread.start();
    130.         repaint();
    132.     }
    134.     //重写paint方法
    135.     public void paint(Graphics g) {
    137.         //首先判断这个双缓冲是否为null
    138.         if (offScreenImage == null) {
    140.             //如果是的话我们为他赋值
    141.             offScreenImage = createImage(1000, 600);
    142.         }
    145.         Graphics graphics = offScreenImage.getGraphics();//绘制
    146.         graphics.fillRect(0, 0, 1000, 600);//对图像进行填充
    147.         //判断游戏模式
    148.         graphics.setColor(Color.BLUE);
    149.         graphics.drawString("开始游戏", 500, 300);
    150.         graphics.setFont(new Font("仿体", Font.BOLD, 100));
    152.         if (state == 1) {
    153.             //绘制背景 执行到这的时候nowBg里面已经存入了图片了
    154.             graphics.drawImage(nowBg.getBgImage(), 0, 0, this);
    157.             //绘制的障碍物
    158.             for (Obstacle ob : nowBg.getObstacleList()) {
    159.                 graphics.drawImage(ob.getShow(), ob.getX(), ob.getY(), this);
    160.             }
    162.             //绘制城堡
    163.             graphics.drawImage(nowBg.getTower(), 620, 270, this);
    165.             //绘制旗杆
    166.             graphics.drawImage(nowBg.getGan(), 500, 220, this);
    168.             //绘制马力
    169.             graphics.drawImage(mario.getShow(), mario.getX(), mario.getY(), this);
    170.             //上面的步骤是将图片已经绘制到缓冲区上了
    172.             //绘制敌人
    173.             for (Enemy enemy : nowBg.getEnemyList()) {
    174.                 graphics.drawImage(enemy.getShow(), enemy.getX(), enemy.getY(), this);
    175.             }
    177.         }
    179.         g.drawImage(offScreenImage, 0, 0, this);
    181.     }
    184.     // 下面我们将图片绘制到窗口中
    187.     @Override
    188.     public void keyTyped(KeyEvent e) {
    190.     }
    192.     //当键盘按下按键时调用
    193.     //这个方法是 当键盘按下某个按键时调用
    194.     @Override
    195.     public void keyPressed(KeyEvent e) {
    196.         //向右移动
    197.         if (e.getKeyCode() == 68) {
    198.             mario.rightMove();
    199.             try {
    200.                 ds = new DatagramSocket();
    201.                 //序列化对象 把对象序列化
    202.                 ByteArrayOutputStream bao = new ByteArrayOutputStream();
    203.                 ObjectOutputStream oos = new ObjectOutputStream(bao);
    204.                 oos.writeObject(marioXY);
    205.                 oos.flush();
    207.                 byte[] sendBuff = bao.toByteArray();
    208.                 dp = new DatagramPacket(sendBuff, sendBuff.length,
    209.                         InetAddress.getLocalHost(), 8787);
    210.                 ds.send(dp);
    211.             } catch (Exception e1) {
    212.                 e1.printStackTrace();
    213.             }
    215.         }
    216.         //向左移动
    217.         if (e.getKeyCode() == 65) {
    218.             mario.leftMove();
    219.         }
    221.         //跳跃
    222.         if (e.getKeyCode() == 87) {
    223.             mario.jump();
    224.         }
    226.         int key = e.getKeyCode();
    227.         switch (key) {
    228.             case KeyEvent.VK_ENTER:
    229.                 state = 1;
    230.                 break;
    231.         }
    234.     }
    237.     //当键盘按下按键时调用
    238.     //这个方法是 当键盘松开某个按键时调用
    239.     @Override
    240.     public void keyReleased(KeyEvent e) {
    241.         //向左停止
    242.         if (e.getKeyCode() == 65) {
    243.             mario.leftStop();
    244.         }
    245.         //向右停止
    246.         if (e.getKeyCode() == 68) {
    247.             mario.rightStop();
    248.         }
    251.     }
    253.     @Override
    254.     public void run() {
    255.         while (true) {
    256.             //重新绘制图像
    257.             repaint();
    258.             try {
    259.                 //线程休眠
    260.                 Thread.sleep(50);
    261.                 //判断马力是否已经走到了最右边
    262.                 if (mario.getX() >= 980) {
    263.                     nowBg = allBg.get(nowBg.getSort());
    264.                     mario.setBackground(nowBg);
    265.                     mario.setX(10);
    266.                     mario.setY(370);
    267.                 }
    269.                 if (mario.getX() <= 0) {
    270.                     nowBg = allBg.get(nowBg.getSort() - 2);
    271.                     mario.setBackground(nowBg);
    272.                     mario.setX(980);
    273.                     mario.setY(370);
    274.                 }
    276.             } catch (Exception e) {
    277.                 e.printStackTrace();
    278.             }
    280.         }
    281.     }
    284.     public static void main(String[] args) {
    285.         MyFrameC m = new MyFrameC();
    286.     }
    288. }

    Client

    1. import javax.swing.*;
    2. import java.awt.*;
    3. import java.awt.event.KeyEvent;
    4. import java.awt.event.KeyListener;
    5. import java.io.ByteArrayOutputStream;
    6. import java.io.ObjectOutputStream;
    7. import java.net.DatagramPacket;
    8. import java.net.DatagramSocket;
    9. import java.net.InetAddress;
    10. import java.util.ArrayList;
    11. import java.util.List;
    14. /*
    15.  *
    16.  *   执行类
    17.  *
    18.  *
    19.  * */
    21. //窗口包
    22. public class MyFrameC extends JFrame implements KeyListener, Runnable {
    25.     //给游戏背景添加上图片
    26.     //用于存储所有的背景、
    27.     private List<Background> allBg = new ArrayList<>();
    28.     //用于存储当前背景
    29.     private Background nowBg = new Background();
    30.     //用于双缓存
    31.     //把要显示的东西全部绘制在一张'图片'上(内存开辟),然后再把这张'图片'一次性显示到屏幕上~
    32.     private Image offScreenImage = null;
    34.     //马力对象
    35.     public static Mario mario = new Mario();
    37.     public static Mario mario2 = new Mario();
    39.     //定义一个全局变量x,y
    40.     public static int x, y;
    42.     //接收数据
    43.     DatagramSocket ds;
    45.     //发送数据
    46.     DatagramPacket dp;
    49.     //坐标类
    50.     public static MarioXY marioXY = new MarioXY(50,330);
    52.     private int a;
    53.     private int state;
    55.     //定义一个线程对象，用于实现马力的运动
    56.     private Thread thread = new Thread(this);
    57.     static String str;
    58.     static Integer i;
    60.     //空参构造方法
    61.     //在创建对象的时候就把窗口创建出来
    62.     public MyFrameC() {
    64.         //给MarioXY赋值
    65.         marioXY = new MarioXY(20, 330);
    67.         //设置窗口大小为800 * 600
    68.         this.setSize(1000, 600);
    70.         //设置窗口居中显示
    71.         this.setLocationRelativeTo(null);
    73.         //设置窗口的可见性
    74.         this.setVisible(true);
    76.         //设置点击窗口上的关闭键,结束程序
    77.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    79.         //设置窗口大小不可变
    80.         this.setResizable(false);
    82.         //向窗口对象添加键盘监听器 这里我们需要继承一个接口KeyListener
    83.         this.addKeyListener(this);
    85.         //设置窗口名称
    86.         this.setTitle("超级马力");
    88.         //调用静态初始化方法 初始化图片
    89.         StaticValue.init();
    91.         //初始化马力对象
    92.         mario = new Mario(marioXY.getX(), marioXY.getY(), marioXY);
    94.         //创建全部的场景 使用for循环
    95.         for (int i = 1; i <= 3; i++) {
    96.             //判断是否是第三关 传入i值
    97.             allBg.add(new Background(i, i == 3 ? true : false));
    98.         }
    99.         //设置第一个场景
    100.         nowBg = allBg.get(0);
    102.         //将第一个场景传给马力对象
    103.         mario.setBackground(nowBg);
    106.         //接收对象
    107.        /* new Thread(() -> {
    108.             try {
    109.                 ds = new DatagramSocket(8888);
    110.                 byte[] bytes = new byte[1024];
    111.                 while (true) {
    112.                     dp = new DatagramPacket(bytes, bytes.length);
    113.                     ds.receive(dp);
    115.                     //反序列化
    116.                     ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
    117.                     ObjectInputStream oi = new ObjectInputStream(bais);
    118.                     marioXY = (MarioXY) oi.readObject();
    119.                 }
    120.             } catch (Exception e) {
    121.                 e.printStackTrace();
    122.             }
    123.         }).start();*/
    126.         //发送对象
    129.         thread.start();
    130.         repaint();
    132.     }
    134.     //重写paint方法
    135.     public void paint(Graphics g) {
    137.         //首先判断这个双缓冲是否为null
    138.         if (offScreenImage == null) {
    140.             //如果是的话我们为他赋值
    141.             offScreenImage = createImage(1000, 600);
    142.         }
    145.         Graphics graphics = offScreenImage.getGraphics();//绘制
    146.         graphics.fillRect(0, 0, 1000, 600);//对图像进行填充
    147.         //判断游戏模式
    148.         graphics.setColor(Color.BLUE);
    149.         graphics.drawString("开始游戏", 500, 300);
    150.         graphics.setFont(new Font("仿体", Font.BOLD, 100));
    152.         if (state == 1) {
    153.             //绘制背景 执行到这的时候nowBg里面已经存入了图片了
    154.             graphics.drawImage(nowBg.getBgImage(), 0, 0, this);
    157.             //绘制的障碍物
    158.             for (Obstacle ob : nowBg.getObstacleList()) {
    159.                 graphics.drawImage(ob.getShow(), ob.getX(), ob.getY(), this);
    160.             }
    162.             //绘制城堡
    163.             graphics.drawImage(nowBg.getTower(), 620, 270, this);
    165.             //绘制旗杆
    166.             graphics.drawImage(nowBg.getGan(), 500, 220, this);
    168.             //绘制马力
    169.             graphics.drawImage(mario.getShow(), mario.getX(), mario.getY(), this);
    170.             //上面的步骤是将图片已经绘制到缓冲区上了
    172.             //绘制敌人
    173.             for (Enemy enemy : nowBg.getEnemyList()) {
    174.                 graphics.drawImage(enemy.getShow(), enemy.getX(), enemy.getY(), this);
    175.             }
    177.         }
    179.         g.drawImage(offScreenImage, 0, 0, this);
    181.     }
    184.     // 下面我们将图片绘制到窗口中
    187.     @Override
    188.     public void keyTyped(KeyEvent e) {
    190.     }
    192.     //当键盘按下按键时调用
    193.     //这个方法是 当键盘按下某个按键时调用
    194.     @Override
    195.     public void keyPressed(KeyEvent e) {
    196.         //向右移动
    197.         if (e.getKeyCode() == 68) {
    198.             mario.rightMove();
    199.             try {
    200.                 ds = new DatagramSocket();
    201.                 //序列化对象 把对象序列化
    202.                 ByteArrayOutputStream bao = new ByteArrayOutputStream();
    203.                 ObjectOutputStream oos = new ObjectOutputStream(bao);
    204.                 oos.writeObject(marioXY);
    205.                 oos.flush();
    207.                 byte[] sendBuff = bao.toByteArray();
    208.                 dp = new DatagramPacket(sendBuff, sendBuff.length,
    209.                         InetAddress.getLocalHost(), 8787);
    210.                 ds.send(dp);
    211.             } catch (Exception e1) {
    212.                 e1.printStackTrace();
    213.             }
    215.         }
    216.         //向左移动
    217.         if (e.getKeyCode() == 65) {
    218.             mario.leftMove();
    219.         }
    221.         //跳跃
    222.         if (e.getKeyCode() == 87) {
    223.             mario.jump();
    224.         }
    226.         int key = e.getKeyCode();
    227.         switch (key) {
    228.             case KeyEvent.VK_ENTER:
    229.                 state = 1;
    230.                 break;
    231.         }
    234.     }
    237.     //当键盘按下按键时调用
    238.     //这个方法是 当键盘松开某个按键时调用
    239.     @Override
    240.     public void keyReleased(KeyEvent e) {
    241.         //向左停止
    242.         if (e.getKeyCode() == 65) {
    243.             mario.leftStop();
    244.         }
    245.         //向右停止
    246.         if (e.getKeyCode() == 68) {
    247.             mario.rightStop();
    248.         }
    251.     }
    253.     @Override
    254.     public void run() {
    255.         while (true) {
    256.             //重新绘制图像
    257.             repaint();
    258.             try {
    259.                 //线程休眠
    260.                 Thread.sleep(50);
    261.                 //判断马力是否已经走到了最右边
    262.                 if (mario.getX() >= 980) {
    263.                     nowBg = allBg.get(nowBg.getSort());
    264.                     mario.setBackground(nowBg);
    265.                     mario.setX(10);
    266.                     mario.setY(370);
    267.                 }
    269.                 if (mario.getX() <= 0) {
    270.                     nowBg = allBg.get(nowBg.getSort() - 2);
    271.                     mario.setBackground(nowBg);
    272.                     mario.setX(980);
    273.                     mario.setY(370);
    274.                 }
    276.             } catch (Exception e) {
    277.                 e.printStackTrace();
    278.             }
    280.         }
    281.     }
    284.     public static void main(String[] args) {
    285.         MyFrameC m = new MyFrameC();
    286.     }
    288. }

    坐标系类

    1. import java.io.Serializable;
    3. public class MarioXY implements Serializable {
    6.     private int x;
    7.     private int y;
    10.     public MarioXY(){
    12.     }
    14.     public MarioXY(int x, int y ){
    15.         this.x = x;
    16.         this.y = y;
    18.     }
    20.     public int getX() {
    21.         return x;
    22.     }
    24.     public void setX(int x) {
    25.         this.x = x;
    26.     }
    28.     public int getY() {
    29.         return y;
    30.     }
    32.     public void setY(int y) {
    33.         this.y = y;
    34.     }
    35. }

    Mario类

    1. import java.awt.image.BufferedImage;
    3. /*
    4.  *
    5.  * 实现Runnable接口 线程
    6.  * 马力类
    7.  *
    8.  * */
    9. public class Mario implements Runnable {
    10.     //用于表示横纵坐标
    11.     private int x;
    12.     private int y;
    13.     private MarioXY xy;
    16.     //用于表示当前的状态
    17.     private String status;
    19.     //用于显示当前状态对应的图像
    20.     private BufferedImage show = null;
    22.     //定义一个Background对象，用来获取障碍物的信息
    23.     private Background background = new Background();
    25.     //用来实现马力的动作
    26.     private Thread thread = null;
    28.     //马力的移动速度
    29.     private int xSpeed;
    31.     //马力的跳跃速度
    32.     private int ySpeed;
    34.     //定义一个索引,这个变量用于取得马力的运动图像
    35.     private int index;
    37.     //定义一个int变量 表示马力上升的时间 超过一定时间都不能上升了
    38.     private int upTime = 0;
    40.     //马力死亡
    41.     private boolean isDeath = false;
    44.     //坐标
    45.     MarioXY marioXY;
    47.     //用来实现马力奥的动作
    48.     public Mario() {
    50.     }
    52.     public Mario(int x, int y,MarioXY marioXY) {
    53.         //用于表示马力的位置
    54.         this.x = marioXY.getX();
    55.         this.y = marioXY.getY();
    56.         this.marioXY = marioXY;
    57.         //用于表示马力的初始站立样子
    58.         show = StaticValue.stand_R;
    59.         //用于马力当前状态
    60.         this.status = "stand--right";
    61.         //初始化线程
    62.         thread = new Thread(this);
    63.         thread.start();
    65.     }
    68.     //马力死亡的方法
    69.     public void death(){
    70.         isDeath = true;
    71.     }
    73.     //马力向左移动
    74.     public void leftMove() {
    75.         //改变移动速度
    76.         xSpeed = -10;
    78.         //判断马力是否处于空中，由于处于空中无法移动
    79.         //indexOf传入一个值 返回他出现的第一个索引位置
    80.         if (status.indexOf("jump") != -1) {
    81.             status = "jump--left";
    82.         } else {
    83.             status = "move--left";
    84.         }
    85.     }
    87.     //马力向右移动
    88.     public void rightMove() {
    89.         //速度
    90.         xSpeed = 10;
    92.         if (status.indexOf("jump") != -1) {
    93.             status = "jump--right";
    94.         } else {
    95.             status = "move--right";
    96.         }
    97.     }
    99.     //马力向左停止
    100.     public void leftStop() {
    101.         xSpeed = 0;
    102.         if (status.indexOf("jump") != -1) {
    103.             status = "jump--left";
    104.         } else {
    105.             status = "stop--left";
    106.         }
    107.     }
    109.     //马力向右停止
    110.     public void rightStop() {
    111.         xSpeed = 0;
    112.         if (status.indexOf("jump") != -1) {
    113.             status = "jump--right";
    114.         } else {
    115.             status = "stop--right";
    116.         }
    117.     }
    118.     /*垃圾方法
    119.     //马力向上跳跃
    120.     public void jump_up() {
    122.         ySpeed = 10;
    123.         if (status.indexOf("jump" ) != -1) {
    124.             status = "stop-right";
    125.         }else {
    126.             status = "jump--up";
    127.         }
    128.     }
    130.     //马力向右上跳停止
    131.     public void jump_stop(){
    132.         ySpeed = -10;
    133.         if (status.indexOf("jump") != -1){
    134.             status = "right--stop";
    135.         }else {                               垃圾方法
    136.             status = "jump--stop";
    137.         }
    138.     }*/
    140.     //马力攻击
    141.     public void gongji() {
    143.     }
    145.     //马力跳跃
    146.     public void jump() {
    147.         //判断是否是跳跃状态 如果是-1的话就是 此时马力是跳跃状态
    148.         if (status.indexOf("jump") == -1) {
    150.             //判断马力的方向是那边 如果不等于-1的话 此时马力的方向是左
    151.             if (status.indexOf("left") != -1) {
    152.                 status = "jump--left";
    153.             } else {
    154.                 status = "jump--right";
    155.             }
    156.             ySpeed = -10;
    157.             //跳跃的像素高度
    158.             upTime = 10;
    159.         }
    160.     }
    162.     //马力下落
    163.     public void fall() {
    164.         if (status.indexOf("left") != -1) {
    165.             status = "jump--left";
    166.         } else {
    167.             status = "jump--right";
    168.         }
    169.         ySpeed = 10;
    170.     }
    172.     @Override
    173.     public void run() {
    175.         while (true) {
    179.             //判断是否处于障碍物上
    180.             boolean onObstacle = false;
    182.             //判断是否可以往右走
    183.             boolean canRight = true;
    185.             //判断是否可以往左走
    186.             boolean canLeft = true;
    188.             //判断马力是否到达旗杆的位置
    191.             //遍历当前场景里所有的障碍物
    192.             for (int i = 0; i < background.getObstacleList().size(); i++) {
    194.                 Obstacle ob = background.getObstacleList().get(i);
    196.                 //判断马力是否站立于障碍物之上
    197.                 if (ob.getY() == this.y + 30 && (ob.getX() > this.x - 30 && ob.getX() < this.x + 30)) {
    198.                     onObstacle = true;
    199.                 }
    201.                 //判断马力是否跳起来顶到方块
    202.                 if (ob.getY() >= this.y - 30 && (ob.getY() <= this.y - 20) && (ob.getX() > this.x - 30) && ob.getX() < this.x + 30) {
    203.                     if (ob.getType() == 0) {
    204.                         //删除可破坏的砖块
    205.                         background.getObstacleList().remove(ob);
    206.                     }
    207.                     //当顶到砖块的时候 upTime就为0就会直接下落了
    208.                     upTime = 0;
    209.                 }
    211.                 //判断马力是否可以往右走 如果符合这个条件说明马力的右边有障碍物
    212.                 //更改了一下
    213.                 if (ob.getX() == this.x + 30 && (ob.getY() > this.y - 30 && ob.getY() < this.y + 30)) {
    214.                     canRight = false;
    215.                 }
    217.                 //判断是否可以往左边走 如果符合条件就说明马力的左边有障碍物
    218.                 if (ob.getX() == this.x - 30 && (ob.getY() > this.y - 30 && ob.getY() < this.y + 30)) {
    219.                     canLeft = false;
    220.                 }
    222.             }
    224.             //判断马力是否碰到敌人死亡或踩死蘑菇敌人
    225.             for (int i = 0; i < background.getEnemyList().size(); i++) {
    226.                 Enemy e = background.getEnemyList().get(i);
    227.                 if (e.getY() == this.y + 20 && (e.getX() - 25 <= this.x && e.getX() + 35 >= this.x)) {
    228.                     if (e.getType() == 1) {
    229.                         e.death();
    230.                         upTime = 3;
    231.                         ySpeed -= 10;
    232.                     }
    233.                 }
    234.                 if (e.getX() + 35 > this.x && e.getX() - 25 < this.x && (e.getY() + 35 > this.y && e.getY() - 20 < this.y)) {
    235.                     //马力死亡
    236.                     death();
    237.                 }
    239.             }
    242.             //进行马力跳跃的操作
    243.             //判断马力是否在障碍物之上并且upTime=0
    244.             if (onObstacle && upTime == 0) {
    245.                 //判断马力面向的方向是那边 如果是左边就等于-1 否则是右边
    246.                 if (status.indexOf("left") != -1) {
    247.                     //马力是否是移动中
    248.                     if (xSpeed != 0) {
    249.                         //如果xSpeed不等于0就是处于移动状态  向左
    250.                         status = "move--left";
    251.                     } else {
    252.                         //如果xSpeed等于0 就是停止状态   向左
    253.                         status = "stop-left";
    254.                     }
    255.                 } else {
    256.                     //马力是否是移动中
    257.                     if (xSpeed != 0) {
    258.                         //如果xSpeed不等于0就是处于移动状态 向右
    259.                         status = "move--right";
    260.                     } else {
    261.                         //如果xSpeed等于0 就是停止状态   向右
    262.                         status = "stop--right";
    263.                     }
    264.                 }
    265.             } else {
    266.                 //处于上升状态
    267.                 if (upTime != 0) {
    268.                     //自减 当upTime==0的时候就证明他已经上升到了最高点
    269.                     upTime--;
    270.                 } else {
    272.                     //调用fall()方法让他下落
    273.                     fall();
    274.                 }
    277.                 //这里进行了加 Y轴的
    278.                 y += ySpeed;
    279.                 System.out.println();
    281.             }
    283.             if ((canLeft && xSpeed < 0) || (canRight && xSpeed > 0)) {
    284.                 x += xSpeed;
    286.                 //判断马力是否到了屏幕的最左边，就无法再运动了
    287.                 if (x < 0) {
    288.                     x = 0;
    289.                 }
    290.             }
    293.             //判断当前是否是移动状态
    294.             if (status.contains("move")) {
    295.                 //改变图片的索引
    296.                 index = index == 0 ? 1 : 0;
    297.             }
    299.             //判断是否向左移动
    300.             if ("move--left".equals(status)) {
    301.                 show = StaticValue.run_L.get(index);
    302.             }
    303.             //判断是否向右移动
    304.             if ("move--right".equals(status)) {
    305.                 show = StaticValue.run_R.get(index);
    306.             }
    307.             //判断是否向左停止
    308.             if ("stop--left".equals(status)) {
    309.                 show = StaticValue.stand_L;
    310.             }
    311.             //判断是否向左停止
    312.             if ("stop--right".equals(status)) {
    313.                 show = StaticValue.stand_R;
    314.             }
    316.             //判断是否向左跳跃
    317.             if ("jump--left".equals(status)) {
    318.                 show = StaticValue.jump_L;
    319.             }
    321.             //判断是否向右跳跃
    322.             if ("jump--right".equals(status)) {
    323.                 show = StaticValue.jump_R;
    324.             }
    325.             try {
    326.                 Thread.sleep(50);
    327.             } catch (InterruptedException e) {
    328.                 e.printStackTrace();
    329.             }
    330.             //实时给坐标类信息
    331.             marioXY.setX(this.x);
    332.             marioXY.setY(this.y);
    333.         }
    336.     }
    338.     public int getX() {
    339.         return x;
    340.     }
    342.     public int getY() {
    343.         return y;
    344.     }
    346.     public BufferedImage getShow() {
    347.         return show;
    348.     }
    350.     public void setX(int x) {
    351.         this.x = x;
    352.     }
    354.     public void setY(int Y) {
    355.         this.y = Y;
    356.     }
    358.     public void setShow(BufferedImage show) {
    359.         this.show = show;
    360.     }
    362.     public void setBackground(Background background) {
    363.         this.background = background;
    364.     }
    366.     public MarioXY getXy() {
    367.         return xy;
    368.     }
    370.     public void setXy(MarioXY xy) {
    371.         this.xy = xy;
    372.     }
    373. }