Java版俄罗斯方块

参考：Java项目开发实训教程（朱神喜 黄方胜著）

环境：linux+java;

工具：vim

相关代码：

UML图：未完成品:

(UML还没有完成的，后续会更新）

ErsBox.java

package Mypackage;

/*
 * 方格的抽象,需要这个是可以复制的
 * */

public class ErsBox implements Cloneable {
    //4个方格形成一个方块
    public final static int BOXES_ROWS = 4;
    public final static int BOXES_COLS = 4;

    private boolean isColor;
    
    public ErsBox(boolean isColor) {
        this.isColor = isColor;
    }

    public boolean isColorBox() {
        return this.isColor;
    }

    public void setColor(boolean isColor) {
        this.isColor = isColor;
    }

    public Object clone() {
        Object cloned = null;
        try {
            cloned = super.clone();
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
        return cloned;
    }
}

ControlPanel.java

package Mypackage;

import Mypackage.ErsBox;

import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.EtchedBorder;
import java.awt.*;
import java.awt.event.*;

public class ControlPanel extends JPanel {
    //两个存放游戏信息的文本域
    public final static int DEFAULT_LEVEL = 5;
    private JTextField tfLevel = new JTextField("" + DEFAULT_LEVEL), tfScore = new JTextField("0");

    /*
    //游戏控制的按键
    private JButton
    btPlay = new JButton("开始"),
        btPause = new JButton("暂停"),
        btStop = new JButton("停止"),
        btTurnLevelUp = new JButton("增加难度"),
        btTurnLevelDown = new JButton("降低难度");
    */
    //存放提示面板
    private JPanel plTip = new JPanel(new BorderLayout());
    //方块提示面板
    private TipPanel plTipBlock = new TipPanel();
    //信息存放的面板
    private JPanel plInfo = new JPanel(new GridLayout(4, 1));
    //按钮存放的面板
    private JPanel plButton = new JPanel(new GridLayout(5, 1));
    //计时器，用于定时更新面板信息
   // private Timer timer;
    //当前的游戏局
    //private ErsBlocksGame game;
    //面板的边框
    private Border border = new EtchedBorder(EtchedBorder.RAISED, Color.white, new Color(148, 145, 140));


   // public ControlPanel(final ErsBlocksGame game) {
       public ControlPanel() {
        setLayout(new GridLayout(2, 1, 0, 4));
       // this.game = game;

        plTip.add(new JLabel("下一个方块"), BorderLayout.NORTH);
        plTip.add(plTipBlock,BorderLayout.CENTER);
        plTip.setBorder(border);

        plInfo.add(new JLabel("难度级别"));
        plInfo.add(tfLevel);
        plInfo.add(new JLabel("得分"));
        plInfo.add(tfScore);
        plInfo.setBorder(border);
        //两个文本域设置为不可编辑
    /*    
        plButton.add(btPlay);
        plButton.add(btPause);
        plButton.add(btStop);
        plButton.add(btTurnLevelUp);
        plButton.add(btTurnLevelDown);
        plButton.setBorder(border);
    */
        //将三个面板加放到控制面板中
        add(plTip);
        add(plInfo);
    //    add(plButton);
    
    /*
        //增加键盘监听器
        addKeyListener(new ControlKeyListener());
        //设置各种按钮的监听器行为
        btPlay.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                game.playGame();
            }
        });

        btPause.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                if (btPause.getText().equals(new String("暂停"))) {
                    game.pauseGame();
                } else {
                    game.resumeGame();
                }
            }
        });

        btStop.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                game.stopGame();
            }
        });

        btTurnLevelUp.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                try {
                    int level = Integer.parseInt(tfLevel.getText());
                    if (level < ErsBlocksGame.MAX_LEVEL)
                        tfLevel.setText("" + (level + 1));
                } catch (NumberFormatException e) {}
                requestFocus();
            }
        });

        btTurnLevelDown.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                try {
                    int level = Integer.parseInt(tfLevel.getText());
                    if (level > 1)
                        tfLevel.setText("" + (level - 1));
                } catch (NumberFormatException e) {}
                requestFocus();
            }
        });
    
    */
    //组件适配器调整
        addComponentListener(new ComponentAdapter() {
            public void componentResized(ComponentEvent ce) {
                plTipBlock.fanning();
            }
        });

        
    /*    
        //定时器
        timer = new Timer(500, new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                tfScore.seText("" + game.getScore());
                int scoreForLevelUpdate = game.getScoreForLevelUpdate();
                if(scoreForLevelUpdate >= ErsBlocksGame.PRE_LEVEL_SCORE && scoreForLevelUpdate >0)
                    game.levelUpdate();
            }
        });
        timer.start();
    */
    }
        
    //相关的设置函数与返回函数
    public int getLevel() {
        return Integer.parseInt(tfLevel.getText());
    }

    public void setLevel(int level) {
        tfLevel.setText("" + level);
    }
    
    public int getScore() {
        return Integer.parseInt(tfScore.getText());
    }

    public void setScore(int score) {
        tfScore.setText("" + score);
    }
    
    /*
    public void setPlayButtonEnable(boolean enable) {
        btPlay.setEnabled(enabel);
    }

    public void setPauseButtonEnable(boolean enable) {
        btPause.setEnabled(enable);
    }
    */
    public void setTipStyle(int style) {
        plTipBlock.setStyle(style);
    }

    public void reset() {
        setScore(0);
        setLevel(DEFAULT_LEVEL);
    }



    /*TipPanel提示面板内部类*/
    private class TipPanel extends JPanel {
        private Color backcolor = Color.darkGray, frontColor = Color.lightGray;
        private ErsBox[][] boxes = new ErsBox[ErsBox.BOXES_ROWS][ErsBox.BOXES_COLS];
        private int style = 0x0f00, boxWidth, boxHeight;
        private boolean isTiled = false; //用于判断是否已经获得了长度与宽度；

        //预设置面板的前背景和后背景
        public TipPanel() {
            int i, j;
            for (i = 0; i < ErsBox.BOXES_ROWS; i++) {
                for (j = 0; j < ErsBox.BOXES_COLS; j++) {
                    boxes[i][j] = new ErsBox(false);
                }
            }
        }

        public TipPanel(Color backcolor, Color frontColor) {
            this(); //调用无参的构造函数；
            this.backcolor = backcolor;
            this.frontColor = frontColor;
        }

        public void setStyle(int style) {
            this.style = style;
            repaint();
        }

        public void paintComponent(Graphics g) {
            super.paintComponent(g);
           // 根据窗口的大小重新调整方格的大小
            if (!isTiled)
                fanning();
            int key = 0x8000, i, j;
            for (i = 0; i < ErsBox.BOXES_COLS; i++) {
                for (j = 0; j < ErsBox.BOXES_ROWS; j++) {
                    Color color = (((key & style) == 0) ? backcolor : frontColor);
                    g.setColor(color);
                    g.fill3DRect(j * boxWidth, i * boxHeight, boxWidth, boxHeight, true);
                    key >>= 1;
                }
            }
        }

        public void fanning() {
            boxWidth = getSize().width / ErsBox.BOXES_COLS;
            boxHeight = getSize().height / ErsBox.BOXES_ROWS;
            isTiled = true;
        }

        //用于测试代码的 //
        public ErsBox getBox(int x, int y) {
            if (0 <= x && x <= 3 && 0 <= y && y <= 3)
                return boxes[x][y];
            return null;
        }
    }


    /*方向键的设置*/
    /*
    private  class ControlKeyListener extends KeyAdapter {
        public void keyPressed(KeyEvent ke) {
            if (!game.isPlaying())
                return;
            ErsBlock 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;
                default:
                    break;
            }
        }
    }
    */
}

GameCanvas.java

package Mypackage;

import Mypackage.ErsBox;
import javax.swing.*;
import javax.swing.border.EtchedBorder; //用于设置边框
import java.awt.*;

public class GameCanvas extends JPanel {
    private int rows, cols, score, scoreForLevelUpdate;          //游戏面板的行与列,分数，到下一级别的分数的差距
    private int boxWidth, boxHeight; //方格的宽度与高度
    private Color frontColor = Color.orange, backColor = Color.black;
    private ErsBox[][] boxes;
    
    public GameCanvas(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        int i, j;
        boxes = new ErsBox[rows][cols];
        //设置方格数rows*cols
        for(i = 0; i < rows; i++) {
            for(j = 0;j < cols; j++) {
                boxes[i][j] = new ErsBox(false);
            }
        }
        setBorder(new EtchedBorder(EtchedBorder.RAISED, Color.white, new Color(148, 145, 140)));
    }

    /*GameCanvas的第二个构造函数，主要是在第一个的基础上加上背景颜色
     * @param frontColor Color, 前景色
     * @param backColor Color, 背景色
     */
    public GameCanvas(int rows, int cols, Color frontColor, Color backColor) {
        this(rows, cols);
        this.frontColor = frontColor;
        this.backColor = backColor;
    }

    public int getCols() {
        return cols;
    }

    public int getRows() {
        return rows;
    }

    public Color getBlockColor() {
        return this.frontColor;
    }

    public void setBlockColor(Color frontColor) {
        this.frontColor = frontColor;
    }

    public Color getBackgroundColor() {
        return this.backColor;
    }

    public void setBackgroundColor(Color backColor) {
        this.backColor = backColor;
    }
    
    public int getScore() {
        return score;
    }

    public void setScore(int socre) {
        this.score = score;
    }

    public int getScoreForLevelUpdate() {
        return     scoreForLevelUpdate;
    }

    public void removeLine(int row) {
        int i, j;
        boolean isColor;
        for(i = row; i > 0; i--) {
            for(j = 0; j < cols; ++j) {
                boxes[i][j] = (ErsBox) boxes[i-1][j].clone();
            }
        }
        score += 100;
        scoreForLevelUpdate += 100;
        repaint();
        //首行要清空
    //    for(j = 0; j < cols; ++j)
    //        boxes[0][j].setColor(false);
    }

    /*得到指定行，列的方格引用
     */
    public ErsBox getBox(int row, int col) {
        if(row < 0 || row >= rows  || col < 0 || col >= cols)
            return null;
        return boxes[row][col];
    }

    /*覆盖JComponent类的方法，绘制当前容器的所有的组件
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.setColor(frontColor);
        int i, j;
        for(i = 0; i < rows; ++i) {
            for(j = 0; j < cols; ++j) {
                g.setColor(boxes[i][j].isColorBox() ? frontColor : backColor);
                g.fill3DRect(j*boxWidth, i*boxHeight, boxWidth, boxHeight, true);
            }
        }
    }

    public void resetScoreForLevelUpdate() {
        this.scoreForLevelUpdate = 0;
        this.score = 0;
        repaint();
    }

    //根据窗口的大小调整方块的大小
    public void fanning() {
        boxWidth = getSize().width / cols;
        boxHeight = getSize().height / rows;
    }

    //重置画布
    public void reset() {
        score = 0;
        scoreForLevelUpdate = 0;
        int i, j;
        for(i= 0; i < rows; ++i) {
            for(j = 0; j < cols; ++j) {
                boxes[i][j].setColor(false);
            }
        }
        repaint();
    }
}

ErsBlock.java

package Mypackage;

import Mypackage.ErsBox;
import Mypackage.GameCanvas;

public class ErsBlock extends Thread {

    public final static int BOXES_ROWS = 4;
    public final static int BOXES_COLS = 4;
    public final static int MAX_LEVEL = 10;
    //下落的平滑因子
    public final static int LEVEL_FLATNESS_GENE = 3;
    //相近的两级之间的速度之差，这个主要与游戏难度相关
    public final static int BETWEEN_LEVELS_DEGRESS_TIME = 50;
    //方块的种类
    private final static int BLOCK_KIND_NUMBER = 7;
    //每种方块变形的数目
    private final static int BLOCK_STATUS_NUMBER = 4;
    public final static int[][] STYLES = {
        { 0x0f00, 0x4444, 0x0f00, 0x4444 }, //长条型的4种状态;
        { 0x04e0, 0x0464, 0x00e4, 0x04c4 }, //'T'型的4种状态;
        { 0x4620, 0x6c00, 0x4620, 0x6c00 }, //反'Z'的4种状态;
        { 0x2640, 0xc600, 0x2640, 0xc600 }, //'Z'的4种状态;
        { 0x6220, 0x1700, 0x2230, 0x0740 }, //'7'的4种状态;
        { 0x6440, 0x0e20, 0x44c0, 0x8e00 }, //反'7'的4种状态；
        { 0x0660, 0x0660, 0x0660, 0x0660 }, //正方形的4种状态；
    };
    //private GameGanvas canvas; //游戏面板，这个方块在这个面板上显示
    private GameCanvas canvas; //先用于替代GameGanvas进行测试
    private ErsBox[][] boxes = new ErsBox[BOXES_ROWS][BOXES_COLS];
    //用于构造函数中的参数
    int style, x, y, level;
    //用于控制方块的运行
    boolean pausing = false, moving = true; 
    
    /*debug*/
    public void printNum() {
        System.out.println("y:" + y + "  " + "x" + x);
    }

    /**
     * 构造方法，产生一个特定的块,需要把其ErsBox也弄出来
     * @param style 块的样式，对应于STYLES中的一值
     * @param x 起始位置，对应于canvas中左上角的位置
     * @param y 起始位置， 对应于canvas中左上角的位置
     * @param level 游戏的难度，用于控制方块的下落速度
     * @param canvas 方块出现的画板
     **/
    public ErsBlock(int style, int y, int x, int level, GameCanvas canvas) {
        this.style = style;
        this.x = x;
        this.y = y;
        //printNum();
        this.level = level;
        this.canvas = canvas;
        int key = 0x8000, i, j;
        for(i = 0; i < BOXES_ROWS; ++i) {
            for(j = 0; j < BOXES_COLS; ++j) {
                boolean isColor = ((style & key) != 0);
                boxes[i][j] = new ErsBox(isColor);
                key >>= 1;
            }
        }
        //display();
    }
    
    //线程类的run函数，下落到不能下落为止
    
    public void run() {
        while(moving) {
            try {
                sleep(BETWEEN_LEVELS_DEGRESS_TIME * (MAX_LEVEL - level + LEVEL_FLATNESS_GENE));
            }
            catch (InterruptedException ie) {
                ie.printStackTrace();
            }
            display();    
            if(!pausing) {
                moving = (moveTo(y+1, x) && moving);
            }
        }
        /*debug*/
        //System.out.println("ErsBlockgame run end");
    }

    //向左移动
    public void moveLeft() {
        moveTo(y, x-1);
    }
    
    //向右移动
    public void moveRight() {
        moveTo(y, x+1);
    }

    //向下移动
    public void moveDown() {
        moveTo(y+1, x);
    }

    //块变形(用于测试的)
    public void turnNext() {

        int i, j, newStyle;
        for(i = 0; i < BLOCK_KIND_NUMBER; ++i) {
            for(j = 0; j < BLOCK_STATUS_NUMBER; ++j) {
                if(STYLES[i][j] == style) {
                    newStyle = STYLES[i][(j+1) % BLOCK_STATUS_NUMBER];
                    /*dubug*/
                //    System.out.println("trunNext:" + Integer.toHexString(newStyle));
                    turnTo(newStyle);
                    return;
                }
            }
        }
    }

    //暂停块的下落， 对应游戏暂停；
    public void pauseMove() {
        pausing = true;
    }
    
    public void resumeMove() {
        pausing = false;
    }

    //停止块的下落，对应游戏中止；
    public void stopMove() {
        moving = false;
    }

    //将当前的块从画板中抹去，只有当重新display才会显示
    private void earse() {
        int i, j;
        for(i = 0; i < BOXES_ROWS; i++) {
            for(j = 0; j < BOXES_COLS; j++) {
                if(boxes[i][j].isColorBox()) {
                    ErsBox box = canvas.getBox(y+i, x+j);
                    box.setColor(false);
                }
                /*debug*/
                if(boxes[i][j] == null)
                    System.out.println("box is null");
            }
        }
    }

    //设置当前块从画布中可显示，当再次进行画布的重画时才可以看见
    private void display() {
        int i, j;
        for(i = 0; i < BOXES_ROWS; i++){
            for(j = 0; j < BOXES_COLS; j++) {
                if(boxes[i][j].isColorBox()) {
                    ErsBox box = canvas.getBox(y+i, x+j);
                    if(box == null)
                        continue;
                    box.setColor(true);
                }
            }
        }
    }

    //用于判断是否可以移动到某个坐标
    private boolean isMoveAble(int newRow, int newCol) {
        earse();
        int i, j;
        for(i = 0; i < BOXES_ROWS; ++i) {
            for(j = 0; j < BOXES_COLS; ++j) {
                if(boxes[i][j].isColorBox()) { //只对于有颜色有有限制
                    ErsBox box = canvas.getBox(i+newRow, j+newCol);
                    if(box == null || box.isColorBox()) {
                        display();
                        return false;
                    }
                }
            }
        }
        display();
        return true;
    }

    /*用于进行移动，考虑到不能由多个线程同时控制方块，所以要声明为synchronized
     * @param newRow int, 目的地所在行
     * @param newCol int, 目的地所在列
     * return boolean, true-移动成功，false-移动失败
     */
    private synchronized boolean moveTo(int newRow, int newCol) {
        if(!isMoveAble(newRow, newCol) || !moving) {
            /*debug*/
            //System.out.println("x:" + newCol + "y:" + newRow);
            return false;
        }
        earse();
        y = newRow;
        x = newCol;
        display();
        canvas.repaint();
        return true;
    }

    //当前块能否变形为newStyle,主要是考虑边界问题；
    private boolean isTurnAble(int newStyle) {
        int i, j;
        int key = 0x8000;
        earse();
        for(i = 0; i < BOXES_ROWS; ++i) {
            for(j = 0; j < BOXES_COLS; ++j) {
                if((newStyle & key) != 0) {
                    ErsBox box = canvas.getBox(y+i, x+j);
                    if(box.isColorBox() || box == null) {
                        display();
                        return false;
                    }
                }
                key >>= 1;
            }
        }
        display();
        return true;
    }

    //将当前块变形为newStyle
    private boolean turnTo(int newStyle) {
        if(!isTurnAble(newStyle) || !moving)
            return false;
        int i, j, key=0x8000;
        earse();
        for(i = 0; i < BOXES_ROWS; ++i) {
            for(j = 0; j < BOXES_COLS; ++j) {
                boolean isColor = ((newStyle & key) != 0);
                boxes[i][j].setColor(isColor);
                key >>= 1;
            }
        }
        style = newStyle;
        display();
        canvas.repaint();
        return true;
    }

}

ErsBlocksGame.java

import Mypackage.ErsBox;
import Mypackage.ErsBlock;
import Mypackage.GameCanvas;
import Mypackage.ControlPanel;

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

public class ErsBlocksGame extends JFrame {
    //定义各种参数
    private GameCanvas canvas;
    private ControlPanel ctrlPanel;    
    private JPanel plButton;
    private JPanel ctrlPanelwithButton;
    private ErsBlock block; //当前活动的块
    private boolean playing; //当前游戏的状态
    private final static int PER_LINE_SCORE = 100; //填满一行得100;
    public final static int PER_LEVEL_SCORE = PER_LINE_SCORE * 20; //升级所需的得分
    public final static int MAX_LEVEL = 10;
    public final static int DEFAULT_LEVEL = 5;

    //控制面板的按钮
    private JButton
        btPlay = new JButton("开始"),
        btPause = new JButton("暂停"),
        btStop = new JButton("停止"),
        btTurnLevelUp = new JButton("增加难度"),
        btTurnLevelDown = new JButton("降低难度");

    //定时器（用于定时更新信息面板信息）
    Timer timer;

    //相关菜单（项）声明
    private JMenuBar bar =new JMenuBar();
    private JMenu
        mGame = new JMenu("游戏"),
        mControl = new JMenu("控制"),
        mInfo = new JMenu("帮助");
    private JMenuItem
        //游戏
        miNewGame = new JMenuItem("新游戏"),
        miSetBlockColor = new JMenuItem("设置方块颜色"),
        miSetBackColor = new JMenuItem("设置背景颜色"),
        miTurnHarder = new JMenuItem("增加难度"),
        miTurnEasier = new JMenuItem("降低难度"),
        miExit = new JMenuItem("退出"),
        //控制
        miPlay = new JMenuItem("开始"),
        miPause = new JMenuItem("暂停"),
        miResume = new JMenuItem("继续"),
        miStop = new JMenuItem("停止"),
        //菜单
        miAuthor = new JMenuItem("作者： Java游戏设计组"),
        miSourceInfo = new JMenuItem("版本： 1.0");

    public ErsBlocksGame(String title) {
        super(title);
        setSize(315, 392);
        Dimension scrSize = Toolkit.getDefaultToolkit().getScreenSize();
        setLocation((scrSize.width - getSize().width)/2, (scrSize.height - getSize().height)/2);
        ctrlPanel = new ControlPanel();
        plButton = new JPanel(new GridLayout(5,1));
        ctrlPanelwithButton = new JPanel(new BorderLayout());

        //创建菜单
        createMenu();
        //为控制按钮设置监听器
        createButton();
        //设置键盘监听器
        ctrlPanel.addKeyListener(new ControlKeyListener());//addKeyListener not for JFrame;

        Container container = getContentPane();
        container.setLayout(new BorderLayout(6, 0));
        canvas = new GameCanvas(20, 12);
        //放置
        ctrlPanelwithButton.add(ctrlPanel,BorderLayout.NORTH);
        ctrlPanelwithButton.add(plButton, BorderLayout.SOUTH);
        container.add(canvas, BorderLayout.CENTER);
        container.add(ctrlPanelwithButton, BorderLayout.EAST);
        //增加监听器
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent we) {
                stopGame();
                System.exit(0);
            }
        });
        addComponentListener(new ComponentAdapter() {
            public void componentResized(ComponentEvent ce) {
                canvas.fanning();
            }
        });

        //设置定时器
        timer = new Timer(500, new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                ctrlPanel.setScore(getScore());
                int scoreForLevelUpdate = getScoreForLevelUpdate();
                if(scoreForLevelUpdate >= PER_LEVEL_SCORE && scoreForLevelUpdate > 0)
                    levelUpdate();
            }
        });
        timer.start();//启动

        setVisible(true);
        canvas.fanning();
    }
    
    private void createButton() {
        plButton.add(btPlay);
        plButton.add(btPause);
        plButton.add(btStop);
        plButton.add(btTurnLevelUp);
        plButton.add(btTurnLevelDown);
       // plButton.setBorder(border);
        //设置各种按钮的监听器行为
        btPlay.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                playGame();
            }
        });

        btPause.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                if (btPause.getText().equals(new String("暂停"))) {
                    pauseGame();
                } else {
                    resumeGame();
                }
            }
        });

        btStop.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                stopGame();
            }
        });

        btTurnLevelUp.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                try {
                    int level = ctrlPanel.getLevel();
                    if (level < ErsBlocksGame.MAX_LEVEL)
                        ctrlPanel.setLevel(level + 1);
                } catch (NumberFormatException e) {}
                requestFocus();
            }
        });

        btTurnLevelDown.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                try {
                    int level = ctrlPanel.getLevel();
                    if (level > 1)
                        ctrlPanel.setLevel(level - 1);
                } catch (NumberFormatException e) {}
                requestFocus();
            }
        });
    }
    
    

    private void createMenu() {
        bar.add(mGame);
        bar.add(mControl);
        bar.add(mInfo);

        mGame.add(miNewGame);
        mGame.addSeparator(); //分隔条
        mGame.add(miSetBackColor);
        mGame.add(miSetBlockColor);
        mGame.addSeparator();
        mGame.add(miTurnHarder);
        mGame.add(miTurnEasier);
        mGame.addSeparator();
        mGame.add(miExit);

        mControl.add(miPlay);
        mControl.add(miPause);
        mControl.add(miResume);
        mControl.add(miStop);

        mInfo.add(miAuthor);
        mInfo.add(miSourceInfo);

        setJMenuBar(bar);

        //设置对应的菜单响应事件
        
        //设置快捷键
        miPause.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, KeyEvent.CTRL_MASK));
        miResume.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0));

        //开始菜单项
        miPlay.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                stopGame();
                reset();
                setLevel(DEFAULT_LEVEL);
            }
        });
        
        miNewGame.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                stopGame();
                reset();
                setLevel(DEFAULT_LEVEL);
            }
        });

        miSetBlockColor.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                Color newFrontColor = JColorChooser.showDialog(ErsBlocksGame.this, "设置方块颜色", canvas.getBlockColor());
                if(newFrontColor != null)
                    canvas.setBlockColor(newFrontColor);
            }
        });

        miSetBackColor.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                Color newBackColor = JColorChooser.showDialog(ErsBlocksGame.this, "设置背景颜色", canvas.getBackgroundColor());
                if(newBackColor != null) 
                    canvas.setBackgroundColor(newBackColor);
            }
        });

        miTurnHarder.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                int curLevel = getLevel();
                if(curLevel < MAX_LEVEL)
                    setLevel(curLevel + 1);
            }
        });

        miTurnEasier.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                int curLevel = getLevel();
                if(curLevel > 1) 
                    setLevel(curLevel - 1);
            }
        });

        miExit.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                System.exit(0);
            }
        });

        //控制
        miPlay.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                playGame();
            }
        });

        miPause.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                pauseGame();
            }
        });

        miResume.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                resumeGame();
            }
        });
        
        miStop.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                stopGame();
            }
        });
    }

    /*控制方法*/
    //重置
    public void reset() {
        ctrlPanel.reset();
        canvas.reset();
    }
    //get&set
    public boolean isPlaying() {
        return playing;
    }

    public ErsBlock getCurBlock() {
        return block;
    }

    public GameCanvas getCanvas() {
        return canvas;
    }

    public int getLevel() {
        return ctrlPanel.getLevel();
    }

    public void setLevel(int level) {
        if(level < 11 && level > 0)
            ctrlPanel.setLevel(level);
    }
    
    public int getScore() {
        if(canvas != null)
            return canvas.getScore();
        return 0;
    }

    public int getScoreForLevelUpdate() {
        if(canvas != null)
            return canvas.getScoreForLevelUpdate();
        return 0;
    }
    

    public void setPauseButtonLabel(boolean pause) {
        btPause.setText(pause ? "暂停" : "继续");
    }

    //控制函数(主要是让按钮事件调用）
    public void playGame() {
        play();
        btPlay.setEnabled(false);
        miPlay.setEnabled(false);
        ctrlPanel.requestFocus();
    }

    public void pauseGame() {
        if(block != null)
            block.pauseMove();
        //btPause.setEnabled(false);
        miPause.setEnabled(false);
        miResume.setEnabled(true);
        setPauseButtonLabel(false);
    }
    
    public void resumeGame() {
        if(block != null)
            block.resumeMove();
        //btPause.setEnabled(true);
        miPause.setEnabled(true);
        miResume.setEnabled(false);
        setPauseButtonLabel(true);
        ctrlPanel.requestFocus();
    }

    public void stopGame() {
        playing = false;
        if(block != null)
            block.stopMove();
        miPlay.setEnabled(true);
        miPause.setEnabled(true);
        miResume.setEnabled(false);
        btPlay.setEnabled(true);
        btPause.setEnabled(true);
    }

    public boolean levelUpdate() {
        int curLevel = getLevel();
        if(curLevel < MAX_LEVEL) {
            setLevel(curLevel + 1);
            canvas.resetScoreForLevelUpdate();
            return true;
        }
        return false;
    }
    
    //内部实现
    private void play() {
        reset();
        playing = true;
        Thread thread = new Thread(new Game());
        thread.start();
    }

    private void reportGameOver() {
        JOptionPane.showMessageDialog(this, "游戏结束");
    }
    
    /*方向键的类，作为监听类*/
    private  class ControlKeyListener extends KeyAdapter {
            public void keyPressed(KeyEvent ke) {
                /*debug*/
                //System.out.println("direction key");
                if (!isPlaying())
                    return;
                ErsBlock block = 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;
                    default:
                        break;
                }
            }
        }

    /*Game内部类，用于产生一个新的游戏局*/
    private class Game implements Runnable {
        public void run() {
            //随机产生一个方块
            int col = (int) (Math.random() * (canvas.getCols() - 3)),
                style = ErsBlock.STYLES[(int)(Math.random()*7)][(int)(Math.random()*4)];
            while(playing) {
                if(block != null) {
                    if(block.isAlive()) { //判断线程是否在活动状态
                        try {
                            Thread.currentThread().sleep(100);
                        }
                        catch(InterruptedException ie) {
                            ie.printStackTrace();
                        }
                        continue;
                    }
                }
                checkFullLine();
                if(isGameOver()) {
                    miPlay.setEnabled(true);
                    miPause.setEnabled(true);
                    miResume.setEnabled(false);
                    btPause.setEnabled(true);
                    btPlay.setEnabled(true);
                    reportGameOver();
                    return;
                }
                //创建一个游戏块
                block = new ErsBlock(style, 0, col, getLevel(), canvas);
                block.start();

                /*debug*/
                //System.out.println("new block");
                    
                //生成下一个的列和类型
                col = (int) (Math.random()*(canvas.getCols() - 3));
                style = (int)ErsBlock.STYLES[(int)(Math.random()*7)][(int)(Math.random()*4)];
                ctrlPanel.setTipStyle(style);
            }
        }
        
        /*检查是否有填满的一行*/
        public void checkFullLine() {
            int i, j, row;//i最大的检查行次数
            for(i = 0; i < canvas.getRows(); ++i) {
                row = -1; //需要移动的行
                boolean fullLineColorBox = true;
                for(j = 0; j < canvas.getCols(); ++j) {
                    if(!canvas.getBox(i, j).isColorBox()) {
                        fullLineColorBox = false;
                        break;
                    }
                }
                if(fullLineColorBox) {
                    row = i--;
                    canvas.removeLine(row); //i之上的行都在下移一行
                }
            }
        }

        private boolean isGameOver() {
            for(int j = 0; j < canvas.getCols(); j++) {
                ErsBox box = canvas.getBox(0, j);
                if(box.isColorBox()) {
                    /*debug*/
                    System.out.println("isGameOver:why");
                    return true;
                }
            }
            return false;
        }
    }

    public static void main(String[] args) {
        new ErsBlocksGame("俄罗斯方块游戏");
    }
}

makefile

ErsBlocksGame.class:ControlPanel.class GameCanvas.class ErsBlock.class ErsBlocksGame.java
    javac -d . ErsBlocksGame.java
ControlPanel.class:ErsBox.class ControlPanel.java
    javac -d . ControlPanel.java
ErsBlock.class:ErsBox.class GameCanvas.class ErsBlock.java
    javac -d . ErsBlock.java
GameCanvas.class: ErsBox.class GameCanvas.java
    javac -d . GameCanvas.java
ErsBox.class:ErsBox.java
    javac -d . ErsBox.java
clean:
    rm *.class; rm Mypackage/*.class