1.  package org.crazyit.ball;
  2.  
  3.  import java.awt.Image;
  4.  import java.io.File;
  5.  import javax.imageio.ImageIO;
  6.  import java.io.IOException;
  7.  
  8.  /**
  9.   * 小球对象
  10.   *
  11.   * @author yangenxiong yangenxiong2009@gmail.com
  12.   * @author Kelvin Mak kelvin.mak125@gmail.com
  13.   * @version  1.0
  14.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  15.   * <br>Copyright (C), 2009-2010, yangenxiong
  16.   * <br>This program is protected by copyright laws.
  17.   */
  18.  public class Ball extends BallComponent {
  19.      // 定义球的竖向速度
  20.      private int speedY = 10;
  21.      // 定义弹球的横向速度
  22.      private int speedX = 8;
  23.      // 定义是否在运动
  24.      private boolean started = false;
  25.      // 定义是否结束运动
  26.      private boolean stop = false;
  27.  
  28.      /**
  29.       * m 有参数构造器
  30.       *
  31.       * @param panelWidth
  32.       *            int 画板宽度
  33.       * @param panelHeight
  34.       *            int 画板高度
  35.       * @param offset
  36.       *            int 位移
  37.       * @param path
  38.       *            String 图片路径
  39.       */
  40.      public Ball(int panelWidth, int panelHeight, int offset, String path)
  41.              throws IOException {
  42.          // 调用父构造器
  43.          super(panelWidth, panelHeight, path);
  44.          // 设置y坐标
  45.          this.setY(panelHeight - super.getImage().getHeight(null) - offset);
  46.      }
  47.  
  48.      /**
  49.       * 设置横向速度
  50.       *
  51.       * @param speed
  52.       *            int 速度
  53.       * @return void
  54.       */
  55.      public void setSpeedX(int speed) {
  56.          this.speedX = speed;
  57.      }
  58.  
  59.      /**
  60.       * 设置竖向速度
  61.       *
  62.       * @param speed
  63.       *            int 速度
  64.       * @return void
  65.       */
  66.      public void setSpeedY(int speed) {
  67.          this.speedY = speed;
  68.      }
  69.  
  70.      /**
  71.       * 设置是否在运动
  72.       *
  73.       * @param b
  74.       *            boolean
  75.       * @return void
  76.       */
  77.      public void setStarted(boolean b) {
  78.          this.started = b;
  79.      }
  80.  
  81.      /**
  82.       * 设置是否结束运动
  83.       *
  84.       * @param b
  85.       *            boolean
  86.       * @return void
  87.       */
  88.      public void setStop(boolean b) {
  89.          this.stop = b;
  90.      }
  91.  
  92.      /**
  93.       * 返回横向速度
  94.       *
  95.       * @return int 速度
  96.       */
  97.      public int getSpeedX() {
  98.          return this.speedX;
  99.      }
  100.  
  101.      /**
  102.       * 返回竖向速度
  103.       *
  104.       * @return int 速度
  105.       */
  106.      public int getSpeedY() {
  107.          return this.speedY;
  108.      }
  109.  
  110.      /**
  111.       * 是否在运动
  112.       *
  113.       * @return boolean 是否在运动
  114.       */
  115.      public boolean isStarted() {
  116.          return this.started;
  117.      }
  118.  
  119.      /**
  120.       * 是否已经结束运动
  121.       *
  122.       * @return boolean 是否已经结束运动
  123.       */
  124.      public boolean isStop() {
  125.          return this.stop;
  126.      }
  127.  
  128.  }

