levelloader.java

一个rpg的游戏。。源码 要学习的朋友可以来下载

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 data = Tools.readFileToString(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;