コード例 #1
0
ファイル: Controller.cpp プロジェクト: Arc0re/lithtech
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 ));
	}
}
コード例 #2
0
ファイル: costConstruction.c プロジェクト: blaunay/preesm
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);
		}
	}
}
コード例 #3
0
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);
}
コード例 #4
0
void CAIGoalDisappearReappear::Load(ILTMessage_Read *pMsg)
{
	super::Load(pMsg);

	LOAD_FLOAT( m_fDisappearDistMinSqr );
	LOAD_FLOAT( m_fDisappearDistMaxSqr );
}
コード例 #5
0
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);
}
コード例 #6
0
ファイル: AIGoalCharge.cpp プロジェクト: rickyharis39/nolf2
void CAIGoalCharge::Load(ILTMessage_Read *pMsg)
{
	super::Load(pMsg);

	LOAD_FLOAT(m_fAttackDistanceSqr);
	LOAD_FLOAT(m_fYellDistanceSqr);
	LOAD_FLOAT(m_fStopDistanceSqr);
}
コード例 #7
0
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 );
}
コード例 #8
0
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 );
}
コード例 #9
0
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);
	}
}
コード例 #10
0
ファイル: AIBrain.cpp プロジェクト: Arc0re/lithtech
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);
}
コード例 #11
0
ファイル: DeathScene.cpp プロジェクト: Arc0re/lithtech
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);
}
コード例 #12
0
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);
}
コード例 #13
0
ファイル: SecurityCamera.cpp プロジェクト: Arc0re/lithtech
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();
	}
}
コード例 #14
0
ファイル: TextureFX.cpp プロジェクト: Arc0re/lithtech
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);
}
コード例 #15
0
ファイル: PickupItem.cpp プロジェクト: Arc0re/lithtech
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);
	}
}
コード例 #16
0
ファイル: AIWeaponAbstract.cpp プロジェクト: Arc0re/lithtech
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() );
	}
}
コード例 #17
0
void CAISensorNode::Load(ILTMessage_Read *pMsg)
{
    super::Load(pMsg);

    LOAD_FLOAT(m_fSearchMult);
    LOAD_DWORD( m_cNodesFound );
}
コード例 #18
0
//----------------------------------------------------------------------------
//              
//	ROUTINE:	CAIGoalResurrecting::Load()
//              
//	PURPOSE:	
//              
//----------------------------------------------------------------------------
/*virtual*/ void CAIGoalResurrecting::Load(ILTMessage_Read *pMsg)
{
	CAIGoalAbstractSearch::Load(pMsg);

	LOAD_FLOAT(m_fTimeToResurrect);
	LOAD_BOOL(m_bReactivateGoalOnUpdate);
}
コード例 #19
0
ファイル: ExitTrigger.cpp プロジェクト: Arc0re/lithtech
void ExitTrigger::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
	if (!pMsg) return;

    LOAD_FLOAT(m_fFadeOutTime);
    LOAD_bool(m_bExitMission);
}
コード例 #20
0
//----------------------------------------------------------------------------
//              
//	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);
}
コード例 #21
0
ファイル: AIMovement.cpp プロジェクト: Arc0re/lithtech
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( );
	}

}
コード例 #22
0
ファイル: CoreDump.cpp プロジェクト: Arc0re/lithtech
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;
}
コード例 #23
0
ファイル: AINodeStimulus.cpp プロジェクト: Arc0re/lithtech
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);
}
コード例 #24
0
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 );
}
コード例 #25
0
ファイル: CommandObject.cpp プロジェクト: emoose/lithtech
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 );
	}

}
コード例 #26
0
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 );
	}
}
コード例 #27
0
ファイル: Camera.cpp プロジェクト: Arc0re/lithtech
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 );
}
コード例 #28
0
ファイル: Alarm.cpp プロジェクト: emoose/lithtech
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 );
}
コード例 #29
0
ファイル: Spawner.cpp プロジェクト: jordandavidson/lithtech
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 );
}
コード例 #30
0
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);
}