Java游戏开发案例-方块游戏

// Squares.java

import java.awt.*;
import java.awt.event.*;
import java.util.Random;
import javax.swing.*;

public class Squares extends JApplet
{
   private void createGUI ()
   {
       // 设定界面
      getContentPane ().setLayout (new FlowLayout ());

      // 创建游戏板控件：每个单元格有40像素宽，默认绿色，并且在获得焦点时边框是蓝色，
   // 而失去焦点时变为黑色。把控件加到content pane里。
      final GameBoard gb;
      gb = new GameBoard (40, Color.green, Color.blue, Color.black);
      getContentPane ().add (gb);

      // 界面其他部分包括两个按钮，他们会被放到一个panel里以作为整体处理。例如，
      // 如果Applet的宽度变大了，两个按钮（而不是一个按钮）都会向游戏板的右侧对齐。
      JPanel p = new JPanel ();

      // 创建“Change Square Color”按钮并设置为无效。只有游戏进行中可以改变颜色。
    final JButton btnChangeSquareColor = new JButton ("Change Square Color");
      btnChangeSquareColor.setEnabled (false);

      // 建立“Change Square Color”按钮的action事件监听器，点击此按钮，会随机改变
   // 单元格的颜色
      ActionListener al;
      al = new ActionListener ()
           {
               public void actionPerformed (ActionEvent e)
               {
                  Random rnd = new Random ();

                  while (true)
                  {
                      int r = rnd.nextInt (256);
                      int g = rnd.nextInt (256);
                      int b = rnd.nextInt (256);

                      // 不使用所有组成原色（红、绿、蓝）都小于192的颜色，因为那不
                      // 容易和背景的黑色区分出来。
                      if (r < 192 && g < 192 && b < 192)
                          continue;

                      gb.changeSquareColor (new Color (r, g, b));

                      break;
                  }
               }
           };

      btnChangeSquareColor.addActionListener (al);

      p.add (btnChangeSquareColor);

      // 创建“Start”按钮
    final JButton btnStart = new JButton ("Start");

      // 建立“Start”按钮的action事件监听器。点击这个按钮时，它本身会变为无效（没
      // 理由开始一个正在进行的游戏），并使“Change Square Color”按钮有效（游戏进
      // 行时可以改变单元格颜色）。“done”事件监控器则用于在游戏结束时使“Start”按
      // 钮有效，以及使“Change Square Color”按钮无效。
      al = new ActionListener ()
           {
               public void actionPerformed (ActionEvent e)
               {
                  btnStart.setEnabled (false);
                  btnChangeSquareColor.setEnabled (true);

                  gb.start (new GameBoard.DoneListener ()
                            {
                                public void done ()
                                {
                                   btnStart.setEnabled (true);
                                   btnChangeSquareColor.setEnabled (false);
                                }
                            });
               }
           };

      btnStart.addActionListener (al);

      // 通过一个panel把两个按钮添加到content pane里边。
      p.add (btnStart);

      getContentPane ().add (p);

      // 在Java 1.4.0里，如果不设置JApplet为焦点循环根节点、并且新建一个焦点遍历
      // 规则的话，你就没有办法把焦点从一个控件切换到另一个。你可以在以下链接看到相关信
      // 息：http://bugs.sun.com/bugdatabase/view_bug.do;:YfiG?bug_id=4705205 
      if (System.getProperty ("java.version").equals ("1.4.0"))
      {
          setFocusCycleRoot (true);
          setFocusTraversalPolicy (new LayoutFocusTraversalPolicy ());
      }
   }

   public void init ()
   {
      // Sun的Java教程说Swing控件应该在事件处理线程里创建、查询、以及操作。由于大
      // 多数浏览器都不去调用Applet的主如init()的那些主要方法，我们在那个线程里调
      // 用SwingUtilities.invokeAndWait()以保证在事件处理线程里GUI被正确创建。
      // 我们用invokeAndWait()而不是invokeLater()，因为后者会导致在GUI创建之前
      // init()方法会返回；这会造成一些很难跟踪的applet问题。
      try
      {
          SwingUtilities.invokeAndWait (new Runnable ()
                                        {
                                            public void run ()
                                            {
                                               createGUI ();
                                            }
                                        });
      }
      catch (Exception e)
      {
          System.err.println ("Unable to create GUI");
      }
   }
}

