IGameObject.h

#pragma once
#include "TileObject.h"
#include <vector>
namespace ParaEngine
{
    class CAIBase;
    class CShapeAABB;

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

        IGameObject();
        virtual ~IGameObject();
        virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::GameObject;};
        
    public:
        // implementation of IAttributeFields

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

        virtual bool ResetField(int nFieldID);

        virtual bool InvokeEditor(int nFieldID, const string& sParameters);

        
        ATTRIBUTE_METHOD1(IGameObject, IsModified_s, bool*)     {*p1 = cls->IsModified(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetModified_s, bool)     {cls->SetModified(p1); return S_OK;}
        ATTRIBUTE_METHOD(IGameObject, SaveToDB_s)       {return cls->SaveToDB()?S_OK:E_FAIL;}

        ATTRIBUTE_METHOD1(IGameObject, GetOnLoadScript_s, const char**) {*p1 = cls->GetOnLoadScript().c_str(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetOnLoadScript_s, const char*)  {cls->SetOnLoadScript(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(IGameObject, IsLoaded_s, bool*)   {*p1 = cls->IsLoaded(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetLoaded_s, bool)   {cls->SetLoaded(p1); return S_OK;}

        DEFINE_SCRIPT_EVENT(IGameObject, EnterSentientArea);
        DEFINE_SCRIPT_EVENT(IGameObject, LeaveSentientArea);
        DEFINE_SCRIPT_EVENT(IGameObject, Click);
        DEFINE_SCRIPT_EVENT(IGameObject, Event);
        DEFINE_SCRIPT_EVENT(IGameObject, Perception);
        DEFINE_SCRIPT_EVENT(IGameObject, FrameMove);
        DEFINE_SCRIPT_EVENT(IGameObject, Net_Send);
        DEFINE_SCRIPT_EVENT(IGameObject, Net_Receive);


        ATTRIBUTE_METHOD1(IGameObject, IsGlobal_s, bool*)       {*p1 = cls->IsGlobal(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, MakeGlobal_s, bool)      {cls->MakeGlobal(p1); return S_OK;}

        ATTRIBUTE_METHOD1(IGameObject, IsSentient_s, bool*)         {*p1 = cls->IsSentient(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, MakeSentient_s, bool)        {cls->MakeSentient(p1); return S_OK;}

        ATTRIBUTE_METHOD1(IGameObject, IsAlwaysSentient_s, bool*)       {*p1 = cls->IsAlwaysSentient(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetAlwaysSentient_s, bool)       {cls->SetAlwaysSentient(p1); return S_OK;}

        ATTRIBUTE_METHOD1(IGameObject, GetSentientRadius_s, float*)     {*p1 = cls->GetSentientRadius(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetSentientRadius_s, float)      {cls->SetSentientRadius(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(IGameObject, GetPerceptiveRadius_s, float*)           {*p1 = cls->GetPerceptiveRadius(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetPerceptiveRadius_s, float)        {cls->SetPerceptiveRadius(p1); return S_OK;}

        ATTRIBUTE_METHOD1(IGameObject, GetGroupID_s, int*)          {*p1 = cls->GetGroupID(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetGroupID_s, int)       {cls->SetGroupID(p1); return S_OK;}

        ATTRIBUTE_METHOD1(IGameObject, GetSentientField_s, int*)            {*p1 = cls->GetSentientField(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetSentientField_s, int)     {cls->SetSentientField(p1, false); return S_OK;}
        
        ATTRIBUTE_METHOD1(IGameObject, GetFrameMoveInterval_s, int*)            {*p1 = cls->GetFrameMoveInterval(); return S_OK;}
        ATTRIBUTE_METHOD1(IGameObject, SetFrameMoveInterval_s, int)     {cls->SetFrameMoveInterval(p1); return S_OK;}

    public:
        virtual bool SaveToDB();

        virtual void PathFinding(double dTimeDelta);

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


        virtual CAIBase*         GetAIModule();

        // the following must be implemented. The IGameObject will automatically activate
        // the script. Hence, object which implements these functions need to call the base class
        // to ensure that the script is also activated. 

        virtual int On_Attached();
        virtual int On_Detached();

        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);
    public:
        // the following is  implemented.

        void LoadOnLoadScriptIfNot();

        void SetOnLoadScript(const string& str);
        const string& GetOnLoadScript() {return m_sOnLoadScript;};

        bool IsLoaded() { return m_bIsLoaded; };
        void SetLoaded(bool bLoaded) { m_bIsLoaded =bLoaded; };

        virtual bool IsSentient();
        virtual void MakeSentient(bool bSentient=true);

        void ForceSentient(bool bSentient=true);

        float GetSentientRadius();
        void SetSentientRadius(float fR);

        float GetPerceptiveRadius();
        void SetPerceptiveRadius(float fNewRaduis);

        int GetNumOfPerceivedObject();

        IGameObject* GetPerceivedObject(int nIndex);

        float GetDistanceSq2D(IGameObject* pObj);

        bool IsAlwaysSentient() const;
        void SetAlwaysSentient(bool bAlways);

        virtual void UpdateTileContainer();

        virtual void SetTileContainer(CTerrainTile * pTile);

        virtual bool IsGlobal(){return m_bIsGlobal;}
        
        virtual void MakeGlobal(bool bGlobal);

        virtual void SetMovableRegion(const CShapeAABB* aabb);
        virtual const CShapeAABB* GetMovableRegion();
        
        void SetGroupID(int nGroup);
        int GetGroupID();

        void SetSentientField(DWORD dwFieldOrGroup, bool bIsGroup=false);
        DWORD GetSentientField();

        bool IsSentientWith(const IGameObject * pObj);

        virtual bool IsPersistent();
        virtual void SetPersistent(bool bPersistent);
        
        virtual bool IsModified(){return m_bModified;};
        virtual void SetModified(bool bModified){m_bModified = bModified;};

        virtual void SetSpeedScale(float dScale){};
        virtual float GetSpeedScale(){return 1.0f;};
        virtual void SetSizeScale(float dScale){};
        virtual float GetSizeScale(){return 1.0f;};

        inline int GetSimTag(){return m_nSimTag;}
        inline void SetSimTag(int nTag){m_nSimTag = nTag;}
        inline std::vector <std::string>& GetPerceiveList(){return m_PerceivedList;};

        
        inline int GetSentientObjCount(){return m_nSentientObjCount;};
        inline void SetSentientObjCount(int nCount){m_nSentientObjCount = nCount;};
        
        void SetFrameMoveInterval(int nFrameMoveInterval) { m_nFrameMoveInterval = nFrameMoveInterval; };
        int GetFrameMoveInterval() {return m_nFrameMoveInterval; };
        

    protected:
        // this tag is served for simulation.
        int m_nSimTag;
    private:
        bool m_bIsLoaded;
        bool m_bModified;
        bool m_bIsGlobal;
        bool m_bIsPersistent;
        bool m_bAlwaysSentient;

        string       m_sOnLoadScript;

        std::vector <std::string> m_PerceivedList;

        int m_nSentientObjCount;

        float m_fSentientRadius;

        float   m_fPeceptiveRadius;
        int m_nGroup;
        DWORD m_dwSentientField;

        unsigned int m_nFrameMoveInterval;
        
        friend class CSceneObject;
    };

}