十一用java写的俄罗斯方块,并有详细的注释.

游戏控制键说明：
VK_DOWN下落
VK_LEFT向左
VK_RIGHT向右
VK_UP旋转
VK_SPACE一见到底
各个方块的显示说明：
boxes数组存放虚拟的方格对象，isColor属性标识该方格用背景色填充还是前景色填充。
确定isColor的方法是反复将key进行左移一位，然后再与style相与，确定每个方格
的颜色。

游戏motif风格界面:

游戏Windows风格界面:

/*
*虚拟的单个方格类,控制方格的颜色
*/
class RussiaBox implements Cloneable
{
 private boolean isColor;
 
 public RussiaBox(boolean isColor)
 {
   this.isColor = isColor;
 }
 /*
  *设置颜色
 */
 public void setColor(boolean isColor)
 {
   this.isColor=isColor;
 }
 /*
 *返回颜色
 */
 public boolean isColorBox()
 {
   return isColor;
 }
 /*
  * @see java.lang.Object#clone()
  */
 public Object clone()
 {
  Object o = null;
  try
  {
   o=super.clone();
  }catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}
/*
 * 游戏中方块显示的画布类
 */
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

class GameCanvas extends JPanel
{
 private RussiaBox [][]boxes;
 private int rows = 20 , cols = 12;
 private static GameCanvas canvas=null;
 private int boxWidth, boxHeight;//默认为零需要调用fanning函数设置
 private Color blockColor = Color.RED, bgColor = new Color(0,204,204);
 private EtchedBorder border=new EtchedBorder(EtchedBorder.RAISED,Color.WHITE, new Color(148, 145, 140)) ;
 
 /*
  *采用单件模式,构造函数私有
 */
 private GameCanvas()
 {
  boxes = new RussiaBox[rows][cols];
  
  for(int i = 0; i < boxes.length; i ++)
      for(int j = 0; j          boxes[i][j] = new RussiaBox(false);
         
  setBorder(border);
 }
 /*
  *获得GameCanvas实例
  */
 public static GameCanvas getCanvasInstance()
 {
   if(canvas == null)
     canvas = new GameCanvas();
    
    return canvas;
 }
 /*
  *设置画布的背景色
  */
 public void setBgColor(Color bgColor)
 {
      this.bgColor = bgColor;
 }
 /*
 * 获得画布的背景色
 */
 public Color getBgColor()
 {
      return bgColor;
 }
 /*
  *设置方块的颜色
  */
 public void setBlockColor(Color blockColor)
 {
       this.blockColor = blockColor;
 }
 /*
  *方块的颜色
  */
 public Color getBlockColor()
 {
       return blockColor;
 }
 /*
  *设置画布中方块的行数
  */
 public void setRows(int rows)
 {
      this.rows = rows;
 }
 /*
  *得到画布中方块的行数
  */
 public int getRows()
 {
     return rows;
 }
 /*
  *设置画布中方块的列数
  */
 public void setCols(int cols)
 {
      this.cols = cols;
 }
 /*
  *得到画布中方块的列数
  */
 public int getCols()
 {
      return cols; 
 }
 /*
  *得到row行,col列的方格
  */
 public RussiaBox getBox(int row, int col)
 {
   if(row >= 0 && row < rows && col >= 0 && col < cols)
       return boxes[row][col];
      
   else
        return null;
 }
 /*
  *在画布中绘制方块
  */        
 public void paintComponent(Graphics g)
 {
   super.paintComponent(g);
  
   fanning();
   for(int i = 0; i < boxes.length; i ++)
      for(int j = 0; j < boxes[i].length; j ++)
        {
          Color color = boxes[i][j].isColorBox() ? blockColor : bgColor;
          g.setColor(color);
          g.fill3DRect(j * boxWidth, i * boxHeight , boxWidth , boxHeight , true);
        }  
 }
 /*
  *清除第row行
  */
 public void removeLine(int row)
 {
  for(int i = row; i > 0; i --)
    for(int j = 0; j < cols; j ++)
    {
          boxes[i][j] = (RussiaBox)boxes[i-1][j].clone();
     }
 }
 /*
  *重置 为初始时的状态
  */
 public void reset()
 {
   for(int i = 0; i < boxes.length; i++)
       for(int j = 0 ;j < boxes[i].length; j++)
       {
         boxes[i][j].setColor(false);
       }
    repaint();
 }
 /*
  * 根据窗体的大小自动调整方格的大小
  */
 public void fanning()
 {
   boxWidth = getSize().width / cols;
   boxHeight = getSize().height / rows;
 }
 
}
/*
 * 方块类
 */
class RussiaBlock extends Thread
{
 private int style,y,x,level;
 private boolean moving,pausing;
 private RussiaBox boxes[][];
 private GameCanvas canvas;
 
