gamemap.java

手机游戏

package russiangame;

import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;

/**
 * <p>Title: 俄罗斯方块</p>
 *
 * <p>Description: 俄罗斯方块游戏</p>
 *
 * <p>Copyright: Copyright (c) 2005</p>
 *
 * <p>Company: Star Group</p>
 *
 * @author: Part of this programe comes from a open-source project in the Web(www.hyweb.net).
 *          Our group makes some remakeble improvement to it.
 * @version 1.0
 */
public class GameMap {
    public static final short MAP_COL = 12;  //游戏容器区域的列
    public static final short MAP_ROW = 16;  //游戏容器区域的行
    protected int mapData[][]; //地图数据
    protected boolean mapBlockExist[]; //对应行是否有小方格
    private int nScore; //分数
    private int nLevel; //级别
    private int nMaxLevel = 4; //最高级别
    private final int nScoreofLevel[] = {100,200,500,1000};

    public static final Font font =
            Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_LARGE);

    public GameMap() {
        mapData = new int[MAP_ROW][MAP_COL];
        mapBlockExist = new boolean[MAP_ROW];
        this.nLevel = 0;
    }

    /**
     * 初始化地图数据，画出背景色，墙和底
     */
    public void init() {
        this.nScore = 0;
        this.nLevel++;

        //清空地图
        for (int i = 0; i < MAP_ROW; i++) {
            for (int j = 0; j < MAP_COL; j++) {
                this.mapData[i][j] = 0;
            }
            this.mapBlockExist[i] = false;
        }

        //设置墙和地面
        for (int i = 0; i < MAP_ROW; i++) {
            this.mapData[i][0] = 8;
            this.mapData[i][MAP_COL-1] = 8;
        }

        for (int j = 0; j < (MAP_COL-1); j++) {
            this.mapData[MAP_ROW-1][j] = 8;
        }

        this.mapBlockExist[MAP_ROW-1] = true;
    }

    /** 地图数组是一个16×12的整型
     * 第一维是行，对应于坐标系的y轴坐标
     * 第二维是列，对应于坐标系的x轴坐标
     * @param j  x轴坐标，数组对应第二维点
     * @param i  y轴坐标，数组对应第一维点
     * @return   地图数组的坐标数据
     */
    /**
     * @param j
     * @param i
     * @return
     */
    public int getData(int j, int i) {
        int data = this.mapData[i][j];
        return data;
    }

    /**
     * 返回级别
     */
    public int getLevel(){
        return this.nLevel;
    }

    /**
     * 返回游戏的最高级别
     */
    public int getMaxLevel(){
        return this.nMaxLevel;
    }

    /**
     * 返回过关时所对应的分数
     */
    public int getLevelScroe(int level){
        if(level>nMaxLevel)
            return -1;
        else
            return this.nScoreofLevel[level-1];
    }
    /**
     * 返回分数
     */
    public int getScore(){
        return this.nScore;
    }

    /** 地图数组是一个16×12的整型
     * 第一维是行，对应于坐标系的y轴坐标
     * 第二维是列，对应于坐标系的x轴坐标
     * @param j  x轴坐标，数组对应第二维点
     * @param i  y轴坐标，数组对应第一维点
     * @param vData  地图数组的坐标数据
     */
    public void setData(int j, int i, int vData) {
        if (j >= 0 && i >= 0) {
            mapData[i][j] = vData;
            mapBlockExist[i] = true;
        }
    }

    /** 绘制画布（墙和底面）
     * @param g
     */
    public void paint(Graphics g) {
        //清空屏幕
        RussianGameDisplayable.Clear(g);
        paintScore(g);
        paintLevel(g);

        for (int i = 0; i < MAP_ROW; i++) {
            for (int j = 0; j < MAP_COL; j++) {
                if (mapData[i][j] == 8) {
                    GameBlock.drawBrick(RussianGameDisplayable.GAMEAREA_X +
                                        j * RussianGameDisplayable.BRICK_WIDTH,
                                        RussianGameDisplayable.GAMEAREA_Y +
                                        i * RussianGameDisplayable.BRICK_WIDTH,
                                        g, 7);
                }
            }
        }
    }

    /**检查是否有消行行为（消1～4都返回true）
     * @param g
     * @param row
     * @return
     */
    public boolean check(Graphics g, int inputRow) {
        boolean deleteFlag = false;
        int yRow = inputRow + 4;
        if (yRow >= (MAP_ROW-1)) {
            yRow = MAP_ROW-1;
        }

        for (int y = inputRow; y < yRow; y++) {
            boolean flag = true;
            for (int j = 1; j < (MAP_COL-1); j++) {
                if (this.mapData[y][j] == 0) {
                    flag = false;
                }
            }

            if (flag) {
                this.mapBlockExist[y] = false;
                for (int j = 1; j < (MAP_COL-1); j++) {
                    this.mapData[y][j] = 0;
                }

                this.deleteRow(g, y);
                deleteFlag = true;

                this.nScore += 10;
                this.paintScore(g);
            }
        }

        return deleteFlag;
    }


    /**以行为单位，根据每格mapData[]数据中的信息画出他们的图形
     * @param g
     * @param y  传入的行号
     */
    public void drawBlock(Graphics g, int y) {
        for (int x = 1; x < (MAP_COL-1); x++) {
            if (mapData[y][x] != 0) {
                GameBlock.drawBrick(RussianGameDisplayable.GAMEAREA_X +
                                    x * RussianGameDisplayable.BRICK_WIDTH,
                                    RussianGameDisplayable.GAMEAREA_Y +
                                    y * RussianGameDisplayable.BRICK_WIDTH, g,
                                    mapData[y][x] - 1);
            }
        }
    }

    /** 有消去行为后调用,重画容器地图
     */
    public void repaintMap(Graphics g) {
        //从容器底开始，反向冒泡法
        for (int i =  (MAP_ROW-2); i > 0; i--) {
            int tmp;

            //有砖块才移动
            if (this.mapBlockExist[i]) {
                //只有下一行为空白才进行移动
                if (!this.mapBlockExist[i + 1]) {
                    tmp = i + 1;

                    if (!mapBlockExist[i + 2]) {
                        tmp = i + 2;

                        if (!mapBlockExist[i + 3]) {
                            tmp = i + 3;

                            if (!mapBlockExist[i + 4]) {
                                tmp = i + 4;
                            }
                        }
                    }

                    //从图形上删除当前行
                    this.deleteRow(g, i);

                    //逻辑上的行复制
                    for (int j = 1; j < (MAP_COL-1); j++) {
                        mapData[tmp][j] = mapData[i][j];
                        //将原先行置为逻辑空
                        mapData[i][j] = 0;
                    }

                    mapBlockExist[i] = false;
                    mapBlockExist[tmp] = true;

                    //图形上的行复制 (重画)
                    this.drawBlock(g, tmp);
                }
            }
        }
    }

    /** 删除行，只是简单的把该行置黑
     * @param g
     * @param y
     */
    public void deleteRow(Graphics g, int y) {
        g.setColor(RussianGameDisplayable.BACKGROUND);
        g.fillRect(RussianGameDisplayable.GAMEAREA_X +
                   RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.GAMEAREA_Y +
                   y * RussianGameDisplayable.BRICK_WIDTH,
                   10 * RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.BRICK_WIDTH);
    }

    /**绘制得分
     * @param g
     */
    private void paintScore(Graphics g) {
        //清除记分牌
        g.setColor(RussianGameDisplayable.BACKGROUND);
        g.fillRect(RussianGameDisplayable.GAMEAREA_X +
                   12 * RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.GAMEAREA_Y +
                   6 * RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.BRICK_WIDTH * 4,
                   RussianGameDisplayable.BRICK_WIDTH * 3);

        //计分
        g.setColor(0, 255, 0);
        g.setFont(font);
        g.drawString("SCORE",
                     RussianGameDisplayable.GAMEAREA_X +
                     14 * RussianGameDisplayable.BRICK_WIDTH,
                     RussianGameDisplayable.GAMEAREA_Y +
                     7 * RussianGameDisplayable.BRICK_WIDTH,
                     Graphics.BASELINE | Graphics.HCENTER);

        g.setColor(255, 0, 0);
        g.drawString("" + nScore,
                     RussianGameDisplayable.GAMEAREA_X +
                     14 * RussianGameDisplayable.BRICK_WIDTH,
                     RussianGameDisplayable.GAMEAREA_Y +
                     8 * RussianGameDisplayable.BRICK_WIDTH,
                     Graphics.BASELINE | Graphics.HCENTER);
    }

    /**绘制级别
     * @param g
     */
    private void paintLevel(Graphics g){
        //清除级别信息
        g.setColor(RussianGameDisplayable.BACKGROUND);
        g.fillRect(RussianGameDisplayable.GAMEAREA_X +
                   12 * RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.GAMEAREA_Y +
                   9 * RussianGameDisplayable.BRICK_WIDTH,
                   RussianGameDisplayable.BRICK_WIDTH * 4,
                   RussianGameDisplayable.BRICK_WIDTH * 3);

        //级别
        g.setColor(0, 255, 0);
        g.setFont(font);
        g.drawString("LEVEL",
                     RussianGameDisplayable.GAMEAREA_X +
                     14 * RussianGameDisplayable.BRICK_WIDTH,
                     RussianGameDisplayable.GAMEAREA_Y +
                     10 * RussianGameDisplayable.BRICK_WIDTH,
                     Graphics.BASELINE | Graphics.HCENTER);

        g.setColor(255, 0, 0);
        g.drawString("" + nLevel,
                     RussianGameDisplayable.GAMEAREA_X +
                     14 * RussianGameDisplayable.BRICK_WIDTH,
                     RussianGameDisplayable.GAMEAREA_Y +
                     11 * RussianGameDisplayable.BRICK_WIDTH,
                     Graphics.BASELINE | Graphics.HCENTER);
    }
}