levelloader.java

来自「游戏学院《天下武王》教学实例」· Java 代码 · 共 668 行 · 第 1/2 页

//package org.gamecollege.j2me.rpg;


import java.util.Hashtable;
import java.util.Vector;

import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.lcdui.game.TiledLayer;

/**
 *
 * 关卡装载器
 */
public class LevelLoader implements Runnable {
    //单例
    public static final LevelLoader instance = new LevelLoader();

    //需要装载数据的Level对象
    private Level level;

    //私有的构造函数。确保单例
    private LevelLoader() {

    }

    /**
     * 实现Runnable接口，开线程来装载关卡
     * 这样，在装载关卡数据时，我们可以在屏幕上绘制动画
     *
    */
   public void run() {
       //设置游戏状态
       MyRPGGameMIDlet.mc.setGameStatus(MyGameCanvas.STATUS_LOADING_LEVEL);

       //根据关卡号，查找相应的关卡文件，读取
       int levelNo = level.levelNo;
       //String levelFile = "/level/level" + levelNo + ".lev";
       String levelFile = "/level" + levelNo + ".lev";
       String data = Tools.readUTFFileToString2(levelFile);
       //去掉多行注释
       data = Tools.delMutilLineComment(data);

       //解析关卡文件中元数据段
       int index1 = data.indexOf("{");
       int index2 = data.indexOf("}", index1);
       parseMetaData(data.substring(index1 + 1, index2), level);
       System.out.println("parseMetaData:OK");

       //解析关卡文件技能数据段
       index1 = data.indexOf("{", index2 + 1);
       index2 = data.indexOf("}", index1 + 1);
       parseSkillsData(data.substring(index1 + 1, index2), level);
       System.out.println("parseSkillsData:OK");

       //解析关卡文件中道具数据段
       index1 = data.indexOf("{", index2 + 1);
       index2 = data.indexOf("}", index1 + 1);
       parsePropertyData(data.substring(index1 + 1, index2), level);
       System.out.println("parsePropertyData:OK");

       //解析关卡文件中NPC数据段
       index1 = data.indexOf("{", index2 + 1);
       index2 = data.indexOf("}", index1 + 1);
       parseNPCData(data.substring(index1 + 1, index2), level);
       System.out.println("parseNPCData:OK");

       //解析关卡文件中主角数据段
       index1 = data.indexOf("{", index2 + 1);
       index2 = data.indexOf("}", index1 + 1);
       String palyerData = data.substring(index1 + 1, index2).trim();
       parsePlayerData(palyerData, level);
       System.out.println("parsePlayerData:OK");

       //解析关卡文件中连接区数据段
       index1 = data.indexOf("{", index2 + 1);
       index2 = data.indexOf("}", index1 + 1);
       parseLinkData(data.substring(index1 + 1, index2), level);
       System.out.println("parseLinkData:OK");

       //循环解析关卡文件中各个地图数据段
        while (true) {
            index1 = data.indexOf("{", index2 + 1);
            if (index1 < 0) {
                break;
            }
            index2 = data.indexOf("}", index1 + 1);
            parseMapData(data.substring(index1 + 1, index2), level);
            System.out.println("a map ok");
        }
        //通知canvas关卡装载完毕
        MyRPGGameMIDlet.mc.handLevelLoaded();
    }


    /**
     * 装载关卡数据，开线程进行
     * @param level
     */
    public void loadLevel(Level level) {

        this.level = level;
        if (MyRPGGameMIDlet.mc.getGameStatus() !=
            MyGameCanvas.STATUS_LOADING_LEVEL) {
            new Thread(this).start();
        }

    }

    /**
     * 解析主角数据段
     * @param pd 主角数据
     * @param level 待设置的关卡
     */

    private void parsePlayerData(String pd, Level level) {
        if (level.levelNo != 0) {
            return;
        }

        StringTokenizer st = new StringTokenizer(pd, "|");

        Player p = MyRPGGameMIDlet.mc.myPlayer;

        //清空主角的护具，药品，技能，武器4个Vector
        p.jacketVec.removeAllElements();
        p.medicVec.removeAllElements();
        p.skillVec.removeAllElements();
        p.weaponVec.removeAllElements();

        //读取主角属性数据，并设置，当这些属性值不为-1时，代表这些属性值已经在别处设置
        //比如说读取存档
        String item = st.nextToken();
        if (p.rate == -1)
            p.rate = Integer.parseInt(item);

        item = st.nextToken();
        if (p.money == -1)
            p.money = Integer.parseInt(item);

        item = st.nextToken();
        if (p.hp == -1)
            p.hp = Integer.parseInt(item);

        item = st.nextToken();
        if (p.mp == -1)
            p.mp = Integer.parseInt(item);

        item = st.nextToken();
        if (p.exp == -1)
            p.levelInitExp = p.exp = Integer.parseInt(item);
        //升级公式，升级要达到的经验值为上一个级别的1.5倍
        if (p.nextExp == -1)
            p.nextExp = p.exp * 3 / 2;

        item = st.nextToken();
        if (p.rank == -1)
            p.rank = Integer.parseInt(item);

        item = st.nextToken();
        if (p.attackPoint == -1)
            p.attackPoint = Integer.parseInt(item);

        item = st.nextToken();
        if (p.defendPoint == -1)
            p.defendPoint = Integer.parseInt(item);

        //解析主角数据时，如果主角的propertyIDs和skillIDs属性已经设置，那么就初始化
        //主角的护具，药品，技能，武器4个Vector
        if (p.propertyIDs != null) {
            StringTokenizer st2 = new StringTokenizer(p.propertyIDs, "|");
            while (st2.hasMoreTokens()) {
                String id = st2.nextToken().trim();
                Property p2 = (Property) level.properties.get(Integer
                        .valueOf(id));
                if (p2.type == 1) {
                    p.weaponVec.addElement(p2);
                } else if (p2.type == 2) {
                    p.medicVec.addElement(p2);
                } else if (p2.type == 3) {
                    p.jacketVec.addElement(p2);
                }
            }
        }

        System.out.println("p.skillIDs=" + p.skillIDs);

        if (p.skillIDs != null) {
            StringTokenizer st2 = new StringTokenizer(p.skillIDs, "|");
            while (st2.hasMoreTokens()) {
                String id = st2.nextToken().trim();
                Skill p2 = (Skill) level.skills.get(Integer.valueOf(id));
                p.skillVec.addElement(p2);
            }
        }

    }