 public final static int ROWS = 4;
 public final static int COLS = 4;
 public final static int BLOCK_KIND_NUMBER = 7;
 public final static int BLOCK_STATUS_NUMBER = 4;
 public final static int BETWEEN_LEVELS_TIME = 50;
 public final static int LEVEL_FLATNESS_GENE = 3;

 /*
  *方块的所有风格及其不同的状态
  */
 public final static int[][] STYLES = {// 共28种状态
  {0x0f00, 0x4444, 0x0f00, 0x4444}, // 长条型的四种状态
  {0x04e0, 0x0464, 0x00e4, 0x04c4}, // 'T'型的四种状态
  {0x4620, 0x6c00, 0x4620, 0x6c00}, // 反'Z'型的四种状态
  {0x2640, 0xc600, 0x2640, 0xc600}, // 'Z'型的四种状态
  {0x6220, 0x1700, 0x2230, 0x0740}, // '7'型的四种状态
  {0x6440, 0x0e20, 0x44c0, 0x8e00}, // 反'7'型的四种状态
  {0x0660, 0x0660, 0x0660, 0x0660}, // 方块的四种状态
 };
 /*
  *构造函数
  */
 public RussiaBlock(int y,int x,int level,int style)
 {
  
   this.y = y;
   this.x = x;
   this.level = level;
   moving = true;
   pausing = false;
   this.style = style;
  
   canvas = GameCanvas.getCanvasInstance();
  
   boxes = new RussiaBox[ROWS][COLS];
   int key = 0x8000;
   for(int i = 0; i < boxes.length; i++)
     for(int j = 0; j < boxes[i].length; j++)
     {
        boolean isColor = ( (style & key) != 0 );
       boxes[i][j] = new RussiaBox(isColor);
       key >>= 1;
     }
    display();
 }
 /*
  *线程的 run方法控制放块的下落及下落速度
  */
 public void run()
 {
  while(moving)
  {
   try
   {
    sleep( BETWEEN_LEVELS_TIME * (RussiaBlocksGame.MAX_LEVEL - level + LEVEL_FLATNESS_GENE) );
     if(!pausing)
         moving = ( moveTo(y + 1,x) &&  moving );
   }catch(InterruptedException e)
   {
    e.printStackTrace();
   }
  }
 }
 /*
  *暂停移动
  */
 public void pauseMove()
 {
   pausing =  true;
 }
 /*
  *从暂停状态恢复
  */
 public void resumeMove()
 {
  pausing = false;
 }
 
