donghua.java

HappyTreeFriends手机游戏的源代码

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

public class Donghua
{



	

    public static final int FLIP_NONE = 0;


    public static int GetFlip(boolean flipX, boolean flipY)
    {
        return FLIP_NONE;
    }

    public static void SetClip(Graphics g, int clipX, int clipY, int clipW, int clipH)
    {
        g.setClip(clipX, clipY, clipW, clipH);
    }


    public static void Jiancaipinmu(Graphics g, int clipX, int clipY, int clipW, int clipH)
    {
        if (clipY < 0)
        {
            clipH += clipY;
            clipY = 0;
        }
        if (clipY + clipH > PINGMUDDD.PINGMUGAO)
        {
            clipH = PINGMUDDD.PINGMUGAO - clipY;
        }
        if (clipX < 0)
        {
            clipW += clipX;
            clipX = 0;
        }
        if (clipX + clipW > PINGMUDDD.PINGMUKUAN)
        {
            clipW = PINGMUDDD.PINGMUKUAN - clipX;
        }
        SetClip(g, clipX, clipY, clipW, clipH);
    }


    public static void SetClipOnViewport(Graphics g, int clipX, int clipY, int clipW, int clipH)
    {
        if (clipY < PINGMUDDD.sssCHUANNN_TOP)
        {
            clipH += clipY - PINGMUDDD.sssCHUANNN_TOP;
            clipY = PINGMUDDD.sssCHUANNN_TOP;
        }
        if (clipY + clipH > PINGMUDDD.sssCHUANNN_TOP + PINGMUDDD.sssCHUANNN_HEIGHT)
        {
            clipH = PINGMUDDD.sssCHUANNN_TOP + PINGMUDDD.sssCHUANNN_HEIGHT - clipY;
        }
        if (clipX < PINGMUDDD.sssCHUANNN_LEFT)
        {
            clipW += clipX - PINGMUDDD.sssCHUANNN_LEFT;
            clipX = PINGMUDDD.sssCHUANNN_LEFT;
        }
        if (clipX + clipW > PINGMUDDD.sssCHUANNN_LEFT + PINGMUDDD.sssCHUANNN_WIDTH)
        {
            clipW = PINGMUDDD.sssCHUANNN_LEFT + PINGMUDDD.sssCHUANNN_WIDTH - clipX;
        }

	if(Jiaose.s_cutBlood)
		{
		        int LIMT_ADD_X = 0;
			LIMT_ADD_X = (Jiaose.s_level < 3 ? 1 : 2) << Xiyou.s_tileBits;
			if(Xiyou.s_jingtouX < LIMT_ADD_X)
				{
					if(clipX < LIMT_ADD_X - Xiyou.s_jingtouX)
						{
							clipW -= LIMT_ADD_X - Xiyou.s_jingtouX - clipX;
							clipX = LIMT_ADD_X - Xiyou.s_jingtouX;
						}
					
				}
			if(Xiyou.s_jingtouX +  PINGMUDDD.sssCHUANNN_WIDTH > Jiaose.MAP_EDGE_RIGHT - LIMT_ADD_X)
				{
					if(PINGMUDDD.sssCHUANNN_WIDTH - (clipX + clipW) < 
						Xiyou.s_jingtouX +  PINGMUDDD.sssCHUANNN_WIDTH - (Jiaose.MAP_EDGE_RIGHT - LIMT_ADD_X))
						clipW -= Xiyou.s_jingtouX +  PINGMUDDD.sssCHUANNN_WIDTH - (Jiaose.MAP_EDGE_RIGHT - LIMT_ADD_X) - (PINGMUDDD.sssCHUANNN_WIDTH - (clipX + clipW));
				}
			int LIMIT_ADD_Y = (Jiaose.BIG_MAP_CENTER_Y[Jiaose.s_level /Jiaose.MAP_UP_BY_LEVEL] - (Jiaose.BIG_MAP_H[Jiaose.s_level /Jiaose.MAP_UP_BY_LEVEL] >> 1)) >> 8;        
			if(Xiyou.s_jingtouY < LIMIT_ADD_Y)
				{
					if(clipY < LIMIT_ADD_Y - Xiyou.s_jingtouY)
						{
							clipH -= LIMIT_ADD_Y - Xiyou.s_jingtouY - clipY;
							clipY = LIMIT_ADD_Y - Xiyou.s_jingtouY;
						}
					
				}
			
			
		}
        SetClip(g, clipX, clipY, clipW, clipH);
    }