class GameBoard extends JPanel
{
   // 游戏状态
   private final static int INITIAL = 0;
   private final static int INPLAY = 1;
   private final static int LOSE = 2;
   private final static int WIN = 3;

   // 边框尺寸
   private final static int BORDER_SIZE = 5;

   // 当前游戏状态
   private int state = INITIAL;

   // 在单元格边框之间的像素宽度
   private int cellSize;

   // 游戏板的宽度（包含边框）
   private int width;

   // 游戏板及消息区的总计高度（包含边框）
   private int height;

   // 每一个单元格的颜色
   private Color squareColor;

   // 在游戏板拥有焦点时的边框颜色
   private Color focusBorderColor;

   // 在游戏板是去焦点时的边框颜色
   private Color nonfocusBorderColor;

   // 游戏板当前的边框颜色
   private Color borderColor;

   // 单元格状态：true代表特定单元格包含一个有颜色的方块（非黑色）
   private boolean [] cells = new boolean [9];

   // 对游戏结束监听器的引用
   private GameBoard.DoneListener dl;

   // 对倒计时的计时器的引用；这个计数器判断玩家时候获胜/失败，并且通知当游戏结束时通
   // 知DoneListener
   private Timer timer;

   // 计时器的计时数字
   private int counter;

   // 游戏板构造函数
   GameBoard (int cellSize, Color squareColor, Color focusBorderColor,
              Color nonfocusBorderColor)
   {
      this.cellSize = cellSize;

      width = 3*cellSize+2+2*BORDER_SIZE;
      height = width + 50;

      setPreferredSize (new Dimension (width, height));

      this.squareColor = squareColor;


      this.focusBorderColor = focusBorderColor;


      this.nonfocusBorderColor = nonfocusBorderColor;

      this.borderColor = nonfocusBorderColor;

      addFocusListener (new FocusListener ()
                        {
                            public void focusGained (FocusEvent e)
                            {
                               borderColor = GameBoard.this.focusBorderColor;

                               repaint ();
                            }

                            public void focusLost (FocusEvent e)
                            {
                               borderColor = GameBoard.this.nonfocusBorderColor;

                               repaint ();
                            }
                        });

      addKeyListener (new KeyAdapter ()
                      {
                          public void keyTyped (KeyEvent e)
                          {
                             if (state != INPLAY)
                               return;

                             char key = e.getKeyChar ();

                             // 如果玩家通过数字小键盘输入，则将输入映射到相应的单
                             // 元格，并对此单元格及其周围的单元格做出相应变动。
                             if (Character.isDigit (key))
                                 switch (key)
                                 {
                                    case '1': GameBoard.this.toggle (6);
                                              break;

                                    case '2': GameBoard.this.toggle (7);
                                              break;

                                    case '3': GameBoard.this.toggle (8);
                                              break;


                                    case '4': GameBoard.this.toggle (3);
                                              break;

                                    case '5': GameBoard.this.toggle (4);
                                              break;

                                    case '6': GameBoard.this.toggle (5);
                                              break;

                                    case '7': GameBoard.this.toggle (0);
                                              break;

                                    case '8': GameBoard.this.toggle (1);
                                              break;

                                    case '9': GameBoard.this.toggle (2);
                                 }
                          }
                      });

      addMouseListener (new MouseAdapter ()
                        {
                            public void mouseClicked (MouseEvent e)
                            {
                               if (state != INPLAY)
                                 return;

                               // 当鼠标点击游戏板时，确保游戏板获得焦点，以便玩家
                               // 使用键盘作为替代输入方法。
                               GameBoard.this.requestFocusInWindow ();

                               // 哪一个单元格被点击？
                               int cell = GameBoard.this.
                                          mouseToCell (e.getX (), e.getY ());

                               // 如果一个单元格被点击（cell != -1），则翻转那个
                               // 单元格及其邻居的颜色。
                               if (cell != -1)
                                   GameBoard.this.toggle (cell);
                            }
                        });

      setFocusable (true);
   }

   // 修改当前单元格的颜色。注意：这个方法被事件处理线程调用
   void changeSquareColor (Color squareColor)
   {
      if (!SwingUtilities.isEventDispatchThread ())
          return;

      this.squareColor = squareColor;
      repaint ();
   }

