CWE-ou-minkata/Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plSynchedObject.h"
#include "plSynchedValue.h"
#include "plNetApp.h"
#include "plNetGroup.h"
#include "hsResMgr.h"
#include "pnSceneObject/plSceneObject.h"
#include "pnKeyedObject/plKey.h"
#include "pnMessage/plSDLModifierMsg.h"
#include "pnMessage/plSetNetGroupIDMsg.h"

#include <algorithm>

// statics
plSynchedObject* plSynchedObject::fStaticSynchedObj=nil;
std::vector<plSynchedObject::StateDefn> plSynchedObject::fDirtyStates;
std::vector<hsBool> plSynchedObject::fSynchStateStack;

plSynchedObject::plSynchedObject() : 
    fSynchFlags(0),
#ifdef USE_SYNCHED_VALUES
    fSynchedValueAddrOffsets(nil),
    fNumSynchedValues(0),
    fSynchedValueFriends(nil),
    fNumSynchedValueFriends(0),
#endif
    fNetGroup(plNetGroup::kNetGroupUnknown)
{ 
    fStaticSynchedObj=this; 
}

plSynchedObject::~plSynchedObject()
{
#ifdef USE_SYNCHED_VALUES
    delete [] fSynchedValueAddrOffsets;
    delete [] fSynchedValueFriends;
#endif
}

hsBool plSynchedObject::MsgReceive(plMessage* msg)
{
    plSetNetGroupIDMsg* setNetGroupID = plSetNetGroupIDMsg::ConvertNoRef(msg);
    if (setNetGroupID)
    {
        SetNetGroupConstant(setNetGroupID->fId);
        return true;
    }

    return hsKeyedObject::MsgReceive(msg);
}

#ifdef USE_SYNCHED_VALUES
plSynchedValueBase* plSynchedObject::GetSynchedValue(int i) const
{ 
    if (i<fNumSynchedValues)
        return IGetSynchedValue((NumSynchedValuesType)i);
    return IGetSynchedValueFriend((NumSynchedValuesType)(i-fNumSynchedValues));
}

// realloc and add 
void plSynchedObject::IAppendSynchedValueAddrOffset(AddrOffsetType synchedValueAddrOffset)
{
    // copy to new larger array
    AddrOffsetType* tmp = TRACKED_NEW AddrOffsetType[fNumSynchedValues+1];
    Int32 i;
    for(i=0;i<fNumSynchedValues;i++)
        tmp[i] = fSynchedValueAddrOffsets[i];

    // delete old one
    delete [] fSynchedValueAddrOffsets;

    // point to new array and append value
    fSynchedValueAddrOffsets=tmp;
    tmp[fNumSynchedValues++]=synchedValueAddrOffset;
}

void plSynchedObject::IAppendSynchedValueFriend(plSynchedValueBase* v)
{
    // copy to new larger array
    plSynchedValueBase** tmp = TRACKED_NEW plSynchedValueBase*[fNumSynchedValueFriends+1];
    Int32 i;
    for(i=0;i<fNumSynchedValueFriends;i++)
        tmp[i] = fSynchedValueFriends[i];

    // delete old one
    delete [] fSynchedValueFriends;

    // point to new array and append value
    fSynchedValueFriends=tmp;
    tmp[fNumSynchedValueFriends++]=v;
}

// adds synchedValue and returns index
UInt8 plSynchedObject::RegisterSynchedValue(plSynchedValueBase* v) 
{ 
    Int32 addrOff = ((Int32)v - (Int32)this)>>2;    
    hsAssert(hsABS(addrOff) < (UInt32)(1<<(sizeof(AddrOffsetType)<<3)), "address offset overflow");
    IAppendSynchedValueAddrOffset((AddrOffsetType)addrOff); 
    Int32 idx = fNumSynchedValues-1; 
    hsAssert(idx<256, "index too big");
    return (UInt8)idx;
}

hsBool plSynchedObject::RemoveSynchedValue(plSynchedValueBase* v) 
{
    int i;
    for(i=0;i<GetNumSynchedValues(); i++)
        if (GetSynchedValue(i)==v)
            break;
    
    // couldn't find it
    if (i==GetNumSynchedValues())
        return false;

    int idx=i;
    if (idx<fNumSynchedValues)
    {
        AddrOffsetType* tmp = TRACKED_NEW AddrOffsetType[fNumSynchedValues-1];      
        for(i=0;i<idx;i++)
            tmp[i] = fSynchedValueAddrOffsets[i];
        for(i=idx+1;i<fNumSynchedValues;i++)
            tmp[i-1] = fSynchedValueAddrOffsets[i];
        delete [] fSynchedValueAddrOffsets;
        fSynchedValueAddrOffsets=tmp;       
        fNumSynchedValues--;
    }
    else
    {
        idx -= fNumSynchedValues;
        plSynchedValueBase** tmp = TRACKED_NEW plSynchedValueBase*[fNumSynchedValueFriends-1];      
        for(i=0;i<idx;i++)
            tmp[i] = fSynchedValueFriends[i];
        for(i=idx+1;i<fNumSynchedValueFriends;i++)
            tmp[i-1] = fSynchedValueFriends[i];
        delete [] fSynchedValueFriends;
        fSynchedValueFriends=tmp;       
        fNumSynchedValueFriends--;
    }

    return true;
}