    public static void DrawImage(Graphics g, Image img, int flip, int x, int y, int anchor)
    {
            g.drawImage(img, x, y, anchor);
    }


    public static void DrawImage(Graphics g, Image img, int imgW, int imgH, int flip, int x, int y, int anchor)
    {
  
            g.drawImage(img, x, y, anchor);
  
    }


    public static void DrawRegion(Graphics g, Image img, int regionX, int regionY, int regionW, int regionH, int flip,
                                  int x, int y)
    {
        SetClip(g, x, y, regionW, regionH);
        g.drawImage(img, x - regionX, y - regionY, 0);
    }


    public static void HuaQuYuZaiPINMU(Graphics g, Image img, int regionX, int regionY, int regionW, int regionH, int flip,
                                          int x, int y)
    {
        Jiancaipinmu(g, x, y, regionW, regionH);

        g.drawImage(img, x - regionX, y - regionY, 0);
 
    }

    public static void HuaQuYuZaiShiTu(Graphics g, Image img, int regionX, int regionY, int regionW, int regionH, int flip,
                                            int x, int y)
    {
        SetClipOnViewport(g, x, y, regionW, regionH);
        g.drawImage(img, x - regionX, y - regionY, 0);
    }


		


    public static Donghua[] s_anims;


   
    public int m_ID;

  
    private int m_imageID;


    public int m_imageFormat;
   
    public static final int IMAGE_FORMAT_PNG = 0;
  
    public static final int IMAGE_FORMAT_GLI = 1;
 
    public static final int IMAGE_FORMAT_BIN = 2;

 
  
    public static Image[] s_pngImages = new Image[DWorld.IMAGE_COUNT];
  
    private static byte[] s_pngImagesRefs = new byte[DWorld.IMAGE_COUNT];
   
    private int m_pngImageWidth;
  
    private int m_pngImageHeight;



 
    private byte[] m_MOkkkai;
   
    private static int MODULE_MASK = 0xFF;
    
    private boolean m_largeMokuaiiiiiiiiiiiiiies;


    private byte[][] m_frames;
    
    private static int ZHEN_MASK = 0xFF;
    
    private boolean m_manyMokuaiiiiiiiiiiiiiies;
   
    private boolean m_largeZhennnnnns;



    public short[][] m_actions;
   
    private boolean m_manyZhennnnnns;

    public byte m_colHezzzzzz[];
    public byte m_attHezzzzzz[];

    public short m_mechModel[];
  
    private int m_palBits;
  
    private int m_palMask;
   
    private int m_palCount;
    
    private int m_palLen;

   
    private short[] m_pals;

   
    private short[][] m_scenePals;



    public static final int PAL_ID_SELF = 0;
    public static final int PAL_ID_SELF_SHIRT = 0;
    public static final int PAL_ID_SELF_TROUSERS = 0;
    public static final int PAL_ID_ENEMY = 0;
    public static final int PAL_ID_ENEMY_SHIRT = 0;
    public static final int PAL_ID_ENEMY_TROUSERS = 0;

    public static final int MAX_SCENE_PAL_COUNT = 3;
    public static final int SCENE_PAL_ID_SELF = 0;
    public static final int SCENE_PAL_ID_ENEMY = 1;

   
    public void CreateScenePals()
    {
        m_scenePals = new short[MAX_SCENE_PAL_COUNT][];
        m_scenePals[SCENE_PAL_ID_SELF] = new short[m_palLen];
        CreateOneScenePal(SCENE_PAL_ID_SELF, PAL_ID_SELF, PAL_ID_SELF_SHIRT, PAL_ID_SELF_TROUSERS, false);
       
    }

    
    private void CreateOneScenePal(int scenePalID, int palID, int shirtPalID, int trousersPalID, boolean buildNewPal)
    {
        
        for (int i = 0; i < m_palLen; i++)
             m_scenePals[scenePalID][i] = m_pals[palID * m_palLen + i];
             
        if (!buildNewPal)
            return;
            
  
        for (int i = 2; i < 3; i++)
             m_scenePals[scenePalID][i] = m_pals[shirtPalID * m_palLen + i];
       
        for (int i = 5; i < 7; i++)
             m_scenePals[scenePalID][i] = m_pals[trousersPalID * m_palLen + i];
    }

 
    public void FreeScenePals()
    {
        for (int i = 0; i < MAX_SCENE_PAL_COUNT; i++)
            m_scenePals[i] = null;
        m_scenePals = null;
    }