   // 绘制组件：先画边框，对后画消息
   public void paintComponent (Graphics g)
   {
      // 推荐首先调用父类的paintComponent()
      super.paintComponent (g);

      // 用当前边框颜色绘制四边
      g.setColor (borderColor);
      for (int i = 0; i < BORDER_SIZE; i++)
           g.drawRect (i, i, width-2*i-1, height-2*i-1);

      // 将组件的游戏板画为黑色（除了边框及消息区）
      g.setColor (Color.black);
      g.fillRect (BORDER_SIZE, BORDER_SIZE, width-2*BORDER_SIZE,
                  width-2*BORDER_SIZE);

      // 画游戏板的水平线
      g.setColor (Color.white);
      g.drawLine (BORDER_SIZE, BORDER_SIZE+cellSize,
                  BORDER_SIZE+width-2*BORDER_SIZE-1, BORDER_SIZE+cellSize);

      g.drawLine (BORDER_SIZE, BORDER_SIZE+2*cellSize+1,
                  BORDER_SIZE+width-2*BORDER_SIZE-1, BORDER_SIZE+2*cellSize+1);

      // 画游戏板的垂直线
      g.drawLine (BORDER_SIZE+cellSize, BORDER_SIZE, BORDER_SIZE+cellSize,
                  BORDER_SIZE+width-2*BORDER_SIZE-1);

      g.drawLine (BORDER_SIZE+2*cellSize+1, BORDER_SIZE,
                  BORDER_SIZE+2*cellSize+1, BORDER_SIZE+width-2*BORDER_SIZE-1);

      // 画方格
      g.setColor (squareColor);
      for (int i = 0; i < cells.length; i++)
      {
           if (cells [i])
           {                           
               int x = BORDER_SIZE+(i%3)*(cellSize+1)+3;
               int y = BORDER_SIZE+(i/3)*(cellSize+1)+3;

               int w = cellSize-6;
               int h = w;

               g.fillRect (x, y, w, h);
           }
      }

      // 将消息区画为白色（在游戏板下方，边框之内）
      g.setColor (Color.white);
      g.fillRect (BORDER_SIZE, width-BORDER_SIZE, width-2*BORDER_SIZE,
                  height-width);

      // 如果游戏板不是初始化状态，则打印出相应消息
      if (state != INITIAL)
      {
          g.setColor (Color.black);

          String text;

          switch (state)
          {
             case LOSE:
                  text = "YOU LOSE!";
                  break;

             case WIN:
                  text = "YOU WIN!";

                  break;

             default:
                  text = "" + counter;
          }

          g.drawString (text, (width-g.getFontMetrics ().stringWidth (text))/2,
                        width-BORDER_SIZE+30);
      }
   }

   // 如果游戏不再进行中，则开始一个新游戏。注册游戏结束监听器，并且初始化一个方块颜色
   // 的图案，同时启动一个间隔为1秒的计时器。注意：这个方法将被事件处理线程调用。
   void start (GameBoard.DoneListener dl)
   {
      if (!SwingUtilities.isEventDispatchThread ())
          return;

      if (state == INPLAY)
          return;

      this.dl = dl;

      Random rnd = new Random ();

      while (true)
      {
         for (int i = 0; i < cells.length; i++)
              cells [i] = rnd.nextBoolean ();

         int counter = 0;
         for (int i = 0; i < cells.length; i++)
              if (cells [i])
                  counter++;

         if (counter != 0 && counter != cells.length)
             break;
      }

      ActionListener al;
      al = new ActionListener ()
           {
               public void actionPerformed (ActionEvent e)
               {
                  // 如果玩家赢了，则通知游戏结束监听器
                  if (state == WIN)
                  {
                      timer.stop ();
                      GameBoard.this.dl.done ();
                      return;
                  }

                  // 如果计时器到达0，则玩家输了；通知游戏结束监听器
                  if (--counter == 0)
                  {
                      state = LOSE;
                      timer.stop ();
                      GameBoard.this.dl.done ();
                  }

                  repaint ();
               }
           };

      timer = new Timer (1000, al);

      state = INPLAY;
      counter = 30;
                
      timer.start ();
   }

