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 costConstruction(int height, int width, float truncValue, unsigned char *disparity, float *grayL, float *grayR, unsigned char *cenL, unsigned char *cenR, float *disparityError) { int i, j; // For each disparity, scan the pixels of the left image for (j = 0; j < height; j++) { for (i = 0; i < width; i++) { unsigned char censusCost; int leftPxlIdx = j * width + i; int rightPxlIdx = j * width + (((i - *disparity) > 0) ? i - *disparity : 0); float result; // Get the cost from the census signatures censusCost = hammingCost(cenL + leftPxlIdx, cenR + rightPxlIdx); // Combination method 3 -- weight addition result = min(fabs((float)(LOAD_FLOAT(&grayL[leftPxlIdx])-LOAD_FLOAT(&grayR[rightPxlIdx]))),truncValue) + censusCost / 5.0; STORE_FLOAT(&disparityError[leftPxlIdx], &result); } } }
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 CAIGoalDisappearReappear::Load(ILTMessage_Read *pMsg) { super::Load(pMsg); LOAD_FLOAT( m_fDisappearDistMinSqr ); LOAD_FLOAT( m_fDisappearDistMaxSqr ); }
void CAISenseRecord::Load(HMESSAGEREAD hRead) { LOAD_HOBJECT(m_hObject); LOAD_DWORD_CAST(m_stType, SenseType); LOAD_DWORD_CAST(m_soOutcome, SenseOutcome); LOAD_FLOAT(m_fTimestamp); LOAD_FLOAT(m_fLifetime); }
void CAIGoalCharge::Load(ILTMessage_Read *pMsg) { super::Load(pMsg); LOAD_FLOAT(m_fAttackDistanceSqr); LOAD_FLOAT(m_fYellDistanceSqr); LOAD_FLOAT(m_fStopDistanceSqr); }
void CAIGoalDisappearReappearEvasive::Load(ILTMessage_Read *pMsg) { super::Load(pMsg); LOAD_BOOL( m_bFirstTime ); LOAD_BOOL( m_bForceDisappear ); LOAD_FLOAT( m_fReappearDistOverride ); LOAD_FLOAT( m_fReappearDelay ); }
void CAIHumanStateLaunch::Load(ILTMessage_Read *pMsg) { super::Load(pMsg); LOAD_FLOAT( m_fLaunchSpeed ); LOAD_FLOAT( m_fLaunchHeight ); LOAD_VECTOR( m_vLaunchDest ); LOAD_DWORD_CAST( m_eLaunchMovement, EnumAnimProp ); }
void CAISenseMgr::Load(HMESSAGEREAD hRead) { LOAD_BOOL(m_bEnabled); LOAD_FLOAT(m_fNextUpdateTime); LOAD_FLOAT(m_fUpdateRate); for ( int iSense = 0 ; iSense < CAISense::kNumSenses ; iSense++ ) { m_apSenses[iSense]->Load(hRead); } }
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 CDeathScene::Load(ILTMessage_Read *pMsg) { if ( !pMsg || !g_pLTServer ) return; LOAD_DWORD_CAST(m_eCharacterDeath, CharacterDeath); LOAD_HOBJECT(m_hSceneObject); LOAD_FLOAT(m_fNoiseVolume); LOAD_TIME(m_fNoiseTime); LOAD_TIME(m_fLastPainTime); LOAD_FLOAT(m_fLastPainVolume); LOAD_BOOL(m_bWasPlayer); m_pObjectRelationMgr->Load(pMsg); }
void CAnimationContext::Load(HMESSAGEREAD hRead) { m_Props.Load(hRead); LOAD_DWORD_CAST(m_eState, State); LOAD_INT(m_iAnimation); LOAD_INT(m_iAnimationFrom); LOAD_INT(m_iTransition); LOAD_BOOL(m_bLocked); LOAD_BOOL(m_bHackToAvoidTheUsualOneFrameOffBullshit); LOAD_FLOAT(m_fPitchTarget); LOAD_FLOAT(m_fPitch); }
void SecurityCamera::Load(ILTMessage_Read *pMsg) { if (!pMsg) return; m_LightTimer.Load(pMsg); LOAD_VECTOR(m_vPos); LOAD_HOBJECT(m_hDisablerModel); LOAD_HOBJECT(m_hLight); LOAD_DWORD_CAST(m_eState, State); LOAD_DWORD_CAST(m_ePreviousState, State); LOAD_FLOAT(m_fYaw); LOAD_FLOAT(m_fYaw1); LOAD_FLOAT(m_fYaw2); LOAD_FLOAT(m_fYawSpeed); LOAD_FLOAT(m_fYaw1PauseTime); LOAD_FLOAT(m_fYaw2PauseTime); LOAD_FLOAT(m_fYawPauseTimer); LOAD_FLOAT(m_fSoundRadius); LOAD_BOOL(m_bDisabled); LOAD_BOOL(m_bTripped); LOAD_BYTE_CAST(m_eLightColor, LightColor); // Restore our sounds... if (m_eState == eStateFocusing) { StartFocusingSound(); } }
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); }
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 CAISensorNode::Load(ILTMessage_Read *pMsg) { super::Load(pMsg); LOAD_FLOAT(m_fSearchMult); LOAD_DWORD( m_cNodesFound ); }
//---------------------------------------------------------------------------- // // ROUTINE: CAIGoalResurrecting::Load() // // PURPOSE: // //---------------------------------------------------------------------------- /*virtual*/ void CAIGoalResurrecting::Load(ILTMessage_Read *pMsg) { CAIGoalAbstractSearch::Load(pMsg); LOAD_FLOAT(m_fTimeToResurrect); LOAD_BOOL(m_bReactivateGoalOnUpdate); }
void ExitTrigger::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags) { if (!pMsg) return; LOAD_FLOAT(m_fFadeOutTime); LOAD_bool(m_bExitMission); }
//---------------------------------------------------------------------------- // // ROUTINE: CAIHumanStateResurrecting::Load() // // PURPOSE: // //---------------------------------------------------------------------------- /*virtual*/ void CAIHumanStateResurrecting::Load(ILTMessage_Read *pMsg) { CAIHumanState::Load(pMsg); LOAD_TIME(m_fResurrectCompleteTime); LOAD_FLOAT(m_fResurrectCompleteDuration); LOAD_BOOL(m_bEntryCanDistruct); }
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 CoreDump::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags) { if (!pMsg) return; LOAD_FLOAT(m_fTotalEnergy); LOAD_FLOAT(m_fCurrentEnergy); for(int i=0;i<MAX_CORE_DUMP_FX;i++) { LOAD_HOBJECT(m_collFX[i]); } m_bActive = false; // We specifically don't save/load the player because we don't support // saving/loading during a transfer HOBJECT hPlayer = NULL; }
void AINodeStimulus::Load(ILTMessage_Read *pMsg) { super::Load(pMsg); LOAD_DWORD_CAST( m_eStimulusType, EnumAIStimulusType ); LOAD_DWORD_CAST( m_eStimulusID, EnumAIStimulusID ); LOAD_FLOAT( m_fStimulusDuration ); LOAD_DWORD_CAST(m_eAISoundType, EnumAISoundType); }
void CAIHumanStateAttackProne::Load(ILTMessage_Read *pMsg) { super::Load(pMsg); m_pStrategyShoot->Load(pMsg); LOAD_TIME( m_fStayProneTime ); LOAD_TIME( m_fLastFiredTime ); LOAD_FLOAT( m_fHalfMinDistSqr ); }
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 AINavMeshLinkAbstract::Load(ILTMessage_Read *pMsg) { LOAD_STDSTRING(m_strName); LOAD_INT_CAST(m_eNMLinkID, ENUM_NMLinkID); LOAD_INT_CAST(m_eNMPolyID, ENUM_NMPolyID); std::string strSmartObject; LOAD_STDSTRING( strSmartObject ); m_nSmartObjectID = g_pAIDB->GetAISmartObjectRecordID( strSmartObject.c_str() ); LOAD_bool(m_bLinkActive); LOAD_bool(m_bLinkEnabled); LOAD_bool(m_bTraversalTimedOut); LOAD_TIME(m_fNextTraversalTime); LOAD_TIME(m_fNextPreferredTime); LOAD_FLOAT(m_fPreferredDelay); LOAD_DWORD_CAST(m_eEnabledAwarenessMod, EnumAIAwarenessMod); LOAD_DWORD_CAST(m_eMinEnabledAwareness, EnumAIAwareness); LOAD_DWORD_CAST(m_eMaxEnabledAwareness, EnumAIAwareness); LOAD_DWORD_CAST(m_eMinActiveAwareness, EnumAIAwareness); LOAD_DWORD_CAST(m_eMaxActiveAwareness, EnumAIAwareness); // Don't load: // m_cLinkBounds // m_pvLinkBounds; LOAD_VECTOR(m_vLinkEdgeA0); LOAD_VECTOR(m_vLinkEdgeA1); LOAD_VECTOR(m_vMidPtLinkEdgeA); LOAD_VECTOR(m_vLinkEdgeB0); LOAD_VECTOR(m_vLinkEdgeB1); LOAD_VECTOR(m_vMidPtLinkEdgeB); LOAD_VECTOR(m_vLinkDirXZ); LOAD_FLOAT(m_fLinkDistXZ); LOAD_FLOAT(m_fEntryOffsetDistA); LOAD_FLOAT(m_fEntryOffsetDistB); LOAD_FLOAT(m_fExitOffsetDistA); LOAD_FLOAT(m_fExitOffsetDistB); LOAD_FLOAT(m_fFloorTop); LOAD_FLOAT(m_fFloorBottom); LOAD_HOBJECT(m_hReservingAI); if( g_pAINavMesh ) { g_pAINavMesh->AddAINavMeshLink( this ); } }
void Camera::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags) { if (!pMsg) return; LOAD_INT ( sm_nActiveCamera ); LOAD_bool ( m_bOn ); LOAD_bool ( m_bIsListener ); LOAD_bool ( m_bAllowPlayerMovement ); LOAD_bool ( m_bOneTime ); LOAD_BYTE ( m_nCameraType); LOAD_bool ( m_bStartActive ); LOAD_FLOAT ( m_fActiveTime ); LOAD_TIME ( m_fTurnOffTime ); LOAD_bool ( m_bCanSkip ); LOAD_bool ( m_bOnSkipCleanupOnly ); LOAD_STDSTRING ( m_sCleanupCmd ); LOAD_FLOAT ( m_fFovY ); LOAD_FLOAT ( m_fFovAspectScale ); }
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 Spawner::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags) { if (!pMsg) return; LOAD_FLOAT(m_fSoundRadius); LOAD_STDSTRING( m_sSpawnSound ); LOAD_STDSTRING( m_sTarget ); LOAD_STDSTRING( m_sInitialCommand ); }
void CAIVolumeNeighbor::Load(HMESSAGEREAD hRead) { LOAD_INT(m_iVolume); LOAD_VECTOR(m_vConnectionPos); LOAD_VECTOR(m_avConnectionEndpoints[0]); LOAD_VECTOR(m_avConnectionEndpoints[1]); LOAD_VECTOR(m_vConnectionPerpDir); LOAD_VECTOR(m_vConnectionDir); LOAD_FLOAT(m_fConnectionLength); }