 /*
  *停止移动
  */
 public void stopMove()
 {
   moving = false;
 }
/*
 *向左移一格
 */
 public void moveLeft()
 {
   moveTo(y , x - 1);
 }
 /*
 *向右移一格
 */
 public void moveRight()
 {
   moveTo(y , x + 1);
 }
 /*
 *向下移一格,返回与其他几个不同，为了一键到底
 */
 public boolean moveDown()
 {
  if(moveTo(y + 1, x))
       return true;
  else
       return false;
 }
 /*
  *移到newRow,newCol位置
  */
 public synchronized boolean moveTo(int newRow, int newCol)
 {
    //erase();//必须在判断前进行擦除，否则isMoveable将产生错误行为
   
    if(!moving || !isMoveable(newRow,newCol))
    {
       display();
        return false;
    }
    y = newRow;
    x = newCol;
    display();
    canvas.repaint();
    return true;
 }
 /*
  *判断能否移到newRow,newCol位置
  */
 private boolean isMoveable(int newRow, int newCol)
 {
     erase();
     for(int i = 0; i < boxes.length; i ++)
      for(int j = 0; j< boxes[i].length; j ++ )
        {
          if( boxes[i][j].isColorBox() )
          {
            RussiaBox box = canvas.getBox(newRow + i, newCol + j);
            if(box == null || box.isColorBox())
                return false;
          }         
        }
       return true;
 }
 /*
  *通过旋转变为下一种状态
  */
  public void turnNext()
 {
   int newStyle = 0;
   for(int i = 0; i < STYLES.length; i ++)
    for(int j = 0 ;j < STYLES[i].length; j++)
      {
       if(style == STYLES[i][j])
       {
            newStyle = STYLES[i][(j + 1)%BLOCK_STATUS_NUMBER];
            break;
        }
      }
      turnTo(newStyle);
 }
 /*
  *通过旋转变能否变为newStyle状态
  */
 private synchronized boolean turnTo(int newStyle)
 {
   //erase();//擦除之后在判断isTurnNextAble
   if(!moving || !isTurnable(newStyle))
   {    
         display();
         return false;
   }
  
   style=newStyle;
   int key = 0x8000;
  
   for(int i = 0; i < boxes.length; i ++)
    for(int j = 0 ;j < boxes[i].length; j++)
      {
       boolean isColor = ((key & style) != 0 );
       boxes[i][j].setColor(isColor);
       key >>=1;
      }
      display();
      canvas.repaint();
      return true;
 }
 /*
  *判断通过旋转能否变为下一种状态
  */
 private boolean isTurnable(int newStyle)
 {
   erase();
   int key = 0x8000; 
   for(int i = 0; i< boxes.length; i++)
      for(int j=0; j        {
         if((key & newStyle) != 0)
          {
            RussiaBox box = canvas.getBox(y + i, x + j);
            if(box == null || box.isColorBox())
                return false;
          }
          key >>= 1;
        }
        return true;
 }
 /*
  *擦除当前方块(只是设置isColor属性,颜色并没有清除,为了判断能否移动之用)
  */
 private void erase()
 {
   for(int i = 0; i < boxes.length; i ++)
      for(int j = 0; j< boxes[i].length; j ++ )
        {
          if( boxes[i][j].isColorBox() )
          {
             RussiaBox box = canvas.getBox( y + i, x + j);
             if(box != null)
             box.setColor(false);
           }
         }
 }
 /*
 *显示当前方块(其实只是设置Color属性,在调用repaint方法时才真正显示)
 */
 private void display()
 {
   for(int i = 0; i < boxes.length; i ++)
      for(int j = 0;j< boxes[i].length ; j ++)
      {
         if(boxes[i][j].isColorBox())
         {
          RussiaBox box = canvas.getBox( y + i, x + j);
          if(box != null)
           box.setColor( true );
         }
      }
 }
}
/*
 * 控制面板类
 */
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

class ControlPanel extends JPanel
{
 private TipBlockPanel tipBlockPanel;
 private JPanel tipPanel,InfoPanel,buttonPanel;
 private final JTextField levelField,scoreField;
 private JButton playButton,pauseButton,stopButton,
                 turnHarderButton,turnEasilyButton;
  private EtchedBorder border=new EtchedBorder(EtchedBorder.RAISED,Color.WHITE, new Color(148, 145, 140)) ;
 
  private RussiaBlocksGame game;
  private Timer timer;
   
