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.
1167 lines
30 KiB
1167 lines
30 KiB
![]()
2 years ago
|
//========= 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 "ammodef.h"
|
||
|
#include "Sprite.h"
|
||
|
#include "hl2/hl2_player.h"
|
||
|
#include "soundenvelope.h"
|
||
|
#include "explode.h"
|
||
|
#include "IEffects.h"
|
||
|
#include "animation.h"
|
||
|
#include "props.h"
|
||
|
#include "rope.h"
|
||
|
#include "rope_shared.h"
|
||
|
#include "basehlcombatweapon_shared.h"
|
||
|
#include "iservervehicle.h"
|
||
|
#include "physics_prop_ragdoll.h"
|
||
|
#include "portal_util_shared.h"
|
||
|
#include "prop_portal.h"
|
||
|
#include "portal_player.h"
|
||
|
#include "world.h"
|
||
|
#include "ai_baseactor.h" // for Glados ent playing VCDs
|
||
|
#include "sceneentity.h" // precacheing vcds
|
||
|
|
||
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
#include "tier0/memdbgon.h"
|
||
|
|
||
|
#define SECURITY_CAMERA_MODEL "models/props/security_camera.mdl"
|
||
|
#define SECURITY_CAMERA_BC_YAW "aim_yaw"
|
||
|
#define SECURITY_CAMERA_BC_PITCH "aim_pitch"
|
||
|
#define SECURITY_CAMERA_RANGE 1500
|
||
|
#define SECURITY_CAMERA_SPREAD VECTOR_CONE_2DEGREES
|
||
|
#define SECURITY_CAMERA_MAX_WAIT 5
|
||
|
#define SECURITY_CAMERA_PING_TIME 1.0f //LPB!!
|
||
|
|
||
|
#define SECURITY_CAMERA_NUM_ROPES 2
|
||
|
#define SECURITY_CAMERA_GLOW_SPRITE "sprites/glow1.vmt"
|
||
|
|
||
|
//Aiming variables
|
||
|
#define SECURITY_CAMERA_MAX_NOHARM_PERIOD 0.0f
|
||
|
#define SECURITY_CAMERA_MAX_GRACE_PERIOD 3.0f
|
||
|
|
||
|
//Spawnflags
|
||
|
#define SF_SECURITY_CAMERA_AUTOACTIVATE 0x00000020
|
||
|
#define SF_SECURITY_CAMERA_STARTINACTIVE 0x00000040
|
||
|
#define SF_SECURITY_CAMERA_NEVERRETIRE 0x00000080
|
||
|
#define SF_SECURITY_CAMERA_OUT_OF_AMMO 0x00000100
|
||
|
|
||
|
#define CAMERA_DESTROYED_SCENE_1 "scenes/general/generic_security_camera_destroyed-1.vcd"
|
||
|
#define CAMERA_DESTROYED_SCENE_2 "scenes/general/generic_security_camera_destroyed-2.vcd"
|
||
|
#define CAMERA_DESTROYED_SCENE_3 "scenes/general/generic_security_camera_destroyed-3.vcd"
|
||
|
#define CAMERA_DESTROYED_SCENE_4 "scenes/general/generic_security_camera_destroyed-4.vcd"
|
||
|
#define CAMERA_DESTROYED_SCENE_5 "scenes/general/generic_security_camera_destroyed-5.vcd"
|
||
|
|
||
|
//Heights
|
||
|
#define SECURITY_CAMERA_YAW_SPEED 7.0f
|
||
|
|
||
|
#define SECURITY_CAMERA_TOTAL_TO_KNOCK_DOWN 33
|
||
|
|
||
|
//Turret states
|
||
|
enum turretState_e
|
||
|
{
|
||
|
TURRET_SEARCHING,
|
||
|
TURRET_AUTO_SEARCHING,
|
||
|
TURRET_ACTIVE,
|
||
|
TURRET_DEPLOYING,
|
||
|
TURRET_RETIRING,
|
||
|
TURRET_DEAD,
|
||
|
};
|
||
|
|
||
|
// Forces glados actor to play reaction scenes when player dismounts camera.
|
||
|
void PlayDismountSounds( void );
|
||
|
|
||
|
|
||
|
//
|
||
|
// Security Camera
|
||
|
//
|
||
|
|
||
|
class CNPC_SecurityCamera : public CNPCBaseInteractive<CAI_BaseNPC>, public CDefaultPlayerPickupVPhysics
|
||
|
{
|
||
|
DECLARE_CLASS( CNPC_SecurityCamera, CNPCBaseInteractive<CAI_BaseNPC> );
|
||
|
public:
|
||
|
|
||
|
CNPC_SecurityCamera( void );
|
||
|
~CNPC_SecurityCamera( void );
|
||
|
|
||
|
void Precache( void );
|
||
|
virtual void CreateSounds( void );
|
||
|
virtual void StopLoopingSounds( void );
|
||
|
virtual void Spawn( void );
|
||
|
virtual void Activate( void );
|
||
|
bool CreateVPhysics( void );
|
||
|
virtual void UpdateOnRemove( void );
|
||
|
virtual void NotifySystemEvent( CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t ¶ms );
|
||
|
virtual int ObjectCaps( void );
|
||
|
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||
|
|
||
|
// Think functions
|
||
|
void Retire( void );
|
||
|
void Deploy( void );
|
||
|
void ActiveThink( void );
|
||
|
void SearchThink( void );
|
||
|
void DeathThink( void );
|
||
|
|
||
|
// Inputs
|
||
|
void InputToggle( inputdata_t &inputdata );
|
||
|
void InputEnable( inputdata_t &inputdata );
|
||
|
void InputDisable( inputdata_t &inputdata );
|
||
|
void InputRagdoll( inputdata_t &inputdata );
|
||
|
|
||
|
void SetLastSightTime();
|
||
|
|
||
|
int OnTakeDamage( const CTakeDamageInfo &inputInfo );
|
||
|
virtual void PlayerPenetratingVPhysics( void );
|
||
|
bool OnAttemptPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason );
|
||
|
|
||
|
bool ShouldSavePhysics() { return true; }
|
||
|
|
||
|
virtual bool CanBeAnEnemyOf( CBaseEntity *pEnemy );
|
||
|
|
||
|
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 )
|
||
|
{
|
||
|
Vector vForward;
|
||
|
|
||
|
GetVectors( &vForward, 0, 0 );
|
||
|
|
||
|
return vForward * 10.0f;
|
||
|
}
|
||
|
|
||
|
Vector EyePosition( void )
|
||
|
{
|
||
|
return GetAbsOrigin() + EyeOffset(GetActivity());
|
||
|
}
|
||
|
|
||
|
|
||
|
protected:
|
||
|
|
||
|
bool PreThink( turretState_e state );
|
||
|
void Ping( void );
|
||
|
void Toggle( void );
|
||
|
void Enable( void );
|
||
|
void Disable( void );
|
||
|
|
||
|
void RopesOn( void );
|
||
|
void RopesOff( void );
|
||
|
void EyeOn( void );
|
||
|
void EyeOff( void );
|
||
|
|
||
|
bool UpdateFacing( void );
|
||
|
|
||
|
private:
|
||
|
|
||
|
CHandle<CRopeKeyframe> m_hRopes[ SECURITY_CAMERA_NUM_ROPES ];
|
||
|
CHandle<CSprite> m_hEyeGlow;
|
||
|
|
||
|
bool m_bAutoStart;
|
||
|
bool m_bActive; //Denotes the turret is deployed and looking for targets
|
||
|
bool m_bBlinkState;
|
||
|
bool m_bEnabled; //Denotes whether the turret is able to deploy or not
|
||
|
|
||
|
float m_flLastSight;
|
||
|
float m_flPingTime;
|
||
|
|
||
|
QAngle m_vecGoalAngles;
|
||
|
QAngle m_vecCurrentAngles;
|
||
|
Vector m_vNoisePos;
|
||
|
int m_iTicksTillNextNoise;
|
||
|
|
||
|
CSoundPatch *m_pMovementSound;
|
||
|
|
||
|
COutputEvent m_OnDeploy;
|
||
|
COutputEvent m_OnRetire;
|
||
|
|
||
|
DECLARE_DATADESC();
|
||
|
};
|
||
|
|
||
|
//Datatable
|
||
|
BEGIN_DATADESC( CNPC_SecurityCamera )
|
||
|
|
||
|
DEFINE_ARRAY( m_hRopes, FIELD_EHANDLE, SECURITY_CAMERA_NUM_ROPES ),
|
||
|
DEFINE_FIELD( m_hEyeGlow, FIELD_EHANDLE ),
|
||
|
|
||
|
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_flLastSight, FIELD_TIME ),
|
||
|
DEFINE_FIELD( m_flPingTime, FIELD_TIME ),
|
||
|
DEFINE_FIELD( m_vecGoalAngles, FIELD_VECTOR ),
|
||
|
DEFINE_FIELD( m_vecCurrentAngles, FIELD_VECTOR ),
|
||
|
DEFINE_FIELD( m_vNoisePos, FIELD_VECTOR ),
|
||
|
DEFINE_FIELD( m_iTicksTillNextNoise, FIELD_INTEGER ),
|
||
|
|
||
|
DEFINE_SOUNDPATCH( m_pMovementSound ),
|
||
|
|
||
|
DEFINE_THINKFUNC( Retire ),
|
||
|
DEFINE_THINKFUNC( Deploy ),
|
||
|
DEFINE_THINKFUNC( ActiveThink ),
|
||
|
DEFINE_THINKFUNC( SearchThink ),
|
||
|
DEFINE_THINKFUNC( DeathThink ),
|
||
|
|
||
|
// Inputs
|
||
|
DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),
|
||
|
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
|
||
|
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
|
||
|
DEFINE_INPUTFUNC( FIELD_VOID, "Ragdoll", InputRagdoll ),
|
||
|
|
||
|
DEFINE_OUTPUT( m_OnDeploy, "OnDeploy" ),
|
||
|
DEFINE_OUTPUT( m_OnRetire, "OnRetire" ),
|
||
|
|
||
|
END_DATADESC()
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( npc_security_camera, CNPC_SecurityCamera );
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Constructor
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CNPC_SecurityCamera::CNPC_SecurityCamera( void )
|
||
|
{
|
||
|
m_bActive = false;
|
||
|
m_bAutoStart = false;
|
||
|
m_flPingTime = 0;
|
||
|
m_flLastSight = 0;
|
||
|
m_bBlinkState = false;
|
||
|
m_bEnabled = false;
|
||
|
m_vecCurrentAngles = QAngle( 0.0f, 0.0f, 0.0f );
|
||
|
|
||
|
m_vecGoalAngles.Init();
|
||
|
m_vNoisePos = Vector( 0.0f, 0.0f, 0.0f );
|
||
|
m_iTicksTillNextNoise = 5;
|
||
|
|
||
|
m_pMovementSound = NULL;
|
||
|
m_hEyeGlow = NULL;
|
||
|
}
|
||
|
|
||
|
CNPC_SecurityCamera::~CNPC_SecurityCamera( void )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Precache
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Precache( void )
|
||
|
{
|
||
|
PrecacheModel( SECURITY_CAMERA_MODEL );
|
||
|
|
||
|
PrecacheScriptSound( "Portalgun.pedestal_rotate_loop" );
|
||
|
|
||
|
// Scenes for when the player dismounts a security camera. Spoken only if Aperture_AI actor is in the
|
||
|
PrecacheInstancedScene( CAMERA_DESTROYED_SCENE_1 );
|
||
|
PrecacheInstancedScene( CAMERA_DESTROYED_SCENE_2 );
|
||
|
PrecacheInstancedScene( CAMERA_DESTROYED_SCENE_3 );
|
||
|
PrecacheInstancedScene( CAMERA_DESTROYED_SCENE_4 );
|
||
|
PrecacheInstancedScene( CAMERA_DESTROYED_SCENE_5 );
|
||
|
|
||
|
BaseClass::Precache();
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::CreateSounds()
|
||
|
{
|
||
|
if (!m_pMovementSound)
|
||
|
{
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
CPASAttenuationFilter filter( this );
|
||
|
|
||
|
m_pMovementSound = controller.SoundCreate( filter, entindex(), "Portalgun.pedestal_rotate_loop" );
|
||
|
controller.Play( m_pMovementSound, 0, 100 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::StopLoopingSounds()
|
||
|
{
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
controller.SoundDestroy( m_pMovementSound );
|
||
|
m_pMovementSound = NULL;
|
||
|
|
||
|
BaseClass::StopLoopingSounds();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Spawn the entity
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Spawn( void )
|
||
|
{
|
||
|
Precache();
|
||
|
|
||
|
SetModel( SECURITY_CAMERA_MODEL );
|
||
|
|
||
|
BaseClass::Spawn();
|
||
|
|
||
|
m_HackedGunPos = Vector( 0, 0, 12.75 );
|
||
|
SetViewOffset( EyeOffset( ACT_IDLE ) );
|
||
|
m_flFieldOfView = VIEW_FIELD_FULL;
|
||
|
m_takedamage = DAMAGE_NO;
|
||
|
m_iHealth = 1000;
|
||
|
m_bloodColor = BLOOD_COLOR_MECH;
|
||
|
|
||
|
SetSolid( SOLID_BBOX );
|
||
|
AddSolidFlags( FSOLID_NOT_STANDABLE );
|
||
|
|
||
|
SetCollisionBounds( Vector( -16.0f, -16.0f, -16.0f ), Vector( 16.0f, 16.0f, 16.0f ) );
|
||
|
|
||
|
RemoveFlag( FL_AIMTARGET );
|
||
|
AddEFlags( EFL_NO_DISSOLVE );
|
||
|
|
||
|
SetPoseParameter( SECURITY_CAMERA_BC_YAW, 0 );
|
||
|
SetPoseParameter( SECURITY_CAMERA_BC_PITCH, 0 );
|
||
|
|
||
|
//Set our autostart state
|
||
|
m_bAutoStart = !!( m_spawnflags & SF_SECURITY_CAMERA_AUTOACTIVATE );
|
||
|
m_bEnabled = ( ( m_spawnflags & SF_SECURITY_CAMERA_STARTINACTIVE ) == false );
|
||
|
|
||
|
//Do we start active?
|
||
|
if ( m_bAutoStart && m_bEnabled )
|
||
|
{
|
||
|
SetThink( &CNPC_SecurityCamera::SearchThink );
|
||
|
}
|
||
|
|
||
|
//Stagger our starting times
|
||
|
SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.1f, 0.3f ) );
|
||
|
|
||
|
CreateVPhysics();
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::Activate( void )
|
||
|
{
|
||
|
BaseClass::Activate();
|
||
|
|
||
|
CreateSounds();
|
||
|
|
||
|
RopesOn();
|
||
|
EyeOn();
|
||
|
}
|
||
|
|
||
|
bool CNPC_SecurityCamera::CreateVPhysics( void )
|
||
|
{
|
||
|
IPhysicsObject *pPhysics = VPhysicsInitNormal( SOLID_VPHYSICS, FSOLID_NOT_STANDABLE, false );
|
||
|
if ( !pPhysics )
|
||
|
DevMsg( "npc_turret_floor unable to spawn physics object!\n" );
|
||
|
else
|
||
|
pPhysics->EnableMotion( false );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::UpdateOnRemove( void )
|
||
|
{
|
||
|
RopesOff();
|
||
|
EyeOff();
|
||
|
|
||
|
BaseClass::UpdateOnRemove();
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::NotifySystemEvent(CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t ¶ms )
|
||
|
{
|
||
|
// On teleport, we record a pointer to the portal we are arriving at
|
||
|
if ( eventType == NOTIFY_EVENT_TELEPORT )
|
||
|
{
|
||
|
RopesOff();
|
||
|
RopesOn();
|
||
|
}
|
||
|
|
||
|
BaseClass::NotifySystemEvent( pNotify, eventType, params );
|
||
|
}
|
||
|
|
||
|
int CNPC_SecurityCamera::ObjectCaps( void )
|
||
|
{
|
||
|
IPhysicsObject *pPhysics = VPhysicsGetObject();
|
||
|
if ( !pPhysics || !pPhysics->IsMotionEnabled() )
|
||
|
return BaseClass::ObjectCaps();
|
||
|
|
||
|
return ( BaseClass::ObjectCaps() | FCAP_USE_IN_RADIUS | FCAP_USE_ONGROUND | FCAP_IMPULSE_USE );
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
||
|
{
|
||
|
CBasePlayer *pPlayer = ToBasePlayer( pActivator );
|
||
|
if ( pPlayer )
|
||
|
pPlayer->PickupObject( this );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CNPC_SecurityCamera::OnTakeDamage( const CTakeDamageInfo &inputInfo )
|
||
|
{
|
||
|
if ( !m_takedamage )
|
||
|
return 0;
|
||
|
|
||
|
CTakeDamageInfo info = inputInfo;
|
||
|
|
||
|
if ( m_bActive == false )
|
||
|
info.ScaleDamage( 0.1f );
|
||
|
|
||
|
m_iHealth -= info.GetDamage();
|
||
|
|
||
|
if ( m_iHealth <= 0 )
|
||
|
{
|
||
|
m_iHealth = 0;
|
||
|
m_takedamage = DAMAGE_NO;
|
||
|
|
||
|
RemoveFlag( FL_NPC ); // why are they set in the first place???
|
||
|
|
||
|
ExplosionCreate( GetAbsOrigin(), GetLocalAngles(), this, 100, 100, false );
|
||
|
SetThink( &CNPC_SecurityCamera::DeathThink );
|
||
|
|
||
|
StopSound( "NPC_SecurityCamera.Alert" );
|
||
|
|
||
|
m_OnDamaged.FireOutput( info.GetInflictor(), this );
|
||
|
|
||
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// 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_SecurityCamera::PlayerPenetratingVPhysics( void )
|
||
|
{
|
||
|
// We don't care!
|
||
|
}
|
||
|
|
||
|
bool CNPC_SecurityCamera::OnAttemptPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
|
||
|
{
|
||
|
return !m_bActive;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Shut down
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Retire( void )
|
||
|
{
|
||
|
if ( PreThink( TURRET_RETIRING ) )
|
||
|
return;
|
||
|
|
||
|
//Level out the turret
|
||
|
m_vecGoalAngles = GetAbsAngles();
|
||
|
SetNextThink( gpGlobals->curtime );
|
||
|
|
||
|
//Set ourselves to close
|
||
|
if ( m_bActive )
|
||
|
{
|
||
|
//Notify of the retraction
|
||
|
m_OnRetire.FireOutput( NULL, this );
|
||
|
}
|
||
|
|
||
|
m_bActive = false;
|
||
|
m_flLastSight = 0;
|
||
|
|
||
|
SetThink( &CNPC_SecurityCamera::SUB_DoNothing );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Start up
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Deploy( void )
|
||
|
{
|
||
|
if ( PreThink( TURRET_DEPLOYING ) )
|
||
|
return;
|
||
|
|
||
|
m_vecGoalAngles = GetAbsAngles();
|
||
|
|
||
|
SetNextThink( gpGlobals->curtime );
|
||
|
|
||
|
if ( !m_bActive )
|
||
|
{
|
||
|
m_bActive = true;
|
||
|
|
||
|
//Notify we're deploying
|
||
|
m_OnDeploy.FireOutput( NULL, this );
|
||
|
}
|
||
|
|
||
|
m_flPlaybackRate = 0;
|
||
|
SetThink( &CNPC_SecurityCamera::SearchThink );
|
||
|
|
||
|
//EmitSound( "NPC_SecurityCamera.Move" );
|
||
|
|
||
|
SetLastSightTime();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::SetLastSightTime()
|
||
|
{
|
||
|
if( HasSpawnFlags( SF_SECURITY_CAMERA_NEVERRETIRE ) )
|
||
|
{
|
||
|
m_flLastSight = FLT_MAX;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_flLastSight = gpGlobals->curtime + SECURITY_CAMERA_MAX_WAIT;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Causes the turret to face its desired angles
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CNPC_SecurityCamera::UpdateFacing( void )
|
||
|
{
|
||
|
bool bMoved = false;
|
||
|
|
||
|
if ( m_vecCurrentAngles.x < m_vecGoalAngles.x )
|
||
|
{
|
||
|
m_vecCurrentAngles.x += SECURITY_CAMERA_YAW_SPEED;
|
||
|
|
||
|
if ( m_vecCurrentAngles.x > m_vecGoalAngles.x )
|
||
|
m_vecCurrentAngles.x = m_vecGoalAngles.x;
|
||
|
|
||
|
bMoved = true;
|
||
|
}
|
||
|
|
||
|
if ( m_vecCurrentAngles.y < m_vecGoalAngles.y )
|
||
|
{
|
||
|
m_vecCurrentAngles.y += SECURITY_CAMERA_YAW_SPEED;
|
||
|
|
||
|
if ( m_vecCurrentAngles.y > m_vecGoalAngles.y )
|
||
|
m_vecCurrentAngles.y = m_vecGoalAngles.y;
|
||
|
|
||
|
bMoved = true;
|
||
|
}
|
||
|
|
||
|
if ( m_vecCurrentAngles.x > m_vecGoalAngles.x )
|
||
|
{
|
||
|
m_vecCurrentAngles.x -= SECURITY_CAMERA_YAW_SPEED;
|
||
|
|
||
|
if ( m_vecCurrentAngles.x < m_vecGoalAngles.x )
|
||
|
m_vecCurrentAngles.x = m_vecGoalAngles.x;
|
||
|
|
||
|
bMoved = true;
|
||
|
}
|
||
|
|
||
|
if ( m_vecCurrentAngles.y > m_vecGoalAngles.y )
|
||
|
{
|
||
|
m_vecCurrentAngles.y -= SECURITY_CAMERA_YAW_SPEED;
|
||
|
|
||
|
if ( m_vecCurrentAngles.y < m_vecGoalAngles.y )
|
||
|
m_vecCurrentAngles.y = m_vecGoalAngles.y;
|
||
|
|
||
|
bMoved = true;
|
||
|
}
|
||
|
|
||
|
if ( bMoved )
|
||
|
{
|
||
|
if ( m_pMovementSound )
|
||
|
{
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
controller.SoundChangeVolume( m_pMovementSound, RandomFloat( 0.7f, 0.9f ), 0.05f );
|
||
|
}
|
||
|
|
||
|
// Update pitch
|
||
|
int iPose = LookupPoseParameter( SECURITY_CAMERA_BC_PITCH );
|
||
|
SetPoseParameter( iPose, m_vecCurrentAngles.x );
|
||
|
|
||
|
// Update yaw
|
||
|
iPose = LookupPoseParameter( SECURITY_CAMERA_BC_YAW );
|
||
|
SetPoseParameter( iPose, m_vecCurrentAngles.y );
|
||
|
|
||
|
InvalidateBoneCache();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_pMovementSound )
|
||
|
{
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
controller.SoundChangeVolume( m_pMovementSound, 0.0f, 0.05f );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return bMoved;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Input : *pEntity -
|
||
|
// Output : Returns true on success, false on failure.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CNPC_SecurityCamera::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )
|
||
|
{
|
||
|
CBaseEntity *pHitEntity = NULL;
|
||
|
if ( BaseClass::FVisible( pEntity, traceMask, &pHitEntity ) )
|
||
|
return true;
|
||
|
|
||
|
// If we hit something that's okay to hit anyway, still fire
|
||
|
if ( pHitEntity && pHitEntity->MyCombatCharacterPointer() )
|
||
|
{
|
||
|
if (IRelationType(pHitEntity) == D_HT)
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
if (ppBlocker)
|
||
|
{
|
||
|
*ppBlocker = pHitEntity;
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Allows the turret to fire on targets if they're visible
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::ActiveThink( void )
|
||
|
{
|
||
|
//Allow descended classes a chance to do something before the think function
|
||
|
if ( PreThink( TURRET_ACTIVE ) )
|
||
|
return;
|
||
|
|
||
|
//Update our think time
|
||
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
||
|
|
||
|
CBaseEntity *pEnemy = GetEnemy();
|
||
|
|
||
|
//If we've become inactive, go back to searching
|
||
|
if ( m_bActive == false || !pEnemy )
|
||
|
{
|
||
|
SetEnemy( NULL );
|
||
|
SetLastSightTime();
|
||
|
SetThink( &CNPC_SecurityCamera::SearchThink );
|
||
|
m_vecGoalAngles = GetAbsAngles();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
//Get our shot positions
|
||
|
Vector vecMid = EyePosition();
|
||
|
Vector vecMidEnemy = pEnemy->GetAbsOrigin();
|
||
|
|
||
|
//Store off our last seen location
|
||
|
UpdateEnemyMemory( pEnemy, vecMidEnemy );
|
||
|
|
||
|
//Look for our current enemy
|
||
|
bool bEnemyVisible = pEnemy->IsAlive() && FInViewCone( pEnemy ) && FVisible( pEnemy );
|
||
|
|
||
|
//Calculate dir and dist to enemy
|
||
|
Vector vecDirToEnemy = vecMidEnemy - vecMid;
|
||
|
float flDistToEnemy = VectorNormalize( vecDirToEnemy );
|
||
|
|
||
|
CProp_Portal *pPortal = NULL;
|
||
|
|
||
|
if ( pEnemy->IsAlive() )
|
||
|
{
|
||
|
pPortal = FInViewConeThroughPortal( pEnemy );
|
||
|
|
||
|
if ( pPortal && FVisibleThroughPortal( pPortal, pEnemy ) )
|
||
|
{
|
||
|
// Translate our target across the portal
|
||
|
Vector vecMidEnemyTransformed;
|
||
|
UTIL_Portal_PointTransform( pPortal->m_hLinkedPortal->MatrixThisToLinked(), vecMidEnemy, vecMidEnemyTransformed );
|
||
|
|
||
|
//Calculate dir and dist to enemy
|
||
|
Vector vecDirToEnemyTransformed = vecMidEnemyTransformed - vecMid;
|
||
|
float flDistToEnemyTransformed = VectorNormalize( vecDirToEnemyTransformed );
|
||
|
|
||
|
// If it's not visible through normal means or the enemy is closer through the portal, use the translated info
|
||
|
if ( !bEnemyVisible || flDistToEnemyTransformed < flDistToEnemy )
|
||
|
{
|
||
|
bEnemyVisible = true;
|
||
|
vecMidEnemy = vecMidEnemyTransformed;
|
||
|
vecDirToEnemy = vecDirToEnemyTransformed;
|
||
|
flDistToEnemy = flDistToEnemyTransformed;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pPortal = NULL;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pPortal = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Add noise to the look position
|
||
|
--m_iTicksTillNextNoise;
|
||
|
|
||
|
if ( m_iTicksTillNextNoise <= 0 && flDistToEnemy < 256.0f )
|
||
|
{
|
||
|
m_vNoisePos.x = RandomFloat( -8.0f, 8.0f );
|
||
|
m_vNoisePos.y = RandomFloat( -8.0f, 8.0f );
|
||
|
m_vNoisePos.z = RandomFloat( 0.0f, 32.0f );
|
||
|
|
||
|
m_iTicksTillNextNoise = RandomInt( 5, 30 );
|
||
|
}
|
||
|
|
||
|
//We want to look at the enemy's eyes so we don't jitter
|
||
|
Vector vEnemyEyes = pEnemy->EyePosition();
|
||
|
|
||
|
if ( pPortal )
|
||
|
{
|
||
|
UTIL_Portal_PointTransform( pPortal->m_hLinkedPortal->MatrixThisToLinked(), vEnemyEyes, vEnemyEyes );
|
||
|
}
|
||
|
|
||
|
Vector vecDirToEnemyEyes = ( vEnemyEyes + m_vNoisePos ) - vecMid;
|
||
|
VectorNormalize( vecDirToEnemyEyes );
|
||
|
|
||
|
QAngle vecAnglesToEnemy;
|
||
|
VectorAngles( vecDirToEnemyEyes, vecAnglesToEnemy );
|
||
|
|
||
|
Vector vForward, vRight, vUp;
|
||
|
GetVectors( &vForward, &vRight, &vUp );
|
||
|
|
||
|
vecAnglesToEnemy.x = acosf( vecDirToEnemyEyes.Dot( -vUp ) ) * ( 180.0f / M_PI );
|
||
|
|
||
|
Vector vProjectedDirToEnemyEyes = vecDirToEnemyEyes - vecDirToEnemyEyes.Dot( vUp ) * vUp;
|
||
|
VectorNormalize( vProjectedDirToEnemyEyes );
|
||
|
|
||
|
if ( vProjectedDirToEnemyEyes.IsZero() )
|
||
|
vecAnglesToEnemy.y = m_vecGoalAngles.y;
|
||
|
else
|
||
|
{
|
||
|
if ( vProjectedDirToEnemyEyes.Dot( vForward ) > 0.0f )
|
||
|
vecAnglesToEnemy.y = acosf( vProjectedDirToEnemyEyes.Dot( vRight ) ) * ( 180.0f / M_PI ) - 90.0f;
|
||
|
else
|
||
|
vecAnglesToEnemy.y = -acosf( vProjectedDirToEnemyEyes.Dot( vRight ) ) * ( 180.0f / M_PI ) - 90.0f;
|
||
|
}
|
||
|
|
||
|
vecAnglesToEnemy.y = AngleNormalize( vecAnglesToEnemy.y );
|
||
|
|
||
|
//Current enemy is not visible
|
||
|
if ( ( bEnemyVisible == false ) || ( flDistToEnemy > SECURITY_CAMERA_RANGE ) )
|
||
|
{
|
||
|
if ( gpGlobals->curtime > m_flLastSight )
|
||
|
{
|
||
|
// Should we look for a new target?
|
||
|
ClearEnemyMemory();
|
||
|
SetEnemy( NULL );
|
||
|
SetLastSightTime();
|
||
|
SetThink( &CNPC_SecurityCamera::SearchThink );
|
||
|
m_vecGoalAngles = GetAbsAngles();
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
bEnemyVisible = false;
|
||
|
}
|
||
|
|
||
|
//If we can see our enemy, face it
|
||
|
if ( bEnemyVisible )
|
||
|
{
|
||
|
m_vecGoalAngles.y = vecAnglesToEnemy.y;
|
||
|
m_vecGoalAngles.x = vecAnglesToEnemy.x;
|
||
|
|
||
|
m_flLastSight = gpGlobals->curtime + 0.5f;
|
||
|
}
|
||
|
|
||
|
//Turn to face
|
||
|
UpdateFacing();
|
||
|
|
||
|
// Update rope positions
|
||
|
for ( int iRope = 0; iRope < SECURITY_CAMERA_NUM_ROPES; ++iRope )
|
||
|
{
|
||
|
if ( m_hRopes[ iRope ] )
|
||
|
{
|
||
|
m_hRopes[ iRope ]->EndpointsChanged();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Target doesn't exist or has eluded us, so search for one
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::SearchThink( void )
|
||
|
{
|
||
|
//Allow descended classes a chance to do something before the think function
|
||
|
if ( PreThink( TURRET_SEARCHING ) )
|
||
|
return;
|
||
|
|
||
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
||
|
|
||
|
//If our enemy has died, pick a new enemy
|
||
|
if ( ( GetEnemy() != NULL ) && ( GetEnemy()->IsAlive() == false ) )
|
||
|
{
|
||
|
SetEnemy( NULL );
|
||
|
}
|
||
|
|
||
|
//Acquire the target
|
||
|
if ( GetEnemy() == NULL )
|
||
|
{
|
||
|
CBaseEntity *pEnemy = NULL;
|
||
|
|
||
|
//CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
|
||
|
for( int i = 1; i <= gpGlobals->maxClients; ++i )
|
||
|
{
|
||
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
||
|
if ( pPlayer && pPlayer->IsAlive() )
|
||
|
{
|
||
|
if ( FInViewCone( pPlayer ) && FVisible( pPlayer ) )
|
||
|
{
|
||
|
pEnemy = pPlayer;
|
||
|
break;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CProp_Portal *pPortal = FInViewConeThroughPortal( pPlayer );
|
||
|
if ( pPortal && FVisibleThroughPortal( pPortal, pPlayer ) )
|
||
|
{
|
||
|
pEnemy = pPlayer;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( pEnemy )
|
||
|
{
|
||
|
SetEnemy( pEnemy );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//If we've found a target follow it
|
||
|
if ( GetEnemy() != NULL )
|
||
|
{
|
||
|
m_flLastSight = 0;
|
||
|
m_bActive = true;
|
||
|
SetThink( &CNPC_SecurityCamera::ActiveThink );
|
||
|
|
||
|
//EmitSound( "NPC_CeilingTurret.Active" );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
--m_iTicksTillNextNoise;
|
||
|
|
||
|
if ( m_iTicksTillNextNoise <= 0 )
|
||
|
{
|
||
|
//Display that we're scanning
|
||
|
m_vecGoalAngles.x = RandomFloat( -10.0f, 30.0f );
|
||
|
m_vecGoalAngles.y = RandomFloat( -80.0f, 80.0f );
|
||
|
|
||
|
m_iTicksTillNextNoise = RandomInt( 10, 35 );
|
||
|
}
|
||
|
|
||
|
//Turn and ping
|
||
|
//UpdateFacing();
|
||
|
Ping();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Allows a generic think function before the others are called
|
||
|
// Input : state - which state the turret is currently in
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CNPC_SecurityCamera::PreThink( turretState_e state )
|
||
|
{
|
||
|
CheckPVSCondition();
|
||
|
|
||
|
//Animate
|
||
|
StudioFrameAdvance();
|
||
|
|
||
|
//Do not interrupt current think function
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Make a pinging noise so the player knows where we are
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Ping( void )
|
||
|
{
|
||
|
//See if it's time to ping again
|
||
|
if ( m_flPingTime > gpGlobals->curtime )
|
||
|
return;
|
||
|
|
||
|
//Ping!
|
||
|
//EmitSound( "NPC_CeilingTurret.Ping" );
|
||
|
|
||
|
m_flPingTime = gpGlobals->curtime + SECURITY_CAMERA_PING_TIME;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Toggle the turret's state
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Toggle( void )
|
||
|
{
|
||
|
//Toggle the state
|
||
|
if ( m_bEnabled )
|
||
|
{
|
||
|
Disable();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Enable();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Enable the turret and deploy
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Enable( void )
|
||
|
{
|
||
|
m_bEnabled = true;
|
||
|
|
||
|
// if the turret is flagged as an autoactivate turret, re-enable its ability open self.
|
||
|
if ( m_spawnflags & SF_SECURITY_CAMERA_AUTOACTIVATE )
|
||
|
{
|
||
|
m_bAutoStart = true;
|
||
|
}
|
||
|
|
||
|
SetThink( &CNPC_SecurityCamera::Deploy );
|
||
|
SetNextThink( gpGlobals->curtime + 0.05f );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Retire the turret until enabled again
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::Disable( void )
|
||
|
{
|
||
|
m_bEnabled = false;
|
||
|
m_bAutoStart = false;
|
||
|
|
||
|
SetEnemy( NULL );
|
||
|
SetThink( &CNPC_SecurityCamera::Retire );
|
||
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::RopesOn( void )
|
||
|
{
|
||
|
for ( int iRope = 0; iRope < SECURITY_CAMERA_NUM_ROPES; ++iRope )
|
||
|
{
|
||
|
// Make a rope if it doesn't exist
|
||
|
if ( !m_hRopes[ iRope ] )
|
||
|
{
|
||
|
CFmtStr str;
|
||
|
|
||
|
int iStartIndex = LookupAttachment( str.sprintf( "Wire%i_A", iRope + 1 ) );
|
||
|
int iEndIndex = LookupAttachment( str.sprintf( "Wire%i_B", iRope + 1 ) );
|
||
|
|
||
|
m_hRopes[ iRope ] = CRopeKeyframe::Create( this, this, iStartIndex, iEndIndex );
|
||
|
if ( m_hRopes[ iRope ] )
|
||
|
{
|
||
|
m_hRopes[ iRope ]->m_Width = 0.7;
|
||
|
m_hRopes[ iRope ]->m_nSegments = ROPE_MAX_SEGMENTS;
|
||
|
m_hRopes[ iRope ]->EnableWind( false );
|
||
|
m_hRopes[ iRope ]->SetupHangDistance( 9.0f );
|
||
|
m_hRopes[ iRope ]->m_bConstrainBetweenEndpoints = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::RopesOff( void )
|
||
|
{
|
||
|
for ( int iRope = 0; iRope < SECURITY_CAMERA_NUM_ROPES; ++iRope )
|
||
|
{
|
||
|
// Remove rope if it's alive
|
||
|
if ( m_hRopes[ iRope ] )
|
||
|
{
|
||
|
UTIL_Remove( m_hRopes[ iRope ] );
|
||
|
m_hRopes[ iRope ] = NULL;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::EyeOn( void )
|
||
|
{
|
||
|
if ( !m_hEyeGlow )
|
||
|
{
|
||
|
// Create our eye sprite
|
||
|
m_hEyeGlow = CSprite::SpriteCreate( SECURITY_CAMERA_GLOW_SPRITE, GetLocalOrigin(), false );
|
||
|
if ( !m_hEyeGlow )
|
||
|
return;
|
||
|
|
||
|
m_hEyeGlow->SetTransparency( kRenderWorldGlow, 255, 0, 0, 128, kRenderFxNoDissipation );
|
||
|
m_hEyeGlow->SetAttachment( this, LookupAttachment( "light" ) );
|
||
|
m_hEyeGlow->SetScale( 0.3f, 1.0f );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::EyeOff( void )
|
||
|
{
|
||
|
if ( m_hEyeGlow != NULL )
|
||
|
{
|
||
|
UTIL_Remove( m_hEyeGlow );
|
||
|
m_hEyeGlow = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::InputToggle( inputdata_t &inputdata )
|
||
|
{
|
||
|
Toggle();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::InputEnable( inputdata_t &inputdata )
|
||
|
{
|
||
|
Enable();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::InputDisable( inputdata_t &inputdata )
|
||
|
{
|
||
|
Disable();
|
||
|
}
|
||
|
|
||
|
void CNPC_SecurityCamera::InputRagdoll( inputdata_t &inputdata )
|
||
|
{
|
||
|
if ( !m_bEnabled )
|
||
|
return;
|
||
|
|
||
|
// Leave decal on wall (may want to disable this once decal for where cam touches wall is made)
|
||
|
Vector vForward;
|
||
|
GetVectors( &vForward, NULL, NULL );
|
||
|
|
||
|
trace_t tr;
|
||
|
UTIL_TraceLine ( GetAbsOrigin() + 10.0f * vForward, GetAbsOrigin() -60.0f * vForward, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
||
|
if ( tr.m_pEnt )
|
||
|
UTIL_DecalTrace( &tr, "SecurityCamera.Detachment" );
|
||
|
|
||
|
// Disable it's AI
|
||
|
Disable();
|
||
|
SetThink( &CNPC_SecurityCamera::DeathThink );
|
||
|
EyeOff();
|
||
|
|
||
|
// Make it move
|
||
|
IPhysicsObject *pPhysics = VPhysicsGetObject();
|
||
|
if ( !pPhysics || pPhysics->IsMotionEnabled() )
|
||
|
return;
|
||
|
|
||
|
pPhysics->EnableMotion( true );
|
||
|
pPhysics->Wake();
|
||
|
|
||
|
PlayDismountSounds();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_SecurityCamera::DeathThink( void )
|
||
|
{
|
||
|
if ( PreThink( TURRET_DEAD ) )
|
||
|
return;
|
||
|
|
||
|
// Level out our angles
|
||
|
m_vecGoalAngles.x = 120.0f;
|
||
|
m_vecGoalAngles.y = 0.0f;
|
||
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
||
|
|
||
|
if ( m_lifeState != LIFE_DEAD )
|
||
|
{
|
||
|
m_lifeState = LIFE_DEAD;
|
||
|
|
||
|
//EmitSound( "NPC_CeilingTurret.Die" );
|
||
|
}
|
||
|
|
||
|
// lots of smoke
|
||
|
Vector pos;
|
||
|
CollisionProp()->RandomPointInBounds( vec3_origin, Vector( 1, 1, 1 ), &pos );
|
||
|
|
||
|
CBroadcastRecipientFilter filter;
|
||
|
|
||
|
te->Smoke( filter, 0.0, &pos, g_sModelIndexSmoke, 2.5, 10 );
|
||
|
|
||
|
g_pEffects->Sparks( pos );
|
||
|
|
||
|
if ( !UpdateFacing() )
|
||
|
{
|
||
|
m_flPlaybackRate = 0;
|
||
|
SetThink( NULL );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Input : *pEnemy -
|
||
|
// Output : Returns true on success, false on failure.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CNPC_SecurityCamera::CanBeAnEnemyOf( CBaseEntity *pEnemy )
|
||
|
{
|
||
|
// If we're out of ammo, make friendly companions ignore us
|
||
|
if ( m_spawnflags & SF_SECURITY_CAMERA_OUT_OF_AMMO )
|
||
|
{
|
||
|
if ( pEnemy->Classify() == CLASS_PLAYER_ALLY_VITAL )
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
return BaseClass::CanBeAnEnemyOf( pEnemy );
|
||
|
}
|
||
|
|
||
|
|
||
|
void PlayDismountSounds()
|
||
|
{
|
||
|
// Play GLaDOS's audio reaction
|
||
|
CPortal_Player* pPlayer = ToPortalPlayer( UTIL_PlayerByIndex( 1 ) );
|
||
|
CAI_BaseActor* pGlaDOS = (CAI_BaseActor*)gEntList.FindEntityByName( NULL, "Aperture_AI" );
|
||
|
|
||
|
if ( !pPlayer || !pGlaDOS )
|
||
|
{
|
||
|
DevMsg( 2, "Could not play CNPC_SecurityCamera dismount scene, make sure actor named 'Aperture_AI' is present in map.\n" );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "security_camera_detached" );
|
||
|
if ( event )
|
||
|
{
|
||
|
gameeventmanager->FireEvent( event );
|
||
|
}
|
||
|
|
||
|
// If glados is currently talking, don't let her talk over herself or interrupt a potentially important speech.
|
||
|
// Should we play the dismount sound after she's done? or is that too disjointed from the camera dismounting act to make sense...
|
||
|
if ( IsRunningScriptedScene( pGlaDOS, false ) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
pPlayer->IncNumCamerasDetatched();
|
||
|
int iNumCamerasDetatched = pPlayer->GetNumCamerasDetatched();
|
||
|
|
||
|
// If they've knocked down every one possible, play special '1' sound.
|
||
|
if ( iNumCamerasDetatched == SECURITY_CAMERA_TOTAL_TO_KNOCK_DOWN )
|
||
|
{
|
||
|
InstancedScriptedScene( pGlaDOS, CAMERA_DESTROYED_SCENE_1 );
|
||
|
}
|
||
|
else // iNumCamerasDetatched < SECURITY_CAMERA_TOTAL_TO_KNOCK_DOWN
|
||
|
{
|
||
|
// Play different sounds based on progress towards security camera knockdown total.
|
||
|
switch ( iNumCamerasDetatched )
|
||
|
{
|
||
|
case 1:
|
||
|
InstancedScriptedScene( pGlaDOS, CAMERA_DESTROYED_SCENE_2 );
|
||
|
break;
|
||
|
|
||
|
case 2:
|
||
|
InstancedScriptedScene( pGlaDOS, CAMERA_DESTROYED_SCENE_3 );
|
||
|
break;
|
||
|
|
||
|
case 3:
|
||
|
InstancedScriptedScene( pGlaDOS, CAMERA_DESTROYED_SCENE_4 );
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
InstancedScriptedScene( pGlaDOS, CAMERA_DESTROYED_SCENE_5 );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|