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.
1342 lines
31 KiB
1342 lines
31 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose:
|
||
|
//
|
||
|
//=============================================================================
|
||
|
|
||
|
#ifndef TF_TURRET_H
|
||
|
#define TF_TURRET_H
|
||
|
#ifdef _WIN32
|
||
|
#pragma once
|
||
|
#endif
|
||
|
|
||
|
|
||
|
#include "ehandle.h"
|
||
|
#include "tf_shareddefs.h"
|
||
|
|
||
|
#if 0
|
||
|
extern Vector VecBModelOrigin( entvars_t* pevBModel );
|
||
|
|
||
|
#define TURRET_SHOTS 2
|
||
|
#define TURRET_RANGE (100 * 12)
|
||
|
#define TURRET_SPREAD Vector( 0, 0, 0 )
|
||
|
#define TURRET_TURNRATE 30 //angles per 0.1 second
|
||
|
#define TURRET_MAXWAIT 15 // seconds turret will stay active w/o a target
|
||
|
#define TURRET_MAXSPIN 5 // seconds turret barrel will spin w/o a target
|
||
|
#define TURRET_MACHINE_VOLUME 0.5
|
||
|
|
||
|
typedef enum
|
||
|
{
|
||
|
TURRET_ANIM_NONE = 0,
|
||
|
TURRET_ANIM_FIRE,
|
||
|
TURRET_ANIM_SPIN,
|
||
|
TURRET_ANIM_DEPLOY,
|
||
|
TURRET_ANIM_RETIRE,
|
||
|
TURRET_ANIM_DIE,
|
||
|
} TURRET_ANIM;
|
||
|
|
||
|
class CBaseTurret : public CBaseMonster
|
||
|
{
|
||
|
public:
|
||
|
void Spawn(void);
|
||
|
virtual void Precache(void);
|
||
|
void KeyValue( KeyValueData *pkvd );
|
||
|
void EXPORT TurretUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||
|
|
||
|
virtual void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
|
||
|
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
|
||
|
virtual int Classify(void);
|
||
|
|
||
|
int BloodColor( void ) { return DONT_BLEED; }
|
||
|
void GibMonster( void ) {} // UNDONE: Throw turret gibs?
|
||
|
|
||
|
// Think functions
|
||
|
|
||
|
void EXPORT ActiveThink(void);
|
||
|
void EXPORT SearchThink(void);
|
||
|
void EXPORT AutoSearchThink(void);
|
||
|
void EXPORT TurretDeath(void);
|
||
|
|
||
|
virtual void EXPORT SpinDownCall(void) { m_iSpin = 0; }
|
||
|
virtual void EXPORT SpinUpCall(void) { m_iSpin = 1; }
|
||
|
|
||
|
// void SpinDown(void);
|
||
|
// float EXPORT SpinDownCall( void ) { return SpinDown(); }
|
||
|
|
||
|
// virtual float SpinDown(void) { return 0;}
|
||
|
// virtual float Retire(void) { return 0;}
|
||
|
|
||
|
void EXPORT Deploy(void);
|
||
|
void EXPORT Retire(void);
|
||
|
|
||
|
void EXPORT Initialize(void);
|
||
|
|
||
|
virtual void Ping(void);
|
||
|
virtual void EyeOn(void);
|
||
|
virtual void EyeOff(void);
|
||
|
|
||
|
virtual int Save( CSave &save );
|
||
|
virtual int Restore( CRestore &restore );
|
||
|
|
||
|
static TYPEDESCRIPTION m_SaveData[];
|
||
|
|
||
|
// other functions
|
||
|
void SetTurretAnim(TURRET_ANIM anim);
|
||
|
int MoveTurret(void);
|
||
|
virtual void Shoot(Vector &vecSrc, Vector &vecDirToEnemy) { };
|
||
|
|
||
|
float m_flMaxSpin; // Max time to spin the barrel w/o a target
|
||
|
int m_iSpin;
|
||
|
|
||
|
CSprite *m_pEyeGlow;
|
||
|
int m_eyeBrightness;
|
||
|
|
||
|
int m_iDeployHeight;
|
||
|
int m_iRetractHeight;
|
||
|
int m_iMinPitch;
|
||
|
|
||
|
int m_iBaseTurnRate; // angles per second
|
||
|
float m_fTurnRate; // actual turn rate
|
||
|
int m_iOrientation; // 0 = floor, 1 = Ceiling
|
||
|
int m_iOn;
|
||
|
int m_fBeserk; // Sometimes this bitch will just freak out
|
||
|
int m_iAutoStart; // true if the turret auto deploys when a target
|
||
|
// enters its range
|
||
|
|
||
|
Vector m_vecLastSight;
|
||
|
float m_flLastSight; // Last time we saw a target
|
||
|
float m_flMaxWait; // Max time to seach w/o a target
|
||
|
int m_iSearchSpeed; // Not Used!
|
||
|
|
||
|
// movement
|
||
|
float m_flStartYaw;
|
||
|
Vector m_vecCurAngles;
|
||
|
Vector m_vecGoalAngles;
|
||
|
|
||
|
|
||
|
float m_flPingTime; // Time until the next ping, used when searching
|
||
|
float m_flSpinUpTime; // Amount of time until the barrel should spin down when searching
|
||
|
};
|
||
|
|
||
|
|
||
|
TYPEDESCRIPTION CBaseTurret::m_SaveData[] =
|
||
|
{
|
||
|
DEFINE_FIELD( CBaseTurret, m_flMaxSpin, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iSpin, FIELD_INTEGER ),
|
||
|
|
||
|
DEFINE_FIELD( CBaseTurret, m_pEyeGlow, FIELD_CLASSPTR ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_eyeBrightness, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iDeployHeight, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iRetractHeight, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iMinPitch, FIELD_INTEGER ),
|
||
|
|
||
|
DEFINE_FIELD( CBaseTurret, m_iBaseTurnRate, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_fTurnRate, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iOrientation, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iOn, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_fBeserk, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iAutoStart, FIELD_INTEGER ),
|
||
|
|
||
|
|
||
|
DEFINE_FIELD( CBaseTurret, m_vecLastSight, FIELD_POSITION_VECTOR ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_flLastSight, FIELD_TIME ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_flMaxWait, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_iSearchSpeed, FIELD_INTEGER ),
|
||
|
|
||
|
DEFINE_FIELD( CBaseTurret, m_flStartYaw, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_vecCurAngles, FIELD_VECTOR ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_vecGoalAngles, FIELD_VECTOR ),
|
||
|
|
||
|
DEFINE_FIELD( CBaseTurret, m_flPingTime, FIELD_TIME ),
|
||
|
DEFINE_FIELD( CBaseTurret, m_flSpinUpTime, FIELD_TIME ),
|
||
|
};
|
||
|
|
||
|
IMPLEMENT_SAVERESTORE( CBaseTurret, CBaseMonster );
|
||
|
|
||
|
class CTurret : public CBaseTurret
|
||
|
{
|
||
|
public:
|
||
|
void Spawn(void);
|
||
|
void Precache(void);
|
||
|
// Think functions
|
||
|
void SpinUpCall(void);
|
||
|
void SpinDownCall(void);
|
||
|
|
||
|
virtual int Save( CSave &save );
|
||
|
virtual int Restore( CRestore &restore );
|
||
|
|
||
|
static TYPEDESCRIPTION m_SaveData[];
|
||
|
|
||
|
// other functions
|
||
|
void Shoot(Vector &vecSrc, Vector &vecDirToEnemy);
|
||
|
|
||
|
private:
|
||
|
int m_iStartSpin;
|
||
|
|
||
|
};
|
||
|
TYPEDESCRIPTION CTurret::m_SaveData[] =
|
||
|
{
|
||
|
DEFINE_FIELD( CTurret, m_iStartSpin, FIELD_INTEGER ),
|
||
|
};
|
||
|
|
||
|
IMPLEMENT_SAVERESTORE( CTurret, CBaseTurret );
|
||
|
|
||
|
|
||
|
class CMiniTurret : public CBaseTurret
|
||
|
{
|
||
|
public:
|
||
|
void Spawn( );
|
||
|
void Precache(void);
|
||
|
// other functions
|
||
|
void Shoot(Vector &vecSrc, Vector &vecDirToEnemy);
|
||
|
};
|
||
|
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( monster_turret, CTurret );
|
||
|
LINK_ENTITY_TO_CLASS( monster_miniturret, CMiniTurret );
|
||
|
|
||
|
void CBaseTurret::KeyValue( KeyValueData *pkvd )
|
||
|
{
|
||
|
if (FStrEq(pkvd->szKeyName, "maxsleep"))
|
||
|
{
|
||
|
m_flMaxWait = atof(pkvd->szValue);
|
||
|
pkvd->fHandled = TRUE;
|
||
|
}
|
||
|
else if (FStrEq(pkvd->szKeyName, "orientation"))
|
||
|
{
|
||
|
m_iOrientation = atoi(pkvd->szValue);
|
||
|
pkvd->fHandled = TRUE;
|
||
|
|
||
|
}
|
||
|
else if (FStrEq(pkvd->szKeyName, "searchspeed"))
|
||
|
{
|
||
|
m_iSearchSpeed = atoi(pkvd->szValue);
|
||
|
pkvd->fHandled = TRUE;
|
||
|
|
||
|
}
|
||
|
else if (FStrEq(pkvd->szKeyName, "turnrate"))
|
||
|
{
|
||
|
m_iBaseTurnRate = atoi(pkvd->szValue);
|
||
|
pkvd->fHandled = TRUE;
|
||
|
}
|
||
|
else if (FStrEq(pkvd->szKeyName, "style") ||
|
||
|
FStrEq(pkvd->szKeyName, "height") ||
|
||
|
FStrEq(pkvd->szKeyName, "value1") ||
|
||
|
FStrEq(pkvd->szKeyName, "value2") ||
|
||
|
FStrEq(pkvd->szKeyName, "value3"))
|
||
|
pkvd->fHandled = TRUE;
|
||
|
else
|
||
|
CBaseMonster::KeyValue( pkvd );
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::Spawn()
|
||
|
{
|
||
|
Precache( );
|
||
|
pev->nextthink = gpGlobals->time + 1;
|
||
|
pev->movetype = MOVETYPE_FLY;
|
||
|
pev->sequence = 0;
|
||
|
pev->frame = 0;
|
||
|
pev->solid = SOLID_SLIDEBOX;
|
||
|
|
||
|
// Make turrets invulnerable in multiplayer
|
||
|
if (gpGlobals->deathmatch)
|
||
|
pev->takedamage = DAMAGE_NO;
|
||
|
else
|
||
|
pev->takedamage = DAMAGE_AIM;
|
||
|
|
||
|
SetBits (pev->flags, FL_MONSTER);
|
||
|
SetUse( &CBaseTurret::TurretUse );
|
||
|
|
||
|
// Start turrets automatically in multiplayer
|
||
|
if (gpGlobals->deathmatch)
|
||
|
m_iAutoStart = TRUE;
|
||
|
|
||
|
if (( pev->spawnflags & SF_MONSTER_TURRET_AUTOACTIVATE )
|
||
|
&& !( pev->spawnflags & SF_MONSTER_TURRET_STARTINACTIVE ))
|
||
|
{
|
||
|
m_iAutoStart = TRUE;
|
||
|
}
|
||
|
|
||
|
ResetSequenceInfo( );
|
||
|
SetBoneController( 0, 0 );
|
||
|
SetBoneController( 1, 0 );
|
||
|
m_flFieldOfView = VIEW_FIELD_FULL;
|
||
|
// m_flSightRange = TURRET_RANGE;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::Precache( )
|
||
|
{
|
||
|
PRECACHE_SOUND ("turret/tu_fire1.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_ping.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_active2.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_die.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_die2.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_die3.wav");
|
||
|
// PRECACHE_SOUND ("turret/tu_retract.wav"); // just use deploy sound to save memory
|
||
|
PRECACHE_SOUND ("turret/tu_deploy.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_spinup.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_spindown.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_search.wav");
|
||
|
PRECACHE_SOUND ("turret/tu_alert.wav");
|
||
|
}
|
||
|
|
||
|
#define TURRET_GLOW_SPRITE "sprites/flare3.spr"
|
||
|
|
||
|
void CTurret::Spawn()
|
||
|
{
|
||
|
Precache( );
|
||
|
SET_MODEL(ENT(pev), "models/turret.mdl");
|
||
|
pev->health = gSkillData.turretHealth;
|
||
|
m_HackedGunPos = Vector( 0, 0, 12.75 );
|
||
|
m_flMaxSpin = TURRET_MAXSPIN;
|
||
|
pev->view_ofs.z = 12.75;
|
||
|
|
||
|
CBaseTurret::Spawn( );
|
||
|
|
||
|
m_iRetractHeight = 16;
|
||
|
m_iDeployHeight = 32;
|
||
|
m_iMinPitch = -15;
|
||
|
UTIL_SetSize(pev, Vector(-32, -32, -m_iRetractHeight), Vector(32, 32, m_iRetractHeight));
|
||
|
|
||
|
SetThink(&CTurret::Initialize);
|
||
|
|
||
|
m_pEyeGlow = CSprite::SpriteCreate( TURRET_GLOW_SPRITE, pev->origin, FALSE );
|
||
|
m_pEyeGlow->SetTransparency( kRenderGlow, 255, 0, 0, 0, kRenderFxNoDissipation );
|
||
|
m_pEyeGlow->SetAttachment( edict(), 2 );
|
||
|
m_eyeBrightness = 0;
|
||
|
|
||
|
pev->nextthink = gpGlobals->time + 0.3;
|
||
|
}
|
||
|
|
||
|
void CTurret::Precache()
|
||
|
{
|
||
|
CBaseTurret::Precache( );
|
||
|
PRECACHE_MODEL ("models/turret.mdl");
|
||
|
PRECACHE_MODEL (TURRET_GLOW_SPRITE);
|
||
|
}
|
||
|
|
||
|
void CMiniTurret::Spawn()
|
||
|
{
|
||
|
Precache( );
|
||
|
SET_MODEL(ENT(pev), "models/miniturret.mdl");
|
||
|
pev->health = gSkillData.miniturretHealth;
|
||
|
m_HackedGunPos = Vector( 0, 0, 12.75 );
|
||
|
m_flMaxSpin = 0;
|
||
|
pev->view_ofs.z = 12.75;
|
||
|
|
||
|
CBaseTurret::Spawn( );
|
||
|
m_iRetractHeight = 16;
|
||
|
m_iDeployHeight = 32;
|
||
|
m_iMinPitch = -15;
|
||
|
UTIL_SetSize(pev, Vector(-16, -16, -m_iRetractHeight), Vector(16, 16, m_iRetractHeight));
|
||
|
|
||
|
SetThink(&CMiniTurret::Initialize);
|
||
|
pev->nextthink = gpGlobals->time + 0.3;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CMiniTurret::Precache()
|
||
|
{
|
||
|
CBaseTurret::Precache( );
|
||
|
PRECACHE_MODEL ("models/miniturret.mdl");
|
||
|
PRECACHE_SOUND("weapons/hks1.wav");
|
||
|
PRECACHE_SOUND("weapons/hks2.wav");
|
||
|
PRECACHE_SOUND("weapons/hks3.wav");
|
||
|
}
|
||
|
|
||
|
void CBaseTurret::Initialize(void)
|
||
|
{
|
||
|
m_iOn = 0;
|
||
|
m_fBeserk = 0;
|
||
|
m_iSpin = 0;
|
||
|
|
||
|
SetBoneController( 0, 0 );
|
||
|
SetBoneController( 1, 0 );
|
||
|
|
||
|
if (m_iBaseTurnRate == 0)
|
||
|
{
|
||
|
// Make turrets turn faster in multiplayer
|
||
|
if (gpGlobals->deathmatch)
|
||
|
m_iBaseTurnRate = TURRET_TURNRATE * 2;
|
||
|
else
|
||
|
m_iBaseTurnRate = TURRET_TURNRATE;
|
||
|
}
|
||
|
if (m_flMaxWait == 0)
|
||
|
{
|
||
|
// Make turrets retarget faster
|
||
|
//if (gpGlobals->deathmatch)
|
||
|
//m_flMaxWait = 1;
|
||
|
//else
|
||
|
m_flMaxWait = TURRET_MAXWAIT;
|
||
|
}
|
||
|
m_flStartYaw = pev->angles.y;
|
||
|
if (m_iOrientation == 1)
|
||
|
{
|
||
|
pev->idealpitch = 180;
|
||
|
pev->angles.x = 180;
|
||
|
pev->view_ofs.z = -pev->view_ofs.z;
|
||
|
pev->effects |= EF_INVLIGHT;
|
||
|
pev->angles.y = pev->angles.y + 180;
|
||
|
if (pev->angles.y > 360)
|
||
|
pev->angles.y = pev->angles.y - 360;
|
||
|
}
|
||
|
|
||
|
m_vecGoalAngles.x = 0;
|
||
|
|
||
|
if (m_iAutoStart)
|
||
|
{
|
||
|
m_flLastSight = gpGlobals->time + m_flMaxWait;
|
||
|
SetThink(&CBaseTurret::AutoSearchThink);
|
||
|
pev->nextthink = gpGlobals->time + .1;
|
||
|
}
|
||
|
else
|
||
|
SetThink(&CBaseTurret::SUB_DoNothing);
|
||
|
}
|
||
|
|
||
|
void CBaseTurret::TurretUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
||
|
{
|
||
|
if ( !ShouldToggle( useType, m_iOn ) )
|
||
|
return;
|
||
|
|
||
|
if (m_iOn)
|
||
|
{
|
||
|
m_hEnemy = NULL;
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
m_iAutoStart = FALSE;// switching off a turret disables autostart
|
||
|
//!!!! this should spin down first!!BUGBUG
|
||
|
SetThink(&CBaseTurret::Retire);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pev->nextthink = gpGlobals->time + 0.1; // turn on delay
|
||
|
|
||
|
// if the turret is flagged as an autoactivate turret, re-enable it's ability open self.
|
||
|
if ( pev->spawnflags & SF_MONSTER_TURRET_AUTOACTIVATE )
|
||
|
{
|
||
|
m_iAutoStart = TRUE;
|
||
|
}
|
||
|
|
||
|
SetThink(&CBaseTurret::Deploy);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::Ping( void )
|
||
|
{
|
||
|
// make the pinging noise every second while searching
|
||
|
if (m_flPingTime == 0)
|
||
|
m_flPingTime = gpGlobals->time + 1;
|
||
|
else if (m_flPingTime <= gpGlobals->time)
|
||
|
{
|
||
|
m_flPingTime = gpGlobals->time + 1;
|
||
|
EMIT_SOUND(ENT(pev), CHAN_ITEM, "turret/tu_ping.wav", 1, ATTN_NORM);
|
||
|
EyeOn( );
|
||
|
}
|
||
|
else if (m_eyeBrightness > 0)
|
||
|
{
|
||
|
EyeOff( );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::EyeOn( )
|
||
|
{
|
||
|
if (m_pEyeGlow)
|
||
|
{
|
||
|
if (m_eyeBrightness != 255)
|
||
|
{
|
||
|
m_eyeBrightness = 255;
|
||
|
}
|
||
|
m_pEyeGlow->SetBrightness( m_eyeBrightness );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::EyeOff( )
|
||
|
{
|
||
|
if (m_pEyeGlow)
|
||
|
{
|
||
|
if (m_eyeBrightness > 0)
|
||
|
{
|
||
|
m_eyeBrightness = MAX( 0, m_eyeBrightness - 30 );
|
||
|
m_pEyeGlow->SetBrightness( m_eyeBrightness );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::ActiveThink(void)
|
||
|
{
|
||
|
int fAttack = 0;
|
||
|
Vector vecDirToEnemy;
|
||
|
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
StudioFrameAdvance( );
|
||
|
|
||
|
if ((!m_iOn) || (m_hEnemy == NULL))
|
||
|
{
|
||
|
m_hEnemy = NULL;
|
||
|
m_flLastSight = gpGlobals->time + m_flMaxWait;
|
||
|
SetThink(&CBaseTurret::SearchThink);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// if it's dead, look for something new
|
||
|
if ( !m_hEnemy->IsAlive() )
|
||
|
{
|
||
|
if (!m_flLastSight)
|
||
|
{
|
||
|
m_flLastSight = gpGlobals->time + 0.5; // continue-shooting timeout
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (gpGlobals->time > m_flLastSight)
|
||
|
{
|
||
|
m_hEnemy = NULL;
|
||
|
m_flLastSight = gpGlobals->time + m_flMaxWait;
|
||
|
SetThink(&CBaseTurret::SearchThink);
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Vector vecMid = pev->origin + pev->view_ofs;
|
||
|
Vector vecMidEnemy = m_hEnemy->BodyTarget( vecMid );
|
||
|
|
||
|
// Look for our current enemy
|
||
|
int fEnemyVisible = FBoxVisible(pev, m_hEnemy->pev, vecMidEnemy );
|
||
|
|
||
|
vecDirToEnemy = vecMidEnemy - vecMid; // calculate dir and dist to enemy
|
||
|
float flDistToEnemy = vecDirToEnemy.Length();
|
||
|
|
||
|
Vector vec = UTIL_VecToAngles(vecMidEnemy - vecMid);
|
||
|
|
||
|
// Current enmey is not visible.
|
||
|
if (!fEnemyVisible || (flDistToEnemy > TURRET_RANGE))
|
||
|
{
|
||
|
if (!m_flLastSight)
|
||
|
{
|
||
|
m_flLastSight = gpGlobals->time + 0.5;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Should we look for a new target?
|
||
|
if (gpGlobals->time > m_flLastSight)
|
||
|
{
|
||
|
m_hEnemy = NULL;
|
||
|
m_flLastSight = gpGlobals->time + m_flMaxWait;
|
||
|
SetThink(&CBaseTurret::SearchThink);
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
fEnemyVisible = 0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_vecLastSight = vecMidEnemy;
|
||
|
}
|
||
|
|
||
|
UTIL_MakeAimVectors(m_vecCurAngles);
|
||
|
|
||
|
/*
|
||
|
ALERT( at_console, "%.0f %.0f : %.2f %.2f %.2f\n",
|
||
|
m_vecCurAngles.x, m_vecCurAngles.y,
|
||
|
gpGlobals->v_forward.x, gpGlobals->v_forward.y, gpGlobals->v_forward.z );
|
||
|
*/
|
||
|
|
||
|
Vector vecLOS = vecDirToEnemy; //vecMid - m_vecLastSight;
|
||
|
vecLOS = vecLOS.Normalize();
|
||
|
|
||
|
// Is the Gun looking at the target
|
||
|
if (DotProduct(vecLOS, gpGlobals->v_forward) <= 0.866) // 30 degree slop
|
||
|
fAttack = FALSE;
|
||
|
else
|
||
|
fAttack = TRUE;
|
||
|
|
||
|
// fire the gun
|
||
|
if (m_iSpin && ((fAttack) || (m_fBeserk)))
|
||
|
{
|
||
|
Vector vecSrc, vecAng;
|
||
|
GetAttachment( 0, vecSrc, vecAng );
|
||
|
SetTurretAnim(TURRET_ANIM_FIRE);
|
||
|
// In deathmatch, they just shoot right at you
|
||
|
if (gpGlobals->deathmatch)
|
||
|
{
|
||
|
// Adjust for feigning spies
|
||
|
vecAng = m_hEnemy->Center() - vecSrc;
|
||
|
UTIL_MakeVectors(vecAng);
|
||
|
Shoot(vecSrc, vecAng);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Shoot(vecSrc, gpGlobals->v_forward );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetTurretAnim(TURRET_ANIM_SPIN);
|
||
|
}
|
||
|
|
||
|
//move the gun
|
||
|
if (m_fBeserk)
|
||
|
{
|
||
|
if (RANDOM_LONG(0,9) == 0)
|
||
|
{
|
||
|
m_vecGoalAngles.y = RANDOM_FLOAT(0,360);
|
||
|
m_vecGoalAngles.x = RANDOM_FLOAT(0,90) - 90 * m_iOrientation;
|
||
|
TakeDamage(pev,pev,1, DMG_GENERIC); // don't beserk forever
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
else if (fEnemyVisible)
|
||
|
{
|
||
|
if (vec.y > 360)
|
||
|
vec.y -= 360;
|
||
|
|
||
|
if (vec.y < 0)
|
||
|
vec.y += 360;
|
||
|
|
||
|
//ALERT(at_console, "[%.2f]", vec.x);
|
||
|
|
||
|
if (vec.x < -180)
|
||
|
vec.x += 360;
|
||
|
|
||
|
if (vec.x > 180)
|
||
|
vec.x -= 360;
|
||
|
|
||
|
// now all numbers should be in [1...360]
|
||
|
// pin to turret limitations to [-90...15]
|
||
|
|
||
|
if (m_iOrientation == 0)
|
||
|
{
|
||
|
if (vec.x > 90)
|
||
|
vec.x = 90;
|
||
|
else if (vec.x < m_iMinPitch)
|
||
|
vec.x = m_iMinPitch;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (vec.x < -90)
|
||
|
vec.x = -90;
|
||
|
else if (vec.x > -m_iMinPitch)
|
||
|
vec.x = -m_iMinPitch;
|
||
|
}
|
||
|
|
||
|
// ALERT(at_console, "->[%.2f]\n", vec.x);
|
||
|
|
||
|
m_vecGoalAngles.y = vec.y;
|
||
|
m_vecGoalAngles.x = vec.x;
|
||
|
|
||
|
}
|
||
|
|
||
|
SpinUpCall();
|
||
|
MoveTurret();
|
||
|
}
|
||
|
|
||
|
|
||
|
void CTurret::Shoot(Vector &vecSrc, Vector &vecDirToEnemy)
|
||
|
{
|
||
|
// Make turrets more dangerous in multiplayer
|
||
|
if (gpGlobals->deathmatch)
|
||
|
FireBullets( 1, vecSrc, vecDirToEnemy, TURRET_SPREAD, TURRET_RANGE, BULLET_MONSTER_12MM, 1, 20 );
|
||
|
else
|
||
|
FireBullets( 1, vecSrc, vecDirToEnemy, TURRET_SPREAD, TURRET_RANGE, BULLET_MONSTER_12MM, 1 );
|
||
|
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "turret/tu_fire1.wav", 1, 0.6);
|
||
|
pev->effects = pev->effects | EF_MUZZLEFLASH;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CMiniTurret::Shoot(Vector &vecSrc, Vector &vecDirToEnemy)
|
||
|
{
|
||
|
// Make turrets more dangerous in multiplayer
|
||
|
if (gpGlobals->deathmatch)
|
||
|
FireBullets( 1, vecSrc, vecDirToEnemy, TURRET_SPREAD, TURRET_RANGE, BULLET_MONSTER_12MM, 1, 15 );
|
||
|
else
|
||
|
FireBullets( 1, vecSrc, vecDirToEnemy, TURRET_SPREAD, TURRET_RANGE, BULLET_MONSTER_9MM, 1 );
|
||
|
|
||
|
switch(RANDOM_LONG(0,2))
|
||
|
{
|
||
|
case 0: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/hks1.wav", 1, ATTN_NORM); break;
|
||
|
case 1: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/hks2.wav", 1, ATTN_NORM); break;
|
||
|
case 2: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/hks3.wav", 1, ATTN_NORM); break;
|
||
|
}
|
||
|
pev->effects = pev->effects | EF_MUZZLEFLASH;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::Deploy(void)
|
||
|
{
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
StudioFrameAdvance( );
|
||
|
|
||
|
if (pev->sequence != TURRET_ANIM_DEPLOY)
|
||
|
{
|
||
|
m_iOn = 1;
|
||
|
SetTurretAnim(TURRET_ANIM_DEPLOY);
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_deploy.wav", TURRET_MACHINE_VOLUME, ATTN_NORM);
|
||
|
SUB_UseTargets( this, USE_ON, 0 );
|
||
|
}
|
||
|
|
||
|
if (m_fSequenceFinished)
|
||
|
{
|
||
|
pev->maxs.z = m_iDeployHeight;
|
||
|
pev->mins.z = -m_iDeployHeight;
|
||
|
UTIL_SetSize(pev, pev->mins, pev->maxs);
|
||
|
|
||
|
m_vecCurAngles.x = 0;
|
||
|
|
||
|
if (m_iOrientation == 1)
|
||
|
{
|
||
|
m_vecCurAngles.y = UTIL_AngleMod( pev->angles.y + 180 );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_vecCurAngles.y = UTIL_AngleMod( pev->angles.y );
|
||
|
}
|
||
|
|
||
|
SetTurretAnim(TURRET_ANIM_SPIN);
|
||
|
pev->framerate = 0;
|
||
|
SetThink(&CBaseTurret::SearchThink);
|
||
|
}
|
||
|
|
||
|
m_flLastSight = gpGlobals->time + m_flMaxWait;
|
||
|
}
|
||
|
|
||
|
void CBaseTurret::Retire(void)
|
||
|
{
|
||
|
// make the turret level
|
||
|
m_vecGoalAngles.x = 0;
|
||
|
m_vecGoalAngles.y = m_flStartYaw;
|
||
|
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
|
||
|
StudioFrameAdvance( );
|
||
|
|
||
|
EyeOff( );
|
||
|
|
||
|
if (!MoveTurret())
|
||
|
{
|
||
|
if (m_iSpin)
|
||
|
{
|
||
|
SpinDownCall();
|
||
|
}
|
||
|
else if (pev->sequence != TURRET_ANIM_RETIRE)
|
||
|
{
|
||
|
SetTurretAnim(TURRET_ANIM_RETIRE);
|
||
|
EMIT_SOUND_DYN(ENT(pev), CHAN_BODY, "turret/tu_deploy.wav", TURRET_MACHINE_VOLUME, ATTN_NORM, 0, 120);
|
||
|
SUB_UseTargets( this, USE_OFF, 0 );
|
||
|
}
|
||
|
else if (m_fSequenceFinished)
|
||
|
{
|
||
|
m_iOn = 0;
|
||
|
m_flLastSight = 0;
|
||
|
SetTurretAnim(TURRET_ANIM_NONE);
|
||
|
pev->maxs.z = m_iRetractHeight;
|
||
|
pev->mins.z = -m_iRetractHeight;
|
||
|
UTIL_SetSize(pev, pev->mins, pev->maxs);
|
||
|
if (m_iAutoStart)
|
||
|
{
|
||
|
SetThink(&CBaseTurret::AutoSearchThink);
|
||
|
pev->nextthink = gpGlobals->time + .1;
|
||
|
}
|
||
|
else
|
||
|
SetThink(&CBaseTurret::SUB_DoNothing);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetTurretAnim(TURRET_ANIM_SPIN);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CTurret::SpinUpCall(void)
|
||
|
{
|
||
|
StudioFrameAdvance( );
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
|
||
|
// Are we already spun up? If not start the two stage process.
|
||
|
if (!m_iSpin)
|
||
|
{
|
||
|
SetTurretAnim( TURRET_ANIM_SPIN );
|
||
|
// for the first pass, spin up the the barrel
|
||
|
if (!m_iStartSpin)
|
||
|
{
|
||
|
pev->nextthink = gpGlobals->time + 1.0; // spinup delay
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_spinup.wav", TURRET_MACHINE_VOLUME, ATTN_NORM);
|
||
|
m_iStartSpin = 1;
|
||
|
pev->framerate = 0.1;
|
||
|
}
|
||
|
// after the barrel is spun up, turn on the hum
|
||
|
else if (pev->framerate >= 1.0)
|
||
|
{
|
||
|
pev->nextthink = gpGlobals->time + 0.1; // retarget delay
|
||
|
EMIT_SOUND(ENT(pev), CHAN_STATIC, "turret/tu_active2.wav", TURRET_MACHINE_VOLUME, ATTN_NORM);
|
||
|
SetThink(&CTurret::ActiveThink);
|
||
|
m_iStartSpin = 0;
|
||
|
m_iSpin = 1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pev->framerate += 0.075;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (m_iSpin)
|
||
|
{
|
||
|
SetThink(&CTurret::ActiveThink);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CTurret::SpinDownCall(void)
|
||
|
{
|
||
|
if (m_iSpin)
|
||
|
{
|
||
|
SetTurretAnim( TURRET_ANIM_SPIN );
|
||
|
if (pev->framerate == 1.0)
|
||
|
{
|
||
|
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "turret/tu_active2.wav", 0, 0, SND_STOP, 100);
|
||
|
EMIT_SOUND(ENT(pev), CHAN_ITEM, "turret/tu_spindown.wav", TURRET_MACHINE_VOLUME, ATTN_NORM);
|
||
|
}
|
||
|
pev->framerate -= 0.02;
|
||
|
if (pev->framerate <= 0)
|
||
|
{
|
||
|
pev->framerate = 0;
|
||
|
m_iSpin = 0;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret::SetTurretAnim(TURRET_ANIM anim)
|
||
|
{
|
||
|
if (pev->sequence != anim)
|
||
|
{
|
||
|
switch(anim)
|
||
|
{
|
||
|
case TURRET_ANIM_FIRE:
|
||
|
case TURRET_ANIM_SPIN:
|
||
|
if (pev->sequence != TURRET_ANIM_FIRE && pev->sequence != TURRET_ANIM_SPIN)
|
||
|
{
|
||
|
pev->frame = 0;
|
||
|
}
|
||
|
break;
|
||
|
default:
|
||
|
pev->frame = 0;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
pev->sequence = anim;
|
||
|
ResetSequenceInfo( );
|
||
|
|
||
|
switch(anim)
|
||
|
{
|
||
|
case TURRET_ANIM_RETIRE:
|
||
|
pev->frame = 255;
|
||
|
pev->framerate = -1.0;
|
||
|
break;
|
||
|
case TURRET_ANIM_DIE:
|
||
|
pev->framerate = 1.0;
|
||
|
break;
|
||
|
}
|
||
|
//ALERT(at_console, "Turret anim #%d\n", anim);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//
|
||
|
// This search function will sit with the turret deployed and look for a new target.
|
||
|
// After a set amount of time, the barrel will spin down. After m_flMaxWait, the turret will
|
||
|
// retact.
|
||
|
//
|
||
|
void CBaseTurret::SearchThink(void)
|
||
|
{
|
||
|
// ensure rethink
|
||
|
SetTurretAnim(TURRET_ANIM_SPIN);
|
||
|
StudioFrameAdvance( );
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
|
||
|
if (m_flSpinUpTime == 0 && m_flMaxSpin)
|
||
|
m_flSpinUpTime = gpGlobals->time + m_flMaxSpin;
|
||
|
|
||
|
Ping( );
|
||
|
|
||
|
// If we have a target and we're still healthy
|
||
|
if (m_hEnemy != NULL)
|
||
|
{
|
||
|
if (!m_hEnemy->IsAlive() )
|
||
|
m_hEnemy = NULL;// Dead enemy forces a search for new one
|
||
|
}
|
||
|
|
||
|
|
||
|
// Acquire Target
|
||
|
if (m_hEnemy == NULL)
|
||
|
{
|
||
|
Look(TURRET_RANGE);
|
||
|
m_hEnemy = BestVisibleEnemy();
|
||
|
}
|
||
|
|
||
|
// If we've found a target, spin up the barrel and start to attack
|
||
|
if (m_hEnemy != NULL)
|
||
|
{
|
||
|
m_flLastSight = 0;
|
||
|
m_flSpinUpTime = 0;
|
||
|
SetThink(&CBaseTurret::ActiveThink);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Are we out of time, do we need to retract?
|
||
|
if (gpGlobals->time > m_flLastSight)
|
||
|
{
|
||
|
//Before we retrace, make sure that we are spun down.
|
||
|
m_flLastSight = 0;
|
||
|
m_flSpinUpTime = 0;
|
||
|
SetThink(&CBaseTurret::Retire);
|
||
|
}
|
||
|
// should we stop the spin?
|
||
|
else if ((m_flSpinUpTime) && (gpGlobals->time > m_flSpinUpTime))
|
||
|
{
|
||
|
SpinDownCall();
|
||
|
}
|
||
|
|
||
|
// generic hunt for new victims
|
||
|
m_vecGoalAngles.y = (m_vecGoalAngles.y + 0.1 * m_fTurnRate);
|
||
|
if (m_vecGoalAngles.y >= 360)
|
||
|
m_vecGoalAngles.y -= 360;
|
||
|
MoveTurret();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//
|
||
|
// This think function will deploy the turret when something comes into range. This is for
|
||
|
// automatically activated turrets.
|
||
|
//
|
||
|
void CBaseTurret::AutoSearchThink(void)
|
||
|
{
|
||
|
// ensure rethink
|
||
|
StudioFrameAdvance( );
|
||
|
|
||
|
// Think slower in Multiplayer
|
||
|
pev->nextthink = gpGlobals->time + 2;
|
||
|
|
||
|
// If we have a target and we're still healthy
|
||
|
|
||
|
if (m_hEnemy != NULL)
|
||
|
{
|
||
|
if (!m_hEnemy->IsAlive() )
|
||
|
m_hEnemy = NULL;// Dead enemy forces a search for new one
|
||
|
}
|
||
|
|
||
|
// Acquire Target
|
||
|
|
||
|
if (m_hEnemy == NULL)
|
||
|
{
|
||
|
Look( TURRET_RANGE );
|
||
|
m_hEnemy = BestVisibleEnemy();
|
||
|
}
|
||
|
|
||
|
if (m_hEnemy != NULL)
|
||
|
{
|
||
|
SetThink(&CBaseTurret::Deploy);
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_alert.wav", TURRET_MACHINE_VOLUME, ATTN_NORM);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CBaseTurret :: TurretDeath( void )
|
||
|
{
|
||
|
BOOL iActive = FALSE;
|
||
|
|
||
|
StudioFrameAdvance( );
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
|
||
|
if (pev->deadflag != DEAD_DEAD)
|
||
|
{
|
||
|
pev->deadflag = DEAD_DEAD;
|
||
|
|
||
|
float flRndSound = RANDOM_FLOAT ( 0 , 1 );
|
||
|
|
||
|
if ( flRndSound <= 0.33 )
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_die.wav", 1.0, ATTN_NORM);
|
||
|
else if ( flRndSound <= 0.66 )
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_die2.wav", 1.0, ATTN_NORM);
|
||
|
else
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_die3.wav", 1.0, ATTN_NORM);
|
||
|
|
||
|
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "turret/tu_active2.wav", 0, 0, SND_STOP, 100);
|
||
|
|
||
|
if (m_iOrientation == 0)
|
||
|
m_vecGoalAngles.x = -15;
|
||
|
else
|
||
|
m_vecGoalAngles.x = -90;
|
||
|
|
||
|
SetTurretAnim(TURRET_ANIM_DIE);
|
||
|
|
||
|
EyeOn( );
|
||
|
}
|
||
|
|
||
|
EyeOff( );
|
||
|
|
||
|
if (pev->dmgtime + RANDOM_FLOAT( 0, 2 ) > gpGlobals->time)
|
||
|
{
|
||
|
// lots of smoke
|
||
|
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
|
||
|
WRITE_BYTE( TE_SMOKE );
|
||
|
WRITE_COORD( RANDOM_FLOAT( pev->absmin.x, pev->absmax.x ) );
|
||
|
WRITE_COORD( RANDOM_FLOAT( pev->absmin.y, pev->absmax.y ) );
|
||
|
WRITE_COORD( pev->origin.z - m_iOrientation * 64 );
|
||
|
WRITE_SHORT( g_sModelIndexSmoke );
|
||
|
WRITE_BYTE( 25 ); // scale * 10
|
||
|
WRITE_BYTE( 10 - m_iOrientation * 5); // framerate
|
||
|
MESSAGE_END();
|
||
|
}
|
||
|
|
||
|
if (pev->dmgtime + RANDOM_FLOAT( 0, 5 ) > gpGlobals->time)
|
||
|
{
|
||
|
Vector vecSrc = Vector( RANDOM_FLOAT( pev->absmin.x, pev->absmax.x ), RANDOM_FLOAT( pev->absmin.y, pev->absmax.y ), 0 );
|
||
|
if (m_iOrientation == 0)
|
||
|
vecSrc = vecSrc + Vector( 0, 0, RANDOM_FLOAT( pev->origin.z, pev->absmax.z ) );
|
||
|
else
|
||
|
vecSrc = vecSrc + Vector( 0, 0, RANDOM_FLOAT( pev->absmin.z, pev->origin.z ) );
|
||
|
|
||
|
UTIL_Sparks( vecSrc );
|
||
|
}
|
||
|
|
||
|
if (m_fSequenceFinished && !MoveTurret( ) && pev->dmgtime + 5 < gpGlobals->time)
|
||
|
{
|
||
|
pev->framerate = 0;
|
||
|
SetThink( NULL );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
void CBaseTurret :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
|
||
|
{
|
||
|
if ( ptr->iHitgroup == 10 )
|
||
|
{
|
||
|
// hit armor
|
||
|
if ( pev->dmgtime != gpGlobals->time || (RANDOM_LONG(0,10) < 1) )
|
||
|
{
|
||
|
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT( 1, 2) );
|
||
|
pev->dmgtime = gpGlobals->time;
|
||
|
}
|
||
|
|
||
|
flDamage = 0.1;// don't hurt the monster much, but allow bits_COND_LIGHT_DAMAGE to be generated
|
||
|
}
|
||
|
|
||
|
if ( !pev->takedamage )
|
||
|
return;
|
||
|
|
||
|
AddMultiDamage( pevAttacker, this, flDamage, bitsDamageType );
|
||
|
}
|
||
|
|
||
|
// take damage. bitsDamageType indicates type of damage sustained, ie: DMG_BULLET
|
||
|
|
||
|
int CBaseTurret::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
|
||
|
{
|
||
|
if ( !pev->takedamage )
|
||
|
return 0;
|
||
|
|
||
|
if (!m_iOn)
|
||
|
flDamage /= 10.0;
|
||
|
|
||
|
pev->health -= flDamage;
|
||
|
if (pev->health <= 0)
|
||
|
{
|
||
|
pev->health = 0;
|
||
|
pev->takedamage = DAMAGE_NO;
|
||
|
pev->dmgtime = gpGlobals->time;
|
||
|
|
||
|
ClearBits (pev->flags, FL_MONSTER); // why are they set in the first place???
|
||
|
|
||
|
SetUse(NULL);
|
||
|
SetThink(&CBaseTurret::TurretDeath);
|
||
|
SUB_UseTargets( this, USE_ON, 0 ); // wake up others
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
if (pev->health <= 10)
|
||
|
{
|
||
|
if (m_iOn && (1 || RANDOM_LONG(0, 0x7FFF) > 800))
|
||
|
{
|
||
|
m_fBeserk = 1;
|
||
|
SetThink(&CBaseTurret::SearchThink);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int CBaseTurret::MoveTurret(void)
|
||
|
{
|
||
|
int state = 0;
|
||
|
// any x movement?
|
||
|
|
||
|
if (m_vecCurAngles.x != m_vecGoalAngles.x)
|
||
|
{
|
||
|
float flDir = m_vecGoalAngles.x > m_vecCurAngles.x ? 1 : -1 ;
|
||
|
|
||
|
m_vecCurAngles.x += 0.1 * m_iBaseTurnRate * flDir;
|
||
|
|
||
|
// if we started below the goal, and now we're past, peg to goal
|
||
|
if (flDir == 1)
|
||
|
{
|
||
|
if (m_vecCurAngles.x > m_vecGoalAngles.x)
|
||
|
m_vecCurAngles.x = m_vecGoalAngles.x;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (m_vecCurAngles.x < m_vecGoalAngles.x)
|
||
|
m_vecCurAngles.x = m_vecGoalAngles.x;
|
||
|
}
|
||
|
|
||
|
if (m_iOrientation == 0)
|
||
|
SetBoneController(1, -m_vecCurAngles.x);
|
||
|
else
|
||
|
SetBoneController(1, m_vecCurAngles.x);
|
||
|
state = 1;
|
||
|
}
|
||
|
|
||
|
if (m_vecCurAngles.y != m_vecGoalAngles.y)
|
||
|
{
|
||
|
float flDir = m_vecGoalAngles.y > m_vecCurAngles.y ? 1 : -1 ;
|
||
|
float flDist = fabs(m_vecGoalAngles.y - m_vecCurAngles.y);
|
||
|
|
||
|
if (flDist > 180)
|
||
|
{
|
||
|
flDist = 360 - flDist;
|
||
|
flDir = -flDir;
|
||
|
}
|
||
|
if (flDist > 30)
|
||
|
{
|
||
|
if (m_fTurnRate < m_iBaseTurnRate * 10)
|
||
|
{
|
||
|
m_fTurnRate += m_iBaseTurnRate;
|
||
|
}
|
||
|
}
|
||
|
else if (m_fTurnRate > 45)
|
||
|
{
|
||
|
m_fTurnRate -= m_iBaseTurnRate;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_fTurnRate += m_iBaseTurnRate;
|
||
|
}
|
||
|
|
||
|
m_vecCurAngles.y += 0.1 * m_fTurnRate * flDir;
|
||
|
|
||
|
if (m_vecCurAngles.y < 0)
|
||
|
m_vecCurAngles.y += 360;
|
||
|
else if (m_vecCurAngles.y >= 360)
|
||
|
m_vecCurAngles.y -= 360;
|
||
|
|
||
|
if (flDist < (0.05 * m_iBaseTurnRate))
|
||
|
m_vecCurAngles.y = m_vecGoalAngles.y;
|
||
|
|
||
|
//ALERT(at_console, "%.2f -> %.2f\n", m_vecCurAngles.y, y);
|
||
|
if (m_iOrientation == 0)
|
||
|
SetBoneController(0, m_vecCurAngles.y - pev->angles.y );
|
||
|
else
|
||
|
SetBoneController(0, pev->angles.y - 180 - m_vecCurAngles.y );
|
||
|
state = 1;
|
||
|
}
|
||
|
|
||
|
if (!state)
|
||
|
m_fTurnRate = m_iBaseTurnRate;
|
||
|
|
||
|
//ALERT(at_console, "(%.2f, %.2f)->(%.2f, %.2f)\n", m_vecCurAngles.x,
|
||
|
// m_vecCurAngles.y, m_vecGoalAngles.x, m_vecGoalAngles.y);
|
||
|
return state;
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// ID as a machine
|
||
|
//
|
||
|
int CBaseTurret::Classify ( void )
|
||
|
{
|
||
|
if (m_iOn || m_iAutoStart)
|
||
|
return CLASS_MACHINE;
|
||
|
return CLASS_NONE;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
//=========================================================
|
||
|
// Sentry gun - smallest turret, placed near grunt entrenchments
|
||
|
//=========================================================
|
||
|
class CSentry : public CBaseTurret
|
||
|
{
|
||
|
public:
|
||
|
void Spawn( );
|
||
|
void Precache(void);
|
||
|
// other functions
|
||
|
void Shoot(Vector &vecSrc, Vector &vecDirToEnemy);
|
||
|
int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
|
||
|
void EXPORT SentryTouch( CBaseEntity *pOther );
|
||
|
void EXPORT SentryDeath( void );
|
||
|
|
||
|
};
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( monster_sentry, CSentry );
|
||
|
|
||
|
void CSentry::Precache()
|
||
|
{
|
||
|
CBaseTurret::Precache( );
|
||
|
PRECACHE_MODEL ("models/sentry.mdl");
|
||
|
}
|
||
|
|
||
|
void CSentry::Spawn()
|
||
|
{
|
||
|
Precache( );
|
||
|
SET_MODEL(ENT(pev), "models/sentry.mdl");
|
||
|
pev->health = gSkillData.sentryHealth;
|
||
|
m_HackedGunPos = Vector( 0, 0, 48 );
|
||
|
pev->view_ofs.z = 48;
|
||
|
m_flMaxWait = 1E6;
|
||
|
m_flMaxSpin = 1E6;
|
||
|
|
||
|
CBaseTurret::Spawn();
|
||
|
m_iRetractHeight = 64;
|
||
|
m_iDeployHeight = 64;
|
||
|
m_iMinPitch = -60;
|
||
|
UTIL_SetSize(pev, Vector(-16, -16, -m_iRetractHeight), Vector(16, 16, m_iRetractHeight));
|
||
|
|
||
|
SetTouch(&CSentry::SentryTouch);
|
||
|
SetThink(&CSentry::Initialize);
|
||
|
pev->nextthink = gpGlobals->time + 0.3;
|
||
|
}
|
||
|
|
||
|
void CSentry::Shoot(Vector &vecSrc, Vector &vecDirToEnemy)
|
||
|
{
|
||
|
// Make turrets more dangerous in multiplayer
|
||
|
if (gpGlobals->deathmatch)
|
||
|
FireBullets( 1, vecSrc, vecDirToEnemy, TURRET_SPREAD, TURRET_RANGE, BULLET_MONSTER_12MM, 1, 10 );
|
||
|
else
|
||
|
FireBullets( 1, vecSrc, vecDirToEnemy, TURRET_SPREAD, TURRET_RANGE, BULLET_MONSTER_MP5, 1 );
|
||
|
|
||
|
switch(RANDOM_LONG(0,2))
|
||
|
{
|
||
|
case 0: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/hks1.wav", 1, ATTN_NORM); break;
|
||
|
case 1: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/hks2.wav", 1, ATTN_NORM); break;
|
||
|
case 2: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/hks3.wav", 1, ATTN_NORM); break;
|
||
|
}
|
||
|
pev->effects = pev->effects | EF_MUZZLEFLASH;
|
||
|
}
|
||
|
|
||
|
int CSentry::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
|
||
|
{
|
||
|
if ( !pev->takedamage )
|
||
|
return 0;
|
||
|
|
||
|
if (!m_iOn)
|
||
|
{
|
||
|
SetThink( &CSentry::Deploy );
|
||
|
SetUse( NULL );
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
}
|
||
|
|
||
|
pev->health -= flDamage;
|
||
|
if (pev->health <= 0)
|
||
|
{
|
||
|
pev->health = 0;
|
||
|
pev->takedamage = DAMAGE_NO;
|
||
|
pev->dmgtime = gpGlobals->time;
|
||
|
|
||
|
ClearBits (pev->flags, FL_MONSTER); // why are they set in the first place???
|
||
|
|
||
|
SetUse(NULL);
|
||
|
SetThink(&CSentry::SentryDeath);
|
||
|
SUB_UseTargets( this, USE_ON, 0 ); // wake up others
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CSentry::SentryTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
if (pOther && (pOther->pev->flags & (FL_CLIENT | FL_MONSTER)))
|
||
|
{
|
||
|
TakeDamage(pOther->pev, pOther->pev, 0, 0 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CSentry :: SentryDeath( void )
|
||
|
{
|
||
|
BOOL iActive = FALSE;
|
||
|
|
||
|
StudioFrameAdvance( );
|
||
|
pev->nextthink = gpGlobals->time + 0.1;
|
||
|
|
||
|
if (pev->deadflag != DEAD_DEAD)
|
||
|
{
|
||
|
pev->deadflag = DEAD_DEAD;
|
||
|
|
||
|
float flRndSound = RANDOM_FLOAT ( 0 , 1 );
|
||
|
|
||
|
if ( flRndSound <= 0.33 )
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_die.wav", 1.0, ATTN_NORM);
|
||
|
else if ( flRndSound <= 0.66 )
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_die2.wav", 1.0, ATTN_NORM);
|
||
|
else
|
||
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "turret/tu_die3.wav", 1.0, ATTN_NORM);
|
||
|
|
||
|
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "turret/tu_active2.wav", 0, 0, SND_STOP, 100);
|
||
|
|
||
|
SetBoneController( 0, 0 );
|
||
|
SetBoneController( 1, 0 );
|
||
|
|
||
|
SetTurretAnim(TURRET_ANIM_DIE);
|
||
|
|
||
|
pev->solid = SOLID_NOT;
|
||
|
pev->angles.y = UTIL_AngleMod( pev->angles.y + RANDOM_LONG( 0, 2 ) * 120 );
|
||
|
|
||
|
EyeOn( );
|
||
|
}
|
||
|
|
||
|
EyeOff( );
|
||
|
|
||
|
Vector vecSrc, vecAng;
|
||
|
GetAttachment( 1, vecSrc, vecAng );
|
||
|
|
||
|
if (pev->dmgtime + RANDOM_FLOAT( 0, 2 ) > gpGlobals->time)
|
||
|
{
|
||
|
// lots of smoke
|
||
|
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
|
||
|
WRITE_BYTE( TE_SMOKE );
|
||
|
WRITE_COORD( vecSrc.x + RANDOM_FLOAT( -16, 16 ) );
|
||
|
WRITE_COORD( vecSrc.y + RANDOM_FLOAT( -16, 16 ) );
|
||
|
WRITE_COORD( vecSrc.z - 32 );
|
||
|
WRITE_SHORT( g_sModelIndexSmoke );
|
||
|
WRITE_BYTE( 15 ); // scale * 10
|
||
|
WRITE_BYTE( 8 ); // framerate
|
||
|
MESSAGE_END();
|
||
|
}
|
||
|
|
||
|
if (pev->dmgtime + RANDOM_FLOAT( 0, 8 ) > gpGlobals->time)
|
||
|
{
|
||
|
UTIL_Sparks( vecSrc );
|
||
|
}
|
||
|
|
||
|
if (m_fSequenceFinished && pev->dmgtime + 5 < gpGlobals->time)
|
||
|
{
|
||
|
pev->framerate = 0;
|
||
|
SetThink( NULL );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
#endif // TF_TURRET_H
|