void AISenseRecord::Load(ILTMessage_Read *pMsg)
{
LOAD_DWORD_CAST(eSenseType, EnumAISenseType);
EnumAIStimulusType eStimulus;
LOAD_DWORD_CAST(eStimulus, EnumAIStimulusType);
if(eStimulus != kStim_InvalidType)
{
pAIBM_Last_Stimulus = g_pAIButeMgr->GetStimulus(eStimulus);
}
LOAD_HOBJECT(hLastStimulusSource);
LOAD_HOBJECT(hLastStimulusTarget);
LOAD_DWORD_CAST(eLastTargetMatchID, EnumAITargetMatchID);
LOAD_VECTOR(vLastStimulusPos);
LOAD_VECTOR(vLastStimulusDir);
LOAD_DWORD(nLastStimulusAlarmLevel);
LOAD_DWORD_CAST(eLastStimulusID, EnumAIStimulusID);
LOAD_FLOAT(fSenseDistance);
LOAD_FLOAT(fSenseDistanceSqr);
LOAD_FLOAT(fCurStimulation);
LOAD_FLOAT(fMaxStimulation);
LOAD_FLOAT(fReactionDelayTimer);
LOAD_FLOAT(fReactionDelayTime);
LOAD_TIME(fLastStimulationTime);
LOAD_DWORD(nCycle);
LOAD_BYTE(cFalseStimulation);
LOAD_INT(ptSightGrid.x);
LOAD_INT(ptSightGrid.y);
}
void CAISense::Load(HMESSAGEREAD hRead)
{
LOAD_HOBJECT(m_hObject);
LOAD_BOOL(m_bEnabled);
LOAD_FLOAT(m_fDistance);
LOAD_FLOAT(m_fDistanceSqr);
LOAD_BOOL(m_bUpdated);
LOAD_DWORD_CAST(m_soOutcome, SenseOutcome);
LOAD_HOBJECT(m_hStimulus);
LOAD_VECTOR(m_vStimulusPosition);
LOAD_FLOAT(m_fStimulation);
LOAD_FLOAT(m_fStimulationIncreaseRateAlert);
LOAD_FLOAT(m_fStimulationDecreaseRateAlert);
LOAD_FLOAT(m_fStimulationIncreaseRateUnalert);
LOAD_FLOAT(m_fStimulationDecreaseRateUnalert);
LOAD_FLOAT(m_fStimulationTime);
LOAD_RANGE(m_rngStimulationThreshhold);
LOAD_BOOL(m_bStimulationPartial);
LOAD_BOOL(m_bStimulationFull);
LOAD_BOOL(m_bIncreasedStimulation);
LOAD_DWORD(m_cFalseStimulation);
LOAD_DWORD(m_nFalseStimulationLimit);
LOAD_BOOL(m_bReacting);
LOAD_FLOAT(m_fReactionDelay);
LOAD_FLOAT(m_fReactionDelayTimer);
LOAD_FLOAT(m_fTimestamp);
}
void CNamedObjectList::Load( ILTMessage_Read *pMsg, uint8 nType )
{
LOAD_HOBJECT( m_hObject );
// Load object names.
std::string strObjectName;
uint32 cObjectNames;
LOAD_DWORD( cObjectNames );
m_lstObjectNames.reserve( cObjectNames );
for( uint32 iObjectName=0; iObjectName < cObjectNames; ++iObjectName )
{
LOAD_STDSTRING( strObjectName );
m_lstObjectNames.push_back( strObjectName );
}
// Load object handles.
HOBJECT hObject;
uint32 cObjects;
LOAD_DWORD( cObjects );
m_lstObjectHandles.reserve( cObjects );
for( uint32 iObject=0; iObject < cObjects; ++iObject )
{
LOAD_HOBJECT( hObject );
m_lstObjectHandles.push_back( hObject );
}
}
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 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 CAIWeaponAbstract::Load(ILTMessage_Read *pMsg)
{
HOBJECT hOwner = NULL;
HWEAPON hWeapon = NULL;
LOAD_HOBJECT(hOwner);
LOAD_HRECORD( hWeapon, g_pWeaponDB->GetWeaponsCategory() );
LOAD_STDSTRING(m_szFireSocketName);
LOAD_INT_CAST(m_eFiringState, ENUM_AIFiringState);
LOAD_DWORD(m_iAnimRandomSeed);
LOAD_TIME(m_fRandomSeedSelectionTime);
LOAD_FLOAT(m_flWeaponContextInaccuracyScalar);
LOAD_DWORD(m_hWeaponSocket);
LOAD_bool(m_bCanDropWeapon);
ASSERT(IsAI(hOwner));
CAI* pAI = (CAI*)g_pLTServer->HandleToObject(hOwner);
ASSERT(pAI->GetArsenal());
if (pAI)
{
ASSERT(pAI->GetArsenal());
if (CArsenal* pArsenal = pAI->GetArsenal())
{
m_pWeapon = pArsenal->GetWeapon(hWeapon);
}
}
if( m_pWeapon )
{
m_pAIWeaponRecord = AIWeaponUtils::GetAIWeaponRecord(
m_pWeapon->GetWeaponRecord(),
pAI->GetAIBlackBoard()->GetBBAIWeaponOverrideSet() );
}
}
void CAISenseRecorderAbstract::Load(ILTMessage_Read *pMsg)
{
uint32 cSenses;
LOAD_DWORD(cSenses);
AISenseRecord* pSenseRecord;
for(uint32 iSense=0; iSense < cSenses; ++iSense)
{
pSenseRecord = debug_new_AISenseRecord( *this );
pSenseRecord->Load(pMsg);
m_mapSenseRecords.insert( AISENSE_RECORD_MAP::value_type(pSenseRecord->eSenseType, pSenseRecord) );
}
LOAD_BOOL( m_bDoneProcessingStimuli );
EnumAIStimulusID eStimID;
uint32 cStimulus;
LOAD_DWORD( cStimulus );
for( uint32 iStimulus=0; iStimulus < cStimulus; ++iStimulus )
{
LOAD_DWORD_CAST( eStimID, EnumAIStimulusID );
m_mapProcessedStimuli.insert( AI_PROCESSED_STIMULI_MAP::value_type( eStimID, 0 ) );
}
LOAD_DWORD( m_cIntersectSegmentCount );
}
void GameBase::Load(ILTMessage_Read *pMsg)
{
uint32 nSaveVersion;
LOAD_DWORD(nSaveVersion);
g_pVersionMgr->SetCurrentSaveVersion( nSaveVersion );
LOAD_DWORD(m_dwOriginalFlags);
LOAD_BYTE_CAST( m_eOriginalShadowLOD, EEngineLOD );
}
void CAIGoalRespondToBackup::Load(ILTMessage_Read *pMsg)
{
super::Load(pMsg);
LOAD_HOBJECT(m_hNodeBackup);
LOAD_VECTOR(m_vEnemySeenPos);
LOAD_DWORD(m_cResponses);
LOAD_DWORD(m_cArrivalCount);
}
void CDestructibleModel::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if (!g_pLTServer || !pMsg) return;
LOAD_BYTE( m_DestructibleModelFlags );
LOAD_DWORD( m_dwOriginalFlags );
LOAD_DWORD_CAST( m_eStimID, EnumAIStimulusID );
LOAD_FLOAT( m_fStimRadius );
LOAD_DWORD( m_nDestroyAlarmLevel );
char szString[2048];
LOAD_CHARSTRING( szString, LTARRAYSIZE( szString ));
delete[] m_pszDestroyedFXName;
m_pszDestroyedFXName = LTStrDup( szString );
}
void TextureFX::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if (!pMsg)
return;
//read in the changed flag and the values
for(uint32 nCurrStage = 0; nCurrStage < NUM_STAGES; nCurrStage++)
{
//read in the ID
LOAD_DWORD(m_Stages[nCurrStage].m_nID);
//read in the changed
LOAD_BYTE(m_Stages[nCurrStage].m_nChanged);
//read in the variables
for(uint32 nCurrVar = 0; nCurrVar < NUM_VARS; nCurrVar++)
{
if(m_Stages[nCurrStage].m_nChanged & (1 << nCurrVar))
{
//only read it in if it was flagges as being changed
LOAD_FLOAT(m_Stages[nCurrStage].m_fVars[nCurrVar]);
}
}
}
m_bClientNeedsUpdate = true;
SetNextUpdate(UPDATE_NEXT_FRAME);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: SkeletonObject::Load
//
// PURPOSE: Load the object
//
// ----------------------------------------------------------------------- //
void SkeletonObject::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if (!pMsg) return;
// Load our important data members
LOAD_DWORD(m_dwSomeVariable);
}
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 CAISensorNode::Load(ILTMessage_Read *pMsg)
{
super::Load(pMsg);
LOAD_FLOAT(m_fSearchMult);
LOAD_DWORD( m_cNodesFound );
}
void CAICentralKnowledgeMgr::Load(ILTMessage_Read *pMsg)
{
EnumAICentralKnowledgeType eKnowledgeType;
uint32 cKnowledge;
LOAD_DWORD(cKnowledge);
CAICentralKnowledgeRecord* pAICentralKnowledgeRecord;
for( uint32 iKnowledge=0; iKnowledge < cKnowledge; ++iKnowledge )
{
LOAD_DWORD_CAST( eKnowledgeType, EnumAICentralKnowledgeType );
pAICentralKnowledgeRecord = AI_FACTORY_NEW( CAICentralKnowledgeRecord );
pAICentralKnowledgeRecord->Load(pMsg);
// Some Knowledge records may have handles to objects that have transitioned
// to a new level. Delete these records.
if( ( !pAICentralKnowledgeRecord->m_pAI ) ||
( !pAICentralKnowledgeRecord->m_pKnowledgeTarget ) )
{
AI_FACTORY_DELETE( pAICentralKnowledgeRecord );
}
else {
m_mapCentralKnowledge.insert( AICENTRAL_KNOWLEDGE_MAP::value_type( eKnowledgeType, pAICentralKnowledgeRecord ) );
}
}
}
void Controller::Load(ILTMessage_Read *pMsg)
{
FadeState *pState;
uint32 i;
GameBaseLite::Load( pMsg );
LOAD_BOOL(m_bFirstUpdate);
LOAD_DWORD_CAST(m_State, CState);
// Read FLICKER vars.
LOAD_TIME(m_fNextFlickerTime);
LOAD_FLOAT(m_fIntervalMin);
LOAD_FLOAT(m_fIntervalMax);
LOAD_DWORD(m_FlickerCounter);
m_FlickerMsg[0] = 0;
LOAD_CHARSTRING(m_FlickerMsg, sizeof(m_FlickerMsg));
// Read FADE vars.
LOAD_TIME(m_fStartTime);
LOAD_FLOAT(m_fDuration);
LOAD_DWORD_CAST(m_WaveType, WaveType);
LOAD_DWORD_CAST(m_ParamType, ParamType);
m_DestValue.Load(pMsg);
for(i=0; i < MAX_CONTROLLER_TARGETS; i++)
{
pState = &m_Fades[i];
pState->m_StartVal.Load(pMsg);
LOAD_HOBJECT(pState->m_hTarget);
LOAD_CHARSTRING( pState->m_ObjectName, ARRAY_LEN( pState->m_ObjectName ));
}
}
void CAIMovement::Load(ILTMessage_Read *pMsg)
{
m_stackAnimations.Load(pMsg, FnLoadAnimationProp);
LOAD_DWORD_CAST(m_eState, State);
LOAD_BOOL(m_bUnderwater);
LOAD_VECTOR(m_vDest);
LOAD_COBJECT(m_pDestVolume, AIVolume);
LOAD_VECTOR(m_vLastValidVolumePos);
LOAD_BOOL(m_bClimbing);
LOAD_BOOL(m_bFaceDest);
LOAD_FLOAT(m_fSetSpeed);
LOAD_BOOL(m_bIgnoreVolumes);
LOAD_DWORD_CAST(m_eLastMovementType, EnumAnimMovement);
LOAD_FLOAT(m_fAnimRate);
LOAD_BOOL(m_bMovementLocked);
LOAD_BOOL(m_bRotationLocked);
LOAD_BOOL(m_bNoDynamicPathfinding);
LOAD_BOOL(m_bMoved);
LOAD_BOOL(m_bNewPathSet);
LOAD_VECTOR(m_vBoundPts[0]);
LOAD_VECTOR(m_vBoundPts[1]);
LOAD_VECTOR(m_vBoundPts[2]);
LOAD_DWORD(m_cBoundPts);
LOAD_DWORD(m_iBoundPt);
LOAD_BOOL(m_bDoParabola);
LOAD_VECTOR(m_vParabolaOrigin);
LOAD_FLOAT(m_fParabolaPeakDist);
LOAD_FLOAT(m_fParabolaPeakHeight);
LOAD_FLOAT(m_fParabola_a);
LOAD_BOOL(m_bParabolaPeaked);
// If we're loading from a transition, then our positional information is invalid.
if( g_pGameServerShell->GetLGFlags( ) == LOAD_TRANSITION )
{
m_bMovementLocked = LTFALSE;
m_bRotationLocked = LTFALSE;
m_bMoved = LTFALSE;
Clear( );
}
}
void PropDisturbStruct::Load(ILTMessage_Read *pMsg)
{
char szBuf[256];
LOAD_CHARSTRING( szBuf, ARRAY_LEN( szBuf ) );
sTouchSoundName = szBuf;
LOAD_DWORD_CAST( eTouchAnimType, EnumPropAnimationType );
LOAD_DWORD( hTouchAnim );
LOAD_DWORD( hHitAnim );
uint32 nPropTypeId;
LOAD_DWORD(nPropTypeId);
if( nPropTypeId != -1 )
{
PROPTYPE* pPropType = g_pPropTypeMgr->GetPropType( nPropTypeId );
UBER_ASSERT( pPropType, "PropDisturbStruct::Load: Could not find proptype" );
pPD = pPropType->pDisturb;
}
}
void CAIPathKnowledgeMgr::Load(ILTMessage_Read *pMsg)
{
uint32 cKnowledge;
LOAD_DWORD(cKnowledge);
AIVolume *pVolume;
CAIPathMgr::EnumPathBuildStatus eStatus;
for( uint32 iKnowledge=0; iKnowledge < cKnowledge; ++iKnowledge )
{
LOAD_COBJECT( pVolume, AIVolume );
LOAD_DWORD_CAST( eStatus, CAIPathMgr::EnumPathBuildStatus );
m_mapPathKnowledge.insert( AIPATH_KNOWLEDGE_MAP::value_type( pVolume, eStatus ) );
}
LOAD_DWORD( m_nPathKnowledgeIndex );
}
void TransitionArea::Load( ILTMessage_Read *pMsg, uint32 dwSaveFlags )
{
if( !pMsg ) return;
LOAD_DWORD( m_dwFlags );
LOAD_INT( m_nTransLevel );
LOAD_ROTATION( m_tfWorld.m_rRot );
LOAD_VECTOR( m_tfWorld.m_vPos );
}
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 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 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 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 Group::Load(ILTMessage_Read *pMsg)
{
uint32 nSize;
LOAD_DWORD( nSize );
m_saObjectNames.clear();
m_saObjectNames.resize( nSize );
for( uint32 i = 0; i < nSize; ++i )
{
LOAD_STDSTRING( m_saObjectNames[i] );
}
}
void CAIHelicopterStateGoto::Load(HMESSAGEREAD hRead)
{
CAIHelicopterState::Load(hRead);
m_pStrategyFollowPath->Load(hRead);
LOAD_VECTOR(m_vDest);
LOAD_DWORD(m_cNodes);
LOAD_DWORD(m_iNextNode);
LOAD_BOOL(m_bLoop);
int iNode;
for ( iNode = 0 ; iNode < m_cNodes ; iNode++ )
{
LOAD_DWORD(m_adwNodes[iNode]);
}
for ( iNode = m_cNodes ; iNode < kMaxGotoNodes ; iNode++ )
{
m_adwNodes[iNode] = CAINode::kInvalidNodeID;
}
}
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 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 Turret::Load( ILTMessage_Read *pMsg, uint32 dwLoadFlags )
{
if( !pMsg )
return;
m_swtDestroyedDeactivationDelay.Load( *pMsg );
LOAD_HRECORD( m_hTurret, g_pWeaponDB->GetTurretsCategory( ));
LOAD_HOBJECT( m_hOperatingObject );
LOAD_STDSTRING( m_sActivateCommand );
LOAD_STDSTRING( m_sDeactivateCommand );
LOAD_DWORD( m_nCurDamageState );
if( m_hOperatingObject )
m_bPostLoadActivate = true;
}
void DoomsDayDevice::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if( !pMsg )
return;
LOAD_BYTE_CAST( m_eDoomsDayDeviceState, DoomsDayDeviceState );
m_Timer.Load( pMsg );
LOAD_BYTE( m_nOwningTeamID );
LOAD_FLOAT( m_fDropZoneRadius );
uint32 dwTargets;
LOAD_DWORD( dwTargets );
for( uint32 i = 0; i < dwTargets; ++i )
{
LOAD_HOBJECT( m_lsthTargets[i] );
}
}
