www.pudn.com > TXWW.rar > GameInnerThread.java


/* 
 * Created on 2005-7-20 
 * 
 * TODO To change the template for this generated file go to 
 * Window - Preferences - Java - Code Style - Code Templates 
 */ 
package org.gamecollege.j2me.rpg; 
 
 
import java.util.Enumeration; 
import java.util.Random; 
import java.util.Vector; 
 
import javax.microedition.lcdui.Image; 
import javax.microedition.lcdui.game.Sprite; 
import javax.microedition.media.MediaException; 
import javax.microedition.media.Player; 
import javax.microedition.media.PlayerListener; 
 
/** 
 * @author Jagie 
 *  
 * TODO To change the template for this generated type comment go to Window - 
 * Preferences - Java - Code Style - Code Templates 
 */ 
public class GameInnerThread implements Runnable, PlayerListener { 
	/* 
	 * 当音乐播放完毕时,则又重新开始 
	 *  
	 * @see javax.microedition.media.PlayerListener#playerUpdate(javax.microedition.media.Player, 
	 *      java.lang.String, java.lang.Object) 
	 */ 
	public void playerUpdate(Player p, String event, Object arg2) { 
		if (event.equals(PlayerListener.END_OF_MEDIA)) { 
			try { 
				p.start(); 
			} catch (MediaException e) { 
				// TODO Auto-generated catch block 
				e.printStackTrace(); 
			} 
		} 
	} 
 
	MyGameCanvas canvas; 
 
	boolean isRunning; 
 
	Random ran = new Random(); 
 
	Vector allAvaliableRanEnemy; 
 
	Vector allAvaliableSkill; 
 
	private Sprite[] randFightBgs; 
 
 
 
	private Thread me; 
 
	public GameInnerThread(MyGameCanvas canvas) { 
		this.canvas = canvas; 
 
	} 
 
	public void init() { 
 
		if (canvas.curLevel == null) { 
			return; 
		} 
 
		allAvaliableRanEnemy = new Vector(); 
		Enumeration e = canvas.curLevel.npcs.elements(); 
 
		while (e.hasMoreElements()) { 
			NPC npc = (NPC) e.nextElement(); 
			if (npc.type == 5) { 
				allAvaliableRanEnemy.addElement(npc); 
 
			} 
		} 
 
		allAvaliableSkill = new Vector(); 
		e = canvas.curLevel.skills.elements(); 
 
		while (e.hasMoreElements()) { 
			Skill skill = (Skill) e.nextElement(); 
 
			allAvaliableSkill.addElement(skill); 
 
		} 
		 
		ResourceLoader.player.addPlayerListener(this); 
 
		 
	} 
 
	public void start() { 
		isRunning = true; 
		init(); 
		playMidi(); 
		me = new Thread(this); 
		me.start(); 
	} 
 
	public void stop() { 
		isRunning = false; 
		try { 
			ResourceLoader.player.stop(); 
		} catch (MediaException e) { 
			// TODO Auto-generated catch block 
			e.printStackTrace(); 
		} 
	} 
 
	public Sprite getRandomFightBg() { 
		return randFightBgs[Math.abs(ran.nextInt()) % randFightBgs.length]; 
	} 
 
	private void loadFightBgs() { 
		Vector v = canvas.curLevel.curMap.randFightBgImages; 
		randFightBgs = new Sprite[v.size()]; 
		for (int i = 0; i < randFightBgs.length; i++) { 
			randFightBgs[i] = new Sprite((Image) v.elementAt(i)); 
		} 
	} 
 
	public void run() { 
 
		while (isRunning && me == Thread.currentThread()) { 
 
			Map map = canvas.curLevel.curMap; 
 
			switch (canvas.getGameStatus()) { 
			//当游戏处于主角行走状态时,所要做的事情就是产生随机敌人 
			case MyGameCanvas.STATUS_WALKING: 
				if (map.isFightMap && canvas.ranEnemy == null) { 
					if (randFightBgs == null) { 
						loadFightBgs(); 
					} else if (canvas.myPlayer.moveTimes > 20) { 
						int r = Math.abs(ran.nextInt()) 
								% allAvaliableRanEnemy.size(); 
						NPC src = (NPC) allAvaliableRanEnemy.elementAt(r); 
						canvas.ranEnemy = cloneNpc(src); 
						setNpcAttackState(canvas.ranEnemy, 0); 
						//随机敌人的Hp为主角 
						canvas.ranEnemy.hp = canvas.myPlayer.hp; 
						canvas.handleRanEnemy(); 
						canvas.myPlayer.moveTimes = 0; 
					} 
				} 
 
				break; 
				//当游戏处于战斗状态,所要做的事情就是改变英雄和敌人的动画帧 
			case MyGameCanvas.STATUS_FIGHTING: 
 
				synchronized (this) { 
					//NPC在攻击 
					if (canvas.myPlayer.attackStatus == -1) { 
						canvas.myPlayer.setAttackStatusSprite(-1); 
						int sleepTime = 2000; 
						int state = canvas.ranEnemy.npcAttackState; 
						if (state == 1 || state == 2) { 
							sleepTime = 0; 
						} 
 
						try { 
							Thread.sleep(sleepTime); 
						} catch (InterruptedException e1) { 
							// TODO Auto-generated catch block 
							e1.printStackTrace(); 
						} 
 
						state = state + 1 > 2 ? 0 : state + 1; 
 
						setNpcAttackState(canvas.ranEnemy, state); 
					} else { 
						//主角在攻击 
						setNpcAttackState(canvas.ranEnemy, 0); 
						int sleepTime = 100; 
						int nextStatus = 0; 
						switch (canvas.myPlayer.attackStatus) { 
						case 0: 
							nextStatus = 1; 
 
							break; 
						case 1: 
							nextStatus = 2; 
							break; 
						case 2: 
							demageNPC(); 
							nextStatus = -1; 
							break; 
						case 1979: 
							sleepTime=50; 
							nextStatus = 1980; 
							 
							break; 
						case 1980: 
							sleepTime=50; 
							demageNPC(); 
							//消耗体力和魔法 
							canvas.myPlayer.hp-=canvas.myPlayer.fireSkill.hpCost; 
							canvas.myPlayer.mp-=canvas.myPlayer.fireSkill.mpCost; 
							nextStatus = -1; 
							 
							break; 
 
						} 
 
						try { 
							Thread.sleep(sleepTime); 
						} catch (InterruptedException e1) { 
							// TODO Auto-generated catch block 
							e1.printStackTrace(); 
						} 
 
						canvas.myPlayer.setAttackStatusSprite(nextStatus); 
					} 
 
					break; 
				} 
 
			} 
 
			try { 
				Thread.sleep(50); 
			} catch (InterruptedException e) { 
				// TODO Auto-generated catch block 
				e.printStackTrace(); 
			} 
 
		} 
	} 
 