Ball

  1.  package org.crazyit.ball;
  2.  
  3.  import java.awt.Image;
  4.  import java.io.File;
  5.  import javax.imageio.ImageIO;
  6.  import java.io.IOException;
  7.  
  8.  /**
  9.   * 桌面弹球游戏相关组件的父类
  10.   *
  11.   * @author yangenxiong yangenxiong2009@gmail.com
  12.   * @author Kelvin Mak kelvin.mak125@gmail.com
  13.   * @version  1.0
  14.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  15.   * <br>Copyright (C), 2009-2010, yangenxiong
  16.   * <br>This program is protected by copyright laws.
  17.   */
  18.  public class BallComponent {
  19.      // 设置x坐标
  20.      private int x = -1;
  21.      // 设置y坐标
  22.      private int y = -1;
  23.      // 设置图片
  24.      private Image image = null;
  25.      // 设置图片速度
  26.      private int speed = 5;
  27.  
  28.      /**
  29.       * 构造器
  30.       *
  31.       * @param path
  32.       *            String 图片路径
  33.       */
  34.      public BallComponent(String path) throws IOException {
  35.          super();
  36.          this.image = ImageIO.read(new File(path));
  37.      }
  38.  
  39.      /**
  40.       * 构造器
  41.       *
  42.       * @param panelWidth
  43.       *            int 画板宽度
  44.       * @param panelHeight
  45.       *            int 画板高度
  46.       * @param path
  47.       *            String 图片路径
  48.       */
  49.      public BallComponent(int panelWidth, int panelHeight, String path)
  50.              throws IOException {
  51.          super();
  52.          // 读取图片
  53.          this.image = ImageIO.read(new File(path));
  54.          // 设置x坐标
  55.          this.x = (int) ((panelWidth - image.getWidth(null)) / 2);
  56.      }
  57.  
  58.      /**
  59.       * 构造器
  60.       *
  61.       * @param x
  62.       *            int 图像的x坐标
  63.       * @param y
  64.       *            int 图像的y坐标
  65.       * @param path
  66.       *            String 图片路径
  67.       */
  68.      public BallComponent(String path, int x, int y) throws IOException {
  69.          super();
  70.          // 读取图片
  71.          this.image = ImageIO.read(new File(path));
  72.          this.x = x;
  73.          this.y = y;
  74.      }
  75.  
  76.      /**
  77.       * 获取x坐标
  78.       *
  79.       * @return int x坐标
  80.       */
  81.      public int getX() {
  82.          return this.x;
  83.      }
  84.  
  85.      /**
  86.       * 获取y坐标
  87.       *
  88.       * @return int y坐标
  89.       */
  90.      public int getY() {
  91.          return this.y;
  92.      }
  93.  
  94.      /**
  95.       * 获取图片速度
  96.       *
  97.       * @return int 图片速度
  98.       */
  99.      public int getSpeed() {
  100.          return this.speed;
  101.      }
  102.  
  103.      /**
  104.       * 设置x坐标
  105.       *
  106.       * @param x
  107.       *            int x坐标
  108.       * @return void
  109.       */
  110.      public void setX(int x) {
  111.          this.x = x;
  112.      }
  113.  
  114.      /**
  115.       * 设置y坐标
  116.       *
  117.       * @param y
  118.       *            int y坐标
  119.       * @return void
  120.       */
  121.      public void setY(int y) {
  122.          this.y = y;
  123.      }
  124.  
  125.      /**
  126.       * 返回图片
  127.       *
  128.       * @return Image 图片
  129.       */
  130.      public Image getImage() {
  131.          return this.image;
  132.      }
  133.  }

BallComponent

  1.  package org.crazyit.ball;
  2.  
  3.  import javax.swing.JFrame;
  4.  import javax.swing.JPanel;
  5.  import javax.swing.Timer;
  6.  import java.awt.Dimension;
  7.  import java.awt.Image;
  8.  import java.awt.Graphics;
  9.  import java.awt.Color;
  10.  import java.awt.event.KeyAdapter;
  11.  import java.awt.event.KeyListener;
  12.  import java.awt.event.KeyEvent;
  13.  import java.awt.event.ActionListener;
  14.  import java.awt.event.ActionEvent;
  15.  import java.io.IOException;
  16.  
  17.  /**
  18.   * 游戏界面
  19.   *
  20.   * @author yangenxiong yangenxiong2009@gmail.com
  21.   * @author Kelvin Mak kelvin.mak125@gmail.com
  22.   * @version  1.0
  23.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  24.   * <br>Copyright (C), 2009-2010, yangenxiong
  25.   * <br>This program is protected by copyright laws.
  26.   */
  27.  public class BallFrame extends JFrame {
  28.      // 定义JPanel的宽度
  29.      private final int BALLPANEL_WIDTH = 307;
  30.      // 定义JPanel的高度
  31.      private final int BALLPANEL_HEIGHT = 400;
  32.      // 定义画板
  33.      private BallPanel ballPanel = null;
  34.      // 定义档板
  35.      // private Image stick = null;
  36.      // 设置档板x坐标
  37.      private int stickX = -1;
  38.      // 创建一个BallService实例
  39.      private BallService service = null;
  40.      // 定义一个timer
  41.      Timer timer = null;
  42.  
  43.      /**
  44.       * 默认构造器
  45.       */
  46.      public BallFrame() throws IOException {
  47.          super();
  48.          // 初始化
  49.          initialize();
  50.      }
  51.  
  52.      /**
  53.       * 初始化界面
  54.       *
  55.       * @return void
  56.       */
  57.      public void initialize() throws IOException {
  58.          // 设置窗口的标题
  59.          this.setTitle("弹球");
  60.          // 设置为不可改变大小
  61.          this.setResizable(false);
  62.          // 设置背景为黑色
  63.          this.setBackground(Color.BLACK);
  64.          // 获取画板
  65.          ballPanel = getBallPanel();
  66.          // 创建BallService实例
  67.          service = new BallService(this, BALLPANEL_WIDTH, BALLPANEL_HEIGHT);
  68.  
  69.          // 定义每0.1秒执行一次监听器
  70.          ActionListener task = new ActionListener() {
  71.              public void actionPerformed(ActionEvent e) {
  72.                  // 开始改变位置
  73.                  service.run();
  74.                  // 刷新画板
  75.                  ballPanel.repaint();
  76.              }
  77.          };
  78.          // 如果timer不为空
  79.          if (timer != null) {
  80.              // 重新开始timer
  81.              timer.restart();
  82.          } else {
  83.              // 新建一个timer
  84.              timer = new Timer(100, task);
  85.              // 开始timer
  86.              timer.start();
  87.          }
  88.  
  89.          this.add(ballPanel);
  90.          // 增加事件监听器
  91.          KeyListener[] klarr = this.getKeyListeners();
  92.          if (klarr.length == 0) {
  93.              // 定义键盘监听适配器
  94.              KeyListener keyAdapter = new KeyAdapter() {
  95.                  public void keyPressed(KeyEvent ke) {
  96.                      // 改变档板的坐标
  97.                      service.setStickPos(ke);
  98.                  }
  99.              };
  100.              this.addKeyListener(keyAdapter);
  101.          }
  102.      }
  103.  
  104.      /**
  105.       * 获取画板
  106.       *
  107.       * @return BallPanel 返回BallPanle
  108.       */
  109.      public BallPanel getBallPanel() {
  110.  
  111.          if (ballPanel == null) {
  112.              // 新建一个画板
  113.              ballPanel = new BallPanel();
  114.              // 设置画板的大小
  115.              ballPanel.setPreferredSize(new Dimension(BALLPANEL_WIDTH,
  116.                      BALLPANEL_HEIGHT));
  117.          }
  118.          return ballPanel;
  119.      }
  120.  
  121.      // 定义一个JPanel内部类来完成画图功能
  122.      public class BallPanel extends JPanel {
  123.          /**
  124.           * 重写void paint( Graphics g )方法
  125.           *
  126.           * @param g
  127.           *            Graphics
  128.           * @return void
  129.           */
  130.          public void paint(Graphics g) {
  131.              // 画图
  132.              service.draw(g);
  133.          }
  134.      }
  135.  
  136.  }

