cdxmotion.h

Go to the documentation of this file.

// CDXMotion.h: interface for the CDXMotion class.
//

#if !defined(AFX_CDXMOTION_H__B1AFC48A_B370_4EBC_B815_8F3A2EB0DE28__INCLUDED_)
#define AFX_CDXMOTION_H__B1AFC48A_B370_4EBC_B815_8F3A2EB0DE28__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

// push avoid dll warning
#ifdef __WIN32__
#pragma warning( push )
#pragma warning( disable: 4251 )
#endif

//#include "cdx.h"
#include "cdxsprite.h"
#include "gamebasetype.h"
#include "ctimer.h"
//#include "cdxspritepool.h"

class CDXMotion;

typedef void CB_CDXMOTION_CHANGED_FRAME(CDXMotion* motion, int old_frame, int current_frame);

ARSA_API void ARSACALLCONV CDXMOTION_SET_CHANGE_FRAME(CB_CDXMOTION_CHANGED_FRAME* func);

#define BBOX_MAX        2
#define CONTEXT         0
#define ATTACK          1

struct BBoxInfo
{
        BBoxInfo()
        {
                Type = CONTEXT;
        }

        irr::core::stringc getTypeStr() const { return Type == CONTEXT ? "CONTEXT" : "ATTACK"; };

        irr::core::stringc Event;
        BYTE  Type;
        RECT  Box;
        CDX_Color Color;
        POINT CenterPos;
};

struct COLLISION
{
        COLLISION()
        {
                SLeft = true;
                STop = true;
                SRight = true;
                SBottom = true;
                SWO = 0;
                ActorInfo = 0;
                Motion = 0;
                Time = 0;
        }

        POINT           HitPoint;
        BBoxInfo        HiterData;
        BBoxInfo        HittyData;
        bool            SLeft,
                                STop,
                                SRight,
                                SBottom;
        void*           SWO;                    
        void*           ActorInfo;              
        void*           Motion;                 
        int                     Time;                   
};

typedef struct COLLISION* PCOLLISION;

//struct FrameBBoxInfo
//{
//      irr::core::array<BBoxInfo>      BBox;                   // bounding box
//      //BYTE          Length;                 // length of bounding box each motion
//}

struct MotionInfo
{
        MotionInfo()
        {
                Sprite = 0;
                //Num = 0;
        }

        CDXSprite*      Sprite;                 
        POINT           SpriteSize;             
        POINT           CenterPos;              
        //int                   Num;                    //! number of sprite
        irr::core::stringc Event;       
        //bool          KillSprite;             //! kill sprite in this class / default is true 

        irr::core::array<irr::core::array<BBoxInfo>> BBox;
        LIFETIMEINFO SpeedTime;
};

// call back function
//typedef bool CBSWOCOLLISION( void*, void*, BYTE, BYTE, PCOLLISION );
//typedef CBSWOCOLLISION *PCBSWOCOLLISION;

class ARSA_API CDXMotion
{
public:
        CDXMotion();
        virtual ~CDXMotion();

        //virtual bool Create( CDXScreen *Screen, CDXSpritePool *SPool, World* world, const char* SMName, void* Data = 0, void* actor = 0, bool usepath = true, bool hflip = true );
        virtual bool CreateByScript( const char* SMName, void* Data = 0, void* actor = 0, bool usepath = true, bool hflip = true);
        virtual bool SaveXML( irr::core::stringc& out_stream );
        virtual bool LoadXML( const irr::core::stringc& in_stream, const irr::io::path& folder = irr::io::path() );

        /* !
        //===========================//
        // use manual add sprite, MUST call AddSprite later
        //===========================//
        */
        //virtual bool  Create(CDXScreen *Screen, CDXSpritePool *SPool, World* world, int Frame, void* Data = 0, void* actor = 0, float Life = 0.0f, bool path = true);
        virtual bool    Create( void* Data = 0, void* actor = 0, float Life = 0.0f, bool path = true);
        virtual bool    Update( bool readevent = true );
        virtual void    Draw( CDXSurface* dest = 0, PRECT Rect = 0, bool CheckScreen = 1, CDX_Color* pal = 0, bool mem_alloc = false );
        //virtual void  Draw( PRECT Rect = 0, bool CheckScreen = 1, CDX_Color* pal = 0, bool mem_alloc = false);
        virtual void    Destroy( void );
        virtual bool    isOk() const { return !m_SpriteList.empty() ? true : false; }
        virtual void    Pause(void);
        virtual void    Run(void);      

        virtual int                     AddSprite( const char* ObjName, int cx, int cy, bool hflip = true );
        virtual int                     AddSprite( int w, int h, int bpp, DWORD flags, int cx, int cy, CDXSurface* src = 0 );
        virtual MotionInfo* GetMotionInfo( int Frame );
        virtual MotionInfo* GetMotionInfoByActive( void );
        virtual CDXSprite*      GetSprite( int Frame );
        virtual int                     GetWidth( int Frame );
        virtual int                     GetHeight( int Frame );
        virtual bool            GetCenterX( int Frame, int* cx );
        virtual bool            GetCenterY( int Frame, int* cy );
        
