d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
505 Commits
25 Branches
6 Tags
221 MiB
Tree: 62ad1ba047
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '62ad1ba047'
${ noResults }
source-engine/game/server/hl2/npc_basescanner.cpp

1848 lines
53 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "npcevent.h"
#include "ai_basenpc_physicsflyer.h"
#include "weapon_physcannon.h"
#include "hl2_player.h"
#include "npc_scanner.h"
#include "IEffects.h"
#include "explode.h"
#include "ai_route.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar g_debug_basescanner( "g_debug_basescanner", "0", FCVAR_CHEAT );
BEGIN_DATADESC( CNPC_BaseScanner )
DEFINE_EMBEDDED( m_KilledInfo ),
DEFINE_SOUNDPATCH( m_pEngineSound ),
DEFINE_FIELD( m_flFlyNoiseBase, FIELD_FLOAT ),
DEFINE_FIELD( m_flEngineStallTime, FIELD_TIME ),
DEFINE_FIELD( m_fNextFlySoundTime, FIELD_TIME ),
DEFINE_FIELD( m_nFlyMode, FIELD_INTEGER ),
DEFINE_FIELD( m_vecDiveBombDirection, FIELD_VECTOR ),
DEFINE_FIELD( m_flDiveBombRollForce, FIELD_FLOAT ),
// Physics Influence
DEFINE_FIELD( m_hPhysicsAttacker, FIELD_EHANDLE ),
DEFINE_FIELD( m_flLastPhysicsInfluenceTime, FIELD_TIME ),
DEFINE_FIELD( m_flGoalOverrideDistance, FIELD_FLOAT ),
DEFINE_FIELD( m_flAttackNearDist, FIELD_FLOAT ),
DEFINE_FIELD( m_flAttackFarDist, FIELD_FLOAT ),
DEFINE_FIELD( m_flAttackRange, FIELD_FLOAT ),
DEFINE_FIELD( m_nPoseTail, FIELD_INTEGER ),
DEFINE_FIELD( m_nPoseDynamo, FIELD_INTEGER ),
DEFINE_FIELD( m_nPoseFlare, FIELD_INTEGER ),
DEFINE_FIELD( m_nPoseFaceVert, FIELD_INTEGER ),
DEFINE_FIELD( m_nPoseFaceHoriz, FIELD_INTEGER ),
// DEFINE_FIELD( m_bHasSpoken, FIELD_BOOLEAN ),
DEFINE_FIELD( m_pSmokeTrail, FIELD_CLASSPTR ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetDistanceOverride", InputSetDistanceOverride ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetFlightSpeed", InputSetFlightSpeed ),
DEFINE_THINKFUNC( DiveBombSoundThink ),
END_DATADESC()
ConVar sk_scanner_dmg_dive( "sk_scanner_dmg_dive","0");
//-----------------------------------------------------------------------------
// Think contexts
//-----------------------------------------------------------------------------
static const char *s_pDiveBombSoundThinkContext = "DiveBombSoundThinkContext";
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CNPC_BaseScanner::CNPC_BaseScanner()
{
#ifdef _DEBUG
m_vCurrentBanking.Init();
#endif
m_pEngineSound = NULL;
m_bHasSpoken = false;
m_flAttackNearDist = SCANNER_ATTACK_NEAR_DIST;
m_flAttackFarDist = SCANNER_ATTACK_FAR_DIST;
m_flAttackRange = SCANNER_ATTACK_RANGE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::Spawn(void)
{
#ifdef _XBOX
// Always fade the corpse
AddSpawnFlags( SF_NPC_FADE_CORPSE );
AddEffects( EF_NOSHADOW );
#endif // _XBOX
SetHullType( HULL_TINY_CENTERED );
SetHullSizeNormal();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetMoveType( MOVETYPE_VPHYSICS );
m_bloodColor = DONT_BLEED;
SetViewOffset( Vector(0, 0, 10) ); // Position of the eyes relative to NPC's origin.
m_flFieldOfView = 0.2;
m_NPCState = NPC_STATE_NONE;
SetNavType( NAV_FLY );
AddFlag( FL_FLY );
// This entity cannot be dissolved by the combine balls,
// nor does it get killed by the mega physcannon.
AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL );
m_flGoalOverrideDistance = 0.0f;
m_nFlyMode = SCANNER_FLY_PATROL;
AngleVectors( GetLocalAngles(), &m_vCurrentBanking );
m_fHeadYaw = 0;
m_pSmokeTrail = NULL;
SetCurrentVelocity( vec3_origin );
// Noise modifier
Vector bobAmount;
bobAmount.x = random->RandomFloat( -2.0f, 2.0f );
bobAmount.y = random->RandomFloat( -2.0f, 2.0f );
bobAmount.z = random->RandomFloat( 2.0f, 4.0f );
if ( random->RandomInt( 0, 1 ) )
{
bobAmount.z *= -1.0f;
}
SetNoiseMod( bobAmount );
// set flight speed
m_flSpeed = GetMaxSpeed();
// --------------------------------------------
CapabilitiesAdd( bits_CAP_MOVE_FLY | bits_CAP_SQUAD | bits_CAP_TURN_HEAD | bits_CAP_SKIP_NAV_GROUND_CHECK );
NPCInit();
m_flFlyNoiseBase = random->RandomFloat( 0, M_PI );
m_flNextAttack = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::UpdateEfficiency( bool bInPVS )
{
SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL );
SetMoveEfficiency( AIME_NORMAL );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float CNPC_BaseScanner::GetAutoAimRadius()
{
if( g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE )
{
return 24.0f;
}
return 12.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Called just before we are deleted.
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::UpdateOnRemove( void )
{
// Stop combat loops if I'm alive. If I'm dead, the die sound will already have stopped it.
if ( IsAlive() && m_bHasSpoken )
{
SentenceStop();
}
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose: Gets the appropriate next schedule based on current condition
// bits.
//-----------------------------------------------------------------------------
int CNPC_BaseScanner::SelectSchedule(void)
{
// ----------------------------------------------------
// If I'm dead, go into a dive bomb
// ----------------------------------------------------
if ( m_iHealth <= 0 )
{
m_flSpeed = SCANNER_MAX_DIVE_BOMB_SPEED;
return SCHED_SCANNER_ATTACK_DIVEBOMB;
}
// -------------------------------
// If I'm in a script sequence
// -------------------------------
if ( m_NPCState == NPC_STATE_SCRIPT )
return(BaseClass::SelectSchedule());
// -------------------------------
// Flinch
// -------------------------------
if ( HasCondition(COND_LIGHT_DAMAGE) || HasCondition(COND_HEAVY_DAMAGE) )
{
if ( IsHeldByPhyscannon( ) )
return SCHED_SMALL_FLINCH;
if ( m_NPCState == NPC_STATE_IDLE )
return SCHED_SMALL_FLINCH;
if ( m_NPCState == NPC_STATE_ALERT )
{
if ( m_iHealth < ( 3 * m_iMaxHealth / 4 ))
return SCHED_TAKE_COVER_FROM_ORIGIN;
if ( SelectWeightedSequence( ACT_SMALL_FLINCH ) != -1 )
return SCHED_SMALL_FLINCH;
}
else
{
if ( random->RandomInt( 0, 10 ) < 4 )
return SCHED_SMALL_FLINCH;
}
}
// I'm being held by the physcannon... struggle!
if ( IsHeldByPhyscannon( ) )
return SCHED_SCANNER_HELD_BY_PHYSCANNON;
// ----------------------------------------------------------
// If I have an enemy
// ----------------------------------------------------------
if ( GetEnemy() != NULL && GetEnemy()->IsAlive() )
{
// Patrol if the enemy has vanished
if ( HasCondition( COND_LOST_ENEMY ) )
return SCHED_SCANNER_PATROL;
// Chase via route if we're directly blocked
if ( HasCondition( COND_SCANNER_FLY_BLOCKED ) )
return SCHED_SCANNER_CHASE_ENEMY;
// Attack if it's time
if ( gpGlobals->curtime >= m_flNextAttack )
{
if ( HasCondition( COND_CAN_MELEE_ATTACK1 ) )
return SCHED_SCANNER_ATTACK;
}
// Otherwise fly in low for attack
return SCHED_SCANNER_ATTACK_HOVER;
}
// Default to patrolling around
return SCHED_SCANNER_PATROL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::OnScheduleChange( void )
{
m_flSpeed = GetMaxSpeed();
BaseClass::OnScheduleChange();
}
//-----------------------------------------------------------------------------
// Purpose: For innate melee attack
//-----------------------------------------------------------------------------
int CNPC_BaseScanner::MeleeAttack1Conditions( float flDot, float flDist )
{
if (GetEnemy() == NULL)
{
return COND_NONE;
}
// Check too far to attack with 2D distance
float vEnemyDist2D = (GetEnemy()->GetLocalOrigin() - GetLocalOrigin()).Length2D();
if (m_flNextAttack > gpGlobals->curtime)
{
return COND_NONE;
}
else if (vEnemyDist2D > m_flAttackRange)
{
return COND_TOO_FAR_TO_ATTACK;
}
else if (flDot < 0.7)
{
return COND_NOT_FACING_ATTACK;
}
return COND_CAN_MELEE_ATTACK1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : eOldState -
// eNewState -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::OnStateChange( NPC_STATE eOldState, NPC_STATE eNewState )
{
if (( eNewState == NPC_STATE_ALERT ) || ( eNewState == NPC_STATE_COMBAT ))
{
SetPoseParameter(m_nPoseFlare, 1.0f);
}
else
{
SetPoseParameter(m_nPoseFlare, 0);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pTask -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::StartTask( const Task_t *pTask )
{
switch (pTask->iTask)
{
case TASK_SCANNER_SET_FLY_PATROL:
{
// Fly in patrol mode and clear any
// remaining target entity
m_nFlyMode = SCANNER_FLY_PATROL;
TaskComplete();
break;
}
case TASK_SCANNER_SET_FLY_CHASE:
{
m_nFlyMode = SCANNER_FLY_CHASE;
TaskComplete();
break;
}
case TASK_SCANNER_SET_FLY_ATTACK:
{
m_nFlyMode = SCANNER_FLY_ATTACK;
TaskComplete();
break;
}
case TASK_SCANNER_SET_FLY_DIVE:
{
// Pick a direction to divebomb.
if ( GetEnemy() != NULL )
{
// Fly towards my enemy
Vector vEnemyPos = GetEnemyLKP();
m_vecDiveBombDirection = vEnemyPos - GetLocalOrigin();
}
else
{
// Pick a random forward and down direction.
Vector forward;
GetVectors( &forward, NULL, NULL );
m_vecDiveBombDirection = forward + Vector( random->RandomFloat( -10, 10 ), random->RandomFloat( -10, 10 ), random->RandomFloat( -20, -10 ) );
}
VectorNormalize( m_vecDiveBombDirection );
// Calculate a roll force.
m_flDiveBombRollForce = random->RandomFloat( 20.0, 420.0 );
if ( random->RandomInt( 0, 1 ) )
{
m_flDiveBombRollForce *= -1;
}
DiveBombSoundThink();
m_nFlyMode = SCANNER_FLY_DIVE;
TaskComplete();
break;
}
default:
BaseClass::StartTask(pTask);
break;
}
}
//------------------------------------------------------------------------------
// Purpose: Override to split in two when attacked
//------------------------------------------------------------------------------
int CNPC_BaseScanner::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
// Start smoking when we're nearly dead
if ( m_iHealth < ( m_iMaxHealth - ( m_iMaxHealth / 4 ) ) )
{
StartSmokeTrail();
}
return (BaseClass::OnTakeDamage_Alive( info ));
}
//------------------------------------------------------------------------------
// Purpose: Override to split in two when attacked
//------------------------------------------------------------------------------
int CNPC_BaseScanner::OnTakeDamage_Dying( const CTakeDamageInfo &info )
{
// do the damage
m_iHealth -= info.GetDamage();
if ( m_iHealth < -40 )
{
Gib();
return 1;
}
return VPhysicsTakeDamage( info );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{
if ( info.GetDamageType() & DMG_BULLET)
{
g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal);
}
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
}
//-----------------------------------------------------------------------------
// Take damage from being thrown by a physcannon
//-----------------------------------------------------------------------------
#define SCANNER_SMASH_SPEED 250.0 // How fast a scanner must slam into something to take full damage
void CNPC_BaseScanner::TakeDamageFromPhyscannon( CBasePlayer *pPlayer )
{
CTakeDamageInfo info;
info.SetDamageType( DMG_GENERIC );
info.SetInflictor( this );
info.SetAttacker( pPlayer );
info.SetDamagePosition( GetAbsOrigin() );
info.SetDamageForce( Vector( 1.0, 1.0, 1.0 ) );
// Convert velocity into damage.
Vector vel;
VPhysicsGetObject()->GetVelocity( &vel, NULL );
float flSpeed = vel.Length();
float flFactor = flSpeed / SCANNER_SMASH_SPEED;
// Clamp. Don't inflict negative damage or massive damage!
flFactor = clamp( flFactor, 0.0f, 2.0f );
float flDamage = m_iMaxHealth * flFactor;
#if 0
Msg("Doing %f damage for %f speed!\n", flDamage, flSpeed );
#endif
info.SetDamage( flDamage );
TakeDamage( info );
}
//-----------------------------------------------------------------------------
// Take damage from physics impacts
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::TakeDamageFromPhysicsImpact( int index, gamevcollisionevent_t *pEvent )
{
CBaseEntity *pHitEntity = pEvent->pEntities[!index];
// NOTE: Augment the normal impact energy scale here.
float flDamageScale = PlayerHasMegaPhysCannon() ? 10.0f : 5.0f;
// Scale by the mapmaker's energyscale
flDamageScale *= m_impactEnergyScale;
int damageType = 0;
float damage = CalculateDefaultPhysicsDamage( index, pEvent, flDamageScale, true, damageType );
if ( damage == 0 )
return;
Vector damagePos;
pEvent->pInternalData->GetContactPoint( damagePos );
Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();
if ( damageForce == vec3_origin )
{
// This can happen if this entity is motion disabled, and can't move.
// Use the velocity of the entity that hit us instead.
damageForce = pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass();
}
// FIXME: this doesn't pass in who is responsible if some other entity "caused" this collision
PhysCallbackDamage( this, CTakeDamageInfo( pHitEntity, pHitEntity, damageForce, damagePos, damage, damageType ), *pEvent, index );
}
//-----------------------------------------------------------------------------
// Is the scanner being held?
//-----------------------------------------------------------------------------
bool CNPC_BaseScanner::IsHeldByPhyscannon( )
{
return VPhysicsGetObject() && (VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD);
}
//------------------------------------------------------------------------------
// Physics impact
//------------------------------------------------------------------------------
#define SCANNER_SMASH_TIME 0.75 // How long after being thrown from a physcannon that a manhack is eligible to die from impact
void CNPC_BaseScanner::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
BaseClass::VPhysicsCollision( index, pEvent );
// Take no impact damage while being carried.
if ( IsHeldByPhyscannon( ) )
return;
CBasePlayer *pPlayer = HasPhysicsAttacker( SCANNER_SMASH_TIME );
if( pPlayer )
{
TakeDamageFromPhyscannon( pPlayer );
return;
}
// It also can take physics damage from things thrown by the player.
int otherIndex = !index;
CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];
if ( pHitEntity )
{
if ( pHitEntity->HasPhysicsAttacker( 0.5f ) )
{
// It can take physics damage from things thrown by the player.
TakeDamageFromPhysicsImpact( index, pEvent );
}
else if ( FClassnameIs( pHitEntity, "prop_combine_ball" ) )
{
// It also can take physics damage from a combine ball.
TakeDamageFromPhysicsImpact( index, pEvent );
}
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CNPC_BaseScanner::Gib( void )
{
if ( IsMarkedForDeletion() )
return;
// Sparks
for ( int i = 0; i < 4; i++ )
{
Vector sparkPos = GetAbsOrigin();
sparkPos.x += random->RandomFloat(-12,12);
sparkPos.y += random->RandomFloat(-12,12);
sparkPos.z += random->RandomFloat(-12,12);
g_pEffects->Sparks(sparkPos);
}
// Light
CBroadcastRecipientFilter filter;
te->DynamicLight( filter, 0.0, &WorldSpaceCenter(), 255, 180, 100, 0, 100, 0.1, 0 );
// Cover the gib spawn
ExplosionCreate( WorldSpaceCenter(), GetAbsAngles(), this, 64, 64, false );
// Turn off any smoke trail
if ( m_pSmokeTrail )
{
m_pSmokeTrail->m_ParticleLifetime = 0;
UTIL_Remove(m_pSmokeTrail);
m_pSmokeTrail = NULL;
}
// FIXME: This is because we couldn't save/load the CTakeDamageInfo.
// because it's midnight before the teamwide playtest. Real solution
// is to add a datadesc to CTakeDamageInfo
if ( m_KilledInfo.GetInflictor() )
{
BaseClass::Event_Killed( m_KilledInfo );
}
UTIL_Remove(this);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPhysGunUser -
// bPunting -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
{
m_hPhysicsAttacker = pPhysGunUser;
m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
if ( reason == PUNTED_BY_CANNON )
{
// There's about to be a massive change in velocity.
// Think immediately to handle changes in m_vCurrentVelocity;
SetNextThink( gpGlobals->curtime + 0.01f );
m_flEngineStallTime = gpGlobals->curtime + 2.0f;
ScannerEmitSound( "DiveBomb" );
}
else
{
SetCondition( COND_SCANNER_GRABBED_BY_PHYSCANNON );
ClearCondition( COND_SCANNER_RELEASED_FROM_PHYSCANNON );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPhysGunUser -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
{
m_hPhysicsAttacker = pPhysGunUser;
m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
ClearCondition( COND_SCANNER_GRABBED_BY_PHYSCANNON );
SetCondition( COND_SCANNER_RELEASED_FROM_PHYSCANNON );
if ( Reason == LAUNCHED_BY_CANNON )
{
m_flEngineStallTime = gpGlobals->curtime + 2.0f;
// There's about to be a massive change in velocity.
// Think immediately to handle changes in m_vCurrentVelocity;
SetNextThink( gpGlobals->curtime + 0.01f );
ScannerEmitSound( "DiveBomb" );
}
}
//------------------------------------------------------------------------------
// Do we have a physics attacker?
//------------------------------------------------------------------------------
CBasePlayer *CNPC_BaseScanner::HasPhysicsAttacker( float dt )
{
// If the player is holding me now, or I've been recently thrown
// then return a pointer to that player
if ( IsHeldByPhyscannon( ) || (gpGlobals->curtime - dt <= m_flLastPhysicsInfluenceTime) )
{
return m_hPhysicsAttacker;
}
return NULL;
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CNPC_BaseScanner::StopLoopingSounds(void)
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundDestroy( m_pEngineSound );
m_pEngineSound = NULL;
BaseClass::StopLoopingSounds();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pInflictor -
// pAttacker -
// flDamage -
// bitsDamageType -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::Event_Killed( const CTakeDamageInfo &info )
{
// Copy off the takedamage info that killed me, since we're not going to call
// up into the base class's Event_Killed() until we gib. (gibbing is ultimate death)
m_KilledInfo = info;
// Interrupt whatever schedule I'm on
SetCondition(COND_SCHEDULE_DONE);
// If I have an enemy and I'm up high, do a dive bomb (unless dissolved)
if ( GetEnemy() != NULL && (info.GetDamageType() & DMG_DISSOLVE) == false )
{
Vector vecDelta = GetLocalOrigin() - GetEnemy()->GetLocalOrigin();
if ( ( vecDelta.z > 120 ) && ( vecDelta.Length() > 360 ) )
{
// If I'm divebombing, don't take any more damage. It will make Event_Killed() be called again.
// This is especially bad if someone machineguns the divebombing scanner.
AttackDivebomb();
return;
}
}
Gib();
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CNPC_BaseScanner::AttackDivebomb( void )
{
ScannerEmitSound( "DiveBomb" );
m_takedamage = DAMAGE_NO;
StartSmokeTrail();
}
//------------------------------------------------------------------------------
// Purpose: Checks to see if we hit anything while dive bombing.
//------------------------------------------------------------------------------
void CNPC_BaseScanner::AttackDivebombCollide(float flInterval)
{
//
// Trace forward to see if I hit anything
//
Vector checkPos = GetAbsOrigin() + (GetCurrentVelocity() * flInterval);
trace_t tr;
CBaseEntity* pHitEntity = NULL;
AI_TraceHull( GetAbsOrigin(), checkPos, GetHullMins(), GetHullMaxs(), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if (tr.m_pEnt)
{
pHitEntity = tr.m_pEnt;
// Did I hit an entity that isn't another scanner?
if (pHitEntity && pHitEntity->Classify()!=CLASS_SCANNER)
{
if ( !pHitEntity->ClassMatches("item_battery") )
{
if ( !pHitEntity->IsWorld() )
{
CTakeDamageInfo info( this, this, sk_scanner_dmg_dive.GetFloat(), DMG_CLUB );
CalculateMeleeDamageForce( &info, (tr.endpos - tr.startpos), tr.endpos );
pHitEntity->TakeDamage( info );
}
Gib();
}
}
}
if (tr.fraction != 1.0)
{
// We've hit something so deflect our velocity based on the surface
// norm of what we've hit
if (flInterval > 0)
{
float moveLen = (1.0 - tr.fraction)*(GetAbsOrigin() - checkPos).Length();
Vector vBounceVel = moveLen*tr.plane.normal/flInterval;
// If I'm right over the ground don't push down
if (vBounceVel.z < 0)
{
float floorZ = GetFloorZ(GetAbsOrigin());
if (abs(GetAbsOrigin().z - floorZ) < 36)
{
vBounceVel.z = 0;
}
}
SetCurrentVelocity( GetCurrentVelocity() + vBounceVel );
}
CBaseCombatCharacter* pBCC = ToBaseCombatCharacter( pHitEntity );
if (pBCC)
{
// Spawn some extra blood where we hit
SpawnBlood(tr.endpos, g_vecAttackDir, pBCC->BloodColor(), sk_scanner_dmg_dive.GetFloat());
}
else
{
if (!(m_spawnflags & SF_NPC_GAG))
{
// <<TEMP>> need better sound here...
ScannerEmitSound( "Shoot" );
}
// For sparks we must trace a line in the direction of the surface norm
// that we hit.
checkPos = GetAbsOrigin() - (tr.plane.normal * 24);
AI_TraceLine( GetAbsOrigin(), checkPos,MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
if (tr.fraction != 1.0)
{
g_pEffects->Sparks( tr.endpos );
CBroadcastRecipientFilter filter;
te->DynamicLight( filter, 0.0,
&GetAbsOrigin(), 255, 180, 100, 0, 50, 0.1, 0 );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::PlayFlySound(void)
{
if ( IsMarkedForDeletion() )
return;
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
//Setup the sound if we're not already
if ( m_pEngineSound == NULL )
{
// Create the sound
CPASAttenuationFilter filter( this );
m_pEngineSound = controller.SoundCreate( filter, entindex(), CHAN_STATIC, GetEngineSound(), ATTN_NORM );
Assert(m_pEngineSound);
// Start the engine sound
controller.Play( m_pEngineSound, 0.0f, 100.0f );
controller.SoundChangeVolume( m_pEngineSound, 1.0f, 2.0f );
}
float speed = GetCurrentVelocity().Length();
float flVolume = 0.25f + (0.75f*(speed/GetMaxSpeed()));
int iPitch = MIN( 255, 80 + (20*(speed/GetMaxSpeed())) );
//Update our pitch and volume based on our speed
controller.SoundChangePitch( m_pEngineSound, iPitch, 0.1f );
controller.SoundChangeVolume( m_pEngineSound, flVolume, 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::ScannerEmitSound( const char *pszSoundName )
{
CFmtStr snd;
snd.sprintf("%s.%s", GetScannerSoundPrefix(), pszSoundName );
m_bHasSpoken = true;
EmitSound( snd.Access() );
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CNPC_BaseScanner::SpeakSentence( int sentenceType )
{
if (sentenceType == SCANNER_SENTENCE_ATTENTION)
{
ScannerEmitSound( "Attention" );
}
else if (sentenceType == SCANNER_SENTENCE_HANDSUP)
{
ScannerEmitSound( "Scan" );
}
else if (sentenceType == SCANNER_SENTENCE_PROCEED)
{
ScannerEmitSound( "Proceed" );
}
else if (sentenceType == SCANNER_SENTENCE_CURIOUS)
{
ScannerEmitSound( "Curious" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::InputSetFlightSpeed(inputdata_t &inputdata)
{
//FIXME: Currently unsupported
/*
m_flFlightSpeed = inputdata.value.Int();
m_bFlightSpeedOverridden = (m_flFlightSpeed > 0);
*/
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::StartSmokeTrail( void )
{
if ( m_pSmokeTrail != NULL )
return;
m_pSmokeTrail = SmokeTrail::CreateSmokeTrail();
if ( m_pSmokeTrail )
{
m_pSmokeTrail->m_SpawnRate = 10;
m_pSmokeTrail->m_ParticleLifetime = 1;
m_pSmokeTrail->m_StartSize = 8;
m_pSmokeTrail->m_EndSize = 50;
m_pSmokeTrail->m_SpawnRadius = 10;
m_pSmokeTrail->m_MinSpeed = 15;
m_pSmokeTrail->m_MaxSpeed = 25;
m_pSmokeTrail->m_StartColor.Init( 0.5f, 0.5f, 0.5f );
m_pSmokeTrail->m_EndColor.Init( 0, 0, 0 );
m_pSmokeTrail->SetLifetime( 500.0f );
m_pSmokeTrail->FollowEntity( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::BlendPhyscannonLaunchSpeed()
{
// Blend out desired velocity when launched by the physcannon
if (!VPhysicsGetObject())
return;
if ( HasPhysicsAttacker( SCANNER_SMASH_TIME ) && !IsHeldByPhyscannon( ) )
{
Vector vecCurrentVelocity;
VPhysicsGetObject()->GetVelocity( &vecCurrentVelocity, NULL );
float flLerpFactor = (gpGlobals->curtime - m_flLastPhysicsInfluenceTime) / SCANNER_SMASH_TIME;
flLerpFactor = clamp( flLerpFactor, 0.0f, 1.0f );
flLerpFactor = SimpleSplineRemapVal( flLerpFactor, 0.0f, 1.0f, 0.0f, 1.0f );
flLerpFactor *= flLerpFactor;
VectorLerp( vecCurrentVelocity, m_vCurrentVelocity, flLerpFactor, m_vCurrentVelocity );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::MoveExecute_Alive(float flInterval)
{
// Amount of noise to add to flying
float noiseScale = 3.0f;
// -------------------------------------------
// Avoid obstacles, unless I'm dive bombing
// -------------------------------------------
if (m_nFlyMode != SCANNER_FLY_DIVE)
{
SetCurrentVelocity( GetCurrentVelocity() + VelocityToAvoidObstacles(flInterval) );
}
// If I am dive bombing add more noise to my flying
else
{
AttackDivebombCollide(flInterval);
noiseScale *= 4;
}
IPhysicsObject *pPhysics = VPhysicsGetObject();
if ( pPhysics && pPhysics->IsAsleep() )
{
pPhysics->Wake();
}
// Add time-coherent noise to the current velocity so that it never looks bolted in place.
AddNoiseToVelocity( noiseScale );
AdjustScannerVelocity();
float maxSpeed = GetEnemy() ? ( GetMaxSpeed() * 2.0f ) : GetMaxSpeed();
if ( m_nFlyMode == SCANNER_FLY_DIVE )
{
maxSpeed = -1;
}
// Limit fall speed
LimitSpeed( maxSpeed );
// Blend out desired velocity when launched by the physcannon
BlendPhyscannonLaunchSpeed();
// Update what we're looking at
UpdateHead( flInterval );
// Control the tail based on our vertical travel
float tailPerc = clamp( GetCurrentVelocity().z, -150, 250 );
tailPerc = SimpleSplineRemapVal( tailPerc, -150, 250, -25, 80 );
SetPoseParameter( m_nPoseTail, tailPerc );
// Spin the dynamo based upon our speed
float flCurrentDynamo = GetPoseParameter( m_nPoseDynamo );
float speed = GetCurrentVelocity().Length();
float flDynamoSpeed = (maxSpeed > 0 ? speed / maxSpeed : 1.0) * 60;
flCurrentDynamo -= flDynamoSpeed;
if ( flCurrentDynamo < -180.0 )
{
flCurrentDynamo += 360.0;
}
SetPoseParameter( m_nPoseDynamo, flCurrentDynamo );
PlayFlySound();
}
//-----------------------------------------------------------------------------
// Purpose: Handles movement towards the last move target.
// Input : flInterval -
//-----------------------------------------------------------------------------
bool CNPC_BaseScanner::OverridePathMove( CBaseEntity *pMoveTarget, float flInterval )
{
// Save our last patrolling direction
Vector lastPatrolDir = GetNavigator()->GetCurWaypointPos() - GetAbsOrigin();
// Continue on our path
if ( ProgressFlyPath( flInterval, pMoveTarget, (MASK_NPCSOLID|CONTENTS_WATER), false, 64 ) == AINPP_COMPLETE )
{
if ( IsCurSchedule( SCHED_SCANNER_PATROL ) )
{
m_vLastPatrolDir = lastPatrolDir;
VectorNormalize(m_vLastPatrolDir);
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_BaseScanner::OverrideMove( float flInterval )
{
// ----------------------------------------------
// If dive bombing
// ----------------------------------------------
if (m_nFlyMode == SCANNER_FLY_DIVE)
{
MoveToDivebomb( flInterval );
}
else
{
Vector vMoveTargetPos(0,0,0);
CBaseEntity *pMoveTarget = NULL;
// The original line of code was, due to the accidental use of '|' instead of
// '&', always true. Replacing with 'true' to suppress the warning without changing
// the (long-standing) behavior.
if ( true ) //!GetNavigator()->IsGoalActive() || ( GetNavigator()->GetCurWaypointFlags() | bits_WP_TO_PATHCORNER ) )
{
// Select move target
if ( GetTarget() != NULL )
{
pMoveTarget = GetTarget();
}
else if ( GetEnemy() != NULL )
{
pMoveTarget = GetEnemy();
}
// Select move target position
if ( GetEnemy() != NULL )
{
vMoveTargetPos = GetEnemy()->GetAbsOrigin();
}
}
else
{
vMoveTargetPos = GetNavigator()->GetCurWaypointPos();
}
ClearCondition( COND_SCANNER_FLY_CLEAR );
ClearCondition( COND_SCANNER_FLY_BLOCKED );
// See if we can fly there directly
if ( pMoveTarget )
{
trace_t tr;
AI_TraceHull( GetAbsOrigin(), vMoveTargetPos, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
float fTargetDist = (1.0f-tr.fraction)*(GetAbsOrigin() - vMoveTargetPos).Length();
if ( ( tr.m_pEnt == pMoveTarget ) || ( fTargetDist < 50 ) )
{
if ( g_debug_basescanner.GetBool() )
{
NDebugOverlay::Line(GetLocalOrigin(), vMoveTargetPos, 0,255,0, true, 0);
NDebugOverlay::Cross3D(tr.endpos,Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1);
}
SetCondition( COND_SCANNER_FLY_CLEAR );
}
else
{
//HANDY DEBUG TOOL
if ( g_debug_basescanner.GetBool() )
{
NDebugOverlay::Line(GetLocalOrigin(), vMoveTargetPos, 255,0,0, true, 0);
NDebugOverlay::Cross3D(tr.endpos,Vector(-5,-5,-5),Vector(5,5,5),255,0,0,true,0.1);
}
SetCondition( COND_SCANNER_FLY_BLOCKED );
}
}
// If I have a route, keep it updated and move toward target
if ( GetNavigator()->IsGoalActive() )
{
if ( OverridePathMove( pMoveTarget, flInterval ) )
{
BlendPhyscannonLaunchSpeed();
return true;
}
}
// ----------------------------------------------
// If attacking
// ----------------------------------------------
else if (m_nFlyMode == SCANNER_FLY_ATTACK)
{
MoveToAttack( flInterval );
}
// -----------------------------------------------------------------
// If I don't have a route, just decelerate
// -----------------------------------------------------------------
else if (!GetNavigator()->IsGoalActive())
{
float myDecay = 9.5;
Decelerate( flInterval, myDecay);
}
}
MoveExecute_Alive( flInterval );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &goalPos -
// &startPos -
// idealRange -
// idealHeight -
// Output : Vector
//-----------------------------------------------------------------------------
Vector CNPC_BaseScanner::IdealGoalForMovement( const Vector &goalPos, const Vector &startPos, float idealRange, float idealHeightDiff )
{
Vector vMoveDir;
if ( GetGoalDirection( &vMoveDir ) == false )
{
vMoveDir = ( goalPos - startPos );
vMoveDir.z = 0;
VectorNormalize( vMoveDir );
}
// Move up from the position by the desired amount
Vector vIdealPos = goalPos + Vector( 0, 0, idealHeightDiff ) + ( vMoveDir * -idealRange );
// Trace down and make sure we can fit here
trace_t tr;
AI_TraceHull( vIdealPos, vIdealPos - Vector( 0, 0, MinGroundDist() ), GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
// Move up otherwise
if ( tr.fraction < 1.0f )
{
vIdealPos.z += ( MinGroundDist() * ( 1.0f - tr.fraction ) );
}
//FIXME: We also need to make sure that we fit here at all, and if not, chose a new spot
// Debug tools
if ( g_debug_basescanner.GetBool() )
{
NDebugOverlay::Cross3D( goalPos, -Vector(8,8,8), Vector(8,8,8), 255, 255, 0, true, 0.1f );
NDebugOverlay::Cross3D( startPos, -Vector(8,8,8), Vector(8,8,8), 255, 0, 255, true, 0.1f );
NDebugOverlay::Cross3D( vIdealPos, -Vector(8,8,8), Vector(8,8,8), 255, 255, 255, true, 0.1f );
NDebugOverlay::Line( startPos, goalPos, 0, 255, 0, true, 0.1f );
NDebugOverlay::Cross3D( goalPos + ( vMoveDir * -idealRange ), -Vector(8,8,8), Vector(8,8,8), 255, 255, 255, true, 0.1f );
NDebugOverlay::Line( goalPos, goalPos + ( vMoveDir * -idealRange ), 255, 255, 0, true, 0.1f );
NDebugOverlay::Line( goalPos + ( vMoveDir * -idealRange ), vIdealPos, 255, 255, 0, true, 0.1f );
}
return vIdealPos;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::MoveToAttack(float flInterval)
{
if (GetEnemy() == NULL)
return;
if ( flInterval <= 0 )
return;
Vector vTargetPos = GetEnemyLKP();
//float flDesiredDist = m_flAttackNearDist + ( ( m_flAttackFarDist - m_flAttackNearDist ) / 2 );
Vector idealPos = IdealGoalForMovement( vTargetPos, GetAbsOrigin(), GetGoalDistance(), m_flAttackNearDist );
MoveToTarget( flInterval, idealPos );
//FIXME: Re-implement?
/*
// ---------------------------------------------------------
// Add evasion if I have taken damage recently
// ---------------------------------------------------------
if ((m_flLastDamageTime + SCANNER_EVADE_TIME) > gpGlobals->curtime)
{
vFlyDirection = vFlyDirection + VelocityToEvade(GetEnemyCombatCharacterPointer());
}
*/
}
//-----------------------------------------------------------------------------
// Purpose: Accelerates toward a given position.
// Input : flInterval - Time interval over which to move.
// vecMoveTarget - Position to move toward.
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::MoveToTarget( float flInterval, const Vector &vecMoveTarget )
{
// Don't move if stalling
if ( m_flEngineStallTime > gpGlobals->curtime )
return;
// Look at our inspection target if we have one
if ( GetEnemy() != NULL )
{
// Otherwise at our enemy
TurnHeadToTarget( flInterval, GetEnemy()->EyePosition() );
}
else
{
// Otherwise face our motion direction
TurnHeadToTarget( flInterval, vecMoveTarget );
}
// -------------------------------------
// Move towards our target
// -------------------------------------
float myAccel;
float myZAccel = 400.0f;
float myDecay = 0.15f;
Vector vecCurrentDir;
// Get the relationship between my current velocity and the way I want to be going.
vecCurrentDir = GetCurrentVelocity();
VectorNormalize( vecCurrentDir );
Vector targetDir = vecMoveTarget - GetAbsOrigin();
float flDist = VectorNormalize(targetDir);
float flDot;
flDot = DotProduct( targetDir, vecCurrentDir );
if( flDot > 0.25 )
{
// If my target is in front of me, my flight model is a bit more accurate.
myAccel = 250;
}
else
{
// Have a harder time correcting my course if I'm currently flying away from my target.
myAccel = 128;
}
if ( myAccel > flDist / flInterval )
{
myAccel = flDist / flInterval;
}
if ( myZAccel > flDist / flInterval )
{
myZAccel = flDist / flInterval;
}
MoveInDirection( flInterval, targetDir, myAccel, myZAccel, myDecay );
// calc relative banking targets
Vector forward, right, up;
GetVectors( &forward, &right, &up );
m_vCurrentBanking.x = targetDir.x;
m_vCurrentBanking.z = 120.0f * DotProduct( right, targetDir );
m_vCurrentBanking.y = 0;
float speedPerc = SimpleSplineRemapVal( GetCurrentVelocity().Length(), 0.0f, GetMaxSpeed(), 0.0f, 1.0f );
speedPerc = clamp( speedPerc, 0.0f, 1.0f );
m_vCurrentBanking *= speedPerc;
}
//-----------------------------------------------------------------------------
// Danger sounds.
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::DiveBombSoundThink()
{
Vector vecPosition, vecVelocity;
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject == NULL )
return;
pPhysicsObject->GetPosition( &vecPosition, NULL );
pPhysicsObject->GetVelocity( &vecVelocity, NULL );
CBasePlayer *pPlayer = AI_GetSinglePlayer();
if ( pPlayer )
{
Vector vecDelta;
VectorSubtract( pPlayer->GetAbsOrigin(), vecPosition, vecDelta );
VectorNormalize( vecDelta );
if ( DotProduct( vecDelta, vecVelocity ) > 0.5f )
{
Vector vecEndPoint;
VectorMA( vecPosition, 2.0f * TICK_INTERVAL, vecVelocity, vecEndPoint );
float flDist = CalcDistanceToLineSegment( pPlayer->GetAbsOrigin(), vecPosition, vecEndPoint );
if ( flDist < 200.0f )
{
ScannerEmitSound( "DiveBombFlyby" );
SetContextThink( &CNPC_BaseScanner::DiveBombSoundThink, gpGlobals->curtime + 0.5f, s_pDiveBombSoundThinkContext );
return;
}
}
}
SetContextThink( &CNPC_BaseScanner::DiveBombSoundThink, gpGlobals->curtime + 2.0f * TICK_INTERVAL, s_pDiveBombSoundThinkContext );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::MoveToDivebomb(float flInterval)
{
float myAccel = 1600;
float myDecay = 0.05f; // decay current velocity to 10% in 1 second
// Fly towards my enemy
Vector vEnemyPos = GetEnemyLKP();
Vector vFlyDirection = vEnemyPos - GetLocalOrigin();
VectorNormalize( vFlyDirection );
// Set net velocity
MoveInDirection( flInterval, m_vecDiveBombDirection, myAccel, myAccel, myDecay);
// Spin out of control.
Vector forward;
VPhysicsGetObject()->LocalToWorldVector( &forward, Vector( 1.0, 0.0, 0.0 ) );
AngularImpulse torque = forward * m_flDiveBombRollForce;
VPhysicsGetObject()->ApplyTorqueCenter( torque );
// BUGBUG: why Y axis and not Z?
Vector up;
VPhysicsGetObject()->LocalToWorldVector( &up, Vector( 0.0, 1.0, 0.0 ) );
VPhysicsGetObject()->ApplyForceCenter( up * 2000 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CNPC_BaseScanner::IsEnemyPlayerInSuit()
{
if( GetEnemy() && GetEnemy()->IsPlayer() )
{
CHL2_Player *pPlayer = NULL;
pPlayer = (CHL2_Player *)GetEnemy();
if( pPlayer && pPlayer->IsSuitEquipped() )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CNPC_BaseScanner::GetGoalDistance( void )
{
if ( m_flGoalOverrideDistance != 0.0f )
return m_flGoalOverrideDistance;
switch ( m_nFlyMode )
{
case SCANNER_FLY_ATTACK:
{
float goalDist = ( m_flAttackNearDist + ( ( m_flAttackFarDist - m_flAttackNearDist ) / 2 ) );
if( IsEnemyPlayerInSuit() )
{
goalDist *= 0.5;
}
return goalDist;
}
break;
}
return 128.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &vOut -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_BaseScanner::GetGoalDirection( Vector *vOut )
{
CBaseEntity *pTarget = GetTarget();
if ( pTarget == NULL )
return false;
if ( FClassnameIs( pTarget, "info_hint_air" ) || FClassnameIs( pTarget, "info_target" ) )
{
AngleVectors( pTarget->GetAbsAngles(), vOut );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Vector CNPC_BaseScanner::VelocityToEvade(CBaseCombatCharacter *pEnemy)
{
if (pEnemy)
{
// -----------------------------------------
// Keep out of enemy's shooting position
// -----------------------------------------
Vector vEnemyFacing = pEnemy->BodyDirection2D( );
Vector vEnemyDir = pEnemy->EyePosition() - GetLocalOrigin();
VectorNormalize(vEnemyDir);
float fDotPr = DotProduct(vEnemyFacing,vEnemyDir);
if (fDotPr < -0.9)
{
Vector vDirUp(0,0,1);
Vector vDir;
CrossProduct( vEnemyFacing, vDirUp, vDir);
Vector crossProduct;
CrossProduct(vEnemyFacing, vEnemyDir, crossProduct);
if (crossProduct.y < 0)
{
vDir = vDir * -1;
}
return (vDir);
}
else if (fDotPr < -0.85)
{
Vector vDirUp(0,0,1);
Vector vDir;
CrossProduct( vEnemyFacing, vDirUp, vDir);
Vector crossProduct;
CrossProduct(vEnemyFacing, vEnemyDir, crossProduct);
if (random->RandomInt(0,1))
{
vDir = vDir * -1;
}
return (vDir);
}
}
return vec3_origin;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_BaseScanner::DrawDebugTextOverlays(void)
{
int nOffset = BaseClass::DrawDebugTextOverlays();
if ( m_debugOverlays & OVERLAY_TEXT_BIT )
{
Vector vel;
GetVelocity( &vel, NULL );
char tempstr[512];
Q_snprintf( tempstr, sizeof(tempstr), "speed (max): %.2f (%.2f)", vel.Length(), m_flSpeed );
EntityText( nOffset, tempstr, 0 );
nOffset++;
}
return nOffset;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CNPC_BaseScanner::GetHeadTurnRate( void )
{
if ( GetEnemy() )
return 800.0f;
return 350.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
inline CBaseEntity *CNPC_BaseScanner::EntityToWatch( void )
{
return ( GetTarget() != NULL ) ? GetTarget() : GetEnemy(); // Okay if NULL
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::UpdateHead( float flInterval )
{
float yaw = GetPoseParameter( m_nPoseFaceHoriz );
float pitch = GetPoseParameter( m_nPoseFaceVert );
CBaseEntity *pTarget = EntityToWatch();
Vector vLookPos;
if ( !HasCondition( COND_IN_PVS ) || GetAttachment( "eyes", vLookPos ) == false )
{
vLookPos = EyePosition();
}
if ( pTarget != NULL )
{
Vector lookDir = pTarget->EyePosition() - vLookPos;
VectorNormalize( lookDir );
if ( DotProduct( lookDir, BodyDirection3D() ) < 0.0f )
{
SetPoseParameter( m_nPoseFaceHoriz, UTIL_Approach( 0, yaw, 10 ) );
SetPoseParameter( m_nPoseFaceVert, UTIL_Approach( 0, pitch, 10 ) );
return;
}
float facingYaw = VecToYaw( BodyDirection3D() );
float yawDiff = VecToYaw( lookDir );
yawDiff = UTIL_AngleDiff( yawDiff, facingYaw + yaw );
float facingPitch = UTIL_VecToPitch( BodyDirection3D() );
float pitchDiff = UTIL_VecToPitch( lookDir );
pitchDiff = UTIL_AngleDiff( pitchDiff, facingPitch + pitch );
SetPoseParameter( m_nPoseFaceHoriz, UTIL_Approach( yaw + yawDiff, yaw, 50 ) );
SetPoseParameter( m_nPoseFaceVert, UTIL_Approach( pitch + pitchDiff, pitch, 50 ) );
}
else
{
SetPoseParameter( m_nPoseFaceHoriz, UTIL_Approach( 0, yaw, 10 ) );
SetPoseParameter( m_nPoseFaceVert, UTIL_Approach( 0, pitch, 10 ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &linear -
// &angular -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::ClampMotorForces( Vector &linear, AngularImpulse &angular )
{
// limit reaction forces
if ( m_nFlyMode != SCANNER_FLY_DIVE )
{
linear.x = clamp( linear.x, -500, 500 );
linear.y = clamp( linear.y, -500, 500 );
linear.z = clamp( linear.z, -500, 500 );
}
// If we're dive bombing, we need to drop faster than normal
if ( m_nFlyMode != SCANNER_FLY_DIVE )
{
// Add in weightlessness
linear.z += 800;
}
angular.z = clamp( angular.z, -GetHeadTurnRate(), GetHeadTurnRate() );
if ( m_nFlyMode == SCANNER_FLY_DIVE )
{
// Disable pitch and roll motors while crashing.
angular.x = 0;
angular.y = 0;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::InputSetDistanceOverride( inputdata_t &inputdata )
{
m_flGoalOverrideDistance = inputdata.value.Float();
}
//-----------------------------------------------------------------------------
// Purpose: Emit sounds specific to the NPC's state.
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::AlertSound(void)
{
ScannerEmitSound( "Alert" );
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CNPC_BaseScanner::DeathSound( const CTakeDamageInfo &info )
{
ScannerEmitSound( "Die" );
}
//-----------------------------------------------------------------------------
// Purpose: Overridden so that scanners play battle sounds while fighting.
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
bool CNPC_BaseScanner::ShouldPlayIdleSound( void )
{
if ( HasSpawnFlags( SF_NPC_GAG ) )
return false;
if ( random->RandomInt( 0, 25 ) != 0 )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Plays sounds while idle or in combat.
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::IdleSound(void)
{
if ( m_NPCState == NPC_STATE_COMBAT )
{
// dvs: the combat sounds should be related to what is happening, rather than random
ScannerEmitSound( "Combat" );
}
else
{
ScannerEmitSound( "Idle" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Plays a sound when hurt.
//-----------------------------------------------------------------------------
void CNPC_BaseScanner::PainSound( const CTakeDamageInfo &info )
{
ScannerEmitSound( "Pain" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CNPC_BaseScanner::GetMaxSpeed()
{
return SCANNER_MAX_SPEED;
}
//-----------------------------------------------------------------------------
//
// Schedules
//
//-----------------------------------------------------------------------------
AI_BEGIN_CUSTOM_NPC( npc_basescanner, CNPC_BaseScanner )
DECLARE_TASK( TASK_SCANNER_SET_FLY_PATROL )
DECLARE_TASK( TASK_SCANNER_SET_FLY_CHASE )
DECLARE_TASK( TASK_SCANNER_SET_FLY_ATTACK )
DECLARE_TASK( TASK_SCANNER_SET_FLY_DIVE )
DECLARE_CONDITION(COND_SCANNER_FLY_CLEAR)
DECLARE_CONDITION(COND_SCANNER_FLY_BLOCKED)
DECLARE_CONDITION(COND_SCANNER_RELEASED_FROM_PHYSCANNON)
DECLARE_CONDITION(COND_SCANNER_GRABBED_BY_PHYSCANNON)
//=========================================================
// > SCHED_SCANNER_PATROL
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_PATROL,
" Tasks"
" TASK_SCANNER_SET_FLY_PATROL 0"
" TASK_SET_TOLERANCE_DISTANCE 32"
" TASK_SET_ROUTE_SEARCH_TIME 5" // Spend 5 seconds trying to build a path if stuck
" TASK_GET_PATH_TO_RANDOM_NODE 2000"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_GIVE_WAY"
" COND_NEW_ENEMY"
" COND_SEE_ENEMY"
" COND_SEE_FEAR"
" COND_HEAR_COMBAT"
" COND_HEAR_DANGER"
" COND_HEAR_PLAYER"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_PROVOKED"
" COND_SCANNER_GRABBED_BY_PHYSCANNON"
)
//=========================================================
// > SCHED_SCANNER_ATTACK
//
// This task does nothing. Translate it in your derived
// class to perform your attack.
//
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_ATTACK,
" Tasks"
" TASK_SCANNER_SET_FLY_ATTACK 0"
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
" TASK_WAIT 0.1"
""
" Interrupts"
" COND_TOO_FAR_TO_ATTACK"
" COND_SCANNER_FLY_BLOCKED"
" COND_NEW_ENEMY"
" COND_SCANNER_GRABBED_BY_PHYSCANNON"
)
//=========================================================
// > SCHED_SCANNER_ATTACK_HOVER
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_ATTACK_HOVER,
" Tasks"
" TASK_SCANNER_SET_FLY_ATTACK 0"
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
" TASK_WAIT 0.1"
""
" Interrupts"
" COND_TOO_FAR_TO_ATTACK"
" COND_SCANNER_FLY_BLOCKED"
" COND_NEW_ENEMY"
" COND_SCANNER_GRABBED_BY_PHYSCANNON"
)
//=========================================================
// > SCHED_SCANNER_ATTACK_DIVEBOMB
//
// Only done when scanner is dead
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_ATTACK_DIVEBOMB,
" Tasks"
" TASK_SCANNER_SET_FLY_DIVE 0"
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
" TASK_WAIT 10"
""
" Interrupts"
" COND_SCANNER_GRABBED_BY_PHYSCANNON"
)
//=========================================================
// > SCHED_SCANNER_CHASE_ENEMY
//
// Different interrupts than normal chase enemy.
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_CHASE_ENEMY,
" Tasks"
" TASK_SCANNER_SET_FLY_CHASE 0"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_SCANNER_PATROL"
" TASK_SET_TOLERANCE_DISTANCE 120"
" TASK_GET_PATH_TO_ENEMY 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
""
" Interrupts"
" COND_SCANNER_FLY_CLEAR"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LOST_ENEMY"
" COND_SCANNER_GRABBED_BY_PHYSCANNON"
)
//=========================================================
// > SCHED_SCANNER_CHASE_TARGET
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_CHASE_TARGET,
" Tasks"
" TASK_SCANNER_SET_FLY_CHASE 0"
" TASK_SET_TOLERANCE_DISTANCE 64"
" TASK_GET_PATH_TO_TARGET 0" //FIXME: This is wrong!
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_SCANNER_FLY_CLEAR"
" COND_NEW_ENEMY"
" COND_SCANNER_GRABBED_BY_PHYSCANNON"
)
//=========================================================
// > SCHED_SCANNER_FOLLOW_HOVER
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_FOLLOW_HOVER,
" Tasks"
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
" TASK_WAIT 0.1"
""
" Interrupts"
" COND_SCANNER_FLY_BLOCKED"
" COND_SCANNER_GRABBED_BY_PHYSCANNON"
)
//=========================================================
// > SCHED_SCANNER_HELD_BY_PHYSCANNON
//=========================================================
DEFINE_SCHEDULE
(
SCHED_SCANNER_HELD_BY_PHYSCANNON,
" Tasks"
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
" TASK_WAIT 5.0"
""
" Interrupts"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_SCANNER_RELEASED_FROM_PHYSCANNON"
)
AI_END_CUSTOM_NPC()