ParaScriptingCharacter.h

#pragma once

#include "ParaScriptingCommon.h"
#include "ParaScriptingGlobal.h"
#include "BipedObject.h"

namespace ParaEngine{
    class CBaseObject;
    class CMovieCtrler;
    class CSequenceCtler;
    class CFaceTrackingCtrler;
}
namespace luabind
{
    namespace adl{
        class object;
    }
    using adl::object;  
}
namespace ParaScripting
{
    using namespace std;
    using namespace luabind;
    using namespace ParaEngine;
    class ParaObject;

    class PE_CORE_DECL ParaMovieCtrler
    {
    public:
        CMovieCtrler*   m_pMovieCtrler;     // a pointer to the object

        bool IsValid(){return m_pMovieCtrler!=NULL;}
    public:
        ParaMovieCtrler():m_pMovieCtrler(NULL){};
        ParaMovieCtrler(CMovieCtrler* pObj):m_pMovieCtrler(pObj){};
        ~ParaMovieCtrler(){};
    public:
        string GetTime(const char* sFormat);
        void SetTime(float fTime);
        void Suspend();
        void Resume();
        void Play();
        void Record();

        void RecordNewDialog(const char* sDialog);
        bool RecordNewAction(const char* sActionName);
        bool RecordNewAction_(const char* sActionName, float fTime);
        void RecordNewEffect(int effectID, const char* sTarget);

        void GetOffsetPosition(float *x, float *y, float *z);
        void SetOffsetPosition(float x, float y, float z);

        void SaveMovie(const char* filename);
        void LoadMovie(const char* filename);
    };
    class PE_CORE_DECL ParaSeqCtrler
    {
    public:
        CSequenceCtler* m_pSequenceCtrler;      // a pointer to the object

        bool IsValid(){return m_pSequenceCtrler!=NULL;}
    public:
        ParaSeqCtrler():m_pSequenceCtrler(NULL){};
        ParaSeqCtrler(CSequenceCtler* pObj):m_pSequenceCtrler(pObj){};
        ~ParaSeqCtrler(){};
    public:
        bool Save(bool bOverride);
        bool LoadByID(int nSequenceID);
        bool LoadFromFile(const char* fileName);
        int  Create(const char* name, const char* description, const char* pData,bool bInMemory);
        string ToString();

        int GetKeyPos();
        void SetKeyPos(int nPos);

        int GetTotalKeys();
        int AdvanceKey(int nOffset);
        void BeginAddKeys();
        void EndAddKeys();

        int GetSequenceID();
        bool DeleteKeysRange(int nFrom, int nTo);

        bool GetPlayDirection();
        void SetPlayDirection(bool bForward);

        float GetInterval();
        void SetInterval(float fInterval);

        void GetStartPos(float& x, float& y, float&z);
        void SetStartPos(float x, float y, float z);

        float GetStartFacing();
        void SetStartFacing(float facing);

        int GetPlayMode();
        void SetPlayMode(int mode);

        float GetMovingTimeout();
        void SetMovingTimeout(float fTimeout);

        void Suspend();
        void Resume();
        // commands:
    public:

        void RunTo(float x,float y,float z);
        void WalkTo(float x,float y,float z);
        void MoveTo(float x,float y,float z);
        void MoveAndTurn(float x,float y,float z,float facing);
        void PlayAnim(const char* sAnim);
        void PlayAnim1(int nAnimID);
        void Wait(float fSeconds);
        void Exec(const char* sCmd);
        void Pause();
        void Turn(float fAngleAbsolute);
        void MoveForward(float fDistance);
        void MoveBack(float fDistance);
        void MoveLeft(float fDistance);
        void MoveRight(float fDistance);
        void Jump();
        void Goto(int nOffset);
        void Goto1(const char* sLable);
        void Lable(const char* sLable);
    };
    
    class PE_CORE_DECL ParaFaceTrackingCtrler
    {
    public:
        CFaceTrackingCtrler*    m_pFaceTrackingCtrler;      // a pointer to the object