 public ControlPanel(final RussiaBlocksGame game)
 {
  this.game = game;
  /*
   *图形界面部分
  */
  setLayout(new GridLayout(3,1,0,4));
  
  tipBlockPanel = new TipBlockPanel();
  tipPanel = new JPanel( new BorderLayout() );
  tipPanel.add( new JLabel("Next Block:") , BorderLayout.NORTH );
  tipPanel.add( tipBlockPanel , BorderLayout.CENTER );
  tipPanel.setBorder(border);
  
  InfoPanel = new JPanel( new GridLayout(4,1,0,0) );
  levelField = new JTextField(""+RussiaBlocksGame.DEFAULT_LEVEL);
  levelField.setEditable(false);
  scoreField = new JTextField("0");
  scoreField.setEditable(false);
  InfoPanel.add(new JLabel("Level:"));
  InfoPanel.add(levelField);
  InfoPanel.add(new JLabel("Score:"));
  InfoPanel.add(scoreField);
  InfoPanel.setBorder(border);
  
  buttonPanel = new JPanel(new GridLayout(5,1,0,0));
  playButton = new JButton("Play");
  pauseButton = new JButton("Pause");
  stopButton = new JButton("Stop");
  turnHarderButton = new JButton("Turn harder");
  turnEasilyButton = new JButton("Turn easily");
 
  buttonPanel.add(playButton);
  buttonPanel.add(pauseButton);
  buttonPanel.add(stopButton);
  buttonPanel.add(turnHarderButton);
  buttonPanel.add(turnEasilyButton);
   buttonPanel.setBorder(border);
  
   addKeyListener(new ControlKeyListener());//添加
  
   add(tipPanel);
   add(InfoPanel);
   add(buttonPanel);
 /*
  *添加事件监听器
  */
   playButton.addActionListener(
   new ActionListener()
   {
    public void actionPerformed(ActionEvent event)
    {
     game.playGame();
     requestFocus();//让ControlPanel重新获得焦点以响应键盘事件
    }
    });
   
    pauseButton.addActionListener(
    new ActionListener()
    {
     public void actionPerformed(ActionEvent event)
     {
      if(pauseButton.getText().equals("Pause"))
        game.pauseGame();
      else
        game.resumeGame(); 
      requestFocus();//让ControlPanel重新获得焦点以响应键盘事件
     }
    }
    );
    stopButton.addActionListener(
    new ActionListener()
    {
     public void actionPerformed(ActionEvent event)
     {
      game.stopGame();
      requestFocus();//让ControlPanel重新获得焦点以响应键盘事件
     }
    });
   turnHarderButton.addActionListener(
   new ActionListener()
   {
     public void actionPerformed(ActionEvent event)
     {
       int level = 0;
       try{
           level = Integer.parseInt(levelField.getText());
           setLevel(level + 1);
          }catch(NumberFormatException e)
          {
           e.printStackTrace();
          }
       requestFocus();//让ControlPanel重新获得焦点以响应键盘事件
     }
   });
   turnEasilyButton.addActionListener(
   new ActionListener()
   {
     public void actionPerformed(ActionEvent event)
     {
       int level = 0;
       try{
           level = Integer.parseInt(levelField.getText());
           setLevel(level - 1);
          }catch(NumberFormatException e)
          {
           e.printStackTrace();
          }
      requestFocus();//让ControlPanel重新获得焦点以响应键盘事件
     }
   });
    /*
    *  时间驱动程序，每格500毫秒对level,score值进行更新
    */
   timer =  new Timer(500,
   new ActionListener()
   {
    public void actionPerformed(ActionEvent event)
    {
     scoreField.setText(""+game.getScore());
     game.levelUpdate();
    }
   }
   );
   timer.start(); 
 } 
 /*
  * 设置预显方块的样式
  */
 public void setBlockStyle(int style)
 {
  tipBlockPanel.setStyle(style);
  tipBlockPanel.repaint();
 } 
 /*
  * 重置，将所有数据恢复到最初值
  */
 public void reset()
 {
  levelField.setText(""+RussiaBlocksGame.DEFAULT_LEVEL);
  scoreField.setText("0");
  setPlayButtonEnabled(true);
  setPauseButtonLabel(true);
  tipBlockPanel.setStyle(0);
 }
 