// adds synchedValueFriend
void plSynchedObject::RegisterSynchedValueFriend(plSynchedValueBase* v) 
{ 
    IAppendSynchedValueFriend(v);
}
#endif

//
// send sdl state msg immediately
//
void plSynchedObject::SendSDLStateMsg(const char* SDLStateName, UInt32 synchFlags /*SendSDLStateFlags*/)
{
    plSDLModifierMsg* sdlMsg = TRACKED_NEW plSDLModifierMsg(SDLStateName,
        (synchFlags & kBCastToClients) ? plSDLModifierMsg::kSendToServerAndClients : plSDLModifierMsg::kSendToServer /* action */);
    sdlMsg->SetFlags(synchFlags);
    hsAssert(GetKey(), "nil key on synchedObject?");
    sdlMsg->Send(GetKey());
}

//
// Tell an object to send an sdl state update.
// The request will get queued (returns true)
//
hsBool plSynchedObject::DirtySynchState(const char* SDLStateName, UInt32 synchFlags /*SendSDLStateFlags*/)
{
    if (!IOKToDirty(SDLStateName))
    {
#if 0
        if (plNetClientApp::GetInstance())
            plNetClientApp::GetInstance()->DebugMsg("NotOKToDirty - Not queueing SDL state, obj %s, sdl %s",
                    GetKeyName(), SDLStateName);
#endif
        return false;
    }
    
    if (!IOKToNetwork(SDLStateName, &synchFlags))
    {
#if 0
        if (plNetClientApp::GetInstance())
            plNetClientApp::GetInstance()->DebugMsg("LocalOnly Object - Not queueing SDL msg, obj %s, sdl %s",
                    GetKeyName(), SDLStateName);
#endif
        return false;
    }

    if (!(synchFlags & kSkipLocalOwnershipCheck))
    {
        int localOwned=IsLocallyOwned();
        if (localOwned==plSynchedObject::kNo)
            return false;
        if (localOwned==plSynchedObject::kYes)
            synchFlags |= kSkipLocalOwnershipCheck;     // don't have to check again
        else
        {
            if (plNetClientApp::GetInstance())
                plNetClientApp::GetInstance()->DebugMsg("Queueing SDL state with 'maybe' ownership, obj %s, sdl %s",
                    GetKeyName(), SDLStateName);
        }
    }
    
    if (synchFlags & kSendImmediately)
    {
        SendSDLStateMsg(SDLStateName, synchFlags);
    }
    else
    {
        IAddDirtyState(GetKey(), SDLStateName, synchFlags);
    }
    return true;
}

//
// STATIC
// add state defn if not already there.
// if there adjust flags if necessary
//
void plSynchedObject::IAddDirtyState(plKey objKey, const char* sdlName, UInt32 sendFlags)
{
    bool found=false;
    std::vector<StateDefn>::iterator it=fDirtyStates.begin();
    for( ; it != fDirtyStates.end(); it++)
    {
        if ((*it).fObjKey==objKey && !stricmp((*it).fSDLName.c_str(), sdlName))
        {
            if (sendFlags & kForceFullSend)
                (*it).fSendFlags |= kForceFullSend;
            if (sendFlags & kBCastToClients)
                (*it).fSendFlags |= kBCastToClients;            
            found=true;
            break;
        }
    }

    if (!found)
    {
        StateDefn state(objKey, sendFlags, sdlName);
        fDirtyStates.push_back(state);
    }   
    else
    {
#if 0
        plNetClientApp::GetInstance()->DebugMsg("Not queueing diplicate request for SDL state, obj %s, sdl %s",
                    objKey->GetName(), sdlName);
#endif
    }
}

//
// STATIC
//
void plSynchedObject::IRemoveDirtyState(plKey objKey, const char* sdlName)
{ 
    std::vector<StateDefn>::iterator it=fDirtyStates.begin();
    for( ; it != fDirtyStates.end(); it++)
    {
        if ((*it).fObjKey==objKey && !stricmp((*it).fSDLName.c_str(), sdlName))
        {
            fDirtyStates.erase(it);
            break;
        }
    }
}

