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

581 lines
18 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "tf_weapon_shotgun.h"
#include "decals.h"
#include "tf_fx_shared.h"
#include "takedamageinfo.h"
#include "tf_gamerules.h"
// Client specific.
#if defined( CLIENT_DLL )
#include "c_tf_player.h"
// Server specific.
#else
#include "tf_player.h"
#include "ilagcompensationmanager.h"
#include "collisionutils.h"
#include "in_buttons.h"
#endif
//=============================================================================
//
// Weapon Shotgun tables.
//
CREATE_SIMPLE_WEAPON_TABLE( TFShotgun, tf_weapon_shotgun_primary )
CREATE_SIMPLE_WEAPON_TABLE( TFShotgun_Soldier, tf_weapon_shotgun_soldier )
CREATE_SIMPLE_WEAPON_TABLE( TFShotgun_HWG, tf_weapon_shotgun_hwg )
CREATE_SIMPLE_WEAPON_TABLE( TFShotgun_Pyro, tf_weapon_shotgun_pyro )
CREATE_SIMPLE_WEAPON_TABLE( TFScatterGun, tf_weapon_scattergun )
CREATE_SIMPLE_WEAPON_TABLE( TFShotgun_Revenge, tf_weapon_sentry_revenge )
CREATE_SIMPLE_WEAPON_TABLE( TFSodaPopper, tf_weapon_soda_popper )
CREATE_SIMPLE_WEAPON_TABLE( TFPEPBrawlerBlaster, tf_weapon_pep_brawler_blaster )
CREATE_SIMPLE_WEAPON_TABLE( TFShotgunBuildingRescue, tf_weapon_shotgun_building_rescue )
#define SCATTERGUN_KNOCKBACK_MIN_DMG 30.0f
#define SCATTERGUN_KNOCKBACK_MIN_RANGE_SQ 160000.0f //400x400
//=============================================================================
//
// Weapon Shotgun functions.
//
bool CanScatterGunKnockBack( CTFWeaponBase *pWeapon, float flDamage, float flDistanceSq )
{
int nBulletKnockBack = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, nBulletKnockBack, set_scattergun_has_knockback );
if ( nBulletKnockBack != 0 )
{
if (flDamage > SCATTERGUN_KNOCKBACK_MIN_DMG && flDistanceSq < SCATTERGUN_KNOCKBACK_MIN_RANGE_SQ )
return true;
float flKnockbackMult = 1.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flKnockbackMult, scattergun_knockback_mult );
if ( flKnockbackMult > 1.0f )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFShotgun::CTFShotgun()
{
m_bReloadsSingly = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFShotgun::PrimaryAttack()
{
if ( !CanAttack() )
return;
// Set the weapon mode.
m_iWeaponMode = TF_WEAPON_PRIMARY_MODE;
BaseClass::PrimaryAttack();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFShotgun::UpdatePunchAngles( CTFPlayer *pPlayer )
{
// Update the player's punch angle.
QAngle angle = pPlayer->GetPunchAngle();
float flPunchAngle = m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flPunchAngle;
angle.x -= SharedRandomInt( "ShotgunPunchAngle", ( flPunchAngle - 1 ), ( flPunchAngle + 1 ) );
pPlayer->SetPunchAngle( angle );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFShotgun::PlayWeaponShootSound( void )
{
BaseClass::PlayWeaponShootSound();
if ( TFGameRules()->GameModeUsesUpgrades() )
{
PlayUpgradedShootSound( "Weapon_Upgrade.DamageBonus" );
}
}
//-----------------------------------------------------------------------------
// CTFShotgun_Revenge
//-----------------------------------------------------------------------------
CTFShotgun_Revenge::CTFShotgun_Revenge()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFShotgun_Revenge::Precache()
{
int iModelIndex = PrecacheModel( TF_WEAPON_TAUNT_FRONTIER_JUSTICE_GUITAR_MODEL );
PrecacheGibsForModel( iModelIndex );
PrecacheParticleSystem( "blood_impact_backscatter" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFShotgun_Revenge::PrimaryAttack()
{
if ( !CanAttack() )
return;
BaseClass::PrimaryAttack();
// Do this after the attack, so that we know if we are doing custom damage
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( pOwner )
{
int iRevengeCrits = pOwner->m_Shared.GetRevengeCrits();
pOwner->m_Shared.SetRevengeCrits( iRevengeCrits-1 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFShotgun_Revenge::SentryKilled( int iCrits )
{
int val = 0;
CALL_ATTRIB_HOOK_INT( val, sentry_killed_revenge );
if ( val == 1 )
{
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( pOwner )
{
pOwner->m_Shared.SetRevengeCrits( pOwner->m_Shared.GetRevengeCrits() + iCrits );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFShotgun_Revenge::Holster( CBaseCombatWeapon *pSwitchingTo )
{
#ifdef GAME_DLL
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( pOwner && pOwner->m_Shared.GetRevengeCrits() )
{
pOwner->m_Shared.RemoveCond( TF_COND_CRITBOOSTED );
}
#endif
return BaseClass::Holster( pSwitchingTo );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFShotgun_Revenge::Deploy( void )
{
#ifdef GAME_DLL
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( pOwner && pOwner->m_Shared.GetRevengeCrits() )
{
pOwner->m_Shared.AddCond( TF_COND_CRITBOOSTED );
}
#endif
return BaseClass::Deploy();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFShotgun_Revenge::GetCustomDamageType() const
{
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( pOwner )
{
int iRevengeCrits = pOwner->m_Shared.GetRevengeCrits();
return iRevengeCrits > 0 ? TF_DMG_CUSTOM_SHOTGUN_REVENGE_CRIT : TF_DMG_CUSTOM_NONE;
}
return TF_DMG_CUSTOM_NONE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFShotgun_Revenge::GetCount( void )
{
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( pOwner )
{
return pOwner->m_Shared.GetRevengeCrits();
}
return 0;
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
void CTFShotgun_Revenge::SetWeaponVisible( bool visible )
{
if ( !visible )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) && pPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_ENGINEER && pPlayer->m_Shared.GetTauntIndex() == TAUNT_BASE_WEAPON )
{
int nModelIndex = modelinfo->GetModelIndex( TF_WEAPON_TAUNT_FRONTIER_JUSTICE_GUITAR_MODEL );
CUtlVector<breakmodel_t> guitarGibs;
BuildGibList( guitarGibs, nModelIndex, 1.0f, COLLISION_GROUP_NONE );
if ( guitarGibs.Count() > 0 )
{
Vector vForward, vRight, vUp;
AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );
Vector vecBreakVelocity = Vector(0,0,200);
AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
Vector vecOrigin = GetAbsOrigin() + vForward*70 + vUp*10;
QAngle vecAngle = GetAbsAngles();
breakablepropparams_t breakParams( vecOrigin, vecAngle, vecBreakVelocity, angularImpulse );
breakParams.impactEnergyScale = 1.0f;
CreateGibsFromList( guitarGibs, nModelIndex, NULL, breakParams, NULL, -1 , false, true );
}
}
}
BaseClass::SetWeaponVisible( visible );
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
int CTFShotgun_Revenge::GetWorldModelIndex( void )
{
// Engineer guitar support.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer && pPlayer->GetPlayerClass() && ( pPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_ENGINEER ) &&
( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) ) && ( pPlayer->m_Shared.GetTauntIndex() == TAUNT_BASE_WEAPON ) )
{
// While we are taunting, replace our normal world model with the guitar.
m_iWorldModelIndex = modelinfo->GetModelIndex( TF_WEAPON_TAUNT_FRONTIER_JUSTICE_GUITAR_MODEL );
return m_iWorldModelIndex;
}
return BaseClass::GetWorldModelIndex();
}
#endif
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Reset revenge crits when the shotgun is changed
//-----------------------------------------------------------------------------
void CTFShotgun_Revenge::Detach( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer )
{
pPlayer->m_Shared.SetRevengeCrits( 0 );
pPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED );
}
BaseClass::Detach();
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFScatterGun::Reload( void )
{
int iWeaponMod = 0;
CALL_ATTRIB_HOOK_INT( iWeaponMod, set_scattergun_no_reload_single );
if ( iWeaponMod == 1 )
{
m_bReloadsSingly = false;
}
return BaseClass::Reload();
}
#define JUMP_SPEED 268.3281572999747f
extern ConVar tf_player_movement_stun_time;
extern float AirBurstDamageForce( const Vector &size, float damage, float scale );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFScatterGun::FireBullet( CTFPlayer *pPlayer )
{
#ifndef CLIENT_DLL
if ( HasKnockback() )
{
// Perform some knock back.
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( !pOwner )
return;
// No knockback during pre-round freeze.
if ( TFGameRules() && (TFGameRules()->State_Get() == GR_STATE_PREROUND) )
return;
// Knock the firer back!
if ( !(pOwner->GetFlags() & FL_ONGROUND) && !pPlayer->m_bScattergunJump )
{
pPlayer->m_bScattergunJump = true;
pOwner->m_Shared.StunPlayer( 0.3f, 1.f, TF_STUN_MOVEMENT | TF_STUN_MOVEMENT_FORWARD_ONLY );
float flForce = AirBurstDamageForce( pOwner->WorldAlignSize(), 60, 6.f );
Vector vecForward;
AngleVectors( pOwner->EyeAngles(), &vecForward );
Vector vecForce = vecForward * -flForce;
EntityMatrix mtxPlayer;
mtxPlayer.InitFromEntity( pOwner );
Vector vecAbsVelocity = pOwner->GetAbsVelocity();
Vector vecAbsVelocityAsPoint = vecAbsVelocity + pOwner->GetAbsOrigin();
Vector vecLocalVelocity = mtxPlayer.WorldToLocal( vecAbsVelocityAsPoint );
vecLocalVelocity.x = -300;
vecAbsVelocityAsPoint = mtxPlayer.LocalToWorld( vecLocalVelocity );
vecAbsVelocity = vecAbsVelocityAsPoint - pOwner->GetAbsOrigin();
pOwner->SetAbsVelocity( vecAbsVelocity );
// Impulse an additional bit of Z push.
pOwner->ApplyAbsVelocityImpulse( Vector(0,0,50.f) );
// Slow player movement for a brief period of time.
pOwner->RemoveFlag( FL_ONGROUND );
}
}
#endif
BaseClass::FireBullet( pPlayer );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFScatterGun::ApplyPostHitEffects( const CTakeDamageInfo &inputInfo, CTFPlayer *pPlayer )
{
#ifndef CLIENT_DLL
if ( !HasKnockback() )
return;
CTFPlayer *pAttacker = ToTFPlayer( inputInfo.GetAttacker() );
if ( !pAttacker )
return;
CTFPlayer *pTarget = pPlayer;
if ( !pTarget )
return;
if ( pTarget->m_Shared.GetWeaponKnockbackID() > -1 )
return;
float flDam = inputInfo.GetDamage();
Vector vecDir = pAttacker->WorldSpaceCenter() - pTarget->WorldSpaceCenter();
if ( !CanScatterGunKnockBack( this, flDam, vecDir.LengthSqr() ) )
return;
// Immune to pushback/knockback
if ( pTarget->m_Shared.InCond( TF_COND_MEGAHEAL ) )
return;
VectorNormalize( vecDir );
float flKnockbackMult = 3.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( this, flKnockbackMult, scattergun_knockback_mult );
float flForce = AirBurstDamageForce( pTarget->WorldAlignSize(), flDam, flKnockbackMult );
Vector vecForce = vecDir * -flForce;
vecForce.z += JUMP_SPEED;
pTarget->ApplyAirBlastImpulse( vecForce );
pTarget->m_Shared.StunPlayer( 0.3f, 1.f, TF_STUN_MOVEMENT | TF_STUN_MOVEMENT_FORWARD_ONLY, pAttacker );
pTarget->m_Shared.SetWeaponKnockbackID( pAttacker->GetUserID() );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFScatterGun::FinishReload( void )
{
CTFPlayer* pOwner = ToTFPlayer( GetOwner() );
if ( !pOwner )
return;
if ( UsesClipsForAmmo1() && !m_bReloadsSingly )
{
int primary = MIN( GetMaxClip1() - m_iClip1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
m_iClip1 += primary;
// Takes a whole clip worth of ammo to reload, causing us to lose whatever was chambered.
pOwner->RemoveAmmo( GetMaxClip1(), m_iPrimaryAmmoType);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFScatterGun::HasKnockback( void )
{
int iWeaponMod = 0;
CALL_ATTRIB_HOOK_INT( iWeaponMod, set_scattergun_has_knockback );
if ( iWeaponMod == 1 )
return true;
else
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Play animation appropriate to ball status.
//-----------------------------------------------------------------------------
bool CTFScatterGun::SendWeaponAnim( int iActivity )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return BaseClass::SendWeaponAnim( iActivity );
if ( HasKnockback() )
{
// Knockback version uses a different model and animation set.
switch ( iActivity )
{
case ACT_VM_DRAW:
iActivity = ACT_ITEM2_VM_DRAW;
break;
case ACT_VM_HOLSTER:
iActivity = ACT_ITEM2_VM_HOLSTER;
break;
case ACT_VM_IDLE:
iActivity = ACT_ITEM2_VM_IDLE;
break;
case ACT_VM_PULLBACK:
iActivity = ACT_ITEM2_VM_PULLBACK;
break;
case ACT_VM_PRIMARYATTACK:
iActivity = ACT_ITEM2_VM_PRIMARYATTACK;
break;
case ACT_VM_SECONDARYATTACK:
iActivity = ACT_ITEM2_VM_SECONDARYATTACK;
break;
case ACT_VM_RELOAD:
iActivity = ACT_ITEM2_VM_RELOAD;
break;
case ACT_VM_DRYFIRE:
iActivity = ACT_ITEM2_VM_DRYFIRE;
break;
case ACT_VM_IDLE_TO_LOWERED:
iActivity = ACT_ITEM2_VM_IDLE_TO_LOWERED;
break;
case ACT_VM_IDLE_LOWERED:
iActivity = ACT_ITEM2_VM_IDLE_LOWERED;
break;
case ACT_VM_LOWERED_TO_IDLE:
iActivity = ACT_ITEM2_VM_LOWERED_TO_IDLE;
break;
default:
break;
}
}
return BaseClass::SendWeaponAnim( iActivity );
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
void CTFScatterGun::Equip( CBaseCombatCharacter *pOwner )
{
CTFPlayer *pPlayer = dynamic_cast<CTFPlayer*>( pOwner );
if ( pPlayer )
{
pPlayer->m_Shared.SetScoutHypeMeter( 0.0f );
}
BaseClass::Equip( pOwner );
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// CTFSodaPopper
//-----------------------------------------------------------------------------
float CTFSodaPopper::GetProgress( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return 0.f;
return pPlayer->m_Shared.GetScoutHypeMeter() * 0.01f;
}
//-----------------------------------------------------------------------------
void CTFSodaPopper::ItemBusyFrame( void )
{
#ifdef GAME_DLL
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner && pOwner->m_nButtons & IN_ATTACK2 )
{
// Check here so we can always activate buff when we want (similar to stickies)
SecondaryAttack();
}
#endif
BaseClass::ItemBusyFrame();
}
//-----------------------------------------------------------------------------
void CTFSodaPopper::SecondaryAttack()
{
CTFPlayer *pPlayer = GetTFPlayerOwner( );
if ( !pPlayer || pPlayer->m_Shared.IsHypeBuffed() )
return;
if ( pPlayer->m_Shared.GetScoutHypeMeter() >= 100.f )
{
pPlayer->m_Shared.AddCond( TF_COND_SODAPOPPER_HYPE );
}
}
//-----------------------------------------------------------------------------
float CTFPEPBrawlerBlaster::GetProgress( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return 0.f;
return pPlayer->m_Shared.GetScoutHypeMeter() * 0.01f;
}
//-----------------------------------------------------------------------------
float CTFShotgunBuildingRescue::GetProjectileSpeed( void )
{
return RemapValClamped( 0.75f, 0.0f, 1.f, 1800, 2600 ); // Temp, if we want to ramp.
}
//-----------------------------------------------------------------------------
float CTFShotgunBuildingRescue::GetProjectileGravity( void )
{
return RemapValClamped( 0.75f, 0.0f, 1.f, 0.5f, 0.1f ); // Temp, if we want to ramp.
}
//-----------------------------------------------------------------------------
bool CTFShotgunBuildingRescue::IsViewModelFlipped( void )
{
return !BaseClass::IsViewModelFlipped(); // Invert because arrows are backwards by default.
}