donghua.java

HappyTreeFriends手机游戏的源代码

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

public class Donghua
{


    public static int GetFlip(boolean flipX, boolean flipY)
    {
        return flipX ? (flipY ? FLIP_XY : FLIP_X) : (flipY ? FLIP_Y : 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 YasuoGli(byte[] src, int offset, int width, int height, int palBits, int palMask, int[] pal, int[] dest)
    {
    	offset &= 0xFFFF;
        int pos = 0;
        int size = width * height;
        int data;
        int shumu;
        int color;
        int wend;
        while (pos < size)
        {
            data = src[offset++] & 0xFF;
            shumu = (data >> palBits) + 1;
            color = pal[data & palMask];
            if (color != 0)
            {
                wend = pos + shumu;
                while (pos < wend)
                {
                    dest[pos++] = color;
                }
            }
            else pos += shumu;
        }
    }

    public static final int FLIP_NONE = Sprite.TRANS_NONE;
   
    public static final int FLIP_X    = Sprite.TRANS_MIRROR;
   
    public static final int FLIP_Y    = Sprite.TRANS_MIRROR_ROT180;
    
    public static final int FLIP_XY   = Sprite.TRANS_ROT180;

 
    public static void DrawImage(Graphics g, Image img, int flip, int x, int y, int anchor)
    {
        if (flip == FLIP_NONE)
            g.drawImage(img, x, y, anchor);
        else
            g.drawRegion(img, 0, 0, img.getWidth(), img.getHeight(), flip, x, y, anchor);
    }


    public static void DrawImage(Graphics g, Image img, int imgW, int imgH, int flip, int x, int y, int anchor)
    {
        if (flip == FLIP_NONE)
            g.drawImage(img, x, y, anchor);
        else
            g.drawRegion(img, 0, 0, imgW, imgH, flip, 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);
        if (flip == FLIP_NONE)
            g.drawImage(img, x - regionX, y - regionY, 0);
        else
            g.drawRegion(img, regionX, regionY, regionW, regionH, flip, x, y, 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);
        if (flip == FLIP_NONE)
            g.drawImage(img, x - regionX, y - regionY, 0);
        else
            g.drawRegion(img, regionX, regionY, regionW, regionH, flip, x, y, 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);
        if (flip == FLIP_NONE)
            g.drawImage(img, x - regionX, y - regionY, 0);
        else
            g.drawRegion(img, regionX, regionY, regionW, regionH, flip, x, y, 0);
    }

  
    public static void DrawRgb(Graphics g, int[] rgbData, int width, int height, boolean processAlpha, int flip,
                               int x, int y)
    {
        if (flip == FLIP_NONE)
            g.drawRGB(rgbData, 0, width, x, y, width, height, processAlpha);
        else
            g.drawRegion(Image.createRGBImage(rgbData, width, height, processAlpha), 0, 0, width, height, flip, x, y, 0);
    }

  
    public static Image CreateRgbImage(int[] rgbData, int width, int height, boolean processAlpha)
    {
        return Image.createRGBImage(rgbData, width, height, processAlpha);
    }

    int m_precalImagespanYi;

    static Image[] s_suipianTu;
    static short[] s_precalcStack;
    static int s_suipianTuCount;
    static int s_precalcStackIndex;
    static int s_precalcStackMax;

    public static void SetPrecalImagesPoolSize( int size )
    {
        if ( size == 0 )
        {
            s_suipianTu = null;
            s_precalcStack  = null;
            s_suipianTuCount = 0;
            s_precalcStackIndex = 0;
            s_precalcStackMax = 0;
        }
        else
        {
            if (size > 0)
            {
                s_precalcStackMax = size;
            }

          
            s_precalcStack = new short[s_precalcStackMax];

           
            s_suipianTu = new Image[s_suipianTuCount];

            for ( int i = 0; i < s_suipianTu.length; ++ i ) s_suipianTu[i] = null;
            for ( int i = 0; i < s_precalcStack.length; ++ i ) s_precalcStack[i] = -1;
        }

    }

     static void RebuildGliImagesPool()
     {
         SetPrecalImagesPoolSize ( 0 );

         for ( int anim_id = 0; anim_id < s_anims.length; ++ anim_id )
         {
             Donghua anim = s_anims[ anim_id ];
             if ( anim == null || anim.m_imageFormat != IMAGE_FORMAT_GLI)
                 continue;
             
             anim.m_precalImagespanYi = s_suipianTuCount;
             s_suipianTuCount += anim.m_palCount * (anim.m_MOkkkai.length>>1);
             s_precalcStackMax += anim.m_frames.length;
         }


         SetPrecalImagesPoolSize ( 400 );

     }



	 


    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_gliImageData;
   
    private short[] m_gliMokuaiiiiiiiiiiiiiiepanYis;


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


    private short[][] m_frames;
    
    private static int ZHEN_MASK = 0xFFFF;
    
    private boolean m_manyMokuaiiiiiiiiiiiiiies;
   
    private boolean m_largeZhennnnnns;



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

    public short m_colHezzzzzz[];
    public short 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 int[][] 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 int[MAX_SCENE_PAL_COUNT][];
        m_scenePals[SCENE_PAL_ID_SELF] = new int[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] = Xiyou.RGB4444to8888(m_pals[palID * m_palLen + i]);
             
        if (!buildNewPal)
            return;
            
        
        for (int i = 2; i < 3; i++)
             m_scenePals[scenePalID][i] = Xiyou.RGB4444to8888(m_pals[shirtPalID * m_palLen + i]);
        
        for (int i = 5; i < 7; i++)
             m_scenePals[scenePalID][i] = Xiyou.RGB4444to8888(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();
            
            RebuildGliImagesPool();
        }
        catch (Exception e)
        {