player.java

一个j2me游戏代码

package pop2;

import java.io.*;
import javax.microedition.lcdui.*;


/**
 * <p>Title: POP2</p>
 * <p>Description: Prince of Persia 2</p>
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: Gameloft (Beijing)</p>
 * @author Cao Heng
 * @version 1.0
 */

public class Player
{
	static Prince m_prince;
	static Actor m_arrow;
	static int m_nActors;
	static Actor[] m_actors; // prince & enemy
    static int activeBoxes[][];
	static int m_actorOffset[]; // offset in origin data
	static byte m_originData[]; // data for current play
	static byte m_recordData[]; // data for last check point
	static Animation[] m_anims;
	static boolean m_showBar;
	private int m_hpLast, m_energyLast;

	static int m_camX; // X position of left top point of screen in background
	static int m_camY; // Y position of left top point of screen in background
	static int m_shakeCamera;
	static Actor m_focusEnemy;

	public Player()
	{
	}
	public int loadActors(DataInputStream is, int size) throws Exception
	{
		m_originData = new byte[size];
		m_recordData = new byte[size];
		is.readFully(m_originData, 0, size);
		m_nActors = GE.readUnsignedShort(m_originData, 0); // actor data count
        activeBoxes = new int[m_nActors][];
		m_actors = new Actor[m_nActors];
		m_actorOffset = new int[m_nActors];
		updateCheckPoint(true);
		size = 2;
		for (int i = 0; i < m_nActors; i++)
		{
			m_actorOffset[i] = size;
			if (m_originData[size+2] == Def.ID_PRINCE)
			{
				m_prince = new Prince();
				m_actors[i] = m_prince;
			}
			else if (GE.m_levelSelected != 0 && m_originData[size+2] == Def.ID_SANDMAN && (m_originData[size+4] & Actor.FLAG_IGNORE) != 0)
			{
				m_arrow = new Actor();
				m_actors[i] = m_arrow;
			}
            activeBoxes[i] = new int[4];
            activeBoxes[i][0] = GE.readUnsignedShort(m_originData, size+10);
            activeBoxes[i][1] = GE.readUnsignedShort(m_originData, size+12);
            activeBoxes[i][2] = GE.readUnsignedShort(m_originData, size+14);
            activeBoxes[i][3] = GE.readUnsignedShort(m_originData, size+16);
			size += 2 + GE.readUnsignedShort(m_originData, size); // actor data size
		}
		return size;
	}
	public void freePlayer()
	{
		int i;
        if (m_anims != null)
        {
            for (i = 0; i < m_anims.length; i++)
            {
                m_anims[i].m_image = null;
            }
        }
        if (m_actors != null)
        {
            for (i = 0; i < m_nActors; i++)
            {
                m_actors[i] = null;
            }
            m_actors = null;
		}
        activeBoxes = null;
		m_actorOffset = null;
		m_nActors = 0;
		m_originData = null;
		m_recordData = null;
	}
	static Actor allocActor(int index)
	{
		Actor a = new Actor();
		m_actors[index] = a;
		a.loadActor(m_originData, m_actorOffset[index]);
		if (a.m_animID == Def.ID_SANDMAN &&
            (a.m_actionIDNow >= Def.SANDMAN_BM_GUARD &&
             a.m_actionIDNow <= Def.SANDMAN_BM_DEAD ||
             a.m_actionIDNow == Def.SANDMAN_BM_HURT))
			a.m_relativeMisc = m_arrow;
		else if (a.m_animID == Def.ID_BOX)
		    a.checkTopBottom(Actor.CHECK_BOTTOM, true);
		return a;
	}
	public void freeActor(int index)
	{
		m_actors[index].packActor(m_originData, m_actorOffset[index]);
		if (m_focusEnemy != null && m_focusEnemy.equals(m_actors[index]))
		    m_focusEnemy = null;
		m_actors[index] = null;
	}
	static void updateCheckPoint(boolean save)
	{
		if (save)
		{
            if (m_arrow != null)
                m_arrow.m_flag[3] = false;
			for (int i = 0; i < m_nActors; i++)
			{
				if (m_actors[i] != null)
		            m_actors[i].packActor(m_originData, m_actorOffset[i]);
			}
			System.arraycopy(m_originData, 0, m_recordData, 0, m_originData.length);
		}
		else
		{
			System.arraycopy(m_recordData, 0, m_originData, 0, m_originData.length);
			for (int i = 0; i < m_nActors; i++)
			{
				if (m_actors[i] != null && !m_actors[i].equals(m_prince) && !m_actors[i].equals(m_arrow))
				    m_actors[i] = null;
			}
            if (m_arrow != null)
                m_arrow.m_flag[3] = false;
			m_focusEnemy = null;
			System.gc();
		}
	}
	// Init variables of pop and enemy, called at the begin of each level ------
	public void initPlayer()
	{
        int i;
        for (i = 0; i < m_anims.length; i++)
        {
            m_anims[i].loadImage();
		}
		// init camera
		Actor a;
		for (i = 0; i < m_nActors; i++)
		{
			a = m_actors[i];
			if (a != null)
			{
			    a.loadActor(m_originData, m_actorOffset[i]);
			}
		}
		m_focusEnemy = null;
		updateCamera(true);
		// init actors
		for (i = 0; i < m_nActors; i++)
		{
			//if (inActiveZone(m_camX, m_camY, m_originData, m_actorOffset[i]))
            if (inActiveZone(m_camX, m_camY, i))
			{
				if (m_actors[i] == null)
					allocActor(i);
			}
		}
		// init prince
		m_hpLast = 0;
		m_energyLast = 0;
		m_prince.checkEnvironment(true);
	}
	// display all actors and misc -------------------------
	public void displayPlayer()
	{
		// draw actors
		Actor a;
		for (int i = 0; i < m_nActors; i++)
		{
			a = m_actors[i];
			if (a != null && a.m_flag[3])
                a.draw(m_camX, m_camY-Def.PF_TOP);
		}
		// Lyman DEBUG
		//GE.m_piece[5] = System.currentTimeMillis() - GE.m_piece[3] - GE.m_piece[4];
		// draw interface
		GE.m_g.setClip(0, 0, Def.SCREEN_WIDTH, Def.SCREEN_HEIGHT);
		if (m_prince != null && m_showBar)
			drawBloodEnergy();
	}
	/*
	void drawHeart()
	{
		int hpNow = m_prince.m_hp * m_heartHeight;
		if (m_hpLast > hpNow)
			m_hpLast--;
		else if (m_hpLast < hpNow)
			m_hpLast++;
		int i, full = m_hpLast / m_heartHeight, remain = m_hpLast % m_heartHeight;
		for (i = 0; i < full; i++)
		{
			GE.m_dg.drawPixels(heart, true, 0, m_heartWidth, 4 + i * (m_heartWidth + 4), 4, m_heartWidth, m_heartHeight, 0, GE.m_dg.TYPE_USHORT_4444_ARGB);
		}
		if (remain > 0)
		{
			GE.m_dg.drawPixels(heart, true, (m_heartHeight-remain)*m_heartWidth, m_heartWidth,
							   4 + i * (m_heartWidth + 4), 4+m_heartHeight-remain, m_heartWidth, remain, 0, GE.m_dg.TYPE_USHORT_4444_ARGB);
		}
	}*/
	private void drawBloodEnergy()
	{
		int x = 3+18+3, y = 6, width, height = Def.SCREEN_HEIGHT/30;
		int widthFill, maxWidth = Def.SCREEN_WIDTH / 2 - 25;

		// Draw blood
		width = maxWidth * m_prince.m_maxhp / Def.BLOOD_MAX;
		widthFill = maxWidth * m_prince.m_hp / Def.BLOOD_MAX;
		if (Def.PF_TOP == 0 || widthFill != m_hpLast || GE.m_brushTop)
		{
			m_hpLast = widthFill;
			//if (widthFill > m_hpLast)
			//	m_hpLast++;
			//else if (widthFill < m_hpLast)
			//	m_hpLast--;
			GE.m_g.setColor(0x0ff0000);
			GE.m_g.fillRect(x, y, m_hpLast, height);
			GE.m_g.setColor(0x0200000);
			GE.m_g.fillRect(x+m_hpLast, y, width-m_hpLast, height);
			GE.m_g.setColor(0x00ffffff);
			GE.m_g.drawRoundRect(x-1, y-1, width, height, 2, 2);
		}

		if (m_prince.ability[m_prince.CAN_WALLING] <= 0)
		    return;

		// Draw energy
		width = maxWidth * m_prince.m_maxEnergy / Def.ENERGY_MAX;
		widthFill = maxWidth * m_prince.m_energy / Def.ENERGY_MAX;
		if (GE.m_curFrameTime % 600 > 300 && (widthFill * 10 / width < 4 || GE.m_msgIndex == Def.ID_TUT_WALLING))
	        return;
		if (Def.PF_TOP == 0 || widthFill != m_energyLast || GE.m_brushTop)
		{
			m_energyLast = widthFill;
			//if (widthFill > m_energyLast)
	        //    m_energyLast++;
            //else if (widthFill < m_energyLast)
	        //    m_energyLast--;
			x = Def.SCREEN_WIDTH - 3 - width;
			GE.m_g.setColor(0x0080f0);
			GE.m_g.fillRect(x+width-m_energyLast, y, m_energyLast, height);
			GE.m_g.setColor(0x001020);
			GE.m_g.fillRect(x, y, width-m_energyLast, height);
			GE.m_g.setColor(0x00ffffff);
			GE.m_g.drawRoundRect(x-1, y-1, width, height, 2, 2);
		}
	}
	static Actor checkDamage(Actor actor)
	{
		int i;
		Actor a;
		for(i = m_nActors - 1; i >= 0; i--)
		{
			a = m_actors[i];
			if (a != null && a.m_flag[3] && a != actor &&
			   (a.m_animID == Def.ID_NAIL || a.m_animID == Def.ID_PRINCE ||
			    a.m_animID == Def.ID_SAW || a.m_animID == Def.ID_SANDMAN))
			{
				if (actor.intersectAttackBox(a)) return a;
			}
		}
		return null;
	}
	static boolean checkTreadleCollision(Actor treadle)
	{
		int i;
		Actor a;
		for(i = m_nActors - 1; i >= 0; i--)
		{
			a = m_actors[i];
			if (a != null && a.m_flag[3] &&
		       (a.m_animID == Def.ID_PRINCE || a.m_animID == Def.ID_BOX || a.m_animID == Def.ID_SANDMAN))
			{
				if (treadle.intersectColBox(a) && (a.m_posY-treadle.m_posY) < (8<<8)) return true;
			}
		}
		return false;
	}
	// update the action of player each frame --------------------------
	public void updatePlayer()
	{
        //GE.m_updatedAI = 0;
		Actor a;
		for (int i = m_nActors - 1; i >= 0; i--)
        {
			a = m_actors[i];
			//if (inActiveZone(m_camX, m_camY, m_originData, m_actorOffset[i]))
            if (inActiveZone(m_camX, m_camY, i))
			{
				if (a == null)
					a = allocActor(i);
			}
			else if (a != null && !a.m_flag[2])
			{
				freeActor(i);
				continue;
			}
			if (a != null)
            {
                //GE.m_updatedAI++;
			    a.updateAI(m_camX, m_camY);
            }
        }
		updateCamera(false);
	}
    /*
	boolean inActiveZone(int camX, int camY, byte[] data, int offset)
	{
		if ((data[offset+4] & Actor.FLAG_IGNORE) != 0)
			return true;
		// active zone is not relative to actor's position any more.
		int bottom = (GE.readUnsignedShort(data, offset+16));
		int right = (GE.readUnsignedShort(data, offset+14));
		if (camX > right || camY > bottom)
			return false;
		int top = (GE.readUnsignedShort(data, offset+12));
		int left = (GE.readUnsignedShort(data, offset+10));
		if (camX + Def.PF_WIDTH < left || camY + Def.PF_HEIGHT < top)
			return false;
		return true;
	}//*/
    ///*
    boolean inActiveZone(int camX, int camY, int i)
    {
        // active zone is not relative to actor's position any more.
        if (camX > activeBoxes[i][2] || camY > activeBoxes[i][3])
            return false;
        if (camX + Def.PF_WIDTH < activeBoxes[i][0] || camY + Def.PF_HEIGHT < activeBoxes[i][1])
            return false;
        return true;
	}//*/
    /*
    static boolean checkBoxCollision(int ypos, int xpos, boolean flip)
    {
        Actor a;
        for (int i=0; i<m_nActors; ++i) {
            a = m_actors[i];
            if (a!=null && a.m_flag[3] && a.m_animID==Def.ID_BOX) {
                int newx = a.m_posX>>8, newy = a.m_posY>>8;
                if (newy-48<ypos+72 && newy>ypos &&
                        (!flip && newx<xpos && newx+48>xpos-16 || flip && newx<xpos+16 && newx+48>xpos) )
                    return true;
            }
        }
        return false;
	}//*/
	static private int getCamSmoothMove(int offset, int speed)
	{
		if (Math.abs(offset) > Math.abs(speed))
		{
			if (speed != 0 && offset/speed > 0)
			    offset -= speed;
			if (offset > 0)
			{
                if (offset < 8)
					offset = 1;
				else if (offset < 32)
					offset = 2;
				else
					offset = 4;
				if (speed > 0)
	                offset += speed;
			}
			else
			{
				if (offset > -8)
                    offset = -1;
				else if (offset > -32)
					offset = -2;
				else
					offset = -4;
	            if (speed < 0)
		            offset += speed;
			}
		}
		return offset;
	}

