H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 14:46:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2aa14bb24c
source-engine/game/server/hl2/cbasehelicopter.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1598 lines
46 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Base class for helicopters & helicopter-type vehicles
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "ai_network.h"
#include "ai_default.h"
#include "ai_schedule.h"
#include "ai_hull.h"
#include "ai_node.h"
#include "ai_task.h"
#include "ai_senses.h"
#include "ai_memory.h"
#include "entitylist.h"
#include "soundenvelope.h"
#include "gamerules.h"
#include "grenade_homer.h"
#include "ndebugoverlay.h"
#include "cbasehelicopter.h"
#include "soundflags.h"
#include "rope.h"
#include "saverestore_utlvector.h"
#include "collisionutils.h"
#include "coordsize.h"
#include "effects.h"
#include "rotorwash.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
void ExpandBBox(Vector &vecMins, Vector &vecMaxs);
#if 0
virtual void NullThink( void );
#endif //0
#define HELICOPTER_THINK_INTERVAL 0.1
#define HELICOPTER_ROTORWASH_THINK_INTERVAL 0.01
#define BASECHOPPER_DEBUG_WASH 1
ConVar g_debug_basehelicopter( "g_debug_basehelicopter", "0", FCVAR_CHEAT );
//---------------------------------------------------------
//---------------------------------------------------------
// TODOs
//
// -Member function: CHANGE MOVE GOAL
//
// -Member function: GET GRAVITY (or GetMaxThrust)
//
//---------------------------------------------------------
//---------------------------------------------------------
static const char *s_pRotorWashThinkContext = "RotorWashThink";
static const char *s_pDelayedKillThinkContext = "DelayedKillThink";
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
BEGIN_DATADESC_NO_BASE( washentity_t )
DEFINE_FIELD( hEntity, FIELD_EHANDLE ),
DEFINE_FIELD( flWashStartTime, FIELD_TIME ),
END_DATADESC()
BEGIN_DATADESC( CBaseHelicopter )
DEFINE_THINKFUNC( HelicopterThink ),
DEFINE_THINKFUNC( RotorWashThink ),
DEFINE_THINKFUNC( CallDyingThink ),
DEFINE_THINKFUNC( DelayedKillThink ),
DEFINE_ENTITYFUNC( CrashTouch ),
DEFINE_ENTITYFUNC( FlyTouch ),
DEFINE_SOUNDPATCH( m_pRotorSound ),
DEFINE_SOUNDPATCH( m_pRotorBlast ),
DEFINE_FIELD( m_flForce, FIELD_FLOAT ),
DEFINE_FIELD( m_fHelicopterFlags, FIELD_INTEGER),
DEFINE_FIELD( m_vecDesiredFaceDir, FIELD_VECTOR ),
DEFINE_FIELD( m_flLastSeen, FIELD_TIME ),
DEFINE_FIELD( m_flPrevSeen, FIELD_TIME ),
// DEFINE_FIELD( m_iSoundState, FIELD_INTEGER ), // Don't save, precached
DEFINE_FIELD( m_vecTargetPosition, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_hRotorWash, FIELD_EHANDLE ),
DEFINE_FIELD( m_flMaxSpeed, FIELD_FLOAT ),
DEFINE_FIELD( m_flMaxSpeedFiring, FIELD_FLOAT ),
DEFINE_FIELD( m_flGoalSpeed, FIELD_FLOAT ),
DEFINE_KEYFIELD( m_flInitialSpeed, FIELD_FLOAT, "InitialSpeed" ),
DEFINE_FIELD( m_flRandomOffsetTime, FIELD_TIME ),
DEFINE_FIELD( m_vecRandomOffset, FIELD_VECTOR ),
DEFINE_FIELD( m_flRotorWashEntitySearchTime, FIELD_TIME ),
DEFINE_FIELD( m_bSuppressSound, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flStartupTime, FIELD_TIME ),
DEFINE_FIELD( m_cullBoxMins, FIELD_VECTOR ),
DEFINE_FIELD( m_cullBoxMaxs, FIELD_VECTOR ),
DEFINE_UTLVECTOR( m_hEntitiesPushedByWash, FIELD_EMBEDDED ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate),
DEFINE_INPUTFUNC( FIELD_VOID, "GunOn", InputGunOn ),
DEFINE_INPUTFUNC( FIELD_VOID, "GunOff", InputGunOff ),
DEFINE_INPUTFUNC( FIELD_VOID, "MissileOn", InputMissileOn ),
DEFINE_INPUTFUNC( FIELD_VOID, "MissileOff", InputMissileOff ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnableRotorWash", InputEnableRotorWash ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableRotorWash", InputDisableRotorWash ),
DEFINE_INPUTFUNC( FIELD_VOID, "MoveTopSpeed", InputMoveTopSpeed ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "MoveSpecifiedSpeed", InputMoveSpecifiedSpeed ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetAngles", InputSetAngles ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnableRotorSound", InputEnableRotorSound ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableRotorSound", InputDisableRotorSound ),
DEFINE_INPUTFUNC( FIELD_VOID, "Kill", InputKill ),
END_DATADESC()
IMPLEMENT_SERVERCLASS_ST( CBaseHelicopter, DT_BaseHelicopter )
SendPropTime( SENDINFO( m_flStartupTime ) ),
END_SEND_TABLE()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseHelicopter::CBaseHelicopter( void )
{
m_cullBoxMins = vec3_origin;
m_cullBoxMaxs = vec3_origin;
m_hRotorWash = NULL;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
// Notes : Have your derived Helicopter's Spawn() function call this one FIRST
//------------------------------------------------------------------------------
void CBaseHelicopter::Precache( void )
{
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
// Notes : Have your derived Helicopter's Spawn() function call this one FIRST
//------------------------------------------------------------------------------
void CBaseHelicopter::Spawn( void )
{
Precache( );
SetSolid( SOLID_BBOX );
SetMoveType( MOVETYPE_STEP );
AddFlag( FL_FLY );
SetState( NPC_STATE_IDLE );
m_lifeState = LIFE_ALIVE;
// motor
//******
// All of this stuff is specific to the individual type of aircraft. Handle it yourself.
//******
// m_iAmmoType = g_pGameRules->GetAmmoDef()->Index("AR2");
// SetModel( "models/attack_helicopter.mdl" );
// UTIL_SetSize( this, Vector( -32, -32, -64 ), Vector( 32, 32, 0 ) );
// UTIL_SetOrigin( this, GetLocalOrigin() );
// m_iHealth = 100;
// m_flFieldOfView = -0.707; // 270 degrees
// InitBoneControllers();
// m_iRockets = 10;
// Get the rotor sound started up.
// This base class assumes the helicopter has no guns or missiles.
// Set the appropriate flags in your derived class' Spawn() function.
m_fHelicopterFlags &= ~BITS_HELICOPTER_MISSILE_ON;
m_fHelicopterFlags &= ~BITS_HELICOPTER_GUN_ON;
m_pRotorSound = NULL;
m_pRotorBlast = NULL;
SetCycle( 0 );
ResetSequenceInfo();
AddFlag( FL_NPC );
m_flMaxSpeed = BASECHOPPER_MAX_SPEED;
m_flMaxSpeedFiring = BASECHOPPER_MAX_FIRING_SPEED;
m_takedamage = DAMAGE_AIM;
// Don't start up if the level designer has asked the
// helicopter to start disabled.
if ( !(m_spawnflags & SF_AWAITINPUT) )
{
Startup();
SetNextThink( gpGlobals->curtime + 1.0f );
}
else
{
m_flStartupTime = FLT_MAX;
}
InitPathingData( 0, BASECHOPPER_MIN_CHASE_DIST_DIFF, BASECHOPPER_AVOID_DIST );
// Setup collision hull
ExpandBBox( m_cullBoxMins, m_cullBoxMaxs );
CollisionProp()->SetSurroundingBoundsType( USE_SPECIFIED_BOUNDS, &m_cullBoxMins, &m_cullBoxMaxs );
AddSolidFlags( FSOLID_CUSTOMRAYTEST | FSOLID_CUSTOMBOXTEST );
m_flRandomOffsetTime = -1.0f;
m_vecRandomOffset.Init( 0, 0, 0 );
}
//------------------------------------------------------------------------------
// Cleanup
//------------------------------------------------------------------------------
void CBaseHelicopter::UpdateOnRemove()
{
StopRotorWash();
BaseClass::UpdateOnRemove();
}
//------------------------------------------------------------------------------
// Gets the max speed of the helicopter
//------------------------------------------------------------------------------
float CBaseHelicopter::GetMaxSpeed()
{
// If our last path_track has specified a speed, use that instead of ours
if ( GetPathMaxSpeed() )
return GetPathMaxSpeed();
return m_flMaxSpeed;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CBaseHelicopter::GetMaxSpeedFiring()
{
// If our last path_track has specified a speed, use that instead of ours
if ( GetPathMaxSpeed() )
return GetPathMaxSpeed();
return m_flMaxSpeedFiring;
}
//------------------------------------------------------------------------------
// Enemy methods
//------------------------------------------------------------------------------
bool CBaseHelicopter::GetTrackPatherTarget( Vector *pPos )
{
if ( GetEnemy() )
{
*pPos = GetEnemy()->BodyTarget( GetAbsOrigin(), false );
return true;
}
return false;
}
CBaseEntity *CBaseHelicopter::GetTrackPatherTargetEnt()
{
return GetEnemy();
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
bool CBaseHelicopter::FireGun( void )
{
return true;
}
//------------------------------------------------------------------------------
// Purpose : The main think function for the helicopters
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::HelicopterThink( void )
{
CheckPVSCondition();
SetNextThink( gpGlobals->curtime + HELICOPTER_THINK_INTERVAL );
// Don't keep this around for more than one frame.
ClearCondition( COND_ENEMY_DEAD );
// Animate and dispatch animation events.
StudioFrameAdvance( );
DispatchAnimEvents( this );
PrescheduleThink();
if ( IsMarkedForDeletion() )
return;
ShowDamage( );
// -----------------------------------------------
// If AI is disabled, kill any motion and return
// -----------------------------------------------
if (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI)
{
SetAbsVelocity( vec3_origin );
SetLocalAngularVelocity( vec3_angle );
SetNextThink( gpGlobals->curtime + HELICOPTER_THINK_INTERVAL );
return;
}
Hunt();
// Finally, forget dead enemies, or ones we've been told to ignore.
if( GetEnemy() != NULL && (!GetEnemy()->IsAlive() || GetEnemy()->GetFlags() & FL_NOTARGET || IRelationType( GetEnemy() ) == D_NU ) )
{
SetEnemy( NULL );
}
HelicopterPostThink();
}
//-----------------------------------------------------------------------------
// Rotor wash think
//-----------------------------------------------------------------------------
void CBaseHelicopter::RotorWashThink( void )
{
if ( m_lifeState == LIFE_ALIVE || m_lifeState == LIFE_DYING )
{
DrawRotorWash( BASECHOPPER_WASH_ALTITUDE, GetAbsOrigin() );
SetContextThink( &CBaseHelicopter::RotorWashThink, gpGlobals->curtime + HELICOPTER_ROTORWASH_THINK_INTERVAL, s_pRotorWashThinkContext );
}
else
{
SetContextThink( NULL, gpGlobals->curtime, s_pRotorWashThinkContext );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseHelicopter::DrawRotorWash( float flAltitude, const Vector &vecRotorOrigin )
{
// Shake any ropes nearby
if ( random->RandomInt( 0, 2 ) == 0 )
{
CRopeKeyframe::ShakeRopes( GetAbsOrigin(), flAltitude, 128 );
}
if ( m_spawnflags & SF_NOROTORWASH )
return;
DoRotorPhysicsPush( vecRotorOrigin, flAltitude );
if ( m_flRotorWashEntitySearchTime > gpGlobals->curtime )
return;
// Only push every half second
m_flRotorWashEntitySearchTime = gpGlobals->curtime + 0.5f;
}
//-----------------------------------------------------------------------------
// Purpose: Push an airboat in our wash
//-----------------------------------------------------------------------------
#define MAX_AIRBOAT_ROLL_ANGLE 20.0f
#define MAX_AIRBOAT_ROLL_COSANGLE 0.866f
#define MAX_AIRBOAT_ROLL_COSANGLE_X2 0.5f
void CBaseHelicopter::DoWashPushOnAirboat( CBaseEntity *pAirboat,
const Vector &vecWashToAirboat, float flWashAmount )
{
// For the airboat, simply produce a small roll and a push outwards.
// But don't produce a roll if we're too rolled in that direction already.
// Get the actual up direction vector
Vector vecUp;
pAirboat->GetVectors( NULL, NULL, &vecUp );
if ( vecUp.z < MAX_AIRBOAT_ROLL_COSANGLE )
return;
// Compute roll direction so that we get pushed down on the side where the rotor wash is.
Vector vecRollNormal;
CrossProduct( vecWashToAirboat, Vector( 0, 0, 1 ), vecRollNormal );
// Project it into the plane of the roll normal
VectorMA( vecUp, -DotProduct( vecUp, vecRollNormal ), vecRollNormal, vecUp );
VectorNormalize( vecUp );
// Compute a vector which is the max direction we can roll given the roll constraint
Vector vecExtremeUp;
VMatrix rot;
MatrixBuildRotationAboutAxis( rot, vecRollNormal, MAX_AIRBOAT_ROLL_ANGLE );
MatrixGetColumn( rot, 2, &vecExtremeUp );
// Find the angle between how vertical we are and how vertical we should be
float flCosDelta = DotProduct( vecExtremeUp, vecUp );
float flDelta = acos(flCosDelta) * 180.0f / M_PI;
flDelta = clamp( flDelta, 0.0f, MAX_AIRBOAT_ROLL_ANGLE );
flDelta = SimpleSplineRemapVal( flDelta, 0.0f, MAX_AIRBOAT_ROLL_ANGLE, 0.0f, 1.0f );
float flForce = 12.0f * flWashAmount * flDelta;
Vector vecWashOrigin;
Vector vecForce;
VectorMultiply( Vector( 0, 0, -1 ), flForce, vecForce );
VectorMA( pAirboat->GetAbsOrigin(), -200.0f, vecWashToAirboat, vecWashOrigin );
pAirboat->VPhysicsTakeDamage( CTakeDamageInfo( this, this, vecForce, vecWashOrigin, flWashAmount, DMG_BLAST ) );
}
//-----------------------------------------------------------------------------
// Purpose: Push a physics object in our wash. Return false if it's now out of our wash
//-----------------------------------------------------------------------------
bool CBaseHelicopter::DoWashPush( washentity_t *pWash, const Vector &vecWashOrigin )
{
if ( !pWash || !pWash->hEntity.Get() )
return false;
// Make sure the entity is still within our wash's radius
CBaseEntity *pEntity = pWash->hEntity;
// This can happen because we can dynamically turn this flag on and off
if ( pEntity->IsEFlagSet( EFL_NO_ROTORWASH_PUSH ))
return false;
Vector vecSpot = pEntity->BodyTarget( vecWashOrigin );
Vector vecToSpot = ( vecSpot - vecWashOrigin );
vecToSpot.z = 0;
float flDist = VectorNormalize( vecToSpot );
if ( flDist > BASECHOPPER_WASH_RADIUS )
return false;
IRotorWashShooter *pShooter = GetRotorWashShooter( pEntity );
IPhysicsObject *pPhysObject;
float flPushTime = (gpGlobals->curtime - pWash->flWashStartTime);
flPushTime = clamp( flPushTime, 0, BASECHOPPER_WASH_RAMP_TIME );
float flWashAmount = RemapVal( flPushTime, 0, BASECHOPPER_WASH_RAMP_TIME, BASECHOPPER_WASH_PUSH_MIN, BASECHOPPER_WASH_PUSH_MAX );
if ( pShooter )
{
Vector vecForce = (0.015f / 0.1f) * flWashAmount * vecToSpot * phys_pushscale.GetFloat();
pEntity = pShooter->DoWashPush( pWash->flWashStartTime, vecForce );
if ( !pEntity )
return true;
washentity_t Wash;
Wash.hEntity = pEntity;
Wash.flWashStartTime = pWash->flWashStartTime;
int i = m_hEntitiesPushedByWash.AddToTail( Wash );
pWash = &m_hEntitiesPushedByWash[i];
pPhysObject = pEntity->VPhysicsGetObject();
if ( !pPhysObject )
return true;
}
else
{
// Airboat gets special treatment
if ( FClassnameIs( pEntity, "prop_vehicle_airboat" ) )
{
DoWashPushOnAirboat( pEntity, vecToSpot, flWashAmount );
return true;
}
pPhysObject = pEntity->VPhysicsGetObject();
if ( !pPhysObject )
return false;
}
// Push it away from the center of the wash
float flMass = pPhysObject->GetMass();
// This used to be mass independent, which is a bad idea because it blows 200kg engine blocks
// as much as it blows cardboard and soda cans. Make this force mass-independent, but clamp at
// 30kg.
flMass = MIN( flMass, 30.0f );
Vector vecForce = (0.015f / 0.1f) * flWashAmount * flMass * vecToSpot * phys_pushscale.GetFloat();
pEntity->VPhysicsTakeDamage( CTakeDamageInfo( this, this, vecForce, vecWashOrigin, flWashAmount, DMG_BLAST ) );
// Debug
if ( g_debug_basehelicopter.GetInt() == BASECHOPPER_DEBUG_WASH )
{
NDebugOverlay::Cross3D( pEntity->GetAbsOrigin(), -Vector(4,4,4), Vector(4,4,4), 255, 0, 0, true, 0.1f );
NDebugOverlay::Line( pEntity->GetAbsOrigin(), pEntity->GetAbsOrigin() + vecForce, 255, 255, 0, true, 0.1f );
IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
Msg("Pushed %s (index %d) (mass %f) with force %f (min %.2f max %.2f) at time %.2f\n",
pEntity->GetClassname(), pEntity->entindex(), pPhysObject->GetMass(), flWashAmount,
BASECHOPPER_WASH_PUSH_MIN * flMass, BASECHOPPER_WASH_PUSH_MAX * flMass, gpGlobals->curtime );
}
// If we've pushed this thing for some time, remove it to give us a chance to find lighter things nearby
if ( flPushTime > 2.0 )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseHelicopter::DoRotorPhysicsPush( const Vector &vecRotorOrigin, float flAltitude )
{
CBaseEntity *pEntity = NULL;
trace_t tr;
// First, trace down and find out where the was is hitting the ground
UTIL_TraceLine( vecRotorOrigin, vecRotorOrigin+Vector(0,0,-flAltitude), (MASK_SOLID_BRUSHONLY|CONTENTS_WATER), NULL, COLLISION_GROUP_NONE, &tr );
// Always raise the physics origin a bit
Vector vecPhysicsOrigin = tr.endpos + Vector(0,0,64);
// Debug
if ( g_debug_basehelicopter.GetInt() == BASECHOPPER_DEBUG_WASH )
{
NDebugOverlay::Cross3D( vecPhysicsOrigin, -Vector(16,16,16), Vector(16,16,16), 0, 255, 255, true, 0.1f );
}
// Push entities that we've pushed before, and are still within range
// Walk backwards because they may be removed if they're now out of range
int iCount = m_hEntitiesPushedByWash.Count();
bool bWasPushingObjects = (iCount > 0);
for ( int i = (iCount-1); i >= 0; i-- )
{
if ( !DoWashPush( &(m_hEntitiesPushedByWash[i]), vecPhysicsOrigin ) )
{
// Out of range now, so remove
m_hEntitiesPushedByWash.Remove(i);
}
}
if ( m_flRotorWashEntitySearchTime > gpGlobals->curtime )
return;
// Any spare slots?
iCount = m_hEntitiesPushedByWash.Count();
if ( iCount >= BASECHOPPER_WASH_MAX_OBJECTS )
return;
// Find the lightest physics entity below us and add it to our list to push around
CBaseEntity *pLightestEntity = NULL;
float flLightestMass = 9999;
while ((pEntity = gEntList.FindEntityInSphere(pEntity, vecPhysicsOrigin, BASECHOPPER_WASH_RADIUS )) != NULL)
{
IRotorWashShooter *pShooter = GetRotorWashShooter( pEntity );
if ( pEntity->IsEFlagSet( EFL_NO_ROTORWASH_PUSH ))
continue;
if ( pShooter || pEntity->GetMoveType() == MOVETYPE_VPHYSICS || (pEntity->VPhysicsGetObject() && !pEntity->IsPlayer()) )
{
// Make sure it's not already in our wash
bool bAlreadyPushing = false;
for ( int i = 0; i < iCount; i++ )
{
if ( m_hEntitiesPushedByWash[i].hEntity == pEntity )
{
bAlreadyPushing = true;
break;
}
}
if ( bAlreadyPushing )
continue;
float flMass = FLT_MAX;
if ( pShooter )
{
flMass = 1.0f;
}
else
{
// Don't try to push anything too big
IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
if ( pPhysObject )
{
flMass = pPhysObject->GetMass();
if ( flMass > BASECHOPPER_WASH_MAX_MASS )
continue;
}
}
// Ignore anything bigger than the one we've already found
if ( flMass > flLightestMass )
continue;
Vector vecSpot = pEntity->BodyTarget( vecPhysicsOrigin );
// Don't push things too far below our starting point (helps reduce through-roof cases w/o doing a trace)
if ( fabs( vecSpot.z - vecPhysicsOrigin.z ) > 96 )
continue;
Vector vecToSpot = ( vecSpot - vecPhysicsOrigin );
vecToSpot.z = 0;
float flDist = VectorNormalize( vecToSpot );
if ( flDist > BASECHOPPER_WASH_RADIUS )
continue;
// Try to cast to the helicopter; if we can't, then we can't be hit.
if ( pEntity->GetServerVehicle() )
{
UTIL_TraceLine( vecSpot, vecPhysicsOrigin, MASK_SOLID_BRUSHONLY, pEntity, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0f )
continue;
}
flLightestMass = flMass;
pLightestEntity = pEntity;
washentity_t Wash;
Wash.hEntity = pLightestEntity;
Wash.flWashStartTime = gpGlobals->curtime;
m_hEntitiesPushedByWash.AddToTail( Wash );
// Can we fit more after adding this one? No? Then we are done.
iCount = m_hEntitiesPushedByWash.Count();
if ( iCount >= BASECHOPPER_WASH_MAX_OBJECTS )
break;
}
}
// Handle sound.
// If we just started pushing objects, ramp the blast sound up.
if ( !bWasPushingObjects && m_hEntitiesPushedByWash.Count() )
{
if ( m_pRotorBlast )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pRotorBlast, 1.0, 1.0 );
}
}
else if ( bWasPushingObjects && m_hEntitiesPushedByWash.Count() == 0 )
{
if ( m_pRotorBlast )
{
// We just stopped pushing objects, so fade the blast sound out.
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pRotorBlast, 0, 1.0 );
}
}
}
//------------------------------------------------------------------------------
// Updates the enemy
//------------------------------------------------------------------------------
float CBaseHelicopter::EnemySearchDistance( )
{
return 4092;
}
//------------------------------------------------------------------------------
// Updates the enemy
//------------------------------------------------------------------------------
void CBaseHelicopter::UpdateEnemy()
{
if( HasCondition( COND_ENEMY_DEAD ) )
{
SetEnemy( NULL );
}
// Look for my best enemy. If I change enemies,
// be sure and change my prevseen/lastseen timers.
if( m_lifeState == LIFE_ALIVE )
{
GetSenses()->Look( EnemySearchDistance() );
GetEnemies()->RefreshMemories();
ChooseEnemy();
if( HasEnemy() )
{
CBaseEntity *pEnemy = GetEnemy();
GatherEnemyConditions( pEnemy );
if ( FVisible( pEnemy ) )
{
if (m_flLastSeen < gpGlobals->curtime - 2)
{
m_flPrevSeen = gpGlobals->curtime;
}
m_flLastSeen = gpGlobals->curtime;
m_vecTargetPosition = pEnemy->WorldSpaceCenter();
}
}
else
{
// look at where we're going instead
m_vecTargetPosition = GetDesiredPosition();
}
}
else
{
// If we're dead or dying, forget our enemy and don't look for new ones(sjb)
SetEnemy( NULL );
}
}
//------------------------------------------------------------------------------
// Purpose : Override the desired position if your derived helicopter is doing something special
//------------------------------------------------------------------------------
void CBaseHelicopter::UpdateDesiredPosition( void )
{
}
//------------------------------------------------------------------------------
// Updates the facing direction
//------------------------------------------------------------------------------
void CBaseHelicopter::UpdateFacingDirection()
{
if ( 1 )
{
Vector targetDir = m_vecTargetPosition - GetAbsOrigin();
Vector desiredDir = GetDesiredPosition() - GetAbsOrigin();
VectorNormalize( targetDir );
VectorNormalize( desiredDir );
if ( !IsCrashing() && m_flLastSeen + 5 > gpGlobals->curtime ) //&& DotProduct( targetDir, desiredDir) > 0.25)
{
// If we've seen the target recently, face the target.
//Msg( "Facing Target \n" );
m_vecDesiredFaceDir = targetDir;
}
else
{
// Face our desired position.
// Msg( "Facing Position\n" );
m_vecDesiredFaceDir = desiredDir;
}
}
else
{
// Face the way the path corner tells us to.
//Msg( "Facing my path corner\n" );
m_vecDesiredFaceDir = GetGoalOrientation();
}
}
//------------------------------------------------------------------------------
// Fire weapons
//------------------------------------------------------------------------------
void CBaseHelicopter::FireWeapons()
{
// ALERT( at_console, "%.0f %.0f %.0f\n", gpGlobals->curtime, m_flLastSeen, m_flPrevSeen );
if (m_fHelicopterFlags & BITS_HELICOPTER_GUN_ON)
{
//if ( (m_flLastSeen + 1 > gpGlobals->curtime) && (m_flPrevSeen + 2 < gpGlobals->curtime) )
{
if (FireGun( ))
{
// slow down if we're firing
if (m_flGoalSpeed > GetMaxSpeedFiring() )
{
m_flGoalSpeed = GetMaxSpeedFiring();
}
}
}
}
if (m_fHelicopterFlags & BITS_HELICOPTER_MISSILE_ON)
{
AimRocketGun();
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::Hunt( void )
{
UpdateEnemy();
UpdateTrackNavigation( );
UpdateDesiredPosition();
UpdateFacingDirection();
Flight();
UpdatePlayerDopplerShift( );
FireWeapons();
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::UpdatePlayerDopplerShift( )
{
// -----------------------------
// make rotor, engine sounds
// -----------------------------
if (m_iSoundState == 0)
{
// Sound startup.
InitializeRotorSound();
}
else
{
CBaseEntity *pPlayer = NULL;
// UNDONE: this needs to send different sounds to every player for multiplayer.
// FIXME: this isn't the correct way to find a player!!!
pPlayer = gEntList.FindEntityByName( NULL, "!player" );
if (pPlayer)
{
Vector dir;
VectorSubtract( pPlayer->GetAbsOrigin(), GetAbsOrigin(), dir );
VectorNormalize(dir);
#if 1
float velReceiver = DotProduct( pPlayer->GetAbsVelocity(), dir );
float velTransmitter = -DotProduct( GetAbsVelocity(), dir );
// speed of sound == 13049in/s
int iPitch = 100 * ((1 - velReceiver / 13049) / (1 + velTransmitter / 13049));
#else
// This is a bogus doppler shift, but I like it better
float relV = DotProduct( GetAbsVelocity() - pPlayer->GetAbsVelocity(), dir );
int iPitch = (int)(100 + relV / 50.0);
#endif
// clamp pitch shifts
if (iPitch > 250)
{
iPitch = 250;
}
if (iPitch < 50)
{
iPitch = 50;
}
UpdateRotorSoundPitch( iPitch );
// Msg( "Pitch:%d\n", iPitch );
}
else
{
Msg( "Chopper didn't find a player!\n" );
}
}
}
//-----------------------------------------------------------------------------
// Computes the actual position to fly to
//-----------------------------------------------------------------------------
void CBaseHelicopter::ComputeActualTargetPosition( float flSpeed, float flTime, float flPerpDist, Vector *pDest, bool bApplyNoise )
{
// This is used to make the helicopter drift around a bit.
if ( bApplyNoise && m_flRandomOffsetTime <= gpGlobals->curtime )
{
m_vecRandomOffset.Random( -25.0f, 25.0f );
m_flRandomOffsetTime = gpGlobals->curtime + 1.0f;
}
if ( IsLeading() && GetEnemy() && IsOnPathTrack() )
{
ComputePointAlongCurrentPath( flSpeed * flTime, flPerpDist, pDest );
*pDest += m_vecRandomOffset;
return;
}
*pDest = GetDesiredPosition() - GetAbsOrigin();
float flDistToDesired = pDest->Length();
if (flDistToDesired > flSpeed * flTime)
{
float scale = flSpeed * flTime / flDistToDesired;
*pDest *= scale;
}
else if ( IsOnPathTrack() )
{
// Blend in a fake destination point based on the dest velocity
Vector vecDestVelocity;
ComputeNormalizedDestVelocity( &vecDestVelocity );
vecDestVelocity *= flSpeed;
float flBlendFactor = 1.0f - flDistToDesired / (flSpeed * flTime);
VectorMA( *pDest, flTime * flBlendFactor, vecDestVelocity, *pDest );
}
*pDest += GetAbsOrigin();
if ( bApplyNoise )
{
// ComputePointAlongCurrentPath( flSpeed * flTime, flPerpDist, pDest );
*pDest += m_vecRandomOffset;
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void CBaseHelicopter::Flight( void )
{
if( GetFlags() & FL_ONGROUND )
{
//This would be really bad.
SetGroundEntity( NULL );
}
// Generic speed up
if (m_flGoalSpeed < GetMaxSpeed())
{
m_flGoalSpeed += GetAcceleration();
}
//NDebugOverlay::Line(GetAbsOrigin(), m_vecDesiredPosition, 0,0,255, true, 0.1);
// tilt model 5 degrees (why?! sjb)
QAngle vecAdj = QAngle( 5.0, 0, 0 );
// estimate where I'll be facing in one seconds
Vector forward, right, up;
AngleVectors( GetLocalAngles() + GetLocalAngularVelocity() * 2 + vecAdj, &forward, &right, &up );
// Vector vecEst1 = GetLocalOrigin() + GetAbsVelocity() + up * m_flForce - Vector( 0, 0, 384 );
// float flSide = DotProduct( m_vecDesiredPosition - vecEst1, right );
QAngle angVel = GetLocalAngularVelocity();
float flSide = DotProduct( m_vecDesiredFaceDir, right );
if (flSide < 0)
{
if (angVel.y < 60)
{
angVel.y += 8;
}
}
else
{
if (angVel.y > -60)
{
angVel.y -= 8;
}
}
angVel.y *= ( 0.98 ); // why?! (sjb)
// estimate where I'll be in two seconds
AngleVectors( GetLocalAngles() + angVel * 1 + vecAdj, NULL, NULL, &up );
Vector vecEst = GetAbsOrigin() + GetAbsVelocity() * 2.0 + up * m_flForce * 20 - Vector( 0, 0, 384 * 2 );
// add immediate force
AngleVectors( GetLocalAngles() + vecAdj, &forward, &right, &up );
Vector vecImpulse( 0, 0, 0 );
vecImpulse.x += up.x * m_flForce;
vecImpulse.y += up.y * m_flForce;
vecImpulse.z += up.z * m_flForce;
// add gravity
vecImpulse.z -= 38.4; // 32ft/sec
ApplyAbsVelocityImpulse( vecImpulse );
float flSpeed = GetAbsVelocity().Length();
float flDir = DotProduct( Vector( forward.x, forward.y, 0 ), Vector( GetAbsVelocity().x, GetAbsVelocity().y, 0 ) );
if (flDir < 0)
{
flSpeed = -flSpeed;
}
float flDist = DotProduct( GetDesiredPosition() - vecEst, forward );
// float flSlip = DotProduct( GetAbsVelocity(), right );
float flSlip = -DotProduct( GetDesiredPosition() - vecEst, right );
// fly sideways
if (flSlip > 0)
{
if (GetLocalAngles().z > -30 && angVel.z > -15)
angVel.z -= 4;
else
angVel.z += 2;
}
else
{
if (GetLocalAngles().z < 30 && angVel.z < 15)
angVel.z += 4;
else
angVel.z -= 2;
}
// These functions contain code Ken wrote that used to be right here as part of the flight model,
// but we want different helicopter vehicles to have different drag characteristics, so I made
// them virtual functions (sjb)
ApplySidewaysDrag( right );
ApplyGeneralDrag();
// apply power to stay correct height
// FIXME: these need to be per class variables
#define MAX_FORCE 80
#define FORCE_POSDELTA 12
#define FORCE_NEGDELTA 8
if (m_flForce < MAX_FORCE && vecEst.z < GetDesiredPosition().z)
{
m_flForce += FORCE_POSDELTA;
}
else if (m_flForce > 30)
{
if (vecEst.z > GetDesiredPosition().z)
m_flForce -= FORCE_NEGDELTA;
}
// pitch forward or back to get to target
//-----------------------------------------
// Pitch is reversed since Half-Life! (sjb)
//-----------------------------------------
if (flDist > 0 && flSpeed < m_flGoalSpeed /* && flSpeed < flDist */ && GetLocalAngles().x + angVel.x < 40)
{
// ALERT( at_console, "F " );
// lean forward
angVel.x += 12.0;
}
else if (flDist < 0 && flSpeed > -50 && GetLocalAngles().x + angVel.x > -20)
{
// ALERT( at_console, "B " );
// lean backward
angVel.x -= 12.0;
}
else if (GetLocalAngles().x + angVel.x < 0)
{
// ALERT( at_console, "f " );
angVel.x += 4.0;
}
else if (GetLocalAngles().x + angVel.x > 0)
{
// ALERT( at_console, "b " );
angVel.x -= 4.0;
}
SetLocalAngularVelocity( angVel );
// ALERT( at_console, "%.0f %.0f : %.0f %.0f : %.0f %.0f : %.0f\n", GetAbsOrigin().x, GetAbsVelocity().x, flDist, flSpeed, GetLocalAngles().x, m_vecAngVelocity.x, m_flForce );
// ALERT( at_console, "%.0f %.0f : %.0f %0.f : %.0f\n", GetAbsOrigin().z, GetAbsVelocity().z, vecEst.z, m_vecDesiredPosition.z, m_flForce );
}
//------------------------------------------------------------------------------
// Updates the rotor wash volume
//------------------------------------------------------------------------------
void CBaseHelicopter::UpdateRotorWashVolume()
{
if ( !m_pRotorSound )
return;
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
float flVolDelta = GetRotorVolume() - controller.SoundGetVolume( m_pRotorSound );
if ( flVolDelta )
{
// We can change from 0 to 1 in 3 seconds.
// Figure out how many seconds flVolDelta will take.
float flRampTime = fabs( flVolDelta ) * 3.0f;
controller.SoundChangeVolume( m_pRotorSound, GetRotorVolume(), flRampTime );
}
}
//------------------------------------------------------------------------------
// For scripted times where it *has* to shoot
//------------------------------------------------------------------------------
float CBaseHelicopter::GetRotorVolume( void )
{
return m_bSuppressSound ? 0.0f : 1.0f;
}
//-----------------------------------------------------------------------------
// Rotor sound
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputEnableRotorSound( inputdata_t &inputdata )
{
m_bSuppressSound = false;
}
void CBaseHelicopter::InputDisableRotorSound( inputdata_t &inputdata )
{
m_bSuppressSound = true;
}
//-----------------------------------------------------------------------------
// Purpose: Marks the entity for deletion
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputKill( inputdata_t &inputdata )
{
StopRotorWash();
m_bSuppressSound = true;
SetContextThink( &CBaseHelicopter::DelayedKillThink, gpGlobals->curtime + 3.0f, s_pDelayedKillThinkContext );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseHelicopter::StopRotorWash( void )
{
if ( m_hRotorWash )
{
UTIL_Remove( m_hRotorWash );
m_hRotorWash = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Marks the entity for deletion
//-----------------------------------------------------------------------------
void CBaseHelicopter::DelayedKillThink( )
{
// tell owner ( if any ) that we're dead.This is mostly for NPCMaker functionality.
CBaseEntity *pOwner = GetOwnerEntity();
if ( pOwner )
{
pOwner->DeathNotice( this );
SetOwnerEntity( NULL );
}
UTIL_Remove( this );
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::InitializeRotorSound( void )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
if ( m_pRotorSound )
{
// Get the rotor sound started up.
controller.Play( m_pRotorSound, 0.0, 100 );
UpdateRotorWashVolume();
}
if ( m_pRotorBlast )
{
// Start the blast sound and then immediately drop it to 0 (starting it at 0 wouldn't start it)
controller.Play( m_pRotorBlast, 1.0, 100 );
controller.SoundChangeVolume(m_pRotorBlast, 0, 0.0);
}
m_iSoundState = SND_CHANGE_PITCH; // hack for going through level transitions
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::UpdateRotorSoundPitch( int iPitch )
{
if (m_pRotorSound)
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangePitch( m_pRotorSound, iPitch, 0.1 );
UpdateRotorWashVolume();
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::FlyTouch( CBaseEntity *pOther )
{
// bounce if we hit something solid
if ( pOther->GetSolid() == SOLID_BSP)
{
// trace_t tr;
// tr = CBaseEntity::GetTouchTrace();
// UNDONE, do a real bounce
// FIXME: This causes bad problems, so we just ignore it right now
//ApplyAbsVelocityImpulse( tr.plane.normal * (GetAbsVelocity().Length() + 200) );
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::CrashTouch( CBaseEntity *pOther )
{
// only crash if we hit something solid
if ( pOther->GetSolid() == SOLID_BSP)
{
SetTouch( NULL );
SetNextThink( gpGlobals->curtime );
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::DyingThink( void )
{
StudioFrameAdvance( );
SetNextThink( gpGlobals->curtime + 0.1f );
SetLocalAngularVelocity( GetLocalAngularVelocity() * 1.02 );
}
//-----------------------------------------------------------------------------
// Purpose: Override base class to add display of fly direction
// Input :
// Output :
//-----------------------------------------------------------------------------
void CBaseHelicopter::DrawDebugGeometryOverlays(void)
{
if (m_pfnThink!= NULL)
{
// ------------------------------
// Draw route if requested
// ------------------------------
if (m_debugOverlays & OVERLAY_NPC_ROUTE_BIT)
{
NDebugOverlay::Line(GetAbsOrigin(), GetDesiredPosition(), 0,0,255, true, 0);
}
}
BaseClass::DrawDebugGeometryOverlays();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CBaseHelicopter::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{
// Take no damage from trace attacks unless it's blast damage. RadiusDamage() sometimes calls
// TraceAttack() as a means for delivering blast damage. Usually when the explosive penetrates
// the target. (RPG missiles do this sometimes).
if( info.GetDamageType() & (DMG_BLAST|DMG_AIRBOAT) )
{
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::NullThink( void )
{
StudioFrameAdvance( );
SetNextThink( gpGlobals->curtime + 0.5f );
}
void CBaseHelicopter::Startup( void )
{
StopRotorWash();
if ( !( m_spawnflags & SF_NOROTORWASH ) )
{
m_hRotorWash = CreateRotorWashEmitter( GetAbsOrigin(), GetAbsAngles(), this, BASECHOPPER_WASH_ALTITUDE );
}
// Fade in the blades
m_flStartupTime = gpGlobals->curtime;
m_flGoalSpeed = m_flInitialSpeed;
SetThink( &CBaseHelicopter::HelicopterThink );
SetTouch( &CBaseHelicopter::FlyTouch );
SetNextThink( gpGlobals->curtime + 0.1f );
m_flRotorWashEntitySearchTime = gpGlobals->curtime;
SetContextThink( &CBaseHelicopter::RotorWashThink, gpGlobals->curtime, s_pRotorWashThinkContext );
}
void CBaseHelicopter::StopLoopingSounds()
{
// Kill the rotor sounds
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundDestroy( m_pRotorSound );
controller.SoundDestroy( m_pRotorBlast );
m_pRotorSound = NULL;
m_pRotorBlast = NULL;
BaseClass::StopLoopingSounds();
}
void CBaseHelicopter::Event_Killed( const CTakeDamageInfo &info )
{
m_lifeState = LIFE_DYING;
SetMoveType( MOVETYPE_FLYGRAVITY );
SetGravity( UTIL_ScaleForGravity( 240 ) ); // use a lower gravity
StopLoopingSounds();
UTIL_SetSize( this, Vector( -32, -32, -64), Vector( 32, 32, 0) );
SetThink( &CBaseHelicopter::CallDyingThink );
SetTouch( &CBaseHelicopter::CrashTouch );
SetNextThink( gpGlobals->curtime + 0.1f );
m_iHealth = 0;
m_takedamage = DAMAGE_NO;
/*
if (m_spawnflags & SF_NOWRECKAGE)
{
m_flNextRocket = gpGlobals->curtime + 4.0;
}
else
{
m_flNextRocket = gpGlobals->curtime + 15.0;
}
*/
StopRotorWash();
m_OnDeath.FireOutput( info.GetAttacker(), this );
}
void CBaseHelicopter::GibMonster( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: Call Startup for a helicopter that's been flagged to start disabled
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputActivate( inputdata_t &inputdata )
{
if( m_spawnflags & SF_AWAITINPUT )
{
Startup();
// Now clear the spawnflag to protect from
// subsequent calls.
m_spawnflags &= ~SF_AWAITINPUT;
}
}
//------------------------------------------------------------------------------
// Purpose : Turn the gun on
//------------------------------------------------------------------------------
void CBaseHelicopter::InputGunOn( inputdata_t &inputdata )
{
m_fHelicopterFlags |= BITS_HELICOPTER_GUN_ON;
}
//-----------------------------------------------------------------------------
// Purpose: Turn the gun off
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputGunOff( inputdata_t &inputdata )
{
m_fHelicopterFlags &= ~BITS_HELICOPTER_GUN_ON;
}
//------------------------------------------------------------------------------
// Purpose : Turn the missile on
//------------------------------------------------------------------------------
void CBaseHelicopter::InputMissileOn( inputdata_t &inputdata )
{
m_fHelicopterFlags |= BITS_HELICOPTER_MISSILE_ON;
}
//-----------------------------------------------------------------------------
// Purpose: Turn the missile off
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputMissileOff( inputdata_t &inputdata )
{
m_fHelicopterFlags &= ~BITS_HELICOPTER_MISSILE_ON;
}
//-----------------------------------------------------------------------------
// Enable, disable rotor wash
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputEnableRotorWash( inputdata_t &inputdata )
{
m_spawnflags &= ~SF_NOROTORWASH;
}
void CBaseHelicopter::InputDisableRotorWash( inputdata_t &inputdata )
{
m_spawnflags |= SF_NOROTORWASH;
}
//-----------------------------------------------------------------------------
// Causes the helicopter to immediately accelerate to its desired velocity
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputMoveTopSpeed( inputdata_t &inputdata )
{
Vector vecVelocity;
ComputeActualTargetPosition( GetMaxSpeed(), 1.0f, 0.0f, &vecVelocity, false );
vecVelocity -= GetAbsOrigin();
float flLength = VectorNormalize( vecVelocity );
if (flLength < 1e-3)
{
GetVectors( &vecVelocity, NULL, NULL );
}
vecVelocity *= GetMaxSpeed();
SetAbsVelocity( vecVelocity );
}
//-----------------------------------------------------------------------------
// Cause helicopter to immediately accelerate to specified velocity
//-----------------------------------------------------------------------------
void CBaseHelicopter::InputMoveSpecifiedSpeed( inputdata_t &inputdata )
{
Vector vecVelocity;
ComputeActualTargetPosition( GetMaxSpeed(), 1.0f, 0.0f, &vecVelocity, false );
vecVelocity -= GetAbsOrigin();
float flLength = VectorNormalize( vecVelocity );
if (flLength < 1e-3)
{
GetVectors( &vecVelocity, NULL, NULL );
}
float flSpeed = inputdata.value.Float();
vecVelocity *= flSpeed;
SetAbsVelocity( vecVelocity );
}
//------------------------------------------------------------------------------
// Input values
//------------------------------------------------------------------------------
void CBaseHelicopter::InputSetAngles( inputdata_t &inputdata )
{
const char *pAngles = inputdata.value.String();
QAngle angles;
UTIL_StringToVector( angles.Base(), pAngles );
SetAbsAngles( angles );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CBaseHelicopter::ApplySidewaysDrag( const Vector &vecRight )
{
Vector vecNewVelocity = GetAbsVelocity();
vecNewVelocity.x *= 1.0 - fabs( vecRight.x ) * 0.05;
vecNewVelocity.y *= 1.0 - fabs( vecRight.y ) * 0.05;
vecNewVelocity.z *= 1.0 - fabs( vecRight.z ) * 0.05;
SetAbsVelocity( vecNewVelocity );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CBaseHelicopter::ApplyGeneralDrag( void )
{
Vector vecNewVelocity = GetAbsVelocity();
vecNewVelocity *= 0.995;
SetAbsVelocity( vecNewVelocity );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CBaseHelicopter::ChooseEnemy( void )
{
// See if there's a new enemy.
CBaseEntity *pNewEnemy;
pNewEnemy = BestEnemy();
if ( pNewEnemy != GetEnemy() )
{
if ( pNewEnemy != NULL )
{
// New enemy! Clear the timers and set conditions.
SetEnemy( pNewEnemy );
m_flLastSeen = m_flPrevSeen = gpGlobals->curtime;
}
else
{
SetEnemy( NULL );
SetState( NPC_STATE_ALERT );
}
return true;
}
else
{
ClearCondition( COND_NEW_ENEMY );
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CBaseHelicopter::GatherEnemyConditions( CBaseEntity *pEnemy )
{
// -------------------
// If enemy is dead
// -------------------
if ( !pEnemy->IsAlive() )
{
SetCondition( COND_ENEMY_DEAD );
ClearCondition( COND_SEE_ENEMY );
ClearCondition( COND_ENEMY_OCCLUDED );
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pInfo -
// bAlways -
//-----------------------------------------------------------------------------
void CBaseHelicopter::SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways )
{
// Are we already marked for transmission?
if ( pInfo->m_pTransmitEdict->Get( entindex() ) )
return;
BaseClass::SetTransmit( pInfo, bAlways );
// Make our smoke trail always come with us
if ( m_hRotorWash )
{
m_hRotorWash->SetTransmit( pInfo, bAlways );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpandBBox(Vector &vecMins, Vector &vecMaxs)
{
// expand for *any* rotation
float maxval = 0;
for (int i = 0; i < 3; i++)
{
float v = fabs( vecMins[i]);
if (v > maxval)
maxval = v;
v = fabs( vecMaxs[i]);
if (v > maxval)
maxval = v;
}
vecMins.Init(-maxval, -maxval, -maxval);
vecMaxs.Init(maxval, maxval, maxval);
}
Reference in New Issue View Git Blame Copy Permalink