 /*
  *设置playButton是否可用
  */
 public void setPlayButtonEnabled(boolean enable)
 {
  playButton.setEnabled(enable);
 }
 
 /*
  *设置pauseButton的文本
  */
 public void setPauseButtonLabel(boolean pause)
 {
  pauseButton.setText( pause ? "Pause" : "Rusume" );
 }
 
 /*
  *设置方块的大小,改变窗体大小时调用可自动调整方块到合适的尺寸
  */
 public void fanning()
 {
  tipBlockPanel.fanning();
 }  
 /*
  *根据level文本域的值返回当前的级别
  */
 public int getLevel()
  {
     int level = 0;
     try
     {
      level=Integer.parseInt(levelField.getText());
     }catch(NumberFormatException e)
     {
       e.printStackTrace();
     }
     return level;
  }
  /*
   * 设置level文本域的值
   */
  public void setLevel(int level)
  {
    if(level > 0 && level <= RussiaBlocksGame.MAX_LEVEL)
       levelField.setText("" + level);
  }  
  /*
   * 内部类 为预显方块的显示区域
   */
  private class TipBlockPanel extends JPanel
  {
    private Color bgColor = Color.darkGray,
                  blockColor = Color.lightGray;             
    private RussiaBox [][]boxes = new RussiaBox[RussiaBlock.ROWS][RussiaBlock.COLS];
    private int boxWidth, boxHeight,style;
    private boolean isTiled = false;
   
    /*
     * 构造函数
     */
   public TipBlockPanel()
   {
    for(int i = 0; i < boxes.length; i ++)
       for(int j = 0; j < boxes[i].length; j ++)
         {
          boxes[i][j]=new RussiaBox(false);
         }
         style = 0x0000;
   }
   /*
    * 构造函数
    */
   public TipBlockPanel(Color bgColor, Color blockColor)
   {
    this();
    this.bgColor = bgColor;
    this.blockColor = blockColor;
   }
    /*
     * 设置方块的风格
     */
    public void setStyle(int style)
    {
     this.style = style;
     repaint();
    }
   