    /**
     * 解析连接区数据
     * @param ld 连接区数据
     * @param level 关卡
     */

    private void parseLinkData(String ld, Level level) {
        StringTokenizer st = new StringTokenizer(ld, "|");
        Hashtable ht = new Hashtable();
        while (st.hasMoreTokens()) {
            String linkData = st.nextToken().trim();
            linkData = linkData.substring(1, linkData.length() - 1);

            StringTokenizer st2 = new StringTokenizer(linkData, ",");
            Linker linker = new Linker();

            String item = st2.nextToken().trim();
            linker.ID = Integer.parseInt(item);

            item = st2.nextToken().trim();
            linker.belongMapID = Integer.parseInt(item);

            item = st2.nextToken().trim();
            linker.colNo = Integer.parseInt(item);

            item = st2.nextToken().trim();
            linker.rowNo = Integer.parseInt(item);

            item = st2.nextToken().trim();
            linker.nextLevelID = Integer.parseInt(item);

            item = st2.nextToken().trim();
            linker.nextMapID = Integer.parseInt(item);

            item = st2.nextToken().trim();
            linker.newHeroColNo = Integer.parseInt(item);

            item = st2.nextToken().trim();
            linker.newHeroRowNo = Integer.parseInt(item);

            ht.put(new Integer(linker.ID), linker);
        }

        level.links = ht;

    }


    /**
     * 解析地图区数据
     * @param md
     * @param level
     */

    private void parseMapData(String md, Level level) {

        StringTokenizer st = new StringTokenizer(md, "#");
        Hashtable ht = level.maps;
        if (level.maps == null) {
            ht = new Hashtable();
        }

        String item = st.nextToken();
        StringTokenizer st2 = new StringTokenizer(item, "|");

        String item2 = st2.nextToken().trim();

        Map map = new Map();
        map.mapNo = Integer.parseInt(item2);

        item2 = st2.nextToken();
        map.description = item2;
        item2 = st2.nextToken();
        map.cols = Integer.parseInt(item2);

        item2 = st2.nextToken();
        map.rows = Integer.parseInt(item2);

        item2 = st2.nextToken();
        map.heroAppearCol = Integer.parseInt(item2);

        item2 = st2.nextToken();
        map.heroAppearRow = Integer.parseInt(item2);

        item2 = st2.nextToken().trim();
        //不是可能发生随机战斗的地图
        if (item2.indexOf("-1") >= 0) {
            map.isFightMap = false;
        } else {
            //是可能发生随机战斗的地图，设置地图的随机战斗背景图
            map.isFightMap = true;
            StringTokenizer st3 = new StringTokenizer(item2, ",");
            map.randFightBgImages = new Vector();
            while (st3.hasMoreTokens()) {
                String temp = st3.nextToken().trim();
                map.randFightBgImages.addElement(level.allImages.get(Integer
                        .valueOf(temp)));
            }
        }

        item2 = st2.nextToken();

        map.rpgObjects = new Vector();
        //设置地图上npc,道具分布
        String npcs = st.nextToken().trim();
        st2 = new StringTokenizer(npcs, "|");
        while (st2.hasMoreTokens()) {
            String npc = st2.nextToken();
            npc = npc.substring(1, npc.length() - 1);
            int index1 = npc.indexOf(",");
            int index2 = npc.indexOf(",", index1 + 1);
            NPC Npc = (NPC) level.npcs.get(Integer.valueOf(npc.substring(0,
                    index1)));
            Npc.colNo = Integer.parseInt(npc.substring(index1 + 1, index2));
            Npc.rowNo = Integer.parseInt(npc.substring(index2 + 1));
            map.rpgObjects.addElement(GameInnerThread.cloneNpc(Npc));
        }
        //地图所用材质图
        Image material = (Image) level.allImages.get(Integer.valueOf(item2));
        //碰撞区
        String noWalkArea = st.nextToken();
        st2 = new StringTokenizer(noWalkArea, "|");
        TiledLayer tl = new TiledLayer(map.cols, map.cols, material,
                                       level.tileWidth, level.tileHeight);

        int count = 0;
        while (st2.hasMoreTokens()) {
            int column = count % map.cols;
            int row = (count - column) / map.cols;
            tl.setCell(column, row, Integer.parseInt(st2.nextToken().trim()));
            count++;
        }

        map.collisionArea = tl;
        map.walkableArea = new Vector();