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