	private void demageNPC() { 
		//		伤害NPC 
		int de = (canvas.myPlayer.getRealAttackPoint() - canvas.ranEnemy.defendPoint); 
		canvas.ranEnemy.hp -= de; 
		if (canvas.ranEnemy.hp <= 0) { 
			//得经验公式 
			canvas.myPlayer.exp += (canvas.myPlayer.nextExp - canvas.myPlayer.levelInitExp) / 3; 
 
			//得金钱 
			canvas.myPlayer.money += Math.abs(ran.nextInt()) 
					% (canvas.beforeFightMoney / 3); 
 
			//得技能 
			Vector av = getAvailableSkills(); 
			if (av.size() > 0 && ran.nextInt() % 2 == 0) { 
				canvas.ranSkill = (Skill) av.elementAt(Math.abs(ran.nextInt()) 
						% av.size()); 
			} 
			//canvas.ranSkill=(Skill)this.allAvaliableSkill.elementAt(0); 
 
			canvas.handleFightOver(); 
 
		} 
	} 
 
	private Vector getAvailableSkills() { 
		Vector v = new Vector(); 
		for (int i = allAvaliableSkill.size() - 1; i >= 0; i--) { 
			Skill sk = (Skill) allAvaliableSkill.elementAt(i); 
			if (!canvas.myPlayer.skillVec.contains(sk)) { 
				if (sk.requiredLevel == canvas.myPlayer.rank) { 
					v.addElement(sk); 
				} 
 
			} 
		} 
 
		return v; 
	} 
 
	private void setNpcAttackState(NPC npc, int nextState) { 
 
		npc.npcAttackState = nextState; 
		switch (nextState) { 
		//最初状态 
		case 0: 
			npc.sprite.setPosition(100, 90); 
			npc.sprite.setFrame(canvas.ranEnemy.startFrameIndex); 
			break; 
		//攻击1状态 
		case 1: 
			npc.sprite.setPosition(97, 102); 
 
			npc.sprite.setFrame(canvas.ranEnemy.startFrameIndex + 1); 
			break; 
		//攻击2状态 
		case 2: 
			npc.sprite.setPosition(95, 102); 
			npc.sprite.setFrame(canvas.ranEnemy.startFrameIndex + 2); 
			//伤害值 
			int de = npc.attackPoint - canvas.myPlayer.getRealDefendPoint(); 
			if (de < 0) { 
				de = 5; 
			} 
 
			 
			canvas.myPlayer.hp -= de; 
			if (canvas.myPlayer.hp <= 0) { 
				canvas.handleGameOver(); 
			} 
			break; 
 
		} 
	} 
 
	public static NPC cloneNpc(NPC npc) { 
		NPC newNpc = new NPC(); 
		newNpc.endFrameIndex = npc.endFrameIndex; 
		newNpc.ID = npc.ID; 
		newNpc.jacketVec = npc.jacketVec; 
		newNpc.medicVec = npc.medicVec; 
		newNpc.name = npc.name; 
		newNpc.skillVec = npc.skillVec; 
		newNpc.sprite = npc.sprite; 
		newNpc.startFrameIndex = npc.startFrameIndex; 
		newNpc.talkContents = npc.talkContents; 
		newNpc.type = npc.type; 
		newNpc.attackPoint = npc.attackPoint; 
		newNpc.defendPoint = npc.defendPoint; 
		newNpc.weaponVec = npc.weaponVec; 
		newNpc.colNo = npc.colNo; 
		newNpc.rowNo = npc.rowNo; 
		return newNpc; 
	} 
 
 
 
	/** 
	 *  播放背景音乐 
	 */ 
	private void playMidi() {  
		if (ResourceLoader.player != null) { 
			try { 
				ResourceLoader.player.realize(); 
				ResourceLoader.player.start(); 
			} catch (MediaException e) { 
				// TODO 自动生成 catch 块 
				e.printStackTrace(); 
			} 
		} 
	} 
}