    /*
     * 绘制预显方块
     */
   public void paintComponent(Graphics g)
   {
    super.paintComponent(g);
    
    int key = 0x8000;
    
    if(!isTiled)
       fanning();
    for(int i = 0; i < boxes.length; i ++)
      for(int j = 0; j       {
         Color color = (style & key) != 0  ?  blockColor : bgColor;
         g.setColor(color);
         g.fill3DRect(j * boxWidth, i * boxHeight, boxWidth, boxHeight, true);  
         key >>=1;
       }
   }
   /*
    *设置方块的大小,改变窗体大小时调用可自动调整方块到合适的尺寸
    */
  
   public void fanning()
   {
    boxWidth = getSize().width / RussiaBlock.COLS;
    boxHeight = getSize().height /RussiaBlock.ROWS;
    isTiled=true;
   }
  }
  /*
   *内部类 键盘键听器,响应键盘事件
   */
  class ControlKeyListener extends KeyAdapter {
  public void keyPressed(KeyEvent ke)
  {
   if (!game.isPlaying()) return;
     
   RussiaBlock block = game.getCurBlock();
   switch (ke.getKeyCode()) {
    case KeyEvent.VK_DOWN:
     block.moveDown();
     break;
    case KeyEvent.VK_LEFT:
     block.moveLeft();
     break;
    case KeyEvent.VK_RIGHT:
     block.moveRight();
     break;
    case KeyEvent.VK_UP:
     block.turnNext();
     break;
    case KeyEvent.VK_SPACE://一键到底
      while(block.moveDown())
      {  
      }
      break;
    default:
     break;
   }
  }
 }
}
/*
 * 主游戏类
 */
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class RussiaBlocksGame extends JFrame
{
 public final static int PER_LINE_SCORE = 100;//消去一行得分
 public final static int PER_LEVEL_SCORE = PER_LINE_SCORE*20;//升一级需要的分数
 public final static int DEFAULT_LEVEL = 5;//默认级别
 public final static int MAX_LEVEL = 10;//最高级别
 private int score=0,curLevelScore = 0;//总分和本级得分
 
 private GameCanvas canvas;
 private ControlPanel controlPanel;
 private RussiaBlock block;
 
 private int style = 0;
 boolean playing = false;
 
 private JMenuBar bar;
 private JMenu gameMenu,controlMenu,windowStyleMenu,informationMenu;
 private JMenuItem newGameItem,setBlockColorItem,setBgColorItem,
         turnHardItem,turnEasyItem,exitItem;
   private JMenuItem playItem,pauseItem,resumeItem,stopItem;
   private JRadioButtonMenuItem windowsRadioItem,motifRadioItem,metalRadioItem;
   private JMenuItem authorItem,helpItem;
   private ButtonGroup buttonGroup;
  /*
   * 构造函数
   */
  public RussiaBlocksGame(String title)
  {
   super(title);
   
   setSize(300,400);
   Dimension scrSize=Toolkit.getDefaultToolkit().getScreenSize();
   setLocation((scrSize.width-getSize().width)/2,(scrSize.height-getSize().height)/2);
   
   createMenu();
   Container container=getContentPane();
   container.setLayout(new BorderLayout());
   
   canvas = GameCanvas.getCanvasInstance();
   controlPanel = new ControlPanel(this);
   
   container.add(canvas,BorderLayout.CENTER);
   container.add(controlPanel,BorderLayout.EAST);
   
   addWindowListener(
   new WindowAdapter()
   {
    public void windowClosing(WindowEvent event)
    {
     stopGame();
     System.exit(0);
    }
   }
   );
   
   addComponentListener(
   new ComponentAdapter()
   {
    public void componentResized(ComponentEvent event)
    {
     canvas.fanning();
    }
   }
   );
   canvas.fanning();
   setVisible(true);
  }
  /*
   * 判断游戏是否正在进行
   */
   public boolean isPlaying()
   {
    return playing;
   }
   /*
    * 开始游戏并设置按钮和菜单项的可用性
    */ 
   public void playGame()
   {
    play();
    controlPanel.setPlayButtonEnabled(false);
    playItem.setEnabled(false);
   }
   /*
    * 暂停游戏
    */
   public void pauseGame()
   {
     if(block != null) block.pauseMove();
     controlPanel.setPauseButtonLabel(false);
     pauseItem.setEnabled(false);
     resumeItem.setEnabled(true);
   }
   /*
    * 从暂停中恢复游戏
    */
   public void resumeGame()
   {
    if(block != null) block.resumeMove();
    controlPanel.setPauseButtonLabel(true);
    pauseItem.setEnabled(true);
    resumeItem.setEnabled(false);
   }
   /*
    * 停止游戏
    */
   public void stopGame()
   {
    if(block != null) block.stopMove();
    playing = false;
    controlPanel.setPlayButtonEnabled(true);
    controlPanel.setPauseButtonLabel(true);
                playItem.setEnabled(true);
   }
   /*
    * 得到当前级别
    */
   public int  getLevel()
   {
    return controlPanel.getLevel();
   }
   /*
    * 设置当前级别,并更新控制面板的显示
    */
   public void setLevel(int level)
   {
    if(level>0&&level<11)
    controlPanel.setLevel(level);
   }
   /*
    * 得到当前总分数
    */
   public int getScore()
   {
    if(canvas != null)
        return score;
     return 0;
   }
   /*
    * 得到本级得分
    */
   public int getCurLevelScore()
   {
    if(canvas != null)
        return curLevelScore;
     return 0;
   }
   /*
    * 更新等级
    */
   public void levelUpdate()
   {
    int curLevel = getLevel();
    if(curLevel < MAX_LEVEL && curLevelScore >= PER_LEVEL_SCORE)
    {
      setLevel(curLevel + 1);
      curLevelScore -= PER_LEVEL_SCORE;
    }  
   }
   /*
    * 获得当前得方块
    */
   public RussiaBlock getCurBlock() {
     return block;
  }
   /*
    * 开始游戏
    */
   private void play()
   {
    playing=true;
    Thread thread = new Thread(new Game());
    thread.start();
    reset();
   }
   /*
     * 重置
     */
     private void reset()
     {
      controlPanel.reset();
      canvas.reset();
                score = 0;
                curLevelScore = 0;
     }
    /*
     * 宣告游戏结束
     */ 
   private void reportGameOver()
   {
    JOptionPane.showMessageDialog(this,"Game over!");
   }
   /*
    * 创建菜单
    */
  private void createMenu()
  {
   gameMenu = new JMenu("Game");
   newGameItem = new JMenuItem("New Game");
   setBlockColorItem = new JMenuItem("Set Block Color...");
   setBgColorItem = new JMenuItem("Set BackGround Color...");
   turnHardItem = new JMenuItem("Turn Harder");
   turnEasyItem = new JMenuItem("Turn Easily");
   exitItem = new JMenuItem("Exit");
   gameMenu.add(newGameItem);
    gameMenu.add(setBlockColorItem);
    gameMenu.add(setBgColorItem);
    gameMenu.add(turnHardItem);
    gameMenu.add(turnEasyItem);
    gameMenu.add(exitItem);   
   
   controlMenu =  new JMenu("Control");
    playItem = new JMenuItem("Play");
    pauseItem = new JMenuItem("Pause");
    resumeItem = new JMenuItem("Resume");
    stopItem = new JMenuItem("Stop");
    controlMenu.add(playItem);
    controlMenu.add(pauseItem);
    controlMenu.add(resumeItem);
    controlMenu.add(stopItem);
   
    windowStyleMenu = new JMenu("WindowStyle");
    buttonGroup = new ButtonGroup();
    windowsRadioItem = new JRadioButtonMenuItem("Windows");
    motifRadioItem = new JRadioButtonMenuItem("Motif");
    metalRadioItem = new JRadioButtonMenuItem("Mentel",true);
    windowStyleMenu.add(windowsRadioItem);
    buttonGroup.add(windowsRadioItem);
    windowStyleMenu.add(motifRadioItem);
    buttonGroup.add(motifRadioItem);
    windowStyleMenu.add(metalRadioItem);
    buttonGroup.add(metalRadioItem);
   
    informationMenu = new JMenu("Information");
    authorItem = new JMenuItem("Author:Fuliang");
    helpItem = new JMenuItem("Help");
    informationMenu.add(authorItem);
    informationMenu.add(helpItem);
   
    bar = new JMenuBar();
    bar.add(gameMenu);
   bar.add(controlMenu);
   bar.add(windowStyleMenu);
   bar.add(informationMenu);
   
   addActionListenerToMenu();
   setJMenuBar(bar);
  }
  /*
   * 添加菜单响应
   */
  private void addActionListenerToMenu()
  {
   newGameItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    stopGame();
    reset();
    setLevel(DEFAULT_LEVEL);
   }
  });
  
  setBlockColorItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    Color newBlockColor =
            JColorChooser.showDialog(RussiaBlocksGame.this,
                    "Set color for block", canvas.getBlockColor());
    if (newBlockColor != null)
     canvas.setBlockColor(newBlockColor);
   }
  });
  
  setBgColorItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    Color newBgColor =
            JColorChooser.showDialog(RussiaBlocksGame.this,"Set color for block",
                               canvas.getBgColor());
    if (newBgColor != null)
     canvas.setBgColor(newBgColor);
   }
  });
  
  turnHardItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    int curLevel = getLevel();
    if (curLevel < MAX_LEVEL) setLevel(curLevel + 1);
   }
  });
  
  turnEasyItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    int curLevel = getLevel();
    if (curLevel > 1) setLevel(curLevel - 1);
   }
  });
  
  exitItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    System.exit(0);
   }
  });
  playItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    playGame();
   }
  });
  
  pauseItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    pauseGame();
   }
  });
  
  resumeItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    resumeGame();
   }
  });
  
  stopItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    stopGame();
   }
  });
  
  windowsRadioItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    String plaf = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
    setWindowStyle(plaf);
    canvas.fanning();
    controlPanel.fanning();
   }
  });
  
  motifRadioItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    String plaf = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
    setWindowStyle(plaf);
    canvas.fanning();
    controlPanel.fanning();;
   }
  });
  
   metalRadioItem.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent ae) {
    String plaf = "javax.swing.plaf.metal.MetalLookAndFeel";
    setWindowStyle(plaf);
    canvas.fanning();
    controlPanel.fanning();
   }
  });
  
   }
   /*
    * 设定窗口风格
    */
   private void setWindowStyle(String plaf)
   {
  try {
   UIManager.setLookAndFeel(plaf);
   SwingUtilities.updateComponentTreeUI(this);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
  
 private class Game implements Runnable
 {
  /*
   *  (non-Javadoc)
   * @see java.lang.Runnable#run()
   * 游戏线程的run函数
   */
  public void run()
  {
   int col=(int)(Math.random()*(canvas.getCols()-3));
   style=RussiaBlock.STYLES[(int)(Math.random()*RussiaBlock.BLOCK_KIND_NUMBER)][(int)(Math.random()*RussiaBlock.BLOCK_STATUS_NUMBER)];
   
         while (playing) {
    if (block != null) {    //第一次循环时，block为空
     if (block.isAlive()) {
      try {
       Thread.sleep(100);
      } catch (InterruptedException ie) {
       ie.printStackTrace();
      }
      continue;
     }
    }
    
    checkFullLine();
    
    if (isGameOver()) {     //检查游戏是否应该结束了
     playItem.setEnabled(true);
     pauseItem.setEnabled(true);
     resumeItem.setEnabled(false);
     controlPanel.setPlayButtonEnabled(true);
     controlPanel.setPauseButtonLabel(true);

     reportGameOver();
     return;
  }
  block = new RussiaBlock(-1, col, getLevel(),style);
  block.start();
  
  col=(int)(Math.random()*(canvas.getCols()-3));
   style=RussiaBlock.STYLES[(int)(Math.random()*RussiaBlock.BLOCK_KIND_NUMBER)][(int)(Math.random()*RussiaBlock.BLOCK_STATUS_NUMBER)];
    controlPanel.setBlockStyle(style);
 }
 }
 /*
  * 判断是否能消去整行
  */
  public void checkFullLine()
  {
   for (int i = 0; i < canvas.getRows(); i++) {
    int row = -1;
    boolean fullLineColorBox = true;
    for (int j = 0; j < canvas.getCols(); j++) {
     if (!canvas.getBox(i, j).isColorBox()) {
      fullLineColorBox = false;
      break;
     }
    }
    if (fullLineColorBox) {
     curLevelScore += PER_LINE_SCORE;
     score += PER_LINE_SCORE;
     row = i--;
     canvas.removeLine(row);
    }
   }
  }
  /*
   * 判断游戏是否结束
   */
  private boolean isGameOver() {
   for (int i = 0; i < canvas.getCols(); i++) {
    RussiaBox box = canvas.getBox(0, i);
    if (box.isColorBox()) return true;
   }
   return false;
  }
 }
 public static void main(String[] args)
 {
  new RussiaBlocksGame("Russia Blocks Game");
 }
}