BallFrame

  1.  package org.crazyit.ball;
  2.  
  3.  import java.io.IOException;
  4.  
  5.  import javax.swing.JFrame;
  6.  
  7.  /**
  8.   * 游戏入口类
  9.   *
  10.   * @author yangenxiong yangenxiong2009@gmail.com
  11.   * @author Kelvin Mak kelvin.mak125@gmail.com
  12.   * @version  1.0
  13.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  14.   * <br>Copyright (C), 2009-2010, yangenxiong
  15.   * <br>This program is protected by copyright laws.
  16.   */
  17.  public class BallGame {
  18.      /**
  19.       * 开始游戏
  20.       *
  21.       * @return void
  22.       */
  23.      public static void main(String[] args) throws IOException {
  24.          BallFrame ballFrame = new BallFrame();
  25.          ballFrame.pack();
  26.          ballFrame.setVisible(true);
  27.          ballFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  28.      }
  29.  }

BallGame

  1.  package org.crazyit.ball;
  2.  
  3.  import java.awt.event.KeyEvent;
  4.  import java.awt.Image;
  5.  import java.awt.Graphics;
  6.  import java.io.IOException;
  7.  
  8.  /**
  9.   * 处理游戏逻辑的对象
  10.   *
  11.   * @author yangenxiong yangenxiong2009@gmail.com
  12.   * @author Kelvin Mak kelvin.mak125@gmail.com
  13.   * @version  1.0
  14.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  15.   * <br>Copyright (C), 2009-2010, yangenxiong
  16.   * <br>This program is protected by copyright laws.
  17.   */
  18.  public class BallService {
  19.      // 定义一个Stick(档板)
  20.      private Stick stick = null;
  21.      // 定义一个弹球
  22.      private Ball ball = null;
  23.      // 定义一个游戏结束图片
  24.      private BallComponent gameOver = null;
  25.      // 定义一个赢了游戏的图片
  26.      private BallComponent won = null;
  27.      // 定义一个砖块图片数组
  28.      private Brick[][] bricks = null;
  29.      private int width;
  30.      private int height;
  31.      BallFrame ballFrame = null;
  32.  
  33.      /**
  34.       * 私有空构造器
  35.       */
  36.      private BallService() {
  37.          super();
  38.      }
  39.  
  40.      /**
  41.       *
  42.       * @param frame
  43.       *            JFrame JFrame实例
  44.       * @param width
  45.       *            int 宽
  46.       * @param height
  47.       *            int 高
  48.       * @return BallService
  49.       */
  50.      public BallService(BallFrame frame, int width, int height)
  51.              throws IOException {
  52.          // 初始化变量
  53.          this.width = width;
  54.          this.height = height;
  55.          this.ballFrame = frame;
  56.          // 创建一个Stick(档板)实例
  57.          stick = new Stick(width, height, "img/stick.jpg");
  58.          // 创建一个弹球的实例
  59.          ball = new Ball(width, height, stick.getImage().getHeight(null),
  60.                  "img/ball.gif");
  61.          // 游戏结束图片
  62.          gameOver = new BallComponent("img/over.gif");
  63.          // 赢图片
  64.          won = new BallComponent("img/win.gif");
  65.          // 砖块图片数组
  66.          bricks = createBrickArr("img/brick.gif", 11, 6);
  67.      }
  68.  
  69.      /**
  70.       * run
  71.       *
  72.       * @return void
  73.       */
  74.      public void run() {
  75.          // 弹球坐标改变
  76.          setBallPos();
  77.          // 道具坐标改改变
  78.          setMagicPos();
  79.      }
  80.  
  81.      /**
  82.       * 设置档板图片的位置
  83.       *
  84.       * @param ke
  85.       *            KeyEvent 键盘事件
  86.       * @return void
  87.       */
  88.      public void setStickPos(KeyEvent ke) {
  89.          // 把弹球的运动状态设为true
  90.          ball.setStarted(true);
  91.          // 如果是左方向键
  92.          if (ke.getKeyCode() == KeyEvent.VK_LEFT) {
  93.              if (stick.getX() - stick.SPEED > 0) {
  94.                  // x坐标向左移动
  95.                  stick.setX(stick.getX() - stick.SPEED);
  96.              }
  97.          }
  98.          // 如果是右方向键
  99.          if (ke.getKeyCode() == KeyEvent.VK_RIGHT) {
  100.              if (stick.getX() + stick.SPEED < width - stick.getPreWidth()) {
  101.                  // x坐标向右移动
  102.                  stick.setX(stick.getX() + stick.SPEED);
  103.                  // ballFrame.getBallGame().reStart( ballFrame );
  104.              }
  105.          }
  106.          // 如果是F2键
  107.          if (ke.getKeyCode() == KeyEvent.VK_F2) {
  108.              // 初始化ballFrame
  109.              try {
  110.                  ballFrame.initialize();
  111.              } catch (IOException e) {
  112.                  System.out.println(e.getMessage());
  113.              }
  114.          }
  115.      }
  116.  
  117.      /**
  118.       * 设置小球图片的位置
  119.       *
  120.       * @return void
  121.       */
  122.      public void setBallPos() {
  123.          // 正数的数度
  124.          int absSpeedX = Math.abs(ball.getSpeedX());
  125.          int absSpeedY = Math.abs(ball.getSpeedY());
  126.          // 如果游戏已经开始而且没有结束
  127.          if (ball.isStarted()) {
  128.              // 如果小球碰到左边界
  129.              if (ball.getX() - absSpeedX < 0) {
  130.                  // 重新设置x坐标
  131.                  ball.setX(ball.getImage().getWidth(null));
  132.                  // 把x方向的速度设为反方向
  133.                  ball.setSpeedX(-ball.getSpeedX());
  134.              }
  135.              // 如果小球碰到右边界
  136.              if (ball.getX() + absSpeedX > width
  137.                      - ball.getImage().getWidth(null)) {
  138.                  // 重新设置x坐标
  139.                  ball.setX(width - ball.getImage().getWidth(null) * 2);
  140.                  // 把x方向的速度设为反方向
  141.                  ball.setSpeedX(-ball.getSpeedX());
  142.              }
  143.              // 如果小球碰到上边界
  144.              if (ball.getY() - absSpeedY < 0) {
  145.                  // 重新设置y坐标
  146.                  ball.setY(ball.getImage().getWidth(null));
  147.                  // 把y方向的速度设为反方向
  148.                  ball.setSpeedY(-ball.getSpeedY());
  149.              }
  150.              // 如果小球碰到下边界
  151.              if (ball.getY() + absSpeedY > height
  152.                      - stick.getImage().getHeight(null)) {
  153.                  // 如果小球与档板有碰撞
  154.                  if (isHitStick(ball)) {
  155.                      // 重新设置y坐标
  156.                      ball.setY(height - ball.getImage().getHeight(null) * 2);
  157.                      // 把y方向的速度设为反方向
  158.                      ball.setSpeedY(-ball.getSpeedY());
  159.                  }
  160.              }
  161.              // 与砖块碰撞后的运动
  162.              for (int i = bricks.length - 1; i > -1; i--) {
  163.                  for (int j = bricks[i].length - 1; j > -1; j--) {
  164.                      // 如果小球与砖块有碰撞
  165.                      if (isHitBrick(bricks[i][j])) {
  166.                          if (ball.getSpeedY() > 0) {
  167.                              ball.setSpeedY(-ball.getSpeedY());
  168.                          }
  169.                      }
  170.                  }
  171.              }
  172.              // 结束游戏
  173.              if (ball.getY() > height) {
  174.                  ball.setStop(true);
  175.              }
  176.  
  177.              // 设置x坐标
  178.              ball.setX(ball.getX() - (int) (Math.random() * 2)
  179.                      - ball.getSpeedX());
  180.              // 设置y坐标
  181.              ball.setY(ball.getY() - (int) (Math.random() * 2)
  182.                      - ball.getSpeedY());
  183.          }
  184.      }
  185.  
  186.      /**
  187.       * 小球与砖块是否有碰撞
  188.       *
  189.       * @return boolean
  190.       */
  191.      public boolean isHitBrick(Brick brick) {
  192.          if (brick.isDisable()) {
  193.              return false;
  194.          }
  195.          // ball的圆心x坐标
  196.          double ballX = ball.getX() + ball.getImage().getWidth(null) / 2;
  197.          // ball的圆心y坐标
  198.          double ballY = ball.getY() + ball.getImage().getHeight(null) / 2;
  199.          // brick的中心x坐标
  200.          double brickX = brick.getX() + brick.getImage().getWidth(null) / 2;
  201.          // brick的中心y坐标
  202.          double brickY = brick.getY() + brick.getImage().getHeight(null) / 2;
  203.          // 两个坐标点的距离
  204.          double distance = Math.sqrt(Math.pow(ballX - brickX, 2)
  205.                  + Math.pow(ballY - brickY, 2));
  206.          // 如果两个图形重叠，返回true;
  207.          if (distance < (ball.getImage().getWidth(null) + brick.getImage()
  208.                  .getWidth(null)) / 2) {
  209.              // 使brick无效
  210.              brick.setDisable(true);
  211.              return true;
  212.  
  213.          }
  214.          return false;
  215.      }
  216.  
  217.      /**
  218.       * BallComponent是否与档板有碰撞
  219.       *
  220.       * @param image
  221.       *            BallComponent 图像
  222.       * @return boolean
  223.       */
  224.      public boolean isHitStick(BallComponent bc) {
  225.          // 获取图片对象
  226.          Image tempImage = bc.getImage();
  227.          // 如果与档板有碰撞
  228.          if (bc.getX() + tempImage.getWidth(null) > stick.getX()
  229.                  && bc.getX() < stick.getX() + stick.getPreWidth()
  230.                  && bc.getY() + tempImage.getHeight(null) > stick.getY()) {
  231.              return true;
  232.          }
  233.          return false;
  234.      }
  235.  
  236.      /**
  237.       * 设置道具的位置
  238.       *
  239.       * @return void
  240.       */
  241.      public void setMagicPos() {
  242.          for (int i = 0; i < bricks.length; i++) {
  243.              for (int j = 0; j < bricks[i].length; j++) {
  244.                  // 获取magic
  245.                  Magic magic = bricks[i][j].getMagic();
  246.                  if (magic != null) {
  247.                      // 如果这个brick的状态是无效的
  248.                      if (bricks[i][j].isDisable() && magic.getY() < height) {
  249.                          // 设置magic的y坐标向下增加
  250.                          magic.setY(magic.getY() + magic.getSpeed());
  251.                          // 设置档板的宽度
  252.                          setStickWidth(magic);
  253.  
  254.                      }
  255.                  }
  256.              }
  257.          }
  258.      }
  259.  
  260.      /**
  261.       * 设置档板的长度
  262.       *
  263.       * @param magic
  264.       *            Magic 道具
  265.       * @return void
  266.       */
  267.      public void setStickWidth(Magic magic) {
  268.          if (isHitStick(magic)) {
  269.              // 道具的作用
  270.              magic.magicDo(stick);
  271.          }
  272.      }
  273.  
  274.      /**
  275.       * 判断是否赢了
  276.       *
  277.       * @return boolean
  278.       */
  279.      public boolean isWon() {
  280.          // 如果消了全部砖块，则为赢
  281.          for (int i = 0; i < bricks.length; i++) {
  282.              for (int j = 0; j < bricks[i].length; j++) {
  283.                  if (!bricks[i][j].isDisable()) {
  284.                      return false;
  285.                  }
  286.              }
  287.          }
  288.          return true;
  289.      }
  290.  
  291.      /**
  292.       * 创建一个类型为Brick的数组
  293.       *
  294.       * @param path
  295.       *            String 图像路径
  296.       * @param xSize
  297.       *            int
  298.       * @param ySize
  299.       *            int
  300.       * @return Brick[][]
  301.       */
  302.      public Brick[][] createBrickArr(String path, int xSize, int ySize)
  303.              throws IOException {
  304.          // 创建一个Brick[][]
  305.          Brick[][] bricks = new Brick[xSize][ySize];
  306.          int x = 0;
  307.          int y = 0;
  308.          int random = 0;
  309.          int imageSize = 28;
  310.          boolean isDisable = false;
  311.          // 迭代初始化数组
  312.          for (int i = 0; i < xSize; i++) {
  313.              for (int j = 0; j < ySize; j++) {
  314.                  // 创建一个新的砖块
  315.                  random = (int) (Math.random() * 3);
  316.                  x = i * imageSize;
  317.                  y = j * imageSize;
  318.                  // 一定机率没有砖块
  319.                  isDisable = Math.random() > 0.8 ? true : false;
  320.                  if (isDisable) {
  321.                      random = 0;
  322.                  }
  323.                  Brick brick = new Brick(path, random, x, y);
  324.                  brick.setDisable(isDisable);
  325.                  // 设置x坐标
  326.                  brick.setX(x);
  327.                  // 设置y坐标
  328.                  brick.setY(y);
  329.                  bricks[i][j] = brick;
  330.              }
  331.          }
  332.          return bricks;
  333.      }
  334.  
  335.      /**
  336.       * 画图
  337.       *
  338.       * @param g
  339.       *            Graphics 用来画图的对象
  340.       * @return void
  341.       */
  342.      public void draw(Graphics g) {
  343.          // 如果赢了
  344.          if (isWon()) {
  345.              // 绘制赢的图片
  346.              g.drawImage(won.getImage(), won.getX(), won.getY(), width,
  347.                      height - 10, null);
  348.          } else if (ball.isStop()) {
  349.              // 绘制游戏结束图像
  350.              g.drawImage(gameOver.getImage(), gameOver.getX(), gameOver.getY(),
  351.                      width, height - 10, null);
  352.          } else {
  353.              // 清除原来的图像
  354.              g.clearRect(0, 0, width, height);
  355.              // 绘制档板图像
  356.              g.drawImage(stick.getImage(), stick.getX(), stick.getY(), stick
  357.                      .getPreWidth(), stick.getImage().getHeight(null), null);
  358.              // 绘制弹球图像
  359.              g.drawImage(ball.getImage(), ball.getX(), ball.getY(), null);
  360.              // 迭代绘制砖块图像
  361.              for (int i = 0; i < bricks.length; i++) {
  362.                  for (int j = 0; j < bricks[i].length; j++) {
  363.                      BallComponent magic = bricks[i][j].getMagic();
  364.                      // 如果这个砖块图像对像是有效的
  365.                      if (!bricks[i][j].isDisable()) {
  366.                          // 里面的数字1为砖块图像间的间隙
  367.                          g.drawImage(bricks[i][j].getImage(), bricks[i][j]
  368.                                  .getX(), bricks[i][j].getY(), bricks[i][j]
  369.                                  .getImage().getWidth(null) - 1, bricks[i][j]
  370.                                  .getImage().getHeight(null) - 1, null);
  371.                      } else if (magic != null && magic.getY() < height) {
  372.                          g.drawImage(magic.getImage(), magic.getX(), magic
  373.                                  .getY(), null);
  374.                      }
  375.                  }
  376.              }
  377.          }
  378.      }
  379.  }

