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.
91 Commits
25 Branches
6 Tags
221 MiB
Tree: 31586ce622
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '31586ce622'
${ noResults }
source-engine/game/shared/tf/tf_weapon_sniperrifle.cpp

2272 lines
61 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: TF Sniper Rifle
//
//=============================================================================//
#include "cbase.h"
#include "tf_fx_shared.h"
#include "tf_weapon_sniperrifle.h"
#include "in_buttons.h"
#include "tf_gamerules.h"
// Client specific.
#ifdef CLIENT_DLL
#include "view.h"
#include "beamdraw.h"
#include "vgui/ISurface.h"
#include <vgui/ILocalize.h>
#include "vgui_controls/Controls.h"
#include "hud_crosshair.h"
#include "functionproxy.h"
#include "materialsystem/imaterialvar.h"
#include "toolframework_client.h"
#include "input.h"
#include "client_virtualreality.h"
#include "sourcevr/isourcevirtualreality.h"
// forward declarations
void ToolFramework_RecordMaterialParams( IMaterial *pMaterial );
#else
#include "tf_gamerules.h"
#include "tf_fx.h"
#endif
#define TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC 50.0
#define TF_WEAPON_SNIPERRIFLE_UNCHARGE_PER_SEC 75.0
#define TF_WEAPON_SNIPERRIFLE_DAMAGE_MIN 50
#define TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX 150
#define TF_WEAPON_SNIPERRIFLE_RELOAD_TIME 1.5f
#define TF_WEAPON_SNIPERRIFLE_ZOOM_TIME 0.3f
#define TF_WEAPON_SNIPERRIFLE_NO_CRIT_AFTER_ZOOM_TIME 0.2f
#define SNIPER_DOT_SPRITE_RED "effects/sniperdot_red.vmt"
#define SNIPER_DOT_SPRITE_BLUE "effects/sniperdot_blue.vmt"
#define SNIPER_CHARGE_BEAM_RED "tfc_sniper_charge_red"
#define SNIPER_CHARGE_BEAM_BLUE "tfc_sniper_charge_blue"
#ifdef CLIENT_DLL
ConVar tf_sniper_fullcharge_bell( "tf_sniper_fullcharge_bell", "0", FCVAR_ARCHIVE );
#endif
//=============================================================================
//
// Weapon Sniper Rifles tables.
//
IMPLEMENT_NETWORKCLASS_ALIASED( TFSniperRifle, DT_TFSniperRifle )
BEGIN_NETWORK_TABLE_NOBASE( CTFSniperRifle, DT_SniperRifleLocalData )
#if !defined( CLIENT_DLL )
SendPropFloat( SENDINFO(m_flChargedDamage), 0, SPROP_NOSCALE | SPROP_CHANGES_OFTEN ),
#else
RecvPropFloat( RECVINFO(m_flChargedDamage) ),
#endif
END_NETWORK_TABLE()
BEGIN_NETWORK_TABLE( CTFSniperRifle, DT_TFSniperRifle )
#if !defined( CLIENT_DLL )
SendPropDataTable( "SniperRifleLocalData", 0, &REFERENCE_SEND_TABLE( DT_SniperRifleLocalData ), SendProxy_SendLocalWeaponDataTable ),
#else
RecvPropDataTable( "SniperRifleLocalData", 0, 0, &REFERENCE_RECV_TABLE( DT_SniperRifleLocalData ) ),
#endif
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFSniperRifle )
#ifdef CLIENT_DLL
DEFINE_PRED_FIELD( m_flUnzoomTime, FIELD_FLOAT, 0 ),
DEFINE_PRED_FIELD( m_flRezoomTime, FIELD_FLOAT, 0 ),
DEFINE_PRED_FIELD( m_bRezoomAfterShot, FIELD_BOOLEAN, 0 ),
DEFINE_PRED_FIELD( m_flChargedDamage, FIELD_FLOAT, 0 ),
#endif
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_sniperrifle, CTFSniperRifle );
PRECACHE_WEAPON_REGISTER( tf_weapon_sniperrifle );
BEGIN_DATADESC( CTFSniperRifle )
DEFINE_FIELD( m_flUnzoomTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flRezoomTime, FIELD_FLOAT ),
DEFINE_FIELD( m_bRezoomAfterShot, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flChargedDamage, FIELD_FLOAT ),
END_DATADESC()
//=============================================================================
IMPLEMENT_NETWORKCLASS_ALIASED( TFSniperRifleDecap, DT_TFSniperRifleDecap )
BEGIN_NETWORK_TABLE( CTFSniperRifleDecap, DT_TFSniperRifleDecap )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFSniperRifleDecap )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_sniperrifle_decap, CTFSniperRifleDecap );
PRECACHE_WEAPON_REGISTER( tf_weapon_sniperrifle_decap );
//=============================================================================
IMPLEMENT_NETWORKCLASS_ALIASED( TFSniperRifleClassic, DT_TFSniperRifleClassic )
BEGIN_NETWORK_TABLE( CTFSniperRifleClassic, DT_TFSniperRifleClassic )
#if !defined( CLIENT_DLL )
SendPropBool( SENDINFO(m_bCharging) ),
#else
RecvPropBool( RECVINFO(m_bCharging) ),
#endif
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFSniperRifleClassic )
#ifdef CLIENT_DLL
DEFINE_PRED_FIELD( m_bCharging, FIELD_BOOLEAN, 0 ),
#endif
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_sniperrifle_classic, CTFSniperRifleClassic );
PRECACHE_WEAPON_REGISTER( tf_weapon_sniperrifle_classic );
//=============================================================================
#ifdef STAGING_ONLY
IMPLEMENT_NETWORKCLASS_ALIASED( TFSniperRifleRevolver, DT_TFSniperRifleRevolver )
BEGIN_NETWORK_TABLE( CTFSniperRifleRevolver, DT_TFSniperRifleRevolver )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFSniperRifleRevolver )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_sniperrifle_revolver, CTFSniperRifleRevolver );
PRECACHE_WEAPON_REGISTER( tf_weapon_sniperrifle_revolver );
#endif // STAGING_ONLY
//=============================================================================
//
// Weapon Sniper Rifles functions.
//
//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
CTFSniperRifle::CTFSniperRifle()
{
// Server specific.
#ifdef GAME_DLL
m_hSniperDot = NULL;
#else
m_bPlayedBell = false;
#endif
m_bCurrentShotIsHeadshot = false;
m_flChargedDamage = 0.0f;
m_flChargePerSec = TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC;
m_bWasAimedAtEnemy = false;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
CTFSniperRifle::~CTFSniperRifle()
{
// Server specific.
#ifdef GAME_DLL
DestroySniperDot();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::Spawn()
{
m_iAltFireHint = HINT_ALTFIRE_SNIPERRIFLE;
BaseClass::Spawn();
ResetTimers();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::Precache()
{
BaseClass::Precache();
PrecacheModel( SNIPER_DOT_SPRITE_RED );
PrecacheModel( SNIPER_DOT_SPRITE_BLUE );
PrecacheScriptSound( "doomsday.warhead" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ResetTimers( void )
{
m_flUnzoomTime = -1;
m_flRezoomTime = -1;
m_bRezoomAfterShot = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::Reload( void )
{
// We currently don't reload.
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::CanHolster( void ) const
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer )
{
// TF_COND_MELEE_ONLY need to be able to immediately holster and switch to melee weapon
if ( pPlayer->m_Shared.InCond( TF_COND_MELEE_ONLY ) )
return true;
// don't allow us to holster this weapon if we're in the process of zooming and
// we've just fired the weapon (next primary attack is only 1.5 seconds after firing)
if ( ( pPlayer->GetFOV() < pPlayer->GetDefaultFOV() ) && ( m_flNextPrimaryAttack > gpGlobals->curtime ) )
return false;
}
return BaseClass::CanHolster();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::Holster( CBaseCombatWeapon *pSwitchingTo )
{
// Server specific.
#ifdef GAME_DLL
// Destroy the sniper dot.
DestroySniperDot();
#endif
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
{
ZoomOut();
}
m_flChargedDamage = 0.0f;
#ifdef CLIENT_DLL
m_bPlayedBell = false;
#endif
ResetTimers();
return BaseClass::Holster( pSwitchingTo );
}
void CTFSniperRifle::WeaponReset( void )
{
BaseClass::WeaponReset();
ZoomOut();
m_bCurrentShotIsHeadshot = false;
m_flChargePerSec = TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::OwnerCanJump( void )
{
return gpGlobals->curtime > m_flUnzoomTime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::HandleZooms( void )
{
// Get the owning player.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return;
// Handle the zoom when taunting.
if ( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
{
if ( pPlayer->m_Shared.InCond( TF_COND_AIMING ) )
{
ToggleZoom();
}
//Don't rezoom in the middle of a taunt.
ResetTimers();
}
if ( m_flUnzoomTime > 0 && gpGlobals->curtime > m_flUnzoomTime )
{
if ( m_bRezoomAfterShot )
{
ZoomOutIn();
m_bRezoomAfterShot = false;
}
else
{
ZoomOut();
}
m_flUnzoomTime = -1;
}
if ( m_flRezoomTime > 0 )
{
if ( gpGlobals->curtime > m_flRezoomTime )
{
ZoomIn();
m_flRezoomTime = -1;
}
}
if ( ( pPlayer->m_nButtons & IN_ATTACK2 ) && ( m_flNextSecondaryAttack <= gpGlobals->curtime ) )
{
// If we're in the process of rezooming, just cancel it
if ( m_flRezoomTime > 0 || m_flUnzoomTime > 0 )
{
// Prevent them from rezooming in less time than they would have
m_flNextSecondaryAttack = m_flRezoomTime + TF_WEAPON_SNIPERRIFLE_ZOOM_TIME;
m_flRezoomTime = -1;
}
else
{
Zoom();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ItemPostFrame( void )
{
// If we're lowered, we're not allowed to fire
if ( m_bLowered )
return;
// Get the owning player.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return;
if ( !CanAttack() )
{
if ( IsZoomed() )
{
ToggleZoom();
}
return;
}
HandleZooms();
#ifdef GAME_DLL
// Update the sniper dot position if we have one
if ( m_hSniperDot )
{
UpdateSniperDot();
}
#endif
// Start charging when we're zoomed in, and allowed to fire
if ( pPlayer->m_Shared.IsJumping() )
{
// Unzoom if we're jumping
if ( IsZoomed() )
{
ToggleZoom();
}
m_flChargedDamage = 0.0f;
m_bRezoomAfterShot = false;
m_flRezoomTime = -1.f;
}
else if ( m_flNextSecondaryAttack <= gpGlobals->curtime )
{
// Don't start charging in the time just after a shot before we unzoom to play rack anim.
if ( pPlayer->m_Shared.InCond( TF_COND_AIMING ) && !m_bRezoomAfterShot )
{
float fSniperRifleChargePerSec = m_flChargePerSec;
ApplyChargeSpeedModifications( fSniperRifleChargePerSec );
fSniperRifleChargePerSec += SniperRifleChargeRateMod();
// we don't want sniper charge rate to go too high.
fSniperRifleChargePerSec = clamp( fSniperRifleChargePerSec, 0, 2.f * TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC );
m_flChargedDamage = MIN( m_flChargedDamage + gpGlobals->frametime * fSniperRifleChargePerSec, TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX );
#ifdef CLIENT_DLL
// play the recharged bell if we're fully charged
if ( IsFullyCharged() && !m_bPlayedBell )
{
m_bPlayedBell = true;
if ( tf_sniper_fullcharge_bell.GetBool() )
{
C_TFPlayer::GetLocalTFPlayer()->EmitSound( "TFPlayer.ReCharged" );
}
}
#endif
}
else
{
m_flChargedDamage = MAX( 0, m_flChargedDamage - gpGlobals->frametime * TF_WEAPON_SNIPERRIFLE_UNCHARGE_PER_SEC );
}
}
// Fire.
if ( pPlayer->m_nButtons & IN_ATTACK )
{
Fire( pPlayer );
}
// Idle.
if ( !( ( pPlayer->m_nButtons & IN_ATTACK) || ( pPlayer->m_nButtons & IN_ATTACK2 ) ) )
{
// No fire buttons down or reloading
if ( !ReloadOrSwitchWeapons() && ( m_bInReload == false ) )
{
WeaponIdle();
}
}
// Sniper Rage (Hitman's heatmaker)
// Activate on 'R'
// no longer need full charge
if ( (pPlayer->m_nButtons & IN_RELOAD ) && pPlayer->m_Shared.GetRageMeter() > 1.0f )
{
int iBuffType = 0;
CALL_ATTRIB_HOOK_INT( iBuffType, set_buff_type );
if ( iBuffType > 0 )
{
pPlayer->m_Shared.ActivateRageBuff( pPlayer, iBuffType );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::PlayWeaponShootSound( void )
{
if ( TFGameRules()->GameModeUsesUpgrades() )
{
PlayUpgradedShootSound( "Weapon_Upgrade.DamageBonus" );
}
if ( !IsFullyCharged() )
{
float flDamageBonus = 1.0f;
CALL_ATTRIB_HOOK_FLOAT( flDamageBonus, sniper_full_charge_damage_bonus );
if ( flDamageBonus > 1.0f )
{
WeaponSound( SPECIAL3 );
return;
}
}
BaseClass::PlayWeaponShootSound();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::Lower( void )
{
if ( BaseClass::Lower() )
{
if ( IsZoomed() )
{
ToggleZoom();
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Secondary attack.
//-----------------------------------------------------------------------------
void CTFSniperRifle::Zoom( void )
{
// Don't allow the player to zoom in while jumping
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && pPlayer->m_Shared.IsJumping() )
{
if ( pPlayer->GetFOV() >= 75 )
return;
}
ToggleZoom();
// at least 0.1 seconds from now, but don't stomp a previous value
m_flNextPrimaryAttack = MAX( m_flNextPrimaryAttack, gpGlobals->curtime + 0.1 );
m_flNextSecondaryAttack = gpGlobals->curtime + TF_WEAPON_SNIPERRIFLE_ZOOM_TIME;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ZoomOutIn( void )
{
ZoomOut();
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && pPlayer->ShouldAutoRezoom() )
{
float flRezoomDelay = 0.9f;
if ( !UsesClipsForAmmo1() )
{
// Since sniper rifles don't actually use clips the fast reload hook also affects unzoom and zoom delays
ApplyScopeSpeedModifications( flRezoomDelay );
}
m_flRezoomTime = gpGlobals->curtime + flRezoomDelay;
}
else
{
m_flNextSecondaryAttack = gpGlobals->curtime + 1.0f;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ZoomIn( void )
{
// Start aiming.
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
return;
BaseClass::ZoomIn();
pPlayer->m_Shared.AddCond( TF_COND_AIMING );
pPlayer->TeamFortress_SetSpeed();
#ifdef GAME_DLL
// Create the sniper dot.
CreateSniperDot();
pPlayer->ClearExpression();
#endif
}
//-----------------------------------------------------------------------------
bool CTFSniperRifle::IsZoomed( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer )
{
return pPlayer->m_Shared.InCond( TF_COND_ZOOMED );
}
return false;
}
//-----------------------------------------------------------------------------
//
// Have we been zoomed in long enough for our shot to do max damage
//
bool CTFSniperRifle::IsFullyCharged( void ) const
{
return m_flChargedDamage >= TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ZoomOut( void )
{
BaseClass::ZoomOut();
// Stop aiming
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
pPlayer->m_Shared.RemoveCond( TF_COND_AIMING );
pPlayer->TeamFortress_SetSpeed();
#ifdef GAME_DLL
// Destroy the sniper dot.
DestroySniperDot();
pPlayer->ClearExpression();
#endif
// if we are thinking about zooming, cancel it
m_flUnzoomTime = -1;
m_flRezoomTime = -1;
m_bRezoomAfterShot = false;
m_flChargedDamage = 0.0f;
#ifdef CLIENT_DLL
m_bPlayedBell = false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ApplyScopeSpeedModifications( float &flBaseRef )
{
CALL_ATTRIB_HOOK_FLOAT( flBaseRef, fast_reload );
// Prototype hack
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer )
{
if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_HASTE || pPlayer->m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
{
flBaseRef *= 0.5f;
}
else if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_KING || pPlayer->m_Shared.InCond( TF_COND_KING_BUFFED ) )
{
flBaseRef *= 0.75f;
}
int iMaster = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iMaster, ability_master_sniper );
if ( iMaster )
{
flBaseRef *= RemapValClamped( iMaster, 1, 2, 0.6f, 0.3f );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ApplyChargeSpeedModifications( float &flBaseRef )
{
CALL_ATTRIB_HOOK_FLOAT( flBaseRef, mult_sniper_charge_per_sec );
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer )
{
Vector vForward;
AngleVectors( pPlayer->EyeAngles() + pPlayer->GetPunchAngle(), &vForward );
Vector vShootPos = pPlayer->Weapon_ShootPosition();
trace_t tr;
UTIL_TraceLine( vShootPos, vShootPos + vForward * m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flRange, MASK_BLOCKLOS_AND_NPCS, pPlayer, COLLISION_GROUP_NONE, &tr );
CTFPlayer *pTarget = ToTFPlayer( tr.m_pEnt );
if ( pTarget && pTarget->IsAlive() && pTarget->GetTeamNumber() != pPlayer->GetTeamNumber() &&
!( pTarget->m_Shared.IsStealthed() && !pTarget->m_Shared.InCond( TF_COND_STEALTHED_BLINK ) ) )
{
CALL_ATTRIB_HOOK_FLOAT( flBaseRef, mult_sniper_charge_per_sec_with_enemy_under_crosshair );
int nBeep = 0;
CALL_ATTRIB_HOOK_FLOAT( nBeep, sniper_beep_with_enemy_under_crosshair );
if ( nBeep > 0 && !m_bWasAimedAtEnemy )
{
pPlayer->EmitSound( "doomsday.warhead" );
}
m_bWasAimedAtEnemy = true;
}
else
{
m_bWasAimedAtEnemy = false;
}
if ( pPlayer && ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_PRECISION || pPlayer->m_Shared.GetCarryingRuneType() == RUNE_HASTE ) )
{
flBaseRef *= 3.0f;
}
else if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_KING || pPlayer->m_Shared.InCond( TF_COND_KING_BUFFED ) )
{
flBaseRef *= 1.5f;
}
// Prototype hack
int iMaster = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iMaster, ability_master_sniper );
if ( iMaster )
{
flBaseRef *= RemapValClamped( iMaster, 1, 2, 1.5f, 3.f );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::MustBeZoomedToFire( void )
{
int iModOnlyFireZoomed = 0;
CALL_ATTRIB_HOOK_INT( iModOnlyFireZoomed, sniper_only_fire_zoomed );
return ( iModOnlyFireZoomed != 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::HandleNoScopeFireDeny( void )
{
if ( m_flNextEmptySoundTime < gpGlobals->curtime )
{
WeaponSound( SPECIAL2 );
#ifdef CLIENT_DLL
ParticleProp()->Init( this );
ParticleProp()->Create( "dxhr_sniper_fizzle", PATTACH_POINT_FOLLOW, "muzzle" );
#endif
m_flNextEmptySoundTime = gpGlobals->curtime + 0.5;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ETFDmgCustom CTFSniperRifle::GetPenetrateType() const
{
if ( IsFullyCharged() )
{
int iPenetrate = 0;
CALL_ATTRIB_HOOK_INT( iPenetrate, sniper_penetrate_players_when_charged );
if ( iPenetrate > 0 )
return TF_DMG_CUSTOM_PENETRATE_ALL_PLAYERS;
}
return BaseClass::GetPenetrateType();
}
#ifdef SIXENSE
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFSniperRifle::GetRezoomTime() const
{
return m_flRezoomTime;
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::Fire( CTFPlayer *pPlayer )
{
// Check the ammo. We don't use clip ammo, check the primary ammo type.
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
{
HandleFireOnEmpty();
return;
}
// Some weapons can only fire while zoomed
if ( MustBeZoomedToFire() )
{
if ( !IsZoomed() )
{
HandleNoScopeFireDeny();
return;
}
}
if ( m_flNextPrimaryAttack > gpGlobals->curtime )
return;
// Fire the sniper shot.
PrimaryAttack();
if ( IsZoomed() )
{
// If we have more bullets, zoom out, play the bolt animation and zoom back in
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
{
// do not zoom out if we're under rage or about to enter it
if ( !( pPlayer->m_Shared.InCond( TF_COND_SNIPERCHARGE_RAGE_BUFF ) ) )
{
float flUnzoomDelay = 0.5f;
if ( !UsesClipsForAmmo1() )
{
// Since sniper rifles don't actually use clips the fast reload hook also affects unzoom and zoom delays
ApplyScopeSpeedModifications( flUnzoomDelay );
}
SetRezoom( true, flUnzoomDelay ); // zoom out in 0.5 seconds, then rezoom
}
}
else
{
//just zoom out
SetRezoom( false, 0.5f ); // just zoom out in 0.5 seconds
}
}
else
{
float flZoomDelay = SequenceDuration();
// Since sniper rifles don't actually use clips the fast reload hook also affects zoom delays
ApplyScopeSpeedModifications( flZoomDelay );
// Prevent primary fire preventing zooms
m_flNextSecondaryAttack = gpGlobals->curtime + flZoomDelay;
}
m_flChargedDamage = 0.0f;
#ifdef GAME_DLL
if ( m_hSniperDot )
{
m_hSniperDot->ResetChargeTime();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::SetRezoom( bool bRezoom, float flDelay )
{
m_flUnzoomTime = gpGlobals->curtime + flDelay;
m_bRezoomAfterShot = bRezoom;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CTFSniperRifle::GetProjectileDamage( void )
{
float flDamage = MAX( m_flChargedDamage, TF_WEAPON_SNIPERRIFLE_DAMAGE_MIN );
float flDamageMod = 1.f;
CALL_ATTRIB_HOOK_FLOAT( flDamageMod, mult_dmg );
flDamage *= flDamageMod;
if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer && pPlayer->m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
{
flDamage *= 2.f;
}
}
if ( IsFullyCharged() )
{
CALL_ATTRIB_HOOK_FLOAT( flDamage, sniper_full_charge_damage_bonus );
}
return flDamage;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFSniperRifle::GetDamageType( void ) const
{
// Only do hit location damage if we're zoomed
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
return BaseClass::GetDamageType();
int nDamageType = BaseClass::GetDamageType() & ~DMG_USE_HITLOCATIONS;
return nDamageType;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::CreateSniperDot( void )
{
// Server specific.
#ifdef GAME_DLL
// Check to see if we have already been created?
if ( m_hSniperDot )
return;
// Get the owning player (make sure we have one).
CBaseCombatCharacter *pPlayer = GetOwner();
if ( !pPlayer )
return;
// Create the sniper dot, but do not make it visible yet.
m_hSniperDot = CSniperDot::Create( GetAbsOrigin(), pPlayer, true );
m_hSniperDot->ChangeTeam( pPlayer->GetTeamNumber() );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::DestroySniperDot( void )
{
// Server specific.
#ifdef GAME_DLL
// Destroy the sniper dot.
if ( m_hSniperDot )
{
UTIL_Remove( m_hSniperDot );
m_hSniperDot = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::UpdateSniperDot( void )
{
// Server specific.
#ifdef GAME_DLL
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
return;
// Get the start and endpoints.
Vector vecMuzzlePos = pPlayer->Weapon_ShootPosition();
Vector forward;
pPlayer->EyeVectors( &forward );
Vector vecEndPos = vecMuzzlePos + ( forward * MAX_TRACE_LENGTH );
trace_t trace;
UTIL_TraceLine( vecMuzzlePos, vecEndPos, ( MASK_SHOT & ~CONTENTS_WINDOW ), GetOwner(), COLLISION_GROUP_NONE, &trace );
// Update the sniper dot.
if ( m_hSniperDot )
{
CBaseEntity *pEntity = NULL;
if ( trace.DidHitNonWorldEntity() )
{
pEntity = trace.m_pEnt;
if ( !pEntity || !pEntity->m_takedamage )
{
pEntity = NULL;
}
}
m_hSniperDot->Update( pEntity, trace.endpos, trace.plane.normal );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::CanFireCriticalShot( bool bIsHeadshot )
{
m_bCurrentAttackIsCrit = false;
m_bCurrentShotIsHeadshot = false;
if ( !BaseClass::CanFireCriticalShot( bIsHeadshot ) )
return false;
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && pPlayer->m_Shared.IsCritBoosted() )
{
m_bCurrentShotIsHeadshot = bIsHeadshot;
return true;
}
// If we don't auto crit on a headshot, use standard criteria to determine other crits.
if ( GetRifleType() == RIFLE_JARATE )
{
return false; // Never auto crit on headshot.
}
// can only fire a crit shot if this is a headshot, unless we're critboosted
if ( !bIsHeadshot )
return false;
int iFullChargeHeadShotPenalty = 0;
CALL_ATTRIB_HOOK_INT( iFullChargeHeadShotPenalty, sniper_no_headshot_without_full_charge );
if ( iFullChargeHeadShotPenalty != 0 )
{
if ( !IsFullyCharged() )
return false;
}
int iCanCritNoScope = 0;
CALL_ATTRIB_HOOK_INT( iCanCritNoScope, sniper_crit_no_scope );
if ( iCanCritNoScope == 0 )
{
if ( pPlayer )
{
// no crits if they're not zoomed
if ( pPlayer->GetFOV() >= pPlayer->GetDefaultFOV() )
{
return false;
}
// no crits for 0.2 seconds after starting to zoom
if ( ( gpGlobals->curtime - pPlayer->GetFOVTime() ) < TF_WEAPON_SNIPERRIFLE_NO_CRIT_AFTER_ZOOM_TIME )
{
return false;
}
}
}
m_bCurrentAttackIsCrit = true;
m_bCurrentShotIsHeadshot = bIsHeadshot;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Our owner was stunned.
//-----------------------------------------------------------------------------
void CTFSniperRifle::OnControlStunned( void )
{
BaseClass::OnControlStunned();
ZoomOut();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFSniperRifle::GetCustomDamageType() const
{
if ( IsJarateRifle() )
{
return TF_DMG_CUSTOM_PENETRATE_NONBURNING_TEAMMATE;
}
return TF_DMG_CUSTOM_PENETRATE_MY_TEAM;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::Detach( void )
{
if ( IsZoomed() )
{
ToggleZoom();
}
BaseClass::Detach();
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::OnPlayerKill( CTFPlayer *pVictim, const CTakeDamageInfo &info )
{
BaseClass::OnPlayerKill( pVictim, info );
if ( m_iConsecutiveKills == 3 )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer )
{
pPlayer->AwardAchievement( ACHIEVEMENT_TF_SNIPER_RIFLE_NO_MISSING );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::OnBulletFire( int iEnemyPlayersHit )
{
BaseClass::OnBulletFire( iEnemyPlayersHit );
// Did we completely miss?
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if( iEnemyPlayersHit == 0 && pPlayer && pPlayer->m_Shared.InCond( TF_COND_AIMING ) )
{
EconEntity_OnOwnerKillEaterEventNoPartner( assert_cast<CEconEntity *>( this ), pPlayer, kKillEaterEvent_NEGATIVE_SniperShotsMissed );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifle::ExplosiveHeadShot( CTFPlayer *pAttacker, CTFPlayer *pVictim )
{
if ( !pAttacker )
return;
if ( !pVictim )
return;
int iExplosiveShot = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER ( pAttacker, iExplosiveShot, explosive_sniper_shot );
// Stun the source
float flStunDuration = 1.f + ( ( (float)iExplosiveShot - 1.f ) * 0.5f );
float flStunAmt = pVictim->IsMiniBoss() ? 0.5f : RemapValClamped( iExplosiveShot, 1, 3, 0.5f, 0.8f );
pVictim->m_Shared.StunPlayer( flStunDuration, flStunAmt, TF_STUN_MOVEMENT, pAttacker );
// Generate an explosion and look for nearby bots
float flDmgRange = 125.f + iExplosiveShot * 25.f;
float flDmg = 130.f + iExplosiveShot * 20.f;
CBaseEntity *pObjects[ 32 ];
int nCount = UTIL_EntitiesInSphere( pObjects, ARRAYSIZE( pObjects ), pVictim->GetAbsOrigin(), flDmgRange, FL_CLIENT );
for ( int i = 0; i < nCount; i++ )
{
if ( !pObjects[i] )
continue;
if ( !pObjects[i]->IsAlive() )
continue;
if ( pObjects[i] == pVictim )
continue;
if ( pAttacker->InSameTeam( pObjects[i] ) )
continue;
if ( !pVictim->FVisible( pObjects[i], MASK_OPAQUE ) )
continue;
CTFPlayer *pTFPlayer = static_cast<CTFPlayer *>( pObjects[i] );
if ( !pTFPlayer )
continue;
if ( pTFPlayer->m_Shared.InCond( TF_COND_PHASE ) || pTFPlayer->m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
continue;
if ( pTFPlayer->m_Shared.IsInvulnerable() )
continue;
// Stun
flStunAmt = pTFPlayer->IsMiniBoss() ? 0.5f : RemapValClamped( iExplosiveShot, 1, 3, 0.5f, 0.8f );
pTFPlayer->m_Shared.StunPlayer( flStunDuration, flStunAmt, TF_STUN_MOVEMENT, pAttacker );
// DoT
pTFPlayer->m_Shared.MakeBleed( pAttacker, this, 0.1f, flDmg );
// Shoot a beam at them
CPVSFilter filter( pTFPlayer->WorldSpaceCenter() );
Vector vStart = pVictim->EyePosition();
Vector vEnd = pTFPlayer->EyePosition();
te_tf_particle_effects_control_point_t controlPoint = { PATTACH_ABSORIGIN, vEnd };
TE_TFParticleEffectComplex( filter, 0.0f, "dxhr_arm_muzzleflash", vStart, QAngle( 0, 0, 0 ), NULL, &controlPoint, pTFPlayer, PATTACH_CUSTOMORIGIN );
pTFPlayer->EmitSound( "Weapon_Upgrade.ExplosiveHeadshot" );
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::IsJarateRifle( void ) const
{
return GetJarateTimeInternal() > 0.f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFSniperRifle::GetJarateTime( void ) const
{
if ( m_flChargedDamage > 0.f )
{
return GetJarateTimeInternal();
}
else
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFSniperRifle::GetJarateTimeInternal( void ) const
{
float flMaxJarateTime = 0.0f;
CALL_ATTRIB_HOOK_FLOAT( flMaxJarateTime, jarate_duration );
if ( flMaxJarateTime > 0 )
{
const float flMinJarateTime = 2.f;
float flDuration = RemapValClamped( m_flChargedDamage, TF_WEAPON_SNIPERRIFLE_DAMAGE_MIN, TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX, flMinJarateTime, flMaxJarateTime );
return flDuration;
}
return 0.f;
}
//-----------------------------------------------------------------------------
// Purpose: UI Progress (same as GetProgress() without the division by 100.0f)
//-----------------------------------------------------------------------------
bool CTFSniperRifle::IsRageFull( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
{
return false;
}
return ( pPlayer->m_Shared.GetRageMeter() >= 100.0f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::EffectMeterShouldFlash( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
{
return false;
}
if ( pPlayer && ( IsRageFull() || pPlayer->m_Shared.IsRageDraining() ) )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: UI Progress
//-----------------------------------------------------------------------------
float CTFSniperRifle::GetProgress( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
{
return 0.f;
}
return pPlayer->m_Shared.GetRageMeter() / 100.0f;
}
//=============================================================================
//
// Client specific functions.
//
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifle::ShouldEjectBrass()
{
if ( GetJarateTimeInternal() > 0.f )
return false;
else
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFSniperRifle::GetHUDDamagePerc( void )
{
return (m_flChargedDamage / TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX);
}
//-----------------------------------------------------------------------------
// Returns the sniper chargeup from 0 to 1
//-----------------------------------------------------------------------------
class CProxySniperRifleCharge : public CResultProxy
{
public:
void OnBind( void *pC_BaseEntity );
};
void CProxySniperRifleCharge::OnBind( void *pC_BaseEntity )
{
Assert( m_pResult );
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( GetSpectatorTarget() != 0 && GetSpectatorMode() == OBS_MODE_IN_EYE )
{
pPlayer = (C_TFPlayer *)UTIL_PlayerByIndex( GetSpectatorTarget() );
}
if ( pPlayer )
{
CTFSniperRifle *pWeapon = assert_cast<CTFSniperRifle*>(pPlayer->GetActiveTFWeapon());
if ( pWeapon )
{
float flChargeValue = ( ( 1.0 - pWeapon->GetHUDDamagePerc() ) * 0.8 ) + 0.6;
VMatrix mat, temp;
Vector2D center( 0.5, 0.5 );
MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
// scale
{
Vector2D scale( 1.0f, 0.25f );
MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
MatrixMultiply( temp, mat, mat );
}
MatrixBuildTranslation( temp, center.x, center.y, 0.0f );
MatrixMultiply( temp, mat, mat );
// translation
{
Vector2D translation( 0.0f, flChargeValue );
MatrixBuildTranslation( temp, translation.x, translation.y, 0.0f );
MatrixMultiply( temp, mat, mat );
}
m_pResult->SetMatrixValue( mat );
}
}
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
EXPOSE_INTERFACE( CProxySniperRifleCharge, IMaterialProxy, "SniperRifleCharge" IMATERIAL_PROXY_INTERFACE_VERSION );
#endif
//=============================================================================
//
// Laser Dot functions.
//
IMPLEMENT_NETWORKCLASS_ALIASED( SniperDot, DT_SniperDot )
BEGIN_NETWORK_TABLE( CSniperDot, DT_SniperDot )
#ifdef CLIENT_DLL
RecvPropFloat( RECVINFO( m_flChargeStartTime ) ),
#else
SendPropTime( SENDINFO( m_flChargeStartTime ) ),
#endif
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( env_sniperdot, CSniperDot );
BEGIN_DATADESC( CSniperDot )
DEFINE_FIELD( m_vecSurfaceNormal, FIELD_VECTOR ),
DEFINE_FIELD( m_hTargetEnt, FIELD_EHANDLE ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
CSniperDot::CSniperDot( void )
{
m_vecSurfaceNormal.Init();
m_hTargetEnt = NULL;
#ifdef CLIENT_DLL
m_hSpriteMaterial = NULL;
m_laserBeamEffect = NULL;
#endif
ResetChargeTime();
}
//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
CSniperDot::~CSniperDot( void )
{
#ifdef CLIENT_DLL
if ( m_laserBeamEffect )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_laserBeamEffect );
m_laserBeamEffect = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &origin -
// Output : CSniperDot
//-----------------------------------------------------------------------------
CSniperDot *CSniperDot::Create( const Vector &origin, CBaseEntity *pOwner, bool bVisibleDot )
{
// Client specific.
#ifdef CLIENT_DLL
return NULL;
// Server specific.
#else
// Create the sniper dot entity.
CSniperDot *pDot = static_cast<CSniperDot*>( CBaseEntity::Create( "env_sniperdot", origin, QAngle( 0.0f, 0.0f, 0.0f ) ) );
if ( !pDot )
return NULL;
//Create the graphic
pDot->SetMoveType( MOVETYPE_NONE );
pDot->AddSolidFlags( FSOLID_NOT_SOLID );
pDot->AddEffects( EF_NOSHADOW );
UTIL_SetSize( pDot, -Vector( 4.0f, 4.0f, 4.0f ), Vector( 4.0f, 4.0f, 4.0f ) );
// Set owner.
pDot->SetOwnerEntity( pOwner );
// Force updates even though we don't have a model.
pDot->AddEFlags( EFL_FORCE_CHECK_TRANSMIT );
return pDot;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSniperDot::Update( CBaseEntity *pTarget, const Vector &vecOrigin, const Vector &vecNormal )
{
SetAbsOrigin( vecOrigin );
m_vecSurfaceNormal = vecNormal;
m_hTargetEnt = pTarget;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Vector CSniperDot::GetChasePosition()
{
return GetAbsOrigin() - m_vecSurfaceNormal * 10;
}
//=============================================================================
//
// Client specific functions.
//
#ifdef CLIENT_DLL
bool CSniperDot::GetRenderingPositions( C_TFPlayer *pPlayer, Vector &vecAttachment, Vector &vecEndPos, float &flSize )
{
if ( !pPlayer )
return false;
// Get the sprite rendering position.
flSize = 6.0;
bool bScaleSizeByDistance = false;
const float c_fMaxSizeDistVR = 384.0f;
const float c_flMaxSizeDistUnzoomed = 200.0f;
if ( !pPlayer->IsDormant() )
{
Vector vecDir;
QAngle angles;
float flDist = MAX_TRACE_LENGTH;
// Always draw the dot in front of our faces when in first-person.
if ( pPlayer->IsLocalPlayer() )
{
// Take our view position and orientation
vecAttachment = CurrentViewOrigin();
vecDir = CurrentViewForward();
// Clamp the forward distance for the sniper's firstperson
flDist = c_fMaxSizeDistVR;
flSize = 2.0;
// Make the dot bigger when charging and not zoomed in (The Classic)
if ( pPlayer->m_Shared.InCond( TF_COND_AIMING ) && !pPlayer->m_Shared.InCond( TF_COND_ZOOMED ))
{
flSize = 4.0f;
bScaleSizeByDistance = true;
}
if ( UseVR() )
{
// The view direction is not exactly the same as the weapon direction because of stereo, calibration, etc.
g_ClientVirtualReality.OverrideWeaponHudAimVectors ( &vecAttachment, &vecDir );
// No clamping, thanks - we need the distance to be correct so that
// vergence works properly, and we'll scale the size up accordingly.
flDist = MAX_TRACE_LENGTH;
bScaleSizeByDistance = true;
}
}
else
{
// Take the owning player eye position and direction.
vecAttachment = pPlayer->EyePosition();
QAngle anglesEye = pPlayer->EyeAngles();
AngleVectors( anglesEye, &vecDir );
}
trace_t tr;
CTraceFilterIgnoreFriendlyCombatItems filter( pPlayer, COLLISION_GROUP_NONE, pPlayer->GetTeamNumber() );
UTIL_TraceLine( vecAttachment, vecAttachment + ( vecDir * flDist ), MASK_SHOT, &filter, &tr );
// Backup off the hit plane, towards the source
vecEndPos = tr.endpos + vecDir * -4;
if ( UseVR() )
{
float fDist = ( vecEndPos - vecAttachment ).Length();
if ( fDist > c_fMaxSizeDistVR )
{
// Scale the dot up so it's still visible in first person.
flSize *= ( fDist * ( 1.0f / c_fMaxSizeDistVR ) );
}
}
else if ( bScaleSizeByDistance )
{
float fDist = ( vecEndPos - vecAttachment ).Length();
if ( fDist > c_flMaxSizeDistUnzoomed )
{
// Scale the dot up so it's still visible in first person.
flSize *= ( fDist * ( 1.0f / c_flMaxSizeDistUnzoomed ) );
}
}
}
else
{
// Just use our position if we can't predict it otherwise.
vecAttachment = GetAbsOrigin();
vecEndPos = GetAbsOrigin();
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// TFTODO: Make the sniper dot get brighter the more damage it will do.
//-----------------------------------------------------------------------------
int CSniperDot::DrawModel( int flags )
{
// Get the owning player.
C_TFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( !pPlayer )
return -1;
Vector vecAttachement;
Vector vecEndPos;
float flSize;
if ( !GetRenderingPositions( pPlayer, vecAttachement, vecEndPos, flSize ) )
{
return -1;
}
// Draw our laser dot in space.
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( m_hSpriteMaterial, this );
CTFWeaponBase *pBaseWeapon = pPlayer->GetActiveTFWeapon();
CTFSniperRifle *pWeapon = dynamic_cast< CTFSniperRifle* >( pBaseWeapon );
float flLifeTime = gpGlobals->curtime - m_flChargeStartTime;
float flChargePerSec = TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC;
if ( pWeapon )
{
pWeapon->ApplyChargeSpeedModifications( flChargePerSec );
}
// Sniper Rage
if ( pPlayer->m_Shared.InCond( TF_COND_SNIPERCHARGE_RAGE_BUFF ) )
{
flChargePerSec *= 1.25f;
}
float flStrength;
if ( pWeapon )
{
flStrength = pWeapon->GetHUDDamagePerc();
// FIXME: We should find out what's causing this and fix it.
AssertMsg1( flStrength >= ( 0.0f - FLT_EPSILON ) && flStrength <= ( 1.0f + FLT_EPSILON ), "GetHUDDamagePerc returned out of range value: %f", flStrength );
flStrength = clamp( flStrength, 0.1f, 1.0f );
}
else
{
flStrength = RemapValClamped( flLifeTime, 0.0, TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX / flChargePerSec, 0.1f, 1.0f );
}
color32 innercolor = { 255, 255, 255, 255 };
color32 outercolor = { 255, 255, 255, 128 };
DrawSprite( vecEndPos, flSize, flSize, outercolor );
DrawSprite( vecEndPos, flSize * flStrength, flSize * flStrength, innercolor );
// Successful.
return 1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CSniperDot::ShouldDraw( void )
{
if ( IsEffectActive( EF_NODRAW ) )
return false;
// Don't draw the sniper dot when in thirdperson.
if ( ::input->CAM_IsThirdPerson() )
return false;
return true;
}
void CSniperDot::ClientThink( void )
{
// snipers have laser sights in PvE mode
if ( TFGameRules()->IsPVEModeActive() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
{
C_TFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer )
{
if ( !m_laserBeamEffect )
{
m_laserBeamEffect = ParticleProp()->Create( "laser_sight_beam", PATTACH_ABSORIGIN_FOLLOW );
}
if ( m_laserBeamEffect )
{
m_laserBeamEffect->SetSortOrigin( m_laserBeamEffect->GetRenderOrigin() );
m_laserBeamEffect->SetControlPoint( 2, Vector( 0, 0, 255 ) );
Vector vecAttachment;
Vector vecEndPos;
float flSize;
if ( pPlayer->GetAttachment( "eye_1", vecAttachment ) )
{
m_laserBeamEffect->SetControlPoint( 1, vecAttachment );
}
else if ( GetRenderingPositions( pPlayer, vecAttachment, vecEndPos, flSize ) )
{
m_laserBeamEffect->SetControlPoint( 1, vecAttachment );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSniperDot::OnDataChanged( DataUpdateType_t updateType )
{
if ( updateType == DATA_UPDATE_CREATED )
{
if ( GetTeamNumber() == TF_TEAM_BLUE )
{
m_hSpriteMaterial.Init( SNIPER_DOT_SPRITE_BLUE, TEXTURE_GROUP_CLIENT_EFFECTS );
}
else
{
m_hSpriteMaterial.Init( SNIPER_DOT_SPRITE_RED, TEXTURE_GROUP_CLIENT_EFFECTS );
}
SetNextClientThink( CLIENT_THINK_ALWAYS );
}
}
#endif // CLIENT_DLL
#ifdef GAME_DLL
void CTFSniperRifleDecap::OnPlayerKill( CTFPlayer *pVictim, const CTakeDamageInfo &info )
{
BaseClass::OnPlayerKill( pVictim, info );
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer && IsHeadshot( info.GetDamageCustom() ) )
{
// If we got a headshot kill, increment our number of decapitations.
int iDecaps = pPlayer->m_Shared.GetDecapitations() + 1;
pPlayer->m_Shared.SetDecapitations( iDecaps );
}
}
#endif // GAME_DLL
static const int MAX_HEAD_BONUS = 6;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFSniperRifleDecap::SniperRifleChargeRateMod()
{
return ( .25f * ( MIN( GetCount(), MAX_HEAD_BONUS ) - 2 ) ) * TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFSniperRifleDecap::GetCount( void )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer )
{
return pPlayer->m_Shared.GetDecapitations();
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
CTFSniperRifleClassic::CTFSniperRifleClassic()
{
m_bCharging = false;
#ifdef CLIENT_DLL
m_pChargedEffect = NULL;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
CTFSniperRifleClassic::~CTFSniperRifleClassic()
{
#ifdef CLIENT_DLL
if ( m_pChargedEffect )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_pChargedEffect );
m_pChargedEffect = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::Precache()
{
BaseClass::Precache();
PrecacheParticleSystem( SNIPER_CHARGE_BEAM_RED );
PrecacheParticleSystem( SNIPER_CHARGE_BEAM_BLUE );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::ZoomOut( void )
{
CTFWeaponBaseGun::ZoomOut(); // intentionally skipping CTFSniperRifle::ZoomOut()
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::ZoomIn( void )
{
// Start aiming.
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
return;
CTFWeaponBaseGun::ZoomIn(); // intentionally skipping CTFSniperRifle::ZoomIn()
}
//-----------------------------------------------------------------------------
// Purpose: Secondary attack.
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::Zoom( void )
{
ToggleZoom();
// at least 0.1 seconds from now, but don't stomp a previous value
m_flNextSecondaryAttack = gpGlobals->curtime + TF_WEAPON_SNIPERRIFLE_ZOOM_TIME;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::HandleZooms( void )
{
// Get the owning player.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return;
// Handle the zoom when taunting.
if ( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
{
if ( IsZoomed() )
{
ToggleZoom();
return;
}
}
if ( ( pPlayer->m_nButtons & IN_ATTACK2 ) && ( m_flNextSecondaryAttack <= gpGlobals->curtime ) )
{
Zoom();
}
}
#ifdef CLIENT_DLL
void CTFSniperRifleClassic::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged( updateType );
ManageChargeBeam();
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::ItemPostFrame( void )
{
// If we're lowered, we're not allowed to fire
if ( m_bLowered )
return;
// Get the owning player.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return;
if ( !CanAttack() )
{
if ( IsZoomed() )
{
ToggleZoom();
}
WeaponReset();
return;
}
HandleZooms();
#ifdef GAME_DLL
// Update the sniper dot position if we have one
if ( m_hSniperDot )
{
UpdateSniperDot();
}
#endif
if ( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
{
WeaponReset();
return;
}
if ( ( pPlayer->m_nButtons & IN_ATTACK ) && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) )
{
if ( !m_bCharging )
{
pPlayer->m_Shared.AddCond( TF_COND_AIMING );
pPlayer->TeamFortress_SetSpeed();
m_bCharging = true;
#ifdef GAME_DLL
// Create the sniper dot.
CreateSniperDot();
pPlayer->ClearExpression();
#endif
}
float fSniperRifleChargePerSec = m_flChargePerSec;
ApplyChargeSpeedModifications( fSniperRifleChargePerSec );
fSniperRifleChargePerSec += SniperRifleChargeRateMod();
// we don't want sniper charge rate to go too high.
fSniperRifleChargePerSec = clamp( fSniperRifleChargePerSec, 0, 2.f * TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC );
m_flChargedDamage = MIN( m_flChargedDamage + gpGlobals->frametime * fSniperRifleChargePerSec, TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX );
#ifdef CLIENT_DLL
// play the recharged bell if we're fully charged
if ( IsFullyCharged() && !m_bPlayedBell )
{
m_bPlayedBell = true;
if ( tf_sniper_fullcharge_bell.GetBool() )
{
C_TFPlayer::GetLocalTFPlayer()->EmitSound( "TFPlayer.ReCharged" );
}
}
#endif
}
else if ( m_bCharging )
{
if ( pPlayer->GetGroundEntity() )
{
Fire( pPlayer );
}
else
{
pPlayer->EmitSound( "Player.DenyWeaponSelection" );
}
WeaponReset();
}
else
{
// Idle.
// No fire buttons down or reloading
if ( !ReloadOrSwitchWeapons() && ( m_bInReload == false ) )
{
WeaponIdle();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFSniperRifleClassic::GetDamageType( void ) const
{
return CTFWeaponBaseGun::GetDamageType(); // intentionally skipping CTFSniperRifle::GetDamageType()
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifleClassic::Holster( CBaseCombatWeapon *pSwitchingTo )
{
WeaponReset();
return BaseClass::Holster( pSwitchingTo );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifleClassic::Deploy( void )
{
WeaponReset();
return BaseClass::Deploy();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::WeaponReset( void )
{
m_flChargedDamage = 0.0f;
m_bCharging = false;
#ifdef CLIENT_DLL
ManageChargeBeam();
#endif
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer )
{
pPlayer->m_Shared.RemoveCond( TF_COND_AIMING );
pPlayer->TeamFortress_SetSpeed();
}
#ifdef GAME_DLL
// Destroy the sniper dot.
DestroySniperDot();
if ( pPlayer )
{
pPlayer->ClearExpression();
}
#else
m_bPlayedBell = false;
#endif
m_bCurrentShotIsHeadshot = false;
m_flChargePerSec = TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC;
CTFWeaponBase::WeaponReset(); // intentionally skipping CTFSniperRifle::WeaponReset()
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFSniperRifleClassic::Lower( void )
{
if ( BaseClass::Lower() )
{
WeaponReset();
return true;
}
return false;
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::ManageChargeBeam( void )
{
if ( m_bCharging )
{
if ( !m_pChargedEffect )
{
m_pChargedEffect = ParticleProp()->Create( ( GetTeamNumber() == TF_TEAM_RED ) ? SNIPER_CHARGE_BEAM_RED : SNIPER_CHARGE_BEAM_BLUE, PATTACH_POINT_FOLLOW, "laser" );
}
}
else
{
if ( m_pChargedEffect )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_pChargedEffect );
m_pChargedEffect = NULL;
}
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSniperRifleClassic::Detach( void )
{
WeaponReset();
BaseClass::Detach();
}
#ifdef STAGING_ONLY
// ********************************************************************************************************
// CTFSniperRifleRevolver
// ********************************************************************************************************
void CTFSniperRifleRevolver::PrimaryAttack()
{
BaseClass::PrimaryAttack();
#ifdef GAME_DLL
// Head bob
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer /*&& pPlayer->m_Shared.InCond( TF_COND_ZOOMED )*/ )
{
float impulse = RandomFloat( -2.0f, -1.0f );
if ( pPlayer->GetFlags() & FL_DUCKING )
{
impulse = RandomFloat( -0.5f, -0.2f );
}
pPlayer->ApplyPunchImpulseX( impulse );
}
float flCharge = (m_flChargedDamage / TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX);
if ( flCharge > 0.99 )
{
// Only at full charge do you get fast attack speed
// reduce the time between attacks
float flCurrTime = gpGlobals->curtime;
//float flTimeBetweenShots = m_flNextPrimaryAttack - flCurrTime;
//float flTime = RemapVal( flCharge, 0.0, 1, flTimeBetweenShots, 0.2 );
m_flNextPrimaryAttack = flCurrTime + 0.3;
}
#endif
}
//-----------------------------------------------------------------------------
float CTFSniperRifleRevolver::GetProjectileDamage()
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
{
float flCharge = ( m_flChargedDamage / TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX );
if ( flCharge > 0.99 )
{
return 75.0f; // Full Charge dmg bonus is less then the normal one (150)
}
return 50.0f;
}
return 40.0;
}
//-----------------------------------------------------------------------------
bool CTFSniperRifleRevolver::Reload( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return false;
// do not reload if zoomed unless you are empty
if ( m_iClip1 > 0 && pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
return false;
bool bReload = CTFWeaponBaseGun::Reload(); // intentionally skipping CTFSniperRifle::Reload().
if ( bReload && m_iClip1 <= 0 && m_iClip1 != -1 )
{
if ( pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
{
ZoomOut();
m_bRezoomAfterShot = pPlayer->ShouldAutoRezoom();
}
}
return bReload;
}
//-----------------------------------------------------------------------------
void CTFSniperRifleRevolver::ZoomIn( void )
{
// Start aiming.
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( m_iClip1 <= 0 && m_iClip1 != -1 )
return;
pPlayer->m_Shared.AddCond( TF_COND_AIMING );
pPlayer->TeamFortress_SetSpeed();
m_flChargedDamage = 0;
#ifdef GAME_DLL
// Create the sniper dot.
CreateSniperDot();
pPlayer->ClearExpression();
#endif
CTFWeaponBaseGun::ZoomIn(); // intentionally skipping CTFSniperRifle::ZoomIn()
}
//-----------------------------------------------------------------------------
void CTFSniperRifleRevolver::ZoomOut( void )
{
// Start aiming.
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
pPlayer->m_Shared.RemoveCond( TF_COND_AIMING );
pPlayer->TeamFortress_SetSpeed();
m_flChargedDamage = 0;
#ifdef GAME_DLL
// Destroy the sniper dot.
DestroySniperDot();
pPlayer->ClearExpression();
#endif
CTFWeaponBaseGun::ZoomOut(); // intentionally skipping CTFSniperRifle::ZoomOut()
}
//-----------------------------------------------------------------------------
void CTFSniperRifleRevolver::ItemPostFrame( void )
{
// If we're lowered, we're not allowed to fire
if ( m_bLowered )
return;
// Get the owning player.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return;
if ( !CanAttack() )
{
if ( IsZoomed() )
{
ToggleZoom();
}
WeaponReset();
}
if ( m_bRezoomAfterShot && m_iClip1 > 0 )
{
Zoom();
m_bRezoomAfterShot = false;
}
HandleZooms();
#ifdef GAME_DLL
// Update the sniper dot position if we have one
if ( m_hSniperDot )
{
UpdateSniperDot();
}
#endif
if ( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
{
WeaponReset();
return;
}
// Handle Charge Meter
if ( m_flNextSecondaryAttack <= gpGlobals->curtime )
{
// Don't start charging in the time just after a shot before we unzoom to play rack anim.
if ( pPlayer->m_Shared.InCond( TF_COND_AIMING ) && !m_bRezoomAfterShot )
{
float fSniperRifleChargePerSec = m_flChargePerSec;
ApplyChargeSpeedModifications( fSniperRifleChargePerSec );
fSniperRifleChargePerSec += SniperRifleChargeRateMod();
// we don't want sniper charge rate to go too high.
fSniperRifleChargePerSec = clamp( fSniperRifleChargePerSec, 0, 2.f * TF_WEAPON_SNIPERRIFLE_CHARGE_PER_SEC );
m_flChargedDamage = MIN( m_flChargedDamage + gpGlobals->frametime * fSniperRifleChargePerSec, TF_WEAPON_SNIPERRIFLE_DAMAGE_MAX );
#ifdef CLIENT_DLL
// play the recharged bell if we're fully charged
if ( IsFullyCharged() && !m_bPlayedBell )
{
m_bPlayedBell = true;
if ( tf_sniper_fullcharge_bell.GetBool() )
{
C_TFPlayer::GetLocalTFPlayer()->EmitSound( "TFPlayer.ReCharged" );
}
}
#endif
}
else
{
m_flChargedDamage = MAX( 0, m_flChargedDamage - gpGlobals->frametime * TF_WEAPON_SNIPERRIFLE_UNCHARGE_PER_SEC );
}
}
return CTFWeaponBaseGun::ItemPostFrame(); // intentionally skipping CTFSniperRifle::ItemPostFrame(). This should just fire the gun
}
//-----------------------------------------------------------------------------
bool CTFSniperRifleRevolver::CanFireCriticalShot( bool bIsHeadshot )
{
return CTFSniperRifle::CanFireCriticalShot( bIsHeadshot ); // Skip TFC Sniper Rifle
}
//-----------------------------------------------------------------------------
//
ConVar tf_sniper_bolt_speed( "tf_sniper_bolt_speed", "3000", FCVAR_REPLICATED, "Dev Convar - Speed of projectile for Revolver Sniper");
ConVar tf_sniper_bolt_gravity( "tf_sniper_bolt_gravity", "0.1", FCVAR_REPLICATED, "Dev Convar - Gravity of projectile for Revolver Sniper");
float CTFSniperRifleRevolver::GetProjectileSpeed( void )
{
//return 4900.0;
return tf_sniper_bolt_speed.GetFloat();
}
//-----------------------------------------------------------------------------
float CTFSniperRifleRevolver::GetProjectileGravity( void )
{
//return 0.1;
return tf_sniper_bolt_gravity.GetFloat();
}
#endif // STAGING_ONLY