   // 将鼠标位置映射到单元格编号[0,8]，如果鼠标坐标在任何单元格之外，则返回-1。
   private int mouseToCell (int x, int y)
   {
       // 检查第一列
       if (x >= BORDER_SIZE && x < BORDER_SIZE+cellSize)
       {
           if (y >= BORDER_SIZE && y < BORDER_SIZE+cellSize)
               return 0;

           if (y >= BORDER_SIZE+cellSize+1 && y < BORDER_SIZE+2*cellSize+1)
               return 3;

           if (y >= BORDER_SIZE+2*cellSize+2 && y < BORDER_SIZE+3*cellSize+2)
               return 6;
       }

       // Examine second column.
       // 检查第二列
       if (x >= BORDER_SIZE+cellSize+1 && x < BORDER_SIZE+2*cellSize+1)
       {
           if (y >= BORDER_SIZE && y < BORDER_SIZE+cellSize)
               return 1;

           if (y >= BORDER_SIZE+cellSize+1 && y < BORDER_SIZE+2*cellSize+1)
               return 4;

           if (y >= BORDER_SIZE+2*cellSize+2 && y < BORDER_SIZE+3*cellSize+2)
               return 7;
       }

       // 检查第三列
       if (x >= BORDER_SIZE+2*cellSize+2 && x < BORDER_SIZE+3*cellSize+2)
       {
           if (y >= BORDER_SIZE && y < BORDER_SIZE+cellSize)
               return 2;

           if (y >= BORDER_SIZE+cellSize+1 && y < BORDER_SIZE+2*cellSize+1)
               return 5;

           if (y >= BORDER_SIZE+2*cellSize+2 && y < BORDER_SIZE+3*cellSize+2)
               return 8;
       }

       return -1;
   }

   // 翻转一个单元格及其周围的颜色。文中图1A展示了如下遵循数字键盘布局的单元格映射表：
   // 7 8 9
   // 4 5 6
   // 1 2 3
   //
   // 由于单元格数组从0开始，更容易使用的映射方式如下图所示：
   // 0 1 2
   // 3 4 5
   // 6 7 8
   //
   // 当调用toggle()，调用的代码必须把数字键(1-9)转换为如上所示的索引(0-8)。
   private void toggle (int cell)
   {
      // 切换单元格颜色
      switch (cell)
      {
         case 0: cells [0] = !cells [0];
                 cells [1] = !cells [1];
                 cells [3] = !cells [3];
                 cells [4] = !cells [4];
                 break;

         case 1: cells [0] = !cells [0];
                 cells [1] = !cells [1];
                 cells [2] = !cells [2];
                 break;

         case 2: cells [1] = !cells [1];
                 cells [2] = !cells [2];
                 cells [4] = !cells [4];
                 cells [5] = !cells [5];
                 break;

         case 3: cells [0] = !cells [0];
                 cells [3] = !cells [3];
                 cells [6] = !cells [6];
                 break;

         case 4: cells [0] = !cells [0];
                 cells [2] = !cells [2];
                 cells [4] = !cells [4];
                 cells [6] = !cells [6];
                 cells [8] = !cells [8];
                 break;

         case 5: cells [2] = !cells [2];
                 cells [5] = !cells [5];
                 cells [8] = !cells [8];
                 break;

         case 6: cells [3] = !cells [3];
                 cells [4] = !cells [4];
                 cells [6] = !cells [6];
                 cells [7] = !cells [7];
                 break;

         case 7: cells [6] = !cells [6];
                 cells [7] = !cells [7];
                 cells [8] = !cells [8];
                 break;

         case 8: cells [4] = !cells [4];
                 cells [5] = !cells [5];
                 cells [7] = !cells [7];
                 cells [8] = !cells [8];
      }

      // 检测玩家是否获胜。这段代码放在这儿不和递减计时器及判断玩家是否失败的代码一块儿放到
//start()方法的事件监听器，否则如果玩家碰巧把所有方块都交换成黑色，而又立刻换成了其它颜色，
//结果本来该获胜的玩家却被判输了。这种办法不可取。
      int i;
      for (i = 0; i < cells.length; i++)
           if (cells [i])
               break;

      if (i == cells.length)
          state = WIN;

      // 绘制游戏板，以及单元的颜色
      repaint ();
   }

   // 游戏结束监听器的接口定义。Start()方法接受一个实现此接口的对象作为参数。
   interface DoneListener
   {
      void done ();
   }
}