BallService

  1.  package org.crazyit.ball;
  2.  
  3.  import java.awt.Image;
  4.  import java.io.IOException;
  5.  
  6.  /**
  7.   * 砖块类
  8.   *
  9.   * @author yangenxiong yangenxiong2009@gmail.com
  10.   * @author Kelvin Mak kelvin.mak125@gmail.com
  11.   * @version  1.0
  12.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  13.   * <br>Copyright (C), 2009-2010, yangenxiong
  14.   * <br>This program is protected by copyright laws.
  15.   */
  16.  public class Brick extends BallComponent {
  17.  
  18.      // 定义道具
  19.      private Magic magic = null;
  20.      // 定义一个boolean变量设置本类是否有效
  21.      private boolean disable = false;
  22.      public static final int MAGIC_LONG_TYPE = 1;
  23.      public static final int MAGIC_SHORT_TYPE = 2;
  24.  
  25.      /**
  26.       * 构造器
  27.       *
  28.       * @return void
  29.       */
  30.      public Brick(String path, int type, int x, int y) throws IOException {
  31.          super(path);
  32.          if (type == Brick.MAGIC_LONG_TYPE) {
  33.              this.magic = new LongMagic("img/long.gif", x, y);
  34.          } else if (type == Brick.MAGIC_SHORT_TYPE) {
  35.              this.magic = new ShortMagic("img/short.gif", x, y);
  36.          }
  37.          if (this.magic != null) {
  38.              this.magic.setX(x);
  39.              this.magic.setY(y);
  40.          }
  41.      }
  42.  
  43.      /**
  44.       * 设置本类有没有效
  45.       *
  46.       * @param disable
  47.       *            boolean
  48.       * @return void
  49.       */
  50.      public void setDisable(boolean disable) {
  51.          this.disable = disable;
  52.      }
  53.  
  54.      /**
  55.       * 查看本类有没有效
  56.       *
  57.       * @return boolean 是否有效
  58.       */
  59.      public boolean isDisable() {
  60.          return this.disable;
  61.      }
  62.  
  63.      /**
  64.       * 获取道具
  65.       *
  66.       * @return String magic
  67.       */
  68.      public Magic getMagic() {
  69.          return this.magic;
  70.      }
  71.  
  72.      /**
  73.       * 设置道具
  74.       *
  75.       * @return String magic
  76.       */
  77.      public void setMagic(Magic magic) {
  78.          this.magic = magic;
  79.      }
  80.  }