    private static final String FILE_NAME_ANIMATION = "/animation.bin";
    
    private static final String FILE_NAME_GFXDATA = "/gfxdata.bin";


    public static void LoadAnimations(int mask)
    {
        try
        {
            DataInputStream dis = new DataInputStream(FILE_NAME_ANIMATION.getClass().getResourceAsStream(FILE_NAME_ANIMATION));
            int animationCount = Xiyou.ReadUnsignedVarshort(dis);
            int[] animationpanYis = new int[animationCount+1];
            for (int i = 0; i < animationCount+1; i++)
            {
                animationpanYis[i] = Xiyou.ReadUnsignedShort(dis);
            }
            if (s_anims == null)
                s_anims = new Donghua[animationCount];		
            for (int i = 0; i < animationCount; i++)
            {           
                if (((1 << i) & mask) == 0)
                {
                    
                    dis.skip(animationpanYis[i + 1] - animationpanYis[i]);
                    if (s_anims[i] != null)
                    {
                        s_anims[i].Free();
                        s_anims[i] = null;
                    }
                }
                else if (s_anims[i] == null)
                {
                    
                    Donghua a = new Donghua();
                    s_anims[i] = a;
                    a.m_ID = i;
                    a.Load(dis);
                    a.LoadGfx();
		Debug.Mem("Loadanimation: " + i );			
                }
            }		
            dis.close();
            dis = null;
            FreeUnusedPngImages();
            
        }
        catch (Exception e)
        {
            Debug.PrintException(e);
        }
    }

    private void Load(DataInputStream dis) throws Exception
    {
        int flag = Xiyou.ReadUnsignedByte(dis);
        m_manyMokuaiiiiiiiiiiiiiies = (flag & 0x01) != 0;
        m_largeZhennnnnns = (flag & 0x02) != 0;
        m_manyZhennnnnns = (flag & 0x04) != 0;

        int frameCount = Xiyou.ReadUnsignedVarshort(dis);
        m_frames = new byte[frameCount][];

        m_colHezzzzzz = new byte[frameCount * 4];
        m_attHezzzzzz = new byte[frameCount * 4];
	
        for (int i = 0; i < frameCount; i++)
        {
            int embeddingMokuaiiiiiiiiiiiiiieCount = Xiyou.ReadUnsignedByte(dis);
            m_frames[i] = new byte[embeddingMokuaiiiiiiiiiiiiiieCount * 4];
            for (int j = 0; j < embeddingMokuaiiiiiiiiiiiiiieCount; j++)
            {
                m_frames[i][j*4] = (byte)Xiyou.ReadUnsignedByte(dis);
	
                m_frames[i][j*4+1] = (byte)Xiyou.ReadUnsignedByte(dis);
                m_frames[i][j*4+2] = Xiyou.ReadByte(dis);
                m_frames[i][j*4+3] = Xiyou.ReadByte(dis);
            }
          
           
       	    m_colHezzzzzz[i * 4 + 0] = Xiyou.ReadByte(dis);
            m_colHezzzzzz[i * 4 + 1] = Xiyou.ReadByte(dis);
            m_colHezzzzzz[i * 4 + 2] = Xiyou.ReadByte(dis); 
            m_colHezzzzzz[i * 4 + 3] = Xiyou.ReadByte(dis); 
                
          
            m_attHezzzzzz[i * 4 + 0] = Xiyou.ReadByte(dis); 
            m_attHezzzzzz[i * 4 + 1] = Xiyou.ReadByte(dis); 
            m_attHezzzzzz[i * 4 + 2] = Xiyou.ReadByte(dis); 
            m_attHezzzzzz[i * 4 + 3] = Xiyou.ReadByte(dis); 
        }

        int actionCount = Xiyou.ReadUnsignedVarshort(dis);
        m_actions = new short[actionCount][];
        m_mechModel = new short[actionCount * 4];
        for (int i = 0; i < actionCount; i++)
        {
            int embeddingZhennnnnnCount = Xiyou.ReadUnsignedByte(dis);
            m_actions[i] = new short[embeddingZhennnnnnCount];
            for (int j = 0; j < embeddingZhennnnnnCount; j++)
            {
                m_actions[i][j] = (short)Xiyou.ReadUnsignedShort(dis);
            }
            
            for ( int  j = 0; j < 4; j++ )