java实现俄罗斯方块游戏

public class ControlPanel extends JPanel {
 private static final long serialVersiOnUID= 3900659640646175724L;// 用来表明不同版本之间类的兼容性

 // 定义文本框
 private JTextField tfLevel = new JTextField("" + RussiaBlocksGame.DEFAULT_LEVEL), tfScore = new JTextField("0"),
 tfTime = new JTextField(" ");

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

 // 创建面板容器类为边界布局BorderLayout()
 private JPanel plTip = new JPanel(new BorderLayout());

 private TipPanel plTipBlock = new TipPanel();

 // 创建信息面板容器类为网格布局GridLayout(4,1)，4行1列
 private JPanel plInfo = new JPanel(new GridLayout(4, 1));

 // 创建按钮面板容器类为网格布局GridLayout(6,1)
 private JPanel plButton = new JPanel(new GridLayout(6, 1));

 // 定义时间类
 // private Timer timer;

 // 创建组件边框Boreder，EtchedBorder“浮雕化”边框
 private Border border = new EtchedBorder(EtchedBorder.RAISED, Color.white, new Color(148, 145, 140));

 /*
 * 控制面板类的构造函数
 */
 public ControlPanel(final RussiaBlocksGame game) {
 // TODO Auto-generated constructor stub

 // 创建网格布局，GridLayout(3,1,0,2)， 指定 行数 和 列数 的网格布局, 并指定 水平 和 竖直 网格间隙
 setLayout(new GridLayout(3, 1, 0, 2));

 // 添加组件
 plTip.add(new JLabel("下一个方块"), BorderLayout.NORTH);
 plTip.add(plTipBlock);
 plTip.setBorder(border);

 plInfo.add(new JLabel("难度系数"));
 plInfo.add(tfLevel);
 plInfo.add(new JLabel("得分"));
 plInfo.add(tfScore);
 plInfo.setBorder(border);

 plButton.add(btPlay);
 btPlay.setEnabled(true);
 plButton.add(btPause);
 btPause.setEnabled(false);
 plButton.add(btStop);
 btStop.setEnabled(false);
 plButton.add(btTurnLevelDown);
 plButton.add(btTurnLevelUp);
 plButton.setBorder(border);

 tfLevel.setEnabled(false);
 tfScore.setEnabled(false);
 tfTime.setEnabled(false);

 add(plTip);
 add(plInfo);
 add(plButton);
 }

 // 初始化菜单栏
 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("终止游戏"),
 miRule = new JMenuItem("游戏规则"), miAuthor = new JMenuItem("关于本游戏");

