ubergames
/
ef2gamesource
mirror of https://github.com/UberGames/EF2GameSource.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ef2gamesource/dlls/game/actor_sensoryperception.cpp

1086 lines
25 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
//
// $Logfile:: /Code/DLLs/game/actor_sensoryperception.cpp $
// $Revision:: 21 $
// $Author:: Sketcher $
// $Date:: 4/09/03 5:04p $
//
// Copyright (C) 2001 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
//
#include "_pch_cpp.h"
#include "actor_sensoryperception.h"
#include "player.h"
#include "object.h"
//======================================
// SensoryPerception Implementation
//======================================
//
// Name: SensoryPerception()
// Parameters: None
// Description: Constructor
//
SensoryPerception::SensoryPerception()
{
// Should always use other constructor
gi.Error( ERR_FATAL, "SensoryPerception::SensoryPerception -- Default Constructor Called" );
}
//
// Name: SensoryPerception()
// Parameters: Actor* actor -- The actor pointer to be assigned
// to the internal actor pointer
// Description: Constructor
//
SensoryPerception::SensoryPerception(Actor *actor )
{
//Initialize our Actor
if ( actor )
act = actor;
else
gi.Error( ERR_FATAL, "SensoryPerception::SensoryPerception -- actor is NULL" );
_init();
}
//
// Name: ~SensoryPerception()
// Parameters: None
// Description: Destructor
//
SensoryPerception::~SensoryPerception()
{
}
qboolean SensoryPerception::isInLineOfSight( const Vector &position , const int entNum )
{
trace_t trace;
Vector startPos;
Vector endPos;
Entity *traceEnt;
startPos = act->origin;
startPos.z += 15;
endPos = position;
endPos.z += 15;
Vector modMins;
Vector modMaxs;
modMins = act->mins;
modMins *= 1.5;
modMaxs = act->maxs;
modMaxs *= 1.5;
trace = G_Trace( startPos, modMins, modMaxs, endPos, act, act->edict->clipmask, false, "isInLineOfSight" );
//G_DebugLine( startPos , trace.endpos, 1.0f, 0.0f, 1.0f, 1.0f );
_lineOfSight.entNum = entNum;
_lineOfSight.time = level.time;
if ( trace.entityNum == entNum || entNum == ENTITYNUM_NONE )
{
_lineOfSight.inLineOfSight = true;
}
else
{
traceEnt = G_GetEntity( trace.entityNum );
_lineOfSight.inLineOfSight = false;
if ( traceEnt && traceEnt->isSubclassOf( Actor) )
{
Actor *traceActor;
traceActor = (Actor*)traceEnt;
_lineOfSight.inLineOfSight = traceActor->sensoryPerception->checkInLineOfSight( position , entNum );
}
}
return _lineOfSight.inLineOfSight;
}
qboolean SensoryPerception::checkInLineOfSight( const Vector &position , const int entNum )
{
float timeDelta;
timeDelta = level.time - _lineOfSight.time;
if ( timeDelta > .5 || entNum != _lineOfSight.entNum )
return isInLineOfSight( position , entNum );
else
return _lineOfSight.inLineOfSight;
}
void SensoryPerception::_init()
{
// Set up Stimuli
_stimuli = STIMULI_ALL;
_permanent_stimuli = STIMULI_ALL;
//Member Vars
_noise_position = vec_zero;
_noise_time = 0;
_fov = DEFAULT_FOV;
_fovdot = (float)cos( (double)_fov * 0.5 * M_PI / 180.0 );
_vision_distance = DEFAULT_VISION_DISTANCE;
_last_soundType = SOUNDTYPE_NONE;
_nextSenseTime = 0.0f;
_lineOfSight.entNum = 0;
_lineOfSight.inLineOfSight = false;
_lineOfSight.time = 0.0f;
}
//
// Name: SenseEnemies()
// Parameters: None
// Description: Checks for players and teammates, to see if the actor
// needs to wake up
//
void SensoryPerception::SenseEnemies()
{
int i;
if ( _nextSenseTime > level.time )
return;
_nextSenseTime = level.time + 0.5f + G_Random( 0.2f );
//_nextSenseTime = 0;
//Well, who your enemies are depends on what side your on
if ( ( act->actortype == IS_ENEMY ) || ( act->actortype == IS_MONSTER ) )
{
//
//If we an ENEMY or a MONSTER than teammates are our enemies
//
Sentient *teammate;
for ( i = 1 ; i <= TeamMateList.NumObjects() ; i++ )
{
teammate = TeamMateList.ObjectAt( i );
if ( _SenseEntity( teammate ) ) return;
}
}
else
{
//
//If we an CIVILIAN, FRIEND, or TEAMMATE our potiential enemies are active monsters
//
Entity *ent;
for ( i = 1 ; i <= ActiveList.NumObjects() ; i++ )
{
ent = ActiveList.ObjectAt( i );
_SenseEntity(ent);
}
//In case we didn't find an enemy, but if the players nearby, we want to wake up anyway
_SenseEntity( GetPlayer( 0 ) );
}
}
qboolean SensoryPerception::_SenseEntity( Entity *ent )
{
// Dont want to target the enemy if he's not a valid target
if (!ent)
return false;
if ( !EntityIsValidTarget(ent) )
return false;
// Dont wake ourselves up
if ( ent->entnum == act->entnum )
return false;
if ( ent->isSubclassOf ( Actor ) )
{
if ( !ent->isThinkOn() )
return false;
}
/*
// Check if we're in the PVS
if ( gi.inPVS( ent->centroid, act->centroid ) )
{
// Check if we can see the enemy
if ( CanSeeEntity ( act , ent , true , true ) )
Stimuli( STIMULI_SIGHT , ent );
else
{
// Lets not idle for teammates, just players
if ( ent->isSubclassOf( Player ) )
{
// We couldn't see the enemy, but we're in the PVS, so we need to wake up and idle a bit.
if ( ( world->farplane_distance == 0 ) || ( Distance( ent->centroid, act->centroid ) < world->farplane_distance ) )
{
act->Wakeup();
//act->ActivateAI();
}
}
else
return false;
}
return true;
}
*/
if ( gi.inPVS( ent->centroid, act->centroid ) )
{
Vector enemyToSelf;
enemyToSelf = act->origin - ent->origin;
float visionDistance = GetVisionDistance();
if ( enemyToSelf.length() < visionDistance )
{
if ( CanSeeEntity( act, ent, true, true ) )
Stimuli( STIMULI_SIGHT , ent );
}
}
return false;
}
//
// Name: Stimuli()
// Parameters: int stimuli -- The Stimuli
// Description: Wakes up the actor if it should respond to the stimuli
//
void SensoryPerception::Stimuli( int stimuli )
{
if ( ShouldRespondToStimuli( stimuli ) )
{
act->Wakeup();
act->ActivateAI();
}
}
//
// Name: Stimuli()
// Parameters: int new_stimuli -- The Stimuli
// Entity ent -- The Entity
// qboolean force -- Force the actor to make the entity an enemy
// Description: Wakes up the actor if it should respond to the stimuli
//
void SensoryPerception::Stimuli( int new_stimuli, Entity *ent )
{
if ( !ent )
return;
if ( ShouldRespondToStimuli( new_stimuli ) && EntityIsValidTarget(ent))
{
act->enemyManager->TryToAddToHateList( ent );
act->Wakeup();
act->ActivateAI();
}
}
//
// Name: Stimuli()
// Parameters: int new_stimuli -- The Stimuli
// const Vector &pos -- The location of the stimuli
// Description: Wakes up the actor if it should respond to the stimuli
//
void SensoryPerception::Stimuli( int new_stimuli, const Vector &pos )
{
if ( ShouldRespondToStimuli( new_stimuli ) )
{
// Investigate the position
if ( !act->GetActorFlag( ACTOR_FLAG_NOISE_HEARD ) )
{
_noise_position = pos;
_noise_time = level.time;
act->SetActorFlag( ACTOR_FLAG_NOISE_HEARD, true );
}
if ( act->last_time_active + 10.0f < level.time )
{
act->Wakeup();
act->ActivateAI();
}
}
}
//
// Name: Stimuli()
// Parameters: int new_stimuli -- The stimuli
// const Vector &pos -- The location of the stimuli
// int sound_Type -- sound type of the stimuli
// Description: Wakes up the actor if it should respond to the stimuli
//
void SensoryPerception::Stimuli( int new_stimuli, const Vector &pos, int sound_Type )
{
if ( ShouldRespondToStimuli( new_stimuli ) )
{
if ( !act->GetActorFlag( ACTOR_FLAG_NOISE_HEARD ) )
{
_noise_position = pos;
_last_soundType = sound_Type;
_noise_time = level.time;
act->SetActorFlag( ACTOR_FLAG_NOISE_HEARD, true );
}
if ( act->last_time_active + 10.0f < level.time )
{
act->Wakeup();
act->ActivateAI();
}
}
}
//
// Name: RespondTo()
// Parameters: const str &stimuli_name -- string name for the stimuli
// qboolean respond -- Respond or Not to the stimuli
// Description: sets if the actor will respond to a particular stimulus
//
void SensoryPerception::RespondTo(const str &stimuli_name , qboolean respond )
{
if ( !Q_stricmp( stimuli_name.c_str() , "sight" ) )
RespondTo(STIMULI_SIGHT , respond );
else if ( !Q_stricmp( stimuli_name.c_str() , "sound" ) )
RespondTo(STIMULI_SOUND , respond );
else if ( !Q_stricmp( stimuli_name.c_str() , "pain" ) )
RespondTo(STIMULI_PAIN , respond );
else if ( !Q_stricmp( stimuli_name.c_str() , "script" ) )
RespondTo(STIMULI_SCRIPT , respond );
else if ( !Q_stricmp( stimuli_name.c_str() , "all" ) )
RespondTo(STIMULI_ALL , respond );
else if ( !Q_stricmp( stimuli_name.c_str() , "none" ) )
RespondTo(STIMULI_NONE , respond );
}
//
// Name: RespondTo()
// Parameters: int stimuli -- the stimuli
// qboolean respond -- Respond or Not to the stimuli
// Description: sets if the actor will respond to a particular stimulus
//
void SensoryPerception::RespondTo( int stimuli , qboolean respond )
{
if ( stimuli == STIMULI_ALL )
{
if ( respond )
_stimuli = STIMULI_ALL;
else
_stimuli = STIMULI_NONE;
return;
}
if ( stimuli == STIMULI_NONE )
{
if ( respond )
_stimuli = STIMULI_NONE;
else
_stimuli = STIMULI_ALL;
return;
}
if ( respond )
_stimuli |= stimuli;
else
_stimuli &= ~stimuli;
}
//
// Name: PermanentlyRespondTo
// Parameters: const str &stimuli_name -- string name for the stimuli
// qboolean respond -- Respond or Not to the stimuli
// Description: Allows the actor to ALWAYS respond or not to a particular stimulus
// this allows us to make actors that are deaf or blind... etc
//
void SensoryPerception::PermanentlyRespondTo(const str &stimuli_name , qboolean respond )
{
if ( !Q_stricmp( stimuli_name.c_str() , "sight" ) )
{
if ( respond )
_permanent_stimuli |= STIMULI_SIGHT;
else
_permanent_stimuli &= ~STIMULI_SIGHT;
}
else if ( !Q_stricmp( stimuli_name.c_str() , "sound" ) )
{
if ( respond )
_permanent_stimuli |= STIMULI_SOUND;
else
_permanent_stimuli &= ~STIMULI_SOUND;
}
else if ( !Q_stricmp( stimuli_name.c_str() , "pain" ) )
{
if ( respond )
_permanent_stimuli |= STIMULI_PAIN;
else
_permanent_stimuli &= ~STIMULI_PAIN;
}
else if ( !Q_stricmp( stimuli_name.c_str() , "script" ) )
{
if ( respond )
_permanent_stimuli |= STIMULI_SCRIPT;
else
_permanent_stimuli &= ~STIMULI_SCRIPT;
}
else if ( !Q_stricmp( stimuli_name.c_str() , "all" ) )
{
if ( respond )
_permanent_stimuli = STIMULI_ALL;
else
_permanent_stimuli = STIMULI_NONE;
}
else if ( !Q_stricmp( stimuli_name.c_str() , "none" ) )
{
if ( respond )
_permanent_stimuli = STIMULI_NONE;
else
_permanent_stimuli = STIMULI_ALL;
}
}
//
// Name: ShouldRespondToStimuli()
// Parameters: int new_stimuli -- the stimuli to check
// Description: Checks if the actor should respond to the stimuli
//
qboolean SensoryPerception::ShouldRespondToStimuli( int new_stimuli )
{
if( ( act->targetType == ATTACK_SCRIPTED_ONLY ) && ( new_stimuli != STIMULI_SCRIPT ) ) return false;
if ( _stimuli == STIMULI_ALL )
return true;
if ( _stimuli == STIMULI_NONE )
return false;
return ( (( new_stimuli & _stimuli ) && ( new_stimuli & _permanent_stimuli )) || ( new_stimuli == STIMULI_SCRIPT ) );
}
//
// Name: ShowInfo()
// Parameters: None
// Description: Prints sensoryinformation to the console
//
void SensoryPerception::ShowInfo()
{
if ( ShouldRespondToStimuli( STIMULI_ALL ) )
{
gi.Printf( "Actor is Responding To: ALL" );
return;
}
if ( ShouldRespondToStimuli( STIMULI_NONE ) )
{
gi.Printf( "Actor is Responding To: NONE" );
return;
}
if ( ShouldRespondToStimuli( STIMULI_SIGHT ) )
gi.Printf( "Actor is Responding To: SIGHT" );
if ( ShouldRespondToStimuli( STIMULI_SOUND ) )
gi.Printf( "Actor is Responding To: SOUND" );
if ( ShouldRespondToStimuli( STIMULI_PAIN ) )
gi.Printf( "Actor is Responding To: PAIN" );
if ( ShouldRespondToStimuli( STIMULI_SCRIPT ) )
gi.Printf( "Actor is Responding To: SCRIPT" );
}
//
// Name: WithinVisionDistance()
// Parameters: Entity *ent -- The entity to be checked
// Description: Checks if the passed in entity is
// within the vision_distance of the actor, or the
// farplane_distance of the world ( whichever is smaller )
//
qboolean SensoryPerception::WithinVisionDistance( const Entity *ent )
{
float distance;
if ( !ent )
return false;
if ( !act )
gi.Error( ERR_DROP, "SensoryPerception::WithinVisionDistance -- actor is NULL" );
// Use whichever is less : the actor's vision distance or the distance of the farplane (fog)
if ( ( world->farplane_distance != 0.0f ) && ( world->farplane_distance < _vision_distance ) )
distance = world->farplane_distance;
else
distance = _vision_distance;
return act->WithinDistance( ent, distance );
}
qboolean SensoryPerception::WithinVisionDistance( const Vector &pos )
{
float distance;
if ( !act )
gi.Error( ERR_DROP, "SensoryPerception::WithinVisionDistance -- actor is NULL" );
// Use whichever is less : the actor's vision distance or the distance of the farplane (fog)
if ( ( world->farplane_distance != 0.0f ) && ( world->farplane_distance < _vision_distance ) )
distance = world->farplane_distance;
else
distance = _vision_distance;
return act->WithinDistance( pos, distance );
}
//
// Name: InFOV()
// Parameters: Vector &pos -- The position vector to be checked
// float check_fov -- The fov number to be used
// float check_fovdot -- the dot product
// Description: Checks if the passed in pos to see if it is in the FOV
//
qboolean SensoryPerception::InFOV( const Vector &pos, float check_fov, float check_fovdot )
{
Vector delta;
float dot;
Vector temp;
int tagNum;
if ( !act )
gi.Error( ERR_DROP, "SensoryPerception::InFOV -- actor is NULL" );
if ( check_fov == 360.0f )
return true;
temp = act->EyePosition();
delta = pos - act->EyePosition();
if ( !delta.x && !delta.y )
{
// special case for straight up and down
return true;
}
// give better vertical vision
delta.z = 0;
delta.normalize();
tagNum = gi.Tag_NumForName( act->edict->s.modelindex, "tag_eyes" );
if ( tagNum >= 0 )
{
Vector tag_pos;
Vector forward;
act->GetTag( tagNum, &tag_pos, &forward );
dot = DotProduct( &forward[0] , delta );
}
else
{
dot = DotProduct( act->orientation[ 0 ], delta );
}
return ( dot > check_fovdot );
}
//
// Name: InFOV()
// Parameters: Vector &pos -- The position to be checked
// Description: Calls another version of InFOV
//
qboolean SensoryPerception::InFOV( const Vector &pos )
{
return InFOV( pos, _fov, _fovdot );
}
//
// Name: InFOV()
// Parameters: Entity* ent -- Provides the Position to check
// Description: Calls another version InFOV
//
qboolean SensoryPerception::InFOV( const Entity *ent )
{
return InFOV( ent->centroid );
}
//
// Name: CanSeeEntity()
// Parameters: Entity *start - The entity trying to see
// Entity *target - The entity that needs to be seen
// qboolean useFOV - take FOV into consideration or not
// qboolean useVisionDistance - take visionDistance into consideration
// Description: Wraps a lot of the different CanSee Functions into one
//
qboolean SensoryPerception::CanSeeEntity( Entity *start, const Entity *target, qboolean useFOV, qboolean useVisionDistance )
{
// Check for NULL
if ( !start || !target )
return false;
// Check if This Actor can even see at all
if ( !ShouldRespondToStimuli( STIMULI_SIGHT ) )
return false;
// Check for FOV
if ( useFOV )
{
if ( !InFOV( target ) )
return false;
}
// Check for vision distance
if ( useVisionDistance )
{
if ( !WithinVisionDistance( target ) )
return false;
}
// Do Trace
trace_t trace;
Vector p;
Vector eyePos;
p = target->centroid;
eyePos = vec_zero;
// If the start entity is an actor, then we want to add in the eyeposition
if ( start->isSubclassOf ( Actor ) )
{
Actor *a;
a = (Actor*)start;
if ( !a )
return false;
eyePos = a->EyePosition();
}
// Check if he's visible
trace = G_Trace( eyePos, vec_zero, vec_zero, p, target, MASK_OPAQUE, false, "SensoryPerception::CanSeeEntity" );
//if ( act->actortype == IS_TEAMMATE )
// {
// G_DebugLine( eyePos , target->centroid, 0.0f, 0.0f, 1.0f, 1.0f );
// G_DebugLine( eyePos , trace.endpos , 1.0f, 0.0f, 1.0f, 1.0f );
// }
if ( ( trace.fraction == 1.0f ) || ( trace.ent == target->edict ) )
return true;
// Check if his head is visible
p.z = target->absmax.z;
trace = G_Trace( eyePos, vec_zero, vec_zero, p, target, MASK_OPAQUE, false, "SensoryPerception::CanSeeEntity" );
if ( trace.fraction == 1.0f || trace.ent == target->edict )
return true;
return false;
}
//
// Name: CanSeeEntity()
// Parameters: Vector &start -- The starting position
// Entity *target - The entity that needs to be seen
// qboolean useFOV - take FOV into consideration or not
// qboolean useVisionDistance - take visionDistance into consideration
// Description: Wraps a lot of the different CanSee Functions into one
//
qboolean SensoryPerception::CanSeeEntity( const Vector &start , const Entity *target, qboolean useFOV , qboolean useVisionDistance )
{
Vector realStart;
// Check for NULL
if ( !target )
return false;
// Check if This Actor can even see at all
if ( !ShouldRespondToStimuli( STIMULI_SIGHT ) )
return false;
// Check for FOV
if ( useFOV )
{
if ( !InFOV( target ) )
return false;
}
// Check for vision distance
if ( useVisionDistance )
{
if ( !WithinVisionDistance( target ) )
return false;
}
// Do Trace
trace_t trace;
Vector p;
Vector eyePos;
realStart = start;
p = target->centroid;
// Add in the eye offset
eyePos = act->EyePosition() - act->origin;
realStart += eyePos;
// Check if he's visible
trace = G_Trace( realStart, vec_zero, vec_zero, p, act, MASK_OPAQUE, false, "SensoryPerception::CanSeeEntity" );
if ( trace.fraction == 1.0f || trace.ent == target->edict )
return true;
// Check if his head is visible
p.z = target->absmax.z;
trace = G_Trace( realStart, vec_zero, vec_zero, p, act, MASK_OPAQUE, false, "SensoryPerception::CanSeeEntity" );
if ( trace.fraction == 1.0f || trace.ent == target->edict )
return true;
return false;
}
//
// Name: CanSeeEntityComplex
// Parameters: Entity *start - The entity trying to see
// Entity *target - The entity that needs to be seen
// qboolean useFOV - take FOV into consideration or not
// qboolean useVisionDistance - take visionDistance into consideration
// Description: More detailed can see check
//
qboolean SensoryPerception::CanSeeEntityComplex(Entity *start, Entity *target, qboolean useFOV, qboolean useVisionDistance )
{
// Check for NULL
if ( !start || !target )
return false;
// Check if This Actor can even see at all
if ( !ShouldRespondToStimuli( STIMULI_SIGHT ) )
return false;
if ( !act )
gi.Error( ERR_DROP, "SensoryPerception::CanSeeEntityComplex -- actor is NULL" );
// Check if target is alive
if ( !act->IsEntityAlive( target ) )
return false;
return _CanSeeComplex(start->centroid, target, useFOV, useVisionDistance );
}
//
// Name: CanSeeEntityComplex
// Parameters: Entity *start - The entity trying to see
// Entity *target - The entity that needs to be seen
// qboolean useFOV - take FOV into consideration or not
// qboolean useVisionDistance - take visionDistance into consideration
// Description: More detailed can see check
//
qboolean SensoryPerception::CanSeeEntityComplex( Vector &start, Entity *target, qboolean useFOV , qboolean useVisionDistance )
{
// Check for NULL
if ( !target )
return false;
// Check if This Actor can even see at all
if ( !ShouldRespondToStimuli( STIMULI_SIGHT ) )
return false;
if ( !act )
gi.Error( ERR_DROP, "SensoryPerception::CanSeeEntityComplex -- actor is NULL" );
// Check if target is alive
if ( !act->IsEntityAlive( target ) )
return false;
return _CanSeeComplex(start, target, useFOV, useVisionDistance );
}
qboolean SensoryPerception::CanSeePosition( const Vector &start, const Vector &position, qboolean useFOV , qboolean useVisionDistance )
{
// Check if This Actor can even see at all
if ( !ShouldRespondToStimuli( STIMULI_SIGHT ) )
return false;
// Check for FOV
if ( useFOV )
{
if ( !InFOV( position ) )
return false;
}
// Check for vision distance
if ( useVisionDistance )
{
if ( !WithinVisionDistance( position ) )
return false;
}
// Do Trace
trace_t trace;
Vector eyePos;
eyePos = vec_zero;
// Check if he's visible
trace = G_Trace( start, vec_zero, vec_zero, position, act, MASK_OPAQUE, false, "SensoryPerception::CanSeeEntity" );
if ( trace.fraction == 1.0f )
return true;
return false;
}
//
// Name: _CanSeeComplex
// Parameters: Vector &start - start position
// Vector &end - end position
// qboolean useFOV - take FOV into consideration or not
// qboolean useVisionDistance
// Description: Creates a plane to do a more complex check of vision
//
qboolean SensoryPerception::_CanSeeComplex( Vector &start, Entity *target , qboolean useFOV, qboolean useVisionDistance )
{
Vector d;
Vector p1;
Vector p2;
if ( !target )
return false;
d = target->centroid - start;
d.z = 0;
d.normalize();
p1.x = -d.y;
p1.y = d.x;
p1 *= max( act->size.x, act->size.y ) * 1.44f * 0.5f;
p2 = p1;
p1.z = act->mins.z;
p2.z = act->maxs.z;
if ( CanSeeEntity( start + p1, target , useFOV , useVisionDistance ) )
{
return true;
}
if ( CanSeeEntity( start + p2, target , useFOV , useVisionDistance ) )
{
return true;
}
p1.z = -p1.z;
p2.z = -p2.z;
if ( CanSeeEntity( start - p1, target , useFOV , useVisionDistance ) )
{
return true;
}
if ( CanSeeEntity( start - p2, target , useFOV , useVisionDistance ) )
{
return true;
}
return false;
}
//
// Name: SetNoisePosition()
// Parameters: Vector pos
// Description: Sets the _noise_position vector
//
void SensoryPerception::SetNoisePosition( const Vector &pos )
{
_noise_position = pos;
}
//
// Name: GetNoisePosition()
// Parameters: None
// Description: Returns _noise_position
//
Vector SensoryPerception::GetNoisePosition()
{
return _noise_position;
}
//
// Name: SetLastSoundType()
// Parameters: int soundtype
// Description: sets _last_soundType
//
void SensoryPerception::SetLastSoundType( int soundtype )
{
_last_soundType = soundtype;
}
//
// Name: GetLastSoundType()
// Parameters: None
// Description: returns _last_soundType
//
int SensoryPerception::GetLastSoundType()
{
return _last_soundType;
}
//
// Name: SetNoiseTime()
// Parameters: float noisetime
// Description: sets _noise_time
//
void SensoryPerception::SetNoiseTime( float noisetime )
{
_noise_time = noisetime;
}
//
// Name: GetNoiseTime()
// Parameters: None
// Description: returns _noise_time
//
float SensoryPerception::GetNoiseTime()
{
return _noise_time;
}
//
// Name: SetFOV()
// Parameters: float fov
// Description: sets _fov
//
void SensoryPerception::SetFOV( float fov )
{
_fov = fov;
}
//
// Name: GetFOV()
// Parameters: None
// Description: returns _fov
//
float SensoryPerception::GetFOV()
{
return _fov;
}
//
// Name: setFOVdot
// Parameters: float fov_dot
// Description: _fovdot
//
void SensoryPerception::SetFOVdot( float fov_dot )
{
_fovdot = fov_dot;
}
//
// Name: GetFOVdot()
// Parameters: none
// Description: returns _fovdot
//
float SensoryPerception::GetFOVdot()
{
return _fovdot;
}
//
// Name: SetVisionDistance()
// Parameters: float vision_distance
// Description: Sets _vision_distance
//
void SensoryPerception::SetVisionDistance( float vision_distance )
{
_vision_distance = vision_distance;
}
//
// Name: GetVisionDistance()
// Parameters: None
// Description: returns _vision_distance
//
float SensoryPerception::GetVisionDistance()
{
return _vision_distance;
}
//
// Name: DoArchive
// Parameters: Archiver &arc -- The archiver object
// Actor *actor -- The actor
// Description: Sets the act pointer and calls Archive
//
void SensoryPerception::DoArchive( Archiver &arc , Actor *actor )
{
Archive( arc );
if ( actor )
act = actor;
else
gi.Error( ERR_FATAL, "SensoryPerception::DoArchive -- actor is NULL" );
}
//
// Name: Archive()
// Parameters: Archiver &arc -- The archiver object
// Description: Archives the class
//
void SensoryPerception::Archive ( Archiver &arc )
{
arc.ArchiveInteger ( &_stimuli );
arc.ArchiveInteger ( &_permanent_stimuli );
arc.ArchiveVector ( &_noise_position );
arc.ArchiveInteger ( &_last_soundType );
arc.ArchiveFloat ( &_noise_time );
arc.ArchiveFloat ( &_fov );
arc.ArchiveFloat ( &_fovdot );
arc.ArchiveFloat ( &_vision_distance );
arc.ArchiveFloat ( &_nextSenseTime );
arc.ArchiveInteger( &_lineOfSight.entNum );
arc.ArchiveFloat( &_lineOfSight.time );
arc.ArchiveBoolean( &_lineOfSight.inLineOfSight );
}
Reference in New Issue View Git Blame Copy Permalink