piecesprite.java

j2me简单实例,j2me教程加源码,希望大家喜欢

package com.j2medev.chapter5;

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

public class PieceSprite
{
    Image sprImage;
    short[][][][] sprData;
    boolean isEndOfAnimation;
    public static final int TRANS_NONE = 0;
    public static final int TRANS_ROT90 = 5;
    public static final int TRANS_ROT180 = 3;
    public static final int TRANS_ROT270 = 6;
    public static final int TRANS_MIRROR = 2;
    public static final int TRANS_MIRROR_ROT90 = 7;
    public static final int TRANS_MIRROR_ROT180 = 1;
    public static final int TRANS_MIRROR_ROT270 = 4;
    //following params is equal to Graphics's paramas  ,so it is easy for porting
    public static final int HCENTER = 1;
    public static final int VCENTER = 2;
    public static final int LEFT = 4;
    public static final int RIGHT = 8;
    public static final int TOP = 16;
    public static final int BOTTOM = 32;
    /**
     * 当前动画数据
     */
    short[][][] currentAnimation;
    /**
     * 当前帧数据
     */
    short[][] currentFrame;
    /**
     * 当前帧时间
     */
    short currentFrameTime;
    /**
     * 当前帧保留值
     */
    short currentFrameValue;
    /**
     * 当前帧水平偏移
     */
    short currentFrameGlobalX;
    /**
     * 当前帧垂直偏移
     */
    short currentFrameGlobalY;
    /**
     * 当前帧碰撞起始点X
     */
    short currentFrameCollisionX;
    /**
     * 当前帧碰撞机始点Y
     */
    short currentFrameCollisionY;
    /**
     * 当前帧碰撞宽度
     */
    short currentFrameCollisionW;
    /**
     * 当前帧碰撞高度
     */
    short currentFrameCollisionH;
    /**
     * 当前帧帧号
     */
    short currentFrameNr;
    /**
     * 是否连续播放
     */
    boolean isAnimationRepeat;
    /**
     * 帧的起始时间
     */
    long startFrameTime;
    /**
     * 是否是一次性载入标志
     */
    boolean b_LoadedOnce;
    /**
     * 构造函数直接通过传入四维数组进行初始化
     * @param spriteSheet Image
     * @param spriteData short[][][][]
     */
    public PieceSprite(Image spriteSheet, short[][][][] spriteData)
    {
        sprImage = spriteSheet;
        sprData = spriteData;
    }