 /**
 * 建立并设置窗口菜单
 */
 private void creatMenu() {
 bar.add(mGame);
 bar.add(mControl);
 bar.add(mInfo);

 mGame.add(miNewGame);
 mGame.addSeparator();
 mGame.add(miSetBlockColor);
 mGame.add(miSetBackColor);
 mGame.addSeparator();
 mGame.add(miTurnHarder);
 mGame.add(miTurnEasier);
 mGame.addSeparator();
 mGame.add(miExit);
 mControl.add(miPlay);
 miPlay.setEnabled(true);
 mControl.add(miPause);
 miPause.setEnabled(false);
 mControl.add(miResume);
 miResume.setEnabled(false);
 mControl.add(miStop);
 miStop.setEnabled(false);

 mInfo.add(miRule);
 mInfo.add(miAuthor);
 setJMenuBar(bar);

 miNewGame.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 stopGame();
 reset();
 setLevel(DEFAULT_LEVEL);
 }
 });

 // 设置方块颜色
 miSetBlockColor.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 Color newFrOntColor= JColorChooser.showDialog(RussiaBlocksGame.this, "设置方块颜色",
 canvas.getBackgroundColor());
 if (newFrontColor != null) {
 canvas.setBlockColor(newFrontColor);
 }
 }
 });

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

 // 定义菜单栏"关于"的功能，弹出确认框。
 miAuthor.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 JOptionPane.showMessageDialog(null, "软件工程(4)班\n3115005372\n杨宇杰\n©一切解释权归杨宇杰所有", "关于俄罗斯方块 - 2016", 1);
 }
 });

 // 游戏规则说明
 miRule.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 JOptionPane.showMessageDialog(null,
 "由小方块组成的不同形状的板块陆续从屏幕上方落下来，\n玩家通过调整板块的位置和方向，使它们在屏幕底部拼\n出完整的一条或几条。这些完整的横条会随即消失，给新\n落下来的板块腾出空间，与此同时，玩家得到分数奖励。\n没有被消除掉的方块不断堆积起来，一旦堆到屏幕顶端，\n玩家便告输，游戏结束。",
 "游戏规则", 1);
 }
 });

 // 增加难度
 miTurnHarder.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 int curLevel = getLevel();
 if (!playing && curLevel  1) {
 setLevel(curLevel - 1);
 }
 }
 });

 // 退出按钮动作响应
 miExit.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 System.exit(0);
 }
 });

 }

 /*
 * 添加事件监听
 */
 /*
 * 开始游戏
 */
 btPlay.addActionListener(new ActionListener() {

 @Override
 public void actionPerformed(ActionEvent ae) {
 // TODO Auto-generated method stub
 game.playGame();

 }
 });

 /*
 * 暂停游戏
 */
 btPause.addActionListener(new ActionListener() {

 @Override
 public void actionPerformed(ActionEvent ae) {
 // TODO Auto-generated method stub
 if (btPause.getText().equals("暂停")) {
 game.pauseGame();
 } else {
 game.resumeGame();
 }
 }
 });

 /*
 * 停止游戏
 */
 btStop.addActionListener(new ActionListener() {

 @Override
 public void actionPerformed(ActionEvent ae) {
 // TODO Auto-generated method stub
 game.stopGame();

 }
 });

 /*
 * 升高难度
 */
 btTurnLevelUp.addActionListener(new ActionListener() {

 @Override
 public void actionPerformed(ActionEvent ae) {
 // TODO Auto-generated method stub
 try {
 int level = Integer.parseInt(tfLevel.getText());
 if (level  1) {
 tfLevel.setText("" + (level - 1));

 }

 } catch (NumberFormatException e) {
 // TODO: handle exception
 requestFocus();
 }

 }
 });

 /*
 * 主要用于解决Jframe窗口大小变化时，里面的组件的位置也会自适应的移动。
 */
 addComponentListener(new ComponentAdapter() {
 public void componentResized(ComponentEvent ce) {
 plTipBlock.fanning();
 }
 });

public class ErsBox implements Cloneable {

 private boolean isColor;
 private Dimension size = new Dimension(); // Dimension类封装单个对象中组件的宽度和高度(精确到整数)

 /*
 * 方格类构造函数 isColor是不是用前景色为此方格着色，true前景色，false背景色
 */
 public ErsBox(boolean isColor) {
 // TODO Auto-generated constructor stub
 this.isColor = isColor;
 }

 /*
 * 设置方格的颜色 true前景色，false背景色
 */
 public void setColor(boolean isColor) {
 // TODO Auto-generated method stub
 this.isColor = isColor;

 }

 /*
 * 得到此方格的尺寸
 */
 public Dimension getSize() {
 return size;
 }

 /**
 * 设置方格的尺寸，
 *
 * @param size Dimension ,方格的尺寸
 */
 public void setSize(Dimension size) {
 this.size = size;
 }

 /*
 * 覆盖object的object clone()，实现克隆
 */
 public Object clone() {
 Object clOned= null;
 try {
 clOned= super.clone();
 } catch (Exception ex) {
 // TODO: handle exception
 ex.printStackTrace();
 }
 return cloned;

 }

 /**
 * 此方格是不是用前景色表现
 *
 * @return boolean ，true用前景色表现，false 用背景色表现
 */
 public boolean isColorBox() {
 // TODO Auto-generated method stub
 return isColor;
 }

}

public class ErsBlock extends Thread {

 // 一个块占得4行
 public static final int BOXES_ROWS = 4;

 // 一个块占4列
 public static final int BOXES_COLS = 4;

 /*
 * 让升级变化平滑的因子，避免最后几级之间的速度相差近一倍
 */
 public final static int LEVEL_FLATNESS_GENE = 3;

 // 相近的两级之间，块每下落一行的时间差别为多少（毫秒）
 public final static int BETWEEN_LEVELS_DEGRESS_TIME = 50;

 // 方块的样式数目为7
 public final static int BLOCK_KIND_NUMBER = 7;

