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.
48 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 0b5a04e732
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0b5a04e732'
${ noResults }
source-engine/game/server/tf/tf_turret.h

1342 lines
31 KiB
Raw Blame History

//========= 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