board.java

这是一个TetrisApplet程序,,是用JAVA开发的,提大家学习

/*
 * Board.java
 *
 * 创建于 2004年12月12日, 下午11:41
 */

package TetrisApplet;

/**
 *
 * @author  刘斌 [e-mail]
 */

import javax.swing.JPanel;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;

/**
 * 俄罗斯方块的面板类，用于绘制，移动砖块
 */
class Board extends JPanel implements java.lang.Runnable {
    
    //**************常量定义************************
    
    /**
     * 最大行数
     */
    private static final int MAX_ROWS = 36;
    
    /**
     * 最大列数
     */
    private static final int MAX_COLS = 18;
    
    /**
     * 最大的颜色数，用于随机创建砖块时给砖块赋值
     */
    private static final int MAX_COLOR_NUM = 7;
    
    /**
     * 表示该单元内容为空
     */
    private static final int BLANK_CELL = -1;
    
    /**
     * 边框的宽度，界面安排中的边框位置为：
     *
     *
     *      ＃＃＃＃＃＃边框＃＃＃＃＃＃边框＃＃＃＃
     *      ＃      面板          ＃   分数
     *      边       和           边
     *      框      砖块          框   下一个砖块
     *      ＃  （MAX_ROWS+1）*   ＃
     *      ＃   (MAX_COLS+2)     ＃
     */
    private static final int BORDER = 20;
    
    //**************变量定义************************
    
    /**
     * 砖块的颜色数组，当创建砖块时，
     * 需要随机的从该数组中选取任一颜色，作为砖块的颜色
     */
    private Color colors[];
    
    /**
     * 每次执行循环的延迟时间，也就是游戏的速度，
     * 其值越小，速度越快
     */
    private int delay = 1500;
    
    /**
     * 当前得分
     * 消一不同色的行，得100分，消一同色的行得1000分
     * 同时消两行或者两行以上得分翻倍
     **/
    private int score=0;
    
    /**
     * 显示下一个砖块的起始X坐标
     */
    private int msgX;
    
    /**
     * 游戏终止标志，当该值为True时，结束游戏，退出执行线程
     */
    public boolean gameTerminated = true;
    
    /**
     * 砖块移动到底部的标志，
     * 当该值为true是，要创建一个新的砖块
     */
    private boolean reachBottom;
    
    /**
     * 当前的砖块和下一个要出现的砖块对象
     */
    private Brick3D brick, next_brick;
    
    /**
     * BoardInfo数组用于描述面板中的砖块信息，
     * 在绘制砖块时会根据该信息绘制
     * -1 - 空 (BLANK_CELL)
     * [0,MAX_COLOR_NUM－1] - 该单元格中有砖块，其值表示砖块的颜色，
     * 是colors数组的索引。
     */
    private int[][] board_info;
    
   
    //*****************公有成员函数定义**************************************
    
    /**
     * 构造函数，创建一个Board实例
     */
    public Board() {
        //创建颜色数组，并赋值
        colors = new Color[MAX_COLOR_NUM];
        colors[0] = new Color(128, 255, 128);
        colors[1] = new Color(128, 0, 0);
        colors[2] = new Color(0, 128, 0);
        colors[3] = new Color(255, 0, 128);
        colors[4] = new Color(128, 128, 0);
        colors[5] = new Color(128, 0, 128);
        colors[6] = new Color(0, 128, 128);
        
        //设置背景颜色
        setBackground(Color.BLACK);
        
        enableEvents(java.awt.AWTEvent.MOUSE_EVENT_MASK |
                      java.awt.AWTEvent.MOUSE_WHEEL_EVENT_MASK |
                      java.awt.AWTEvent.KEY_EVENT_MASK
        );
        
        //计算消息区的起始X坐标
        msgX = 2*BORDER + (MAX_COLS+2)*Brick3D.CELL_WIDTH;
        
        //创建当前砖块和预览砖块对象
        brick = new Brick3D(0,0,Color.BLUE);
        next_brick = new Brick3D(0,0,Color.BLUE);
    }
    