 // 每一个样式的方块反转状态种类为4
 public final static int BLOCK_STASTUS_NUMBER = 4;

 /**
 * 分别对应7中模型的28中状态
 */
 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 }, // 方块的四种状态
 };

 private GameCanvas canvas;
 private ErsBox[][] boxes = new ErsBox[BOXES_ROWS][BOXES_COLS];
 private int style, y, x, level;
 private boolean pausing = false, moving = true;

 /*
 * 构造一个函数，产生一个特定的块 style为块的样式，对应STYLES中的某一个 y起始位置，左上角在canvas中的坐标行
 * x起始位置，左上角在canvas中的坐标列 level游戏等级控制下降速度 canvas面板
 */
 public ErsBlock(int style, int y, int x, int level, GameCanvas canvas) {
 this.style = style;
 this.y = y;
 this.x = x;
 this.level = level;
 this.canvas = canvas;

 int key = 0x8000;
 for (int i = 0; i >= 1;
 }
 }
 display();
 }

 /*
 * 线程类的run()函数覆盖，下落块，直到块不能再下落
 */
 @Override
 public void run() {
 while (moving) {
 try {
 sleep(BETWEEN_LEVELS_DEGRESS_TIME * (RussiaBlocksGame.MAX_LEVEL - level + LEVEL_FLATNESS_GENE));
 } catch (InterruptedException ie) {
 ie.printStackTrace();
 }
 // 后边的moving是表示在等待的100毫秒间，moving没有被改变
 if (!pausing) {
 moving = (moveTo(y + 1, x) && moving);
 }
 }
 }

 /*
 * 块左移一格
 */
 public void moveLeft() {
 // TODO Auto-generated method stub
 moveTo(y, x - 1);
 }

 /*
 * 块右移一格
 */
 public void moveRight() {
 // TODO Auto-generated method stub
 moveTo(y, x + 1);
 }

 /**
 * 块下移一格
 */
 public void moveDown() {
 // TODO Auto-generated method stub
 moveTo(y + 1, x);
 }

 /*
 * 块变形
 */
 public void turnNext() {
 for (int i = 0; i >= 1;
 }
 }
 display();
 return true;
 }

 /*
 * 将当前块变成newStyle所指定的块样式 newStyle ，希望改变的样式，对应STYLES中的某一个 true 改变成功，false改变失败
 */
 private boolean turnTo(int newStyle) {
 // TODO Auto-generated method stub
 if (!isTurnAble(newStyle) || !moving) {
 return false;
 }

 erase();
 int key = 0x8000;
 for (int i = 0; i >= 1;
 }
 }
 style = newStyle;

 display();
 canvas.repaint();

 return true;
 }

}

