俄罗斯方块 Java 版

aijuans
浏览: 1548331 次
最近访客更多访客>>

loginboot
taijibamen
pinocao
hejin_sl
博主相关

博客
微博
相册
留言
关于我
文章分类

社区版块

存档分类

2015-01 ( 21)
2014-12 ( 25)
2014-11 ( 13)
更多存档...
   1 package ersblockgamedemo;
   2 
   3 /**
   4  *
   5  * @author jiangnan314
   6  */
   7 import java.applet.Applet;
   8 import java.applet.AudioClip;
   9 import java.awt.*;
  10 import java.awt.event.*;
  11 import java.text.DateFormat;
  12 import java.text.SimpleDateFormat;
  13 import java.util.Date;
  14 import javax.swing.*;
  15 import javax.swing.border.Border;
  16 import javax.swing.border.EtchedBorder;
  17 
  18 /**
  19  * 游戏主类，继承自JFrame类，负责游戏的全局控制。 内含： 1.一个GameCanvas画布类的实例对象，
  20  * 2.一个保存当前活动块（ErsBlock）实例的对象； 3.一个保存当前控制面板（ControlPanel）实例的对象；
  21  */
  22 public class ErsBlocksGame extends JFrame {
  23 
  24     /**
  25      * 每填满一行计多少分
  26      */
  27     public final static int PER_LINE_SCORE = 100;
  28     /**
  29      * 积多少分以后能升级
  30      */
  31     public final static int PER_LEVEL_SCORE = PER_LINE_SCORE * 20;
  32     /**
  33      * 最大级数是10级
  34      */
  35     public final static int MAX_LEVEL = 10;
  36     /**
  37      * 默认级数是2
  38      */
  39     public final static int DEFAULT_LEVEL = 2;
  40     private GameCanvas canvas;
  41     private ErsBlock block;
  42     private FileDialog dialog = new FileDialog(this);
  43     private boolean playing = false;
  44     private AudioClip audioclip;
  45     private ControlPanel ctrlPanel;
  46     private JMenuBar bar = new JMenuBar();
  47     private JMenu mGame = new JMenu(" 游戏"),
  48             mControl = new JMenu(" 控制"),
  49             mWindowStyle = new JMenu("游戏风格"),
  50             mMusic = new JMenu("设置游戏音乐"),
  51             mInfo = new JMenu("帮助");
  52     private JMenuItem miNewGame = new JMenuItem("新游戏"),
  53             miSetBlockColor = new JMenuItem("设置方块颜色..."),
  54             miSetBackColor = new JMenuItem("设置背景颜色..."),
  55             miTurnHarder = new JMenuItem("升高游戏难度"),
  56             miTurnEasier = new JMenuItem("降低游戏难度"),
  57             miExit = new JMenuItem("退出"),
  58             miPlay = new JMenuItem("开始"),
  59             miPause = new JMenuItem("暂停"),
  60             miResume = new JMenuItem("恢复"),
  61             miOpen = new JMenuItem("打开"),
  62             playMusic = new JMenuItem("播放"),
  63             stopMusic = new JMenuItem("停止"),
  64             miStop = new JMenuItem("终止游戏"),
  65             loopMusic = new JMenuItem("循环"),
  66             miAuthor = new JMenuItem("关于本游戏");
  67     private JCheckBoxMenuItem miAsWindows = new JCheckBoxMenuItem("Windows"),
  68             miAsMotif = new JCheckBoxMenuItem("Motif"),
  69             miAsMetal = new JCheckBoxMenuItem("Metal", true);
  70 
  71     /**
  72      * 主游戏类的构造方法
  73      *
  74      * @param title String ,窗口标题
  75      */
  76     public ErsBlocksGame(String title) {
  77         super(title);                                          //设置标题
  78         setSize(328, 405);                                     //设置窗口大小                  
  79         setLocationRelativeTo(null);                             //设置窗口居中
  80 
  81         creatMenu();
  82         Container container = getContentPane();
  83         container.setLayout(new BorderLayout(6, 0));              //设置窗口的布局管理器
  84         canvas = new GameCanvas(20, 15);                          //新建游戏画布
  85         ctrlPanel = new ControlPanel(this);                        //新建控制面板
  86         container.add(canvas, BorderLayout.CENTER);                //左边加上画布
  87         container.add(ctrlPanel, BorderLayout.EAST);               //右边加上控制面板
  88 
  89         addWindowListener(new WindowAdapter() {                    //注册窗口事件。当点击关闭按钮时，结束游戏，系统退出。
  90             @Override
  91             public void windowClosing(WindowEvent we) {
  92                 stopGame();
  93                 System.exit(0);
  94             }
  95         });
  96         addComponentListener(new ComponentAdapter() {
  97             @Override
  98             public void componentResized(ComponentEvent ce) {
  99                 canvas.fanning();
 100             }
 101         });
 102 
 103         setVisible(true);
 104         canvas.fanning();
 105 
 106 
 107     }
 108 
 109     /**
 110      * 让游戏复位
 111      */
 112     public void reset() {                            //画布复位，控制面板复位
 113         ctrlPanel.setPlayButtonEnable(true);
 114         ctrlPanel.setPauseButtonEnable(false);
 115         ctrlPanel.setPauseButtonLabel(true);
 116         ctrlPanel.setStopButtonEnable(false);
 117         ctrlPanel.setTurnLevelDownButtonEnable(true);
 118         ctrlPanel.setTurnLevelUpButtonEnable(true);
 119         miPlay.setEnabled(true);
 120         miPause.setEnabled(false);
 121         miResume.setEnabled(false);
 122         miStop.setEnabled(false);
 123         ctrlPanel.reset();
 124         canvas.reset();
 125     }
 126 
 127     /**
 128      * 判断游戏是否还在进行
 129      *
 130      * @return boolean,true -还在运行，false-已经停止
 131      */
 132     public boolean isPlaying() {
 133         return playing;
 134     }
 135 
 136     /**
 137      * 得到当前活动的块
 138      *
 139      * @return ErsBlock,当前活动块的引用
 140      */
 141     public ErsBlock getCurBlock() {
 142         return block;
 143     }
 144 
 145     /**
 146      * 得到当前画布
 147      *
 148      * @return GameCanvas,当前画布的引用
 149      */
 150     public GameCanvas getCanvas() {
 151         return canvas;
 152     }
 153 
 154     /**
 155      * 开始游戏
 156      */
 157     public void playGame() {
 158         play();
 159         ctrlPanel.setPlayButtonEnable(false);
 160         ctrlPanel.setPauseButtonEnable(true);
 161         ctrlPanel.setPauseButtonLabel(true);
 162         ctrlPanel.setStopButtonEnable(true);
 163         ctrlPanel.setTurnLevelDownButtonEnable(false);
 164         ctrlPanel.setTurnLevelUpButtonEnable(false);
 165         miPlay.setEnabled(false);
 166         miPause.setEnabled(true);
 167         miResume.setEnabled(false);
 168         miStop.setEnabled(true);
 169         miTurnHarder.setEnabled(false);
 170         miTurnEasier.setEnabled(false);
 171         ctrlPanel.requestFocus();              //设置焦点
 172     }
 173 
 174     /**
 175      * 游戏暂停
 176      */
 177     public void pauseGame() {
 178         if (block != null) {
 179             block.pauseMove();
 180         }
 181         ctrlPanel.setPlayButtonEnable(false);
 182         ctrlPanel.setPauseButtonLabel(false);
 183         ctrlPanel.setStopButtonEnable(true);
 184         miPlay.setEnabled(false);
 185         miPause.setEnabled(false);
 186         miResume.setEnabled(true);
 187         miStop.setEnabled(true);
 188     }
 189 
 190     /**
 191      * 让暂停中的游戏继续
 192      */
 193     public void resumeGame() {
 194         if (block != null) {
 195             block.resumeMove();
 196         }
 197         ctrlPanel.setPlayButtonEnable(false);
 198         ctrlPanel.setPauseButtonEnable(true);
 199         ctrlPanel.setPauseButtonLabel(true);
 200         miPause.setEnabled(true);
 201         miResume.setEnabled(false);
 202         ctrlPanel.requestFocus();
 203     }
 204 
 205     /**
 206      * 用户停止游戏
 207      */
 208     public void stopGame() {
 209         playing = false;
 210         if (block != null) {
 211             block.stopMove();
 212         }
 213         ctrlPanel.setPlayButtonEnable(true);
 214         ctrlPanel.setPauseButtonEnable(false);
 215         ctrlPanel.setPauseButtonLabel(true);
 216         ctrlPanel.setStopButtonEnable(false);
 217         ctrlPanel.setTurnLevelDownButtonEnable(true);
 218         ctrlPanel.setTurnLevelUpButtonEnable(true);
 219         miPlay.setEnabled(true);
 220         miPause.setEnabled(false);
 221         miResume.setEnabled(false);
 222         miStop.setEnabled(false);
 223         miTurnHarder.setEnabled(true);
 224         miTurnEasier.setEnabled(true);
 225     }
 226 
 227     public AudioClip getAudioClip() {
 228         return audioclip;
 229     }
 230 
 231     public void setAudioClip(AudioClip clip) {
 232         this.audioclip = clip;
 233     }
 234 
 235     public void playAudio() {
 236         if (audioclip != null) {
 237             audioclip.play();
 238         }
 239     }
 240 
 241     public void loop() {
 242         if (audioclip != null) {
 243             loop();
 244         }
 245     }
 246 
 247     public void stop() {
 248         if (audioclip != null) {
 249             stop();
 250         }
 251     }
 252 
 253     /**
 254      * 得到游戏者设置的难度
 255      *
 256      * @return int ，游戏难度1-MAX_LEVEL
 257      */
 258     public int getLevel() {
 259         return ctrlPanel.getLevel();
 260     }
 261 
 262     /**
 263      * 用户设置游戏难度
 264      *
 265      * @param level int ，游戏难度1-MAX_LEVEL
 266      */
 267     public void setLevel(int level) {
 268         if (level < 11 && level > 0) {
 269             ctrlPanel.setLevel(level);
 270         }
 271     }
 272 
 273     /**
 274      * 得到游戏积分
 275      *
 276      * @return int，积分
 277      */
 278     public int getScore() {
 279         if (canvas != null) {
 280             return canvas.getScore();
 281         }
 282         return 0;
 283     }
 284 
 285     /**
 286      * 得到自上次升级以来的游戏积分，升级以后，此积分清零
 287      *
 288      * @return int,积分
 289      */
 290     public int getScoreForLevelUpdate() {
 291         if (canvas != null) {
 292             return canvas.getScoreForLevelUpdate();
 293         }
 294         return 0;
 295     }
 296 
 297     /**
 298      * 当积分累积到一定数值时，升一次级
 299      *
 300      * @return Boolean，true-update succeed，false-update fail
 301      */
 302     public boolean levelUpdate() {
 303         int curLevel = getLevel();
 304         if (curLevel < MAX_LEVEL) {
 305             setLevel(curLevel + 1);
 306             canvas.resetScoreForLevelUpdate();
 307             return true;
 308         }
 309         return false;
 310     }
 311 
 312     /**
 313      * 游戏开始
 314      */
 315     private void play() {
 316         reset();
 317         playing = true;
 318         Thread thread = new Thread(new Game());
 319         thread.start();
 320     }
 321 
 322     /**
 323      * 报告游戏结束了
 324      */
 325     private void reportGameOver() {
 326         new gameOverDialog(this, "俄罗斯方块", "游戏结束，您的得分为" + canvas.getScore());
 327     }
 328 
 329     /**
 330      * 建立并设置窗口菜单
 331      */
 332     private void creatMenu() {
 333         bar.add(mGame);
 334         bar.add(mControl);
 335         bar.add(mWindowStyle);
 336         bar.add(mMusic);
 337         bar.add(mInfo);
 338         mGame.add(miNewGame);
 339         mGame.addSeparator();
 340         mGame.add(miSetBlockColor);
 341         mGame.add(miSetBackColor);
 342         mGame.addSeparator();
 343         mGame.add(miTurnHarder);
 344         mGame.add(miTurnEasier);
 345         mGame.addSeparator();
 346         mGame.add(miExit);
 347         mControl.add(miPlay);
 348         miPlay.setEnabled(true);
 349         mControl.add(miPause);
 350         miPause.setEnabled(false);
 351         mControl.add(miResume);
 352         miResume.setEnabled(false);
 353         mControl.add(miStop);
 354         miStop.setEnabled(false);
 355         mWindowStyle.add(miAsWindows);
 356         mWindowStyle.add(miAsMotif);
 357         mWindowStyle.add(miAsMetal);
 358         mMusic.add(miOpen);
 359         mMusic.add(playMusic);
 360         mMusic.add(stopMusic);
 361         mMusic.add(loopMusic);
 362         mInfo.add(miAuthor);
 363         setJMenuBar(bar);
 364 
 365         miPause.setAccelerator(KeyStroke.getKeyStroke(
 366                 KeyEvent.VK_P, KeyEvent.CTRL_MASK));
 367         miResume.setAccelerator(KeyStroke.getKeyStroke(
 368                 KeyEvent.VK_R, KeyEvent.CTRL_MASK));
 369 
 370         miNewGame.addActionListener(new ActionListener() {
 371             @Override
 372             public void actionPerformed(ActionEvent e) {
 373                 stopGame();
 374                 reset();
 375                 setLevel(DEFAULT_LEVEL);
 376             }
 377         });
 378         miSetBlockColor.addActionListener(new ActionListener() {
 379             @Override
 380             public void actionPerformed(ActionEvent e) {
 381                 Color newFrontColor =
 382                         JColorChooser.showDialog(ErsBlocksGame.this, "设置方块颜色", canvas.getBlockColor());
 383                 if (newFrontColor != null) {
 384                     canvas.setBlockColor(newFrontColor);
 385                 }
 386             }
 387         });
 388         miSetBackColor.addActionListener(new ActionListener() {
 389             @Override
 390             public void actionPerformed(ActionEvent e) {
 391                 Color newBackColor =
 392                         JColorChooser.showDialog(ErsBlocksGame.this, "设置背景颜色", canvas.getBackgroundColor());
 393                 if (newBackColor != null) {
 394                     canvas.setBackgroundColor(newBackColor);
 395                 }
 396             }
 397         });
 398         miAuthor.addActionListener(new ActionListener() {                        //定义菜单栏"关于"的功能，弹出确认框。
 399             @Override
 400             public void actionPerformed(ActionEvent e) {
 401                 JOptionPane.showMessageDialog(null, "© Copyright 姜楠-张卓\n" + "  All Rights Reserved.", "关于俄罗斯方块 - 2013", 1);
 402             }
 403         });
 404         miTurnHarder.addActionListener(new ActionListener() {
 405             @Override
 406             public void actionPerformed(ActionEvent e) {
 407                 int curLevel = getLevel();
 408                 if (!playing && curLevel < MAX_LEVEL) {
 409                     setLevel(curLevel + 1);
 410                 }
 411             }
 412         });
 413         miTurnEasier.addActionListener(new ActionListener() {
 414             @Override
 415             public void actionPerformed(ActionEvent e) {
 416                 int curLevel = getLevel();
 417                 if (!playing && curLevel > 1) {
 418                     setLevel(curLevel - 1);
 419                 }
 420             }
 421         });
 422         miExit.addActionListener(new ActionListener() {
 423             @Override
 424             public void actionPerformed(ActionEvent e) {
 425                 System.exit(0);
 426             }
 427         });
 428         miPlay.addActionListener(new ActionListener() {
 429             @Override
 430             public void actionPerformed(ActionEvent e) {
 431                 playGame();
 432             }
 433         });
 434         miPause.addActionListener(new ActionListener() {
 435             @Override
 436             public void actionPerformed(ActionEvent e) {
 437                 pauseGame();
 438             }
 439         });
 440         miResume.addActionListener(new ActionListener() {
 441             @Override
 442             public void actionPerformed(ActionEvent e) {
 443                 resumeGame();
 444             }
 445         });
 446         miStop.addActionListener(new ActionListener() {
 447             @Override
 448             public void actionPerformed(ActionEvent e) {
 449                 stopGame();
 450             }
 451         });
 452         miOpen.addActionListener(new ActionListener() {
 453             @Override
 454             public void actionPerformed(ActionEvent e) {
 455                 dialog.setVisible(true);
 456                 if (dialog.getFile() != null) {
 457                     String filename = dialog.getDirectory() + dialog.getFile();
 458                     try {
 459                         setAudioClip(Applet.newAudioClip((new java.io.File(filename)).toURI().toURL()));
 460                         playAudio();
 461                     } catch (Exception ex) {
 462                         ex.printStackTrace();
 463                     }
 464                 }
 465             }
 466         });
 467         playMusic.addActionListener(new ActionListener() {
 468             @Override
 469             public void actionPerformed(ActionEvent e) {
 470                 playAudio();
 471                 playMusic.setEnabled(false);
 472                 stopMusic.setEnabled(true);
 473             }
 474         });
 475         stopMusic.addActionListener(new ActionListener() {
 476             @Override
 477             public void actionPerformed(ActionEvent e) {
 478                 stop();
 479             }
 480         });
 481         loopMusic.addActionListener(new ActionListener() {
 482             @Override
 483             public void actionPerformed(ActionEvent e) {
 484                 loop();
 485             }
 486         });
 487         miAsWindows.addActionListener(new ActionListener() {                    //改变游戏风格，Windows风格，motif风格，metal风格
 488             @Override
 489             public void actionPerformed(ActionEvent ae) {
 490                 String plaf = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
 491                 setWindowStyle(plaf);
 492                 canvas.fanning();                                               //以新的界面风格的重新绘制画布和控制面板
 493                 ctrlPanel.fanning();
 494                 miAsWindows.setState(true);                                     //
 495                 miAsMetal.setState(false);
 496                 miAsMotif.setState(false);
 497             }
 498         });
 499         miAsMotif.addActionListener(new ActionListener() {
 500             @Override
 501             public void actionPerformed(ActionEvent e) {
 502                 String plaf = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
 503                 setWindowStyle(plaf);
 504                 canvas.fanning();
 505                 ctrlPanel.fanning();
 506                 miAsWindows.setState(false);
 507                 miAsMetal.setState(false);
 508                 miAsMotif.setState(true);
 509             }
 510         });
 511         miAsMetal.addActionListener(new ActionListener() {
 512             @Override
 513             public void actionPerformed(ActionEvent e) {
 514                 String plaf = "javax.swing.plaf.metal.MetalLookAndFeel";
 515                 setWindowStyle(plaf);
 516                 canvas.fanning();
 517                 ctrlPanel.fanning();
 518                 miAsWindows.setState(false);
 519                 miAsMetal.setState(true);
 520                 miAsMotif.setState(false);
 521             }
 522         });
 523 
 524 
 525     }
 526 
 527     /**
 528      * 根据字串设置窗口外观
 529      *
 530      * @param plaf String,窗口外观的描述
 531      */
 532     private void setWindowStyle(String plaf) {
 533         try {
 534             UIManager.setLookAndFeel(plaf);
 535             SwingUtilities.updateComponentTreeUI(this);
 536         } catch (Exception e) {
 537         }
 538     }
 539 
 540     /**
 541      * 一轮游戏过程，实现了Runnable接口 一轮游戏是一个大循环，在这个循环中，每隔100毫秒， 检查游戏中的当前块是否已经到底了，如果没有，
 542      * 就继续等待。如果到底了，就看有没有全填满的行， 如果有就删除它，并为游戏者加分，同时随机产生一个 新的当前块人 让它自动落下。
 543      * 当新产生一个块时，先检查画布最顶上的一行是否已经 被占了，如果是，可以判断Game Over 了。
 544      */
 545     private class Game implements Runnable {
 546 
 547         @Override
 548         public void run() {
 549             int col = (int) (Math.random() * (canvas.getCols() - 3));
 550             int style = ErsBlock.STYLES[ (int) (Math.random() * 7)][(int) (Math.random() * 4)];
 551 
 552             while (playing) {
 553                 if (block != null) {   //第一次循环时，block为空
 554                     if (block.isAlive()) {
 555                         try {
 556                             Thread.currentThread().sleep(500);
 557                         } catch (InterruptedException ie) {
 558                             ie.printStackTrace();
 559                         }
 560                         continue;
 561                     }
 562                 }
 563 
 564                 checkFullLine();    //检查是否有全填满的行
 565 
 566                 if (isGameOver()) {
 567                     reportGameOver();
 568                     miPlay.setEnabled(true);
 569                     miPause.setEnabled(false);
 570                     miResume.setEnabled(false);
 571                     miStop.setEnabled(false);
 572                     ctrlPanel.setPlayButtonEnable(true);
 573                     ctrlPanel.setPauseButtonLabel(false);
 574                     ctrlPanel.setStopButtonEnable(false);
 575                     return;
 576                 }
 577 
 578                 block = new ErsBlock(style, -1, col, getLevel(), canvas);
 579                 block.start();
 580 
 581                 col = (int) (Math.random() * (canvas.getCols() - 3));
 582                 style = ErsBlock.STYLES[ (int) (Math.random() * 7)][(int) (Math.random() * 4)];
 583 
 584                 ctrlPanel.setTipStyle(style);
 585             }
 586         }
 587 
 588         //检查画布中是否有全填满的行，如果有就删之
 589         public void checkFullLine() {
 590             for (int i = 0; i < canvas.getRows(); i++) {
 591                 int row = -1;
 592                 boolean fullLineColorBox = true;
 593                 for (int j = 0; j < canvas.getCols(); j++) {
 594                     if (!canvas.getBox(i, j).isColorBox()) {
 595                         fullLineColorBox = false;
 596                         break;
 597                     }
 598                 }
 599                 if (fullLineColorBox) {
 600                     row = i--;
 601                     canvas.removeLine(row);
 602                 }
 603             }
 604         }
 605 
 606         //根据最顶行是否被占，判断游戏是否已经结束了
 607         //@return boolean ，true-游戏结束了，false-游戏未结束
 608         private boolean isGameOver() {
 609             for (int i = 0; i < canvas.getCols(); i++) {
 610                 ErsBox box = canvas.getBox(0, i);
 611                 if (box.isColorBox()) {
 612                     return true;
 613                 }
 614             }
 615             return false;
 616         }
 617     }
 618 
 619     /**
 620      * 定义GameOver对话框。
 621      */
 622     private class gameOverDialog extends JDialog implements ActionListener {
 623 
 624         private JButton againButton, exitButton;
 625         private Border border = new EtchedBorder(EtchedBorder.RAISED, Color.white, new Color(148, 145, 140));
 626 
 627         public gameOverDialog(JFrame parent, String title, String message) {
 628             super(parent, title, true);
 629             if (parent != null) {
 630                 setSize(240, 120);
 631                 this.setLocationRelativeTo(parent);
 632                 JPanel messagePanel = new JPanel();
 633                 messagePanel.add(new JLabel(message));
 634                 messagePanel.setBorder(border);
 635                 Container container = this.getContentPane();
 636                 container.setLayout(new GridLayout(2, 0, 0, 10));
 637                 container.add(messagePanel);
 638                 JPanel choosePanel = new JPanel();
 639                 choosePanel.setLayout(new GridLayout(0, 2, 4, 0));
 640                 container.add(choosePanel);
 641                 againButton = new JButton("再玩一局");
 642                 exitButton = new JButton("退出游戏");
 643                 choosePanel.add(new JPanel().add(againButton));
 644                 choosePanel.add(new JPanel().add(exitButton));
 645                 choosePanel.setBorder(border);
 646             }
 647             againButton.addActionListener(this);
 648             exitButton.addActionListener(this);
 649             this.setVisible(true);
 650         }
 651 
 652         @Override
 653         public void actionPerformed(ActionEvent e) {
 654             if (e.getSource() == againButton) {
 655                 this.setVisible(false);
 656                 reset();
 657             } else if (e.getSource() == exitButton) {
 658                 stopGame();
 659                 System.exit(0);
 660 
 661             }
 662         }
 663     }
 664 
 665     /**
 666      * 程序入口函数
 667      *
 668      * @param args String[],附带的命令行参数
 669      */
 670     public static void main(String[] args) {
 671         new ErsBlocksGame("俄罗斯方块：ZJUT-CS&T");
 672     }
 673 }
 674 
 675 /**
 676  * 画布类，内有<行数>*<列数> 个方格类实例。 继承自JPanel类。 ErsBlock线程类动态改变画布类的方格颜色，画布类通过
 677  * 检查方格颜色来体现ErsBlock块的移动情况。
 678  */
 679 class GameCanvas extends JPanel {
 680 
 681     private Color backColor = Color.LIGHT_GRAY, frontColor = Color.orange;
 682     private int rows, cols, score = 0, scoreForLevelUpdate = 0;
 683     private ErsBox[][] boxes;
 684     private int boxWidth, boxHeight;
 685 
 686     /**
 687      * 画布类的构造函数
 688      *
 689      * @param rows int,画布的行数
 690      * @param cols int,画布的列数 行数和列数决定着画布拥有方格的数目
 691      */
 692     public GameCanvas(int rows, int cols) {
 693         this.rows = rows;
 694         this.cols = cols;
 695 
 696         boxes = new ErsBox[rows][cols];
 697         for (int i = 0; i < boxes.length; i++) {
 698             for (int j = 0; j < boxes[i].length; j++) {
 699                 boxes[i][j] = new ErsBox(false);
 700             }
 701         }
 702 
 703         setBorder(new EtchedBorder(EtchedBorder.RAISED, Color.white, new Color(148, 145, 140)));
 704     }
 705 
 706     /**
 707      * 画布类的构造函数
 708      *
 709      * @param rows
 710      * @param cols
 711      * @param backColor
 712      * @param frontColor
 713      */
 714     public GameCanvas(int rows, int cols,
 715             Color backColor, Color frontColor) {
 716         this(rows, cols);
 717         this.backColor = backColor;
 718         this.frontColor = frontColor;
 719     }
 720 
 721     /**
 722      * 设置游戏背景色彩
 723      *
 724      * @param backColor Color，背景色彩
 725      */
 726     public void setBackgroundColor(Color backColor) {
 727         this.backColor = backColor;
 728     }
 729 
 730     /**
 731      * 取得游戏背景色彩
 732      *
 733      * @return Color ,背景色彩
 734      */
 735     public Color getBackgroundColor() {
 736         return backColor;
 737     }
 738 
 739     /**
 740      * 设置游戏方块颜色
 741      *
 742      * @param frontColor Color，方块颜色
 743      */
 744     public void setBlockColor(Color frontColor) {
 745         this.frontColor = frontColor;
 746     }
 747 
 748     /**
 749      * 取得游戏方块色彩
 750      *
 751      * @return Color,方块颜色
 752      */
 753     public Color getBlockColor() {
 754         return frontColor;
 755     }
 756 
 757     /**
 758      * 取得画布中方格的列数
 759      *
 760      * @return
 761      */
 762     public int getRows() {
 763         return rows;
 764     }
 765 
 766     /**
 767      * 取得画布中方格的行数
 768      *
 769      * @return int,方格的行数
 770      */
 771     public int getCols() {
 772         return cols;
 773     }
 774 
 775     /**
 776      * 取得游戏成绩
 777      *
 778      * @return int, 分数
 779      */
 780     public int getScore() {
 781         return score;
 782     }
 783 
 784     /**
 785      * 取得自上一次升级后的积分
 786      *
 787      * @return int ,上一次升级后的积分
 788      */
 789     public int getScoreForLevelUpdate() {
 790         return scoreForLevelUpdate;
 791     }
 792 
 793     /**
 794      * 升级后，将上一次升级以来的积分清零
 795      */
 796     public void resetScoreForLevelUpdate() {
 797         scoreForLevelUpdate -= ErsBlocksGame.PER_LEVEL_SCORE;
 798     }
 799 
 800     /**
 801      * 得到某一行某一列的方格引用
 802      *
 803      * @return row int ,要引用的方格所在的行
 804      * @param col int, 要引用的方格所在的行
 805      * @return ErsBox,在row行col列的方格的引用
 806      */
 807     public ErsBox getBox(int row, int col) {
 808         if (row < 0 || row > boxes.length - 1 || col < 0 || col > boxes[0].length - 1) {
 809             return null;
 810         }
 811         return (boxes[row][col]);
 812     }
 813 
 814     /**
 815      * 覆盖JComponent类的函数，画组件。
 816      *
 817      * @param g 图形设备环境
 818      */
 819     @Override
 820     public void paintComponent(Graphics g) {
 821         super.paintComponent(g);
 822 
 823         g.setColor(frontColor);
 824         for (int i = 0; i < boxes.length; i++) {
 825             for (int j = 0; j < boxes[i].length; j++) {
 826                 g.setColor(boxes[i][j].isColorBox() ? frontColor : backColor);
 827                 g.fill3DRect(j * boxWidth, i * boxHeight,
 828                         boxWidth, boxHeight, true);
 829             }
 830         }
 831     }
 832 
 833     /**
 834      * 根据窗口大小，自动调节方格的尺寸
 835      */
 836     public void fanning() {
 837         boxWidth = getSize().width / cols;
 838         boxHeight = getSize().height / rows;
 839     }
 840 
 841     /**
 842      * 当一行被游戏者叠满后，将此行清除，并为游戏者加分
 843      *
 844      * @param row int，要清除的行，是由ErsBoxesGame类计算的
 845      */
 846     public synchronized void removeLine(int row) {
 847         for (int i = row; i > 0; i--) {
 848             for (int j = 0; j < cols; j++) {
 849                 boxes[i][j] = (ErsBox) boxes[i - 1][j].clone();                 //将上一行的方块颜色克隆下来，
 850             }                                                                   //即消去一行方块
 851         }
 852 
 853         score += ErsBlocksGame.PER_LEVEL_SCORE;
 854         scoreForLevelUpdate += ErsBlocksGame.PER_LEVEL_SCORE;
 855         repaint();
 856     }
 857 
 858     /**
 859      * 重置画布，置积分为零
 860      */
 861     public void reset() {
 862         score = 0;
 863         scoreForLevelUpdate = 0;
 864         for (int i = 0; i < boxes.length; i++) {
 865             for (int j = 0; j < boxes[i].length; j++) {
 866                 boxes[i][j].setColor(false);
 867             }
 868         }
 869 
 870         repaint();
 871     }
 872 }
 873 
 874 /**
 875  * 方格类，是组成块的基本元素，用自己的颜色来表示块的外观
 876  */
 877 class ErsBox implements Cloneable {
 878 
 879     private boolean isColor;
 880     private Dimension size = new Dimension();
 881 
 882     /**
 883      * 方格类的构造函数，
 884      *
 885      * @param isColor 是不是用前景色来为此方格着色 true前景色，false 用背景色
 886      */
 887     public ErsBox(boolean isColor) {
 888         this.isColor = isColor;
 889     }
 890 
 891     /**
 892      * 此方格是不是用前景色表现
 893      *
 894      * @return boolean ，true用前景色表现，false 用背景色表现
 895      */
 896     public boolean isColorBox() {
 897         return isColor;
 898     }
 899 
 900     /**
 901      * 设置方格的颜色，
 902      *
 903      * @param isColor boolean ，true用前景色表现，false 用背景色表现
 904      */
 905     public void setColor(boolean isColor) {
 906         this.isColor = isColor;
 907     }
 908 
 909     /**
 910      * 得到此方格的尺寸
 911      *
 912      * @return Dimension ，方格的尺寸
 913      */
 914     public Dimension getSize() {
 915         return size;
 916     }
 917 
 918     /**
 919      * 设置方格的尺寸，
 920      *
 921      * @param size Dimension ,方格的尺寸
 922      */
 923     public void setSize(Dimension size) {
 924         this.size = size;
 925     }
 926 
 927     /**
 928      * 覆盖Object的Object clone(),实现克隆
 929      *
 930      * @return Object，克隆的结果
 931      */
 932     @Override
 933     public Object clone() {
 934         Object cloned = null;
 935         try {
 936             cloned = super.clone();
 937         } catch (Exception ex) {
 938             ex.printStackTrace();
 939         }
 940 
 941         return cloned;
 942     }
 943 }
 944 
 945 /**
 946  * 块类，继承自线程类（Thread） 由4 × 4个方块（ErsBox）构成一个方块， 控制块的移动·下落·变形等
 947  */
 948 class ErsBlock extends Thread {
 949 
 950     /**
 951      * 一个块占的行数是4行
 952      */
 953     public final static int BOXES_ROWS = 4;
 954     /**
 955      * 一个块占的列数是4列
 956      */
 957     public final static int BOXES_COLS = 4;
 958     /**
 959      * 让升级变化平滑的因子，避免最后几级之间的速度相差近一倍
 960      */
 961     public final static int LEVEL_FLATNESS_GENE = 3;
 962     /**
 963      * 相近的两级之间，块每下落一行的时间差别为多少（毫秒）
 964      */
 965     public final static int BETWEEN_LEVELS_DEGRESS_TIME = 50;
 966     /**
 967      * 方块的样式数目为7
 968      */
 969     public final static int BLOCK_KIND_NUMBER = 7;
 970     /**
 971      * 每一个样式的方块的反转状态种类为4
 972      */
 973     public final static int BLOCK_STATUS_NUMBER = 4;
 974     /**
 975      * 分别对应7种模型的28种状态
 976      */
 977     public final static int[][] STYLES = { //共28种状态
 978         {0x0f00, 0x4444, 0x0f00, 0x4444}, //长条型的四种状态
 979         {0x04e0, 0x0464, 0x00e4, 0x04c4}, //T型的四种状态
 980         {0x4620, 0x6c00, 0x4620, 0x6c00}, //反Z型的四种状态
 981         {0x2640, 0xc600, 0x2640, 0xc600}, //Z型的四种状态
 982         {0x6220, 0x1700, 0x2230, 0x0740}, //7型的四种状态
 983         {0x6440, 0x0e20, 0x44c0, 0x8e00}, //反7型的四种状态   
 984         {0x0660, 0x0660, 0x0660, 0x0660}, //方块的四种状态
 985     };
 986     private GameCanvas canvas;
 987     private ErsBox[][] boxes = new ErsBox[BOXES_ROWS][BOXES_COLS];
 988     private int style, y, x, level;
 989     private boolean pausing = false, moving = true;
 990 
 991     /**
 992      * 构造函数，产生一个特定的块
 993      *
 994      * @param style 块的样式，对应STYLES的28个值中的一个
 995      * @param y 起始位置，左上角在canvas中的坐标行
 996      * @param x 起始位置，左上角在canvas中的坐标lie
 997      * @param level 游戏等级，控制块的下落速度
 998      * @param canvas 画板
 999      */
1000     public ErsBlock(int style, int y, int x, int level, GameCanvas canvas) {
1001         this.style = style;
1002         this.y = y;
1003         this.x = x;
1004         this.level = level;
1005         this.canvas = canvas;
1006 
1007         int key = 0x8000;
1008         for (int i = 0; i < boxes.length; i++) {
1009             for (int j = 0; j < boxes[i].length; j++) {
1010                 boolean isColor = ((style & key) != 0);
1011                 boxes[i][j] = new ErsBox(isColor);
1012                 key >>= 1;
1013             }
1014         }
1015 
1016         display();
1017     }
1018 
1019     /**
1020      * 线程类的run()函数覆盖，下落块，直到块不能再下落
1021      */
1022     @Override
1023     public void run() {
1024         while (moving) {
1025             try {
1026                 sleep(BETWEEN_LEVELS_DEGRESS_TIME
1027                         * (ErsBlocksGame.MAX_LEVEL - level + LEVEL_FLATNESS_GENE));
1028             } catch (InterruptedException ie) {
1029                 ie.printStackTrace();
1030             }
1031             //后边的moving是表示在等待的100毫秒间，moving没有被改变
1032             if (!pausing) {
1033                 moving = (moveTo(y + 1, x) && moving);
1034             }
1035         }
1036     }
1037 
1038     /**
1039      * 块向左移动一格
1040      */
1041     public void moveLeft() {
1042         moveTo(y, x - 1);
1043     }
1044 
1045     /**
1046      * 块向右移动一格
1047      */
1048     public void moveRight() {
1049         moveTo(y, x + 1);
1050     }
1051 
1052     /**
1053      * 块向下移动一格
1054      */
1055     public void moveDown() {
1056         moveTo(y + 1, x);
1057     }
1058 
1059     /**
1060      * 块变型
1061      */
1062     public void turnNext() {
1063         for (int i = 0; i < BLOCK_KIND_NUMBER; i++) {
1064             for (int j = 0; j < BLOCK_STATUS_NUMBER; j++) {
1065                 if (STYLES[i][j] == style) {
1066                     int newStyle = STYLES[i][(j + 1) % BLOCK_STATUS_NUMBER];
1067                     turnTo(newStyle);
1068                     return;
1069                 }
1070             }
1071         }
1072     }
1073 
1074     public void startMove() {
1075         pausing = false;
1076         moving = true;
1077     }
1078 
1079     /**
1080      * 暂停块的下落，对应游戏暂停
1081      */
1082     public void pauseMove() {
1083         pausing = true;
1084         //   moving = false;
1085     }
1086 
1087     /**
1088      * 继续块的下落，对应游戏继续
1089      */
1090     public void resumeMove() {
1091         pausing = false;
1092         moving = true;
1093     }
1094 
1095     /**
1096      * 停止块的下落，对应游戏停止
1097      */
1098     public void stopMove() {
1099         pausing = false;
1100         moving = false;
1101     }
1102 
1103     /**
1104      * 将当前块从画布的对应位置移除，要等到下次重画画布时才能反映出来
1105      */
1106     private void erase() {
1107         for (int i = 0; i < boxes.length; i++) {
1108             for (int j = 0; j < boxes[i].length; j++) {
1109                 if (boxes[i][j].isColorBox()) {
1110                     ErsBox box = canvas.getBox(i + y, j + x);
1111                     if (box == null) {
1112                         continue;
1113                     }
1114                     box.setColor(false);
1115                 }
1116             }
1117         }
1118     }
1119 
1120     /**
1121      * 让当前块放置在画布的对因位置上，要等到下次重画画布时才能看见
1122      */
1123     private void display() {
1124         for (int i = 0; i < boxes.length; i++) {
1125             for (int j = 0; j < boxes[i].length; j++) {
1126                 if (boxes[i][j].isColorBox()) {
1127                     ErsBox box = canvas.getBox(i + y, j + x);
1128                     if (box == null) {
1129                         continue;
1130                     }
1131                     box.setColor(true);
1132                 }
1133             }
1134         }
1135     }
1136 
1137     /**
1138      * 当前块能否移动到newRow/newCol 所指定的位置
1139      *
1140      * @param newRow int,目的地所在行
1141      * @param newCol int，目的地所在列
1142      * @return boolean，true-能移动，false-不能移动
1143      */
1144     public boolean isMoveAble(int newRow, int newCol) {
1145         erase();
1146         for (int i = 0; i < boxes.length; i++) {
1147             for (int j = 0; j < boxes[i].length; j++) {
1148                 if (boxes[i][j].isColorBox()) {
1149                     ErsBox box = canvas.getBox(i + newRow, j + newCol);
1150                     if (box == null || (box.isColorBox())) {
1151                         display();
1152                         return false;
1153                     }
1154                 }
1155             }
1156         }
1157         display();
1158         return true;
1159     }
1160 
1161     /**
1162      * 将当前块移动到newRow/newCol 所指定的位置
1163      *
1164      * @param newRow int,目的地所在行
1165      * @param newCol int，目的地所在列
1166      * @return boolean，true-移动成功，false-移动失败
1167      */
1168     private synchronized boolean moveTo(int newRow, int newCol) {
1169         if (!isMoveAble(newRow, newCol) || !moving) {
1170             return false;
1171         }
1172 
1173         erase();
1174         y = newRow;
1175         x = newCol;
1176 
1177         display();
1178         canvas.repaint();
1179 
1180         return true;
1181     }
1182 
1183     /**
1184      * 当前块能否变成newStyle所指定的块样式，主要是考虑 边界以及被其他块挡住，不能移动的情况
1185      *
1186      * @param newSytle int，希望改变的块样式，对应STYLES的28个值中的一个
1187      * @return boolean，true-能改变，false-不能改变
1188      */
1189     private boolean isTurnAble(int newStyle) {
1190         int key = 0x8000;
1191         erase();
1192         for (int i = 0; i < boxes.length; i++) {
1193             for (int j = 0; j < boxes[i].length; j++) {
1194                 if ((newStyle & key) != 0) {
1195                     ErsBox box = canvas.getBox(i + y, j + x);
1196                     if (box == null || (box.isColorBox())) {
1197                         display();
1198                         return false;
1199                     }
1200                 }
1201                 key >>= 1;
1202             }
1203         }
1204         display();
1205         return true;
1206     }
1207 
1208     /**
1209      * 将当前块变成newStyle所指定的块样式
1210      *
1211      * @param newStyle int，希望改变的块样式，对应STYLES的28个值中的一个
1212      * @return true-改变成功，false-改变失败
1213      */
1214     private boolean turnTo(int newStyle) {
1215         if (!isTurnAble(newStyle) || !moving) {
1216             return false;
1217         }
1218 
1219         erase();
1220         int key = 0x8000;
1221         for (int i = 0; i < boxes.length; i++) {
1222             for (int j = 0; j < boxes[i].length; j++) {
1223                 boolean isColor = ((newStyle & key) != 0);
1224                 boxes[i][j].setColor(isColor);
1225                 key >>= 1;
1226             }
1227         }
1228         style = newStyle;
1229 
1230         display();
1231         canvas.repaint();
1232 
1233         return true;
1234     }
1235 }
1236 
1237 /**
1238  * 控制面板类，继承自JPanel。 上边安放预显窗口，等级，得分，控制按钮 主要用来控制游戏进程。
1239  */
1240 class ControlPanel extends JPanel {
1241 
1242     private JTextField tfLevel = new JTextField("" + ErsBlocksGame.DEFAULT_LEVEL),
1243             tfScore = new JTextField(" 0"),
1244             tfTime = new JTextField(" ");
1245     private JButton btPlay = new JButton(" 开始"),
1246             btPause = new JButton(" 暂停"),
1247             btStop = new JButton("终止游戏"),
1248             btTurnLevelUp = new JButton(" 增加难度"),
1249             btTurnLevelDown = new JButton(" 降低难度");
1250     private JPanel plTip = new JPanel(new BorderLayout());
1251     private TipPanel plTipBlock = new TipPanel();
1252     private JPanel plInfo = new JPanel(new GridLayout(4, 1));
1253     private JPanel plButton = new JPanel(new GridLayout(6, 1));
1254     private Timer timer;
1255     private ErsBlocksGame game;
1256     private Border border = new EtchedBorder(EtchedBorder.RAISED, Color.white, new Color(148, 145, 140));
1257 
1258     /**
1259      * 控制面板类的构造函数
1260      *
1261      * @param game ErsBlocksGame,ErsBlocksGame 类的一个实例引用 方便直接控制ErsBlocksGame类的行为。
1262      */
1263     public ControlPanel(final ErsBlocksGame game) {
1264         setLayout(new GridLayout(3, 1, 0, 2));
1265         this.game = game;
1266 
1267         plTip.add(new JLabel(" 下一个方块"), BorderLayout.NORTH);               //添加组件
1268         plTip.add(plTipBlock);
1269         plTip.setBorder(border);
1270 
1271         plInfo.add(new JLabel(" 难度系数"));
1272         plInfo.add(tfLevel);
1273         plInfo.add(new JLabel(" 得分"));
1274         plInfo.add(tfScore);
1275         plInfo.setBorder(border);
1276 
1277         plButton.add(btPlay);
1278         btPlay.setEnabled(true);
1279         plButton.add(btPause);
1280         btPause.setEnabled(false);
1281         plButton.add(btStop);
1282         btStop.setEnabled(false);
1283         plButton.add(btTurnLevelUp);
1284         plButton.add(btTurnLevelDown);
1285         plButton.add(tfTime);
1286         plButton.setBorder(border);
1287 
1288         tfLevel.setEditable(false);
1289         tfScore.setEditable(false);
1290         tfTime.setEditable(false);
1291 
1292         add(plTip);
1293         add(plInfo);
1294         add(plButton);
1295 
1296         addKeyListener(new KeyAdapter() {
1297             @Override
1298             public void keyPressed(KeyEvent ke) {
1299                 if (!game.isPlaying()) {
1300                     return;
1301                 }
1302 
1303                 ErsBlock block = game.getCurBlock();
1304                 switch (ke.getKeyCode()) {
1305                     case KeyEvent.VK_DOWN:
1306                         block.moveDown();
1307                         break;
1308                     case KeyEvent.VK_LEFT:
1309                         block.moveLeft();
1310                         break;
1311                     case KeyEvent.VK_RIGHT:
1312                         block.moveRight();
1313                         break;
1314                     case KeyEvent.VK_UP:
1315                         block.turnNext();
1316                         break;
1317                     default:
1318                         break;
1319                 }
1320             }
1321         });
1322 
1323         btPlay.addActionListener(new ActionListener() {                         //开始游戏
1324             @Override
1325             public void actionPerformed(ActionEvent ae) {
1326                 game.playGame();
1327             }
1328         });
1329         btPause.addActionListener(new ActionListener() {                        //暂停游戏
1330             @Override
1331             public void actionPerformed(ActionEvent ae) {
1332                 if (btPause.getText().equals(" 暂停")) {
1333                     game.pauseGame();
1334                 } else {
1335                     game.resumeGame();
1336                 }
1337             }
1338         });
1339         btStop.addActionListener(new ActionListener() {                         //停止游戏
1340             @Override
1341             public void actionPerformed(ActionEvent ae) {
1342                 game.stopGame();
1343             }
1344         });
1345         btTurnLevelUp.addActionListener(new ActionListener() {                  //升高难度
1346             @Override
1347             public void actionPerformed(ActionEvent ae) {
1348                 try {
1349                     int level = Integer.parseInt(tfLevel.getText());
1350                     if (level < ErsBlocksGame.MAX_LEVEL) {
1351                         tfLevel.setText("" + (level + 1));
1352                     }
1353                 } catch (NumberFormatException e) {
1354                 }
1355                 requestFocus();
1356             }
1357         });
1358         btTurnLevelDown.addActionListener(new ActionListener() {                //降低游戏难度
1359             @Override
1360             public void actionPerformed(ActionEvent ae) {
1361                 try {
1362                     int level = Integer.parseInt(tfLevel.getText());
1363                     if (level > 1) {
1364                         tfLevel.setText("" + (level - 1));
1365                     }
1366                 } catch (NumberFormatException e) {
1367                 }
1368                 requestFocus();
1369             }
1370         });
1371 
1372         addComponentListener(new ComponentAdapter() {
1373             @Override
1374             public void componentResized(ComponentEvent ce) {
1375                 plTipBlock.fanning();
1376             }
1377         });
1378 
1379         timer = new Timer(1000, new ActionListener() {
1380             @Override
1381             public void actionPerformed(ActionEvent ae) {
1382                 DateFormat format = new SimpleDateFormat("时间:HH:mm:ss");      //系统获得时间
1383                 Date date = new Date();
1384                 tfTime.setText(format.format(date));
1385 
1386                 tfScore.setText("" + game.getScore());
1387                 int ScoreForLevelUpdate = //判断当前分数是否能升级
1388                         game.getScoreForLevelUpdate();
1389                 if (ScoreForLevelUpdate >= ErsBlocksGame.PER_LEVEL_SCORE
1390                         && ScoreForLevelUpdate > 0) {
1391                     game.levelUpdate();
1392                 }
1393             }
1394         });
1395         timer.start();
1396     }
1397 
1398     /**
1399      * 设置预显窗口的样式
1400      *
1401      * @param style int,对应ErsBlock类的STYLES中的28个值
1402      */
1403     public void setTipStyle(int style) {
1404         plTipBlock.setStyle(style);
1405     }
1406 
1407     /**
1408      * 取得用户设置的游戏等级。
1409      *
1410      * @return int ,难度等级，1-ErsBlocksGame.MAX_LEVEL
1411      */
1412     public int getLevel() {
1413         int level = 0;
1414         try {
1415             level = Integer.parseInt(tfLevel.getText());
1416         } catch (NumberFormatException e) {
1417         }
1418         return level;
1419     }
1420 
1421     /**
1422      * 让用户修改游戏难度等级。
1423      *
1424      * @param level 修改后的游戏难度等级
1425      */
1426     public void setLevel(int level) {
1427         if (level > 0 && level < 11) {
1428             tfLevel.setText("" + level);
1429         }
1430     }
1431 
1432     /**
1433      * 设置“开始”按钮的状态。
1434      */
1435     public void setPlayButtonEnable(boolean enable) {
1436         btPlay.setEnabled(enable);
1437     }
1438 
1439     public void setPauseButtonEnable(boolean enable) {
1440         btPause.setEnabled(enable);
1441     }
1442 
1443     public void setPauseButtonLabel(boolean pause) {
1444         btPause.setText(pause ? " 暂停" : " 继续");
1445     }
1446 
1447     public void setStopButtonEnable(boolean enable) {
1448         btStop.setEnabled(enable);
1449     }
1450 
1451     public void setTurnLevelUpButtonEnable(boolean enable) {
1452         btTurnLevelUp.setEnabled(enable);
1453     }
1454 
1455     public void setTurnLevelDownButtonEnable(boolean enable) {
1456         btTurnLevelDown.setEnabled(enable);
1457     }
1458 
1459     /**
1460      * 重置控制面板
1461      */
1462     public void reset() {
1463         tfScore.setText(" 0");
1464         plTipBlock.setStyle(0);
1465     }
1466 
1467     /**
1468      * 重新计算TipPanel里的boxes[][]里的小框的大小
1469      */
1470     public void fanning() {
1471         plTipBlock.fanning();
1472     }
1473 
1474     /**
1475      * 预显窗口的实现细节类
1476      */
1477     private class TipPanel extends JPanel {                                    //TipPanel用来显示下一个将要出现方块的形状
1478 
1479         private Color backColor = Color.LIGHT_GRAY, frontColor = Color.ORANGE;
1480         private ErsBox[][] boxes = new ErsBox[ErsBlock.BOXES_ROWS][ErsBlock.BOXES_COLS];
1481         private int style, boxWidth, boxHeight;
1482         private boolean isTiled = false;
1483 
1484         /**
1485          * 预显示窗口类构造函数
1486          */
1487         public TipPanel() {
1488             for (int i = 0; i < boxes.length; i++) {
1489                 for (int j = 0; j < boxes[i].length; j++) {
1490                     boxes[i][j] = new ErsBox(false);
1491                 }
1492             }
1493         }
1494 
1495         /**
1496          * 预显示窗口类构造函数
1497          *
1498          * @param backColor Color,窗口的背景色
1499          * @param frontColor Color，窗口的前景色
1500          */
1501         public TipPanel(Color backColor, Color frontColor) {
1502             this();
1503             this.backColor = backColor;
1504             this.frontColor = frontColor;
1505         }
1506 
1507         /**
1508          * 设置预显示窗口的方块样式
1509          *
1510          * @param style int，对应ErsBlock类的STYLES中的28个值
1511          */
1512         public void setStyle(int style) {
1513             this.style = style;
1514             repaint();
1515         }
1516 
1517         /**
1518          * 覆盖JComponent类的函数，画组件。
1519          *
1520          * @param g 图形设备环境
1521          */
1522         @Override
1523         public void paintComponent(Graphics g) {
1524             super.paintComponent(g);
1525 
1526             if (!isTiled) {
1527                 fanning();
1528             }
1529 
1530             int key = 0x8000;
1531             for (int i = 0; i < boxes.length; i++) {
1532                 for (int j = 0; j < boxes[i].length; j++) {
1533                     Color color = ((key & style) != 0 ? frontColor : backColor);
1534                     g.setColor(color);
1535                     g.fill3DRect(j * boxWidth, i * boxHeight,
1536                             boxWidth, boxHeight, true);
1537                     key >>= 1;
1538                 }
1539             }
1540         }
1541 
1542         /**
1543          * g根据窗口的大小，自动调整方格的尺寸
1544          */
1545         public void fanning() {
1546             boxWidth = getSize().width / ErsBlock.BOXES_COLS;
1547             boxHeight = getSize().height / ErsBlock.BOXES_ROWS;
1548             isTiled = true;
1549         }
1550     }
1551 }