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.
77 Commits
25 Branches
6 Tags
221 MiB
Tree: 2a490d398c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2a490d398c'
${ noResults }
source-engine/game/server/hl2/npc_turret_floor.cpp

2331 lines
67 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "npc_turret_floor.h"
#include "ai_senses.h"
#include "ai_memory.h"
#include "engine/IEngineSound.h"
#include "ammodef.h"
#include "hl2/hl2_player.h"
#include "soundenvelope.h"
#include "physics_saverestore.h"
#include "IEffects.h"
#include "basehlcombatweapon_shared.h"
#include "phys_controller.h"
#include "ai_interactions.h"
#include "Sprite.h"
#include "beam_shared.h"
#include "props.h"
#include "particle_parse.h"
#ifdef PORTAL
#include "prop_portal_shared.h"
#include "portal_util_shared.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
const char *GetMassEquivalent(float flMass);
#define DISABLE_SHOT 0
//Debug visualization
ConVar g_debug_turret( "g_debug_turret", "0" );
extern ConVar physcannon_tracelength;
// Interactions
int g_interactionTurretStillStanding = 0;
float CNPC_FloorTurret::fMaxTipControllerVelocity = 300.0f * 300.0f;
float CNPC_FloorTurret::fMaxTipControllerAngularVelocity = 90.0f * 90.0f;
#define LASER_BEAM_SPRITE "effects/laser1.vmt"
#define FLOOR_TURRET_MODEL "models/combine_turrets/floor_turret.mdl"
#define FLOOR_TURRET_MODEL_CITIZEN "models/combine_turrets/citizen_turret.mdl"
#define FLOOR_TURRET_GLOW_SPRITE "sprites/glow1.vmt"
// #define FLOOR_TURRET_BC_YAW "aim_yaw"
// #define FLOOR_TURRET_BC_PITCH "aim_pitch"
#define FLOOR_TURRET_RANGE 1200
#define FLOOR_TURRET_MAX_WAIT 5
#define FLOOR_TURRET_SHORT_WAIT 2.0 // Used for FAST_RETIRE spawnflag
#define FLOOR_TURRET_PING_TIME 1.0f //LPB!!
#define FLOOR_TURRET_VOICE_PITCH_LOW 45
#define FLOOR_TURRET_VOICE_PITCH_HIGH 100
//Aiming variables
#define FLOOR_TURRET_MAX_NOHARM_PERIOD 0.0f
#define FLOOR_TURRET_MAX_GRACE_PERIOD 3.0f
//Activities
int ACT_FLOOR_TURRET_OPEN;
int ACT_FLOOR_TURRET_CLOSE;
int ACT_FLOOR_TURRET_OPEN_IDLE;
int ACT_FLOOR_TURRET_CLOSED_IDLE;
int ACT_FLOOR_TURRET_FIRE;
//Datatable
BEGIN_DATADESC( CNPC_FloorTurret )
DEFINE_FIELD( m_iAmmoType, FIELD_INTEGER ),
DEFINE_FIELD( m_bAutoStart, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bActive, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bBlinkState, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bNoAlarmSounds, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flShotTime, FIELD_TIME ),
DEFINE_FIELD( m_flLastSight, FIELD_TIME ),
DEFINE_FIELD( m_flThrashTime, FIELD_TIME ),
DEFINE_FIELD( m_flPingTime, FIELD_TIME ),
DEFINE_FIELD( m_flNextActivateSoundTime, FIELD_TIME ),
DEFINE_FIELD( m_bCarriedByPlayer, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bUseCarryAngles, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flPlayerDropTime, FIELD_TIME ),
DEFINE_FIELD( m_hLastNPCToKickMe, FIELD_EHANDLE ),
DEFINE_FIELD( m_flKnockOverFailedTime, FIELD_TIME ),
DEFINE_FIELD( m_flDestructStartTime, FIELD_TIME ),
DEFINE_FIELD( m_hFizzleEffect, FIELD_EHANDLE ),
DEFINE_FIELD( m_vecGoalAngles,FIELD_VECTOR ),
DEFINE_FIELD( m_iEyeAttachment, FIELD_INTEGER ),
DEFINE_FIELD( m_iMuzzleAttachment, FIELD_INTEGER ),
DEFINE_FIELD( m_iEyeState, FIELD_INTEGER ),
DEFINE_FIELD( m_hEyeGlow, FIELD_EHANDLE ),
DEFINE_FIELD( m_pMotionController,FIELD_EHANDLE),
DEFINE_FIELD( m_vecEnemyLKP, FIELD_VECTOR ),
DEFINE_FIELD( m_hLaser, FIELD_EHANDLE ),
DEFINE_FIELD( m_bSelfDestructing, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hPhysicsAttacker, FIELD_EHANDLE ),
DEFINE_FIELD( m_flLastPhysicsInfluenceTime, FIELD_TIME ),
DEFINE_FIELD( m_bHackedByAlyx, FIELD_BOOLEAN ),
DEFINE_KEYFIELD( m_iKeySkin, FIELD_INTEGER, "SkinNumber" ),
DEFINE_THINKFUNC( Retire ),
DEFINE_THINKFUNC( Deploy ),
DEFINE_THINKFUNC( ActiveThink ),
DEFINE_THINKFUNC( SearchThink ),
DEFINE_THINKFUNC( AutoSearchThink ),
DEFINE_THINKFUNC( TippedThink ),
DEFINE_THINKFUNC( InactiveThink ),
DEFINE_THINKFUNC( SuppressThink ),
DEFINE_THINKFUNC( DisabledThink ),
DEFINE_THINKFUNC( SelfDestructThink ),
DEFINE_THINKFUNC( BreakThink ),
DEFINE_USEFUNC( ToggleUse ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
DEFINE_INPUTFUNC( FIELD_VOID, "DepleteAmmo", InputDepleteAmmo ),
DEFINE_INPUTFUNC( FIELD_VOID, "RestoreAmmo", InputRestoreAmmo ),
DEFINE_INPUTFUNC( FIELD_VOID, "SelfDestruct", InputSelfDestruct ),
DEFINE_OUTPUT( m_OnDeploy, "OnDeploy" ),
DEFINE_OUTPUT( m_OnRetire, "OnRetire" ),
DEFINE_OUTPUT( m_OnTipped, "OnTipped" ),
DEFINE_OUTPUT( m_OnPhysGunPickup, "OnPhysGunPickup" ),
DEFINE_OUTPUT( m_OnPhysGunDrop, "OnPhysGunDrop" ),
DEFINE_BASENPCINTERACTABLE_DATADESC(),
// DEFINE_FIELD( m_ShotSounds, FIELD_SHORT ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( npc_turret_floor, CNPC_FloorTurret );
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CNPC_FloorTurret::CNPC_FloorTurret( void ) :
m_bActive( false ),
m_hEyeGlow( NULL ),
m_hLaser( NULL ),
m_iAmmoType( -1 ),
m_bAutoStart( false ),
m_flPingTime( 0.0f ),
m_flNextActivateSoundTime( 0.0f ),
m_bCarriedByPlayer( false ),
m_bUseCarryAngles( false ),
m_flPlayerDropTime( 0.0f ),
m_flShotTime( 0.0f ),
m_flLastSight( 0.0f ),
m_bBlinkState( false ),
m_flThrashTime( 0.0f ),
m_pMotionController( NULL ),
m_bEnabled( false ),
m_bSelfDestructing( false )
{
m_vecGoalAngles.Init();
m_vecEnemyLKP = vec3_invalid;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Class_T CNPC_FloorTurret::Classify( void )
{
if ( m_bEnabled )
{
// Hacked or friendly turrets don't attack players
if( m_bHackedByAlyx || IsCitizenTurret() )
return CLASS_PLAYER_ALLY;
return CLASS_COMBINE;
}
return CLASS_NONE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::UpdateOnRemove( void )
{
if ( m_pMotionController != NULL )
{
UTIL_Remove( m_pMotionController );
m_pMotionController = NULL;
}
if ( m_hLaser != NULL )
{
UTIL_Remove( m_hLaser );
m_hLaser = NULL;
}
if ( m_hEyeGlow != NULL )
{
UTIL_Remove( m_hEyeGlow );
m_hEyeGlow = NULL;
}
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose: Precache
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Precache( void )
{
const char *pModelName = STRING( GetModelName() );
pModelName = ( pModelName && pModelName[ 0 ] != '\0' ) ? pModelName : FLOOR_TURRET_MODEL;
PrecacheModel( pModelName );
PrecacheModel( FLOOR_TURRET_GLOW_SPRITE );
PropBreakablePrecacheAll( MAKE_STRING( pModelName ) );
if ( IsCitizenTurret() )
{
PrecacheModel( LASER_BEAM_SPRITE );
PrecacheScriptSound( "NPC_FloorTurret.AlarmPing");
}
// Activities
ADD_CUSTOM_ACTIVITY( CNPC_FloorTurret, ACT_FLOOR_TURRET_OPEN );
ADD_CUSTOM_ACTIVITY( CNPC_FloorTurret, ACT_FLOOR_TURRET_CLOSE );
ADD_CUSTOM_ACTIVITY( CNPC_FloorTurret, ACT_FLOOR_TURRET_CLOSED_IDLE );
ADD_CUSTOM_ACTIVITY( CNPC_FloorTurret, ACT_FLOOR_TURRET_OPEN_IDLE );
ADD_CUSTOM_ACTIVITY( CNPC_FloorTurret, ACT_FLOOR_TURRET_FIRE );
PrecacheScriptSound( "NPC_FloorTurret.Retire" );
PrecacheScriptSound( "NPC_FloorTurret.Deploy" );
PrecacheScriptSound( "NPC_FloorTurret.Move" );
PrecacheScriptSound( "NPC_Combine.WeaponBash" );
PrecacheScriptSound( "NPC_FloorTurret.Activate" );
PrecacheScriptSound( "NPC_FloorTurret.Alert" );
m_ShotSounds = PrecacheScriptSound( "NPC_FloorTurret.ShotSounds" );
PrecacheScriptSound( "NPC_FloorTurret.Die" );
PrecacheScriptSound( "NPC_FloorTurret.Retract");
PrecacheScriptSound( "NPC_FloorTurret.Alarm");
PrecacheScriptSound( "NPC_FloorTurret.Ping");
PrecacheScriptSound( "NPC_FloorTurret.DryFire");
PrecacheScriptSound( "NPC_FloorTurret.Destruct" );
#ifdef HL2_EPISODIC
PrecacheParticleSystem( "explosion_turret_break" );
#endif // HL2_EPISODIC
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose: Spawn the entity
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Spawn( void )
{
Precache();
const char *pModelName = STRING( GetModelName() );
SetModel( ( pModelName && pModelName[ 0 ] != '\0' ) ? pModelName : FLOOR_TURRET_MODEL );
// If we're a citizen turret, we use a different skin
if ( IsCitizenTurret() )
{
if (m_iKeySkin == 0)
{ // select a "random" skin -- rather than being truly random, use a static variable
// to cycle through them evenly. The static won't be saved across save/load, but
// frankly I don't care so much about that.
// m_nSkin = random->RandomInt( 1, 4 );
static unsigned int nextSkin = 0;
m_nSkin = nextSkin + 1;
// add one mod 4
nextSkin = (nextSkin + 1) & 0x03;
}
else
{ // at least make sure that it's in the right range
m_nSkin = clamp(m_iKeySkin,1,4);
}
}
BaseClass::Spawn();
SetBlocksLOS( false );
m_HackedGunPos = Vector( 0, 0, 12.75 );
SetViewOffset( EyeOffset( ACT_IDLE ) );
m_flFieldOfView = 0.4f; // 60 degrees
m_takedamage = DAMAGE_EVENTS_ONLY;
m_iHealth = 100;
m_iMaxHealth = 100;
AddEFlags( EFL_NO_DISSOLVE );
SetPoseParameter( m_poseAim_Yaw, 0 );
SetPoseParameter( m_poseAim_Pitch, 0 );
m_iAmmoType = GetAmmoDef()->Index( "PISTOL" );
m_iMuzzleAttachment = LookupAttachment( "eyes" );
m_iEyeAttachment = LookupAttachment( "light" );
// FIXME: Do we ever need m_bAutoStart? (Sawyer)
m_spawnflags |= SF_FLOOR_TURRET_AUTOACTIVATE;
//Set our autostart state
m_bAutoStart = !!( m_spawnflags & SF_FLOOR_TURRET_AUTOACTIVATE );
m_bEnabled = ( ( m_spawnflags & SF_FLOOR_TURRET_STARTINACTIVE ) == false );
//Do we start active?
if ( m_bAutoStart && m_bEnabled )
{
SetThink( &CNPC_FloorTurret::AutoSearchThink );
SetEyeState( TURRET_EYE_DORMANT );
}
else
{
SetThink( &CNPC_FloorTurret::DisabledThink );
SetEyeState( TURRET_EYE_DISABLED );
}
// Start
if ( OnSide() )
{
SetThink( &CNPC_FloorTurret::DisabledThink );
SetEyeState( TURRET_EYE_DISABLED );
}
//Stagger our starting times
SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.1f, 0.3f ) );
SetUse( &CNPC_FloorTurret::ToggleUse );
// Don't allow us to skip animation setup because our attachments are critical to us!
SetBoneCacheFlags( BCF_NO_ANIMATION_SKIP );
CreateVPhysics();
SetState(NPC_STATE_IDLE);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Activate( void )
{
BaseClass::Activate();
// Force the eye state to the current state so that our glows are recreated after transitions
SetEyeState( m_iEyeState );
if ( !m_pMotionController )
{
// Create the motion controller
m_pMotionController = CTurretTipController::CreateTipController( this );
// Enable the controller
if ( m_pMotionController != NULL )
{
m_pMotionController->Enable();
}
}
}
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::CreateVPhysics( void )
{
//Spawn our physics hull
if ( VPhysicsInitNormal( SOLID_VPHYSICS, 0, false ) == NULL )
{
DevMsg( "npc_turret_floor unable to spawn physics object!\n" );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Retract and stop attacking
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Retire( void )
{
if ( PreThink( TURRET_RETIRING ) )
return;
//Level out the turret
m_vecGoalAngles = GetAbsAngles();
SetNextThink( gpGlobals->curtime + 0.05f );
//Set ourselves to close
if ( GetActivity() != ACT_FLOOR_TURRET_CLOSE )
{
//Set our visible state to dormant
SetEyeState( TURRET_EYE_DORMANT );
SetActivity( (Activity) ACT_FLOOR_TURRET_OPEN_IDLE );
//If we're done moving to our desired facing, close up
if ( UpdateFacing() == false )
{
SetActivity( (Activity) ACT_FLOOR_TURRET_CLOSE );
EmitSound( "NPC_FloorTurret.Retire" );
//Notify of the retraction
m_OnRetire.FireOutput( NULL, this );
}
}
else if ( IsActivityFinished() )
{
m_bActive = false;
m_flLastSight = 0;
SetActivity( (Activity) ACT_FLOOR_TURRET_CLOSED_IDLE );
//Go back to auto searching
if ( m_bAutoStart )
{
SetThink( &CNPC_FloorTurret::AutoSearchThink );
SetNextThink( gpGlobals->curtime + 0.05f );
}
else
{
//Set our visible state to dormant
SetEyeState( TURRET_EYE_DISABLED );
SetThink( &CNPC_FloorTurret::DisabledThink );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Deploy and start attacking
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Deploy( void )
{
if ( PreThink( TURRET_DEPLOYING ) )
return;
m_vecGoalAngles = GetAbsAngles();
SetNextThink( gpGlobals->curtime + 0.05f );
//Show we've seen a target
SetEyeState( TURRET_EYE_SEE_TARGET );
//Open if we're not already
if ( GetActivity() != ACT_FLOOR_TURRET_OPEN )
{
m_bActive = true;
SetActivity( (Activity) ACT_FLOOR_TURRET_OPEN );
EmitSound( "NPC_FloorTurret.Deploy" );
//Notify we're deploying
m_OnDeploy.FireOutput( NULL, this );
}
//If we're done, then start searching
if ( IsActivityFinished() )
{
SetActivity( (Activity) ACT_FLOOR_TURRET_OPEN_IDLE );
m_flShotTime = gpGlobals->curtime + 1.0f;
m_flPlaybackRate = 0;
SetThink( &CNPC_FloorTurret::SearchThink );
EmitSound( "NPC_FloorTurret.Move" );
}
m_flLastSight = gpGlobals->curtime + FLOOR_TURRET_MAX_WAIT;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
{
m_hPhysicsAttacker = pPhysGunUser;
m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
// Drop our mass a lot so that we can be moved easily with +USE
if ( reason != PUNTED_BY_CANNON )
{
Assert( VPhysicsGetObject() );
m_bCarriedByPlayer = true;
m_OnPhysGunPickup.FireOutput( this, this );
// We want to use preferred carry angles if we're not nicely upright
Vector vecToTurret = pPhysGunUser->GetAbsOrigin() - GetAbsOrigin();
vecToTurret.z = 0;
VectorNormalize( vecToTurret );
// We want to use preferred carry angles if we're not nicely upright
Vector forward, up;
GetVectors( &forward, NULL, &up );
bool bUpright = DotProduct( up, Vector(0,0,1) ) > 0.9f;
bool bBehind = DotProduct( vecToTurret, forward ) < 0.85f;
// Correct our angles only if we're not upright or we're mostly behind the turret
if ( hl2_episodic.GetBool() )
{
m_bUseCarryAngles = ( bUpright == false || bBehind );
}
else
{
m_bUseCarryAngles = ( bUpright == false );
}
}
// Clear out our last NPC to kick me, because it makes no sense now
m_hLastNPCToKickMe = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
{
m_hPhysicsAttacker = pPhysGunUser;
m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
m_bCarriedByPlayer = false;
m_bUseCarryAngles = false;
m_OnPhysGunDrop.FireOutput( this, this );
// If this is a friendly turret, remember that it was just dropped
if ( IRelationType( pPhysGunUser ) != D_HT )
{
m_flPlayerDropTime = gpGlobals->curtime + 2.0;
}
// Restore our mass to the original value
Assert( VPhysicsGetObject() );
}
//-----------------------------------------------------------------------------
// Purpose: Whether this should return carry angles
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::HasPreferredCarryAnglesForPlayer( CBasePlayer *pPlayer )
{
// Don't use preferred angles on enemy turrets
if ( IRelationType( pPlayer ) == D_HT )
return false;
return m_bUseCarryAngles;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::OnAttemptPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
{
// Prevent players pulling enemy turrets from afar if they're in front of the turret
if ( reason == PICKED_UP_BY_CANNON && IRelationType( pPhysGunUser ) == D_HT )
{
Vector vecForward;
GetVectors( &vecForward, NULL, NULL );
Vector vecForce = (pPhysGunUser->GetAbsOrigin() - GetAbsOrigin());
float flDistance = VectorNormalize( vecForce );
// If it's over the physcannon tracelength, we're pulling it
if ( flDistance > physcannon_tracelength.GetFloat() )
{
float flDot = DotProduct( vecForward, vecForce );
if ( flDot > 0.5 )
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter *sourceEnt)
{
if ( interactionType == g_interactionCombineBash )
{
// We've been bashed by a combine soldier. Remember who it was, if we haven't got an active kicker
if ( !m_hLastNPCToKickMe )
{
m_hLastNPCToKickMe = sourceEnt;
m_flKnockOverFailedTime = gpGlobals->curtime + 3.0;
}
// Get knocked away
Vector forward, up;
AngleVectors( sourceEnt->GetLocalAngles(), &forward, NULL, &up );
ApplyAbsVelocityImpulse( forward * 100 + up * 50 );
CTakeDamageInfo info( sourceEnt, sourceEnt, 30, DMG_CLUB );
CalculateMeleeDamageForce( &info, forward, GetAbsOrigin() );
TakeDamage( info );
EmitSound( "NPC_Combine.WeaponBash" );
return true;
}
return BaseClass::HandleInteraction( interactionType, data, sourceEnt );
}
//-----------------------------------------------------------------------------
// Purpose: Returns the speed at which the turret can face a target
//-----------------------------------------------------------------------------
float CNPC_FloorTurret::MaxYawSpeed( void )
{
//TODO: Scale by difficulty?
return 360.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this turret was recently dropped by a player
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::WasJustDroppedByPlayer( void )
{
if ( m_flPlayerDropTime > gpGlobals->curtime )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Causes the turret to face its desired angles
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::UpdateFacing( void )
{
bool bMoved = false;
UpdateMuzzleMatrix();
Vector vecGoalDir;
AngleVectors( m_vecGoalAngles, &vecGoalDir );
Vector vecGoalLocalDir;
VectorIRotate( vecGoalDir, m_muzzleToWorld, vecGoalLocalDir );
if ( g_debug_turret.GetBool() )
{
Vector vecMuzzle, vecMuzzleDir;
MatrixGetColumn( m_muzzleToWorld, 3, vecMuzzle );
MatrixGetColumn( m_muzzleToWorld, 0, vecMuzzleDir );
NDebugOverlay::Cross3D( vecMuzzle, -Vector(2,2,2), Vector(2,2,2), 255, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMuzzle+(vecMuzzleDir*256), -Vector(2,2,2), Vector(2,2,2), 255, 255, 0, false, 0.05 );
NDebugOverlay::Line( vecMuzzle, vecMuzzle+(vecMuzzleDir*256), 255, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMuzzle, -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMuzzle+(vecGoalDir*256), -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 0.05 );
NDebugOverlay::Line( vecMuzzle, vecMuzzle+(vecGoalDir*256), 255, 0, 0, false, 0.05 );
}
QAngle vecGoalLocalAngles;
VectorAngles( vecGoalLocalDir, vecGoalLocalAngles );
// Update pitch
float flDiff = AngleNormalize( UTIL_ApproachAngle( vecGoalLocalAngles.x, 0.0, 0.05f * MaxYawSpeed() ) );
SetPoseParameter( m_poseAim_Pitch, GetPoseParameter( m_poseAim_Pitch ) + ( flDiff / 1.5f ) );
if ( fabs( flDiff ) > 0.1f )
{
bMoved = true;
}
// Update yaw
flDiff = AngleNormalize( UTIL_ApproachAngle( vecGoalLocalAngles.y, 0.0, 0.05f * MaxYawSpeed() ) );
SetPoseParameter( m_poseAim_Yaw, GetPoseParameter( m_poseAim_Yaw ) + ( flDiff / 1.5f ) );
if ( fabs( flDiff ) > 0.1f )
{
bMoved = true;
}
// You're going to make decisions based on this info. So bump the bone cache after you calculate everything
InvalidateBoneCache();
return bMoved;
}
void CNPC_FloorTurret::DryFire( void )
{
EmitSound( "NPC_FloorTurret.DryFire");
EmitSound( "NPC_FloorTurret.Activate" );
if ( RandomFloat( 0, 1 ) > 0.5 )
{
m_flShotTime = gpGlobals->curtime + random->RandomFloat( 1, 2.5 );
}
else
{
m_flShotTime = gpGlobals->curtime;
}
}
//-----------------------------------------------------------------------------
// Purpose: Turret will continue to fire on a target's position when it loses sight of it
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::SuppressThink( void )
{
//Allow descended classes a chance to do something before the think function
if ( PreThink( TURRET_SUPPRESSING ) )
return;
//Update our think time
SetNextThink( gpGlobals->curtime + 0.1f );
// Look for a new enemy
HackFindEnemy();
//If we've acquired an enemy, start firing at it
if ( !GetEnemy() )
{
SetThink( &CNPC_FloorTurret::ActiveThink );
return;
}
//See if we're done suppressing
if ( gpGlobals->curtime > m_flLastSight )
{
// Should we look for a new target?
ClearEnemyMemory();
SetEnemy( NULL );
SetThink( &CNPC_FloorTurret::SearchThink );
m_vecGoalAngles = GetAbsAngles();
SpinDown();
if ( m_spawnflags & SF_FLOOR_TURRET_FASTRETIRE )
{
// Retire quickly in this case. (The case where we saw the player, but he hid again).
m_flLastSight = gpGlobals->curtime + FLOOR_TURRET_SHORT_WAIT;
}
else
{
m_flLastSight = gpGlobals->curtime + FLOOR_TURRET_MAX_WAIT;
}
return;
}
//Get our shot positions
Vector vecMid = EyePosition();
Vector vecMidEnemy = m_vecEnemyLKP;
//Calculate dir and dist to enemy
Vector vecDirToEnemy = vecMidEnemy - vecMid;
//We want to look at the enemy's eyes so we don't jitter
Vector vecDirToEnemyEyes = vecMidEnemy - vecMid;
VectorNormalize( vecDirToEnemyEyes );
QAngle vecAnglesToEnemy;
VectorAngles( vecDirToEnemyEyes, vecAnglesToEnemy );
//Draw debug info
if ( g_debug_turret.GetBool() )
{
NDebugOverlay::Cross3D( vecMid, -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMidEnemy, -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 0.05 );
NDebugOverlay::Line( vecMid, vecMidEnemy, 0, 255, 0, false, 0.05f );
}
if ( m_flShotTime < gpGlobals->curtime && m_vecEnemyLKP != vec3_invalid )
{
Vector vecMuzzle, vecMuzzleDir;
UpdateMuzzleMatrix();
MatrixGetColumn( m_muzzleToWorld, 0, vecMuzzleDir );
MatrixGetColumn( m_muzzleToWorld, 3, vecMuzzle );
//Fire the gun
if ( DotProduct( vecDirToEnemy, vecMuzzleDir ) >= 0.9848 ) // 10 degree slop
{
if( m_spawnflags & SF_FLOOR_TURRET_OUT_OF_AMMO )
{
DryFire();
}
else
{
ResetActivity();
SetActivity( (Activity) ACT_FLOOR_TURRET_FIRE );
//Fire the weapon
#if !DISABLE_SHOT
Shoot( vecMuzzle, vecMuzzleDir );
#endif
}
}
}
else
{
SetActivity( (Activity) ACT_FLOOR_TURRET_OPEN_IDLE );
}
//If we can see our enemy, face it
m_vecGoalAngles.y = vecAnglesToEnemy.y;
m_vecGoalAngles.x = vecAnglesToEnemy.x;
//Turn to face
UpdateFacing();
}
//-----------------------------------------------------------------------------
// Purpose: Allows the turret to fire on targets if they're visible
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::ActiveThink( void )
{
//Allow descended classes a chance to do something before the think function
if ( PreThink( TURRET_ACTIVE ) )
return;
HackFindEnemy();
//Update our think time
SetNextThink( gpGlobals->curtime + 0.1f );
//If we've become inactive, go back to searching
if ( ( m_bActive == false ) || ( GetEnemy() == NULL ) )
{
SetEnemy( NULL );
m_flLastSight = gpGlobals->curtime + FLOOR_TURRET_MAX_WAIT;
SetThink( &CNPC_FloorTurret::SearchThink );
m_vecGoalAngles = GetAbsAngles();
return;
}
//Get our shot positions
Vector vecMid = EyePosition();
Vector vecMidEnemy = GetEnemy()->BodyTarget( vecMid );
// Store off our last seen location so we can suppress it later
m_vecEnemyLKP = vecMidEnemy;
//Look for our current enemy
bool bEnemyInFOV = FInViewCone( GetEnemy() );
bool bEnemyVisible = FVisible( GetEnemy() ) && GetEnemy()->IsAlive();
// Robin: This is a hack to get around the fact that the muzzle for the turret
// is outside it's vcollide. This means that if it leans against a thin wall,
// the muzzle can be on the other side of the wall, where it's then able to see
// and shoot at targets. This check ensures that nothing has come between the
// center of the turret and the muzzle.
if ( bEnemyVisible )
{
trace_t tr;
Vector vecCenter;
CollisionProp()->CollisionToWorldSpace( Vector(0,0,52), &vecCenter );
UTIL_TraceLine( vecCenter, vecMid, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
bEnemyVisible = false;
}
}
//Calculate dir and dist to enemy
Vector vecDirToEnemy = vecMidEnemy - vecMid;
float flDistToEnemy = VectorNormalize( vecDirToEnemy );
//Draw debug info
if ( g_debug_turret.GetBool() )
{
NDebugOverlay::Cross3D( vecMid, -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( GetEnemy()->WorldSpaceCenter(), -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 0.05 );
NDebugOverlay::Line( vecMid, GetEnemy()->WorldSpaceCenter(), 0, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMid, -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMidEnemy, -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 0.05 );
NDebugOverlay::Line( vecMid, vecMidEnemy, 0, 255, 0, false, 0.05f );
}
//See if they're past our FOV of attack
if ( bEnemyInFOV == false )
{
// Should we look for a new target?
ClearEnemyMemory();
SetEnemy( NULL );
if ( m_spawnflags & SF_FLOOR_TURRET_FASTRETIRE )
{
// Retire quickly in this case. (The case where we saw the player, but he hid again).
m_flLastSight = gpGlobals->curtime + FLOOR_TURRET_SHORT_WAIT;
}
else
{
m_flLastSight = gpGlobals->curtime + FLOOR_TURRET_MAX_WAIT;
}
SetThink( &CNPC_FloorTurret::SearchThink );
m_vecGoalAngles = GetAbsAngles();
SpinDown();
return;
}
//Current enemy is not visible
if ( ( bEnemyVisible == false ) || ( flDistToEnemy > FLOOR_TURRET_RANGE ))
{
m_flLastSight = gpGlobals->curtime + 2.0f;
ClearEnemyMemory();
SetEnemy( NULL );
SetThink( &CNPC_FloorTurret::SuppressThink );
return;
}
if ( g_debug_turret.GetBool() )
{
Vector vecMuzzle, vecMuzzleDir;
UpdateMuzzleMatrix();
MatrixGetColumn( m_muzzleToWorld, 0, vecMuzzleDir );
MatrixGetColumn( m_muzzleToWorld, 3, vecMuzzle );
// Visualize vertical firing ranges
for ( int i = 0; i < 4; i++ )
{
QAngle angMaxDownPitch = GetAbsAngles();
switch( i )
{
case 0: angMaxDownPitch.x -= 15; break;
case 1: angMaxDownPitch.x += 15; break;
case 2: angMaxDownPitch.x -= 25; break;
case 3: angMaxDownPitch.x += 25; break;
default:
break;
}
Vector vecMaxDownPitch;
AngleVectors( angMaxDownPitch, &vecMaxDownPitch );
NDebugOverlay::Line( vecMuzzle, vecMuzzle + (vecMaxDownPitch*256), 255, 255, 255, false, 0.1 );
}
}
if ( m_flShotTime < gpGlobals->curtime )
{
Vector vecMuzzle, vecMuzzleDir;
UpdateMuzzleMatrix();
MatrixGetColumn( m_muzzleToWorld, 0, vecMuzzleDir );
MatrixGetColumn( m_muzzleToWorld, 3, vecMuzzle );
Vector2D vecDirToEnemy2D = vecDirToEnemy.AsVector2D();
Vector2D vecMuzzleDir2D = vecMuzzleDir.AsVector2D();
bool bCanShoot = true;
float minCos3d = DOT_10DEGREE; // 10 degrees slop
if ( flDistToEnemy < 60.0 )
{
vecDirToEnemy2D.NormalizeInPlace();
vecMuzzleDir2D.NormalizeInPlace();
bCanShoot = ( vecDirToEnemy2D.Dot(vecMuzzleDir2D) >= DOT_10DEGREE );
minCos3d = 0.7071; // 45 degrees
}
//Fire the gun
if ( bCanShoot ) // 10 degree slop XY
{
float dot3d = DotProduct( vecDirToEnemy, vecMuzzleDir );
if( m_spawnflags & SF_FLOOR_TURRET_OUT_OF_AMMO )
{
DryFire();
}
else
{
if ( dot3d >= minCos3d )
{
ResetActivity();
SetActivity( (Activity) ACT_FLOOR_TURRET_FIRE );
//Fire the weapon
#if !DISABLE_SHOT
Shoot( vecMuzzle, vecMuzzleDir, (dot3d < DOT_10DEGREE) );
#endif
}
}
}
}
else
{
SetActivity( (Activity) ACT_FLOOR_TURRET_OPEN_IDLE );
}
//If we can see our enemy, face it
if ( bEnemyVisible )
{
//We want to look at the enemy's eyes so we don't jitter
Vector vecDirToEnemyEyes = GetEnemy()->WorldSpaceCenter() - vecMid;
VectorNormalize( vecDirToEnemyEyes );
QAngle vecAnglesToEnemy;
VectorAngles( vecDirToEnemyEyes, vecAnglesToEnemy );
m_vecGoalAngles.y = vecAnglesToEnemy.y;
m_vecGoalAngles.x = vecAnglesToEnemy.x;
}
//Turn to face
UpdateFacing();
}
//-----------------------------------------------------------------------------
// Purpose: Target doesn't exist or has eluded us, so search for one
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::SearchThink( void )
{
//Allow descended classes a chance to do something before the think function
if ( PreThink( TURRET_SEARCHING ) )
return;
SetNextThink( gpGlobals->curtime + 0.05f );
SetActivity( (Activity) ACT_FLOOR_TURRET_OPEN_IDLE );
//If our enemy has died, pick a new enemy
if ( ( GetEnemy() != NULL ) && ( GetEnemy()->IsAlive() == false ) )
{
SetEnemy( NULL );
}
//Acquire the target
if ( GetEnemy() == NULL )
{
HackFindEnemy();
}
//If we've found a target, spin up the barrel and start to attack
if ( GetEnemy() != NULL )
{
//Give players a grace period
if ( GetEnemy()->IsPlayer() )
{
m_flShotTime = gpGlobals->curtime + 0.5f;
}
else
{
m_flShotTime = gpGlobals->curtime + 0.1f;
}
m_flLastSight = 0;
SetThink( &CNPC_FloorTurret::ActiveThink );
SetEyeState( TURRET_EYE_SEE_TARGET );
SpinUp();
if ( gpGlobals->curtime > m_flNextActivateSoundTime )
{
EmitSound( "NPC_FloorTurret.Activate" );
m_flNextActivateSoundTime = gpGlobals->curtime + 3.0;
}
return;
}
//Are we out of time and need to retract?
if ( gpGlobals->curtime > m_flLastSight )
{
//Before we retrace, make sure that we are spun down.
m_flLastSight = 0;
SetThink( &CNPC_FloorTurret::Retire );
return;
}
//Display that we're scanning
m_vecGoalAngles.x = GetAbsAngles().x + ( sin( gpGlobals->curtime * 1.0f ) * 15.0f );
m_vecGoalAngles.y = GetAbsAngles().y + ( sin( gpGlobals->curtime * 2.0f ) * 60.0f );
//Turn and ping
UpdateFacing();
Ping();
}
//-----------------------------------------------------------------------------
// Purpose: Watch for a target to wander into our view
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::AutoSearchThink( void )
{
//Allow descended classes a chance to do something before the think function
if ( PreThink( TURRET_AUTO_SEARCHING ) )
return;
//Spread out our thinking
SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.2f, 0.4f ) );
//If the enemy is dead, find a new one
if ( ( GetEnemy() != NULL ) && ( GetEnemy()->IsAlive() == false ) )
{
SetEnemy( NULL );
}
//Acquire Target
if ( GetEnemy() == NULL )
{
HackFindEnemy();
}
//Deploy if we've got an active target
if ( GetEnemy() != NULL )
{
SetThink( &CNPC_FloorTurret::Deploy );
if ( !m_bNoAlarmSounds )
{
EmitSound( "NPC_FloorTurret.Alert" );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Fire!
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Shoot( const Vector &vecSrc, const Vector &vecDirToEnemy, bool bStrict )
{
FireBulletsInfo_t info;
if ( !bStrict && GetEnemy() != NULL )
{
Vector vecDir = GetActualShootTrajectory( vecSrc );
info.m_vecSrc = vecSrc;
info.m_vecDirShooting = vecDir;
info.m_iTracerFreq = 1;
info.m_iShots = 1;
info.m_pAttacker = this;
info.m_vecSpread = VECTOR_CONE_PRECALCULATED;
info.m_flDistance = MAX_COORD_RANGE;
info.m_iAmmoType = m_iAmmoType;
}
else
{
info.m_vecSrc = vecSrc;
info.m_vecDirShooting = vecDirToEnemy;
info.m_iTracerFreq = 1;
info.m_iShots = 1;
info.m_pAttacker = this;
info.m_vecSpread = GetAttackSpread( NULL, GetEnemy() );
info.m_flDistance = MAX_COORD_RANGE;
info.m_iAmmoType = m_iAmmoType;
}
FireBullets( info );
EmitSound( "NPC_FloorTurret.ShotSounds", m_ShotSounds );
DoMuzzleFlash();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEnemy -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::IsValidEnemy( CBaseEntity *pEnemy )
{
if ( m_NPCState == NPC_STATE_DEAD )
return false;
// Don't shoot at other turrets.
if ( pEnemy->m_iClassname == m_iClassname )
return false;
// If our eye is stuck in something, don't shoot
if ( UTIL_PointContents(EyePosition()) & MASK_SHOT )
return false;
// Turrets have limited vertical aim capability
// - Can only aim +-15 degrees, + the 10 degree slop they're allowed.
Vector vEnemyPos = pEnemy->EyePosition();
#ifdef PORTAL
if ( !FInViewCone( pEnemy ) || !FVisible( pEnemy ) )
{
CProp_Portal *pPortal = FInViewConeThroughPortal( pEnemy );
if ( pPortal )
{
// Translate our target across the portal
UTIL_Portal_PointTransform( pPortal->m_hLinkedPortal->MatrixThisToLinked(), vEnemyPos, vEnemyPos );
}
}
#endif
Vector los = ( vEnemyPos - EyePosition() );
QAngle angleToTarget;
VectorAngles( los, angleToTarget );
float flZDiff = fabs( AngleNormalize( angleToTarget.x - GetAbsAngles().x) );
if ( flZDiff > 28.0f && los.LengthSqr() > 4096.0f )
return false;
return BaseClass::IsValidEnemy( pEnemy );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEnemy -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::CanBeAnEnemyOf( CBaseEntity *pEnemy )
{
// If we're out of ammo, make friendly companions ignore us
if ( m_spawnflags & SF_FLOOR_TURRET_OUT_OF_AMMO )
{
if ( pEnemy->Classify() == CLASS_PLAYER_ALLY_VITAL )
return false;
}
// If we're on the side, we're never anyone's enemy
if ( OnSide() )
return false;
return BaseClass::CanBeAnEnemyOf( pEnemy );
}
//-----------------------------------------------------------------------------
// Purpose: The turret has been tipped over and will thrash for awhile
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::TippedThink( void )
{
// Update our PVS state
CheckPVSCondition();
//Animate
StudioFrameAdvance();
SetNextThink( gpGlobals->curtime + 0.05f );
SetEnemy( NULL );
// If we're not on side anymore, stop thrashing
if ( !OnSide() )
{
ReturnToLife();
return;
}
//See if we should continue to thrash
if ( gpGlobals->curtime < m_flThrashTime )
{
if ( m_flShotTime < gpGlobals->curtime )
{
if( m_spawnflags & SF_FLOOR_TURRET_OUT_OF_AMMO )
{
DryFire();
}
else if ( IsCitizenTurret() == false ) // Citizen turrets don't wildly fire
{
Vector vecMuzzle, vecMuzzleDir;
UpdateMuzzleMatrix();
MatrixGetColumn( m_muzzleToWorld, 0, vecMuzzleDir );
MatrixGetColumn( m_muzzleToWorld, 3, vecMuzzle );
ResetActivity();
SetActivity( (Activity) ACT_FLOOR_TURRET_FIRE );
#if !DISABLE_SHOT
Shoot( vecMuzzle, vecMuzzleDir );
#endif
}
m_flShotTime = gpGlobals->curtime + 0.05f;
}
m_vecGoalAngles.x = GetAbsAngles().x + random->RandomFloat( -60, 60 );
m_vecGoalAngles.y = GetAbsAngles().y + random->RandomFloat( -60, 60 );
UpdateFacing();
}
else
{
//Face forward
m_vecGoalAngles = GetAbsAngles();
//Set ourselves to close
if ( GetActivity() != ACT_FLOOR_TURRET_CLOSE )
{
SetActivity( (Activity) ACT_FLOOR_TURRET_OPEN_IDLE );
//If we're done moving to our desired facing, close up
if ( UpdateFacing() == false )
{
//Make any last death noises and anims
EmitSound( "NPC_FloorTurret.Die" );
SpinDown();
SetActivity( (Activity) ACT_FLOOR_TURRET_CLOSE );
EmitSound( "NPC_FloorTurret.Retract" );
CTakeDamageInfo info;
info.SetDamage( 1 );
info.SetDamageType( DMG_CRUSH );
Event_Killed( info );
}
}
else if ( IsActivityFinished() )
{
m_bActive = false;
m_flLastSight = 0;
SetActivity( (Activity) ACT_FLOOR_TURRET_CLOSED_IDLE );
// Don't need to store last NPC anymore, because I've been knocked over
if ( m_hLastNPCToKickMe )
{
m_hLastNPCToKickMe = NULL;
m_flKnockOverFailedTime = 0;
}
//Try to look straight
if ( UpdateFacing() == false )
{
m_OnTipped.FireOutput( this, this );
SetEyeState( TURRET_EYE_DEAD );
SetCollisionGroup( COLLISION_GROUP_DEBRIS_TRIGGER );
// Start thinking slowly to see if we're ever set upright somehow
SetThink( &CNPC_FloorTurret::InactiveThink );
SetNextThink( gpGlobals->curtime + 1.0f );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: This turret is dead. See if it ever becomes upright again, and if
// so, become active again.
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::InactiveThink( void )
{
// Update our PVS state
CheckPVSCondition();
// Wake up if we're not on our side
if ( !OnSide() && m_bEnabled )
{
ReturnToLife();
return;
}
if ( IsCitizenTurret() )
{
// Blink if we have ammo or our current blink is "on" and we need to turn it off again
if ( HasSpawnFlags( SF_FLOOR_TURRET_OUT_OF_AMMO ) == false || m_bBlinkState )
{
// If we're on our side, ping and complain to the player
if ( m_bBlinkState == false )
{
// Ping when the light is going to come back on
EmitSound( "NPC_FloorTurret.AlarmPing" );
}
SetEyeState( TURRET_EYE_ALARM );
SetNextThink( gpGlobals->curtime + 0.25f );
}
}
else
{
SetNextThink( gpGlobals->curtime + 1.0f );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::ReturnToLife( void )
{
m_flThrashTime = 0;
// Enable the tip controller
m_pMotionController->Enable( true );
// Return to life
SetState( NPC_STATE_IDLE );
m_lifeState = LIFE_ALIVE;
SetCollisionGroup( COLLISION_GROUP_NONE );
// Become active again
Enable();
}
//-----------------------------------------------------------------------------
// Purpose: The turret is not doing anything at all
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::DisabledThink( void )
{
SetNextThink( gpGlobals->curtime + 0.5 );
if ( OnSide() )
{
m_OnTipped.FireOutput( this, this );
SetEyeState( TURRET_EYE_DEAD );
SetCollisionGroup( COLLISION_GROUP_DEBRIS );
SetThink( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose: The turret doesn't run base AI properly, which is a bad decision.
// As a result, it has to manually find enemies.
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::HackFindEnemy( void )
{
// We have to refresh our memories before finding enemies, so
// dead enemies are cleared out before new ones are added.
GetEnemies()->RefreshMemories();
GetSenses()->Look( FLOOR_TURRET_RANGE );
SetEnemy( BestEnemy() );
}
//-----------------------------------------------------------------------------
// Purpose: Determines whether the turret is upright enough to function
// Output : Returns true if the turret is tipped over
//-----------------------------------------------------------------------------
inline bool CNPC_FloorTurret::OnSide( void )
{
Vector up;
GetVectors( NULL, NULL, &up );
return ( DotProduct( up, Vector(0,0,1) ) < 0.5f );
}
//-----------------------------------------------------------------------------
// Purpose: Allows a generic think function before the others are called
// Input : state - which state the turret is currently in
//-----------------------------------------------------------------------------
bool CNPC_FloorTurret::PreThink( turretState_e state )
{
// Hack to disable turrets when ai is disabled
if ( CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI )
{
// Push our think out into the future
SetNextThink( gpGlobals->curtime + 0.1f );
return true;
}
CheckPVSCondition();
//Animate
StudioFrameAdvance();
// We're gonna blow up, so don't interrupt us
if ( state == TURRET_SELF_DESTRUCTING )
return false;
//See if we've tipped, but only do this if we're not being carried
if ( !IsBeingCarriedByPlayer() )
{
if ( OnSide() == false )
{
// If I still haven't fallen over after an NPC has tried to knock me down, let them know
if ( m_hLastNPCToKickMe && m_flKnockOverFailedTime < gpGlobals->curtime )
{
m_hLastNPCToKickMe->DispatchInteraction( g_interactionTurretStillStanding, NULL, this );
m_hLastNPCToKickMe = NULL;
}
//Debug visualization
if ( g_debug_turret.GetBool() )
{
Vector up;
GetVectors( NULL, NULL, &up );
NDebugOverlay::Line( GetAbsOrigin()+(up*32), GetAbsOrigin()+(up*128), 0, 255, 0, false, 2.0f );
NDebugOverlay::Cross3D( GetAbsOrigin()+(up*32), -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 2.0f );
NDebugOverlay::Cross3D( GetAbsOrigin()+(up*128), -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, false, 2.0f );
}
}
else
{
if ( HasSpawnFlags( SF_FLOOR_TURRET_OUT_OF_AMMO ) == false )
{
//Thrash around for a bit
m_flThrashTime = gpGlobals->curtime + random->RandomFloat( 2.0f, 2.5f );
SetNextThink( gpGlobals->curtime + 0.05f );
SetThink( &CNPC_FloorTurret::TippedThink );
SetEyeState( TURRET_EYE_SEE_TARGET );
SpinUp();
if ( !m_bNoAlarmSounds )
{
EmitSound( "NPC_FloorTurret.Alarm" );
}
}
else
{
// Take away the laser
UTIL_Remove( m_hLaser );
m_hLaser = NULL;
// Become inactive
SetThink( &CNPC_FloorTurret::InactiveThink );
SetEyeState( TURRET_EYE_DEAD );
}
//Stop being targetted
SetState( NPC_STATE_DEAD );
m_lifeState = LIFE_DEAD;
//Disable the tip controller
m_pMotionController->Enable( false );
//Debug visualization
if ( g_debug_turret.GetBool() )
{
Vector up;
GetVectors( NULL, NULL, &up );
NDebugOverlay::Line( GetAbsOrigin()+(up*32), GetAbsOrigin()+(up*128), 255, 0, 0, false, 2.0f );
NDebugOverlay::Cross3D( GetAbsOrigin()+(up*32), -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 2.0f );
NDebugOverlay::Cross3D( GetAbsOrigin()+(up*128), -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 2.0f );
}
//Interrupt current think function
return true;
}
}
//Do not interrupt current think function
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the state of the glowing eye attached to the turret
// Input : state - state the eye should be in
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::SetEyeState( eyeState_t state )
{
// Must have a valid eye to affect
if ( !m_hEyeGlow )
{
// Create our eye sprite
m_hEyeGlow = CSprite::SpriteCreate( FLOOR_TURRET_GLOW_SPRITE, GetLocalOrigin(), false );
if ( !m_hEyeGlow )
return;
m_hEyeGlow->SetTransparency( kRenderWorldGlow, 255, 0, 0, 128, kRenderFxNoDissipation );
m_hEyeGlow->SetAttachment( this, m_iEyeAttachment );
}
// Add the laser if it doesn't already exist
if ( IsCitizenTurret() && HasSpawnFlags( SF_FLOOR_TURRET_OUT_OF_AMMO ) == false && m_hLaser == NULL )
{
m_hLaser = CBeam::BeamCreate( LASER_BEAM_SPRITE, 1.0f );
if ( m_hLaser == NULL )
return;
m_hLaser->EntsInit( this, this );
m_hLaser->FollowEntity( this );
m_hLaser->SetStartAttachment( LookupAttachment( "laser_start" ) );
m_hLaser->SetEndAttachment( LookupAttachment( "laser_end" ) );
m_hLaser->SetNoise( 0 );
m_hLaser->SetColor( 255, 0, 0 );
m_hLaser->SetScrollRate( 0 );
m_hLaser->SetWidth( 1.0f );
m_hLaser->SetEndWidth( 1.0f );
m_hLaser->SetBrightness( 160 );
m_hLaser->SetBeamFlags( SF_BEAM_SHADEIN );
}
m_iEyeState = state;
//Set the state
switch( state )
{
default:
case TURRET_EYE_SEE_TARGET: //Fade in and scale up
m_hEyeGlow->SetColor( 255, 0, 0 );
m_hEyeGlow->SetBrightness( 164, 0.1f );
m_hEyeGlow->SetScale( 0.4f, 0.1f );
break;
case TURRET_EYE_SEEKING_TARGET: //Ping-pongs
//Toggle our state
m_bBlinkState = !m_bBlinkState;
m_hEyeGlow->SetColor( 255, 128, 0 );
if ( m_bBlinkState )
{
//Fade up and scale up
m_hEyeGlow->SetScale( 0.25f, 0.1f );
m_hEyeGlow->SetBrightness( 164, 0.1f );
}
else
{
//Fade down and scale down
m_hEyeGlow->SetScale( 0.2f, 0.1f );
m_hEyeGlow->SetBrightness( 64, 0.1f );
}
break;
case TURRET_EYE_DORMANT: //Fade out and scale down
m_hEyeGlow->SetColor( 0, 255, 0 );
m_hEyeGlow->SetScale( 0.1f, 0.5f );
m_hEyeGlow->SetBrightness( 64, 0.5f );
break;
case TURRET_EYE_DEAD: //Fade out slowly
m_hEyeGlow->SetColor( 255, 0, 0 );
m_hEyeGlow->SetScale( 0.1f, 3.0f );
m_hEyeGlow->SetBrightness( 0, 3.0f );
break;
case TURRET_EYE_DISABLED:
m_hEyeGlow->SetColor( 0, 255, 0 );
m_hEyeGlow->SetScale( 0.1f, 1.0f );
m_hEyeGlow->SetBrightness( 0, 1.0f );
break;
case TURRET_EYE_ALARM:
{
//Toggle our state
m_bBlinkState = !m_bBlinkState;
m_hEyeGlow->SetColor( 255, 0, 0 );
if ( m_bBlinkState )
{
//Fade up and scale up
m_hEyeGlow->SetScale( 0.75f, 0.05f );
m_hEyeGlow->SetBrightness( 192, 0.05f );
}
else
{
//Fade down and scale down
m_hEyeGlow->SetScale( 0.25f, 0.25f );
m_hEyeGlow->SetBrightness( 64, 0.25f );
}
}
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Make a pinging noise so the player knows where we are
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Ping( void )
{
//See if it's time to ping again
if ( m_flPingTime > gpGlobals->curtime )
return;
//Ping!
EmitSound( "NPC_FloorTurret.Ping" );
SetEyeState( TURRET_EYE_SEEKING_TARGET );
m_flPingTime = gpGlobals->curtime + FLOOR_TURRET_PING_TIME;
}
//-----------------------------------------------------------------------------
// Purpose: Toggle the turret's state
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Toggle( void )
{
//This turret is on its side, it can't function
if ( OnSide() || ( IsAlive() == false ) )
return;
//Toggle the state
if ( m_bEnabled )
{
Disable();
}
else
{
Enable();
}
}
//-----------------------------------------------------------------------------
// Purpose: Enable the turret and deploy
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Enable( void )
{
// Don't interrupt blowing up!
if ( m_bSelfDestructing )
return;
// Always allow us to come back to life, even if not right now
m_bEnabled = true;
//This turret is on its side, it can't function
if ( OnSide() || ( IsAlive() == false ) )
return;
// if the turret is flagged as an autoactivate turret, re-enable its ability open self.
if ( m_spawnflags & SF_FLOOR_TURRET_AUTOACTIVATE )
{
m_bAutoStart = true;
}
SetThink( &CNPC_FloorTurret::Deploy );
SetNextThink( gpGlobals->curtime + 0.05f );
}
//-----------------------------------------------------------------------------
// Purpose: Retire the turret until enabled again
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::Disable( void )
{
//This turret is on its side, it can't function
if ( OnSide() || ( IsAlive() == false ) || m_bSelfDestructing )
return;
if ( m_bEnabled )
{
m_bEnabled = false;
m_bAutoStart = false;
SetEnemy( NULL );
SetThink( &CNPC_FloorTurret::Retire );
SetNextThink( gpGlobals->curtime + 0.1f );
}
else
SetThink( &CNPC_FloorTurret::DisabledThink );
}
//-----------------------------------------------------------------------------
// Purpose: Toggle the turret's state via input function
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::InputToggle( inputdata_t &inputdata )
{
Toggle();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::InputEnable( inputdata_t &inputdata )
{
Enable();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::InputDisable( inputdata_t &inputdata )
{
Disable();
}
//-----------------------------------------------------------------------------
// Purpose: Stops the turret from firing live rounds (still attempts to though)
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::InputDepleteAmmo( inputdata_t &inputdata )
{
AddSpawnFlags( SF_FLOOR_TURRET_OUT_OF_AMMO );
}
//-----------------------------------------------------------------------------
// Purpose: Allows the turret to fire live rounds again
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::InputRestoreAmmo( inputdata_t &inputdata )
{
RemoveSpawnFlags( SF_FLOOR_TURRET_OUT_OF_AMMO );
}
//-----------------------------------------------------------------------------
// Purpose: Allow players and npc's to turn the turret on and off
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::ToggleUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
switch( useType )
{
case USE_OFF:
Disable();
break;
case USE_ON:
Enable();
break;
case USE_SET:
break;
case USE_TOGGLE:
Toggle( );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Reduce physics forces from the front
//-----------------------------------------------------------------------------
int CNPC_FloorTurret::VPhysicsTakeDamage( const CTakeDamageInfo &info )
{
bool bShouldIgnoreFromFront = false;
// Ignore crossbow bolts hitting us from the front
bShouldIgnoreFromFront = ( info.GetDamageType() & DMG_BULLET ) != 0;
// Ignore bullets from the front
if ( !bShouldIgnoreFromFront )
{
bShouldIgnoreFromFront = FClassnameIs( info.GetInflictor(), "crossbow_bolt" );
}
// Did it hit us on the front?
if ( bShouldIgnoreFromFront )
{
Vector vecForward;
GetVectors( &vecForward, NULL, NULL );
Vector vecForce = info.GetDamageForce();
VectorNormalize( vecForce );
float flDot = DotProduct( vecForward, vecForce );
if ( flDot < -0.85 )
return 0;
}
return BaseClass::VPhysicsTakeDamage( info );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
//-----------------------------------------------------------------------------
int CNPC_FloorTurret::OnTakeDamage( const CTakeDamageInfo &info )
{
CTakeDamageInfo newInfo = info;
if ( info.GetDamageType() & (DMG_SLASH|DMG_CLUB) )
{
// Take extra force from melee hits
newInfo.ScaleDamageForce( 2.0f );
// Disable our upright controller for some time
if ( m_pMotionController != NULL )
{
m_pMotionController->Suspend( 2.0f );
}
}
else if ( info.GetDamageType() & DMG_BLAST )
{
newInfo.ScaleDamageForce( 2.0f );
}
else if ( (info.GetDamageType() & DMG_BULLET) && !(info.GetDamageType() & DMG_BUCKSHOT) )
{
// Bullets, but not buckshot, do extra push
newInfo.ScaleDamageForce( 2.5f );
}
// Manually apply vphysics because AI_BaseNPC takedamage doesn't call back to CBaseEntity OnTakeDamage
VPhysicsTakeDamage( newInfo );
// Bump up our search time
m_flLastSight = gpGlobals->curtime + FLOOR_TURRET_MAX_WAIT;
// Start looking around in anger if we were idle
if ( IsAlive() && m_bEnabled && m_bAutoStart && GetActivity() == ACT_FLOOR_TURRET_CLOSED_IDLE && m_bSelfDestructing == false )
{
SetThink( &CNPC_FloorTurret::Deploy );
}
return BaseClass::OnTakeDamage( newInfo );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::SpinUp( void )
{
}
#define FLOOR_TURRET_MIN_SPIN_DOWN 1.0f
//-----------------------------------------------------------------------------
// Purpose:
// Output : const QAngle
//-----------------------------------------------------------------------------
QAngle CNPC_FloorTurret::PreferredCarryAngles( void )
{
// FIXME: Embed this into the class
static QAngle g_prefAngles;
Vector vecUserForward;
CBasePlayer *pPlayer = AI_GetSinglePlayer();
pPlayer->EyeVectors( &vecUserForward );
// If we're looking up, then face directly forward
if ( vecUserForward.z >= 0.0f )
return vec3_angle;
// Otherwise, stay "upright"
g_prefAngles.Init();
g_prefAngles.x = -pPlayer->EyeAngles().x;
return g_prefAngles;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::SpinDown( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pVictim -
// Output : float
//-----------------------------------------------------------------------------
float CNPC_FloorTurret::GetAttackDamageScale( CBaseEntity *pVictim )
{
CBaseCombatCharacter *pBCC = pVictim->MyCombatCharacterPointer();
// Do extra damage to antlions & combine
if ( pBCC )
{
if ( pBCC->Classify() == CLASS_ANTLION )
return 2.0;
if ( pBCC->Classify() == CLASS_COMBINE )
return 2.0;
}
return BaseClass::GetAttackDamageScale( pVictim );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Vector CNPC_FloorTurret::GetAttackSpread( CBaseCombatWeapon *pWeapon, CBaseEntity *pTarget )
{
WeaponProficiency_t weaponProficiency = WEAPON_PROFICIENCY_AVERAGE;
// Switch our weapon proficiency based upon our target
if ( pTarget )
{
if ( pTarget->Classify() == CLASS_PLAYER || pTarget->Classify() == CLASS_ANTLION || pTarget->Classify() == CLASS_ZOMBIE )
{
// Make me much more accurate
weaponProficiency = WEAPON_PROFICIENCY_PERFECT;
}
else if ( pTarget->Classify() == CLASS_COMBINE )
{
// Make me more accurate
weaponProficiency = WEAPON_PROFICIENCY_VERY_GOOD;
}
}
return VECTOR_CONE_10DEGREES * ((CBaseHLCombatWeapon::GetDefaultProficiencyValues())[ weaponProficiency ].spreadscale);
}
//------------------------------------------------------------------------------
// Do we have a physics attacker?
//------------------------------------------------------------------------------
CBasePlayer *CNPC_FloorTurret::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: Draw any debug text overlays
// Output : Current text offset from the top
//-----------------------------------------------------------------------------
int CNPC_FloorTurret::DrawDebugTextOverlays( void )
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
if (VPhysicsGetObject())
{
char tempstr[512];
Q_snprintf(tempstr, sizeof(tempstr),"Mass: %.2f kg / %.2f lb (%s)", VPhysicsGetObject()->GetMass(), kg2lbs(VPhysicsGetObject()->GetMass()), GetMassEquivalent(VPhysicsGetObject()->GetMass()));
EntityText( text_offset, tempstr, 0);
text_offset++;
}
}
return text_offset;
}
void CNPC_FloorTurret::UpdateMuzzleMatrix()
{
if ( gpGlobals->tickcount != m_muzzleToWorldTick )
{
m_muzzleToWorldTick = gpGlobals->tickcount;
GetAttachment( m_iMuzzleAttachment, m_muzzleToWorld );
}
}
//-----------------------------------------------------------------------------
// Purpose: We override this code because otherwise we start to move into the
// tricky realm of player avoidance. Since we don't go through the
// normal NPC thinking but we ARE an NPC (...) we miss a bunch of
// book keeping. This means we can become invisible and then never
// reappear.
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::PlayerPenetratingVPhysics( void )
{
// We don't care!
}
#define SELF_DESTRUCT_DURATION 4.0f
#define SELF_DESTRUCT_BEEP_MIN_DELAY 0.1f
#define SELF_DESTRUCT_BEEP_MAX_DELAY 0.75f
#define SELF_DESTRUCT_BEEP_MIN_PITCH 100.0f
#define SELF_DESTRUCT_BEEP_MAX_PITCH 225.0f
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::BreakThink( void )
{
Vector vecUp;
GetVectors( NULL, NULL, &vecUp );
Vector vecOrigin = WorldSpaceCenter() + ( vecUp * 12.0f );
// Our effect
#ifdef HL2_EPISODIC
DispatchParticleEffect( "explosion_turret_break", vecOrigin, GetAbsAngles() );
#endif // HL2_EPISODIC
// K-boom
RadiusDamage( CTakeDamageInfo( this, this, 15.0f, DMG_BLAST ), vecOrigin, (10*12), CLASS_NONE, this );
EmitSound( "NPC_FloorTurret.Destruct" );
breakablepropparams_t params( GetAbsOrigin(), GetAbsAngles(), vec3_origin, RandomAngularImpulse( -800.0f, 800.0f ) );
params.impactEnergyScale = 1.0f;
params.defCollisionGroup = COLLISION_GROUP_INTERACTIVE;
// no damage/damage force? set a burst of 100 for some movement
params.defBurstScale = 100;
PropBreakableCreateAll( GetModelIndex(), VPhysicsGetObject(), params, this, -1, true );
// Throw out some small chunks too obscure the explosion even more
CPVSFilter filter( vecOrigin );
for ( int i = 0; i < 4; i++ )
{
Vector gibVelocity = RandomVector(-100,100);
int iModelIndex = modelinfo->GetModelIndex( g_PropDataSystem.GetRandomChunkModel( "MetalChunks" ) );
te->BreakModel( filter, 0.0, vecOrigin, GetAbsAngles(), Vector(40,40,40), gibVelocity, iModelIndex, 150, 4, 2.5, BREAK_METAL );
}
// We're done!
UTIL_Remove( this );
}
//-----------------------------------------------------------------------------
// Purpose: The countdown to destruction!
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::SelfDestructThink( void )
{
// Continue to animate
PreThink( TURRET_SELF_DESTRUCTING );
// If we're done, explode
if ( ( gpGlobals->curtime - m_flDestructStartTime ) >= SELF_DESTRUCT_DURATION )
{
SetThink( &CNPC_FloorTurret::BreakThink );
SetNextThink( gpGlobals->curtime + 0.1f );
UTIL_Remove( m_hFizzleEffect );
m_hFizzleEffect = NULL;
return;
}
// Find out where we are in the cycle of our destruction
float flDestructPerc = clamp( ( gpGlobals->curtime - m_flDestructStartTime ) / SELF_DESTRUCT_DURATION, 0.0f, 1.0f );
// Figure out when our next beep should occur
float flBeepTime = SELF_DESTRUCT_BEEP_MAX_DELAY + ( ( SELF_DESTRUCT_BEEP_MIN_DELAY - SELF_DESTRUCT_BEEP_MAX_DELAY ) * flDestructPerc );
// If it's time to beep again, do so
if ( gpGlobals->curtime > ( m_flPingTime + flBeepTime ) )
{
// Figure out what our beep pitch will be
float flBeepPitch = SELF_DESTRUCT_BEEP_MIN_PITCH + ( ( SELF_DESTRUCT_BEEP_MAX_PITCH - SELF_DESTRUCT_BEEP_MIN_PITCH ) * flDestructPerc );
StopSound( "NPC_FloorTurret.AlarmPing" );
// Play the beep
CPASAttenuationFilter filter( this, "NPC_FloorTurret.AlarmPing" );
EmitSound_t params;
params.m_pSoundName = "NPC_FloorTurret.AlarmPing";
params.m_nPitch = floor( flBeepPitch );
params.m_nFlags = SND_CHANGE_PITCH;
EmitSound( filter, entindex(), params );
// Flash our eye
SetEyeState( TURRET_EYE_ALARM );
// Save this as the last time we pinged
m_flPingTime = gpGlobals->curtime;
// Randomly twitch
m_vecGoalAngles.x = GetAbsAngles().x + random->RandomFloat( -60*flDestructPerc, 60*flDestructPerc );
m_vecGoalAngles.y = GetAbsAngles().y + random->RandomFloat( -60*flDestructPerc, 60*flDestructPerc );
}
UpdateFacing();
// Think again!
SetNextThink( gpGlobals->curtime + 0.05f );
}
//-----------------------------------------------------------------------------
// Purpose: Make us explode
//-----------------------------------------------------------------------------
void CNPC_FloorTurret::InputSelfDestruct( inputdata_t &inputdata )
{
// Ka-boom!
m_flDestructStartTime = gpGlobals->curtime;
m_flPingTime = gpGlobals->curtime;
m_bSelfDestructing = true;
SetThink( &CNPC_FloorTurret::SelfDestructThink );
SetNextThink( gpGlobals->curtime + 0.1f );
// Create the dust effect in place
m_hFizzleEffect = (CParticleSystem *) CreateEntityByName( "info_particle_system" );
if ( m_hFizzleEffect != NULL )
{
Vector vecUp;
GetVectors( NULL, NULL, &vecUp );
// Setup our basic parameters
m_hFizzleEffect->KeyValue( "start_active", "1" );
m_hFizzleEffect->KeyValue( "effect_name", "explosion_turret_fizzle" );
m_hFizzleEffect->SetParent( this );
m_hFizzleEffect->SetAbsOrigin( WorldSpaceCenter() + ( vecUp * 12.0f ) );
DispatchSpawn( m_hFizzleEffect );
m_hFizzleEffect->Activate();
}
}
//
// Tip controller
//
LINK_ENTITY_TO_CLASS( floorturret_tipcontroller, CTurretTipController );
//---------------------------------------------------------
// Save/Restore
//---------------------------------------------------------
BEGIN_DATADESC( CTurretTipController )
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flSuspendTime, FIELD_TIME ),
DEFINE_FIELD( m_worldGoalAxis, FIELD_VECTOR ),
DEFINE_FIELD( m_localTestAxis, FIELD_VECTOR ),
DEFINE_PHYSPTR( m_pController ),
DEFINE_FIELD( m_angularLimit, FIELD_FLOAT ),
DEFINE_FIELD( m_pParentTurret, FIELD_CLASSPTR ),
END_DATADESC()
CTurretTipController::~CTurretTipController()
{
if ( m_pController )
{
physenv->DestroyMotionController( m_pController );
m_pController = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTurretTipController::Spawn( void )
{
m_bEnabled = true;
// align the object's local Z axis
m_localTestAxis.Init( 0, 0, 1 );
// with the world's Z axis
m_worldGoalAxis.Init( 0, 0, 1 );
// recover from up to 25 degrees / sec angular velocity
m_angularLimit = 25;
m_flSuspendTime = 0;
SetMoveType( MOVETYPE_NONE );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTurretTipController::Activate( void )
{
BaseClass::Activate();
if ( m_pParentTurret == NULL )
{
UTIL_Remove(this);
return;
}
IPhysicsObject *pPhys = m_pParentTurret->VPhysicsGetObject();
if ( pPhys == NULL )
{
UTIL_Remove(this);
return;
}
//Setup the motion controller
if ( !m_pController )
{
m_pController = physenv->CreateMotionController( (IMotionEvent *)this );
m_pController->AttachObject( pPhys, true );
}
else
{
m_pController->SetEventHandler( this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Actual simulation for tip controller
//-----------------------------------------------------------------------------
IMotionEvent::simresult_e CTurretTipController::Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular )
{
if ( Enabled() == false )
return SIM_NOTHING;
// Don't simulate if we're being carried by the player
if ( m_pParentTurret->IsBeingCarriedByPlayer() )
return SIM_NOTHING;
float flAngularLimit = m_angularLimit;
// If we were just dropped by a friendly player, stabilise better
if ( m_pParentTurret->WasJustDroppedByPlayer() )
{
// Increase the controller strength a little
flAngularLimit += 20;
}
else
{
// If the turret has some vertical velocity, don't simulate
Vector vecVelocity;
AngularImpulse angImpulse;
pObject->GetVelocity( &vecVelocity, &angImpulse );
if ( (vecVelocity.LengthSqr() > CNPC_FloorTurret::fMaxTipControllerVelocity) || (angImpulse.LengthSqr() > CNPC_FloorTurret::fMaxTipControllerAngularVelocity) )
return SIM_NOTHING;
}
linear.Init();
AngularImpulse angVel;
pObject->GetVelocity( NULL, &angVel );
matrix3x4_t matrix;
// get the object's local to world transform
pObject->GetPositionMatrix( &matrix );
// Get the alignment axis in object space
Vector currentLocalTargetAxis;
VectorIRotate( m_worldGoalAxis, matrix, currentLocalTargetAxis );
float invDeltaTime = (1/deltaTime);
angular = ComputeRotSpeedToAlignAxes( m_localTestAxis, currentLocalTargetAxis, angVel, 1.0, invDeltaTime * invDeltaTime, flAngularLimit * invDeltaTime );
return SIM_LOCAL_ACCELERATION;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTurretTipController::Enable( bool state )
{
m_bEnabled = state;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : time -
//-----------------------------------------------------------------------------
void CTurretTipController::Suspend( float time )
{
m_flSuspendTime = gpGlobals->curtime + time;
}
float CTurretTipController::SuspendedTill( void )
{
return m_flSuspendTime;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTurretTipController::Enabled( void )
{
if ( m_flSuspendTime > gpGlobals->curtime )
return false;
return m_bEnabled;
}
//-----------------------------------------------------------------------------
//
// Schedules
//
//-----------------------------------------------------------------------------
AI_BEGIN_CUSTOM_NPC( npc_turret_floor, CNPC_FloorTurret )
DECLARE_INTERACTION( g_interactionTurretStillStanding );
AI_END_CUSTOM_NPC()