Brick

  1.  package org.crazyit.ball;
  2.  
  3.  import java.io.IOException;
  4.  
  5.  /**
  6.   * 道具对象
  7.   *
  8.   * @author yangenxiong yangenxiong2009@gmail.com
  9.   * @author Kelvin Mak kelvin.mak125@gmail.com
  10.   * @version  1.0
  11.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  12.   * <br>Copyright (C), 2009-2010, yangenxiong
  13.   * <br>This program is protected by copyright laws.
  14.   */
  15.  public abstract class Magic extends BallComponent {
  16.      /**
  17.       * 提供给子类调用的构造器
  18.       *
  19.       * @param path
  20.       *            String 文件路径
  21.       * @param x
  22.       *            int x坐标
  23.       * @param y
  24.       *            int y坐标
  25.       */
  26.      public Magic(String path, int x, int y) throws IOException {
  27.          super(path, x, y);
  28.      }
  29.  
  30.      /**
  31.       * 道具的功能
  32.       *
  33.       * @param stitck
  34.       *            Stick
  35.       * @return void
  36.       */
  37.      public abstract void magicDo(Stick stick);
  38.  }

Magic

  1.  package org.crazyit.ball;
  2.  
  3.  import java.io.IOException;
  4.  
  5.  /**
  6.   * 使挡板变长的道具
  7.   *
  8.   * @author yangenxiong yangenxiong2009@gmail.com
  9.   * @author Kelvin Mak kelvin.mak125@gmail.com
  10.   * @version  1.0
  11.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  12.   * <br>Copyright (C), 2009-2010, yangenxiong
  13.   * <br>This program is protected by copyright laws.
  14.   */
  15.  public class LongMagic extends Magic {
  16.      /**
  17.       * 构造器
  18.       *
  19.       * @param path
  20.       *            String 文件路径
  21.       * @param x
  22.       *            int x坐标
  23.       * @param y
  24.       *            int y坐标
  25.       */
  26.      public LongMagic(String path, int x, int y) throws IOException {
  27.          super(path, x, y);
  28.      }
  29.  
  30.      /**
  31.       * 道具的功能 : 档板变长
  32.       *
  33.       * @param stitck
  34.       *            Stick
  35.       * @return void
  36.       */
  37.      public void magicDo(Stick stick) {
  38.          double imageWidth = stick.getImage().getWidth(null);
  39.          // 如果档板没有变长过
  40.          if (stick.getPreWidth() <= imageWidth) {
  41.              // 将档板的长度改为双倍
  42.              stick.setPreWidth((int) (stick.getPreWidth() * 2));
  43.          }
  44.      }
  45.  }

