gameblock.java

手机游戏

            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < 4; k++) {
                    this.blockNow[i][j][k] = nowPattern[i][j][k];
                }
            }
        }
    }

    /**
     * 设置下一个下坠物变量的内容。只需要包存4中旋转变化中的第一种即可，所以rot维值=0
     * @param nowblock int[][][] 7种下坠物常量之一
     */
    public void setNextBrick(int[][][] nowblock) {
        this.blockNext = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int k = 0; k < 4; k++) {
                //默认为第一维
                this.blockNext[i][k] = nowblock[0][i][k];
            }
        }
    }

    /**
     * 画小方块
     * @param px x坐标
     * @param py y坐标
     * @param g Graphics
     * @param colorIndex 颜色索引值
     */
    public static void drawBrick(int px, int py, Graphics g, int colorIndex) {
        g.setColor(255, 255, 255);
        g.fillRect(px, py, RussianGameDisplayable.BRICK_WIDTH, 1);
        g.fillRect(px, py, 1, RussianGameDisplayable.BRICK_WIDTH);

        g.setColor(0x00c0c0c0);
        g.fillRect(px + RussianGameDisplayable.BRICK_WIDTH - 1, py + 1, 1,
                   RussianGameDisplayable.BRICK_WIDTH - 1);
        g.fillRect(px + 1, py + RussianGameDisplayable.BRICK_WIDTH - 1,
                   RussianGameDisplayable.BRICK_WIDTH - 2, 1);

        g.setColor(BRICK_COLORS[colorIndex]);
        g.fillRect(px + 1, py + 1, RussianGameDisplayable.BRICK_WIDTH - 1,
                   RussianGameDisplayable.BRICK_WIDTH - 1);
    }

    /**blockpattern[rot][i][j]后二维是一个平面图形，其中i是逻辑行， 对应图形y轴，j是逻辑列，对应图形x轴
     * @param g
     */
    public void drawBlock(Graphics g) {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (this.blockNow[this.rot][i][j] == 1) {
                    drawBrick(RussianGameDisplayable.GAMEAREA_X +
                              (xBrick + j) * RussianGameDisplayable.BRICK_WIDTH,
                              RussianGameDisplayable.GAMEAREA_Y +
                              (yBrick + i) * RussianGameDisplayable.BRICK_WIDTH,
                              g, this.nBrickIDNow - 1);

                }
            }
        }
    }

    /**在游戏容器的右边绘出下一个下坠物
     * @param g
     */
    public void drawNextBlock(Graphics g) {
        g.setColor(RussianGameDisplayable.BACKGROUND);
        g.fillRect(RussianGameDisplayable.GAMEAREA_X +
                   12 * RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.GAMEAREA_Y +
                   2 * RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.BRICK_WIDTH * 4,
                   RussianGameDisplayable.BRICK_WIDTH * 4);

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (this.blockNext[i][j] == 1) {
                    drawBrick(RussianGameDisplayable.GAMEAREA_X +
                              12 * RussianGameDisplayable.BRICK_WIDTH +
                              j * RussianGameDisplayable.BRICK_WIDTH,
                              RussianGameDisplayable.GAMEAREA_Y +
                              2 * RussianGameDisplayable.BRICK_WIDTH +
                              i * RussianGameDisplayable.BRICK_WIDTH,
                              g, this.nBrickIDNext - 1);
                }
            }
        }
    }

    /**
     *初始化函数
     */
    public void init() {
        this.nBrickIDNow = this.nBrickIDNext;
        this.nBrickIDNext = Math.abs(rand.nextInt() % 7) + 1;

        //首先初始化当前下坠物
        switch (this.nBrickIDNow) {
        case 1: setCurrentBrick(this.block_tian);
            break;
        case 2: setCurrentBrick(block_reverse_L);
            break;
        case 3: setCurrentBrick(block_L);
            break;
        case 4: setCurrentBrick(block_I);
            break;
        case 5: setCurrentBrick(block_Z);
            break;
        case 6: setCurrentBrick(block_reverse_Z);
            break;
        case 7: setCurrentBrick(block_T);
            break;
        }

        //初始化下一个下坠物
        switch (this.nBrickIDNext) {
        case 1: setNextBrick(block_tian);
            break;
        case 2: setNextBrick(block_reverse_L);
            break;
        case 3: setNextBrick(block_L);
            break;
        case 4: setNextBrick(block_I);
            break;
        case 5: setNextBrick(block_Z);
            break;
        case 6: setNextBrick(block_reverse_Z);
            break;
        case 7: setNextBrick(block_T);
            break;
        }

        //初始化下坠物出现的位置（游戏容器的Brick宽度为:12 - 2 = 10）
        this.xBrick = 5;
        this.yBrick = 0;
        this.rot = 0;

        //判断map数据，决定yBrick的真正值,之所以这么处理，
        //是因为当game over的时候，最后一个下坠物，可能只能画出一部分
        //为了达到这个效果,必须让yBrick成为一个恰当的负值
        while (isCrashAtBegin()) {
            yBrick--;
            if (yBrick < -4) {
                break;
            }
        }

        //存储旧的位置
        this.oldXBrick = this.xBrick;
        this.oldYBrick = this.yBrick;
        this.oldRot = this.rot;

    }

    /**
     * 判断下坠物刚刚出现的时候是不是和map中已有的砖块重叠
     * 如果重叠的话则只需画出部分下坠物的情况
     * @return true:有重叠,false:无重叠
     */
    public boolean isCrashAtBegin() {
        for (int i = 3; i >= 0; i--) {
            for (int j = 0; j < 4; j++) {
                int nextXBrick = this.xBrick + j;
                int nextYBrick = this.yBrick + i;

                if (nextYBrick < 0) {
                    nextYBrick = 0;
                }

                if (this.blockNow[rot][j][i] == 1
                    && map.getData(nextXBrick, nextYBrick) != 0 &&
                    map.getData(nextXBrick, nextYBrick) != 8) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 检测当前的方块能否向左或者向右移动
     * @param direct
     * @return
     */
    public boolean checkMove(short direct) {
        boolean check = true;

        for (int i = 0; i < 4; i++) {
            if (direct == this.MOVE_LEFT) {
                //左移
                int line = 0;
                while (line <= 3) {
                    if (this.blockNow[rot][i][line] == 1) {
                        if (map.getData(xBrick + line - 1, yBrick + i) != 0) {
                            check = false;
                        }
                        //终止循环
                        line = 4;
                    } else {
                        line++;
                    }
                }

            } else {
                //右移
                int line = 3;
                while (line >= 0) {
                    if (this.blockNow[rot][i][line] == 1) {
                        if (map.getData(xBrick + line + 1, yBrick + i) != 0) {
                            check = false;
                        }
                        //终止循环
                        line = -1;
                    } else {
                        line--;
                    }
                }
            }
        }
        return check;
    }

    /**
     * 响应键盘消息，向左或者向右移动方块
     */
    public void move(short direct) {
        if (direct == this.MOVE_LEFT) {
            xBrick = xBrick - 1;
        } else {
            xBrick = xBrick + 1;
        }
    }

    /**
     * 判断是否能旋转
     * @return
     */
    public boolean checkRot() {
        boolean check = true;
        int tmpRot = this.rot + 1;
        if (tmpRot == 4) {
            tmpRot = 0;
        }

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (this.blockNow[tmpRot][i][j] == 1) {
                    if (xBrick < 0) {
                        check = false;
                    } else if (map.getData(xBrick + j, yBrick + i) != 0) {
                        check = false;
                    }
                }
            }
        }
        return check;
    }


    /**
     * 旋转下坠物
     */
    public void rotBlock() {
       rot = (++rot) % 4;
    }

    /** 判断下坠物是否能下移
     * @return
     */
    public boolean checkDown() {
        boolean check = true;
        for (int j = 0; j < 4; j++) {//方块有4列，每列都要测试一次
            int iRow = 3;
            while (iRow >= 0) {//向下探测4行
                if (this.blockNow[rot][iRow][j] == 1) {//仅比较方块中有小方格的点
                    if (map.getData(this.xBrick + j, this.yBrick + iRow + 1) !=
                        0) {//产生冲突
                        check = false; //不能下降
                    }
                    iRow = -1;  //退出循环
                } else {
                    iRow--;
                }
            }
        }
        return check;
    }


    /**
     * 下坠物下移1行
     */
    public void down() {
        this.yBrick = this.yBrick + 1;
    }

    /**
     * 自绘函数，绘制方块
     */
    public synchronized void paint(Graphics g) {
        g.setColor(RussianGameDisplayable.BACKGROUND);

        //清理原先背景(象素级重画fillRect())
        for (int j = 0; j < 4; j++) {
            for (int i = 0; i < 4; i++) {
                if (this.blockNow[this.oldRot][i][j] == 1) {
                    g.fillRect(RussianGameDisplayable.GAMEAREA_X +
                               (this.oldXBrick + j) *
                               RussianGameDisplayable.BRICK_WIDTH,
                               RussianGameDisplayable.GAMEAREA_Y +
                               (this.oldYBrick + i) *
                               RussianGameDisplayable.BRICK_WIDTH,
                               RussianGameDisplayable.BRICK_WIDTH,
                               RussianGameDisplayable.BRICK_WIDTH);
                }
            }
        }

        //重画新下坠物
        drawBlock(g);

        //储存旧坐标
        this.oldRot = this.rot;
        this.oldXBrick = this.xBrick;
        this.oldYBrick = this.yBrick;
    }

    /**
     * 返回方块的Y坐标
     */
    public int getYBrick() {
        return this.yBrick;
    }

    /**
     * 根据下坠物的当前位置设置地图数据
     */
    public void fixBlock() {
        for (int j = 0; j < 4; j++) {
            for (int i = 0; i < 4; i++) {
                if (this.blockNow[rot][i][j] == 1) {
                    map.setData(this.xBrick + j, this.yBrick + i,
                                this.nBrickIDNow);
                }
            }
        }
    }
}