BipedObject.h

#pragma once
#include "IGameObject.h"
#include "ShadowVolume.h"
#include "BipedWayPoint.h"

namespace ParaEngine
{
    struct IParaPhysicsActor;

    class CBipedObject : public IGameObject, ShadowCaster
    {
    public:
        typedef ParaEngine::weak_ptr<IObject, CBipedObject> WeakPtr_type;

        virtual std::string ToString(DWORD nMethod);
        virtual CBaseObject::_SceneObjectType GetType(){ return CBaseObject::BipedObject; };

        typedef std::list<BipedWayPoint> WayPointList_type;

        enum PhysicsMoveStyle
        {
            MOVESTYLE_SLIDINGWALL = 0,
            MOVESTYLE_HEIGHTONLY,
            MOVESTYLE_ABOVETERRAIN,
            MOVESTYLE_LINEAR,
            MOVESTYLE_OPC,
        };

        enum RenderSelectionStyle
        {
            RenderSelectionStyle_unlit = 0,
            RenderSelectionStyle_border = 1,
            RenderSelectionStyle_flash = 2,
        };


        static const float SPEED_TURN;
        static const float SPEED_WALK;
        static const float SPEED_NORM_TURN;
        
    public:
        CBipedObject(void);
        virtual ~CBipedObject(void);