LongMagic

  1.  package org.crazyit.ball;
  2.  
  3.  import java.io.IOException;
  4.  
  5.  /**
  6.   * 使挡板变短的道具
  7.   *
  8.   * @author yangenxiong yangenxiong2009@gmail.com
  9.   * @author Kelvin Mak kelvin.mak125@gmail.com
  10.   * @version  1.0
  11.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  12.   * <br>Copyright (C), 2009-2010, yangenxiong
  13.   * <br>This program is protected by copyright laws.
  14.   */
  15.  public class ShortMagic extends Magic {
  16.      /**
  17.       * 构造器
  18.       *
  19.       * @param path
  20.       *            String 文件路径
  21.       * @param x
  22.       *            int x坐标
  23.       * @param y
  24.       *            int y坐标
  25.       */
  26.      public ShortMagic(String path, int x, int y) throws IOException {
  27.          super(path, x, y);
  28.      }
  29.  
  30.      /**
  31.       * 道具的功能 : 档板变短
  32.       *
  33.       * @param stitck
  34.       *            Stick
  35.       * @return void
  36.       */
  37.      public void magicDo(Stick stick) {
  38.          double imageWidth = stick.getImage().getWidth(null);
  39.          // 如果档板没有变短过
  40.          if (stick.getPreWidth() >= imageWidth) {
  41.              // 将档板的宽度改为一半
  42.              stick.setPreWidth((int) (stick.getPreWidth() * 0.5));
  43.          }
  44.      }
  45.  }