        virtual bool    InsertEvent( int Frame, const char* Event );
        virtual bool    DeleteEvent( int Frame );
        virtual const char*     GetEvent( int Frame );
        virtual void    AddPosX( int x );
        virtual void    AddPosY( int y );
        virtual void    AddPos( int x, int y );
        virtual void    AddPos( POINT pos );
        virtual void    SetPosX( int x );
        virtual void    SetPosY( int y );
        virtual void    SetPos( int x, int y );
        virtual void    SetPos( POINT pos );
        virtual bool    CalcPos( int frame, long* x, long* y );
        virtual bool    CalcPos( int frame, PPOINT Pos );
        virtual void    UpdatePos();

        virtual bool            CreateColl( void );
        virtual bool            DestroyColl( void );
        virtual bool            AddColl( void* Data );
        virtual bool            RemoveAllColl( void );
        virtual bool            GetColl( void* Data );

        virtual void    SetColor(const irr::video::SColor& color);
        virtual CDX_Color GetColor() const;
        virtual void    SetMotionSpeed( float Speed );
        virtual void    SetMotionSpeedByFrame( float Speed, int Frame );
        virtual void    SetAlpha( WORD AlphaValue );
        virtual void    SetHFlip( void );
        virtual void    SetVFlip( void );
        virtual void    SetVHFlip( void );
        virtual void    SetShadow( bool Enable, const CDX_Color& color = CDX_Color(255,1,1,1) );
        virtual void    SetTrans( void );
        virtual void    SetScale( float Scale );
        virtual void    SetUserData( void* Data );
        virtual void    SetName( const char* Name );
        virtual void    SetFrame( int Frame );
        virtual void    SetFrameReset( void );
        virtual void    SetBBoxShow( bool Show = 1 );
        virtual void    SetBBoxActive( bool Active = 1 );
        virtual void    SetFrameEnd( bool End ) { m_FrameEnd = End; }
        virtual void    SetWorldPos( int wx, int wy )   { m_WorldPos.x = wx; m_WorldPos.y = wy; }
        virtual void    SetWorldPos( const POINT& wpos )        { m_WorldPos = wpos; }
        virtual void    SetBltType( WORD BltType )      { m_BltType = BltType; }
        virtual void    setActor(void* actor) { m_Actor = actor; }

        virtual WORD    GetAlpha( void )                        const { return m_Alpha; }
        virtual bool    GetOutScreen( void );
        virtual const char*     GetName( void );
        virtual void*   GetUserData( void );
        virtual int             GetFrame( void )                        const { return m_FrameCurrent; } // get current motion frame
        //virtual int           GetFrameMax( void )                     const { return m_FrameMax; } // get maximum motion frame        
        virtual irr::u32 GetFrameMax(void)                      const { return m_SpriteList.size(); } // get maximum motion frame
        virtual bool    GetFrameEnd( void );            // get end motion frame
        virtual POINT   GetPos( void )                          const { return m_Pos;   } // get current position
        virtual long    GetPosX( void )                         const { return m_Pos.x; } // get current X position
        virtual long    GetPosY( void )                         const { return m_Pos.y; } // get current Y position
        virtual WORD    GetBltType( void )                      const { return m_BltType; }
        virtual bool    GetBBoxShow( void )                     const { return m_BBoxShow; }
        virtual POINT   GetWorldPos( void )                     const { return m_WorldPos; }
        virtual long    GetWorldPosX( void )            const { return m_WorldPos.x; }
        virtual long    GetWorldPosY( void )            const { return m_WorldPos.y; }
        //virtual void* GetWorld( void )                        const { return m_World; }
        virtual float   GetAllMotionTime( void );
        virtual float   GetLeftMotionTime( void );
        virtual float   GetMotionSpeedByFrame( int Frame );
        virtual bool    GetShadowEnable( void )         const { return m_Shadow; }
        virtual float   GetSpeedByFrame( int Frame );
        virtual bool    GetBBoxActive( void ) const { return m_BBoxActive; }
        virtual irr::core::array<MotionInfo*>& GetList(void) { return m_SpriteList; }
        //virtual irr::core::array<irr::core::array<FrameBBoxInfo>>& GetBBox(void) { return m_FrameBBox; }
        //virtual irr::core::array<LIFETIMEINFO>&       GetSpeed(void) { return m_SpeedTime; }
        virtual const irr::core::array<MotionInfo*>& GetList(void) const { return m_SpriteList; }
        //virtual const irr::core::array<irr::core::array<FrameBBoxInfo>>& GetBBox(void) const { return m_FrameBBox; }
        //virtual const irr::core::array<LIFETIMEINFO>& GetSpeed(void) const { return m_SpeedTime; }
        virtual void* getUserData() const { return m_UserData; }
        virtual void* getActor() const { return m_Actor; }