    public:
        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){ return ATTRIBUTE_CLASSID_CBipedObject; }
        virtual const char* GetAttributeClassName(){ static const char name[] = "CBipedObject"; return name; }
        virtual const char* GetAttributeClassDescription(){ static const char desc[] = ""; return desc; }
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual int GetChildAttributeColumnCount();
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        ATTRIBUTE_METHOD1(CBipedObject, GetPhysicsRadius_s, float*)     { *p1 = cls->GetPhysicsRadius(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetPhysicsRadius_s, float)      { cls->SetPhysicsRadius(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetPhysicsHeight_s, float*)     { *p1 = cls->GetPhysicsHeight(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetPhysicsHeight_s, float)      { cls->SetPhysicsHeight(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetSizeScale_s, float*)     { *p1 = cls->GetSizeScale(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetSizeScale_s, float)      { cls->SetSizeScale(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetDensity_s, float*)       { *p1 = cls->GetDensity(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetDensity_s, float)        { cls->SetDensity(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetSpeedScale_s, float*)        { *p1 = cls->GetSpeedScale(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetSpeedScale_s, float)     { cls->SetSpeedScale(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetCurrentAnimation_s, int*)        { *p1 = cls->GetCurrentAnimation(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, PlayAnimation_s, int)       { cls->PlayAnimation(p1); return S_OK; }
        ATTRIBUTE_METHOD(CBipedObject, DumpBVHAnimations_s)     { cls->DumpBVHAnimations(); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetHeadTurningAngle_s, float*)      { *p1 = cls->GetHeadTurningAngle(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetHeadTurningAngle_s, float)       { cls->SetHeadTurningAngle(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetHeadUpdownAngle_s, float*)       { *p1 = cls->GetHeadUpdownAngle(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetHeadUpdownAngle_s, float)        { cls->SetHeadUpdownAngle(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetBootHeight_s, float*)        { *p1 = cls->GetBootHeight(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetBootHeight_s, float)     { cls->SetBootHeight(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetMovementStyle_s, int*)       { *p1 = cls->GetMovementStyle(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetMovementStyle_s, int)        { cls->SetMovementStyle((PhysicsMoveStyle)p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetSpeed_s, float*)     { *p1 = cls->GetSpeed(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetSpeed_s, float)      { cls->SetSpeed(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetLastSpeed_s, float*)     { *p1 = cls->GetLastSpeed(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetLastSpeed_s, float)      { cls->SetLastSpeed(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetAccelerationDist_s, float*)      { *p1 = cls->GetAccelerationDist(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetAccelerationDist_s, float)       { cls->SetAccelerationDist(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetVerticalSpeed_s, float*)     { *p1 = cls->GetVerticalSpeed(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetVerticalSpeed_s, float)      { cls->SetVerticalSpeed(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetPhysicsGroupSensorMask_s, DWORD*)        { *p1 = cls->GetPhysicsGroupMask(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetPhysicsGroupSensorMask_s, DWORD)     { cls->SetPhysicsGroupMask(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetMaxSpeed_s, float*)      { *p1 = cls->GetMaxSpeed(); return S_OK; }

        ATTRIBUTE_METHOD(CBipedObject, ForceStop_s) { cls->ForceStop(); return S_OK; }

        ATTRIBUTE_METHOD(CBipedObject, ForceMove_s) { cls->ForceMove(); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetIsAlwaysAboveTerrain_s, bool*)       { *p1 = cls->GetIsAlwaysAboveTerrain(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetIsAlwaysAboveTerrain_s, bool)        { cls->SetIsAlwaysAboveTerrain(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetIsAnimPaused_s, bool*)       { *p1 = cls->GetIsAnimPaused(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetIsAnimPaused_s, bool)        { cls->SetIsAnimPaused(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, SetBlendingFactor_s, float)     { cls->SetBlendingFactor(p1); return S_OK; }


        ATTRIBUTE_METHOD1(CBipedObject, GetLastWayPointType_s, int*)        { *p1 = cls->GetLastWayPoint().GetPointType(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, GetLastWayPointPos_s, Vector3*)     { *p1 = cls->GetLastWayPoint().GetPosition(); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetGravity_s, float*)       { *p1 = cls->GetGravity(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetGravity_s, float)        { cls->SetGravity(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetIgnoreSlopeCollision_s, bool*)       { *p1 = cls->GetIgnoreSlopeCollision(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetIgnoreSlopeCollision_s, bool)        { cls->SetIgnoreSlopeCollision(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetCanFly_s, bool*)     { *p1 = cls->GetCanFly(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetCanFly_s, bool)      { cls->SetCanFly(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetAlwaysFlying_s, bool*)       { *p1 = cls->GetAlwaysFlying(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetAlwaysFlying_s, bool)        { cls->SetAlwaysFlying(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetIsFlying_s, bool*)       { *p1 = cls->GetIsFlying(); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, GetFlyUsingCameraDir_s, bool*)      { *p1 = cls->GetFlyUsingCameraDir(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetFlyUsingCameraDir_s, bool)       { cls->SetFlyUsingCameraDir(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, IsAutoWalkupBlock_s, bool*)     { *p1 = cls->IsAutoWalkupBlock(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetAutoWalkupBlock_s, bool)     { cls->SetAutoWalkupBlock(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBipedObject, IsControlledExternally_s, bool*)        { *p1 = cls->IsControlledExternally(); return S_OK; }
        ATTRIBUTE_METHOD1(CBipedObject, SetIsControlledExternally_s, bool)      { cls->SetIsControlledExternally(p1); return S_OK; }

    protected:
        bool MoveTowards(double dTimeDelta, const DVector3& vPosTarget, float fStopDistance, bool * pIsSlidingWall = NULL);

        bool MoveTowards_OPC(double dTimeDelta, const DVector3& vPosTarget, float fQuickMoveDistance = 15.f);

        bool MoveTowards_Linear(double dTimeDelta, const DVector3& vPosTarget);

        bool CheckBlockWorld(DVector3& vMovePos, Vector3& vMinPos, Vector3& vMaxPos, bool& bUseGlobalTerrainNorm, bool& bReachPos, Vector3& vBipedFacing, float fDeltaTime);

        bool FacingTowards(double dTimeDelta, float fTargetFacing);
        void UpdateState(float fTimeDelta);

        bool SetParamsFromAsset();

        void SetIsAlwaysAboveTerrain(bool bEnable) { m_bIsAlwaysAboveTerrain = bEnable; }
        bool GetIsAlwaysAboveTerrain() { return m_bIsAlwaysAboveTerrain; }

        void SetIsAnimPaused(bool bPaused) { m_bPauseAnimation = bPaused; }
        bool GetIsAnimPaused() { return m_bPauseAnimation; }

        void SetBlendingFactor(float fBlendingFactor);

        bool FlyTowards(double dTimeDelta, const DVector3& vPosTarget, float fStopDistance, bool * pIsSlidingWall);
    public:
        void SetMovementStyle(PhysicsMoveStyle nValue){ m_nMovementStyle = nValue; };

        PhysicsMoveStyle  GetMovementStyle(){ return m_nMovementStyle; };

        bool CanAnimOpacity() const;

        virtual Matrix4* GetRenderMatrix(Matrix4& pOut, int nRenderNumber = 0);

        virtual Matrix4* GetAttachmentMatrix(Matrix4& pOut, int nAttachmentID = 0, int nRenderNumber = 0);

        virtual bool HasAttachmentPoint(int nAttachmentID = 0);

        virtual bool ViewTouch();

        virtual int ProcessObjectEvent(const ObjectEvent& event);
        virtual void SetPrimaryTechniqueHandle(int nHandle);

        virtual void SetPosition(const DVector3& v);
        HRESULT InitObject(AssetEntity* pMAE);
        void DeleteAnimInstance();
        virtual void Cleanup();
        CAnimInstanceBase* GetAnimInstance();
        CParaXAnimInstance* GetParaXAnimInstance();
        CharModelInstance* GetCharModelInstance();

        bool DumpBVHAnimations();

        CBaseObject* GetPhysicsBBObj();

        //-- virtual function from baseObject
        virtual HRESULT Draw(SceneState * sceneState);
        virtual void Animate(double dTimeDelta, int nRenderNumber = 0);
        

        virtual AssetEntity* GetPrimaryAsset();

        virtual void SetNormal(const Vector3 & pNorm);
        virtual Vector3 GetNormal();

        virtual void SetScaling(float s);

        virtual float GetScaling();

        virtual void SetLocalTransform(const Matrix4& mXForm);
        virtual void GetLocalTransform(Matrix4* localTransform);

        virtual void GetOBB(CShapeOBB* obb);

        virtual void Reset();

        virtual void PathFinding(double dTimeDelta);

        virtual void AnimateBiped(double dTimeDelta, bool bSharpTurning = false /*reserved*/);

        virtual void SetAssetFileName(const std::string& sFilename);

        virtual int GetNumReplaceableTextures();

        virtual TextureEntity* GetDefaultReplaceableTexture(int ReplaceableTextureID);

        virtual TextureEntity* GetReplaceableTexture(int ReplaceableTextureID);

        virtual bool  SetReplaceableTexture(int ReplaceableTextureID, TextureEntity* pTextureEntity);

        void OneObstaclePathFinding(CBaseObject* pSolid);

        virtual void PushParam();
        virtual void PopParam();

        virtual bool HasAlphaBlendedObjects();

        bool GetWayPoint(BipedWayPoint* pOut);
        BipedWayPoint& GetLastWayPoint();

        void AddWayPoint(const BipedWayPoint& pt);
        void RemoveWayPoint();
        void RemoveWayPointByType(BipedWayPoint::MyType nType = BipedWayPoint::COMMAND_POINT);


        virtual void SetUserControl();
        virtual void ChooseNewLocation(Vector3 *pV);

        /* Low level events(LLE) replacement to low level command*/

        void ReplaceAIModule(CAIBase* pNew);
        virtual CAIBase*         GetAIModule();
        CAIBase* UseAIModule(const string& sAIType);

        void FacingTargetImmediately();
        void FacingTarget(const Vector3 *pV);
        void FacingTarget(float fTargetFacing);


        virtual float GetRoll();
        virtual void SetRoll(float fValue);

        virtual float GetPitch();
        virtual void SetPitch(float fValue);

        virtual void SetYaw(float fFacing);

        virtual void UpdateGeometry();
        
        void SetHeadTurningAngle(float fFacing);
        float GetHeadTurningAngle();

        void SetHeadUpdownAngle(float fFacing);
        float GetHeadUpdownAngle();

        float GetHeadFacing();

        virtual void SetOpacity(float fOpacity);

        void GetSpeedDirection(Vector3 *pV);
        void SetSpeedAngle(float fSpeedAngle);
        float GetSpeedAngle();
        float GetSpeed();

        float GetLastSpeed();
        void SetLastSpeed(float fSpeed);

        float GetAccelerationDist();
        void SetAccelerationDist(float fAccelerationDist = 0.f);


        float GetAbsoluteSpeed();
        void SetSpeed(float fSpeed);
        float GetMaxSpeed();
        virtual void SetSpeedScale(float dScale);
        virtual float GetSpeedScale();
        virtual void SetSizeScale(float dScale);
        virtual float GetSizeScale();

        void SetBootHeight(float fBootHeight);
        float GetBootHeight();

        void SetDensity(float fDensity);
        float GetDensity();

        void SetGravity(float gravity);
        float GetGravity();

        void SetIgnoreSlopeCollision(bool ignoreSlope);
        bool GetIgnoreSlopeCollision();

        void SetCanFly(bool canFly);
        bool GetCanFly();

        bool GetAlwaysFlying() const;
        void SetAlwaysFlying(bool val);

        bool GetFlyUsingCameraDir() const;
        void SetFlyUsingCameraDir(bool val);

        bool GetIsFlying();

        void SetFlyingDirection(const Vector3 *dir);

        void SetAutoWalkupBlock(bool bAutoWalkup);
        bool IsAutoWalkupBlock();

        bool IsControlledExternally() const;
        void SetIsControlledExternally(bool val);

        void FallDown();

        virtual bool IsStanding();
        bool IsStandingIntentioned();
        void SetStandingState();
        bool IsBipedBlocked();

        void SetWalkingState(const char* sName = NULL);

        virtual CBipedStateManager*  GetBipedStateManager(bool bCreateOnDemand = true);

        virtual void SetOnAssetLoaded(const char* sCallbackScript);

        void PlayAnimation(DWORD nIndex, bool bUpdateSpeed = true, bool bAppend = false);

        void PlayAnimation(const char* sName, bool bUpdateSpeed = true, bool bAppend = false);
        int GetCurrentAnimation();


        virtual void SetAnimation(int nAnimID);

        virtual int GetAnimation();

        virtual bool HasAnimation(int nAnimID);

        virtual void SetAnimFrame(int nFrame);

        virtual int GetAnimFrame();

        virtual void EnableAnim(bool bAnimated);
        virtual bool IsAnimEnabled();

        virtual int GetTime();
        virtual void SetTime(int nTime);

        virtual void SetUseGlobalTime(bool bUseGlobalTime);

        virtual bool IsUseGlobalTime();

        bool MountOn(CBaseObject* pTarget, int nMountID = -1);

        void UpdateSpeed(float fSpeed);

        float GetVerticalSpeed();
        void SetVerticalSpeed(float fSpeed);

        void UseSpeedFromAnimation(int nIndex);
        void UseSpeedFromAnimation(const char* sName);

        bool HasAnimId(int nAnimID);

        void PlayDeathDecayAnim();

        void SetNextTargetPosition(const DVector3 &pV, bool bIgnoreHeight = true);
        void WalkTo(const DVector3& pV, bool bIgnoreHeight = true);
        void ForceMove();
        void ForceStop();
        void JumpUpward(float fVerticalSpeed, bool bJumpFromGround);

        virtual float       GetPhysicsRadius();
        void        SetPhysicsRadius(float fR);
        float       GetPhysicsHeight();
        void        SetPhysicsHeight(float fH);
        float GetAssetHeight();

        void ResetBipedPosition(const Vector3 *pV, bool bIgnoreHeight = true);

        virtual void Rotate(float x, float y, float z);

        virtual void SetPhysicsGroupMask(DWORD dwValue);

        virtual DWORD GetPhysicsGroupMask();

    public:
        /* advanced character control functions.*/

        void ResetBaseModel(AssetEntity* assetCharBaseModel);
        void LoadStoredModel(int nModelSetID);

    public:
        virtual bool IsShadowEnabled(){ return m_bIsShadowEnabled; };
        virtual void BuildShadowVolume(SceneState * sceneState, ShadowVolume * pShadowVolume, LightParams* pLight);
        
        virtual IGameObject* QueryIGameObject();

        virtual int On_EnterSentientArea();
        virtual int On_LeaveSentientArea();

        virtual int On_Click(DWORD nMouseKey, DWORD dwParam1, DWORD dwParam2);

        virtual int On_Event(DWORD nEventType, DWORD dwParam1, DWORD dwParam2);

        virtual int On_Perception();
        virtual int On_FrameMove();
        virtual int On_Net_Send(DWORD dwNetType, DWORD dwParam1, DWORD dwParam2);
        virtual int On_Net_Receive(DWORD dwNetType, DWORD dwParam1, DWORD dwParam2);

        virtual bool CanHasPhysics();
        virtual void LoadPhysics();
        virtual void UnloadPhysics();
        virtual void SetPhysicsGroup(int nGroup);
        virtual int GetPhysicsGroup();
        virtual void EnablePhysics(bool bEnable);
        virtual bool IsPhysicsEnabled();
        int GetStaticActorCount();

    protected:
        void AnimateIdle(double dTimeDelta);
        void AnimateMoving(double dTimeDelta, bool bSharpTurning = false);

        void AnimateUserControl(double dTimeDelta);

        ParaXEntity* GetParaXEntity();
    private:
        // -- data structuring
        asset_ptr<AssetEntity>          m_pMultiAnimationEntity;
        ref_ptr<CAnimInstanceBase>      m_pAI;


        PhysicsMoveStyle m_nMovementStyle;

        float       m_fPhysicsRadius;

        /* physical height. this value will restrict the biped's vertical movement.
        if there is no head attachment, the GetPhysicsHeight is used to for character head on position instead.
        If m_fPhysicsHeight is never set, it is always 4*m_fPhysicsRadius. However, if it is set, its value are maintained.
        */
        float       m_fPhysicsHeight;

        // the biped state manager
        CBipedStateManager*  m_pBipedStateManager;

        CAIBase*         m_pAIModule;

        float       m_fSpeed;
        float       m_fLastSpeed;
        float       m_fAccelerationDist;
        float       m_fSpeedAngle;
        float       m_fSpeedVertical;

        Vector3          m_vNorm;
        Vector3          m_vNormTarget;

        float m_fRoll;
        float m_fPitch;

        WayPointList_type m_vPosTarget;

        // float                m_fFacing;  // it is already defined in base object class
        float                m_fFacingTarget;

        float m_fBootHeight;

        float m_fLastBlockLight;
        DWORD m_dwLastBlockHash;

        float m_fDensity;

        //default to 9.18
        float m_gravity;

        float   m_fSizeScale;

        float   m_fSpeedScale;
        float m_fAssetHeight;
        Vector3 m_flyingDir;

        DWORD m_dwPhysicsGroupSensorMask;

        DWORD m_dwPhysicsGroupMask;

        vector<IParaPhysicsActor*> m_staticActors;
        // any bit wise combination of PHYSICS_METHOD
        DWORD m_dwPhysicsMethod;
        uint32 m_nPhysicsGroup;

        bool m_bIgnoreFacingTarget : 1;
        bool m_bIsShadowEnabled : 1;
        bool m_bIsAlwaysAboveTerrain : 1;
        bool m_bPauseAnimation : 1;

        bool m_ignoreSlopeCollision : 1;
        bool m_isFlying : 1;
        bool m_canFly : 1;
        bool m_isAlwaysFlying : 1;
        bool m_isFlyUsingCameraDir : 1;
        bool m_readyToLanding : 1;
        bool m_bAutoWalkupBlock : 1;
        bool m_bIsControlledExternally : 1;
        bool m_bCanAnimOpacity : 1;
        
    };

}