ShortMagic

  1.  package org.crazyit.ball;
  2.  
  3.  import java.io.IOException;
  4.  
  5.  /**
  6.   * 挡板类
  7.   *
  8.   * @author yangenxiong yangenxiong2009@gmail.com
  9.   * @author Kelvin Mak kelvin.mak125@gmail.com
  10.   * @version  1.0
  11.   * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
  12.   * <br>Copyright (C), 2009-2010, yangenxiong
  13.   * <br>This program is protected by copyright laws.
  14.   */
  15.  public class Stick extends BallComponent {
  16.      // 定义档板移动的速度
  17.      public static final int SPEED = 20;
  18.      // 定义档板初始的长度
  19.      private int preWidth = 0;
  20.  
  21.      /**
  22.       * 有参数构造器
  23.       *
  24.       * @param panelWidth
  25.       *            int 画板宽度
  26.       * @param panelHeight
  27.       *            int 画板高度
  28.       * @param path
  29.       *            String 图片路径
  30.       */
  31.      public Stick(int panelWidth, int panelHeight, String path)
  32.              throws IOException {
  33.          // 调用父构造器
  34.          super(panelWidth, panelHeight, path);
  35.          // 设置y坐标
  36.          this.setY(panelHeight - super.getImage().getHeight(null));
  37.          // 设置原本的长度
  38.          this.preWidth = super.getImage().getWidth(null);
  39.      }
  40.  
  41.      /**
  42.       * 获取初始长度
  43.       *
  44.       * @return int 初始长度
  45.       */
  46.      public int getPreWidth() {
  47.          return this.preWidth;
  48.      }
  49.  
  50.      /**
  51.       * 设置初始长度
  52.       *
  53.       * @return void
  54.       */
  55.      public void setPreWidth(int preWidth) {
  56.          this.preWidth = preWidth;
  57.      }
  58.  
  59.  }

Stick

