You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

600 lines
16 KiB

/*==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());
}