예제 #1
0
void CAISensorMgr::Load(ILTMessage_Read *pMsg)
{
	LOAD_COBJECT(m_pAI, CAI);

	int nSensorCount = 0;
	LOAD_INT(nSensorCount);
	{for (int n = 0; n < nSensorCount; ++n)
	{
		EnumAISensorType eSensor;
		LOAD_INT_CAST(eSensor, EnumAISensorType);
		CAISensorAbstract* pSensor = AI_FACTORY_NEW_Sensor( eSensor );
		pSensor->Load(pMsg);

		m_lstAISensors.push_back(pSensor);
	}}

	LOAD_bool(m_bSensorDeleted);
	LOAD_INT(m_iSensorToUpdate);
	LOAD_bool(m_bDoneProcessingStimuli);
	LOAD_TIME( m_fStimulusListNewIterationTime );

	int nProcessedStimuli = 0;
	LOAD_INT(nProcessedStimuli);
	{for (int n = 0; n < nProcessedStimuli; ++n)
	{
		EnumAIStimulusID eStimulusID;
		LOAD_INT_CAST(eStimulusID, EnumAIStimulusID);
		m_lstProcessedStimuli.push_back(eStimulusID);
	}}

	LOAD_INT(m_cIntersectSegmentCount);
}
예제 #2
0
void CAIGoalMgr::Load(ILTMessage_Read *pMsg)
{
	LOAD_COBJECT(m_pAI, CAI);

	int nGoals = 0;
	LOAD_INT(nGoals);
	for (int i = 0; i < nGoals; ++i)
	{
		EnumAIGoalType eGoalClass;
		LOAD_INT_CAST(eGoalClass, EnumAIGoalType);
		CAIGoalAbstract* pGoal = AI_FACTORY_NEW_Goal(eGoalClass);
		pGoal->Load(pMsg);
		m_lstGoals.push_back(pGoal);
	}

	EnumAIGoalType eCurrentGoalType;
	LOAD_INT_CAST(eCurrentGoalType, EnumAIGoalType);
	m_pCurGoal = FindGoalByType(eCurrentGoalType);

	std::string strGoalSet;
	LOAD_STDSTRING( strGoalSet );
	m_iGoalSet = g_pAIDB->GetAIGoalSetRecordID( strGoalSet.c_str() );

	LOAD_DOUBLE(m_fGoalSetTime);
}
예제 #3
0
void CAICentralKnowledgeRecord::Load(ILTMessage_Read *pMsg)
{
	LOAD_DWORD_CAST( m_eKnowledgeType, EnumAICentralKnowledgeType );
	LOAD_COBJECT( m_pAI, ILTBaseClass );
	m_hAI = (m_pAI) ? m_pAI->m_hObject : LTNULL;
	LOAD_COBJECT( m_pKnowledgeTarget, ILTBaseClass );
	m_hKnowledgeTarget= (m_pKnowledgeTarget) ? m_pKnowledgeTarget->m_hObject : LTNULL;
	LOAD_BOOL( m_bLinkKnowledge );

	LOAD_BOOL( m_bKnowledgeDataIsTime );
	if( m_bKnowledgeDataIsTime )
	{
		LOAD_TIME( m_fKnowledgeData );
	}
	else {
		LOAD_FLOAT( m_fKnowledgeData );
	}
}
예제 #4
0
void CAISensorAbstract::Load(ILTMessage_Read *pMsg)
{
	LOAD_INT_CAST(m_eSensorType, EnumAISensorType);
	LOAD_DOUBLE(m_fNextSensorUpdateTime);
	LOAD_INT(m_cSensorRefCount);
	LOAD_COBJECT(m_pAI, CAI);

	m_pSensorRecord = g_pAIDB->GetAISensorRecord( m_eSensorType );
}
예제 #5
0
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();
}
예제 #6
0
void CAIPlan::Load(ILTMessage_Read *pMsg)
{
	int nSteps = 0;
	LOAD_INT(nSteps);
	m_lstAIPlanSteps.reserve(nSteps);
	for (int i = 0; i < nSteps; ++i)
	{
		CAIPlanStep* pPlanStep = AI_FACTORY_NEW( CAIPlanStep );
		pPlanStep->wsWorldState.Load(pMsg);
		LOAD_INT_CAST(pPlanStep->eAIAction, EnumAIActionType);
		m_lstAIPlanSteps.push_back(pPlanStep);
	}
	
	LOAD_INT(m_iPlanStep);
	LOAD_COBJECT(m_pAI, CAI);
	LOAD_TIME(m_fPlanActivationTime);
}
예제 #7
0
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( );
	}

}
예제 #8
0
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 );
}
예제 #9
0
void AISpatialNeighbor::Load(ILTMessage_Read *pMsg)
{
	LOAD_COBJECT(m_pVolume, AISpatialRepresentation);
	LOAD_VECTOR(m_vConnectionPos);
	LOAD_VECTOR(m_avConnectionEndpoints[0]);
	LOAD_VECTOR(m_avConnectionEndpoints[1]);
	LOAD_VECTOR(m_vConnectionMidpoint);
	LOAD_VECTOR(m_vConnectionPerpDir);
	LOAD_VECTOR(m_vConnectionDir);
	LOAD_FLOAT(m_fConnectionLength);
	LOAD_DWORD(m_cGates);

	m_vecfGateOccupancy.resize(m_cGates);
	for ( uint32 iGate = 0 ; iGate < m_cGates ; iGate++ )
	{
		LOAD_FLOAT(m_vecfGateOccupancy[iGate]);
	}

	LOAD_DWORD_CAST(m_eVolumeConnectionType, VolumeConnectionType);
	LOAD_DWORD_CAST(m_eVolumeConnectionLocation, VolumeConnectionLocation);
}