        virtual void    AddFrameBBox( BYTE Frame, BYTE Type, BYTE Length );
        virtual void    AddBBoxData( BYTE Frame, BYTE Type, BYTE Num, int x, int y, int x2, int y2, const char* EventString );
        virtual void    AddBBoxDataAll( BYTE Type, BYTE Num, int x, int y, int x2, int y2, const char* EventString );
        virtual bool    GetBBoxData( BYTE Frame, BYTE Type, BYTE Num, BBoxInfo* Data );
        virtual bool    GetBBoxPos( BYTE Frame, BYTE Type, BYTE Num, WORD BltTYpe, RECT* Data );
        virtual bool    MotionCollision( CDXMotion* pMotion, BYTE Type, BYTE CheckWithType, PCOLLISION Col );
        virtual bool    MotionCollisionAllFrame( CDXMotion* pMotion, BYTE Type, BYTE CheckWithType, PCOLLISION Col );
        virtual bool    RectCollision( const PRECT Box1, const PRECT Box2, PCOLLISION Col );
        virtual bool    RectCollision( const PRECT Box1, BYTE Type, PCOLLISION Col );

        //virtual void  SetLoopTime( int time )         { m_LoopTime = time; if( m_LoopTime > 1 ) m_Looping = 1; }
        virtual void    SetLoopEnable(bool enable)  { m_Looping = enable?1:0; }
        virtual void    SetLoopTime(int time)           { m_LoopTime = time; SetLoopEnable(true); }
        virtual void    SetLoopStart( int start )       { m_LoopStart = start; }
        virtual void    SetLoopEnd( int end )           { m_LoopEnd = end; }
        virtual void    SetLoopReset(void)                      { if (GetLoopTime() > 1) SetLoopEnable(true); m_LoopCount = 0; }
        virtual int             GetLoopTime( void )     const   { return m_LoopTime; }
        virtual int             GetLoopStart( void )const       { return m_LoopStart; }
        virtual int             GetLoopEnd( void )      const   { return m_LoopEnd; }
        virtual void    SetLoop(bool loop) { m_Loop = loop; }
        virtual bool    IsLoop() const { return m_Loop; }

        virtual CDXMotion* clone( void ); // MUST delete
        virtual void clone(CDXMotion* dest);

        virtual void saveCache(void);

        virtual void SetOrder(irr::u32 order) { m_Order = order; }
        virtual irr::u32 GetOrder() const { return m_Order; }

private:
        //CDXScreen*    m_Screen;               // ref only
        //CDXSpritePool*        m_SPool;        // ref only, sprite pool        
        //World*                m_World;                // ref only
        bool            m_FrameEnd;     
        //int                   m_FrameMax;             //! motion max frame
        int                     m_FrameCurrent; 
        int                     m_OldFrame;             
        //DWORD*                m_SpeedMax;
        void*           m_UserData;             
        void*           m_Actor;                
        WORD            m_BltType;              
        irr::core::stringc m_Name;      
        bool            m_BBoxShow;
        bool            m_BBoxActive;
        //bool          m_UsePath;
        // alpha and shadow
        WORD            m_Alpha;
        bool            m_Shadow;
        CDX_Color       m_ShadowColor;

        //POINT         m_CenterPos;    //! center position of sprite
        POINT           m_Pos;                  
        POINT           m_AbsPos;               
        POINT           m_WorldPos;             
        irr::core::array<MotionInfo*>   m_SpriteList;   
        irr::core::array<void*>         m_Colled;
        //irr::core::array<irr::core::array<FrameBBoxInfo>>     m_FrameBBox;
        //irr::core::array<LIFETIMEINFO>        m_SpeedTime;// motion speed each frame life time
        CGameTimer      m_MotionTime;                   

        // loop 
        int                     m_LoopTime,             
                                m_LoopStart,    
                                m_LoopEnd,              
                                m_LoopCount,    
                                m_Looping;              

        bool            m_Loop;         

        BYTE            m_TempFrame;
        //BYTE          m_TempBBFrame;
        irr::core::stringc      m_TempType;

        irr::u32 m_Order;

        //============================//
        // private function
        //============================//
        void            DrawCross( void );

        bool    VFile_ReadScript( const char* Name, bool hflip = true );
        void    VFile_CheckScript(const char* Name, const irr::core::stringc& str_code, bool hflip = true );

        void init(); 
};

// pop avoid dll warning
#ifdef __WIN32__
#pragma warning( pop )
#endif

#endif // !defined(AFX_CDXMOTION_H__B1AFC48A_B370_4EBC_B815_8F3A2EB0DE28__INCLUDED_)