疯狂java实战演义 弹球游戏代码的更多相关文章

  1. Java -- 乒乓球 乒乓弹球游戏

    <疯狂Java讲义> 练习游戏 import java.awt.Canvas; import java.awt.Color; import java.awt.Dimension; impo ...

  2. java实现24点游戏代码

    import java.util.Arrays;import java.util.Scanner; public class Test07 {    public static void main(S ...

  3. 使用 Flutter 与 Firebase 制作 I/O 弹球游戏

    文/ Very Good Ventures 团队,5 月 11 日发表于 Flutter 官方博客 为了今年的 Google I/O 大会,Flutter 团队使用 Flutter 以及 Fireba ...

  4. 《疯狂Java讲义第4版》PDF+代码+课件 电子书pdf 分享

    <疯狂Java讲义(第4版)>是<疯狂Java讲义>的第4版,第4版保持了前3版系统.全面.讲解浅显.细致的特性,全面新增介绍了Java 9的新特性. <疯狂Java讲义 ...

  5. 0038 Java学习笔记-多线程-传统线程间通信、Condition、阻塞队列、《疯狂Java讲义 第三版》进程间通信示例代码存在的一个问题

    调用同步锁的wait().notify().notifyAll()进行线程通信 看这个经典的存取款问题,要求两个线程存款,两个线程取款,账户里有余额的时候只能取款,没余额的时候只能存款,存取款金额相同 ...

  6. java俄罗斯方块游戏代码

    java俄罗斯方块游戏代码: package com; import java.awt.Color; import java.awt.Graphics; import java.awt.event.K ...

  7. 【编程教室】PONG - 100行代码写一个弹球游戏

    大家好,欢迎来到 Crossin的编程教室 ! 今天跟大家讲一讲:如何做游戏 游戏的主题是弹球游戏<PONG>,它是史上第一款街机游戏.因此选它作为我这个游戏开发系列的第一期主题. 游戏引 ...

  8. 《疯狂Java：突破程序员基本功的16课》读书笔记-第二章 对象与内存控制

    Java内存管理分为两个方面:内存分配和内存回收.这里的内存分配特指创建Java对象时JVM为该对象在堆内存中所分配的内存空间.内存回收指的是当该Java对象失去引用,变成垃圾时,JVM的垃圾回收机制 ...

  9. 《疯狂Java：突破程序员基本功的16课》读书笔记-第一章 数组与内存控制

    很早以前就听过李刚老师的疯狂java系列很不错,所以最近找一本拿来拜读,再此做下读书笔记,促进更好的消化. 使用Java数组之前必须先对数组对象进行初始化.当数组的所有元素都被分配了合适的内存空间,并 ...

随机推荐

  1. Android ===smail语法总结

    (转载自 网络)smail 语法总结 http://www.blogjava.net/midea0978/archive/2012/01/04/367847.html Smali背景: Smali,B ...

  2. MongoDB与传统数据库的使用区别——批量插入与批量查询

    我在百X知道上回答问题时经常遇到类似与这样的问题:MongoDB有没有像MySQL一样的ODBC驱动?MongoDB能不能像MySQL一样获取字段名称或类型. 我的回答是:不行,因为MongoDB不是 ...

  3. javaScript的使用

    <script>XXX</ccript>HTML文件插入js的主要方法.这个标签主要有以下的几个属性: 1,charset:可选.表示通过src属性指定的字符集. 2,defe ...

  4. Java之多线程断点下载的实现

    RandomAccessFile类: 此类的实例支持对随机訪问文件的读取和写入.随机訪问文件的行为相似存储在文件系统中的一个大型 byte 数组. 存在指向该隐含数组.光标或索引,称为文件指针.输入操 ...

  5. 第一篇：K-近邻分类算法原理分析与代码实现

    前言 本文介绍机器学习分类算法中的K-近邻算法并给出伪代码与Python代码实现. 算法原理 首先获取训练集中与目标对象距离最近的k个对象,然后再获取这k个对象的分类标签,求出其中出现频数最大的标签. ...

  6. Java基础知识强化之IO流笔记11：递归之递归概述和注意事项

    1. 递归: 方法定义中调用方法本身的现象. e.g: public void show(int n ) { if(n <= 0) { System.exit(0); } System.out. ...

  7. Handler导致内存泄露分析

    (非静态)内部类引起内存泄漏的原因         内部类的实现其实是通过编译器的语法糖(Syntactic sugar)实现的,通过生成相应的子类即以OutClassName$InteriorCla ...

  8. ViewPagerindicator 源码解析

        ViewPagerindicator 源码解析   1. 功能介绍 1.1 ViewPagerIndicator ViewPagerIndicator用于各种基于AndroidSupportL ...

  9. node.js常用的几个模块总结

    /** 一 util *      是 node 里面一个工具模块 ,node 里面几乎所有的模块 都会用到 在这个模块 *  功能: *      1 实现继承 这是主要功能 *      2 实现 ...

  10. 写代码要注意细节，无谓的找前台bug

    <input type="checkbox" name="ckb" value="'+value[0]+'">'真的感觉小细节真 ...