`

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

阅读更多
/*
*虚拟的单个方格类,控制方格的颜色
*/
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].length; 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<boxes[i].length; 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<boxes[i].length ;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");
 }
}


分享到:
评论

相关推荐

    俄罗斯方块源代码加详细注释

    《俄罗斯方块源代码加详细注释》是一个非常适合初学者学习的游戏开发资源,它提供了完整的俄罗斯方块游戏的源代码,并且附带了详尽的注释,方便理解每个部分的功能和逻辑。在这个项目中,我们可以深入学习到游戏编程...

    java俄罗斯方块程序详细讲解

    Java 编写的俄罗斯方块程序是一个经典的编程实例,它展示了如何用面向对象的思维来设计游戏逻辑。在本文中,我们将深入探讨这个程序的核心概念、设计思想和关键代码。 首先,程序的基础是建立一个名为 `RussiaStage...

    Android应用源码俄罗斯方块注释超详细版.zip

    "Android应用源码俄罗斯方块注释超详细版.zip"提供了一个很好的学习资源,它包含了一个已经完全注释的Android版俄罗斯方块游戏的源代码。这份源码不仅能够帮助初学者了解Android游戏开发的基本流程,还能让有经验的...

    俄罗斯方块游戏源码-Java

    【经典再现,Java俄罗斯方块游戏源码】 踏上编码之旅,揭开经典游戏的神秘面纱!我们的Java版俄罗斯方块源码项目是您深入理解游戏开发、算法设计和面向对象编程的完美起点! 核心特色与优势 跨平台兼容:基于强大...

    应用源码俄罗斯方块注释超详细版.zip

    本资料提供了“应用源码俄罗斯方块注释超详细版”,旨在帮助开发者深入理解游戏开发流程,尤其是针对Java和Android平台的编程实践。以下是对这个项目的一些关键知识点的解析: 1. **Android开发环境**:首先,你...

    俄罗斯方块源码及注释(java)

    《Java版俄罗斯方块源码解析与学习指南》 俄罗斯方块是一款经典的益智游戏,其简单的规则和无尽的挑战性使其在全球范围内广受欢迎。本文将深入探讨一个基于Java实现的俄罗斯方块源码,旨在帮助读者理解游戏机制、...

    java 俄罗斯方块 源码+文档+注释+资源文件

    Java 实现的俄罗斯方块项目是一个经典的编程练习,它涵盖了多方面的编程技术,包括图形用户界面(GUI)、事件处理、对象编程以及算法设计。在这个项目中,我们将深入探讨以下几个核心知识点: 1. **Java GUI编程**...

    俄罗斯方块 Java 源码 含海量注释

    这个项目是使用Java来实现经典游戏——俄罗斯方块。它展示了如何利用Java的面向对象特性来构建游戏逻辑,同时提供了丰富的注释,这对于初学者来说是一份极好的学习资料。 1. **面向对象设计**:俄罗斯方块的核心是...

    Android应用源码俄罗斯方块注释超详细版.rar

    在这个“Android应用源码俄罗斯方块注释超详细版”中,我们可以学习到如何将这种经典游戏移植到Android平台。以下是主要涉及的技术点: 1. **用户界面(UI)设计**:游戏界面通常包含一个显示游戏区域的Canvas,...

    Android应用源码俄罗斯方块注释超详细版.zip源码资源下载

    总的来说,这个“Android应用源码俄罗斯方块注释超详细版”是一个绝佳的学习资源,涵盖了Android开发的基本概念、Java编程技巧以及游戏开发的逻辑。通过阅读源码和注释,开发者可以深入了解如何将这些知识应用于实际...

    java游戏俄罗斯方块源码.zip.zip

    首先,"Java俄罗斯方块"是一款基于经典游戏规则的程序,玩家需要控制不同形状的方块下落,并在合适的位置排列它们,以消除完整的一行或多行。在这个项目中,开发者使用Java语言编写了游戏的核心逻辑,包括方块生成、...

    Java写的俄罗斯方块小游戏

    在这个“Java写的俄罗斯方块小游戏”中,开发者利用了Java的核心特性来实现经典的游戏逻辑。游戏的基本原理是不同形状的方块(称为“块”)会从屏幕顶部随机下降,并在到达底部或与其他方块相碰时固定位置。玩家的...

    俄罗斯方块源码 java

    7. **文档与注释**:一个良好的源码应配有详细的文档和注释,帮助读者理解代码功能和设计思路。在这款俄罗斯方块源码中,开发者很可能已经为关键函数和类提供了注释,以辅助学习者理解代码。 通过研究这款基于Java...

    一个比较不错的俄罗斯方块代码(有注释)

    这个压缩包中包含的"一个比较不错的俄罗斯方块代码(有注释)"是用Java语言实现的,这为我们提供了一个很好的机会来深入理解如何用面向对象的思想构建游戏逻辑。 1. **Java编程基础**: - 类与对象:俄罗斯方块的每...

    java实现的简单俄罗斯方块

    在本文中,我们将深入探讨如何使用Java编程语言实现一个简单的俄罗斯方块游戏。这个项目适合初学者提升逻辑思维能力,并且代码中包含了丰富的注释,方便理解和学习。 首先,我们从`MyRect.java`文件开始。这个文件...

    java版俄罗斯方块课程设计

    【Java版俄罗斯方块课程设计】是一个典型的编程项目,它主要涵盖了Java编程语言的应用,特别是对于游戏开发的基础知识。这个项目旨在让学生通过实践理解多线程的概念,以及如何利用Java来实现一个小型的桌面游戏。...

    java 俄罗斯方块代码

    Java 俄罗斯方块是一款经典的基于Java编程语言实现的益智游戏。这个项目展示了如何使用Java进行游戏开发,包括图形用户界面(GUI)的设计、事件处理、游戏逻辑的实现以及对象的移动与碰撞检测等核心概念。 1. **...

Global site tag (gtag.js) - Google Analytics