void CommandObject::Save( ILTMessage_Write *pMsg )
{
GameBaseLite::Save( pMsg );
m_Timer.Save( pMsg );
SAVE_FLOAT( m_fTotalTime );
SAVE_HSTRING( m_hstrFinishedCmd );
SAVE_bool( m_bLocked );
SAVE_INT( m_nNumActivations );
SAVE_INT( m_nNumTimesActivated );
// Save every Event command struct...
SAVE_INT( (int32)(m_lstEventCmds.size()) );
EVENT_CMD_LIST::iterator iter;
EVENT_CMD_STRUCT *pEvntCmdStruct = LTNULL;
for( iter = m_lstEventCmds.begin(); iter != m_lstEventCmds.end(); ++iter )
{
pEvntCmdStruct = *iter;
SAVE_FLOAT( pEvntCmdStruct->m_fTime );
SAVE_BOOL( pEvntCmdStruct->m_bProcessed );
SAVE_HSTRING( pEvntCmdStruct->m_hstrCommand );
}
}
void CAIMovement::Save(ILTMessage_Write *pMsg)
{
m_stackAnimations.Save(pMsg, FnSaveAnimationProp);
SAVE_DWORD(m_eState);
SAVE_BOOL(m_bUnderwater);
SAVE_VECTOR(m_vDest);
SAVE_COBJECT(m_pDestVolume);
SAVE_VECTOR(m_vLastValidVolumePos);
SAVE_BOOL(m_bClimbing);
SAVE_BOOL(m_bFaceDest);
SAVE_FLOAT(m_fSetSpeed);
SAVE_BOOL(m_bIgnoreVolumes);
SAVE_DWORD(m_eLastMovementType);
SAVE_FLOAT(m_fAnimRate);
SAVE_BOOL(m_bMovementLocked);
SAVE_BOOL(m_bRotationLocked);
SAVE_BOOL(m_bNoDynamicPathfinding);
SAVE_BOOL(m_bMoved);
SAVE_BOOL(m_bNewPathSet);
SAVE_VECTOR(m_vBoundPts[0]);
SAVE_VECTOR(m_vBoundPts[1]);
SAVE_VECTOR(m_vBoundPts[2]);
SAVE_DWORD(m_cBoundPts);
SAVE_DWORD(m_iBoundPt);
SAVE_BOOL(m_bDoParabola);
SAVE_VECTOR(m_vParabolaOrigin);
SAVE_FLOAT(m_fParabolaPeakDist);
SAVE_FLOAT(m_fParabolaPeakHeight);
SAVE_FLOAT(m_fParabola_a);
SAVE_BOOL(m_bParabolaPeaked);
}
void CAIGoalDisappearReappear::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_FLOAT( m_fDisappearDistMinSqr );
SAVE_FLOAT( m_fDisappearDistMaxSqr );
}
void Breakable::Save(HMESSAGEWRITE hWrite)
{
if (!hWrite) return;
SAVE_HOBJECT(m_hBreakObj);
SAVE_BOOL(m_bStarted);
SAVE_BOOL(m_bFalling);
SAVE_BOOL(m_bDestroyOnImpact);
SAVE_BOOL(m_bDestroyAfterBreak);
SAVE_BOOL(m_bCrushObjects);
SAVE_BOOL(m_bTouchActivate);
SAVE_FLOAT(m_fBreakTime);
SAVE_FLOAT(m_fBreakSoundRadius);
SAVE_FLOAT(m_fImpactSoundRadius);
SAVE_FLOAT(m_fRotVel);
SAVE_HSTRING(m_hstrBreakSound);
SAVE_HSTRING(m_hstrImpactSound);
SAVE_VECTOR(m_vStartingPitchYawRoll);
SAVE_VECTOR(m_vPitchYawRoll);
SAVE_VECTOR(m_vTotalDelta);
SAVE_VECTOR(m_vDelta);
SAVE_VECTOR(m_vSign);
SAVE_VECTOR(m_vFinalPos);
SAVE_VECTOR(m_vShakeAmount);
SAVE_VECTOR(m_vAdjust);
SAVE_VECTOR(m_vVel);
m_BreakTimer.Save(hWrite);
}
void Controller::Save(ILTMessage_Write *pMsg)
{
FadeState *pState;
uint32 i;
GameBaseLite::Save( pMsg );
SAVE_BOOL(m_bFirstUpdate);
SAVE_DWORD((uint32)m_State);
// Write FLICKER vars.
SAVE_TIME(m_fNextFlickerTime);
SAVE_FLOAT(m_fIntervalMin);
SAVE_FLOAT(m_fIntervalMax);
SAVE_DWORD(m_FlickerCounter);
SAVE_CHARSTRING(m_FlickerMsg);
// Write FADE vars.
SAVE_TIME(m_fStartTime);
SAVE_FLOAT(m_fDuration);
SAVE_DWORD((uint32)m_WaveType);
SAVE_DWORD((uint32)m_ParamType);
m_DestValue.Save(pMsg);
for(i=0; i < MAX_CONTROLLER_TARGETS; i++)
{
pState = &m_Fades[i];
pState->m_StartVal.Save(pMsg);
SAVE_HOBJECT(pState->m_hTarget);
SAVE_CHARSTRING( pState->m_ObjectName );
}
}
void CAIGoalCharge::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_FLOAT(m_fAttackDistanceSqr);
SAVE_FLOAT(m_fYellDistanceSqr);
SAVE_FLOAT(m_fStopDistanceSqr);
}
void CAISenseRecord::Save(HMESSAGEWRITE hWrite)
{
SAVE_HOBJECT(m_hObject);
SAVE_DWORD(m_stType);
SAVE_DWORD(m_soOutcome);
SAVE_FLOAT(m_fTimestamp);
SAVE_FLOAT(m_fLifetime);
}
void CAIGoalDisappearReappearEvasive::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_BOOL( m_bFirstTime );
SAVE_BOOL( m_bForceDisappear );
SAVE_FLOAT( m_fReappearDistOverride );
SAVE_FLOAT( m_fReappearDelay );
}
void CAIHumanStateLaunch::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_FLOAT( m_fLaunchSpeed );
SAVE_FLOAT( m_fLaunchHeight );
SAVE_VECTOR( m_vLaunchDest );
SAVE_DWORD( m_eLaunchMovement );
}
void CAISenseMgr::Save(HMESSAGEWRITE hWrite)
{
SAVE_BOOL(m_bEnabled);
SAVE_FLOAT(m_fNextUpdateTime);
SAVE_FLOAT(m_fUpdateRate);
for ( int iSense = 0 ; iSense < CAISense::kNumSenses ; iSense++ )
{
m_apSenses[iSense]->Save(hWrite);
}
}
void CAIBrain::Save(HMESSAGEWRITE hWrite)
{
SAVE_DWORD(m_eRangeStatusLast);
SAVE_FLOAT(m_fRangeStatusCheckTime);
SAVE_DWORD(m_eDodgeStatusLast);
SAVE_FLOAT(m_fDodgeStatusCheckTimeVector);
SAVE_FLOAT(m_fDodgeStatusCheckTimeProjectile);
SAVE_HSTRING(m_hstrDodgeProjectileName);
SAVE_VECTOR(m_vDodgeProjectilePosition);
SAVE_FLOAT(m_fGrenadeStatusCheckTime);
}
void Body::Save(HMESSAGEWRITE hWrite, uint32 dwSaveFlags)
{
if (!hWrite) return;
LTAnimTracker* pTracker = LTNULL;
if ( (LT_OK == g_pModelLT->GetMainTracker(m_hObject, pTracker)) && pTracker )
{
uint32 dwTime;
g_pModelLT->GetCurAnimTime(pTracker, dwTime);
SAVE_DWORD(dwTime);
}
else
{
SAVE_DWORD(0);
}
SAVE_DWORD(m_eBodyStatePrevious);
SAVE_HOBJECT(m_hHitBox);
SAVE_VECTOR(m_vColor);
SAVE_VECTOR(m_vDeathDir);
SAVE_FLOAT(m_fStartTime);
SAVE_FLOAT(m_fLifetime);
SAVE_BOOL(m_bFirstUpdate);
SAVE_BYTE(m_eModelId);
SAVE_BYTE(m_eModelSkeleton);
SAVE_BYTE(m_eDeathType);
SAVE_BYTE(m_eDamageType);
SAVE_BYTE(m_eModelStyle);
SAVE_DWORD(m_eBodyState);
SAVE_HOBJECT(m_hChecker);
SAVE_HOBJECT(m_hWeaponItem);
if ( m_pState )
{
m_pState->Save(hWrite);
}
SAVE_BOOL(!!m_pAttachments);
if ( m_pAttachments )
{
SAVE_DWORD(m_pAttachments->GetType());
}
SAVE_INT(m_cSpears);
for ( uint32 iSpear = 0 ; iSpear < kMaxSpears ; iSpear++ )
{
SAVE_HOBJECT(m_ahSpears[iSpear]);
}
m_DeathScene.Save(hWrite);
}
void CAnimationContext::Save(HMESSAGEWRITE hWrite)
{
m_Props.Save(hWrite);
SAVE_DWORD(m_eState);
SAVE_INT(m_iAnimation);
SAVE_INT(m_iAnimationFrom);
SAVE_INT(m_iTransition);
SAVE_BOOL(m_bLocked);
SAVE_BOOL(m_bHackToAvoidTheUsualOneFrameOffBullshit);
SAVE_FLOAT(m_fPitchTarget);
SAVE_FLOAT(m_fPitch);
}
void CDeathScene::Save(ILTMessage_Write *pMsg)
{
if ( !pMsg || !g_pLTServer ) return;
SAVE_DWORD(m_eCharacterDeath);
SAVE_HOBJECT(m_hSceneObject);
SAVE_FLOAT(m_fNoiseVolume);
SAVE_TIME(m_fNoiseTime);
SAVE_TIME(m_fLastPainTime);
SAVE_FLOAT(m_fLastPainVolume);
SAVE_BOOL(m_bWasPlayer);
m_pObjectRelationMgr->Save(pMsg);
}
void SecurityCamera::Save(ILTMessage_Write *pMsg)
{
if (!pMsg) return;
m_LightTimer.Save(pMsg);
SAVE_VECTOR(m_vPos);
SAVE_HOBJECT(m_hDisablerModel);
SAVE_HOBJECT(m_hLight);
SAVE_DWORD(m_eState);
SAVE_DWORD(m_ePreviousState);
SAVE_FLOAT(m_fYaw);
SAVE_FLOAT(m_fYaw1);
SAVE_FLOAT(m_fYaw2);
SAVE_FLOAT(m_fYawSpeed);
SAVE_FLOAT(m_fYaw1PauseTime);
SAVE_FLOAT(m_fYaw2PauseTime);
SAVE_FLOAT(m_fYawPauseTimer);
SAVE_FLOAT(m_fSoundRadius);
SAVE_BOOL(m_bDisabled);
SAVE_BOOL(m_bTripped);
SAVE_BYTE((uint8)m_eLightColor);
}
void CoreDump::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!pMsg) return;
SAVE_FLOAT(m_fTotalEnergy);
SAVE_FLOAT(m_fCurrentEnergy);
for(int i=0;i<MAX_CORE_DUMP_FX;i++)
{
SAVE_HOBJECT(m_collFX[i]);
}
// We specifically don't save/load the player because we don't support
// saving/loading during a transfer
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::Save()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ void CAIHumanStateResurrecting::Save(ILTMessage_Write *pMsg)
{
CAIHumanState::Save(pMsg);
SAVE_TIME(m_fResurrectCompleteTime);
SAVE_FLOAT(m_fResurrectCompleteDuration);
SAVE_BOOL(m_bEntryCanDistruct);
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAISensorNode::Save/Load
//
// PURPOSE: Handle saving and restoring the CAISensorNode
//
//----------------------------------------------------------------------------
void CAISensorNode::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_FLOAT(m_fSearchMult);
SAVE_DWORD( m_cNodesFound );
}
void TextureFX::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!pMsg)
return;
//write out the changed flag and the values
for(uint32 nCurrStage = 0; nCurrStage < NUM_STAGES; nCurrStage++)
{
//write out the stage ID
SAVE_DWORD(m_Stages[nCurrStage].m_nID);
//write out the changed
SAVE_BYTE((uint8)m_Stages[nCurrStage].m_nChanged);
//write out the variables
for(uint32 nCurrVar = 0; nCurrVar < NUM_VARS; nCurrVar++)
{
//see if this variable was changed, if it wasn't, don't bother saving
//it out
if(m_Stages[nCurrStage].m_nChanged & (1 << nCurrVar))
{
SAVE_FLOAT(m_Stages[nCurrStage].m_fVars[nCurrVar]);
}
}
}
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIGoalResurrecting::Save()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ void CAIGoalResurrecting::Save(ILTMessage_Write *pMsg)
{
CAIGoalAbstractSearch::Save(pMsg);
SAVE_FLOAT(m_fTimeToResurrect);
SAVE_BOOL(m_bReactivateGoalOnUpdate);
}
void ExitTrigger::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!pMsg) return;
SAVE_FLOAT(m_fFadeOutTime);
SAVE_bool(m_bExitMission);
}
void CAISensorDamageFX::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_bool( m_bDamageFXInitialized );
SAVE_FLOAT( m_fFullHealth );
SAVE_DWORD( m_eDamageFXState );
}
void AINodeStimulus::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_DWORD( m_eStimulusType );
SAVE_DWORD( m_eStimulusID );
SAVE_FLOAT( m_fStimulusDuration );
SAVE_DWORD(m_eAISoundType);
}
void CAIHumanStateAttackProne::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
m_pStrategyShoot->Save(pMsg);
SAVE_TIME( m_fStayProneTime );
SAVE_TIME( m_fLastFiredTime );
SAVE_FLOAT( m_fHalfMinDistSqr );
}
void Spawner::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!pMsg) return;
SAVE_FLOAT(m_fSoundRadius);
SAVE_STDSTRING( m_sSpawnSound );
SAVE_STDSTRING( m_sTarget );
SAVE_STDSTRING( m_sInitialCommand );
}
void CAIVolumeNeighbor::Save(HMESSAGEWRITE hWrite)
{
SAVE_INT(m_iVolume);
SAVE_VECTOR(m_vConnectionPos);
SAVE_VECTOR(m_avConnectionEndpoints[0]);
SAVE_VECTOR(m_avConnectionEndpoints[1]);
SAVE_VECTOR(m_vConnectionPerpDir);
SAVE_VECTOR(m_vConnectionDir);
SAVE_FLOAT(m_fConnectionLength);
}
void Camera::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!pMsg) return;
SAVE_INT ( sm_nActiveCamera );
SAVE_bool ( m_bOn );
SAVE_bool ( m_bIsListener );
SAVE_bool ( m_bAllowPlayerMovement );
SAVE_bool ( m_bOneTime );
SAVE_BYTE ( m_nCameraType);
SAVE_bool ( m_bStartActive );
SAVE_FLOAT ( m_fActiveTime );
SAVE_TIME ( m_fTurnOffTime );
SAVE_bool ( m_bCanSkip );
SAVE_bool ( m_bOnSkipCleanupOnly );
SAVE_STDSTRING ( m_sCleanupCmd );
SAVE_FLOAT ( m_fFovY );
SAVE_FLOAT ( m_fFovAspectScale );
}
void AI_Helicopter::Save(HMESSAGEWRITE hWrite, uint32 dwSaveFlags)
{
CAIVehicle::Save(hWrite, dwSaveFlags);
// Save state...
uint32 dwState = (uint32)-1;
if (m_pHelicopterState)
{
dwState = (uint32) m_pHelicopterState->GetType();
}
SAVE_DWORD(dwState);
if (m_pHelicopterState)
{
m_pHelicopterState->Save(hWrite);
}
SAVE_FLOAT(m_fSpeed);
SAVE_FLOAT(m_fFlySpeed);
SAVE_ROTATION(m_rRotSearchlight);
SAVE_VECTOR(m_vPosSearchlight);
SAVE_INT(m_iObjectSearchLight);
SAVE_ROTATION(m_rRotGunner);
SAVE_VECTOR(m_vPosGunner);
SAVE_INT(m_iObjectGunner);
SAVE_BOOL(m_bWantsRightDoorOpened);
SAVE_BOOL(m_bWantsRightDoorClosed);
SAVE_BOOL(m_bRightDoorOpened);
SAVE_BOOL(m_bWantsLeftDoorOpened);
SAVE_BOOL(m_bWantsLeftDoorClosed);
SAVE_BOOL(m_bLeftDoorOpened);
SAVE_FLOAT(m_fDeathDelay);
SAVE_HSTRING(m_hstrDeathMessage);
SAVE_HSTRING(m_hstrDeath2_3rdMessage);
SAVE_HSTRING(m_hstrDeath1_3rdMessage);
SAVE_HSTRING(m_hstrDeath0_3rdMessage);
SAVE_BOOL(m_bExploded);
}
void CMusicMgr::Save(ILTMessage_Write *pMsg)
{
for ( uint32 iMood = 0 ; iMood < kNumMoods ; iMood++ )
{
SAVE_FLOAT(m_afMoods[iMood]);
}
SAVE_BOOL(m_bLockedMood);
SAVE_BOOL(m_bLockedEvent);
SAVE_INT(m_iRestoreMusicIntensity);
}
void CDestructibleModel::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!g_pLTServer || !pMsg) return;
SAVE_BYTE( m_nDebrisId );
SAVE_BOOL( m_bCreatedDebris );
SAVE_BOOL( m_bCreateExplosion );
SAVE_BYTE( m_nExplosionWeaponId );
SAVE_BOOL( m_bFireAlongForward );
SAVE_FLOAT( m_fDamageFactor );
SAVE_BOOL( m_bRemoveOnDeath );
SAVE_HSTRING( m_hstrSpawn );
SAVE_HSTRING( m_hstrSurfaceOverride );
SAVE_DWORD( m_dwOriginalFlags );
SAVE_BOOL( m_bSaveNeverDestroy );
SAVE_BOOL( m_bSaveCanDamage );
SAVE_DWORD( m_eStimID );
SAVE_FLOAT( m_fStimRadius );
SAVE_DWORD( m_nDestroyAlarmLevel );
}