void plSynchedObject::SetNetGroupConstant(plNetGroupId netGroup)
{
   ClearSynchFlagsBit(kHasConstantNetGroup);
   SetNetGroup(netGroup);   // may recurse
   SetSynchFlagsBit(kHasConstantNetGroup);
}

plNetGroupId plSynchedObject::SelectNetGroup(plKey rmKey)
{
    return plNetClientApp::GetInstance() ? 
      plNetClientApp::GetInstance()->SelectNetGroup(this, rmKey) : plNetGroup::kNetGroupUnknown;
}

plNetGroupId plSynchedObject::GetEffectiveNetGroup() const
{
    return plNetClientApp::GetInstance() ? 
        plNetClientApp::GetInstance()->GetEffectiveNetGroup(this) : plNetGroup::kNetGroupLocalPlayer;
}

int plSynchedObject::IsLocallyOwned() const
{ 
    return plNetClientApp::GetInstance() ? 
        plNetClientApp::GetInstance()->IsLocallyOwned(this) : kYes;
}

void    plSynchedObject::Read(hsStream* stream, hsResMgr* mgr)
{
    hsKeyedObject::Read(stream, mgr);
    fNetGroup = GetKey()->GetUoid().GetLocation();

    stream->ReadSwap(&fSynchFlags);
    if (fSynchFlags & kExcludePersistentState)
    {
        Int16 num;
        stream->ReadSwap(&num);
        fSDLExcludeList.clear();
        int i;
        for(i=0;i<num;i++)
        {
            std::string s;
            plMsgStdStringHelper::Peek(s, stream);
            fSDLExcludeList.push_back(s);
        }
    }

    if (fSynchFlags & kHasVolatileState)
    {
        Int16 num;
        stream->ReadSwap(&num);
        fSDLVolatileList.clear();
        int i;
        for(i=0;i<num;i++)
        {
            std::string s;
            plMsgStdStringHelper::Peek(s, stream);
            fSDLVolatileList.push_back(s);
        }
    }
}

void    plSynchedObject::Write(hsStream* stream, hsResMgr* mgr)
{
    hsKeyedObject::Write(stream, mgr);
    stream->WriteSwap(fSynchFlags);

    if (fSynchFlags & kExcludePersistentState)
    {
        Int16 num=fSDLExcludeList.size();
        stream->WriteSwap(num);

        SDLStateList::iterator it=fSDLExcludeList.begin();
        for(; it != fSDLExcludeList.end(); it++)
        {
            plMsgStdStringHelper::Poke(*it, stream);
        }
    }

    if (fSynchFlags & kHasVolatileState)
    {
        Int16 num=fSDLVolatileList.size();
        stream->WriteSwap(num);

        SDLStateList::iterator it=fSDLVolatileList.begin();
        for(; it != fSDLVolatileList.end(); it++)
        {
            plMsgStdStringHelper::Poke(*it, stream);
        }
    }
}


//
// static
//
hsBool plSynchedObject::PopSynchDisabled() 
{ 
    if (fSynchStateStack.size())
    {
        hsBool ret=fSynchStateStack.back(); 
        fSynchStateStack.pop_back(); 
        return ret;
    }
    else
    {
        hsAssert(false, "invalid stack size?");
    }
    return true;    // disabled
}

#ifdef USE_DIRTY_NOTIFIERS
void plSynchedObject::AddDirtyNotifier(plDirtyNotifier* dn)
{
    if (dn)
    {
        std::vector<plDirtyNotifier*>::iterator it=std::find(fDirtyNotifiers.begin(), fDirtyNotifiers.end(), dn);
        if (it == fDirtyNotifiers.end())    // not there
        {
            dn->SetSynchedObjKey(GetKey());
            fDirtyNotifiers.push_back(dn);  
        }
    }
}

void plSynchedObject::RemoveDirtyNotifier(plDirtyNotifier* dn)
{
    if (dn)
    {
        std::vector<plDirtyNotifier*>::iterator it=std::find(fDirtyNotifiers.begin(), fDirtyNotifiers.end(), dn);
        if (it != fDirtyNotifiers.end())    // its there
            fDirtyNotifiers.erase(it);  
    }
}

void plSynchedObject::CallDirtyNotifiers()
{
    int i;
    for(i=0;i<fDirtyNotifiers.size();i++)
        fDirtyNotifiers[i]->Callback();
}
#else
void plSynchedObject::CallDirtyNotifiers() {}
#endif

//
// return true if it's ok to dirty this object
//
bool plSynchedObject::IOKToDirty(const char* SDLStateName) const
{   
    // is synching disabled?
    bool synchDisabled = (GetSynchDisabled()!=0);
    if (synchDisabled)
        return false;
    
    // is object dirtyAble?
    bool dontDirty = (fSynchFlags & kDontDirty) != 0;
    if (dontDirty)
        return false;

    // is object in a LocalOnly age?
    if (plNetClientApp::GetConstInstance() && plNetClientApp::GetConstInstance()->ObjectInLocalAge(this))
        return false;

    return true;    // OK to dirty
}

