BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/server/portal/npc_rocket_turret.cpp

1413 lines
41 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "cbase.h"
#include "ai_basenpc.h"
#include "ai_senses.h"
#include "ai_memory.h"
#include "engine/IEngineSound.h"
#include "Sprite.h"
#include "IEffects.h"
#include "prop_portal_shared.h"
#include "te.h"
#include "te_effect_dispatch.h"
#include "soundenvelope.h" // for looping sound effects
#include "portal_gamerules.h" // for difficulty settings
#include "weapon_rpg.h"
#include "explode.h"
#include "smoke_trail.h" // smoke trailers on the rocket
#include "physics_bone_follower.h" // For bone follower manager
#include "physicsshadowclone.h" // For translating hit entities shadow clones to real ent
//#include "ndebugoverlay.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define ROCKET_TURRET_RANGE 8192
#define ROCKET_TURRET_EMITER_OFFSET 0.0
#define ROCKET_TURRET_THINK_RATE 0.05
#define ROCKET_TURRET_DEATH_EFFECT_TIME 1.5f
#define ROCKET_TURRET_LOCKON_TIME 2.0f
#define ROCKET_TURRET_HALF_LOCKON_TIME 1.0f
#define ROCKET_TURRET_QUARTER_LOCKON_TIME 0.5f
#define ROCKET_TURRET_ROCKET_FIRE_COOLDOWN_TIME 4.0f
// For search thinks
#define MAX_DIVERGENCE_X 30.0f
#define MAX_DIVERGENCE_Y 15.0f
#define ROCKET_TURRET_DECAL_NAME "decals/scorchfade"
#define ROCKET_TURRET_MODEL_NAME "models/props_bts/rocket_sentry.mdl"
#define ROCKET_TURRET_PROJECTILE_NAME "models/props_bts/rocket.mdl"
#define ROCKET_TURRET_SOUND_LOCKING "NPC_RocketTurret.LockingBeep"
#define ROCKET_TURRET_SOUND_LOCKED "NPC_FloorTurret.LockedBeep"
#define ROCKET_PROJECTILE_FIRE_SOUND "NPC_FloorTurret.RocketFire"
#define ROCKET_PROJECTILE_LOOPING_SOUND "NPC_FloorTurret.RocketFlyLoop"
#define ROCKET_PROJECTILE_DEFAULT_LIFE 20.0
//Spawnflags
#define SF_ROCKET_TURRET_START_INACTIVE 0x00000001
// These bones have physics shadows
const char *pRocketTurretFollowerBoneNames[] =
{
"Root",
"Base",
"Arm_1",
"Arm_2",
"Arm_3",
"Arm_4",
"Rot_LR",
"Rot_UD",
"Gun_casing",
"Gun_Barrel_01",
"gun_barrel_02",
"loader",
"missle_01",
"missle_02",
"panel",
};
class CNPC_RocketTurret : public CAI_BaseNPC
{
DECLARE_CLASS( CNPC_RocketTurret, CAI_BaseNPC );
DECLARE_SERVERCLASS();
DECLARE_DATADESC();
public:
CNPC_RocketTurret( void );
~CNPC_RocketTurret( void );
void Precache( void );
void Spawn( void );
virtual void Activate( void );
virtual ITraceFilter* GetBeamTraceFilter( void );
void UpdateOnRemove( void );
bool CreateVPhysics( void );
// Think functions
void SearchThink( void ); // Lost Target, spaz out
void FollowThink( void ); // Found target, chase it
void LockingThink( void ); // Charge up effects
void FiringThink( void ); // Currently has rocket out
void DyingThink( void ); // Overloading, blowing up
void DeathThink( void ); // Destroyed, sparking
void OpeningThink ( void ); // Finish open/close animation before using pose params
void ClosingThink ( void );
// Inputs
void InputToggle( inputdata_t &inputdata );
void InputEnable( inputdata_t &inputdata );
void InputDisable( inputdata_t &inputdata );
void InputSetTarget( inputdata_t &inputdata );
void InputDestroy( inputdata_t &inputdata );
void RocketDied( void ); // After rocket hits something and self-destructs (or times out)
Class_T Classify( void )
{
if( m_bEnabled )
return CLASS_COMBINE;
return CLASS_NONE;
}
bool FVisible( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );
Vector EyeOffset( Activity nActivity )
{
return vec3_origin;
}
Vector EyePosition( void )
{
Vector vMuzzlePos;
GetAttachment( m_iMuzzleAttachment, vMuzzlePos, NULL, NULL, NULL );
return vMuzzlePos;
}
protected:
bool PreThink( void );
void Toggle( void );
void Enable( void );
void Disable( void );
void SetTarget( CBaseEntity* pTarget );
void Destroy ( void );
float UpdateFacing( void );
void UpdateAimPoint( void );
void FireRocket( void );
void UpdateSkin( int nSkin );
void UpdateMuzzleMatrix ( void );
bool TestLOS( const Vector& vAimPoint );
bool TestPortalsForLOS( Vector* pOutVec, bool bConsiderNonPortalAimPoint );
bool FindAimPointThroughPortal( const CProp_Portal* pPortal, Vector* pVecOut );
void SyncPoseToAimAngles ( void );
void LaserOn ( void );
void LaserOff ( void );
bool m_bEnabled;
bool m_bHasSightOfEnemy;
QAngle m_vecGoalAngles;
CNetworkVar( QAngle, m_vecCurrentAngles );
QAngle m_vecAnglesToEnemy;
enum
{
ROCKET_SKIN_IDLE=0,
ROCKET_SKIN_LOCKING,
ROCKET_SKIN_LOCKED,
ROCKET_SKIN_COUNT,
};
Vector m_vecDirToEnemy;
float m_flDistToEnemy;
float m_flTimeSpentDying;
float m_flTimeLocking; // Period spent locking on to target
float m_flTimeLastFired; // Cooldown time between attacks
float m_flTimeSpentPaused; // for search think's movements
float m_flPauseLength;
float m_flTotalDivergenceX;
float m_flTotalDivergenceY;
matrix3x4_t m_muzzleToWorld;
int m_muzzleToWorldTick;
int m_iPosePitch;
int m_iPoseYaw;
// Contained Bone Follower manager
CBoneFollowerManager m_BoneFollowerManager;
// Model indices for effects
CNetworkVar( int, m_iLaserState );
CNetworkVar( int, m_nSiteHalo );
// Target indicator sprite info
int m_iMuzzleAttachment;
int m_iLightAttachment;
COutputEvent m_OnFoundTarget;
COutputEvent m_OnLostTarget;
CTraceFilterSkipTwoEntities m_filterBeams;
EHANDLE m_hCurRocket;
};
//Datatable
BEGIN_DATADESC( CNPC_RocketTurret )
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_vecGoalAngles, FIELD_VECTOR ),
DEFINE_FIELD( m_vecCurrentAngles, FIELD_VECTOR ),
DEFINE_FIELD( m_bHasSightOfEnemy, FIELD_BOOLEAN ),
DEFINE_FIELD( m_vecAnglesToEnemy, FIELD_VECTOR ),
DEFINE_FIELD( m_vecDirToEnemy, FIELD_VECTOR ),
DEFINE_FIELD( m_flDistToEnemy, FIELD_FLOAT ),
DEFINE_FIELD( m_flTimeSpentDying, FIELD_FLOAT ),
DEFINE_FIELD( m_flTimeLocking, FIELD_FLOAT ),
DEFINE_FIELD( m_flTimeLastFired, FIELD_FLOAT ),
DEFINE_FIELD( m_iLaserState, FIELD_INTEGER ),
DEFINE_FIELD( m_nSiteHalo, FIELD_INTEGER ),
DEFINE_FIELD( m_flTimeSpentPaused, FIELD_FLOAT ),
DEFINE_FIELD( m_flPauseLength, FIELD_FLOAT ),
DEFINE_FIELD( m_flTotalDivergenceX, FIELD_FLOAT ),
DEFINE_FIELD( m_flTotalDivergenceY, FIELD_FLOAT ),
DEFINE_FIELD( m_iPosePitch, FIELD_INTEGER ),
DEFINE_FIELD( m_iPoseYaw, FIELD_INTEGER ),
DEFINE_FIELD( m_hCurRocket, FIELD_EHANDLE ),
DEFINE_FIELD( m_iMuzzleAttachment, FIELD_INTEGER ),
DEFINE_FIELD( m_iLightAttachment, FIELD_INTEGER ),
DEFINE_FIELD( m_muzzleToWorldTick, FIELD_INTEGER ),
DEFINE_FIELD( m_muzzleToWorld, FIELD_MATRIX3X4_WORLDSPACE ),
// DEFINE_FIELD( m_filterBeams, CTraceFilterSkipTwoEntities ),
DEFINE_EMBEDDED( m_BoneFollowerManager ),
DEFINE_THINKFUNC( SearchThink ),
DEFINE_THINKFUNC( FollowThink ),
DEFINE_THINKFUNC( LockingThink ),
DEFINE_THINKFUNC( FiringThink ),
DEFINE_THINKFUNC( DyingThink ),
DEFINE_THINKFUNC( DeathThink ),
DEFINE_THINKFUNC( OpeningThink ),
DEFINE_THINKFUNC( ClosingThink ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetTarget", InputSetTarget ),
DEFINE_INPUTFUNC( FIELD_VOID, "Destroy", InputDestroy ),
DEFINE_OUTPUT( m_OnFoundTarget, "OnFoundTarget" ),
DEFINE_OUTPUT( m_OnLostTarget, "OnLostTarget" ),
END_DATADESC()
IMPLEMENT_SERVERCLASS_ST(CNPC_RocketTurret, DT_NPC_RocketTurret)
SendPropInt( SENDINFO( m_iLaserState ), 2 ),
SendPropInt( SENDINFO( m_nSiteHalo ) ),
SendPropVector( SENDINFO( m_vecCurrentAngles ) ),
END_SEND_TABLE()
LINK_ENTITY_TO_CLASS( npc_rocket_turret, CNPC_RocketTurret );
// Projectile class for this weapon, a rocket
class CRocket_Turret_Projectile : public CMissile
{
DECLARE_CLASS( CRocket_Turret_Projectile, CMissile );
DECLARE_DATADESC();
public:
void Precache( void );
void Spawn( void );
virtual void NotifyLauncherOnDeath( void );
virtual void NotifySystemEvent( CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t &params );
virtual void SetLauncher( EHANDLE hLauncher );
virtual void CreateSmokeTrail( void ); // overloaded from base
virtual void MissileTouch( CBaseEntity *pOther );
EHANDLE m_hLauncher;
CSoundPatch *m_pAmbientSound;
protected:
virtual void DoExplosion( void );
virtual void CreateSounds( void );
virtual void StopLoopingSounds ( void );
};
BEGIN_DATADESC( CRocket_Turret_Projectile )
DEFINE_FIELD( m_hLauncher, FIELD_EHANDLE ),
DEFINE_FUNCTION( MissileTouch ),
DEFINE_SOUNDPATCH( m_pAmbientSound ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( rocket_turret_projectile, CRocket_Turret_Projectile );
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CNPC_RocketTurret::CNPC_RocketTurret( void )
: m_filterBeams( NULL, NULL, COLLISION_GROUP_DEBRIS )
{
m_bEnabled = false;
m_bHasSightOfEnemy = false;
m_vecGoalAngles.Init();
m_vecAnglesToEnemy.Init();
m_vecDirToEnemy.Init();
m_flTimeLastFired = m_flTimeLocking = m_flDistToEnemy = m_flTimeSpentDying = 0.0f;
m_iLightAttachment = m_iMuzzleAttachment = m_nSiteHalo = 0;
m_flTimeSpentPaused = m_flPauseLength = m_flTotalDivergenceX = m_flTotalDivergenceY = 0.0f;
m_hCurRocket = NULL;
}
CNPC_RocketTurret::~CNPC_RocketTurret( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: Precache
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Precache( void )
{
PrecacheModel("effects/bluelaser1.vmt");
m_nSiteHalo = PrecacheModel("sprites/light_glow03.vmt");
PrecacheScriptSound ( ROCKET_TURRET_SOUND_LOCKING );
PrecacheScriptSound ( ROCKET_TURRET_SOUND_LOCKED );
PrecacheScriptSound ( ROCKET_PROJECTILE_FIRE_SOUND );
PrecacheScriptSound ( ROCKET_PROJECTILE_LOOPING_SOUND );
UTIL_PrecacheDecal( ROCKET_TURRET_DECAL_NAME );
PrecacheModel( ROCKET_TURRET_MODEL_NAME );
PrecacheModel ( ROCKET_TURRET_PROJECTILE_NAME );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose: the entity
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Spawn( void )
{
Precache();
BaseClass::Spawn();
SetViewOffset( vec3_origin );
AddEFlags( EFL_NO_DISSOLVE );
SetModel( ROCKET_TURRET_MODEL_NAME );
SetSolid( SOLID_VPHYSICS );
m_iMuzzleAttachment = LookupAttachment ( "barrel" );
m_iLightAttachment = LookupAttachment ( "eye" );
m_iPosePitch = LookupPoseParameter( "aim_pitch" );
m_iPoseYaw = LookupPoseParameter( "aim_yaw" );
m_vecCurrentAngles = m_vecGoalAngles = GetAbsAngles();
CreateVPhysics();
//Set our autostart state
m_bEnabled = ( ( m_spawnflags & SF_ROCKET_TURRET_START_INACTIVE ) == false );
// Set Locked sprite
if ( m_bEnabled )
{
m_iLaserState = 1;
SetSequence(LookupSequence("idle"));
}
else
{
m_iLaserState = 0;
SetSequence(LookupSequence("inactive"));
}
SetCycle(1.0f);
UpdateSkin( ROCKET_SKIN_IDLE );
SetPoseParameter( "aim_pitch", 0 );
SetPoseParameter( "aim_yaw", -180 );
if ( m_bEnabled )
{
SetThink( &CNPC_RocketTurret::FollowThink );
}
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
}
bool CNPC_RocketTurret::CreateVPhysics( void )
{
m_BoneFollowerManager.InitBoneFollowers( this, ARRAYSIZE(pRocketTurretFollowerBoneNames), pRocketTurretFollowerBoneNames );
BaseClass::CreateVPhysics();
return true;
}
void CNPC_RocketTurret::Activate( void )
{
m_filterBeams.SetPassEntity( this );
m_filterBeams.SetPassEntity2( UTIL_GetLocalPlayer() );
BaseClass::Activate();
}
ITraceFilter* CNPC_RocketTurret::GetBeamTraceFilter( void )
{
return &m_filterBeams;
}
void CNPC_RocketTurret::UpdateOnRemove( void )
{
m_BoneFollowerManager.DestroyBoneFollowers();
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_RocketTurret::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )
{
CBaseEntity *pHitEntity = NULL;
if ( BaseClass::FVisible( pEntity, traceMask, &pHitEntity ) )
return true;
if (ppBlocker)
{
*ppBlocker = pHitEntity;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : void CNPC_RocketTurret::UpdateAimPoint
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::UpdateAimPoint ( void )
{
//If we've become inactive
if ( ( m_bEnabled == false ) || ( GetEnemy() == NULL ) )
{
SetEnemy( NULL );
SetNextThink( TICK_NEVER_THINK );
m_vecGoalAngles = GetAbsAngles();
return;
}
//Get our shot positions
Vector vecMid = EyePosition();
Vector vecMidEnemy = GetEnemy()->GetAbsOrigin() + (GetEnemy()->WorldAlignMins() + GetEnemy()->WorldAlignMaxs()) * 0.5f;
//Calculate dir and dist to enemy
m_vecDirToEnemy = vecMidEnemy - vecMid;
m_flDistToEnemy = VectorNormalize( m_vecDirToEnemy );
VectorAngles( m_vecDirToEnemy, m_vecAnglesToEnemy );
bool bEnemyVisible = false;
if ( !(GetEnemy()->GetFlags() & FL_NOTARGET) )
{
bool bEnemyVisibleInWorld = FVisible( GetEnemy() );
// Test portals in our view as possible ways to view the player
bool bEnemyVisibleThroughPortal = TestPortalsForLOS( &vecMidEnemy, bEnemyVisibleInWorld );
bEnemyVisible = bEnemyVisibleInWorld || bEnemyVisibleThroughPortal;
}
//Store off our last seen location
UpdateEnemyMemory( GetEnemy(), vecMidEnemy );
if ( bEnemyVisible )
{
m_vecDirToEnemy = vecMidEnemy - vecMid;
m_flDistToEnemy = VectorNormalize( m_vecDirToEnemy );
VectorAngles( m_vecDirToEnemy, m_vecAnglesToEnemy );
}
//Current enemy is not visible
if ( ( bEnemyVisible == false ) || ( m_flDistToEnemy > ROCKET_TURRET_RANGE ) )
{
// Had LOS, just lost it
if ( m_bHasSightOfEnemy )
{
m_OnLostTarget.FireOutput( GetEnemy(), this );
}
m_bHasSightOfEnemy = false;
}
//If we can see our enemy
if ( bEnemyVisible )
{
// Had no LOS, just gained it
if ( !m_bHasSightOfEnemy )
{
m_OnFoundTarget.FireOutput( GetEnemy(), this );
}
m_bHasSightOfEnemy = true;
}
}
bool SignDiffers ( float f1, float f2 )
{
return !( Sign(f1) == Sign(f2) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::SearchThink()
{
if ( PreThink() || GetEnemy() == NULL )
return;
SetSequence ( LookupSequence( "idle" ) );
UpdateAimPoint();
//Update our think time
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
// Still can't see enemy, zip around frantically
if ( !m_bHasSightOfEnemy )
{
if ( m_flTimeSpentPaused >= m_flPauseLength )
{
float flOffsetX = RandomFloat( -5.0f, 5.0f );
float flOffsetY = RandomFloat( -5.0f, 5.0f );
if ( fabs(m_flTotalDivergenceX) <= MAX_DIVERGENCE_X ||
SignDiffers( m_flTotalDivergenceX, flOffsetX ) )
{
m_flTotalDivergenceX += flOffsetX;
m_vecGoalAngles.x += flOffsetX;
}
if ( fabs(m_flTotalDivergenceY) <= MAX_DIVERGENCE_Y ||
SignDiffers( m_flTotalDivergenceY, flOffsetY ) )
{
m_flTotalDivergenceY += flOffsetY;
m_vecGoalAngles.y += flOffsetY;
}
// Reset pause timer
m_flTimeSpentPaused = 0.0f;
m_flPauseLength = RandomFloat( 0.3f, 2.5f );
}
m_flTimeSpentPaused += ROCKET_TURRET_THINK_RATE;
}
else
{
// Found target, go back to following it
SetThink( &CNPC_RocketTurret::FollowThink );
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
}
// Move beam towards goal angles
UpdateFacing();
}
//-----------------------------------------------------------------------------
// Purpose: Allows the turret to fire on targets if they're visible
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::FollowThink( void )
{
// Default to player as enemy
if ( GetEnemy() == NULL )
{
SetEnemy( UTIL_GetLocalPlayer() );
}
SetSequence ( LookupSequence( "idle" ) );
//Allow descended classes a chance to do something before the think function
if ( PreThink() || GetEnemy() == NULL )
{
return;
}
//Update our think time
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
UpdateAimPoint();
m_vecGoalAngles = m_vecAnglesToEnemy;
// Chase enemy
if ( !m_bHasSightOfEnemy )
{
// Aim at the last known location
m_vecGoalAngles = m_vecCurrentAngles;
// Lost sight, move to search think
SetThink( &CNPC_RocketTurret::SearchThink );
}
//Turn to face
UpdateFacing();
// If our facing direction hits our enemy, fire the beam
Ray_t rayDmg;
Vector vForward;
AngleVectors( m_vecCurrentAngles, &vForward, NULL, NULL );
Vector vEndPoint = EyePosition() + vForward*ROCKET_TURRET_RANGE;
rayDmg.Init( EyePosition(), vEndPoint );
rayDmg.m_IsRay = true;
trace_t traceDmg;
// This version reorients through portals
CTraceFilterSimple subfilter( this, COLLISION_GROUP_NONE );
CTraceFilterTranslateClones filter ( &subfilter );
float flRequiredParameter = 2.0f;
CProp_Portal* pFirstPortal = UTIL_Portal_FirstAlongRay( rayDmg, flRequiredParameter );
UTIL_Portal_TraceRay_Bullets( pFirstPortal, rayDmg, MASK_VISIBLE_AND_NPCS, &filter, &traceDmg, false );
if ( traceDmg.m_pEnt )
{
// This thing we're hurting is our enemy
if ( traceDmg.m_pEnt == GetEnemy() )
{
// If we're past the cooldown time, fire another rocket
if ( (gpGlobals->curtime - m_flTimeLastFired) > ROCKET_TURRET_ROCKET_FIRE_COOLDOWN_TIME )
{
SetThink( &CNPC_RocketTurret::LockingThink );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Charge up, prepare to fire and give player time to dodge
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::LockingThink( void )
{
//Allow descended classes a chance to do something before the think function
if ( PreThink() )
return;
//Turn to face
UpdateFacing();
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
if ( m_flTimeLocking == 0.0f )
{
// Play lockon sound
EmitSound ( ROCKET_TURRET_SOUND_LOCKING );
EmitSound ( ROCKET_TURRET_SOUND_LOCKING, gpGlobals->curtime + ROCKET_TURRET_QUARTER_LOCKON_TIME );
EmitSound ( ROCKET_TURRET_SOUND_LOCKED, gpGlobals->curtime + ROCKET_TURRET_HALF_LOCKON_TIME );
ResetSequence(LookupSequence("load"));
// Change lockon sprite
UpdateSkin( ROCKET_SKIN_LOCKING );
}
m_flTimeLocking += ROCKET_TURRET_THINK_RATE;
if ( m_flTimeLocking > ROCKET_TURRET_LOCKON_TIME )
{
// Set Locked sprite to 'rocket out' color
UpdateSkin( ROCKET_SKIN_LOCKED );
FireRocket();
SetThink ( &CNPC_RocketTurret::FiringThink );
m_flTimeLocking = 0.0f;
}
}
//-----------------------------------------------------------------------------
// Purpose: Charge up, deal damage along our facing direction.
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::FiringThink( void )
{
//Allow descended classes a chance to do something before the think function
if ( PreThink() )
return;
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
CRocket_Turret_Projectile* pRocket = dynamic_cast<CRocket_Turret_Projectile*>(m_hCurRocket.Get());
if ( pRocket )
{
// If this rocket has been out too long, detonate it and launch a new one
if ( (gpGlobals->curtime - m_flTimeLastFired) > ROCKET_PROJECTILE_DEFAULT_LIFE )
{
pRocket->ShotDown();
m_flTimeLastFired = gpGlobals->curtime;
SetThink( &CNPC_RocketTurret::FollowThink );
}
}
else
{
// Set Locked sprite
UpdateSkin( ROCKET_SKIN_IDLE );
// Rocket dead, or never created. Revert to follow think
m_flTimeLastFired = gpGlobals->curtime;
SetThink( &CNPC_RocketTurret::FollowThink );
}
}
void CNPC_RocketTurret::FireRocket ( void )
{
UTIL_Remove( m_hCurRocket );
CRocket_Turret_Projectile *pRocket = (CRocket_Turret_Projectile *) CBaseEntity::Create( "rocket_turret_projectile", EyePosition(), m_vecCurrentAngles, this );
if ( !pRocket )
return;
m_hCurRocket = pRocket;
Vector vForward;
AngleVectors( m_vecCurrentAngles, &vForward, NULL, NULL );
m_flTimeLastFired = gpGlobals->curtime;
EmitSound ( ROCKET_PROJECTILE_FIRE_SOUND );
ResetSequence(LookupSequence("fire"));
pRocket->SetThink( NULL );
pRocket->SetMoveType( MOVETYPE_FLY );
pRocket->CreateSmokeTrail();
pRocket->SetModel( ROCKET_TURRET_PROJECTILE_NAME );
UTIL_SetSize( pRocket, vec3_origin, vec3_origin );
pRocket->SetAbsVelocity( vForward * 550 );
pRocket->SetLauncher ( this );
}
void CNPC_RocketTurret::UpdateSkin( int nSkin )
{
m_nSkin = nSkin;
}
//-----------------------------------------------------------------------------
// Purpose: Rocket destructed, resume search behavior
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::RocketDied( void )
{
// Set Locked sprite
UpdateSkin( ROCKET_SKIN_IDLE );
// Rocket dead, return to follow think
m_flTimeLastFired = gpGlobals->curtime;
SetThink( &CNPC_RocketTurret::FollowThink );
}
//-----------------------------------------------------------------------------
// Purpose: Show this rocket turret has overloaded with effects and noise for a period of time
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::DyingThink( void )
{
// Make the beam graphics freak out a bit
m_iLaserState = 2;
UpdateSkin( ROCKET_SKIN_IDLE );
// If we've freaked out for long enough, be dead
if ( m_flTimeSpentDying > ROCKET_TURRET_DEATH_EFFECT_TIME )
{
Vector vForward;
AngleVectors( m_vecCurrentAngles, &vForward, NULL, NULL );
g_pEffects->EnergySplash( EyePosition(), vForward, true );
m_OnDeath.FireOutput( this, this );
SetThink( &CNPC_RocketTurret::DeathThink );
SetNextThink( gpGlobals->curtime + 1.0f );
m_flTimeSpentDying = 0.0f;
}
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
m_flTimeSpentDying += ROCKET_TURRET_THINK_RATE;
}
//-----------------------------------------------------------------------------
// Purpose: Sparks and fizzes to show it's broken.
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::DeathThink( void )
{
Vector vForward;
AngleVectors( m_vecCurrentAngles, &vForward, NULL, NULL );
m_iLaserState = 0;
SetEnemy( NULL );
g_pEffects->Sparks( EyePosition(), 1, 1, &vForward );
g_pEffects->Smoke( EyePosition(), 0, 6.0f, 20 );
SetNextThink( gpGlobals->curtime + RandomFloat( 2.0f, 8.0f ) );
}
void CNPC_RocketTurret::UpdateMuzzleMatrix()
{
if ( gpGlobals->tickcount != m_muzzleToWorldTick )
{
m_muzzleToWorldTick = gpGlobals->tickcount;
GetAttachment( m_iMuzzleAttachment, m_muzzleToWorld );
}
}
//-----------------------------------------------------------------------------
// Purpose: Avoid aiming/drawing beams while opening and closing
// Input : -
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::OpeningThink()
{
StudioFrameAdvance();
// Require these poses for this animation
QAngle vecNeutralAngles ( 0, 90, 0 );
m_vecGoalAngles = m_vecCurrentAngles = vecNeutralAngles;
SyncPoseToAimAngles();
// Start following player after we're fully opened
float flCurProgress = GetCycle();
if ( flCurProgress >= 0.99f )
{
LaserOn();
SetThink( &CNPC_RocketTurret::FollowThink );
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose: Avoid aiming/drawing beams while opening and closing
// Input : -
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::ClosingThink()
{
LaserOff();
// Require these poses for this animation
QAngle vecNeutralAngles ( 0, 90, 0 );
m_vecGoalAngles = vecNeutralAngles;
// Once we're within 10 degrees of the neutral pose, start close animation.
if ( UpdateFacing() <= 10.0f )
{
StudioFrameAdvance();
}
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
// Start following player after we're fully opened
float flCurProgress = GetCycle();
if ( flCurProgress >= 0.99f )
{
SetThink( NULL );
SetNextThink( TICK_NEVER_THINK );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : void SyncPoseToAimAngles
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::SyncPoseToAimAngles ( void )
{
QAngle localAngles = TransformAnglesToLocalSpace( m_vecCurrentAngles.Get(), EntityToWorldTransform() );
// Update pitch
SetPoseParameter( m_iPosePitch, localAngles.x );
// Update yaw -- NOTE: This yaw movement is screwy for this model, we must invert the yaw delta and also skew an extra 90 deg to
// get the 'forward face' of the turret to match up with the look direction. If the model and it's pose parameters change, this will be wrong.
SetPoseParameter( m_iPoseYaw, AngleNormalize( -localAngles.y - 90 ) );
InvalidateBoneCache();
}
//-----------------------------------------------------------------------------
// Purpose: Causes the turret to face its desired angles
// Returns distance current and goal angles the angles in degrees.
//-----------------------------------------------------------------------------
float CNPC_RocketTurret::UpdateFacing( void )
{
Quaternion qtCurrent ( m_vecCurrentAngles.Get() );
Quaternion qtGoal ( m_vecGoalAngles );
Quaternion qtOut;
float flDiff = QuaternionAngleDiff( qtCurrent, qtGoal );
// 1/10th degree is all the granularity we need, gives rocket player hit box width accuracy at 18k game units.
if ( flDiff < 0.1 )
return flDiff;
// Slerp 5% of the way to goal (distance dependant speed, but torque minimial and no euler wrapping issues).
QuaternionSlerp( qtCurrent, qtGoal, 0.05, qtOut );
QAngle vNewAngles;
QuaternionAngles( qtOut, vNewAngles );
m_vecCurrentAngles = vNewAngles;
SyncPoseToAimAngles();
return flDiff;
}
//-----------------------------------------------------------------------------
// Purpose: Tests if this prop's front point will have direct line of sight to it's target entity once the pose parameters are set to face it
// Input : vAimPoint - The point to aim at
// Output : Returns true if target is in direct line of sight, false otherwise.
//-----------------------------------------------------------------------------
bool CNPC_RocketTurret::TestLOS( const Vector& vAimPoint )
{
// Snap to face (for accurate traces)
QAngle vecOldAngles = m_vecCurrentAngles.m_Value;
Vector vecToAimPoint = vAimPoint - EyePosition();
VectorAngles( vecToAimPoint, m_vecCurrentAngles.m_Value );
SyncPoseToAimAngles();
Vector vFaceOrigin = EyePosition();
trace_t trTarget;
Ray_t ray;
ray.Init( vFaceOrigin, vAimPoint );
ray.m_IsRay = true;
// This aim point does hit target, now make sure there are no blocking objects in the way
CTraceFilterSimple filter ( this, COLLISION_GROUP_NONE );
UTIL_Portal_TraceRay( ray, MASK_VISIBLE_AND_NPCS, &filter, &trTarget, false );
// Set model back to current facing
m_vecCurrentAngles = vecOldAngles;
SyncPoseToAimAngles();
return ( trTarget.m_pEnt == GetEnemy() );
}
//-----------------------------------------------------------------------------
// Purpose: Tests all portals in the turret's vis for possible routes to see it's target point
// Input : pOutVec - The location to aim at in order to hit the target ent, choosing least rotation if multiple
// bConsiderNonPortalAimPoint - Output in pOutVec the non portal (direct) aimpoint if it requires the least rotation
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_RocketTurret::TestPortalsForLOS( Vector* pOutVec, bool bConsiderNonPortalAimPoint = false )
{
// Aim at the target through the world
CBaseEntity* pTarget = GetEnemy();
if ( !pTarget )
{
return false;
}
Vector vAimPoint = pTarget->GetAbsOrigin() + (pTarget->WorldAlignMins() + pTarget->WorldAlignMaxs()) * 0.5f;
int iPortalCount = CProp_Portal_Shared::AllPortals.Count();
if( iPortalCount == 0 )
{
*pOutVec = vAimPoint;
return false;
}
Vector vCurAim;
AngleVectors( m_vecCurrentAngles.m_Value, &vCurAim );
vCurAim.NormalizeInPlace();
CProp_Portal **pPortals = CProp_Portal_Shared::AllPortals.Base();
Vector *portalAimPoints = (Vector *)stackalloc( sizeof( Vector ) * iPortalCount );
bool *bUsable = (bool *)stackalloc( sizeof( bool ) * iPortalCount );
float *fPortalDot = (float *)stackalloc( sizeof( float ) * iPortalCount );
// Test through any active portals: This may be a shorter distance to the target
for( int i = 0; i != iPortalCount; ++i )
{
CProp_Portal *pTempPortal = pPortals[i];
if( !pTempPortal->m_bActivated ||
(pTempPortal->m_hLinkedPortal.Get() == NULL) )
{
//portalAimPoints[i] = vec3_invalid;
bUsable[i] = false;
continue;
}
bUsable[i] = FindAimPointThroughPortal( pPortals[ i ], &portalAimPoints[ i ] );
if ( 1 )
{
QAngle goalAngles;
Vector vecToEnemy = portalAimPoints[ i ] - EyePosition();
vecToEnemy.NormalizeInPlace();
// This value is for choosing the easiest aim point for the turret to see through.
// 'Easiest' is the least rotation needed.
fPortalDot[i] = DotProduct( vecToEnemy, vCurAim );
}
}
int iCountPortalsThatSeeTarget = 0;
float fHighestDot = -1.0;
if ( bConsiderNonPortalAimPoint )
{
QAngle enemyRotToFace;
Vector vecToEnemy = vAimPoint - EyePosition();
vecToEnemy.NormalizeInPlace();
fHighestDot = DotProduct( vecToEnemy, vCurAim );
}
// Compare aim points, use the closest aim point which has direct LOS
for( int i = 0; i != iPortalCount; ++i )
{
if( bUsable[i] )
{
// This aim point has direct LOS
if ( TestLOS( portalAimPoints[ i ] ) && fHighestDot < fPortalDot[ i ] )
{
*pOutVec = portalAimPoints[ i ];
fHighestDot = fPortalDot[ i ];
++iCountPortalsThatSeeTarget;
}
}
}
return (iCountPortalsThatSeeTarget != 0);
}
//-----------------------------------------------------------------------------
// Purpose: Find the center of the target entity as seen through the specified portal
// Input : pPortal - The portal to look through
// Output : Vector& output point in world space where the target *appears* to be as seen through the portal
//-----------------------------------------------------------------------------
bool CNPC_RocketTurret::FindAimPointThroughPortal( const CProp_Portal* pPortal, Vector* pVecOut )
{
if ( pPortal && pPortal->m_bActivated )
{
CProp_Portal* pLinked = pPortal->m_hLinkedPortal.Get();
CBaseEntity* pTarget = GetEnemy();
// Require that the portal is facing towards the beam to test through it
Vector vRocketToPortal, vPortalForward;
VectorSubtract ( pPortal->GetAbsOrigin(), EyePosition(), vRocketToPortal );
pPortal->GetVectors( &vPortalForward, NULL, NULL);
float fDot = DotProduct( vRocketToPortal, vPortalForward );
// Portal must be facing the turret, and have a linked partner
if ( fDot < 0.0f && pLinked && pLinked->m_bActivated && pTarget )
{
VMatrix matToPortalView = pLinked->m_matrixThisToLinked;
Vector vTargetAimPoint = pTarget->GetAbsOrigin() + (pTarget->WorldAlignMins() + pTarget->WorldAlignMaxs()) * 0.5f;
*pVecOut = matToPortalView * vTargetAimPoint;
return true;
}
}
// Bad portal pointer, not linked, no target or otherwise failed
return false;
}
void CNPC_RocketTurret::LaserOn( void )
{
// Set Locked sprite
m_iLaserState = 1;
}
void CNPC_RocketTurret::LaserOff( void )
{
// Set Locked sprite;
m_iLaserState = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Allows a generic think function before the others are called
// Input : state - which state the turret is currently in
//-----------------------------------------------------------------------------
bool CNPC_RocketTurret::PreThink( void )
{
StudioFrameAdvance();
CheckPVSCondition();
//Do not interrupt current think function
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Toggle the turret's state
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Toggle( void )
{
//Toggle the state
if ( m_bEnabled )
{
Disable();
}
else
{
Enable();
}
}
//-----------------------------------------------------------------------------
// Purpose: Enable the turret and deploy
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Enable( void )
{
if ( m_bEnabled )
return;
m_bEnabled = true;
ResetSequence( LookupSequence("open") );
SetThink( &CNPC_RocketTurret::OpeningThink );
SetNextThink( gpGlobals->curtime + 0.05 );
}
//-----------------------------------------------------------------------------
// Purpose: Retire the turret until enabled again
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Disable( void )
{
if ( !m_bEnabled )
return;
UpdateSkin( ROCKET_SKIN_IDLE );
m_bEnabled = false;
ResetSequence(LookupSequence("close"));
SetThink( &CNPC_RocketTurret::ClosingThink );
SetNextThink( gpGlobals->curtime + 0.05 );
SetEnemy( NULL );
}
//-----------------------------------------------------------------------------
// Purpose: Sets the enemy of this rocket
// Input : pTarget - the enemy to set
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::SetTarget( CBaseEntity* pTarget )
{
SetEnemy( pTarget );
}
//-----------------------------------------------------------------------------
// Purpose: Explode and set death think
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Destroy( void )
{
SetThink( &CNPC_RocketTurret::DyingThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::InputToggle( inputdata_t &inputdata )
{
Toggle();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::InputEnable( inputdata_t &inputdata )
{
Enable();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::InputDisable( inputdata_t &inputdata )
{
Disable();
}
void CNPC_RocketTurret::InputSetTarget( inputdata_t &inputdata )
{
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, inputdata.value.String(), NULL, NULL );
SetTarget( pTarget );
}
//-----------------------------------------------------------------------------
// Purpose: Plays some 'death' effects and sets the destroy think
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::InputDestroy( inputdata_t &inputdata )
{
Destroy();
}
//-----------------------------------------------------------------------------
// Projectile methods
//-----------------------------------------------------------------------------
void CRocket_Turret_Projectile::Spawn( void )
{
Precache();
BaseClass::Spawn();
SetTouch ( &CRocket_Turret_Projectile::MissileTouch );
CreateSounds();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOther -
//-----------------------------------------------------------------------------
void CRocket_Turret_Projectile::MissileTouch( CBaseEntity *pOther )
{
Assert( pOther );
Vector vVel = GetAbsVelocity();
// Touched a launcher, and is heading towards that launcher
if ( FClassnameIs( pOther, "npc_rocket_turret" ) )
{
Dissolve( NULL, gpGlobals->curtime + 0.1f, false, ENTITY_DISSOLVE_NORMAL );
Vector vBounceVel = Vector( -vVel.x, -vVel.y, 200 );
SetAbsVelocity ( vBounceVel * 0.1f );
QAngle vBounceAngles;
VectorAngles( vBounceVel, vBounceAngles );
SetAbsAngles ( vBounceAngles );
SetLocalAngularVelocity ( QAngle ( 180, 90, 45 ) );
UTIL_Remove ( m_hRocketTrail );
SetSolid ( SOLID_NONE );
if( m_hRocketTrail )
{
m_hRocketTrail->SetLifetime(0.1f);
m_hRocketTrail = NULL;
}
return;
}
// Don't touch triggers (but DO hit weapons)
if ( pOther->IsSolidFlagSet(FSOLID_TRIGGER|FSOLID_VOLUME_CONTENTS) && pOther->GetCollisionGroup() != COLLISION_GROUP_WEAPON )
return;
Explode();
}
void CRocket_Turret_Projectile::Precache( void )
{
BaseClass::Precache();
PrecacheScriptSound( ROCKET_PROJECTILE_LOOPING_SOUND );
}
void CRocket_Turret_Projectile::NotifyLauncherOnDeath( void )
{
CNPC_RocketTurret* pLauncher = (CNPC_RocketTurret*)m_hLauncher.Get();
if ( pLauncher )
{
pLauncher->RocketDied();
}
}
// When teleported (usually by portal)
void CRocket_Turret_Projectile::NotifySystemEvent(CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t &params )
{
// On teleport, we record a pointer to the portal we are arriving at
if ( eventType == NOTIFY_EVENT_TELEPORT )
{
// HACK: Clearing the owner allows collisions with launcher.
// Players have had trouble realizing a launcher's own rockets don't kill it
// because they didn't ever collide. We do this after a portal teleport so it avoids self-collisions on launch.
SetOwnerEntity( NULL );
// Restart smoke trail
UTIL_Remove( m_hRocketTrail );
m_hRocketTrail = NULL; // This shouldn't leak cause the pointer has been handed to the delete list
CreateSmokeTrail();
}
}
void CRocket_Turret_Projectile::SetLauncher ( EHANDLE hLauncher )
{
m_hLauncher = hLauncher;
}
void CRocket_Turret_Projectile::DoExplosion( void )
{
NotifyLauncherOnDeath();
StopLoopingSounds();
// Explode
ExplosionCreate( GetAbsOrigin(), GetAbsAngles(), GetOwnerEntity(), 200, 25,
SF_ENVEXPLOSION_NOSPARKS | SF_ENVEXPLOSION_NODLIGHTS | SF_ENVEXPLOSION_NOSMOKE, 100.0f, this);
// Hackish: Knock turrets in the area
CBaseEntity* pTurretIter = NULL;
while ( (pTurretIter = gEntList.FindEntityByClassnameWithin( pTurretIter, "npc_portal_turret_floor", GetAbsOrigin(), 128 )) != NULL )
{
CTakeDamageInfo info( this, this, 200, DMG_BLAST );
info.SetDamagePosition( GetAbsOrigin() );
CalculateExplosiveDamageForce( &info, (pTurretIter->GetAbsOrigin() - GetAbsOrigin()), GetAbsOrigin() );
pTurretIter->VPhysicsTakeDamage( info );
}
}
void CRocket_Turret_Projectile::CreateSounds()
{
if (!m_pAmbientSound)
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
CPASAttenuationFilter filter( this );
m_pAmbientSound = controller.SoundCreate( filter, entindex(), ROCKET_PROJECTILE_LOOPING_SOUND );
controller.Play( m_pAmbientSound, 1.0, 100 );
}
}
void CRocket_Turret_Projectile::StopLoopingSounds()
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundDestroy( m_pAmbientSound );
m_pAmbientSound = NULL;
BaseClass::StopLoopingSounds();
}
void CRocket_Turret_Projectile::CreateSmokeTrail( void )
{
if ( m_hRocketTrail )
return;
// Smoke trail.
if ( (m_hRocketTrail = RocketTrail::CreateRocketTrail()) != NULL )
{
m_hRocketTrail->m_Opacity = 0.2f;
m_hRocketTrail->m_SpawnRate = 100;
m_hRocketTrail->m_ParticleLifetime = 0.8f;
m_hRocketTrail->m_StartColor.Init( 0.65f, 0.65f , 0.65f );
m_hRocketTrail->m_EndColor.Init( 0.0, 0.0, 0.0 );
m_hRocketTrail->m_StartSize = 8;
m_hRocketTrail->m_EndSize = 32;
m_hRocketTrail->m_SpawnRadius = 4;
m_hRocketTrail->m_MinSpeed = 2;
m_hRocketTrail->m_MaxSpeed = 16;
m_hRocketTrail->SetLifetime( 999 );
m_hRocketTrail->FollowEntity( this, "0" );
}
}
static void fire_rocket_projectile_f( void )
{
CBasePlayer *pPlayer = (CBasePlayer *)UTIL_GetCommandClient();
Vector ptEyes, vForward;
QAngle vLookAng;
ptEyes = pPlayer->EyePosition();
pPlayer->EyeVectors( &vForward );
vLookAng = pPlayer->EyeAngles();
CRocket_Turret_Projectile *pRocket = (CRocket_Turret_Projectile *) CBaseEntity::Create( "rocket_turret_projectile", ptEyes, vLookAng, pPlayer );
if ( !pRocket )
return;
pRocket->SetThink( NULL );
pRocket->SetMoveType( MOVETYPE_FLY );
pRocket->SetModel( ROCKET_TURRET_PROJECTILE_NAME );
UTIL_SetSize( pRocket, vec3_origin, vec3_origin );
pRocket->CreateSmokeTrail();
pRocket->SetAbsVelocity( vForward * 550 );
pRocket->SetLauncher ( NULL );
}
ConCommand fire_rocket_projectile( "fire_rocket_projectile", fire_rocket_projectile_f, "Fires a rocket turret projectile from the player's eyes for testing.", FCVAR_CHEAT );
Reference in New Issue View Git Blame Copy Permalink