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

2441 lines
69 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Engineer's Sentrygun OMG
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_obj_sentrygun.h"
#include "engine/IEngineSound.h"
#include "tf_player.h"
#include "tf_team.h"
#include "world.h"
#include "tf_projectile_rocket.h"
#include "te_effect_dispatch.h"
#include "tf_gamerules.h"
#include "ammodef.h"
#include "tf_weapon_wrench.h"
#include "tf_weapon_laser_pointer.h"
#include "tf_weapon_shotgun.h"
#include "bot/map_entities/tf_bot_hint_sentrygun.h"
#include "bot/tf_bot.h"
#include "nav_mesh/tf_nav_mesh.h"
#include "nav_pathfind.h"
#include "tf_weapon_knife.h"
#include "tf_logic_robot_destruction.h"
#include "tf_target_dummy.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern bool IsInCommentaryMode();
extern ConVar tf_nav_in_combat_range;
// Ground placed version
#define SENTRY_MODEL_PLACEMENT "models/buildables/sentry1_blueprint.mdl"
#define SENTRY_MODEL_LEVEL_1 "models/buildables/sentry1.mdl"
#define SENTRY_MODEL_LEVEL_1_UPGRADE "models/buildables/sentry1_heavy.mdl"
#define SENTRY_MODEL_LEVEL_2 "models/buildables/sentry2.mdl"
#define SENTRY_MODEL_LEVEL_2_UPGRADE "models/buildables/sentry2_heavy.mdl"
#define SENTRY_MODEL_LEVEL_3 "models/buildables/sentry3.mdl"
#define SENTRY_MODEL_LEVEL_3_UPGRADE "models/buildables/sentry3_heavy.mdl"
#define SENTRY_ROCKET_MODEL "models/buildables/sentry3_rockets.mdl"
#define SENTRYGUN_MINS Vector(-20, -20, 0)
#define SENTRYGUN_MAXS Vector( 20, 20, 66)
#define SENTRYGUN_ADD_SHELLS 40
#define SENTRYGUN_ADD_ROCKETS 8
#define SENTRY_THINK_DELAY 0.05
#define SENTRYGUN_CONTEXT "SentrygunContext"
#define SENTRYGUN_RECENTLY_ATTACKED_TIME 2.0
#define SENTRYGUN_MINIGUN_RESIST_LVL_1 0.0
#define SENTRYGUN_MINIGUN_RESIST_LVL_2 0.15
#define SENTRYGUN_MINIGUN_RESIST_LVL_3 0.20
#define SENTRYGUN_SAPPER_OWNER_DAMAGE_MODIFIER 0.66f
#define SENTRYGUN_MAX_LEVEL_MINI 1
#define MINI_SENTRY_SCALE 0.75f
#define DISPOSABLE_SCALE 0.65f
#define SMALL_SENTRY_SCALE 0.80f
#define WRANGLER_DISABLE_TIME 3.0f
enum
{
SENTRYGUN_ATTACHMENT_MUZZLE = 0,
SENTRYGUN_ATTACHMENT_MUZZLE_ALT,
SENTRYGUN_ATTACHMENT_ROCKET,
};
enum target_ranges
{
RANGE_MELEE,
RANGE_NEAR,
RANGE_MID,
RANGE_FAR,
};
#define VECTOR_CONE_TF_SENTRY Vector( 0.1, 0.1, 0 )
//-----------------------------------------------------------------------------
// Purpose: Only send the LocalWeaponData to the player carrying the weapon
//-----------------------------------------------------------------------------
void* SendProxy_SendLocalObjectDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
{
// Get the weapon entity
CBaseObject *pObject = (CBaseObject*)pVarData;
if ( pObject )
{
// Only send this chunk of data to the player carrying this weapon
CBasePlayer *pPlayer = ToBasePlayer( pObject->GetOwner() );
if ( pPlayer )
{
pRecipients->SetOnly( pPlayer->GetClientIndex() );
return (void*)pVarData;
}
}
return NULL;
}
REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendLocalObjectDataTable );
BEGIN_NETWORK_TABLE_NOBASE( CObjectSentrygun, DT_SentrygunLocalData )
SendPropInt( SENDINFO(m_iKills), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
SendPropInt( SENDINFO(m_iAssists), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
END_NETWORK_TABLE()
IMPLEMENT_SERVERCLASS_ST( CObjectSentrygun, DT_ObjectSentrygun )
SendPropInt( SENDINFO(m_iAmmoShells), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
SendPropInt( SENDINFO(m_iAmmoRockets), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
SendPropInt( SENDINFO(m_iState), Q_log2( SENTRY_NUM_STATES ) + 1, SPROP_UNSIGNED ),
SendPropBool( SENDINFO( m_bPlayerControlled ) ),
SendPropInt( SENDINFO( m_nShieldLevel ), 4, SPROP_UNSIGNED ),
SendPropEHandle( SENDINFO( m_hEnemy ) ),
SendPropEHandle( SENDINFO( m_hAutoAimTarget ) ),
SendPropDataTable( "SentrygunLocalData", 0, &REFERENCE_SEND_TABLE( DT_SentrygunLocalData ), SendProxy_SendLocalObjectDataTable ),
END_SEND_TABLE()
BEGIN_DATADESC( CObjectSentrygun )
END_DATADESC()
LINK_ENTITY_TO_CLASS(obj_sentrygun, CObjectSentrygun);
PRECACHE_REGISTER(obj_sentrygun);
ConVar tf_sentrygun_damage( "tf_sentrygun_damage", "16", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_sentrygun_mini_damage( "tf_sentrygun_mini_damage", "8", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_sentrygun_ammocheat( "tf_sentrygun_ammocheat", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
extern ConVar tf_obj_upgrade_per_hit;
ConVar tf_sentrygun_newtarget_dist( "tf_sentrygun_newtarget_dist", "200", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_sentrygun_metal_per_shell( "tf_sentrygun_metal_per_shell", "1", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_sentrygun_metal_per_rocket( "tf_sentrygun_metal_per_rocket", "2", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_sentrygun_notarget( "tf_sentrygun_notarget", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_sentrygun_max_absorbed_damage_while_controlled_for_achievement( "tf_sentrygun_max_absorbed_damage_while_controlled_for_achievement", "500", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_sentrygun_kill_after_redeploy_time_achievement( "tf_sentrygun_kill_after_redeploy_time_achievement", "10", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
extern ConVar tf_cheapobjects;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CObjectSentrygun::CObjectSentrygun()
{
// Don't bother with health modifying attributes here, because we don't have an owner yet, and it'll be stomped in FirstSpawn()
int iHealth = GetMaxHealthForCurrentLevel();
SetMaxHealth( iHealth );
SetHealth( iHealth );
SetType( OBJ_SENTRYGUN );
m_bFireNextFrame = false;
m_bFireRocketNextFrame = false;
m_flAutoAimStartTime = 0.f;
m_bPlayerControlled = false;
m_iLifetimeShieldedDamage = 0;
m_flFireRate = 1.f;
m_flSentryRange = SENTRY_MAX_RANGE;
m_nShieldLevel.Set( SHIELD_NONE );
m_lastTeammateWrenchHit = NULL;
m_lastTeammateWrenchHitTimer.Invalidate();
m_flScaledSentry = 1.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::Spawn()
{
m_iPitchPoseParameter = -1;
m_iYawPoseParameter = -1;
SetModel( SENTRY_MODEL_PLACEMENT );
// Rotate Details
m_iRightBound = 45;
m_iLeftBound = 315;
m_iBaseTurnRate = 6;
m_flFieldOfView = VIEW_FIELD_NARROW;
// Give the Gun some ammo
m_iAmmoShells = 0;
m_iAmmoRockets = 0;
float flMaxAmmoMult = 1.f;
if ( GetOwner() )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), flMaxAmmoMult, mvm_sentry_ammo );
}
m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_1 * flMaxAmmoMult;
m_iMaxAmmoRockets = SENTRYGUN_MAX_ROCKETS * flMaxAmmoMult;
m_iAmmoType = GetAmmoDef()->Index( "TF_AMMO_PRIMARY" );
// Start searching for enemies
m_hEnemy = NULL;
m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_1;
m_lastTeammateWrenchHit = NULL;
m_lastTeammateWrenchHitTimer.Invalidate();
BaseClass::Spawn();
SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_1 );
SetBuildingSize();
m_iState.Set( SENTRY_STATE_INACTIVE );
SetContextThink( &CObjectSentrygun::SentryThink, gpGlobals->curtime + SENTRY_THINK_DELAY, SENTRYGUN_CONTEXT );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::FirstSpawn()
{
m_flLastAttackedTime = 0;
int iHealth = GetMaxHealthForCurrentLevel();
SetMaxHealth( iHealth );
SetHealth( iHealth );
BaseClass::FirstSpawn();
}
Vector CObjectSentrygun::GetEnemyAimPosition( CBaseEntity* pEnemy ) const
{
// Default to pointing to the origin
Vector vecPos = pEnemy->WorldSpaceCenter();
CTFPlayer* pTFEnemy = ToTFPlayer( pEnemy );
// This is expensive, so only do it if our target is in a state that requires it
if ( pTFEnemy )
{
bool bShouldUseAccurateMethod = false;
int playerFlags = pTFEnemy->GetFlags();
// Crouch jumping makes your box weird
bShouldUseAccurateMethod |= !( playerFlags & FL_ONGROUND ) && ( playerFlags & FL_DUCKING );
// Taunting can make your box weird
bShouldUseAccurateMethod |= pTFEnemy->m_Shared.InCond( TF_COND_TAUNTING );
if ( bShouldUseAccurateMethod )
{
// Use this bone as the the aim target
int iSpineBone = pTFEnemy->LookupBone( "bip_spine_2" );
if ( iSpineBone != -1 )
{
QAngle angles;
pTFEnemy->GetBonePosition( iSpineBone, vecPos, angles );
}
}
}
return vecPos;
}
void CObjectSentrygun::SentryThink( void )
{
m_flSentryRange = SENTRY_MAX_RANGE;
if ( !IsDisposableBuilding() )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), m_flSentryRange, mult_sentry_range );
}
switch( m_iState )
{
case SENTRY_STATE_INACTIVE:
case SENTRY_STATE_UPGRADING: // Base class handles this
break;
case SENTRY_STATE_SEARCHING:
SentryRotate();
break;
case SENTRY_STATE_ATTACKING:
Attack();
break;
default:
Assert( 0 );
break;
}
SetContextThink( &CObjectSentrygun::SentryThink, gpGlobals->curtime + SENTRY_THINK_DELAY, SENTRYGUN_CONTEXT );
if ( m_nShieldLevel > 0 && (gpGlobals->curtime > m_flShieldFadeTime) )
{
m_nShieldLevel.Set( SHIELD_NONE );
m_vecGoalAngles.x = 0;
}
// infinite ammo for enemy team in MvM mode
if ( TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
{
m_iAmmoRockets = SENTRYGUN_MAX_ROCKETS;
m_iMaxAmmoRockets = SENTRYGUN_MAX_ROCKETS;
m_iAmmoShells = SENTRYGUN_MAX_SHELLS_3;
m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_3;
}
}
void CObjectSentrygun::StartPlacement( CTFPlayer *pPlayer )
{
BaseClass::StartPlacement( pPlayer );
// Set my build size
m_vecBuildMins = SENTRYGUN_MINS;
m_vecBuildMaxs = SENTRYGUN_MAXS;
m_vecBuildMins -= Vector( 4,4,0 );
m_vecBuildMaxs += Vector( 4,4,0 );
MakeMiniBuilding( pPlayer );
MakeDisposableBuilding( pPlayer );
MakeScaledBuilding( GetBuilder() );
}
//-----------------------------------------------------------------------------
// Purpose: Start building the object
//-----------------------------------------------------------------------------
bool CObjectSentrygun::StartBuilding( CBaseEntity *pBuilder )
{
SetStartBuildingModel();
// Have to re-call this in case the player changed their weapon
// between StartPlacement and StartBuilding.
MakeMiniBuilding( GetBuilder() );
MakeDisposableBuilding( GetBuilder() );
MakeScaledBuilding( GetBuilder() );
if ( IsMiniBuilding() )
{
SetBodygroup( FindBodygroupByName( "mini_sentry_light" ), 1 );
}
CreateBuildPoints();
SetPoseParameter( m_iPitchPoseParameter, 0.0 );
SetPoseParameter( m_iYawPoseParameter, 0.0 );
SetObjectMode( IsDisposableBuilding() ? MODE_SENTRYGUN_DISPOSABLE : MODE_SENTRYGUN_NORMAL );
return BaseClass::StartBuilding( pBuilder );
}
void CObjectSentrygun::SetStartBuildingModel( void )
{
SetModel( SENTRY_MODEL_LEVEL_1_UPGRADE );
m_iState.Set( SENTRY_STATE_INACTIVE );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::MakeMiniBuilding( CTFPlayer* pPlayer )
{
if ( !ShouldBeMiniBuilding( pPlayer ) || IsMiniBuilding() )
return;
BaseClass::MakeMiniBuilding( pPlayer );
SetModelScale( MINI_SENTRY_SCALE );
int iHealth = GetMaxHealthForCurrentLevel();
SetMaxHealth( iHealth );
SetHealth( iHealth / 2.0f );
SetBuildingSize();
}
//-----------------------------------------------------------------------------
int CObjectSentrygun::GetMaxUpgradeLevel( )
{
if ( IsDisposableBuilding() || IsMiniBuilding() )
return SENTRYGUN_MAX_LEVEL_MINI;
return BaseClass::GetMaxUpgradeLevel();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::OnGoActive( void )
{
SetModel( SENTRY_MODEL_LEVEL_1 );
if ( IsMiniBuilding() )
{
SetBodygroup( FindBodygroupByName( "mini_sentry_light" ), 1 );
}
m_iState.Set( SENTRY_STATE_SEARCHING );
// Orient it
QAngle angles = GetAbsAngles();
m_vecCurAngles.y = UTIL_AngleMod( angles.y );
m_iRightBound = UTIL_AngleMod( (int)angles.y - 50 );
m_iLeftBound = UTIL_AngleMod( (int)angles.y + 50 );
if ( m_iRightBound > m_iLeftBound )
{
m_iRightBound = m_iLeftBound;
m_iLeftBound = UTIL_AngleMod( (int)angles.y - 50);
}
// Start it rotating
m_vecGoalAngles.y = m_iRightBound;
m_vecGoalAngles.x = m_vecCurAngles.x = 0;
m_bTurningRight = true;
EmitSound( "Building_Sentrygun.Built" );
// if our eye pos is underwater, we're waterlevel 3, else 0
bool bUnderwater = ( UTIL_PointContents( EyePosition() ) & MASK_WATER ) ? true : false;
SetWaterLevel( ( bUnderwater ) ? 3 : 0 );
if ( m_bCarryDeploy )
{
m_iAmmoShells = m_iOldAmmoShells;
m_iAmmoRockets = m_iOldAmmoRockets;
}
else
{
m_iAmmoShells = m_iMaxAmmoShells;
m_iAmmoRockets = m_iMaxAmmoRockets;
}
// Init attachments for level 1 sentry gun
m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE] = LookupAttachment( "muzzle" );
m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE_ALT] = 0;
m_iAttachments[SENTRYGUN_ATTACHMENT_ROCKET] = 0;
BaseClass::OnGoActive();
IGameEvent * event = gameeventmanager->CreateEvent( "sentry_on_go_active" );
if ( event )
{
event->SetInt( "index", entindex() ); // object entity index
gameeventmanager->FireEvent( event, true ); // don't send to clients
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::Precache()
{
BaseClass::Precache();
int iModelIndex;
// Models
PrecacheModel( SENTRY_MODEL_PLACEMENT );
iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_1 );
PrecacheGibsForModel( iModelIndex );
iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_1_UPGRADE );
PrecacheGibsForModel( iModelIndex );
iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_2 );
PrecacheGibsForModel( iModelIndex );
iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_2_UPGRADE );
PrecacheGibsForModel( iModelIndex );
iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_3 );
PrecacheGibsForModel( iModelIndex );
iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_3_UPGRADE );
PrecacheGibsForModel( iModelIndex );
PrecacheModel( SENTRY_ROCKET_MODEL );
PrecacheModel( "models/effects/sentry1_muzzle/sentry1_muzzle.mdl" );
PrecacheModel( "models/buildables/sentry_shield.mdl" );
// Sounds
PrecacheScriptSound( "Building_Sentrygun.Fire" );
PrecacheScriptSound( "Building_Sentrygun.Fire2" ); // level 2 sentry
PrecacheScriptSound( "Building_Sentrygun.Fire3" ); // level 3 sentry
PrecacheScriptSound( "Building_Sentrygun.FireRocket" );
PrecacheScriptSound( "Building_Sentrygun.Alert" );
PrecacheScriptSound( "Building_Sentrygun.AlertTarget" );
PrecacheScriptSound( "Building_Sentrygun.Idle" );
PrecacheScriptSound( "Building_Sentrygun.Idle2" ); // level 2 sentry
PrecacheScriptSound( "Building_Sentrygun.Idle3" ); // level 3 sentry
PrecacheScriptSound( "Building_Sentrygun.Built" );
PrecacheScriptSound( "Building_Sentrygun.Empty" );
PrecacheScriptSound( "Building_Sentrygun.ShaftFire" );
PrecacheScriptSound( "Building_Sentrygun.ShaftFire2" );
PrecacheScriptSound( "Building_Sentrygun.ShaftFire3" );
PrecacheScriptSound( "Building_Sentrygun.ShaftLaserPass" );
PrecacheScriptSound( "Building_MiniSentrygun.Fire" );
PrecacheParticleSystem( "sentrydamage_1" );
PrecacheParticleSystem( "sentrydamage_2" );
PrecacheParticleSystem( "sentrydamage_3" );
PrecacheParticleSystem( "sentrydamage_4" );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CObjectSentrygun::CanBeUpgraded( CTFPlayer *pPlayer )
{
if ( m_bWasMapPlaced && !HasSpawnFlags(SF_SENTRY_UPGRADEABLE) )
{
return false;
}
return BaseClass::CanBeUpgraded( pPlayer );
}
//-----------------------------------------------------------------------------
// Purpose: Raises the Sentrygun one level
//-----------------------------------------------------------------------------
void CObjectSentrygun::StartUpgrading( void )
{
BaseClass::StartUpgrading();
float flMaxAmmoMult = 1.f;
if ( GetOwner() )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), flMaxAmmoMult, mvm_sentry_ammo );
}
switch( m_iUpgradeLevel )
{
case 2:
SetModel( SENTRY_MODEL_LEVEL_2_UPGRADE );
m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_2;
SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_2 );
m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_2 * flMaxAmmoMult;
break;
case 3:
SetModel( SENTRY_MODEL_LEVEL_3_UPGRADE );
if ( !m_bCarryDeploy )
{
m_iAmmoRockets = SENTRYGUN_MAX_ROCKETS;
}
m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_3;
SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_3 );
m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_3 * flMaxAmmoMult;
break;
default:
Assert(0);
break;
}
// more ammo capability
if ( !m_bCarryDeploy )
{
m_iAmmoShells = m_iMaxAmmoShells;
}
m_iState.Set( SENTRY_STATE_UPGRADING );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::FinishUpgrading( void )
{
BaseClass::FinishUpgrading();
m_iState.Set( SENTRY_STATE_SEARCHING );
m_hEnemy = NULL;
switch( m_iUpgradeLevel )
{
case 1:
// This can happen when a saper downgrades a sentry
// No need to do anything here
break;
case 2:
SetModel( SENTRY_MODEL_LEVEL_2 );
break;
case 3:
SetModel( SENTRY_MODEL_LEVEL_3 );
break;
default:
Assert(0);
break;
}
// Look up the new attachments
m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE] = LookupAttachment( "muzzle_l" );
m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE_ALT] = LookupAttachment( "muzzle_r" );
m_iAttachments[SENTRYGUN_ATTACHMENT_ROCKET] = LookupAttachment( "rocket_l" );
}
//-----------------------------------------------------------------------------
// Hit by a friendly engineer's wrench
//-----------------------------------------------------------------------------
bool CObjectSentrygun::OnWrenchHit( CTFPlayer *pPlayer, CTFWrench *pWrench, Vector hitLoc )
{
if ( IsDisposableBuilding() )
return false;
bool bDidWork = false;
// If the player repairs it at all, we're done
if ( GetHealth() < GetMaxHealth() )
{
// STAGING_ENGY
// Mod repair value by shield value
float flRepairValue = pWrench->GetRepairValue();
if ( m_nShieldLevel == SHIELD_NORMAL )
{
flRepairValue *= SHIELD_NORMAL_VALUE;
}
if ( Command_Repair( pPlayer, flRepairValue ) )
{
DoWrenchHitEffect( hitLoc, true, false );
bDidWork = true;
}
}
// Don't put in upgrade metal until the sentry is fully healed
if ( !bDidWork )
{
if ( CheckUpgradeOnHit( pPlayer ) )
{
DoWrenchHitEffect( hitLoc, false, true );
bDidWork = true;
}
}
if ( !IsUpgrading() )
{
// player ammo into rockets
// 1 ammo = 1 shell
// 2 ammo = 1 rocket
// only fill rockets if we have extra shells
int iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
// If the sentry has less that 100% ammo, put some ammo in it
if ( m_iAmmoShells < m_iMaxAmmoShells && iPlayerMetal > 0 )
{
int iMaxShellsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_shell.GetFloat() );
// cap the amount we can add
int iAmountToAdd = MIN( SENTRYGUN_ADD_SHELLS, iMaxShellsPlayerCanAfford );
iAmountToAdd = MIN( ( m_iMaxAmmoShells - m_iAmmoShells ), iAmountToAdd );
// STAGING_ENGY
// Mod Ammo if shielded
if ( m_nShieldLevel == SHIELD_NORMAL )
{
iAmountToAdd *= SHIELD_NORMAL_VALUE;
}
pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_shell.GetInt(), TF_AMMO_METAL );
m_iAmmoShells += iAmountToAdd;
if ( iAmountToAdd > 0 )
{
bDidWork = true;
}
}
// One rocket per two ammo
iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
if ( m_iAmmoRockets < m_iMaxAmmoRockets && m_iUpgradeLevel == 3 && iPlayerMetal > 0 )
{
int iMaxRocketsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_rocket.GetFloat() );
int iAmountToAdd = MIN( ( SENTRYGUN_ADD_ROCKETS ), iMaxRocketsPlayerCanAfford );
iAmountToAdd = MIN( ( m_iMaxAmmoRockets - m_iAmmoRockets ), iAmountToAdd );
// STAGING_ENGY
// Mod Ammo if shielded
if ( m_nShieldLevel == SHIELD_NORMAL )
{
iAmountToAdd *= SHIELD_NORMAL_VALUE;
}
pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_rocket.GetFloat(), TF_AMMO_METAL );
m_iAmmoRockets += iAmountToAdd;
if ( iAmountToAdd > 0 )
{
bDidWork = true;
}
}
}
if ( GetOwner() != pPlayer )
{
if ( bDidWork && m_bPlayerControlled )
{
pPlayer->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_HELP_MANUAL_SENTRY, 1 );
}
// keep track of who last hit us with a wrench for kill assists
m_lastTeammateWrenchHit = pPlayer;
m_lastTeammateWrenchHitTimer.Start();
}
return bDidWork;
}
//-----------------------------------------------------------------------------
// Debug infos
//-----------------------------------------------------------------------------
int CObjectSentrygun::DrawDebugTextOverlays(void)
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[512];
Q_snprintf( tempstr, sizeof( tempstr ), "Level: %d", m_iUpgradeLevel.Get() );
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf( tempstr, sizeof( tempstr ), "Shells: %d / %d", m_iAmmoShells.Get(), m_iMaxAmmoShells.Get() );
EntityText(text_offset,tempstr,0);
text_offset++;
if ( m_iUpgradeLevel == 3 )
{
Q_snprintf( tempstr, sizeof( tempstr ), "Rockets: %d / %d", m_iAmmoRockets.Get(), m_iMaxAmmoRockets.Get() );
EntityText(text_offset,tempstr,0);
text_offset++;
}
Q_snprintf( tempstr, sizeof( tempstr ), "Upgrade metal %d", m_iUpgradeMetal.Get() );
EntityText(text_offset,tempstr,0);
text_offset++;
Vector vecSrc = EyePosition();
Vector forward;
// m_vecCurAngles
AngleVectors( m_vecCurAngles, &forward );
NDebugOverlay::Line( vecSrc, vecSrc + forward * 200, 0, 255, 0, false, 0.1 );
// m_vecGoalAngles
AngleVectors( m_vecGoalAngles, &forward );
NDebugOverlay::Line( vecSrc, vecSrc + forward * 200, 0, 0, 255, false, 0.1 );
}
return text_offset;
}
//-----------------------------------------------------------------------------
// Returns the sentry targeting range the target is in
//-----------------------------------------------------------------------------
int CObjectSentrygun::Range( CBaseEntity *pTarget )
{
Vector vecOrg = EyePosition();
Vector vecTargetOrg = pTarget->EyePosition();
int iDist = ( vecTargetOrg - vecOrg ).Length();
if (iDist < 132)
return RANGE_MELEE;
if (iDist < 550)
return RANGE_NEAR;
if (iDist < m_flSentryRange)
return RANGE_MID;
return RANGE_FAR;
}
//-----------------------------------------------------------------------------
// Look for a target
//-----------------------------------------------------------------------------
bool CObjectSentrygun::FindTarget()
{
if ( m_bPlayerControlled )
{
m_flShieldFadeTime = gpGlobals->curtime + WRANGLER_DISABLE_TIME;
}
m_bPlayerControlled = false;
// Disable the sentry guns for ifm.
if ( tf_sentrygun_notarget.GetBool() )
return false;
if ( IsInCommentaryMode() )
return false;
// Sapper, etc.
if ( IsDisabled() )
return false;
// Loop through players within SENTRY_MAX_RANGE units (sentry range).
Vector vecSentryOrigin = EyePosition();
// find the enemy team
int iEnemyTeam = ( GetTeamNumber() == TF_TEAM_BLUE ) ? TF_TEAM_RED : TF_TEAM_BLUE;
CTFTeam *pTeam = TFTeamMgr()->GetTeam( iEnemyTeam );
if ( !pTeam )
return false;
// If we have an enemy get his minimum distance to check against.
Vector vecSegment;
Vector vecTargetCenter;
float flMinDist2 = m_flSentryRange * m_flSentryRange;
CBaseEntity *pTargetCurrent = NULL;
CBaseEntity *pTargetOld = m_hEnemy.Get();
float flOldTargetDist2 = FLT_MAX;
bool bDummyTarget = false;
// Sentry Decoy
// If we already have a sentry decoy target, keep shooting at it
// Otherwise look for a sentry decoy's first
if ( pTargetCurrent == NULL )
{
CTFTargetDummy *pDummy = dynamic_cast<CTFTargetDummy*>( pTargetOld );
if ( pDummy )
{
pTargetCurrent = pDummy;
bDummyTarget = true;
}
else
{
// Search through all dummies and find one in range
for ( int i = 0; i < ITFTargetDummy::AutoList().Count(); ++i )
{
pDummy = static_cast<CTFTargetDummy*>( ITFTargetDummy::AutoList()[i] );
if ( InSameTeam( pDummy ) )
continue;
vecTargetCenter = pDummy->GetAbsOrigin();
vecTargetCenter += pDummy->GetViewOffset();
VectorSubtract( vecTargetCenter, vecSentryOrigin, vecSegment );
float flDist2 = vecSegment.LengthSqr();
// Check to see if the target is closer than the already validated target.
if ( flDist2 > flMinDist2 )
continue;
// Ray trace!!!
if ( FVisible( pDummy, MASK_SHOT | CONTENTS_GRATE ) )
{
pTargetCurrent = pDummy;
bDummyTarget = true;
}
}
}
}
// If our builder has an active laser pointer we don't seek targets.
CTFPlayer* pBuilder = GetBuilder();
if ( pBuilder )
{
// CTFLaserPointer* pPointer = static_cast<CTFLaserPointer*>( pBuilder->Weapon_OwnsThisID( TF_WEAPON_LASER_POINTER ) );
// FIX ME: Temp fix until we find out why the pointer thinks its deployed after spawn
CTFLaserPointer* pPointer = dynamic_cast<CTFLaserPointer*>( pBuilder->GetActiveWeapon() );
if ( pPointer && pPointer->HasLaserDot() && !IsDisposableBuilding() )
{
m_bPlayerControlled = true;
m_nShieldLevel.Set( SHIELD_NORMAL );
m_flShieldFadeTime = gpGlobals->curtime + WRANGLER_DISABLE_TIME;
// If not target dummy, use laserdot, otherwise targetdummy overrides
if ( !bDummyTarget || !pTargetCurrent )
{
pTargetCurrent = pPointer->GetLaserDot();
// Are we in our brief auto aim period?
float flAutoAimTime = gpGlobals->curtime - m_flAutoAimStartTime;
if ( m_hAutoAimTarget && (flAutoAimTime < 0.2f) )
{
// Only use the auto aim target if we can actually range to him.
Vector vecSrc;
QAngle vecAng;
GetAttachment( GetFireAttachment(), vecSrc, vecAng );
Vector vecEnemy = GetEnemyAimPosition( m_hAutoAimTarget );
trace_t trace;
CTraceFilterIgnoreTeammatesAndTeamObjects filter( pBuilder, COLLISION_GROUP_NONE, pBuilder->GetTeamNumber() );
UTIL_TraceLine( vecSrc, vecEnemy, MASK_SOLID, &filter, &trace );
if ( trace.m_pEnt == m_hAutoAimTarget )
{
pTargetCurrent = m_hAutoAimTarget;
}
else
{
m_hAutoAimTarget = NULL;
}
}
else
{
m_hAutoAimTarget = NULL;
}
}
if ( pTargetCurrent->GetAbsOrigin().DistTo( vecSentryOrigin ) > 30.f )
{
if ( pTargetCurrent != pTargetOld )
{
FoundTarget( pTargetCurrent, vecSentryOrigin, true );
}
return true;
}
else
{
pTargetCurrent = NULL;
}
}
}
// Don't auto track to targets while under the effects of the player shield.
// The shield fades 3 seconds after we disengage from player control.
if ( m_nShieldLevel == SHIELD_NORMAL )
return false;
// is there an active truce?
bool bTruceActive = TFGameRules() && TFGameRules()->IsTruceActive();
if ( ( pTargetCurrent == NULL ) && !bTruceActive )
{
// Sentries will try to target players first, then objects. However, if the enemy held was an object it will continue
// to try and attack it first.
int nTeamCount = pTeam->GetNumPlayers();
for ( int iPlayer = 0; iPlayer < nTeamCount; ++iPlayer )
{
CTFPlayer *pTargetPlayer = static_cast<CTFPlayer*>( pTeam->GetPlayer( iPlayer ) );
if ( pTargetPlayer == NULL )
continue;
// Make sure the player is alive.
if ( !pTargetPlayer->IsAlive() )
continue;
if ( pTargetPlayer->GetFlags() & FL_NOTARGET )
continue;
vecTargetCenter = pTargetPlayer->GetAbsOrigin();
vecTargetCenter += pTargetPlayer->GetViewOffset();
VectorSubtract( vecTargetCenter, vecSentryOrigin, vecSegment );
float flDist2 = vecSegment.LengthSqr();
// Check to see if the target is closer than the already validated target.
if ( flDist2 > flMinDist2 )
continue;
// It is closer, check to see if the target is valid.
if ( ValidTargetPlayer( pTargetPlayer, vecSentryOrigin, vecTargetCenter ) )
{
flMinDist2 = flDist2;
pTargetCurrent = pTargetPlayer;
// Store the current target distance if we come across it
if ( pTargetPlayer == pTargetOld )
{
flOldTargetDist2 = flDist2;
}
}
}
}
// If we already have a target, don't check objects.
if ( pTargetCurrent == NULL )
{
// target non-player bots
CUtlVector< INextBot * > botVector;
TheNextBots().CollectAllBots( &botVector );
float closeBotRangeSq = m_flSentryRange * m_flSentryRange;
for( int b=0; b<botVector.Count(); ++b )
{
CBaseCombatCharacter *bot = botVector[b]->GetEntity();
Vector vecBotTarget = GetEnemyAimPosition( bot );
float rangeSq = ( vecBotTarget - vecSentryOrigin ).LengthSqr();
if ( rangeSq < closeBotRangeSq )
{
if ( ValidTargetBot( bot, vecSentryOrigin, vecBotTarget ) )
{
closeBotRangeSq = rangeSq;
pTargetCurrent = bot;
}
}
}
if ( ( pTargetCurrent == NULL ) && !bTruceActive )
{
// target objects
int nTeamObjectCount = pTeam->GetNumObjects();
for ( int iObject = 0; iObject < nTeamObjectCount; ++iObject )
{
CBaseObject *pTargetObject = pTeam->GetObject( iObject );
if ( !pTargetObject )
continue;
vecTargetCenter = pTargetObject->GetAbsOrigin();
vecTargetCenter += pTargetObject->GetViewOffset();
VectorSubtract( vecTargetCenter, vecSentryOrigin, vecSegment );
float flDist2 = vecSegment.LengthSqr();
// Store the current target distance if we come across it
if ( pTargetObject == pTargetOld )
{
flOldTargetDist2 = flDist2;
}
// Check to see if the target is closer than the already validated target.
if ( flDist2 > flMinDist2 )
continue;
// It is closer, check to see if the target is valid.
if ( ValidTargetObject( pTargetObject, vecSentryOrigin, vecTargetCenter ) )
{
flMinDist2 = flDist2;
pTargetCurrent = pTargetObject;
}
}
}
}
// We have a target.
if ( pTargetCurrent )
{
if ( pTargetCurrent != pTargetOld )
{
// Always target dummies
// flMinDist2 is the new target's distance
// flOldTargetDist2 is the old target's distance
// Don't switch unless the new target is closer by some percentage
if ( bDummyTarget || flMinDist2 < ( flOldTargetDist2 * 0.75f ) )
{
FoundTarget( pTargetCurrent, vecSentryOrigin );
}
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CObjectSentrygun::ValidTargetPlayer( CTFPlayer *pPlayer, const Vector &vecStart, const Vector &vecEnd )
{
// Keep shooting at spies that go invisible after we acquire them as a target.
if ( pPlayer->m_Shared.GetPercentInvisible() > 0.5 )
return false;
// Keep shooting at spies that disguise after we acquire them as at a target.
if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pPlayer->m_Shared.GetDisguiseTeam() == GetTeamNumber() && pPlayer != m_hEnemy )
return false;
// Don't shoot spys that are pretending to be a dispenser
if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED_AS_DISPENSER ) )
return false;
// Don't target spies after they OnKill disguise with 'Your Eternal Reward'
if ( ( pPlayer->m_Shared.InCond( TF_COND_DISGUISING ) || pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
&& pPlayer->m_Shared.GetDisguiseTeam() == GetTeamNumber() )
{
CTFKnife *pKnife = dynamic_cast<CTFKnife *>( pPlayer->GetActiveTFWeapon() );
if ( pKnife && pKnife->GetKnifeType() == KNIFE_DISGUISE_ONKILL )
return false;
}
// Not across water boundary.
if ( ( GetWaterLevel() == 0 && pPlayer->GetWaterLevel() >= 3 ) || ( GetWaterLevel() == 3 && pPlayer->GetWaterLevel() <= 0 ) )
return false;
// Ray trace!!!
return FVisible( pPlayer, MASK_SHOT | CONTENTS_GRATE );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CObjectSentrygun::ValidTargetObject( CBaseObject *pObject, const Vector &vecStart, const Vector &vecEnd )
{
// Ignore objects being placed, they are not real objects yet.
if ( pObject->IsPlacing() )
return false;
// Ignore sappers.
if ( pObject->MustBeBuiltOnAttachmentPoint() )
return false;
// Not across water boundary.
if ( ( GetWaterLevel() == 0 && pObject->GetWaterLevel() >= 3 ) || ( GetWaterLevel() == 3 && pObject->GetWaterLevel() <= 0 ) )
return false;
if ( pObject->GetObjectFlags() & OF_DOESNT_HAVE_A_MODEL )
return false;
// Ray trace.
return FVisible( pObject, MASK_SHOT | CONTENTS_GRATE );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CObjectSentrygun::ValidTargetBot( CBaseCombatCharacter *pBot, const Vector &vecStart, const Vector &vecEnd )
{
// Already collected all of the players in FindTarget()
if ( pBot->IsPlayer() )
return false;
// Don't want to shoot bots that are dead, on the same team, or aren't solid (they won't take damage anyway)
if ( !pBot->IsAlive() || pBot->InSameTeam( this ) || pBot->IsSolidFlagSet( FSOLID_NOT_SOLID ) )
return false;
// Not across water boundary.
if ( ( GetWaterLevel() == 0 && pBot->GetWaterLevel() >= 3 ) || ( GetWaterLevel() == 3 && pBot->GetWaterLevel() <= 0 ) )
return false;
if ( TFGameRules() && TFGameRules()->IsPlayingRobotDestructionMode() )
{
CTFRobotDestruction_Robot *pRobot = dynamic_cast< CTFRobotDestruction_Robot* >( pBot );
if ( pRobot && pRobot->GetShieldedState() )
return false;
}
// Ray trace.
CBaseEntity *pBlocker;
bool bVisible = FVisible( pBot, MASK_SHOT | CONTENTS_GRATE, &pBlocker );
if ( bVisible )
return true;
// Also valid if it's parented to the blocker
if ( pBlocker == pBot->GetParent() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Found a Target
//-----------------------------------------------------------------------------
void CObjectSentrygun::FoundTarget( CBaseEntity *pTarget, const Vector &vecSoundCenter, bool bNoSound )
{
m_hEnemy = pTarget;
if ( ( m_iAmmoShells > 0 ) || ( m_iAmmoRockets > 0 && m_iUpgradeLevel == 3 ) )
{
// Play one sound to everyone but the target.
CPASFilter filter( vecSoundCenter );
if ( pTarget->IsPlayer() )
{
CTFPlayer *pPlayer = ToTFPlayer( pTarget );
// Play a specific sound just to the target and remove it from the general recipient list.
if ( !bNoSound )
{
CSingleUserRecipientFilter singleFilter( pPlayer );
EmitSentrySound( singleFilter, entindex(), "Building_Sentrygun.AlertTarget" );
filter.RemoveRecipient( pPlayer );
// if the target is a bot, alert it
CTFBot *bot = ToTFBot( pPlayer );
if ( bot )
{
bot->GetVisionInterface()->AddKnownEntity( this );
bot->RememberEnemySentry( this, bot->GetAbsOrigin() );
}
}
}
if ( !bNoSound )
{
EmitSentrySound( filter, entindex(), "Building_Sentrygun.Alert" );
}
}
// Update timers, we are attacking now!
m_iState.Set( SENTRY_STATE_ATTACKING );
m_flNextAttack = gpGlobals->curtime + SENTRY_THINK_DELAY;
if ( m_flNextRocketAttack < gpGlobals->curtime )
{
m_flNextRocketAttack = gpGlobals->curtime;// + 0.5;
}
}
//-----------------------------------------------------------------------------
// FInViewCone - returns true is the passed ent is in
// the caller's forward view cone. The dot product is performed
// in 2d, making the view cone infinitely tall.
//-----------------------------------------------------------------------------
bool CObjectSentrygun::FInViewCone ( CBaseEntity *pEntity )
{
Vector forward;
AngleVectors( m_vecCurAngles, &forward );
Vector2D vec2LOS = ( pEntity->GetAbsOrigin() - GetAbsOrigin() ).AsVector2D();
vec2LOS.NormalizeInPlace();
float flDot = vec2LOS.Dot( forward.AsVector2D() );
if ( flDot > m_flFieldOfView )
{
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Make sure our target is still valid, and if so, fire at it
//-----------------------------------------------------------------------------
void CObjectSentrygun::Attack()
{
StudioFrameAdvance( );
if ( IsUsingReverseBuild() || !FindTarget() )
{
m_iState.Set( SENTRY_STATE_SEARCHING );
m_hEnemy = NULL;
return;
}
// Track enemy
Vector vecMid = EyePosition();
Vector vecMidEnemy = GetEnemyAimPosition( m_hEnemy );
Vector vecDirToEnemy = vecMidEnemy - vecMid;
QAngle angToTarget;
VectorAngles( vecDirToEnemy, angToTarget );
angToTarget.y = UTIL_AngleMod( angToTarget.y );
if (angToTarget.x < -180)
angToTarget.x += 360;
if (angToTarget.x > 180)
angToTarget.x -= 360;
// now all numbers should be in [1...360]
// pin to turret limitations to [-50...50]
if (angToTarget.x > 50)
angToTarget.x = 50;
else if (angToTarget.x < -50)
angToTarget.x = -50;
m_vecGoalAngles.y = angToTarget.y;
m_vecGoalAngles.x = angToTarget.x;
MoveTurret();
// Fire on the target if it's within 10 units of being aimed right at it
if ( m_flNextAttack <= gpGlobals->curtime && (m_vecGoalAngles - m_vecCurAngles).Length() <= 10 )
{
if ( !m_bPlayerControlled || m_bFireNextFrame )
{
m_bFireNextFrame = false;
Fire();
}
m_flFireRate = 1.f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), m_flFireRate, mult_sentry_firerate );
if ( m_bPlayerControlled )
{
m_flFireRate *= 0.5f;
}
if ( IsMiniBuilding() && !IsDisposableBuilding() )
{
m_flFireRate *= 0.75f;
}
if ( GetBuilder() && GetBuilder()->m_Shared.InCond( TF_COND_CRITBOOSTED_USER_BUFF ) )
{
m_flFireRate *= 0.4f;
}
if ( m_iUpgradeLevel == 1 )
{
// Level 1 sentries fire slower
m_flNextAttack = gpGlobals->curtime + (0.2*m_flFireRate);
}
else
{
m_flNextAttack = gpGlobals->curtime + (0.1*m_flFireRate);
}
}
else
{
// SetSentryAnim( TFTURRET_ANIM_SPIN );
}
if ( m_bPlayerControlled && m_bFireRocketNextFrame )
{
m_bFireRocketNextFrame = false;
FireRocket();
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CObjectSentrygun::FireRocket()
{
if ( m_flNextRocketAttack >= gpGlobals->curtime || m_iAmmoRockets <= 0 )
return false;
if ( m_hEnemy.Get() == NULL )
return false;
Vector vecAimDir;
Vector vecSrc;
QAngle vecAng;
GetAttachment( m_iAttachments[SENTRYGUN_ATTACHMENT_ROCKET], vecSrc, vecAng );
Vector vecEnemyPos = GetEnemyAimPosition( m_hEnemy );
vecAimDir = vecEnemyPos - vecSrc;
vecAimDir.NormalizeInPlace();
// If we cannot see their WorldSpaceCenter ( possible, as we do our target finding based
// on the eye position of the target ) then fire at the eye position
trace_t tr;
CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
ITraceFilter *pFilterChain = NULL;
CTraceFilterIgnoreFriendlyCombatItems traceFilterCombatItem( this, COLLISION_GROUP_NONE, GetTeamNumber() );
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
{
// Ignore teammates and their (physical) upgrade items in MvM
pFilterChain = &traceFilterCombatItem;
}
CTraceFilterChain traceFilterChain( &traceFilter, pFilterChain );
UTIL_TraceLine( vecSrc, vecEnemyPos, MASK_SOLID, &traceFilterChain, &tr);
if ( m_bPlayerControlled || (tr.m_pEnt && !tr.m_pEnt->IsWorld()) )
{
// NOTE: vecAng is not actually set by GetAttachment!!!
QAngle angDir;
VectorAngles( vecAimDir, angDir );
EmitSentrySound( "Building_Sentrygun.FireRocket" );
QAngle angAimDir;
VectorAngles( vecAimDir, angAimDir );
CTFProjectile_SentryRocket *pProjectile = CTFProjectile_SentryRocket::Create( vecSrc, angAimDir, this, GetBuilder() );
if ( pProjectile )
{
int iDamage = 100;
CALL_ATTRIB_HOOK_INT_ON_OTHER( GetOwner(), iDamage, mult_engy_sentry_damage );
pProjectile->SetDamage( iDamage );
}
// Setup next rocket shot
if ( m_bPlayerControlled )
{
m_flNextRocketAttack = gpGlobals->curtime + 2.25;
}
else
{
AddGesture( ACT_RANGE_ATTACK2 );
m_flNextRocketAttack = gpGlobals->curtime + 3;
}
if ( !tf_sentrygun_ammocheat.GetBool() && !HasSpawnFlags( SF_SENTRY_INFINITE_AMMO ) )
{
m_iAmmoRockets--;
}
}
m_timeSinceLastFired.Start();
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CObjectSentrygun::GetFireAttachment()
{
int iAttachment;
if ( m_iUpgradeLevel > 1 && m_iLastMuzzleAttachmentFired == m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE] )
{
// level 2 and 3 turrets alternate muzzles each time they fizzy fizzy fire.
iAttachment = m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE_ALT];
}
else
{
iAttachment = m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE];
}
m_iLastMuzzleAttachmentFired = iAttachment;
return iAttachment;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CObjectSentrygun::OnKilledEnemy(CBasePlayer* pVictim)
{
if ( !pVictim )
return;
CTFPlayer *pOwner = GetOwner();
if ( !pOwner )
return;
if ( m_bPlayerControlled && pVictim->GetAbsOrigin().DistToSqr( GetAbsOrigin() ) > ( m_flSentryRange * m_flSentryRange ) )
{
pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_MANUAL_SENTRY_KILLS_BEYOND_RANGE );
}
CTFPlayer *pCTFVictim = static_cast<CTFPlayer *>( pVictim );
if ( pCTFVictim->GetControlPointStandingOn() != NULL )
{
pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_SENTRY_KILL_CAPS, 1 );
}
if ( (gpGlobals->curtime - GetCarryDeployTime() < tf_sentrygun_kill_after_redeploy_time_achievement.GetInt()) &&
GetUpgradeLevel() == 3 )
{
pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_MOVE_SENTRY_GET_KILL );
}
}
//-----------------------------------------------------------------------------
// Fire on our target
//-----------------------------------------------------------------------------
bool CObjectSentrygun::Fire()
{
//NDebugOverlay::Cross3D( m_hEnemy->WorldSpaceCenter(), 10, 255, 0, 0, false, 0.1 );
Vector vecAimDir;
// Level 3 Turrets fire rockets every 3 seconds
if ( m_iUpgradeLevel == 3 &&
m_iAmmoRockets > 0 &&
m_flNextRocketAttack < gpGlobals->curtime &&
!m_bPlayerControlled )
{
FireRocket();
}
// All turrets fire shells
if ( m_iAmmoShells > 0 )
{
if ( !IsPlayingGesture( ACT_RANGE_ATTACK1 ) )
{
RemoveGesture( ACT_RANGE_ATTACK1_LOW );
AddGesture( ACT_RANGE_ATTACK1 );
}
if ( m_hEnemy.Get() == NULL )
return false;
Vector vecSrc;
QAngle vecAng;
int iAttachment = GetFireAttachment();
GetAttachment( iAttachment, vecSrc, vecAng );
Vector vecMidEnemy = GetEnemyAimPosition( m_hEnemy );
// If we cannot see their WorldSpaceCenter ( possible, as we do our target finding based
// on the eye position of the target ) then fire at the eye position
trace_t tr;
CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
ITraceFilter *pFilterChain = NULL;
CTraceFilterIgnoreFriendlyCombatItems traceFilterCombatItem( this, COLLISION_GROUP_NONE, GetTeamNumber() );
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
{
// Ignore teammates and their (physical) upgrade items in MvM
pFilterChain = &traceFilterCombatItem;
}
CTraceFilterChain traceFilterChain( &traceFilter, pFilterChain );
UTIL_TraceLine( vecSrc, vecMidEnemy, MASK_SOLID, &traceFilterChain, &tr);
if ( !tr.m_pEnt || tr.m_pEnt->IsWorld() )
{
// Hack it lower a little bit..
// The eye position is not always within the hitboxes for a standing TF Player
vecMidEnemy = m_hEnemy->EyePosition() + Vector(0,0,-5);
}
vecAimDir = vecMidEnemy - vecSrc;
float flDistToTarget = vecAimDir.Length();
vecAimDir.NormalizeInPlace();
//NDebugOverlay::Cross3D( vecSrc, 10, 255, 0, 0, false, 0.1 );
FireBulletsInfo_t info;
info.m_vecSrc = vecSrc;
info.m_vecDirShooting = vecAimDir;
info.m_iTracerFreq = 1;
info.m_iShots = 1;
info.m_pAttacker = GetBuilder();
if ( info.m_pAttacker == NULL )
{
info.m_pAttacker = this;
}
if ( m_bPlayerControlled )
{
info.m_vecSpread = VECTOR_CONE_3DEGREES;
}
else
{
info.m_vecSpread = vec3_origin;
}
info.m_flDistance = flDistToTarget + 100;
info.m_iAmmoType = m_iAmmoType;
if ( IsMiniBuilding() )
{
info.m_flDamage = tf_sentrygun_mini_damage.GetFloat();
info.m_flDamageForceScale = 0.0f;
}
else
{
info.m_flDamage = tf_sentrygun_damage.GetFloat();
}
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), info.m_flDamage, mult_engy_sentry_damage );
FireBullets( info );
// sentry gun fire 'heats up' the nav mesh around it
UpdateNavMeshCombatStatus();
//NDebugOverlay::Line( vecSrc, vecSrc + vecAimDir * 1000, 255, 0, 0, false, 0.1 );
CEffectData data;
data.m_nEntIndex = entindex();
data.m_nAttachmentIndex = iAttachment;
data.m_fFlags = m_iUpgradeLevel;
data.m_vOrigin = vecSrc;
DispatchEffect( "TF_3rdPersonMuzzleFlash_SentryGun", data );
if ( IsMiniBuilding() )
{
EmitSound_t params;
params.m_pSoundName = "Building_MiniSentrygun.Fire";
params.m_flSoundTime = 0;
params.m_pflSoundDuration = 0;
params.m_bWarnOnDirectWaveReference = true;
CPASAttenuationFilter filter( this, "Building_MiniSentrygun.Fire" );
EmitSound( filter, entindex(), params );
}
else
{
if ( !m_bPlayerControlled )
{
switch( m_iUpgradeLevel )
{
case 1:
default:
EmitSentrySound( "Building_Sentrygun.Fire" );
break;
case 2:
EmitSentrySound( "Building_Sentrygun.Fire2" );
break;
case 3:
EmitSentrySound( "Building_Sentrygun.Fire3" );
break;
}
}
else
{
switch ( m_iUpgradeLevel )
{
case 1:
EmitSentrySound( "Building_Sentrygun.ShaftFire" );
break;
case 2:
EmitSentrySound( "Building_Sentrygun.ShaftFire2" );
break;
case 3:
EmitSentrySound( "Building_Sentrygun.ShaftFire3" );
break;
}
}
}
if ( !tf_sentrygun_ammocheat.GetBool() && !HasSpawnFlags( SF_SENTRY_INFINITE_AMMO ) )
{
m_iAmmoShells--;
}
}
else
{
if ( m_iUpgradeLevel > 1 )
{
if ( !IsPlayingGesture( ACT_RANGE_ATTACK1_LOW ) )
{
RemoveGesture( ACT_RANGE_ATTACK1 );
AddGesture( ACT_RANGE_ATTACK1_LOW );
}
}
// Out of ammo, play a click
EmitSound( "Building_Sentrygun.Empty" );
// Disposable sentries blow up when their ammo runs out
if ( IsDisposableBuilding() )
{
DetonateObject();
}
m_flNextAttack = gpGlobals->curtime + 0.2;
}
// note when we last fired at en enemy (or tried to)
m_timeSinceLastFired.Start();
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::ModifyFireBulletsDamage( CTakeDamageInfo* dmgInfo )
{
if ( m_bPlayerControlled && dmgInfo )
{
dmgInfo->SetDamageCustom( TF_DMG_CUSTOM_PLAYER_SENTRY );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CObjectSentrygun::GetPushMultiplier()
{
if ( IsMiniBuilding() )
return 8.f;
else
return 16.f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
{
trace_t tmptrace;
tmptrace.endpos = tr.endpos + RandomVector(-10,10);
// Sentryguns are perfectly accurate, but this doesn't look good for tracers.
// Add a little noise to them, but not enough so that it looks like they're missing.
BaseClass::MakeTracer( vecTracerSrc, tmptrace, iTracerType );
}
//-----------------------------------------------------------------------------
// Purpose: MakeTracer asks back for the attachment index
//-----------------------------------------------------------------------------
int CObjectSentrygun::GetTracerAttachment( void )
{
return m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE];
}
//-----------------------------------------------------------------------------
// Rotate and scan for targets
//-----------------------------------------------------------------------------
void CObjectSentrygun::SentryRotate( void )
{
if ( GetReversesBuildingConstructionSpeed() )
{
m_iState.Set( SENTRY_STATE_INACTIVE );
return;
}
// if we're playing a fire gesture, stop it
if ( IsPlayingGesture( ACT_RANGE_ATTACK1 ) )
{
RemoveGesture( ACT_RANGE_ATTACK1 );
}
if ( IsPlayingGesture( ACT_RANGE_ATTACK1_LOW ) )
{
RemoveGesture( ACT_RANGE_ATTACK1_LOW );
}
// animate
StudioFrameAdvance();
// Look for a target
if ( FindTarget() )
return;
// Rotate
if ( !MoveTurret() )
{
// Change direction
if ( IsDisabled() || m_nShieldLevel == SHIELD_NORMAL )
{
EmitSound( "Building_Sentrygun.Disabled" );
m_vecGoalAngles.x = 30;
}
else
{
switch( m_iUpgradeLevel )
{
case 1:
default:
EmitSentrySound( "Building_Sentrygun.Idle" );
break;
case 2:
EmitSound( "Building_Sentrygun.Idle2" );
break;
case 3:
EmitSound( "Building_Sentrygun.Idle3" );
break;
}
// Switch rotation direction
if ( m_bTurningRight )
{
m_bTurningRight = false;
m_vecGoalAngles.y = m_iLeftBound;
}
else
{
m_bTurningRight = true;
m_vecGoalAngles.y = m_iRightBound;
}
// Randomly look up and down a bit
if (random->RandomFloat(0, 1) < 0.3)
{
m_vecGoalAngles.x = (int)random->RandomFloat(-10,10);
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Add the EMP effect
//-----------------------------------------------------------------------------
void CObjectSentrygun::OnStartDisabled( void )
{
// stay at current rotation, angle down
m_vecGoalAngles.x = m_vecCurAngles.x;
m_vecGoalAngles.y = m_vecCurAngles.y;
// target = nULL
BaseClass::OnStartDisabled();
}
//-----------------------------------------------------------------------------
// Purpose: Remove the EMP effect
//-----------------------------------------------------------------------------
void CObjectSentrygun::OnEndDisabled( void )
{
// return to normal rotations
if ( m_bTurningRight )
{
m_bTurningRight = false;
m_vecGoalAngles.y = m_iLeftBound;
}
else
{
m_bTurningRight = true;
m_vecGoalAngles.y = m_iRightBound;
}
m_vecGoalAngles.x = 0;
BaseClass::OnEndDisabled();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CObjectSentrygun::GetBaseTurnRate( void )
{
if ( m_bPlayerControlled )
{
return m_iBaseTurnRate * 100;
}
else
{
return m_iBaseTurnRate;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CObjectSentrygun::MoveTurret( void )
{
bool bMoved = false;
int iBaseTurnRate = GetBaseTurnRate();
if ( IsMiniBuilding() )
{
iBaseTurnRate *= 1.35f;
}
// any x movement?
if ( m_vecCurAngles.x != m_vecGoalAngles.x )
{
float flDir = m_vecGoalAngles.x > m_vecCurAngles.x ? 1 : -1 ;
m_vecCurAngles.x += SENTRY_THINK_DELAY * ( iBaseTurnRate * 5 ) * 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;
}
SetPoseParameter( m_iPitchPoseParameter, -m_vecCurAngles.x );
bMoved = true;
}
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 );
bool bReversed = false;
if ( flDist > 180 )
{
flDist = 360 - flDist;
flDir = -flDir;
bReversed = true;
}
if ( m_hEnemy.Get() == NULL )
{
if ( flDist > 30 )
{
if ( m_flTurnRate < iBaseTurnRate * 10 )
{
m_flTurnRate += iBaseTurnRate;
}
}
else
{
// Slow down
if ( m_flTurnRate > (iBaseTurnRate * 5) )
m_flTurnRate -= iBaseTurnRate;
}
}
else
{
// When tracking enemies, move faster and don't slow
if ( flDist > 30 )
{
if (m_flTurnRate < iBaseTurnRate * 30)
{
m_flTurnRate += iBaseTurnRate * 3;
}
}
}
m_vecCurAngles.y += SENTRY_THINK_DELAY * m_flTurnRate * flDir;
// if we passed over the goal, peg right to it now
if (flDir == -1)
{
if ( (bReversed == false && m_vecGoalAngles.y > m_vecCurAngles.y) ||
(bReversed == true && m_vecGoalAngles.y < m_vecCurAngles.y) )
{
m_vecCurAngles.y = m_vecGoalAngles.y;
}
}
else
{
if ( (bReversed == false && m_vecGoalAngles.y < m_vecCurAngles.y) ||
(bReversed == true && m_vecGoalAngles.y > m_vecCurAngles.y) )
{
m_vecCurAngles.y = m_vecGoalAngles.y;
}
}
if ( m_vecCurAngles.y < 0 )
{
m_vecCurAngles.y += 360;
}
else if ( m_vecCurAngles.y >= 360 )
{
m_vecCurAngles.y -= 360;
}
if ( flDist < ( SENTRY_THINK_DELAY * 0.5 * iBaseTurnRate ) )
{
m_vecCurAngles.y = m_vecGoalAngles.y;
}
QAngle angles = GetAbsAngles();
float flYaw = m_vecCurAngles.y - angles.y;
SetPoseParameter( m_iYawPoseParameter, -flYaw );
InvalidatePhysicsRecursive( ANIMATION_CHANGED );
bMoved = true;
}
if ( !bMoved || m_flTurnRate <= 0 )
{
m_flTurnRate = iBaseTurnRate * 5;
}
return bMoved;
}
//-----------------------------------------------------------------------------
// Purpose: Note our last attacked time
//-----------------------------------------------------------------------------
int CObjectSentrygun::OnTakeDamage( const CTakeDamageInfo &info )
{
CTakeDamageInfo newInfo = info;
// As we increase in level, we get more resistant to minigun bullets, to compensate for
// our increased surface area taking more minigun hits.
if ( ( info.GetDamageType() & DMG_BULLET ) && ( info.GetDamageCustom() == TF_DMG_CUSTOM_MINIGUN ) )
{
float flDamage = newInfo.GetDamage();
flDamage *= ( 1.0 - m_flHeavyBulletResist );
newInfo.SetDamage( flDamage );
}
// If we are shielded due to player control, we take less damage.
bool bFullyShielded = ( m_nShieldLevel > 0 ) && !HasSapper() && !IsPlasmaDisabled();
if ( bFullyShielded )
{
float flDamage = newInfo.GetDamage();
flDamage *= ( m_nShieldLevel == SHIELD_NORMAL ) ? SHIELD_NORMAL_VALUE : SHIELD_MAX_VALUE;
newInfo.SetDamage( flDamage );
}
// Check to see if we are being sapped.
if ( HasSapper() )
{
// Get the sapper owner.
CBaseObject *pSapper = GetObjectOfTypeOnMe( OBJ_ATTACHMENT_SAPPER );
// Take less damage if the owner is causing additional damage.
if ( pSapper && ( info.GetAttacker() == pSapper->GetOwner() ) )
{
float flDamage = newInfo.GetDamage() * SENTRYGUN_SAPPER_OWNER_DAMAGE_MODIFIER;
newInfo.SetDamage( flDamage );
}
}
int iDamageTaken = BaseClass::OnTakeDamage( newInfo );
if ( iDamageTaken > 0 )
{
m_flLastAttackedTime = gpGlobals->curtime;
// check for achievement
if ( bFullyShielded )
{
int iPrevLifetimeShieldedDamage = m_iLifetimeShieldedDamage;
m_iLifetimeShieldedDamage += iDamageTaken;
const int kMaxDamageForAchievement = tf_sentrygun_max_absorbed_damage_while_controlled_for_achievement.GetInt();
if ( iPrevLifetimeShieldedDamage <= kMaxDamageForAchievement && m_iLifetimeShieldedDamage > kMaxDamageForAchievement )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( pOwner && pOwner->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_MANUAL_SENTRY_ABSORB_DMG );
}
}
}
}
return iDamageTaken;
}
//-----------------------------------------------------------------------------
// Purpose: Called when this object is destroyed
//-----------------------------------------------------------------------------
void CObjectSentrygun::Killed( const CTakeDamageInfo &info )
{
CTFPlayer *pTFKiller = ToTFPlayer( info.GetAttacker() );
if ( pTFKiller && pTFKiller->IsPlayerClass( TF_CLASS_SOLDIER ) )
{
if ( pTFKiller->GetAbsOrigin().DistTo( GetAbsOrigin() ) > SENTRY_MAX_RANGE )
{
pTFKiller->AwardAchievement( ACHIEVEMENT_TF_SOLDIER_DESTROY_SENTRY_OUT_OF_RANGE );
}
//If we are in the corridor map, then we check for the achievement for it.
else if ( m_hEnemy && !( pTFKiller->GetFlags() & FL_ONGROUND ) )
{
CBaseEntity *pDamager = GetBuilder();
if ( NULL == pDamager )
{
pDamager = this;
}
static const float DAMAGE_INTERVAL = 2.0f;
if ( pTFKiller->m_AchievementData.IsDamagerInHistory( pDamager, DAMAGE_INTERVAL ) )
{
//Check the map.
if ( 0 == Q_stricmp( "tra_sol_corridor", STRING( gpGlobals->mapname ) ) )
{
#ifdef TF_SOLDIER_TRAINING_ACHIEVEMENTS
//If the attacker was in the air when this sentry died, give him an achievement.
pTFKiller->AwardAchievement( ACHIEVEMENT_TF_SOLDIER_TRAINING_COR_SENTRY_FROM_AIR );
#endif // TF_SOLDIER_TRAINING_ACHIEVEMENTS
}
}
}
}
// Tell our owner's shotgun the sentry died.
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( pOwner )
{
CTFShotgun_Revenge* pShotgun = dynamic_cast<CTFShotgun_Revenge*>( pOwner->Weapon_OwnsThisID( TF_WEAPON_SENTRY_REVENGE ) );
if ( pShotgun )
{
pShotgun->SentryKilled( GetKills() * 2 + GetAssists() );
}
}
// find nearby sentry hint
if ( TFGameRules() && TFGameRules()->IsInTraining() )
{
CTFBotHintSentrygun *sentryHint;
for( sentryHint = static_cast< CTFBotHintSentrygun * >( gEntList.FindEntityByClassname( NULL, "bot_hint_sentrygun" ) );
sentryHint;
sentryHint = static_cast< CTFBotHintSentrygun * >( gEntList.FindEntityByClassname( sentryHint, "bot_hint_sentrygun" ) ) )
{
if ( sentryHint->IsEnabled() && sentryHint->InSameTeam( this ) )
{
Vector toMe = GetAbsOrigin() - sentryHint->GetAbsOrigin();
float dist2 = toMe.LengthSqr();
if ( dist2 < 1.0f )
{
sentryHint->OnSentryGunDestroyed( this );
sentryHint->DecrementUseCount();
break;
}
}
}
}
// Engineers destroying their own sentry don't escape the buster.
// Destroying disposable sentries doesn't reset the buster.
if ( info.GetAttacker() != this && !IsDisposableBuilding() )
{
// Sentry Buster mission accomplished
if ( pOwner )
{
pOwner->ResetAccumulatedSentryGunDamageDealt();
pOwner->ResetAccumulatedSentryGunKillCount();
}
}
// do normal handling
BaseClass::Killed( info );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::SetModel( const char *pModel )
{
float flPoseParam0 = 0.0;
float flPoseParam1 = 0.0;
// Save pose parameters across model change
if ( m_iPitchPoseParameter >= 0 )
{
flPoseParam0 = GetPoseParameter( m_iPitchPoseParameter );
}
if ( m_iYawPoseParameter >= 0 )
{
flPoseParam1 = GetPoseParameter( m_iYawPoseParameter );
}
BaseClass::SetModel( pModel );
// Reset this after model change
SetBuildingSize();
SetSolid( SOLID_BBOX );
// Restore pose parameters
m_iPitchPoseParameter = LookupPoseParameter( "aim_pitch" );
m_iYawPoseParameter = LookupPoseParameter( "aim_yaw" );
SetPoseParameter( m_iPitchPoseParameter, flPoseParam0 );
SetPoseParameter( m_iYawPoseParameter, flPoseParam1 );
CreateBuildPoints();
ReattachChildren();
ResetSequenceInfo();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::SetBuildingSize()
{
// Mini's do NOT need to have their size set here, SetModelScale already handles scaling for hulls (change from MvM)
UTIL_SetSize( this, SENTRYGUN_MINS, SENTRYGUN_MAXS );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::MakeCarriedObject( CTFPlayer *pCarrier )
{
BaseClass::MakeCarriedObject( pCarrier );
m_iOldAmmoShells = m_iAmmoShells;
m_iOldAmmoRockets = m_iAmmoRockets;
m_nShieldLevel.Set( SHIELD_NONE );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::MakeDisposableBuilding( CTFPlayer* pPlayer )
{
// We don't have our main gun
if ( !( pPlayer->GetNumObjects( OBJ_SENTRYGUN ) && pPlayer->CanBuild( OBJ_SENTRYGUN ) == CB_CAN_BUILD ) )
return;
// We're carrying our main gun
if ( pPlayer->m_Shared.IsCarryingObject() && pPlayer->m_Shared.GetCarriedObject() && !pPlayer->m_Shared.GetCarriedObject()->IsDisposableBuilding() )
return;
if ( IsDisposableBuilding() )
return;
SetMaxHealth( SENTRYGUN_MINI_MAX_HEALTH );
SetHealth( SENTRYGUN_MINI_MAX_HEALTH );
SetModelScale( DISPOSABLE_SCALE );
BaseClass::MakeDisposableBuilding( pPlayer );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::RemoveAllAmmo()
{
m_iOldAmmoShells = m_iAmmoShells;
m_iOldAmmoRockets = m_iAmmoRockets;
m_iAmmoShells = 0;
m_iAmmoRockets = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::EmitSentrySound( IRecipientFilter& filter, int iEntIndex, const char *soundname )
{
EmitSound_t params;
params.m_pSoundName = soundname;
params.m_flSoundTime = 0;
params.m_pflSoundDuration = 0;
params.m_bWarnOnDirectWaveReference = true;
if ( IsMiniBuilding() )
{
StopSound( soundname );
params.m_nPitch = PITCH_HIGH;
params.m_nFlags = SND_CHANGE_PITCH;
}
EmitSound( filter, entindex(), params );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::EmitSentrySound( const char* soundname )
{
CPASAttenuationFilter filter( this, soundname );
EmitSound_t params;
params.m_pSoundName = soundname;
params.m_flSoundTime = 0;
params.m_pflSoundDuration = 0;
params.m_bWarnOnDirectWaveReference = true;
if ( IsMiniBuilding() || m_flFireRate != 1.f )
{
StopSound( soundname );
params.m_nPitch = IsMiniBuilding() ? PITCH_HIGH : RemapValClamped( m_flFireRate, 1.0f, 0.5f, 100.f, 120.f );
params.m_nFlags = SND_CHANGE_PITCH;
}
EmitSound( filter, entindex(), params );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFPlayer *CObjectSentrygun::GetAssistingTeammate( float maxAssistDuration ) const
{
if ( maxAssistDuration > 0.0f && ( !m_lastTeammateWrenchHitTimer.HasStarted() || m_lastTeammateWrenchHitTimer.IsGreaterThen( maxAssistDuration ) ) )
return NULL;
return m_lastTeammateWrenchHit;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::SetAutoAimTarget( CTFPlayer* pPlayer )
{
if ( !pPlayer )
return;
// No auto aim target if a dummy is found
CBaseEntity *pTargetOld = m_hEnemy.Get();
if ( pTargetOld )
{
CTFTargetDummy *pDummy = dynamic_cast<CTFTargetDummy*>( pTargetOld );
if ( pDummy )
{
m_hAutoAimTarget = NULL;
return;
}
}
m_hAutoAimTarget = pPlayer;
m_flAutoAimStartTime = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
void CObjectSentrygun::UpdateNavMeshCombatStatus( void )
{
// mark region as 'in combat'
if ( m_inCombatThrottleTimer.IsElapsed() )
{
// important to keep this at one second, so rate cvars make sense (units/sec)
m_inCombatThrottleTimer.Start( 1.0f );
UpdateLastKnownArea();
// only search up/down StepHeight as a cheap substitute for line of sight
CUtlVector< CNavArea * > nearbyAreaVector;
CollectSurroundingAreas( &nearbyAreaVector, GetLastKnownArea(), tf_nav_in_combat_range.GetFloat(), StepHeight, StepHeight );
for( int i=0; i<nearbyAreaVector.Count(); ++i )
{
CTFNavArea *area = static_cast< CTFNavArea * >( nearbyAreaVector[i] );
// hacky - we want sentry gunfire to immediately heat the area since it is so dangerous
area->OnCombat();
area->OnCombat();
area->OnCombat();
area->OnCombat();
area->OnCombat();
}
}
}
//-------------------------------------------------------------------------------------------------------------------------------
int CObjectSentrygun::GetUpgradeMetalRequired()
{
int iMetal = BaseClass::GetUpgradeMetalRequired();
int iSmallSentry = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), iSmallSentry, build_small_sentries );
if ( iSmallSentry )
{
iMetal *= 0.75f;
}
return iMetal;
}
//-------------------------------------------------------------------------------------------------------------------------------
int CObjectSentrygun::GetMaxHealthForCurrentLevel( void )
{
int iHealth = BaseClass::GetMaxHealthForCurrentLevel();
if ( IsScaledSentry() )
{
iHealth *= 0.66f;
}
return iHealth;
}
//-------------------------------------------------------------------------------------------------------------------------------
void CObjectSentrygun::MakeScaledBuilding( CTFPlayer *pPlayer )
{
int iSmallSentry = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), iSmallSentry, build_small_sentries );
if ( iSmallSentry )
{
m_flScaledSentry = iSmallSentry ? SMALL_SENTRY_SCALE : 1.0f;
SetModelScale( m_flScaledSentry );
int iHealth = GetMaxHealthForCurrentLevel();
SetMaxHealth( iHealth );
SetHealth( iHealth );
SetBuildingSize();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_projectile_sentryrocket, CTFProjectile_SentryRocket );
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SentryRocket, DT_TFProjectile_SentryRocket )
BEGIN_NETWORK_TABLE( CTFProjectile_SentryRocket, DT_TFProjectile_SentryRocket )
END_NETWORK_TABLE()
//-----------------------------------------------------------------------------
// Purpose: Creation
//-----------------------------------------------------------------------------
CTFProjectile_SentryRocket *CTFProjectile_SentryRocket::Create( const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
CTFProjectile_SentryRocket *pRocket = static_cast<CTFProjectile_SentryRocket*>( CTFBaseRocket::Create( NULL, "tf_projectile_sentryrocket", vecOrigin, vecAngles, pOwner ) );
if ( pRocket )
{
pRocket->SetScorer( pScorer );
}
return pRocket;
}
CTFProjectile_SentryRocket::CTFProjectile_SentryRocket()
{
UseClientSideAnimation();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_SentryRocket::Spawn()
{
BaseClass::Spawn();
SetModel( SENTRY_ROCKET_MODEL );
UTIL_SetSize( this, vec3_origin, vec3_origin );
ResetSequence( LookupSequence("idle") );
}
#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose: Directly create a sentry gun at the precise position and orientation desired
//-----------------------------------------------------------------------------
void CC_SentrygunSpawn( const CCommand& args )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
CObjectSentrygun *sentry = (CObjectSentrygun *)CreateEntityByName( "obj_sentrygun" );
if ( sentry )
{
CBasePlayer* pPlayer = UTIL_GetCommandClient();
trace_t tr;
Vector forward;
pPlayer->EyeVectors( &forward );
UTIL_TraceLine( pPlayer->EyePosition(),
pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_SOLID,
pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
sentry->SetAbsOrigin( tr.endpos );
QAngle angles = pPlayer->BodyAngles();
angles.x = 0.0f;
angles.z = 0.0f;
sentry->SetAbsAngles( angles );
}
int iSentryLevel = 2;
int iTeamNum = pPlayer->GetTeamNumber();
if ( args.ArgC() > 1 )
{
int i = atoi(args[1]);
if ( abs(i) >= 1 && abs(i) <= 3)
{
iSentryLevel = abs(i)-1;
}
if ( i < 0)
{
iTeamNum = GetEnemyTeam( iTeamNum );
}
}
sentry->m_nDefaultUpgradeLevel = iSentryLevel;
sentry->Spawn();
sentry->ChangeTeam( iTeamNum );
sentry->InitializeMapPlacedObject();
}
}
static ConCommand sentrygun_spawn( "sentrygun_spawn", CC_SentrygunSpawn, "Spawns a Sentrygun where the player is looking. Takes a parameter for level of sentry [1-3: default 3]. If the passed sentry level < 0, an enemy sentry is spawned.", FCVAR_GAMEDLL | FCVAR_CHEAT );
#endif // STAGING_ONLY