//
// return true if this object should send his SDL msg (for persistence or synch) over the net
//
bool plSynchedObject::IOKToNetwork(const char* sdlName, UInt32* synchFlags) const
{
    // determine destination
    bool dstServerOnly=false, dstClientsOnly=false, dstClientsAndServer=false;  

    if ((*synchFlags) & kBCastToClients)
    {   // bcasting to clients and server
        if ((*synchFlags) & kDontPersistOnServer)
            dstClientsOnly=true;
        else
            dstClientsAndServer=true;
    }
    else
    {   // not bcasting, must be sending to server only
        hsAssert( ((*synchFlags) & kDontPersistOnServer)==0, "invalid synchedObject msg flag");
        dstServerOnly=true;
    }

    bool netSynched = IsNetSynched();
    bool inExcludeList = IsInSDLExcludeList(sdlName);

    //
    // check if ok to network based on destination
    //
    if (dstClientsOnly)
    {
        return netSynched;
    }

    if (dstClientsAndServer)
    {
        if ( !netSynched )
        {
            *synchFlags &= ~kBCastToClients;        // don't send to clients
        }
        if ( inExcludeList )
        {
            *synchFlags |= kDontPersistOnServer;    // don't store on server
        }

        return !inExcludeList || netSynched;
    }

    if (dstServerOnly)
    {
        return !inExcludeList;
    }

    hsAssert(false, "how did I get here");
    return false;
}
 
plSynchedObject::SDLStateList::const_iterator plSynchedObject::IFindInSDLStateList(const SDLStateList& list, const char* sdlName) const
{
    if (!sdlName)
        return list.end();  // false

    SDLStateList::const_iterator it = list.begin();
    for(; it != list.end(); it++)
        if (!_stricmp((*it).c_str(), sdlName))
            return it;

    return it;  // .end(), false
}

///////////////////////////
// EXCLUDE LIST
///////////////////////////

void plSynchedObject::AddToSDLExcludeList(const char* sdlName)
{
    if (sdlName)
    {
        if (IFindInSDLStateList(fSDLExcludeList, sdlName)==fSDLExcludeList.end())
        {
            fSDLExcludeList.push_back(sdlName); // Don't dupe sdlName, std::string will copy
            fSynchFlags |= kExcludePersistentState;
        }
    }
}

void plSynchedObject::RemoveFromSDLExcludeList(const char* sdlName)
{
    SDLStateList::const_iterator it=IFindInSDLStateList(fSDLExcludeList, sdlName);
    if (it != fSDLExcludeList.end())
    {
        fSDLExcludeList.erase(fSDLExcludeList.begin()+(it-fSDLExcludeList.begin()));
        if (fSDLExcludeList.size()==0)
            fSynchFlags &= ~kExcludePersistentState;
    }
}

bool plSynchedObject::IsInSDLExcludeList(const char* sdlName) const
{
    if ((fSynchFlags & kExcludeAllPersistentState) != 0)
        return true;
    
    if ((fSynchFlags & kExcludePersistentState) == 0)
        return false;

    SDLStateList::const_iterator it=IFindInSDLStateList(fSDLExcludeList, sdlName);
    return (it != fSDLExcludeList.end());
}

///////////////////////////
// VOLATILE LIST
///////////////////////////

void plSynchedObject::AddToSDLVolatileList(const char* sdlName)
{
    if (sdlName)
    {
        if (IFindInSDLStateList(fSDLVolatileList,sdlName)==fSDLVolatileList.end())
        {
            fSDLVolatileList.push_back(sdlName); // Don't dupe sdlName, std::string will copy
            fSynchFlags |= kHasVolatileState;
        }
    }
}

void plSynchedObject::RemoveFromSDLVolatileList(const char* sdlName)
{
    SDLStateList::const_iterator it=IFindInSDLStateList(fSDLVolatileList,sdlName);
    if (it != fSDLVolatileList.end())
    {
        fSDLVolatileList.erase(fSDLVolatileList.begin()+(it-fSDLVolatileList.begin()));
        if (fSDLVolatileList.size()==0)
            fSynchFlags &= ~kHasVolatileState;
    }
}

bool plSynchedObject::IsInSDLVolatileList(const char* sdlName) const
{
    if ((fSynchFlags & kAllStateIsVolatile) != 0)
        return true;
    
    if ((fSynchFlags & kHasVolatileState) == 0)
        return false;

    SDLStateList::const_iterator it=IFindInSDLStateList(fSDLVolatileList,sdlName);
    return (it != fSDLVolatileList.end());
}