OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
64 Commits
80 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: d4250e19b5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd4250e19b5'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp

1550 lines
44 KiB
Raw Blame History

/*==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 "plCreatableIndex.h"
#include "hsTimer.h"
#include "hsStream.h"
#include "plNetClientMgr.h"
#include "plgDispatch.h"
#include "plPhysical.h"
#include "plNetClientMsgHandler.h"
#include "plNetLinkingMgr.h"
#include "plNetObjectDebugger.h"
#include "pnUtils/pnUtils.h"
#include "pnProduct/pnProduct.h"
#include "pnNetCommon/plSynchedObject.h"
#include "pnNetCommon/plNetServers.h"
#include "pnNetCommon/plSDLTypes.h"
#include "pnKeyedObject/plKey.h"
#include "pnKeyedObject/plFixedKey.h"
#include "pnKeyedObject/hsKeyedObject.h"
#include "pnSceneObject/plSceneObject.h"
#include "pnSceneObject/plObjInterface.h"
#include "pnSceneObject/plCoordinateInterface.h"
#include "pnMessage/plClientMsg.h"
#include "pnMessage/plSDLModifierMsg.h"
#include "pnMessage/plPlayerPageMsg.h"
#include "pnMessage/plTimeMsg.h"
#include "pnModifier/plModifier.h"
#include "pnAsyncCore/pnAsyncCore.h"
#include "plAgeLoader/plAgeLoader.h"
#include "plAgeLoader/plResPatcher.h"
#include "plNetClientRecorder/plNetClientRecorder.h"
#include "plScene/plSceneNode.h"
#include "plNetCommon/plNetCommonConstants.h"
#include "plNetMessage/plNetMessage.h"
#include "plMessage/plLoadAvatarMsg.h"
#include "plMessage/plLoadCloneMsg.h"
#include "plMessage/plSynchEnableMsg.h"
#include "plMessage/plLinkToAgeMsg.h"
#include "plMessage/plLoadAgeMsg.h"
#include "plMessage/plAgeLoadedMsg.h"
#include "plMessage/plCCRMsg.h"
#include "plMessage/plAvatarMsg.h"
#include "plMessage/plNetVoiceListMsg.h"
#include "plMessage/plNetCommMsgs.h"
#include "plMessage/plNetClientMgrMsg.h"
#include "plResMgr/plKeyFinder.h"
#include "plResMgr/plPageInfo.h"
#include "plNetTransport/plNetTransportMember.h"
#include "plAgeDescription/plAgeDescription.h"
#include "plAvatar/plAvatarClothing.h"
#include "plAvatar/plArmatureMod.h"
#include "plAvatar/plAvatarMgr.h"
#include "plSurface/plLayerInterface.h"
#include "plStatusLog/plStatusLog.h"
#include "plSDL/plSDL.h"
#include "plUnifiedTime/plUnifiedTime.h"
#include "plFile/plEncryptedStream.h"
#include "plProgressMgr/plProgressMgr.h"
#include "plVault/plVault.h"
#include "pfMessage/pfKIMsg.h" // Move this to PubUtil level
#if 1 // for debugging
#include "plCreatableIndex.h"
#include "plModifier/plResponderModifier.h"
#include "plSurface/plLayerAnimation.h"
#endif
#include <algorithm>
#include <sstream>
////////////////////////////////////////////////////////////////////
plNetClientMgr::PendingLoad::~PendingLoad()
{
delete fSDRec;
}
////////////////////////////////////////////////////////////////////
//
// CONSTRUCT
//
#pragma warning(disable:4355) // this used in initializer list
plNetClientMgr::plNetClientMgr() :
fLocalPlayerKey(nil),
fMsgHandler(this),
fJoinOrder(0),
// fProgressBar( nil ),
fTaskProgBar( nil ),
fMsgRecorder(nil),
fServerTimeOffset(0),
fTimeSamples(0),
fLastTimeUpdate(0),
fListenListMode(kListenList_Distance),
fAgeSDLObjectKey(nil),
fExperimentalLevel(0),
fOverrideAgeTimeOfDayPercent(-1.f),
fNumInitialSDLStates(0),
fRequiredNumInitialSDLStates(0),
fDisableMsg(nil),
fIsOwner(true)
{
#ifndef HS_DEBUGGING
// release code will timeout inactive players on servers by default
SetFlagsBit(kAllowTimeOut);
#endif
SetFlagsBit(kAllowAuthTimeOut);
// fPlayerVault.SetPlayerName("SinglePlayer"); // in a MP game, this will be replaced with a player name like 'Atrus'
fTransport.SetNumChannels(kNetNumChannels);
}
#pragma warning(default:4355)
//
// DESTRUCT
//
plNetClientMgr::~plNetClientMgr()
{
plSynchedObject::PushSynchDisabled(true); // disable dirty tracking
IDeInitNetClientComm();
if (this==GetInstance())
SetInstance(nil); // we're going down boys
IClearPendingLoads();
}
//
// App is exiting
//
void plNetClientMgr::Shutdown()
{
ISendDirtyState(hsTimer::GetSysSeconds());
plNetLinkingMgr::GetInstance()->LeaveAge(true);
// release existing remote players
int i;
for (i=0;i<RemotePlayerKeys().size();i++)
{
plKey k=RemotePlayerKeys()[i];
plAvatarMgr::GetInstance()->UnLoadRemotePlayer(k);
}
// Finally, pump the dispatch system so all the new refs get delivered.
plgDispatch::Dispatch()->MsgQueueProcess();
if (fMsgRecorder)
{
delete fMsgRecorder;
fMsgRecorder = nil;
}
for (i = 0; i < fMsgPlayers.size(); i++)
delete fMsgPlayers[i];
fMsgPlayers.clear();
IRemoveCloneRoom();
// RATHER BAD DEBUG HACK: Clear the spawn override in armatureMod so there's no memory leak
plArmatureMod::SetSpawnPointOverride( nil );
VaultDestroy();
}
//
// Clear any pending state, probably joining a new age
//
void plNetClientMgr::IClearPendingLoads()
{
std::for_each( fPendingLoads.begin(), fPendingLoads.end(), xtl::delete_ptr() );
fPendingLoads.clear();
}
//
// manually add/remove the cloned object room in plClient
//
void plNetClientMgr::IAddCloneRoom()
{
plSceneNode *cloneRoom = TRACKED_NEW plSceneNode();
cloneRoom->RegisterAs(kNetClientCloneRoom_KEY);
plKey clientKey=hsgResMgr::ResMgr()->FindKey(kClient_KEY);
plClientRefMsg *pMsg1 = TRACKED_NEW plClientRefMsg(clientKey, plRefMsg::kOnCreate, -1, plClientRefMsg::kManualRoom);
hsgResMgr::ResMgr()->AddViaNotify(cloneRoom->GetKey(), pMsg1, plRefFlags::kPassiveRef);
}
//
// manually add/remove the cloned object room in plClient
//
void plNetClientMgr::IRemoveCloneRoom()
{
plKey cloneRoomKey = hsgResMgr::ResMgr()->FindKey(kNetClientCloneRoom_KEY);
plSceneNode *cloneRoom = cloneRoomKey ? plSceneNode::ConvertNoRef(cloneRoomKey->ObjectIsLoaded()) : nil;
if (cloneRoom)
{
cloneRoom->UnRegisterAs(kNetClientCloneRoom_KEY);
cloneRoom = nil;
}
}
//
// turn null send on/off. Null send does everything except actually send the msg out on the socket
//
void plNetClientMgr::SetNullSend(hsBool on)
{
}
//
// returns server time in the form "[m/d/y h:m:s]"
//
const char* plNetClientMgr::GetServerLogTimeAsString(std::string& timestamp) const
{
const plUnifiedTime st=GetServerTime();
xtl::format(timestamp, "{%02d/%02d %02d:%02d:%02d}",
st.GetMonth(), st.GetDay(), st.GetHour(), st.GetMinute(), st.GetSecond());
return timestamp.c_str();
}
//
// support for a single leading tab in statusLog strings
//
const char* ProcessTab(const char* fmt)
{
static std::string s;
if (fmt && *fmt=='\t')
{
s = xtl::format(" %s", fmt);
return s.c_str();
}
return fmt;
}
//
// override for plLoggable
//
bool plNetClientMgr::Log(const char* str) const
{
if (strlen(str)==nil)
return true;
// prepend raw time
std::string buf2 = xtl::format("%.2f %s", hsTimer::GetSeconds(), ProcessTab(str));
if ( GetConsoleOutput() )
hsStatusMessage(buf2.c_str());
// create status log if necessary
if(fStatusLog==nil)
{
fStatusLog = plStatusLogMgr::GetInstance().CreateStatusLog(40, "network.log",
plStatusLog::kTimestamp | plStatusLog::kFilledBackground | plStatusLog::kAlignToTop |
plStatusLog::kServerTimestamp);
fWeCreatedLog = true;
}
plNetObjectDebugger::GetInstance()->LogMsgIfMatch(buf2.c_str());
return fStatusLog->AddLine(buf2.c_str());
}
//
// Display OS version info for log
//
void plNetClientMgr::IDumpOSVersionInfo() const
{
DebugMsg("*** OS Info");
char** versionStrs = DisplaySystemVersion();
int i=0;
while(versionStrs && versionStrs[i])
{
DebugMsg(versionStrs[i]);
delete [] versionStrs[i];
i++;
}
delete [] versionStrs;
}
//
// initialize net client. returns hsFail on err.
//
int plNetClientMgr::Init()
{
int ret=hsOK;
hsLogEntry( DebugMsg("*** plNetClientMgr::Init GMT:%s", plUnifiedTime::GetCurrentTime().Print()) );
IDumpOSVersionInfo();
if (GetFlagsBit(kNullSend))
SetNullSend(true);
VaultInitialize();
RegisterAs( kNetClientMgr_KEY );
IAddCloneRoom();
fNetGroups.Reset();
plgDispatch::Dispatch()->RegisterForExactType(plNetClientMgrMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plAgeLoadedMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plAgeLoaded2Msg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plCCRPetitionMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plPlayerPageMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plInitialAgeStateLoadedMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plNetVoiceListMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plClientMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plNetCommAuthMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plNetCommActivePlayerMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plNetCommLinkToAgeMsg::Index(), GetKey());
IInitNetClientComm();
return ret;
}
//
// Prepare to send.
// Update p2p transport groups and rcvrs list in some msgs
// Returns channel.
//
int plNetClientMgr::IPrepMsg(plNetMessage* msg)
{
// pick channel, prepare msg
int channel=kNetChanDefault;
plNetMsgVoice* v=plNetMsgVoice::ConvertNoRef(msg);
if (v)
{ // VOICE MSG
channel=kNetChanVoice;
// compute new transport group (from talkList) if necessary
GetTalkList()->UpdateTransportGroup(this);
// update receivers list in voice msg based on talk list
v->Receivers()->Clear();
int i;
for(i=0;i<GetTalkList()->GetNumMembers(); i++)
{
v->Receivers()->AddReceiverPlayerID(GetTalkList()->GetMember(i)->GetPlayerID());
}
if (msg->IsBitSet(plNetMessage::kEchoBackToSender))
v->Receivers()->AddReceiverPlayerID(GetPlayerID());
}
else if (plNetMsgListenListUpdate::ConvertNoRef(msg))
{ // LISTEN LIST UPDATE MSG
channel=kNetChanListenListUpdate;
// update transport group from rcvrs list, add p2p mbrs to trasnport group
fTransport.ClearChannelGrp(kNetChanListenListUpdate);
if (IsPeerToPeer())
{
plNetMsgReceiversListHelper* rl = plNetMsgReceiversListHelper::ConvertNoRef(msg);
hsAssert(rl, "error converting msg to rcvrs list?");
int i;
for(i=0;i<rl->GetNumReceivers();i++)
{
int idx=fTransport.FindMember(rl->GetReceiverPlayerID(i));
hsAssert(idx!=-1, "error finding transport mbr");
plNetTransportMember* tm = fTransport.GetMember(idx);
if (tm->IsPeerToPeer())
fTransport.SubscribeToChannelGrp(tm, kNetChanListenListUpdate);
}
}
}
else if( plNetMsgGameMessageDirected::ConvertNoRef( msg ) )
{
channel = kNetChanDirectedMsg;
}
return channel;
}
//
// unload other player since we're leaving the age
//
void plNetClientMgr::IUnloadRemotePlayers()
{
for(int i=RemotePlayerKeys().size()-1;i>=0;i--)
plAvatarMgr::GetInstance()->UnLoadRemotePlayer(RemotePlayerKeys()[i]);
hsAssert(!RemotePlayerKeys().size(),"Still remote players left when linking out");
}
//
// begin linking out sounds and gfx
//
void plNetClientMgr::StartLinkOutFX()
{
// send msg to trigger link out effect
if (fLocalPlayerKey)
{
plNetLinkingMgr * lm = plNetLinkingMgr::GetInstance();
plLinkEffectsTriggerMsg* lem = TRACKED_NEW plLinkEffectsTriggerMsg();
lem->SetLeavingAge(true);
lem->SetLinkKey(fLocalPlayerKey);
lem->SetBCastFlag(plMessage::kNetPropagate);
lem->SetBCastFlag(plMessage::kNetForce); // Necessary?
lem->AddReceiver(hsgResMgr::ResMgr()->FindKey(plUoid(kLinkEffectsMgr_KEY)));
lem->Send();
}
}
//
// beging linking in sounds snd gfx
//
void plNetClientMgr::StartLinkInFX()
{
if (fLocalPlayerKey)
{
const plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
plLinkEffectsTriggerMsg* lem = TRACKED_NEW plLinkEffectsTriggerMsg();
lem->SetLeavingAge(false); // linking in
lem->SetLinkKey(fLocalPlayerKey);
lem->SetLinkInAnimKey(avMod->GetLinkInAnimKey());
// indicate if we are invisible
if (avMod && avMod->IsInStealthMode() && avMod->GetTarget(0))
{
lem->SetInvisLevel(avMod->GetStealthLevel());
}
lem->SetBCastFlag(plMessage::kNetPropagate);
lem->AddReceiver(hsgResMgr::ResMgr()->FindKey(plUoid(kLinkEffectsMgr_KEY)));
lem->AddReceiver(hsgResMgr::ResMgr()->FindKey(plUoid(kClient_KEY)));
plgDispatch::MsgSend(lem);
}
}
//
// compute the difference between our clock and the server's in unified time
//
void plNetClientMgr::UpdateServerTimeOffset(plNetMessage* msg)
{
if ((hsTimer::GetSysSeconds() - fLastTimeUpdate) > 5)
{
fLastTimeUpdate = hsTimer::GetSysSeconds();
const plUnifiedTime& msgSentUT = msg->GetTimeSent();
if (!msgSentUT.AtEpoch())
{
double diff = plUnifiedTime::GetTimeDifference(msgSentUT, plClientUnifiedTime::GetCurrentTime());
if (fServerTimeOffset == 0)
{
fServerTimeOffset = diff;
}
else
{
fServerTimeOffset = fServerTimeOffset + ((diff - fServerTimeOffset) / ++fTimeSamples);
}
DebugMsg("Setting server time offset to %f", fServerTimeOffset);
}
}
}
void plNetClientMgr::ResetServerTimeOffset()
{
fServerTimeOffset = 0;
fTimeSamples = 0;
fLastTimeUpdate = 0;
}
//
// return the gameservers time
//
plUnifiedTime plNetClientMgr::GetServerTime() const
{
if ( fServerTimeOffset==0 ) // offline mode or before connecting/calibrating to a server
return plUnifiedTime::GetCurrentTime();
plUnifiedTime serverUT;
if (fServerTimeOffset<0)
return plUnifiedTime::GetCurrentTime() - plUnifiedTime(fabs(fServerTimeOffset));
else
return plUnifiedTime::GetCurrentTime() + plUnifiedTime(fServerTimeOffset);
}
//
// How old is the age
//
double plNetClientMgr::GetCurrentAgeElapsedSeconds() const
{
return plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeElapsedSeconds(GetServerTime());
}
//
// Get the time in the current age (0-1), taking into account the age's day length
//
float plNetClientMgr::GetCurrentAgeTimeOfDayPercent() const
{
if (fOverrideAgeTimeOfDayPercent>=0)
return fOverrideAgeTimeOfDayPercent;
return plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeTimeOfDayPercent(GetServerTime());
}
//
// main update fxn for net client code, return hsFail on err
//
int plNetClientMgr::Update(double secs)
{
int ret=hsOK; // ret code is unchecked, but what the hay
if (GetFlagsBit(kDisableOnNextUpdate)) {
SetFlagsBit(kDisableOnNextUpdate, false);
IDisableNet();
}
// Pump net messages
NetCommUpdate();
static double lastUpdateTime=0;
double curTime=hsTimer::GetSeconds();
if (curTime-lastUpdateTime > 1.f)
{
DebugMsg("NetClient hasn't updated for %f secs", curTime-lastUpdateTime);
}
lastUpdateTime=curTime;
if (!GetFlagsBit(kDisabled))
{
fNetClientStats.UpdateAgeStats();
}
if (GetFlagsBit(kPlayingGame) )
{
MaybeSendPendingPagingRoomMsgs();
ICheckPendingStateLoad(secs);
ISendDirtyState(secs);
IUpdateListenList(secs);
if (GetFlagsBit(plNetClientApp::kShowLists))
IShowLists();
if (GetFlagsBit(plNetClientApp::kShowRooms))
IShowRooms();
if (GetFlagsBit(plNetClientApp::kShowAvatars))
IShowAvatars();
if (GetFlagsBit(plNetClientApp::kShowRelevanceRegions))
IShowRelevanceRegions();
}
// Send dirty nodes, deliver vault callbacks, etc.
VaultUpdate();
plNetLinkingMgr::GetInstance()->Update();
return ret;
}
//
// See if there is state recvd from the network that needsto be delivered
//
void plNetClientMgr::ICheckPendingStateLoad(double secs)
{
if (!fPendingLoads.empty() && GetFlagsBit( kPlayingGame ) || (GetFlagsBit(kLoadingInitialAgeState) && !GetFlagsBit(kNeedInitialAgeStateCount)))
{
PendingLoadsList::iterator it = fPendingLoads.begin();
while ( it!=fPendingLoads.end() )
{
PendingLoad * pl = (*it);
// cache rcvr key
if (!pl->fKey)
{
// check for existence of key in dataset, excluding clone info.
plUoid tmpUoid = pl->fUoid;
tmpUoid.SetClone(0,0);
if ( !hsgResMgr::ResMgr()->FindKey( tmpUoid ) )
{
// discard the state if object not found in dataset.
char tmp[256];
hsLogEntry( DebugMsg( "Failed to find object %s in dataset. Discarding pending state '%s'",
tmpUoid.StringIze(tmp),
pl->fSDRec->GetDescriptor()->GetName() ) );
delete pl;
it = fPendingLoads.erase(it);
continue;
}
// find and cache the real key.
pl->fKey = hsgResMgr::ResMgr()->FindKey(pl->fUoid);
}
// deliver state if possible
plSynchedObject*so = pl->fKey ? plSynchedObject::ConvertNoRef(pl->fKey->ObjectIsLoaded()) : nil;
if (so && so->IsFinal())
{
plSDLModifierMsg* sdlMsg = TRACKED_NEW plSDLModifierMsg(pl->fSDRec->GetDescriptor()->GetName(),
plSDLModifierMsg::kRecv);
sdlMsg->SetState( pl->fSDRec, true/*delete pl->fSDRec for us*/ );
sdlMsg->SetPlayerID( pl->fPlayerID );
#ifdef HS_DEBUGGING
if (plNetObjectDebugger::GetInstance()->IsDebugObject(so))
{
hsLogEntry( DebugMsg( "Delivering SDL state %s:%s", pl->fKey->GetName(), pl->fSDRec->GetDescriptor()->GetName() ) );
// hsLogEntry(plNetObjectDebugger::GetInstance()->LogMsg(xtl::format("Dispatching SDL state, type %s to object:%s, locallyOwned=%d, st=%.3f rt=%.3f",
// pl->fSDRec->GetDescriptor()->GetName(), pl->fKey->GetName(),
// so->IsLocallyOwned()==plSynchedObject::kYes, secs, hsTimer::GetSeconds()).c_str()));
// hsLogEntry( pl->fSDRec->DumpToObjectDebugger( "Delivering SDL state", false, 0 ) );
}
#endif
sdlMsg->Send(pl->fKey);
pl->fSDRec = nil; // so it won't be deleted in the PendingLoad dtor.
delete pl;
it = fPendingLoads.erase(it);
}
else
{
// report old pending state
double rawSecs = hsTimer::GetSeconds();
if ((rawSecs - pl->fQueuedTime) > 60.f /*secs*/)
{
char tmp[256], tmp2[256];
if (pl->fQueueTimeResets >= 5)
{
// if this is our fifth time in here then we've been queued
// for around 5 minutes and its time to go
WarningMsg( "Pending state '%s' for object [uoid:%s,key:%s] has been queued for about %f secs. Removing...",
pl->fSDRec && pl->fSDRec->GetDescriptor() ? pl->fSDRec->GetDescriptor()->GetName() : "?",
pl->fUoid.StringIze(tmp2), pl->fKey ? pl->fKey->GetUoid().StringIze(tmp) : "?",
( rawSecs - pl->fQueuedTime ) * pl->fQueueTimeResets);
delete pl;
it = fPendingLoads.erase(it);
continue;
}
WarningMsg( "Pending state '%s' for object [uoid:%s,key:%s] has been queued for about %f secs. %s",
pl->fSDRec && pl->fSDRec->GetDescriptor() ? pl->fSDRec->GetDescriptor()->GetName() : "?",
pl->fUoid.StringIze(tmp2), pl->fKey ? pl->fKey->GetUoid().StringIze(tmp) : "?",
( rawSecs - pl->fQueuedTime ) * pl->fQueueTimeResets,
so ? "(not loaded)" : "(not final)" );
// reset queue time so we don't spew too many log msgs.
pl->fQueuedTime = rawSecs;
pl->fQueueTimeResets += 1;
}
it++;
}
}
}
}
//
// Determine the net group for a given object (based on paging unit)
//
plNetGroupId plNetClientMgr::SelectNetGroup(plSynchedObject* objIn, plKey roomKey)
{
if( objIn->GetSynchFlags() & plSynchedObject::kHasConstantNetGroup )
return objIn->GetNetGroup();
return plNetGroupId(roomKey->GetUoid().GetLocation(), 0);
}
//
// Get the net group that an object belongs to, taking into acct
// that objects may derive their net group from another object they belong to.
//
plNetGroupId plNetClientMgr::GetEffectiveNetGroup(const plSynchedObject*& obj) const
{
plNetGroupId netGroup = plNetGroup::kNetGroupUnknown;
// the object is an interface, so consider the owner instead
const plObjInterface* oInt=plObjInterface::ConvertNoRef(obj);
if (oInt)
{
// the object is an interface, so consider the owner instead
if (oInt->GetOwner())
obj = oInt->GetOwner();
}
else
{
const plModifier* mod=plModifier::ConvertNoRef(obj);
if (mod)
{
// the object is a modifier, so consider the first target instead
if (mod->GetNumTargets() && mod->GetTarget(0))
obj = mod->GetTarget(0);
}
else
{
const plLayerInterface* li = plLayerInterface::ConvertNoRef(obj);
const plClothingOutfit* cl = plClothingOutfit::ConvertNoRef(obj);
if (li || cl)
{
// the object is a layer interface or clothing object
plUoid u = obj->GetKey()->GetUoid();
if (u.GetLocation().IsReserved())
{
// layer interface is associated with an avatar, find which one
int cloneID = u.GetCloneID();
int clonePlayerID = u.GetClonePlayerID();
for(int i = -1; i < RemotePlayerKeys().size(); i++)
{
plKey pKey = (i==-1) ? GetLocalPlayerKey() : RemotePlayerKeys()[i];
if (pKey && pKey->GetUoid().GetCloneID()==cloneID && pKey->GetUoid().GetClonePlayerID()==clonePlayerID)
{
obj = plSynchedObject::ConvertNoRef(pKey->ObjectIsLoaded());
break;
}
}
}
else
{
// layer interface is on a non-avatar object
netGroup = u.GetLocation();
}
}
else
{
const plPhysical* ph = plPhysical::ConvertNoRef(obj);
if (ph)
{
// the object is a physical
obj = plSynchedObject::ConvertNoRef(ph->GetObjectKey()->ObjectIsLoaded());
}
}
}
}
if (obj)
netGroup = obj->GetNetGroup();
return netGroup;
}
//
// If we don't know for sure if something is locallyOwned, check if it' related to the remote or
// local avatar. if not, fallback to join order.
//
int plNetClientMgr::IDeduceLocallyOwned(const plUoid& uoid) const
{
// check against local/remote avatars
if (fLocalPlayerKey)
if (uoid.GetLocation() == fLocalPlayerKey->GetUoid().GetLocation() &&
uoid.GetClonePlayerID() == fLocalPlayerKey->GetUoid().GetClonePlayerID())
return plSynchedObject::kYes; // this object's location is the same as the local player's
if (!fRemotePlayerKeys.empty())
if (uoid.GetLocation() == fRemotePlayerKeys.back()->GetUoid().GetLocation() &&
uoid.GetClonePlayerID() == fRemotePlayerKeys.back()->GetUoid().GetClonePlayerID())
return plSynchedObject::kNo; // this object's location is the same as the currently loading remote player's
return fIsOwner;
}
//
// returns yes/no
// for special cases, like sceneNodes.
//
int plNetClientMgr::IsLocallyOwned(const plUoid& uoid) const
{
// we're non-networked
if ( GetFlagsBit(kDisabled))
return plSynchedObject::kYes;
plNetGroupId netGroup = uoid.GetLocation();
int answer=GetNetGroups()->IsGroupLocal(netGroup);
if (answer==-1)
answer = IDeduceLocallyOwned(uoid);
hsAssert(answer==plSynchedObject::kYes || answer==plSynchedObject::kNo, "invalid answer to IsLocallyOwned()");
return answer;
}
//
// check if this object is in a group which is owned (mastered) by this client.
// returns yes/no
//
int plNetClientMgr::IsLocallyOwned(const plSynchedObject* obj) const
{
// we're non-networked
if ( GetFlagsBit(kDisabled) )
return plSynchedObject::kYes;
if( !obj )
return plSynchedObject::kNo;
// object is flagged as local only
if (!obj->IsNetSynched())
return plSynchedObject::kYes;
plNetGroupId netGroup = GetEffectiveNetGroup(obj);
int answer=GetNetGroups()->IsGroupLocal(netGroup);
if (answer==-1) // not sure
answer = IDeduceLocallyOwned(obj->GetKey()->GetUoid());
hsAssert(answer==plSynchedObject::kYes || answer==plSynchedObject::kNo, "invalid answer to IsLocallyOwned()");
return answer;
}
//
// return localPlayer ptr
//
plSynchedObject* plNetClientMgr::GetLocalPlayer(hsBool forceLoad) const
{
if (forceLoad)
return fLocalPlayerKey ? plSynchedObject::ConvertNoRef(fLocalPlayerKey->GetObjectPtr()) : nil;
else
return fLocalPlayerKey ?
plSynchedObject::ConvertNoRef(fLocalPlayerKey->ObjectIsLoaded()) : nil;
}
//
// return a ptr to a remote player
//
plSynchedObject* plNetClientMgr::GetRemotePlayer(int i) const
{
return fRemotePlayerKeys[i] ? plSynchedObject::ConvertNoRef(fRemotePlayerKeys[i]->ObjectIsLoaded()) : nil;
}
//
// check if a key si a remote player
//
hsBool plNetClientMgr::IsRemotePlayerKey(const plKey pKey, int *idx)
{
if (pKey)
{
plKeyVec::iterator result=std::find(fRemotePlayerKeys.begin(), fRemotePlayerKeys.end(), pKey);
hsBool found = result!=fRemotePlayerKeys.end();
if (idx)
*idx = found ? result-fRemotePlayerKeys.begin() : -1;
return found;
}
return false;
}
//
// add remote char if not already there
//
void plNetClientMgr::AddRemotePlayerKey(plKey pKey)
{
hsAssert(pKey, "adding nil remote player key");
if (!IsRemotePlayerKey(pKey))
{
fRemotePlayerKeys.push_back(pKey);
hsAssert(pKey!=fLocalPlayerKey, "setting remote player to the local player?");
}
}
//
// MsgReceive handler for plasma messages
//
hsBool plNetClientMgr::MsgReceive( plMessage* msg )
{
if (plNetLinkingMgr::GetInstance()->MsgReceive( msg ))
return true;
plEvalMsg* evalMsg = plEvalMsg::ConvertNoRef(msg);
if (evalMsg)
{
IPlaybackMsgs();
if ( GetFlagsBit( kNeedToSendAgeLoadedMsg ) )
{
SetFlagsBit( kNeedToSendAgeLoadedMsg, false );
plAgeLoader::GetInstance()->NotifyAgeLoaded( true );
}
if ( GetFlagsBit( kNeedToSendInitialAgeStateLoadedMsg ) )
{
SetFlagsBit(kNeedToSendInitialAgeStateLoadedMsg, false);
plInitialAgeStateLoadedMsg* m = TRACKED_NEW plInitialAgeStateLoadedMsg;
m->Send();
}
return true;
}
plGenRefMsg* ref = plGenRefMsg::ConvertNoRef(msg);
if (ref)
{
if( ref->fType == kVaultImage )
{
// Ignore, we just use it for reffing, don't care about the actual pointer
return true;
}
hsAssert(ref->fType==kAgeSDLHook, "unknown ref msg context");
if (ref->GetContext()==plRefMsg::kOnCreate)
{
hsAssert(fAgeSDLObjectKey==nil, "already have a ref to age sdl hook");
fAgeSDLObjectKey = ref->GetRef()->GetKey();
char tmp[256];
DebugMsg("Age SDL hook object created, uoid=%s", fAgeSDLObjectKey->GetUoid().StringIze(tmp));
}
else
{
fAgeSDLObjectKey=nil;
DebugMsg("Age SDL hook object destroyed");
}
return true;
}
if (plNetClientMgrMsg * ncmMsg = plNetClientMgrMsg::ConvertNoRef(msg)) {
if (ncmMsg->type == plNetClientMgrMsg::kCmdDisableNet) {
SetFlagsBit(kDisableOnNextUpdate);
hsRefCnt_SafeUnRef(fDisableMsg);
fDisableMsg = ncmMsg;
fDisableMsg->Ref();
}
return true;
}
if (plNetCommAuthMsg * authMsg = plNetCommAuthMsg::ConvertNoRef(msg)) {
if (IS_NET_ERROR(authMsg->result)) {
char str[256];
StrPrintf(str, arrsize(str), "Authentication failed: %S", NetErrorToString(authMsg->result));
QueueDisableNet(true, str);
return false; // @@@ TODO: Handle this failure better
}
return true;
}
if (plNetCommActivePlayerMsg * activePlrMsg = plNetCommActivePlayerMsg::ConvertNoRef(msg)) {
if (IS_NET_ERROR(activePlrMsg->result)) {
char str[256];
StrPrintf(str, arrsize(str), "SetActivePlayer failed: %S", NetErrorToString(activePlrMsg->result));
QueueDisableNet(true, str);
return false; // @@@ TODO: Handle this failure better.
}
return true;
}
plPlayerPageMsg *playerPageMsg = plPlayerPageMsg::ConvertNoRef(msg);
if(playerPageMsg)
{
IHandlePlayerPageMsg(playerPageMsg);
return true; // handled
}
plLoadCloneMsg* pCloneMsg = plLoadCloneMsg::ConvertNoRef(msg);
if(pCloneMsg)
{
ILoadClone(pCloneMsg);
return true; // handled
}
// player is petitioning a CCR
plCCRPetitionMsg* petMsg=plCCRPetitionMsg::ConvertNoRef(msg);
if (petMsg)
{
ISendCCRPetition(petMsg);
return true;
}
// a remote CCR is turning invisible
plCCRInvisibleMsg* invisMsg=plCCRInvisibleMsg::ConvertNoRef(msg);
if (invisMsg)
{
LogMsg(kLogDebug, "plNetClientMgr::MsgReceive - Got plCCRInvisibleMsg");
MakeCCRInvisible(invisMsg->fAvKey, invisMsg->fInvisLevel);
return true;
}
plCCRBanLinkingMsg* banLinking = plCCRBanLinkingMsg::ConvertNoRef(msg);
if (banLinking)
{
DebugMsg("Setting BanLinking to %d", banLinking->fBan);
SetFlagsBit(kBanLinking, banLinking->fBan);
return true;
}
plCCRSilencePlayerMsg* silence = plCCRSilencePlayerMsg::ConvertNoRef(msg);
if (silence)
{
DebugMsg("Setting Silence to %d", silence->fSilence);
SetFlagsBit(kSilencePlayer, silence->fSilence);
return true;
}
plInitialAgeStateLoadedMsg *stateMsg = plInitialAgeStateLoadedMsg::ConvertNoRef( msg );
if( stateMsg != nil )
{
// done receiving the initial state of the age from the server
plNetObjectDebugger::GetInstance()->LogMsg("OnServerInitComplete");
// delete fProgressBar;
// fProgressBar=nil;
SetFlagsBit(kLoadingInitialAgeState, false);
StartLinkInFX();
}
plNetVoiceListMsg* voxList = plNetVoiceListMsg::ConvertNoRef(msg);
if (voxList)
{
IHandleNetVoiceListMsg(voxList);
return true;
}
plSynchEnableMsg* synchEnable = plSynchEnableMsg::ConvertNoRef(msg);
if (synchEnable)
{
if (synchEnable->fPush)
{
plSynchedObject::PushSynchDisabled(!synchEnable->fEnable);
}
else
{
plSynchedObject::PopSynchDisabled();
}
return true;
}
plClientMsg* clientMsg = plClientMsg::ConvertNoRef(msg);
if (clientMsg && clientMsg->GetClientMsgFlag()==plClientMsg::kInitComplete)
{
// add 1 debug object for age sdl
if (plNetObjectDebugger::GetInstance())
{
plNetObjectDebugger::GetInstance()->RemoveDebugObject("AgeSDLHook");
plNetObjectDebugger::GetInstance()->AddDebugObject("AgeSDLHook");
}
// if we're linking to startup we don't need (or want) a player set
char ageName[kMaxAgeNameLength];
StrCopy(ageName, NetCommGetStartupAge()->ageDatasetName, arrsize(ageName));
if (!StrLen(ageName))
StrCopy(ageName, "StartUp", arrsize(ageName));
if (0 == StrCmpI(ageName, "StartUp"))
NetCommSetActivePlayer(0, nil);
plAgeLinkStruct link;
link.GetAgeInfo()->SetAgeFilename(NetCommGetStartupAge()->ageDatasetName);
link.SetLinkingRules(plNetCommon::LinkingRules::kOriginalBook);
plNetLinkingMgr::GetInstance()->LinkToAge(&link);
return true;
}
return plNetClientApp::MsgReceive(msg);
}
void plNetClientMgr::IncNumInitialSDLStates()
{
fNumInitialSDLStates++;
DebugMsg( "Received %d initial SDL states", fNumInitialSDLStates );
if ( GetFlagsBit( plNetClientApp::kNeedInitialAgeStateCount ) )
{
DebugMsg( "Need initial SDL state count" );
return;
}
if ( GetNumInitialSDLStates()>=GetRequiredNumInitialSDLStates() )
{
ICheckPendingStateLoad(hsTimer::GetSysSeconds());
NotifyRcvdAllSDLStates();
}
}
void plNetClientMgr::NotifyRcvdAllSDLStates() {
DebugMsg( "Got all initial SDL states" );
plNetClientMgrMsg * msg = TRACKED_NEW plNetClientMgrMsg();
msg->type = plNetClientMgrMsg::kNotifyRcvdAllSDLStates;
msg->SetBCastFlag(plMessage::kBCastByType);
msg->Send();
}
//
// return true if we should send this msg
//
bool plNetClientMgr::CanSendMsg(plNetMessage * msg)
{
// TEMP
if (GetFlagsBit(kSilencePlayer))
{
if (plNetMsgVoice::ConvertNoRef(msg))
return false;
plNetMsgGameMessage* gm=plNetMsgGameMessage::ConvertNoRef(msg);
if (gm && gm->StreamInfo()->GetStreamType()==pfKIMsg::Index())
{
hsReadOnlyStream stream(gm->StreamInfo()->GetStreamLen(), gm->StreamInfo()->GetStreamBuf());
pfKIMsg* kiMsg = pfKIMsg::ConvertNoRef(hsgResMgr::ResMgr()->ReadCreatable(&stream));
if (kiMsg && kiMsg->GetCommand()==pfKIMsg::kHACKChatMsg)
{
delete kiMsg;
return false;
}
delete kiMsg;
}
}
return true;
}
//
// Return the net client (account) name of the player whose avatar
// key is provided. If avKey is nil, returns local client name.
//
const char* plNetClientMgr::GetPlayerName(const plKey avKey) const
{
// local case
if (!avKey || avKey==GetLocalPlayerKey())
return NetCommGetPlayer()->playerNameAnsi;
plNetTransportMember* mbr=TransportMgr().GetMember(TransportMgr().FindMember(avKey));
return mbr ? mbr->GetPlayerName() : nil;
}
const char * plNetClientMgr::GetPlayerNameById (unsigned playerId) const {
// local case
if (NetCommGetPlayer()->playerInt == playerId)
return NetCommGetPlayer()->playerNameAnsi;
plNetTransportMember * mbr = TransportMgr().GetMember(TransportMgr().FindMember(playerId));
return mbr ? mbr->GetPlayerName() : nil;
}
unsigned plNetClientMgr::GetPlayerIdByName (const char name[]) const {
// local case
if (0 == StrCmp(name, NetCommGetPlayer()->playerNameAnsi, (unsigned)-1))
NetCommGetPlayer()->playerInt;
unsigned n = TransportMgr().GetNumMembers();
for (unsigned i = 0; i < n; ++i)
if (plNetTransportMember * member = TransportMgr().GetMember(i))
if (0 == StrCmp(name, member->GetPlayerName(), (unsigned)-1))
return member->GetPlayerID();
return 0;
}
UInt32 plNetClientMgr::GetPlayerID() const
{
return NetCommGetPlayer()->playerInt;
}
//
// return true if the age is the set of local ages
//
static const char* gLocalAges[]={"GUI", "AvatarCustomization", ""};
static bool IsLocalAge(const char* ageName)
{
int i=0;
while(strlen(gLocalAges[i]))
{
if (!stricmp(gLocalAges[i], ageName))
return true;
i++;
}
return false;
}
//
// is the object in a local age?
//
bool plNetClientMgr::ObjectInLocalAge(const plSynchedObject* obj) const
{
plLocation loc = obj->GetKey()->GetUoid().GetLocation();
const plPageInfo* pageInfo = plKeyFinder::Instance().GetLocationInfo(loc);
bool ret= IsLocalAge(pageInfo->GetAge());
return ret;
}
//
// the next age we are going to
//
const char* plNetClientMgr::GetNextAgeFilename()
{
// set when we start linking to an age.
plNetLinkingMgr * lm = plNetLinkingMgr::GetInstance();
return lm->GetAgeLink()->GetAgeInfo()->GetAgeFilename();
}
//
// a remote ccr is turning [in]visible
//
void plNetClientMgr::MakeCCRInvisible(plKey avKey, int level)
{
if (!avKey)
{
ErrorMsg("Failed to make remote CCR Invisible, nil avatar key");
return;
}
if (level<0)
{
ErrorMsg("Failed to make remote CCR Invisible, negative level");
return;
}
if (!avKey->ObjectIsLoaded() || !avKey->ObjectIsLoaded()->IsFinal())
{
hsAssert(false, "avatar not loaded or final");
return;
}
plAvatarStealthModeMsg *msg = TRACKED_NEW plAvatarStealthModeMsg();
msg->SetSender(avKey);
msg->fLevel = level;
if (GetCCRLevel()<level) // I'm a lower level than him, so he's invisible to me
msg->fMode = plAvatarStealthModeMsg::kStealthCloaked;
else
{
// he's visible to me
if (AmCCR() && level > 0)
msg->fMode = plAvatarStealthModeMsg::kStealthCloakedButSeen; // draw as semi-invis
else
msg->fMode = plAvatarStealthModeMsg::kStealthVisible;
}
DebugMsg("Handled MakeCCRInvisible - sending stealth msg");;
// This fxn is called when avatar SDL state is received from the server,
// so this msg will inherit the 'non-local' status of the parent sdl msg.
// That means that the avatar linkSound won't receive it, since the linkSound
// is set as localOnly.
// So, terminate the remote cascade and start a new (local) cascade.
msg->SetBCastFlag(plMessage::kNetStartCascade);
msg->Send();
}
void plNetClientMgr::QueueDisableNet (bool showDlg, const char str[]) {
plNetClientMgrMsg * msg = NEWZERO(plNetClientMgrMsg);
msg->type = plNetClientMgrMsg::kCmdDisableNet;
msg->yes = showDlg;
if (str)
StrCopy(msg->str, str, arrsize(msg->str));
#if 0
msg->Send(GetKey());
#else
msg->Ref();
fDisableMsg = msg;
IDisableNet();
#endif;
}
void plNetClientMgr::IDisableNet () {
ASSERT(fDisableMsg);
if (!GetFlagsBit(kDisabled)) {
SetFlagsBit(kDisabled);
// cause subsequent net operations to fail immediately, but don't block
// waiting for net subsystem to shutdown (we'll do that later)
NetCommEnableNet(false, false);
// display a msg to the player
if ( fDisableMsg->yes )
{
if (!GetFlagsBit(plNetClientApp::kPlayingGame))
{
// KI may not be loaded
char title[256];
StrPrintf(title, arrsize(title), "%S Error", ProductCoreName());
hsMessageBox(fDisableMsg->str, title, hsMessageBoxNormal, hsMessageBoxIconError );
plClientMsg *quitMsg = NEW(plClientMsg)(plClientMsg::kQuit);
quitMsg->Send(hsgResMgr::ResMgr()->FindKey(kClient_KEY));
}
else
{
pfKIMsg *msg = TRACKED_NEW pfKIMsg(pfKIMsg::kKIOKDialog);
msg->SetString(fDisableMsg->str);
msg->Send();
}
}
}
hsRefCnt_SafeUnRef(fDisableMsg);
fDisableMsg = nil;
}
bool plNetClientMgr::IHandlePlayerPageMsg(plPlayerPageMsg *playerMsg)
{
bool result = false;
plKey playerKey = playerMsg->fPlayer;
int idx;
if(playerMsg->fUnload)
{
if (GetLocalPlayerKey() == playerKey)
{
fLocalPlayerKey = nil;
DebugMsg("Net: Unloading local player %s", playerKey->GetName());
// notify server - NOTE: he might not still be around to get this...
plNetMsgPlayerPage npp (playerKey->GetUoid(), playerMsg->fUnload);
npp.SetNetProtocol(kNetProtocolCli2Game);
SendMsg(&npp);
}
else if (IsRemotePlayerKey(playerKey, &idx))
{
fRemotePlayerKeys.erase(fRemotePlayerKeys.begin()+idx); // remove key from list
DebugMsg("Net: Unloading remote player %s", playerKey->GetName());
}
}
else
{
plSceneObject *playerSO = plSceneObject::ConvertNoRef(playerKey->ObjectIsLoaded());
if (!playerSO)
{
hsStatusMessageF("Ignoring player page message for non-existant player.");
}
else
if(playerMsg->fPlayer)
{
if (playerMsg->fLocallyOriginated)
{
hsAssert(!GetLocalPlayerKey() ||
GetLocalPlayerKey() == playerKey,
"Different local player already loaded");
hsLogEntry(DebugMsg("Adding LOCAL player %s\n", playerKey->GetName()));
playerSO->SetNetGroupConstant(plNetGroup::kNetGroupLocalPlayer);
// don't save avatar state permanently on server
playerSO->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);
const plCoordinateInterface* co = playerSO->GetCoordinateInterface();
if (co)
{
int i;
for(i=0;i<co->GetNumChildren();i++)
{
if (co->GetChild(i) && co->GetChild(i)->GetOwner())
const_cast<plSceneObject*>(co->GetChild(i)->GetOwner())->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);
}
}
// notify server
plNetMsgPlayerPage npp (playerKey->GetUoid(), playerMsg->fUnload);
npp.SetNetProtocol(kNetProtocolCli2Game);
SendMsg(&npp);
}
else
{
hsLogEntry(DebugMsg("Adding REMOTE player %s\n", playerKey->GetName()));
playerSO->SetNetGroupConstant(plNetGroup::kNetGroupRemotePlayer);
idx=fTransport.FindMember(playerMsg->fClientID);
if( idx != -1 )
{
hsAssert(playerKey, "NIL KEY?");
hsAssert(playerKey->GetName(), "UNNAMED KEY");
fTransport.GetMember(idx)->SetAvatarKey(playerKey);
}
else
{
hsLogEntry(DebugMsg("Ignoring player page msg (player not found in member list) : %s\n", playerKey->GetName()));
}
}
hsAssert(IFindModifier(playerSO, CLASS_INDEX_SCOPED(plAvatarSDLModifier)), "avatar missing avatar SDL modifier");
hsAssert(IFindModifier(playerSO, CLASS_INDEX_SCOPED(plClothingSDLModifier)), "avatar missing clothing SDL modifier");
hsAssert(IFindModifier(playerSO, CLASS_INDEX_SCOPED(plAGMasterSDLModifier)), "avatar missing AGMaster SDL modifier");
result = true;
}
}
return result;
}
// for debugging purposes
bool plNetClientMgr::IFindModifier(plSynchedObject* obj, Int16 classIdx)
{
plLayerAnimation* layer = plLayerAnimation::ConvertNoRef(obj);
if (layer)
return (layer->GetSDLModifier() != nil);
plResponderModifier* resp = plResponderModifier::ConvertNoRef(obj);
if (resp)
return (resp->GetSDLModifier() != nil);
int cnt=0;
plSceneObject* sceneObj=plSceneObject::ConvertNoRef(obj);
if (sceneObj)
{
int i;
for(i=0; i<sceneObj->GetNumModifiers(); i++)
if (sceneObj->GetModifier(i) && sceneObj->GetModifier(i)->ClassIndex()==classIdx)
cnt++;
}
hsAssert(cnt<2, xtl::format("Object %s has multiple SDL modifiers of the same kind (%s)?",
obj->GetKeyName(), plFactory::GetNameOfClass(classIdx)).c_str());
return cnt==0 ? false : true;
}
plUoid plNetClientMgr::GetAgeSDLObjectUoid(const char* ageName) const
{
hsAssert(ageName, "nil ageName");
// if age sdl hook is loaded
if (fAgeSDLObjectKey)
return fAgeSDLObjectKey->GetUoid();
// if age is loaded
plLocation loc = plKeyFinder::Instance().FindLocation(ageName,plAgeDescription::GetCommonPage(plAgeDescription::kGlobal));
if (!loc.IsValid())
{
// check current age des
if (plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeName() &&
!strcmp(plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeName(), ageName))
loc=plAgeLoader::GetInstance()->GetCurrAgeDesc().CalcPageLocation("BuiltIn");
if (!loc.IsValid())
{
// try to load age desc
hsStream* stream=plAgeLoader::GetAgeDescFileStream(ageName);
if (stream)
{
plAgeDescription ad;
ad.Read(stream);
loc=ad.CalcPageLocation("BuiltIn");
stream->Close();
}
delete stream;
}
}
return plUoid(loc, plSceneObject::Index(), plSDL::kAgeSDLObjectName);
}
//
// Add a state update to the pending queue
//
void plNetClientMgr::AddPendingLoad(PendingLoad *pl)
{
pl->fQueuedTime = hsTimer::GetSeconds(); // timestamp
// find corresponding key
pl->fKey = hsgResMgr::ResMgr()->FindKey(pl->fUoid);
// check for age SDL state
char tmp[256];
if (pl->fUoid.GetObjectName() && !strcmp(pl->fUoid.GetObjectName(), plSDL::kAgeSDLObjectName))
{
DebugMsg("Recv SDL state for age hook object, uoid=%s", pl->fUoid.StringIze(tmp));
if (!pl->fKey)
WarningMsg("Can't find age hook object, nil key!");
else
DebugMsg("Found age hook object");
}
// check if object is ready
if (pl->fKey)
{
if (!pl->fKey->ObjectIsLoaded())
{
WarningMsg("Object %s not loaded, withholding SDL state",
pl->fKey->GetUoid().StringIze(tmp));
}
else if (!pl->fKey->ObjectIsLoaded()->IsFinal())
{
WarningMsg("Object %s is not FINAL, withholding SDL state",
pl->fKey->GetUoid().StringIze(tmp));
}
}
// add entry
fPendingLoads.push_back(pl);
}
void plNetClientMgr::AddPendingPagingRoomMsg( plNetMsgPagingRoom * msg )
{
fPendingPagingRoomMsgs.push_back( msg );
}
void plNetClientMgr::MaybeSendPendingPagingRoomMsgs()
{
if ( GetFlagsBit( kPlayingGame ) )
SendPendingPagingRoomMsgs();
}
void plNetClientMgr::SendPendingPagingRoomMsgs()
{
for ( int i=0; i<fPendingPagingRoomMsgs.size(); i++ )
SendMsg( fPendingPagingRoomMsgs[i] );
ClearPendingPagingRoomMsgs();
}
void plNetClientMgr::ClearPendingPagingRoomMsgs()
{
std::for_each( fPendingPagingRoomMsgs.begin(), fPendingPagingRoomMsgs.end(), xtl::delete_ptr() );
fPendingPagingRoomMsgs.clear();
}
bool plNetClientMgr::DebugMsgV(const char* fmt, va_list args) const
{
LogMsgV(kLogDebug, fmt, args);
return true;
}
bool plNetClientMgr::ErrorMsgV(const char* fmt, va_list args) const
{
LogMsgV(kLogError, fmt, args);
return true;
}
bool plNetClientMgr::WarningMsgV(const char* fmt, va_list args) const
{
LogMsgV(kLogError, fmt, args);
return true;
}
bool plNetClientMgr::AppMsgV(const char* fmt, va_list args) const
{
LogMsgV(kLogPerf, fmt, args);
return true;
}
bool plNetClientMgr::IsObjectOwner()
{
return fIsOwner;
}
void plNetClientMgr::SetObjectOwner(bool own)
{
fIsOwner = own;
}