void CAISense::Save(HMESSAGEWRITE hWrite)
{
SAVE_HOBJECT(m_hObject);
SAVE_BOOL(m_bEnabled);
SAVE_FLOAT(m_fDistance);
SAVE_FLOAT(m_fDistanceSqr);
SAVE_BOOL(m_bUpdated);
SAVE_DWORD(m_soOutcome);
SAVE_HOBJECT(m_hStimulus);
SAVE_VECTOR(m_vStimulusPosition);
SAVE_FLOAT(m_fStimulation);
SAVE_FLOAT(m_fStimulationIncreaseRateAlert);
SAVE_FLOAT(m_fStimulationDecreaseRateAlert);
SAVE_FLOAT(m_fStimulationIncreaseRateUnalert);
SAVE_FLOAT(m_fStimulationDecreaseRateUnalert);
SAVE_FLOAT(m_fStimulationTime);
SAVE_RANGE(m_rngStimulationThreshhold);
SAVE_BOOL(m_bStimulationPartial);
SAVE_BOOL(m_bStimulationFull);
SAVE_BOOL(m_bIncreasedStimulation);
SAVE_DWORD(m_cFalseStimulation);
SAVE_DWORD(m_nFalseStimulationLimit);
SAVE_BOOL(m_bReacting);
SAVE_FLOAT(m_fReactionDelay);
SAVE_FLOAT(m_fReactionDelayTimer);
SAVE_FLOAT(m_fTimestamp);
}
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 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 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 AINodeGuard::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
// Save guarded node names.
HSTRING hstrNodeName;
HSTRING_LIST::iterator hstr_it;
SAVE_DWORD( m_lstGuardedNodeNames.size() );
for ( hstr_it = m_lstGuardedNodeNames.begin(); hstr_it != m_lstGuardedNodeNames.end(); ++hstr_it )
{
hstrNodeName = *hstr_it;
SAVE_HSTRING( hstrNodeName );
}
// Save guarded nodes.
HOBJECT hNode;
HOBJECT_LIST::iterator h_it;
SAVE_DWORD( m_lstGuardedNodes.size() );
for ( h_it = m_lstGuardedNodes.begin(); h_it != m_lstGuardedNodes.end(); ++h_it )
{
hNode = *h_it;
SAVE_HOBJECT( hNode );
}
}
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 CAIGoalGoto::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_HOBJECT(m_hDestNode);
SAVE_DWORD(m_eMovement);
SAVE_DWORD(m_eAwareness);
}
void CAnimatorPlayer::Save(HMESSAGEWRITE hWrite)
{
SAVE_DWORD(m_eLastMain);
SAVE_DWORD(m_eLastWeapon);
SAVE_DWORD(m_eLastPosture);
SAVE_DWORD(m_eLastMovement);
SAVE_DWORD(m_eLastDirection);
}
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 CAIGoalRespondToBackup::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_HOBJECT(m_hNodeBackup);
SAVE_VECTOR(m_vEnemySeenPos);
SAVE_DWORD(m_cResponses);
SAVE_DWORD(m_cArrivalCount);
}
void CAIPoodleStrategyFollowPath::Save(HMESSAGEREAD hWrite)
{
super::Save(hWrite);
m_pPath->Save(hWrite);
m_AIMovement.Save(hWrite);
SAVE_DWORD(m_eState);
SAVE_DWORD(m_eMovement);
}
void CAICentralKnowledgeMgr::Save(ILTMessage_Write *pMsg)
{
AICENTRAL_KNOWLEDGE_MAP::iterator it;
SAVE_DWORD( (uint32)(m_mapCentralKnowledge.size()) );
for( it = m_mapCentralKnowledge.begin(); it != m_mapCentralKnowledge.end(); ++it )
{
SAVE_DWORD( it->first );
it->second->Save( pMsg );
}
}
void CDestructibleModel::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!g_pLTServer || !pMsg) return;
SAVE_BYTE( m_DestructibleModelFlags );
SAVE_DWORD( m_dwOriginalFlags );
SAVE_DWORD( m_eStimID );
SAVE_FLOAT( m_fStimRadius );
SAVE_DWORD( m_nDestroyAlarmLevel );
SAVE_CHARSTRING( m_pszDestroyedFXName );
}
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 CAIPathKnowledgeMgr::Save(ILTMessage_Write *pMsg)
{
AIPATH_KNOWLEDGE_MAP::iterator it;
SAVE_DWORD( m_mapPathKnowledge.size() );
for( it = m_mapPathKnowledge.begin(); it != m_mapPathKnowledge.end(); ++it )
{
SAVE_COBJECT( it->first );
SAVE_DWORD( it->second );
}
SAVE_DWORD( m_nPathKnowledgeIndex );
}
void CAIGoalGoto::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_DWORD( m_NodeCurrent.eFactID );
SAVE_HOBJECT( m_NodeCurrent.hNode );
SAVE_bool( m_NodeCurrent.bTaskIsScripted );
SAVE_DWORD( m_NodePending.eFactID );
SAVE_HOBJECT( m_NodePending.hNode );
SAVE_bool( m_NodePending.bTaskIsScripted );
}
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 AINavMeshLinkAbstract::Save(ILTMessage_Write *pMsg)
{
SAVE_STDSTRING(m_strName);
SAVE_INT(m_eNMLinkID);
SAVE_INT(m_eNMPolyID);
std::string strSmartObject;
strSmartObject = g_pAIDB->GetAISmartObjectRecordName( (ENUM_AISmartObjectID)m_nSmartObjectID );
SAVE_STDSTRING( strSmartObject );
SAVE_bool(m_bLinkActive);
SAVE_bool(m_bLinkEnabled);
SAVE_bool(m_bTraversalTimedOut);
SAVE_TIME(m_fNextTraversalTime);
SAVE_TIME(m_fNextPreferredTime);
SAVE_FLOAT(m_fPreferredDelay);
SAVE_DWORD(m_eEnabledAwarenessMod);
SAVE_DWORD(m_eMinEnabledAwareness);
SAVE_DWORD(m_eMaxEnabledAwareness);
SAVE_DWORD(m_eMinActiveAwareness);
SAVE_DWORD(m_eMaxActiveAwareness);
// Don't save:
// m_cLinkBounds
// m_pvLinkBounds;
SAVE_VECTOR(m_vLinkEdgeA0);
SAVE_VECTOR(m_vLinkEdgeA1);
SAVE_VECTOR(m_vMidPtLinkEdgeA);
SAVE_VECTOR(m_vLinkEdgeB0);
SAVE_VECTOR(m_vLinkEdgeB1);
SAVE_VECTOR(m_vMidPtLinkEdgeB);
SAVE_VECTOR(m_vLinkDirXZ);
SAVE_FLOAT(m_fLinkDistXZ);
SAVE_FLOAT(m_fEntryOffsetDistA);
SAVE_FLOAT(m_fEntryOffsetDistB);
SAVE_FLOAT(m_fExitOffsetDistA);
SAVE_FLOAT(m_fExitOffsetDistB);
SAVE_FLOAT(m_fFloorTop);
SAVE_FLOAT(m_fFloorBottom);
SAVE_HOBJECT(m_hReservingAI);
}
void CAIGoalTalk::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_DWORD(m_eMood);
SAVE_DWORD(m_eMovement);
SAVE_HSTRING(m_hstrGesture);
SAVE_FLOAT(m_fFaceTime);
SAVE_BOOL(m_bStartedDialog);
SAVE_BOOL(m_bInTalkPosition);
SAVE_BOOL(m_bRetriggerDialogue);
SAVE_BOOL(m_bDisposableDialogue);
SAVE_BOOL(m_bTalking);
SAVE_HOBJECT(m_hDialogue);
}
void CAIWeaponAbstract::Save(ILTMessage_Write *pMsg)
{
HOBJECT hOwner = m_pWeapon->GetObject();
ASSERT(IsAI(hOwner));
SAVE_HOBJECT(hOwner);
SAVE_HRECORD( m_pWeapon->GetWeaponRecord() );
SAVE_STDSTRING(m_szFireSocketName);
SAVE_INT(m_eFiringState);
SAVE_DWORD(m_iAnimRandomSeed);
SAVE_TIME(m_fRandomSeedSelectionTime);
SAVE_FLOAT(m_flWeaponContextInaccuracyScalar);
SAVE_DWORD(m_hWeaponSocket);
SAVE_bool(m_bCanDropWeapon);
}
void CAISensorStatusCheck::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_TIME( m_fStatusCheckTime );
SAVE_DWORD( m_eStimulusIDToCheck );
SAVE_HOBJECT( m_hAlly );
}
//----------------------------------------------------------------------------
//
// 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 CAIDogStrategyOneShotAni::Save(HMESSAGEREAD hWrite)
{
super::Save(hWrite);
SAVE_BOOL(m_bAnimating);
SAVE_DWORD(m_eMain);
}
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]);
}
}
}
}
void PropDisturbStruct::Save(ILTMessage_Write *pMsg)
{
SAVE_CHARSTRING( sTouchSoundName.c_str( ) );
SAVE_DWORD( eTouchAnimType );
SAVE_DWORD( hTouchAnim );
SAVE_DWORD( hHitAnim );
if( pPD )
{
SAVE_DWORD( pPD->nPropTypeId );
}
else
{
SAVE_DWORD( -1 );
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: SkeletonObject::Save
//
// PURPOSE: Save the object
//
// ----------------------------------------------------------------------- //
void SkeletonObject::Save(ILTMessage_Write *pMsg, uint32 dwSaveFlags)
{
if (!pMsg) return;
// Save our important data members
SAVE_DWORD(m_dwSomeVariable);
}
void CAIGoalPatrol::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_HOBJECT( m_hPatrolNode );
SAVE_DWORD( m_eAwareness );
}
void CAIHelicopterStateGoto::Save(HMESSAGEREAD hWrite)
{
CAIHelicopterState::Save(hWrite);
m_pStrategyFollowPath->Save(hWrite);
SAVE_VECTOR(m_vDest);
SAVE_DWORD(m_cNodes);
SAVE_DWORD(m_iNextNode);
SAVE_BOOL(m_bLoop);
for ( int iNode = 0 ; iNode < m_cNodes ; iNode++ )
{
SAVE_DWORD(m_adwNodes[iNode]);
}
}
void CAISensorDamageFX::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_bool( m_bDamageFXInitialized );
SAVE_FLOAT( m_fFullHealth );
SAVE_DWORD( m_eDamageFXState );
}
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 );
}