    /**  输入流*/
    private InputStream is = null;
    /**  数据输入流*/
    private DataInputStream dis = null;
    /**
     *当前动画的长度
     */
    short CurrentAnimationFrameLength;
    /**
     *数据文件名
     */
    String m_strBinData;
    short m_rate;
    /**
     * 该构造方法用于播放单一的、连续的、帧频数很多的动画对像
     * @param spriteSheet Image
     * @param binData String
     * @param rate 缩放比例
     * @param bLoadAll boolean 是否将数据一次全部载入到数组中
     */
    public PieceSprite(Image spriteSheet, String binData, short rate,
                       boolean bLoadAll)
    {
        m_rate = rate;
        m_strBinData = binData;
        sprImage = spriteSheet;
        is = getClass().getResourceAsStream(binData);
        dis = new DataInputStream(is);

        b_LoadedOnce = bLoadAll;
        try
        {
            //读取动画长度
            short PlayerAnimationsLength = ReadShortFromBCC(dis);

            if (bLoadAll) //如果是一次载入
            {
                sprData = new short[PlayerAnimationsLength][][][];
                for (int i = 0; i < PlayerAnimationsLength; i++)
                {
                    sprData[i] = read_One_Animation();
                }
                dis.close();
            }
            else //如果是多次载入
            {
                CurrentAnimationFrameLength = ReadShortFromBCC(dis);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    public void TRACE(String str)
    {

        System.out.println(str);
    }
    /**
     * 读取动画工程中的一个动画
     * @return short[][][]
     */
    public short[][][] read_One_Animation()
    {
        //读取该动画包含的Frame的长度
        int CurrentAnimationFrameLength = ReadShortFromBCC(dis);
        short animationData[][][] = new short[CurrentAnimationFrameLength][][];

        for (int i = 0; i < CurrentAnimationFrameLength; i++)
        {
            animationData[i] = read_One_Frame();
        }
        return animationData;
    }
    /**
     * 读取动画中的一帧
     * @return short[][]
     */
    public short[][] read_One_Frame()
    {
        int globalOX = ReadShortFromBCC(dis);
        int globalOY = ReadShortFromBCC(dis);
        int time = ReadShortFromBCC(dis);
        int value = ReadShortFromBCC(dis);
        int rx = ReadShortFromBCC(dis);
        int ry = ReadShortFromBCC(dis);
        int rx2 = ReadShortFromBCC(dis);
        int ry2 = ReadShortFromBCC(dis);

        //读取该Frame的包含的零件的长度
        int CurrentFramePieceLength = ReadShortFromBCC(dis);
        short frameData[][] = new short[CurrentFramePieceLength + 1][];

        for (int k = 0; k < CurrentFramePieceLength + 1; k++)
        {
            if (k == 0)
            {
                frameData[k] = new short[8];

                frameData[0][0] = (short) value;
                frameData[0][1] = (short) time;
                frameData[0][2] = (short) globalOX;
                frameData[0][3] = (short) globalOY;
                frameData[0][4] = (short) rx;
                frameData[0][5] = (short) ry;
                frameData[0][6] = (short) (rx2 - rx);
                frameData[0][7] = (short) (ry2 - ry);
            }
            else
            {
                frameData[k] = new short[6];

                int ox = ReadShortFromBCC(dis);
                int oy = ReadShortFromBCC(dis);
                rx = ReadShortFromBCC(dis);
                ry = ReadShortFromBCC(dis);
                rx2 = ReadShortFromBCC(dis);
                ry2 = ReadShortFromBCC(dis);

                frameData[k][0] = (short) rx;
                frameData[k][1] = (short) ry;
                frameData[k][2] = (short) (rx2 - rx);
                frameData[k][3] = (short) (ry2 - ry);
                frameData[k][4] = (short) ox;
                frameData[k][5] = (short) oy;
            }
        }
        return frameData;
    }
    /**
     *从BorlandC++语言中读取 short数据
     */
    public short ReadShortFromBCC(DataInputStream dataInputStream)
    {
        short data[] = new short[2];
        try
        {
            for (int i = 0; i < 2; i++)
            {
                data[i] = (short) dataInputStream.readByte();
                if (data[i] < 0)
                {
                    data[i] = (short) (256 + data[i]);
                }
            }
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
        //  System.out.println("read int "+(data[0]+(int)(data[1]<<8)+(int)(data[2]<<16)+(int)(data[3]<<24)));
        return (short) ( (short) (data[0]) + (short) (data[1] << 8));
    }
    // RETURN FRAME VALUE
    public int setAnimation(int nr, boolean repeat)
    {
        isEndOfAnimation = false;
        isAnimationRepeat = repeat;
        if (!b_LoadedOnce)
        {
            return -1;
        }

        currentAnimation = sprData[nr];

        return setFrame( (short) 0);
    }
    // FRAME VALUE=0 TIME=100 GLOBAL_X=0 GLOBAL_Y=0 RX=0 RY=0 W=21 H=32
    public int setFrame(short nr)
    {
        currentFrameNr = nr;
        currentFrame = currentAnimation[nr];

        currentFrameValue = currentFrame[0][0];
        currentFrameTime = currentFrame[0][1];
        currentFrameGlobalX = currentFrame[0][2];
        currentFrameGlobalY = currentFrame[0][3];
        currentFrameCollisionX = currentFrame[0][4];
        currentFrameCollisionY = currentFrame[0][5];
        currentFrameCollisionW = currentFrame[0][6];
        currentFrameCollisionH = currentFrame[0][7];

        startFrameTime = System.currentTimeMillis();

        return currentFrameValue;
    }
    /**
     * SETTING ANIMATION NEXT FRAME
     * @return int - TRIGGER VALUE OR -1 IF FRAME NOT SWITCHED
     */
    public int setNextFrame()
    {
        if (b_LoadedOnce)
        {
            // CHECK IF WE CAN SWITCH FOR NEXT FRAME (IS FINISHED FRAME TIME)
            if (startFrameTime + currentFrameTime > System.currentTimeMillis())
            {
                return -1;