void Breakable::Load(HMESSAGEREAD hRead)
{
if (!hRead) return;
LOAD_HOBJECT(m_hBreakObj);
LOAD_BOOL(m_bStarted);
LOAD_BOOL(m_bFalling);
LOAD_BOOL(m_bDestroyOnImpact);
LOAD_BOOL(m_bDestroyAfterBreak);
LOAD_BOOL(m_bCrushObjects);
LOAD_BOOL(m_bTouchActivate);
LOAD_FLOAT(m_fBreakTime);
LOAD_FLOAT(m_fBreakSoundRadius);
LOAD_FLOAT(m_fImpactSoundRadius);
LOAD_FLOAT(m_fRotVel);
LOAD_HSTRING(m_hstrBreakSound);
LOAD_HSTRING(m_hstrImpactSound);
LOAD_VECTOR(m_vStartingPitchYawRoll);
LOAD_VECTOR(m_vPitchYawRoll);
LOAD_VECTOR(m_vTotalDelta);
LOAD_VECTOR(m_vDelta);
LOAD_VECTOR(m_vSign);
LOAD_VECTOR(m_vFinalPos);
LOAD_VECTOR(m_vShakeAmount);
LOAD_VECTOR(m_vAdjust);
LOAD_VECTOR(m_vVel);
m_BreakTimer.Load(hRead);
}
void PickupItem::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if (!pMsg) return;
LOAD_HOBJECT(m_hPlayerObj);
LOAD_FLOAT(m_fRespawnDelay);
LOAD_BOOL(m_bRotate);
LOAD_BOOL(m_bBounce);
LOAD_BOOL(m_bRespawn);
LOAD_DWORD(m_dwUserFlags);
LOAD_DWORD(m_dwFlags);
LOAD_HSTRING(m_hstrPickupCommand);
LOAD_HSTRING(m_hstrSoundFile);
LOAD_HSTRING(m_hstrRespawnSoundFile);
LOAD_HSTRING(m_hstrModelOverride);
LOAD_VECTOR(m_vScale);
LOAD_BOOL(m_bTouchPickup);
LOAD_BOOL(m_bActivatePickup);
LOAD_bool(m_bWasPickedUp);
char szString[1024] = {0};
LOAD_CHARSTRING( szString, ARRAY_LEN( szString ));
m_sWorldAniName = szString;
if( g_pVersionMgr->GetCurrentSaveVersion( ) > CVersionMgr::kSaveVersion__1_2 )
{
LOAD_BYTE(m_nTeamId);
}
}
void ScaleSprite::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if (!pMsg) return;
LOAD_VECTOR(m_vScale);
LOAD_VECTOR(m_vColor);
LOAD_FLOAT(m_fAlpha);
LOAD_BOOL(m_bFlushWithWorld);
LOAD_BOOL(m_bRotatable);
LOAD_BOOL(m_bStartOn);
LOAD_DWORD(m_dwAdditionalFlags);
LOAD_HSTRING(m_hstrDamagedFile);
LOAD_HSTRING(m_hstrDestroyedFile);
}
void CAIState::Load(ILTMessage_Read *pMsg)
{
LOAD_DWORD_CAST(m_eStateStatus, EnumAIStateStatus);
LOAD_BOOL(m_bNoCinematics);
LOAD_FLOAT(m_fElapsedTime);
LOAD_BOOL(m_bFirstUpdate);
LOAD_BOOL(m_bPlayFirstSound);
LOAD_HSTRING(m_hstrReturn);
LOAD_HSTRING(m_hstrFirst);
LOAD_INT(m_cNexts);
for ( int iNext = 0 ; iNext < kMaxNexts ; iNext++ )
{
LOAD_HSTRING(m_ahstrNexts[iNext]);
}
}
void CAIState::Load(HMESSAGEREAD hRead)
{
LOAD_BOOL(m_bAlert);
LOAD_BOOL(m_bNoCinematics);
LOAD_FLOAT(m_fElapsedTime);
LOAD_BOOL(m_bFirstUpdate);
LOAD_BOOL(m_bPlayFirstSound);
LOAD_HSTRING(m_hstrReturn);
LOAD_HSTRING(m_hstrFirst);
LOAD_INT(m_cNexts);
for ( int iNext = 0 ; iNext < kMaxNexts ; iNext++ )
{
LOAD_HSTRING(m_ahstrNexts[iNext]);
}
}
void GameBase::Load(HMESSAGEREAD hRead)
{
m_dwOriginalFlags = g_pLTServer->ReadFromMessageDWord(hRead);
// Load the number of marks in our list...
uint8 nNumInList = g_pLTServer->ReadFromMessageByte(hRead);
// Load the marks...
if (nNumInList > 0)
{
if (m_pMarkList)
{
g_pLTServer->RelinquishList(m_pMarkList);
}
m_pMarkList = g_pLTServer->CreateObjectList();
if (m_pMarkList)
{
HOBJECT hObj = LTNULL;
for (int i=0; i < nNumInList; i++)
{
g_pLTServer->ReadFromLoadSaveMessageObject(hRead, &hObj);
g_pLTServer->AddObjectToList(m_pMarkList, hObj);
}
}
}
LOAD_DWORD(m_nSaveVersion);
LOAD_HSTRING(m_hstrSave);
}
void AINodeGuard::Load(ILTMessage_Read *pMsg)
{
super::Load(pMsg);
// Load guarded node names.
HSTRING hstrNodeName;
uint32 cNodeNames;
LOAD_DWORD( cNodeNames );
m_lstGuardedNodeNames.reserve( cNodeNames );
for( uint32 iNodeName=0; iNodeName < cNodeNames; ++iNodeName )
{
LOAD_HSTRING( hstrNodeName );
m_lstGuardedNodeNames.push_back( hstrNodeName );
}
// Load guarded nodes.
HOBJECT hNode;
uint32 cNodes;
LOAD_DWORD( cNodes );
m_lstGuardedNodes.reserve( cNodes );
for( uint32 iNode=0; iNode < cNodes; ++iNode )
{
LOAD_HOBJECT( hNode );
m_lstGuardedNodes.push_back( hNode );
}
}
void CommandObject::Load( ILTMessage_Read *pMsg )
{
GameBaseLite::Load( pMsg );
m_Timer.Load( pMsg );
LOAD_FLOAT( m_fTotalTime );
LOAD_HSTRING( m_hstrFinishedCmd );
LOAD_bool( m_bLocked );
LOAD_INT( m_nNumActivations );
LOAD_INT( m_nNumTimesActivated );
// Free any event commands we already have...
EVENT_CMD_LIST::iterator iter;
EVENT_CMD_STRUCT *pEvntCmdStruct = LTNULL;
for( iter = m_lstEventCmds.begin(); iter != m_lstEventCmds.end(); ++iter )
{
pEvntCmdStruct = *iter;
FREE_HSTRING( pEvntCmdStruct->m_hstrCommand );
debug_delete( pEvntCmdStruct );
pEvntCmdStruct = LTNULL;
}
m_lstEventCmds.clear();
// Load all event commands...
int nNumEventCmds = 0;
LOAD_INT( nNumEventCmds );
for( int i = 0; i < nNumEventCmds; ++i )
{
pEvntCmdStruct = debug_new( EVENT_CMD_STRUCT );
m_lstEventCmds.push_back( pEvntCmdStruct );
LOAD_FLOAT( pEvntCmdStruct->m_fTime );
LOAD_BOOL( pEvntCmdStruct->m_bProcessed );
LOAD_HSTRING( pEvntCmdStruct->m_hstrCommand );
}
}
void RelationTraits::CIDValue::Load(ILTMessage_Read *pMsg)
{
const char* szValue;
HSTRING hValue;
LOAD_HSTRING( hValue );
szValue = g_pLTServer->GetStringData(hValue);
SetValue( szValue );
FREE_HSTRING( hValue );
}
void Alarm::Load(ILTMessage_Read *pMsg)
{
if (!g_pLTServer || !pMsg) return;
LOAD_DWORD_CAST(m_eState, State);
LOAD_BOOL(m_bPlayerUsable);
LOAD_BOOL(m_bLocked);
LOAD_FLOAT(m_fAlarmSoundTime);
LOAD_HSTRING(m_hstrPlayerActivateCommand);
LOAD_HSTRING(m_hstrAlertRegions);
LOAD_HSTRING(m_hstrRespondRegions);
LOAD_HSTRING(m_hstrSearchRegions);
uint32 cRegions;
AIREGION_LIST::iterator it;
LOAD_DWORD( cRegions );
m_lstAlertRegions.resize( cRegions );
for( it = m_lstAlertRegions.begin(); it != m_lstAlertRegions.end(); ++it )
{
LOAD_HOBJECT( *it );
}
LOAD_DWORD( cRegions );
m_lstRespondRegions.resize( cRegions );
for( it = m_lstRespondRegions.begin(); it != m_lstRespondRegions.end(); ++it )
{
LOAD_HOBJECT( *it );
}
LOAD_DWORD( cRegions );
m_lstSearchRegions.resize( cRegions );
for( it = m_lstSearchRegions.begin(); it != m_lstSearchRegions.end(); ++it )
{
LOAD_HOBJECT( *it );
}
LOAD_VECTOR( m_vRegionsGroupExtentsMin );
LOAD_VECTOR( m_vRegionsGroupExtentsMax );
LOAD_VECTOR( m_vRegionsGroupCenter );
LOAD_FLOAT( m_fRegionsGroupRadius );
}
void AI_Helicopter::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
CAIVehicle::Load(hRead, dwLoadFlags);
// Load state...
uint32 dwState;
LOAD_DWORD(dwState);
if (dwState != (DWORD)-1)
{
SetState((CAIHelicopterState::AIHelicopterStateType)dwState);
if (m_pHelicopterState)
{
m_pHelicopterState->Load(hRead);
}
}
LOAD_FLOAT(m_fSpeed);
LOAD_FLOAT(m_fFlySpeed);
LOAD_ROTATION(m_rRotSearchlight);
LOAD_VECTOR(m_vPosSearchlight);
LOAD_INT(m_iObjectSearchLight);
LOAD_ROTATION(m_rRotGunner);
LOAD_VECTOR(m_vPosGunner);
LOAD_INT(m_iObjectGunner);
LOAD_BOOL(m_bWantsRightDoorOpened);
LOAD_BOOL(m_bWantsRightDoorClosed);
LOAD_BOOL(m_bRightDoorOpened);
LOAD_BOOL(m_bWantsLeftDoorOpened);
LOAD_BOOL(m_bWantsLeftDoorClosed);
LOAD_BOOL(m_bLeftDoorOpened);
LOAD_FLOAT(m_fDeathDelay);
LOAD_HSTRING(m_hstrDeathMessage);
LOAD_HSTRING(m_hstrDeath2_3rdMessage);
LOAD_HSTRING(m_hstrDeath1_3rdMessage);
LOAD_HSTRING(m_hstrDeath0_3rdMessage);
LOAD_BOOL(m_bExploded);
}
void Group::Load(ILTMessage_Read *pMsg)
{
GameBaseLite::Load( pMsg );
LOAD_DWORD(m_nNumTargets);
for (uint32 i=0; i < m_nNumTargets; i++)
{
LOAD_HSTRING(m_hstrObjectNames[i]);
}
}
void Door::OnLoad( ILTMessage_Read *pMsg, uint32 dwSaveFlags )
{
if( !pMsg ) return;
// Load base vars first
ActiveWorldModel::OnLoad( pMsg, dwSaveFlags );
LOAD_HSTRING( m_hstrDoorLink );
LOAD_HOBJECT( m_hAIUser );
}
void DisplayTimer::Load(ILTMessage_Read *pMsg)
{
if (!pMsg) return;
LOAD_HSTRING(m_hstrStartCmd);
LOAD_HSTRING(m_hstrEndCmd);
LOAD_BOOL(m_bRemoveWhenDone);
m_Timer.Load(pMsg);
if( g_pVersionMgr->GetCurrentSaveVersion( ) > CVersionMgr::kSaveVersion__1_2 )
{
LOAD_BYTE( m_nTeamId );
}
if (m_Timer.GetDuration() > 0.0f)
{
UpdateClients();
}
}
void CDestructibleModel::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if (!g_pLTServer || !pMsg) return;
LOAD_BYTE( m_nDebrisId );
LOAD_BOOL( m_bCreatedDebris );
LOAD_BOOL( m_bCreateExplosion );
LOAD_BYTE( m_nExplosionWeaponId );
LOAD_BOOL( m_bFireAlongForward );
LOAD_FLOAT( m_fDamageFactor );
LOAD_BOOL( m_bRemoveOnDeath );
LOAD_HSTRING( m_hstrSpawn );
LOAD_HSTRING( m_hstrSurfaceOverride );
LOAD_DWORD( m_dwOriginalFlags );
LOAD_BOOL( m_bSaveNeverDestroy );
LOAD_BOOL( m_bSaveCanDamage );
LOAD_DWORD_CAST( m_eStimID, EnumAIStimulusID );
LOAD_FLOAT( m_fStimRadius );
LOAD_DWORD( m_nDestroyAlarmLevel );
}
void CAIBrain::Load(HMESSAGEREAD hRead)
{
LOAD_DWORD_CAST(m_eRangeStatusLast, RangeStatus);
LOAD_FLOAT(m_fRangeStatusCheckTime);
LOAD_DWORD_CAST(m_eDodgeStatusLast, DodgeStatus);
LOAD_FLOAT(m_fDodgeStatusCheckTimeVector);
LOAD_FLOAT(m_fDodgeStatusCheckTimeProjectile);
LOAD_HSTRING(m_hstrDodgeProjectileName);
LOAD_VECTOR(m_vDodgeProjectilePosition);
LOAD_FLOAT(m_fGrenadeStatusCheckTime);
}
void AIRegion::Load(ILTMessage_Read *pMsg)
{
LOAD_HSTRING(m_hstrName);
LOAD_DWORD(m_cSearchNodes);
LOAD_DWORD(m_cSearchers);
LOAD_DWORD(m_cPostSearchMsgs);
uint32 cVolumes;
LOAD_DWORD(cVolumes);
m_lstVolumes.resize(cVolumes);
for ( uint32 iVolume=0; iVolume < cVolumes ; ++iVolume )
{
LOAD_COBJECT( m_lstVolumes[iVolume], AIVolume );
}
for ( uint32 iNode = 0 ; iNode < kMaxSearchNodes ; iNode++ )
{
LOAD_COBJECT(m_apSearchNodes[iNode], AINodeSearch);
}
for ( uint32 iPostSearchMsg = 0 ; iPostSearchMsg < kMaxPostSearchMsgs ; iPostSearchMsg++ )
{
LOAD_HSTRING(m_ahstrPostSearchMsgs[iPostSearchMsg]);
}
LOAD_VECTOR(m_vExtentsMin);
LOAD_VECTOR(m_vExtentsMax);
// Permission sets
m_bPSets[0] = pMsg->Readuint8();
m_bPSets[1] = pMsg->Readuint8();
m_bPSets[2] = pMsg->Readuint8();
m_bPSets[3] = pMsg->Readuint8();
m_bPSets[4] = pMsg->Readuint8();
m_bPSets[5] = pMsg->Readuint8();
m_bPSets[6] = pMsg->Readuint8();
m_bPSets[7] = pMsg->Readuint8();
}
void CAIGoalTalk::Load(ILTMessage_Read *pMsg)
{
super::Load(pMsg);
LOAD_DWORD_CAST(m_eMood, EnumAnimProp);
LOAD_DWORD_CAST(m_eMovement, EnumAnimProp);
LOAD_HSTRING(m_hstrGesture);
LOAD_FLOAT(m_fFaceTime);
LOAD_BOOL(m_bStartedDialog);
LOAD_BOOL(m_bInTalkPosition);
LOAD_BOOL(m_bRetriggerDialogue);
LOAD_BOOL(m_bDisposableDialogue);
LOAD_BOOL(m_bTalking);
LOAD_HOBJECT(m_hDialogue);
}
void CDestructibleModel::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
if (!g_pLTServer || !hRead) return;
LOAD_HSTRING(m_hstrSurfaceOverride);
m_hstrSpawn = g_pLTServer->ReadFromMessageHString(hRead);
m_fDamageFactor = g_pLTServer->ReadFromMessageFloat(hRead);
m_bCreatedDebris = (LTBOOL) g_pLTServer->ReadFromMessageByte(hRead);
m_nDebrisId = g_pLTServer->ReadFromMessageByte(hRead);
m_bFireAlongForward = (LTBOOL) g_pLTServer->ReadFromMessageByte(hRead);
m_bCreateExplosion = (LTBOOL) g_pLTServer->ReadFromMessageByte(hRead);
m_nExplosionWeaponId = g_pLTServer->ReadFromMessageByte(hRead);
m_bSaveCanDamage = (LTBOOL) g_pLTServer->ReadFromMessageByte(hRead);
m_bSaveNeverDestroy = (LTBOOL) g_pLTServer->ReadFromMessageByte(hRead);
m_dwOriginalFlags = g_pLTServer->ReadFromMessageDWord(hRead);
}
void PlayerVehicle::Load(ILTMessage_Read *pMsg)
{
if (!pMsg) return;
LOAD_VECTOR(m_vOriginalPos);
LOAD_VECTOR(m_vOriginalDims);
LOAD_ROTATION(m_rOriginalRot);
LOAD_FLOAT(m_fRespawnTime);
LOAD_BYTE_CAST(m_ePPhysicsModel, PlayerPhysicsModel);
LOAD_bool( m_bLocked );
LOAD_bool( m_bRidden );
LOAD_HSTRING( m_hstrLockedCommand );
LOAD_DWORD(m_dwSavedFlags);
LOAD_TIME( m_fLastRideTime );
LOAD_bool( m_bVirgin );
m_RespawnTimer.Load(pMsg);
}
void SpecialFX::OnLoad(ILTMessage_Read *pMsg, uint32 dwFlags)
{
LOAD_CHARSTRING(m_sFxName, 128);
LOAD_DWORD(m_dwFxFlags);
LOAD_bool(m_bStartOn);
LOAD_bool(m_bLoop);
LOAD_bool(m_bIsOn);
LOAD_bool(m_bOneTime);
LOAD_HSTRING(m_hstrTargetName);
LOAD_HOBJECT(m_hTargetObj);
LOAD_bool(m_bRemoveTarget);
if (!m_bLoop)
{
g_pCommonLT->SetObjectFlags(m_hObject, OFT_Flags, 0, FLAGMASK_ALL);
SetNextUpdate(UPDATE_NEVER);
}
}
void DecisionObject::Load(ILTMessage_Read *pMsg)
{
if (!pMsg) return;
for (int i=0; i < MAX_DECISION_CHOICES; i++)
{
m_ChoiceData[i].Load(pMsg);
}
LOAD_HSTRING(m_hstrAbortCmd);
LTBOOL bVisible;
LOAD_bool(bVisible);
LOAD_bool(m_bRemoveAfterChoice);
LOAD_FLOAT(m_fRadius);
LOAD_bool( m_bLock );
if (bVisible)
Show(true,true);
}
void CAIVolume::Load(HMESSAGEREAD hRead)
{
LOAD_HSTRING(m_hstrName);
LOAD_INT(m_iVolume);
LOAD_DWORD(m_iRegion);
LOAD_VECTOR(m_vFrontTopLeft);
LOAD_VECTOR(m_vFrontTopRight);
LOAD_VECTOR(m_vBackTopLeft);
LOAD_VECTOR(m_vBackTopRight);
LOAD_VECTOR(m_vFrontBottomLeft);
LOAD_VECTOR(m_vFrontBottomRight);
LOAD_VECTOR(m_vBackBottomLeft);
LOAD_VECTOR(m_vBackBottomRight);
LOAD_INT(m_cNeighbors);
LOAD_BOOL(m_bHadDoors);
LOAD_INT(m_cDoors);
LOAD_HOBJECT(m_hLift);
LOAD_BOOL(m_bStairs);
LOAD_BOOL(m_bLedge);
LOAD_BOOL(m_bVertical);
LOAD_VECTOR(m_vStairsDir);
LOAD_VECTOR(m_vLedgeDir);
m_aNeighbors = debug_newa(CAIVolumeNeighbor, m_cNeighbors);
for ( uint32 iNeighbor = 0 ; iNeighbor < m_cNeighbors ; iNeighbor++ )
{
m_aNeighbors[iNeighbor].Load(hRead);
}
for ( uint32 iDoor = 0 ; iDoor < cm_nMaxDoors ; iDoor++ )
{
LOAD_HOBJECT(m_ahDoors[iDoor]);
}
for ( uint32 iViewNode = 0 ; iViewNode < kMaxViewNodes ; iViewNode++ )
{
LOAD_DWORD(m_adwViewNodes[iViewNode]);
}
}
void WorldModel::OnLoad( ILTMessage_Read *pMsg, uint32 dwSaveFlags )
{
ASSERT( pMsg != NULL );
m_ActivateTypeHandler.Load( pMsg );
LOAD_bool( m_bIsKeyframed );
LOAD_bool( m_bStartHidden );
LOAD_HSTRING( m_hstrAttachments );
LOAD_BOOL( m_bRemoveAttachments );
LOAD_VECTOR( m_vAttachDir );
LOAD_HOBJECT( m_hAttachDirObj );
LOAD_ROTATION( m_hackInitialRot );
LOAD_FLOAT( m_fStimRadius );
LOAD_HOBJECT( m_hActivateParent );
LOAD_bool( m_bCanActivate );
// Load the object lists last...
uint8 nObjsInList = 0;
// First the Attachment list
LOAD_BYTE( nObjsInList );
m_AttachmentList.clear( );
if( nObjsInList > 0 )
{
LTObjRefNotifier ref( *this );
for( uint8 i = 0; i < nObjsInList; ++i )
{
LOAD_HOBJECT( ref );
if( ref )
{
m_AttachmentList.push_back( ref );
}
}
}
// Then the other attachment list
LOAD_BYTE( nObjsInList );
m_AttachMsgObjList.clear( );
if( nObjsInList > 0 )
{
LTObjRefNotifier ref( *this );
for( uint8 i = 0; i < nObjsInList; ++i )
{
LOAD_HOBJECT( ref );
if( ref )
{
m_AttachMsgObjList.push_back( ref );
}
}
}
// Then the Mark list
LOAD_BYTE( nObjsInList );
m_MarkList.clear( );
if( nObjsInList > 0 )
{
LTObjRefNotifier ref( *this );
for( uint8 i = 0; i < nObjsInList; ++i )
{
LOAD_HOBJECT( ref );
if( ref )
{
m_MarkList.push_back( ref );
}
}
}
}
