GameNetCommon.h

#pragma once
#include "ValueTracker.h"
#include <map>

#define CLIENT_NORMAL_UPDATE_RATE   3

#define SERVER_NORMAL_UPDATE_RATE   3

namespace ParaEngine
{
    using namespace std;
    class CNetTime
    {
    public:
        CNetTime()
        {
            Reset();
        }

        void Reset()
        {
            m_nTime = 0;
        }

        inline int GetTime()
        {
            return m_nTime;
        }

        void FrameMove()
        {
            ++m_nTime;
        }
    private:
        int m_nTime;
    };

    class CNormalUpdatePacket
    {
    public:
        CNormalUpdatePacket(void);
        ~CNormalUpdatePacket(void);
    };

    class CCharacterTracker
    {
    public:
        CCharacterTracker(void){
            m_nLastSendTime.resize(3, INVALID_TIME);
            m_nLastReceiveTime.resize(3, INVALID_TIME);
            m_vPos.SetSize(6);
            m_arrayCustomModelData.SetSize(1);
        };
        ~CCharacterTracker(void){};

    public:
        void Reset()
        {
            for(int i=0;i<(int)m_nLastSendTime.size();++i)
                m_nLastSendTime[i] = INVALID_TIME;

            for(int i=0;i<(int)m_nLastReceiveTime.size();++i)
                m_nLastReceiveTime[i] = INVALID_TIME;

            m_vPos.Reset();
            m_fFacing.Reset();
            m_fVerticalSpeed.Reset();
            m_fSpeed.Reset();
            m_nAnimID.Reset();
            m_bWalking.Reset();
            m_bRunning.Reset();
            m_bIsGlobal.Reset();

            m_fSizeScale.Reset();
            m_sBasemodel.Reset();
            m_bIsCustomModel.Reset();
            m_arrayCustomModelData.Reset();
            m_nSkinIndex.Reset();
        }
        int GetLastSendTime(int nGroupIndex = 0)
        {
            if(nGroupIndex>=0 && nGroupIndex<(int)m_nLastSendTime.size())
                return m_nLastSendTime[nGroupIndex];
            else
                return INVALID_TIME;
        }
        void SetLastSendTime(int nTime, int nGroupIndex = 0)
        {
            if(nGroupIndex>=0 && nGroupIndex<(int)m_nLastSendTime.size())
                m_nLastSendTime[nGroupIndex] = nTime;
        }

        int GetLastReceiveTime(int nGroupIndex = 0)
        {
            if(nGroupIndex>=0 && nGroupIndex<(int)m_nLastReceiveTime.size())
                return m_nLastReceiveTime[nGroupIndex];
            else
                return INVALID_TIME;
        }

        void SetLastReceiveTime(int nTime, int nGroupIndex = 0)
        {
            if(nGroupIndex>=0 && nGroupIndex<(int)m_nLastReceiveTime.size())
                m_nLastReceiveTime[nGroupIndex] = nTime;
        }

        bool IsContant()
        {
            return IsGroupConstant(1) && IsGroupConstant(2);
        }

        bool IsGroupConstant(int nGroup)
        {
            switch(nGroup)
            {
            case 1:
                return m_vPos.IsConstant() && m_fFacing.IsConstant() &&  m_fVerticalSpeed.IsConstant() &&  m_fSpeed.IsConstant() &&  m_nAnimID.IsConstant() && 
                    m_bWalking.IsConstant() &&  m_bRunning.IsConstant();
            case 2:
                return  m_fSizeScale.IsConstant() && m_sBasemodel.IsConstant();
            default:
                return false;
            }
        }

    public:
        // group 1: position, facing, speed and animation
        CVector3Tracker m_vPos; 
        CFloatTracker   m_fFacing;
        CFloatTracker   m_fVerticalSpeed;
        CFloatTracker   m_fSpeed;
        CIntTracker     m_nAnimID;
        CBooleanTracker m_bWalking;
        CBooleanTracker m_bRunning;
        CBooleanTracker m_bIsGlobal; // not in any group

        // group 2: appearance and attribute
        CFloatTracker   m_fSizeScale;
        CStringTracker m_sBasemodel;
        CBooleanTracker m_bIsCustomModel; // not in any group
        CNetByteArrayTracker m_arrayCustomModelData; // not in any group
        CIntTracker     m_nSkinIndex; // not in any group
    private:
        vector<int>  m_nLastSendTime;

        vector<int>  m_nLastReceiveTime;
        // invalid time
        static const int INVALID_TIME = -1;
    };



    class ICharacterTrackerContainer
    {
    public:
        ICharacterTrackerContainer();
        virtual ~ICharacterTrackerContainer();

        void ResetCharTrackers();

        CCharacterTracker* GetCharTracker(const char* sName=NULL);

        CCharacterTracker* CreateCharTracker(const char* sName=NULL);

        bool RemoveCharTracker(const char* sName);
        int RemoveCharTracker(int nBeforePerceivedTime);


        int GetLastTrackerGCTime() {return m_nLastTrackerGCTime;};
        void SetLastTrackerGCTime(int nLag) {m_nLastTrackerGCTime = nLag;};

        int GetTimeLag() {return m_nTimeLag;};
        void SetTimeLag(int nLag) {m_nTimeLag = nLag;};
    private:
        int     m_nTimeLag;
        int     m_nLastTrackerGCTime;

        CCharacterTracker m_charTracker;
        map<string, CCharacterTracker> m_perceptionTracker;
    };

}