    /**
     * 开始执行线程（游戏）
     */
    public void newGame() {
        grabFocus();
        //初始化BOARD_INFO数字
        reset();
        score = 0;
        gameTerminated = false;
        reachBottom = false;
        (new Thread(this)).start();
        repaint();
    }
    
    /**
     * 停止执行线程（游戏）
     */
    public void endGame() {
        gameTerminated = true;
        
        //确保线程执行结束
        long st = System.currentTimeMillis();
        while(System.currentTimeMillis() - st < delay) {} 
        
        brick.X = -1;
        next_brick.X = -1;
        repaint();
    }
    
    /**
     * 线程运行的函数
     */
    public void run() {
        while (!gameTerminated) {
            if ((brick.X == -1)||(reachBottom)) {
                createNewBrick();
                reachBottom = false;
                updateBoardInfo(true);
                updateBoardInfo(false);
            } else {
                drop();
                if (reachBottom) {
                    continue;
                }
            }
            // 控制游戏速度
            try { 
                Thread.sleep(delay);
            }
            catch (InterruptedException e) {
                System.out.println(e.toString());
            }
        }
    }
    
    /**
     * 绘制背景，边界和砖块
     */
    public void paint(Graphics g) {
        super.paint(g);
        
        //绘制背景边框
        drawBorder(g);
        
        if (brick.X == -1) {
            return;
        } 

        //根据board_info数组绘制砖块
        drawBricks(g);
        //绘制下一个砖块
        drawNextBrick(g);
        //绘制当前得分
        drawScore(g);
        
        //显示游戏结束了吗?
        if (gameTerminated) {
            g.setFont(new java.awt.Font("宋体", 0, 36));
            g.setColor(Color.RED);
            g.drawString(java.util.ResourceBundle.getBundle(
                "TetrisApplet/TetrisApplet").getString("Game_Over"),
                4*BORDER, getHeight()/2);
        }
    }
    
    
    //*****************私有成员函数定义**************************************
    
    private void reset() {
        //初始化BOARD_INFO数字
        board_info = new int[MAX_ROWS][MAX_COLS];
        for (int i=0;i<MAX_ROWS;i++) {
            for (int j=0;j<MAX_COLS;j++) {
                board_info[i][j] = BLANK_CELL;
            }
        }        
    }
    /**
     * 绘制背景边框
     */
    private void drawBorder(Graphics g) {
        g.setColor(Color.GRAY);
        
        int bottomY = BORDER + (MAX_ROWS)*Brick3D.CELL_HEIGHT;
        int rightX  = BORDER + (MAX_COLS+1)*Brick3D.CELL_WIDTH;
        
        //容器的左右壁
        int y = BORDER;
        while (y<bottomY) {
            g.fill3DRect(BORDER, y,
            Brick3D.CELL_HEIGHT, Brick3D.CELL_WIDTH, true);
            g.fill3DRect(rightX, y,
            Brick3D.CELL_HEIGHT, Brick3D.CELL_WIDTH, true);
            y+=Brick3D.CELL_HEIGHT;
        }
        
        //容器的底
        int x = BORDER;
        while(x<=rightX) {
            g.fill3DRect(x, y,
            Brick3D.CELL_HEIGHT, Brick3D.CELL_WIDTH, true);
            x += Brick3D.CELL_WIDTH;
        }
    }
    
    /**
     * 根据board_info数组绘制砖块
     */
    private void drawBricks(Graphics g) {
        for (int i=0;i<MAX_ROWS;i++) {
            for (int j=0;j<MAX_COLS;j++) {
                int c = board_info[i][j];
                if (c!=BLANK_CELL) {
                    //确保不会超出边界
                    if (c>=colors.length) {
                        c = colors.length-1;
                    }
                    g.setColor(colors[c]);
                    g.fill3DRect(BORDER + (j+1)*Brick3D.CELL_WIDTH,
                    BORDER + i*Brick3D.CELL_HEIGHT,
                    Brick3D.CELL_WIDTH,
                    Brick3D.CELL_HEIGHT, true);
                }
            }
        }
    }
    
    /**
     * 绘制下一个砖块
     */
    private void drawNextBrick(Graphics g) {
        if (next_brick == null) {
            return;