	static void updateCamera(boolean init)
	{
		int offsetX = -1;
		int offsetY = -1;

		if (m_focusEnemy != null)
		{
			offsetX = m_prince.m_posX - m_focusEnemy.m_posX >> 8;
			offsetY = m_prince.m_posY - m_focusEnemy.m_posY >> 8;
			if (offsetX < 0) offsetX = -offsetX;
			if (offsetY < 0) offsetY = -offsetX;
			if (offsetX < (Def.PF_WIDTH * 3 / 4) && offsetY < (Def.PF_HEIGHT * 3 / 4))
			{
				offsetX = (((m_prince.m_posX + m_focusEnemy.m_posX)/2) >> 8) - Def.PF_WIDTH / 2 - m_camX;
				offsetY = (((m_prince.m_posY + m_focusEnemy.m_posY)/2) >> 8) + (m_prince.getColBox()[3] + m_prince.getColBox()[1])/2 - Def.PF_HEIGHT / 2 - m_camY;
			}
			else
			{
				offsetX = -1;
				offsetY = -1;
			}
		}
		if (offsetX == -1)
		{
			offsetX = (m_prince.m_posX >> 8) - Def.PF_WIDTH / 2;
			offsetY = (m_prince.m_posY >> 8) + (m_prince.getColBox()[3] + m_prince.getColBox()[1])/2 - Def.PF_HEIGHT / 2;
			offsetX += m_prince.m_camOffsetX - m_camX;
			offsetY += m_prince.m_camOffsetY - m_camY;
		}

		if (init)
		{
			GE.m_updateBg = true;
			m_camX += offsetX;
			m_camY += offsetY;
		}
		else if (!m_prince.blocked)
		{
            m_camX += getCamSmoothMove(offsetX, m_prince.m_vX >> 8);
            m_camY += getCamSmoothMove(offsetY, m_prince.m_vY >> 8);
            if (m_shakeCamera > 0)
            {
                m_camY += (m_shakeCamera % 2 == 1) ? 8 : -8;
                m_shakeCamera--;
            }
		}
		if (m_camX < 0) m_camX = 0;
		if (m_camX > GE.m_bgWidth*GE.m_tileWidth - Def.PF_WIDTH) m_camX = GE.m_bgWidth*GE.m_tileWidth - Def.PF_WIDTH;
		if (m_camY < 0) m_camY = 0;
		if (m_camY > GE.m_bgHeight * GE.m_tileHeight - Def.PF_HEIGHT) m_camY = GE.m_bgHeight*GE.m_tileHeight - Def.PF_HEIGHT;
	}
}