donghua.java

HappyTreeFriends手机游戏的源代码

import java.io.*;
import javax.microedition.lcdui.*;
import com.nokia.mid.ui.*;

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, short[] pal, short[] dest)
    {
    	offset &= 0xFFFF;
        int pos = 0;
        int size = width * height;
        int data;
        int shumu;
        short 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 = 0;
  
    public static final int FLIP_X    = DirectGraphics.FLIP_HORIZONTAL;
   
    public static final int FLIP_Y    = DirectGraphics.FLIP_VERTICAL;
   
    public static final int FLIP_XY   = DirectGraphics.FLIP_HORIZONTAL | DirectGraphics.FLIP_VERTICAL;


    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
            DirectUtils.getDirectGraphics(g).drawImage(img, x, y, anchor, flip);
    }

    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
        {
            if ((flip & FLIP_X) != 0)
            {
                regionX = img.getWidth() - regionX - regionW;
            }
            if ((flip & FLIP_Y) != 0)
            {
                regionY = img.getHeight() - regionY - regionH;
            }
            DirectUtils.getDirectGraphics(g).drawImage(img, x - regionX, y - regionY, 0, flip);
        }
    }

   
    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
        {
            if ((flip & FLIP_X) != 0)
            {
                regionX = img.getWidth() - regionX - regionW;
            }
            if ((flip & FLIP_Y) != 0)
            {
                regionY = img.getHeight() - regionY - regionH;
            }
            DirectUtils.getDirectGraphics(g).drawImage(img, x - regionX, y - regionY, 0, flip);
        }
    }

   
    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
        {
            if ((flip & FLIP_X) != 0)
            {
                regionX = img.getWidth() - regionX - regionW;
            }
            if ((flip & FLIP_Y) != 0)
            {
                regionY = img.getHeight() - regionY - regionH;
            }
            DirectUtils.getDirectGraphics(g).drawImage(img, x - regionX, y - regionY, 0, flip);
        }
    }

   
    public static void DrawRgb(Graphics g, short[] rgbData, int width, int height, boolean processAlpha, int flip,
                               int x, int y)
    {
        DirectUtils.getDirectGraphics(g).drawPixels(rgbData, processAlpha, 0, width, x, y, width, height, flip, DirectGraphics.TYPE_USHORT_4444_ARGB);
    }

   
    public static Image CreateRgbImage(short[] rgbData, int width, int height, boolean processAlpha)
    {
        Image img = Image.createImage(width, height);
        DrawRgb(img.getGraphics(), rgbData, width, height, processAlpha, FLIP_NONE, 0, 0);
        return img;
    }



    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 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 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);