public RussiaBlocksGame(String title) {
 super(title); // 设置标题
 setSize(500, 600); // 设置窗口大小
 setLocationRelativeTo(null); // 设置窗口居中

 creatMenu();
 Container cOntainer= getContentPane(); // 创建菜单栏
 container.setLayout(new BorderLayout(6, 0)); // 设置窗口的布局管理器
 canvas = new GameCanvas(20, 15); // 新建游戏画布
 ctrlPanel = new ControlPanel(this); // 新建控制面板
 container.add(canvas, BorderLayout.CENTER); // 左边加上画布
 container.add(ctrlPanel, BorderLayout.EAST); // 右边加上控制面板

 // 注册窗口事件。当点击关闭按钮时，结束游戏，系统退出。
 addWindowListener(new WindowAdapter() {
 @Override
 public void windowClosing(WindowEvent we) {
 stopGame();
 System.exit(0);
 }
 });

 // 根据窗口大小，自动调节方格的尺寸
 addComponentListener(new ComponentAdapter() {
 @Override
 public void componentResized(ComponentEvent ce) {
 canvas.adjust();
 }
 });

 setVisible(true);
 canvas.adjust();
 }

 /**
 * 让游戏复位
 */
 public void reset() { // 画布复位，控制面板复位
 ctrlPanel.setPlayButtonEnable(true);
 ctrlPanel.setPauseButtonEnable(false);
 ctrlPanel.setPauseButtonLabel(true);
 ctrlPanel.setStopButtonEnable(false);
 ctrlPanel.setTurnLevelDownButtonEnable(true);
 ctrlPanel.setTurnLevelUpButtonEnable(true);
 miPlay.setEnabled(true);
 miPause.setEnabled(false);
 miResume.setEnabled(false);
 miStop.setEnabled(false);
 ctrlPanel.reset();
 canvas.reset();
 }

 /**
 * 判断游戏是否还在进行
 *
 * @return boolean,true -还在运行，false-已经停止
 */
 public boolean isPlaying() {
 return playing;
 }

 /**
 * 得到当前活动的块
 *
 * @return ErsBlock,当前活动块的引用
 */
 public ErsBlock getCurBlock() {
 return block;
 }

 /**
 * 得到当前画布
 *
 * @return GameCanvas,当前画布的引用
 */
 public GameCanvas getCanvas() {
 return canvas;
 }

 /**
 * 开始游戏
 */
 public void playGame() {
 play();
 ctrlPanel.setPlayButtonEnable(false);
 ctrlPanel.setPauseButtonEnable(true);
 ctrlPanel.setPauseButtonLabel(true);
 ctrlPanel.setStopButtonEnable(true);
 ctrlPanel.setTurnLevelDownButtonEnable(false);
 ctrlPanel.setTurnLevelUpButtonEnable(false);
 miStop.setEnabled(true);
 miTurnHarder.setEnabled(false);
 miTurnEasier.setEnabled(false);
 ctrlPanel.requestFocus(); // 设置焦点
 }

 /**
 * 游戏暂停
 */
 public void pauseGame() {
 if (block != null) {
 block.pauseMove();
 }
 ctrlPanel.setPlayButtonEnable(false);
 ctrlPanel.setPauseButtonLabel(false);
 ctrlPanel.setStopButtonEnable(true);
 miPlay.setEnabled(false);
 miPause.setEnabled(false);
 miResume.setEnabled(true);
 miStop.setEnabled(true);
 }

 /**
 * 让暂停中的游戏继续
 */
 public void resumeGame() {
 if (block != null) {
 block.resumeMove();
 }
 ctrlPanel.setPlayButtonEnable(false);
 ctrlPanel.setPauseButtonEnable(true);
 ctrlPanel.setPauseButtonLabel(true);
 miPause.setEnabled(true);
 miResume.setEnabled(false);
 ctrlPanel.requestFocus();
 }

 /**
 * 用户停止游戏
 */
 public void stopGame() {
 playing = false;
 if (block != null) {
 block.stopMove();
 }
 ctrlPanel.setPlayButtonEnable(true);
 ctrlPanel.setPauseButtonEnable(false);
 ctrlPanel.setPauseButtonLabel(true);
 ctrlPanel.setStopButtonEnable(false);
 ctrlPanel.setTurnLevelDownButtonEnable(true);
 ctrlPanel.setTurnLevelUpButtonEnable(true);
 miPlay.setEnabled(true);
 miPause.setEnabled(false);
 miResume.setEnabled(false);
 miStop.setEnabled(false);
 miTurnHarder.setEnabled(true);
 miTurnEasier.setEnabled(true);
 reset();// 重置画布和控制面板
 }

 /**
 * 得到游戏者设置的难度
 *
 * @return int ，游戏难度1-MAX_LEVEL
 */
 public int getLevel() {
 return ctrlPanel.getLevel();
 }

 /**
 * 用户设置游戏难度
 *
 * @param level int ，游戏难度1-MAX_LEVEL
 */
 public void setLevel(int level) {
 if (level <11 && level > 0) {
 ctrlPanel.setLevel(level);
 }
 }

 /**
 * 得到游戏积分
 *
 * @return int，积分
 */
 public int getScore() {
 if (canvas != null) {
 return canvas.getScore();
 }
 return 0;
 }

 /**
 * 得到自上次升级以来的游戏积分，升级以后，此积分清零
 *
 * @return int,积分
 */
 public int getScoreForLevelUpdate() {
 if (canvas != null) {
 return canvas.getScoreForLevelUpdate();
 }
 return 0;
 }

 /**
 * 当积分累积到一定数值时，升一次级
 *
 * @return Boolean，true-update succeed，false-update fail
 */
 public boolean levelUpdate() {
 int curLevel = getLevel();
 if (curLevel