        bool IsValid(){return m_pFaceTrackingCtrler!=NULL;}
    public:
        ParaFaceTrackingCtrler():m_pFaceTrackingCtrler(NULL){};
        ParaFaceTrackingCtrler(CFaceTrackingCtrler* pObj):m_pFaceTrackingCtrler(pObj){};
        ~ParaFaceTrackingCtrler(){};
    public:
        void FaceTarget(float x, float y, float z, float fDuration);
    };

    class PE_CORE_DECL ParaCharacter
    {
    public:
        CBipedObject::WeakPtr_type m_pCharacter;        // a pointer to the object

        bool IsValid();
    public:
        ParaCharacter();
        ParaCharacter(CBaseObject* pObj);
        ~ParaCharacter();

        void SetSpeedScale(float fSpeedScale);
        float GetSpeedScale();

        void FallDown();

        void SetSizeScale(float fScale);
        float GetSizeScale();

        void SetFocus();

        void AddAction2(int nAction, const object& param);
        void AddAction(int nAction);

        bool WalkingOrRunning();

        bool HasAnimation(int nAnimID);

        bool IsCustomModel();

        void ResetBaseModel(ParaAssetObject assetCharBaseModel);

        void SetSkin(int nIndex);

        int GetSkin();

        void LoadStoredModel(int nModelSetID);

        void PlayAnimation(const object& anims);
        

        int GetAnimID();

        const char* GetAnimFileName();

        void EnableAnimIDMap(bool bEnable);

        bool IsAnimIDMapEnabled();

        bool AddAnimIDMap(int nFromID, int nToID);

        void ClearAllAnimIDMap();

        
        bool HasMountPoint(int nMountPointID);

        bool IsMounted();

        void MountOn_(const char* sTarget);

        void MountOn(ParaObject& target);

        void MountOn2(ParaObject& target, int nMountID);

        void UnMount();

        void SetBodyParams(int skinColor, int faceType, int hairColor, int hairStyle, int facialHair);

        int GetBodyParams(int type);

        void SetDisplayOptions(int bShowUnderwear, int bShowEars, int bShowHair);

        bool GetDisplayOptions(int type);

        void SetCharacterSlot(int nSlotID, int nItemID);

        int GetCharacterSlotItemID(int nSlotID);

        
        void LoadFromFile(const char* filename);
        void SaveToFile(const char* filename);

        void RefreshModel();

        void UseAIModule(const char* sAIType );

        void AssignAIController(const char* sAICtrlerName, const char* sParam1);
        bool IsAIControllerEnabled(const char* sAICtrlerName);

        ParaMovieCtrler GetMovieController();

        ParaSeqCtrler GetSeqController();

        ParaFaceTrackingCtrler GetFaceTrackingController();

        void CastEffect(int nEffectID);
        void CastEffect2(int nEffectID, const char* sTarget);

        void AddAttachment(ParaAssetObject ModelAsset, int nAttachmentID);
        void AddAttachment3(ParaAssetObject ModelAsset, int nAttachmentID, int nSlotID);
        void AddAttachment4(ParaAssetObject ModelAsset, int nAttachmentID, int nSlotID, float fScaling);
        void AddAttachment5(ParaAssetObject ModelAsset, int nAttachmentID, int nSlotID, float fScaling, ParaAssetObject ReplaceableTexture);

        ParaAttributeObject GetAttachmentAttObj(int nAttachmentID);

        void RemoveAttachment(int nAttachmentID);
        void RemoveAttachment2(int nAttachmentID, int nSlotID);

        void Stop();
        void MoveTo(double x, double y, double z);
        void MoveAndTurn(double x, double y, double z, float facing);

        //
        // cartoon face functions
        //

        double GetCartoonFaceComponent(int nComponentID, int SubType);
        string GetCartoonFaceComponentCode(int nComponentID, int SubType);

        void SetCartoonFaceComponent(int nComponentID, int SubType, double value);
        
        void SetCartoonFaceComponentCode(int nComponentID, int SubType, const char * color);

        bool IsSupportCartoonFace();

        void SetSkinColorMask(const char * strColor);

        string GetSkinColorMask();


        int GetGender();

        int GetRaceID();

    };
}