d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
114 Commits
25 Branches
6 Tags
221 MiB
Tree: 0fb75b41fd
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0fb75b41fd'
${ noResults }
source-engine/game/shared/tf/tf_weaponbase.cpp

6559 lines
211 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Weapons.
//
//=============================================================================
#include "cbase.h"
#include "in_buttons.h"
#include "takedamageinfo.h"
#include "tf_weaponbase.h"
#include "ammodef.h"
#include "tf_gamerules.h"
#include "eventlist.h"
#include "econ_item_system.h"
#include "activitylist.h"
#include "gcsdk/gcmsg.h"
#include "econ_gcmessages.h"
#include "tf_gcmessages.h"
#include "tf_weapon_wrench.h"
#include "passtime_convars.h"
// Server specific.
#if !defined( CLIENT_DLL )
#include "tf_player.h"
#include "tf_weapon_medigun.h"
#include "tf_gamestats.h"
#include "tf_player.h"
#include "tf_gamerules.h"
#include "tf_gamestats.h"
#include "ilagcompensationmanager.h"
#include "collisionutils.h"
#include "tf_team.h"
#include "tf_obj.h"
#include "tf_weapon_grenade_pipebomb.h"
#include "particle_parse.h"
#include "tf_weaponbase_grenadeproj.h"
#include "tf_weapon_compound_bow.h"
#include "tf_projectile_arrow.h"
#include "tf_gamestats.h"
#include "bot/tf_bot_manager.h"
#include "bot/tf_bot.h"
#include "halloween/halloween_base_boss.h"
#include "tf_fx.h"
#include "tf_gamestats.h"
// Client specific.
#else
#include "c_tf_player.h"
#include "tf_viewmodel.h"
#include "hud_crosshair.h"
#include "c_tf_playerresource.h"
#include "clientmode_tf.h"
#include "r_efx.h"
#include "dlight.h"
#include "effect_dispatch_data.h"
#include "c_te_effect_dispatch.h"
#include "toolframework_client.h"
#include "hud_chat.h"
#include "econ_notifications.h"
#include "prediction.h"
// for spy material proxy
#include "tf_proxyentity.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/imaterialvar.h"
extern CTFWeaponInfo *GetTFWeaponInfo( int iWeapon );
#endif
#include "gc_clientsystem.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern ConVar tf_useparticletracers;
ConVar tf_scout_hype_pep_mod( "tf_scout_hype_pep_mod", "1.0", FCVAR_REPLICATED | FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_scout_hype_pep_max( "tf_scout_hype_pep_max", "99.0", FCVAR_REPLICATED | FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_scout_hype_pep_min_damage( "tf_scout_hype_pep_min_damage", "5.0", FCVAR_REPLICATED | FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_weapon_criticals_nopred( "tf_weapon_criticals_nopred", "1.0", FCVAR_REPLICATED | FCVAR_CHEAT );
#ifdef _DEBUG
ConVar tf_weapon_criticals_anticheat( "tf_weapon_criticals_anticheat", "1.0", FCVAR_REPLICATED );
ConVar tf_weapon_criticals_debug( "tf_weapon_criticals_debug", "0.0", FCVAR_REPLICATED );
extern ConVar tf_weapon_criticals_force_random;
#endif // _DEBUG
extern ConVar tf_weapon_criticals_bucket_cap;
extern ConVar tf_weapon_criticals_bucket_bottom;
#ifdef CLIENT_DLL
extern ConVar cl_crosshair_file;
extern ConVar cl_flipviewmodels;
#endif
#ifdef STAGING_ONLY
ConVar tf_weapon_force_allow_inspect( "tf_weapon_force_allow_inspect", "0", FCVAR_REPLICATED | FCVAR_ARCHIVE, "Allow the inspect animation on any weapon" );
#endif
//=============================================================================
//
// Global functions.
//
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool IsAmmoType( int iAmmoType, const char *pAmmoName )
{
return GetAmmoDef()->Index( pAmmoName ) == iAmmoType;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void FindHullIntersection( const Vector &vecSrc, trace_t &tr, const Vector &mins, const Vector &maxs, CBaseEntity *pEntity )
{
int i, j, k;
trace_t tmpTrace;
Vector vecEnd;
float distance = 1e6f;
Vector minmaxs[2] = {mins, maxs};
Vector vecHullEnd = tr.endpos;
vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
UTIL_TraceLine( vecSrc, vecHullEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
if ( tmpTrace.fraction < 1.0 )
{
tr = tmpTrace;
return;
}
for ( i = 0; i < 2; i++ )
{
for ( j = 0; j < 2; j++ )
{
for ( k = 0; k < 2; k++ )
{
vecEnd.x = vecHullEnd.x + minmaxs[i][0];
vecEnd.y = vecHullEnd.y + minmaxs[j][1];
vecEnd.z = vecHullEnd.z + minmaxs[k][2];
UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
if ( tmpTrace.fraction < 1.0 )
{
float thisDistance = (tmpTrace.endpos - vecSrc).Length();
if ( thisDistance < distance )
{
tr = tmpTrace;
distance = thisDistance;
}
}
}
}
}
}
//=============================================================================
//
// TFWeaponBase tables.
//
IMPLEMENT_NETWORKCLASS_ALIASED( TFWeaponBase, DT_TFWeaponBase )
#ifdef GAME_DLL
void* SendProxy_SendActiveLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID );
void* SendProxy_SendNonLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID );
#endif
//-----------------------------------------------------------------------------
// Purpose: Only sent to the player holding it.
//-----------------------------------------------------------------------------
BEGIN_NETWORK_TABLE_NOBASE( CTFWeaponBase, DT_LocalTFWeaponData )
#if defined( CLIENT_DLL )
RecvPropTime( RECVINFO( m_flLastCritCheckTime ) ),
RecvPropTime( RECVINFO( m_flReloadPriorNextFire ) ),
RecvPropTime( RECVINFO( m_flLastFireTime ) ),
RecvPropTime( RECVINFO( m_flEffectBarRegenTime ) ),
RecvPropFloat( RECVINFO( m_flObservedCritChance ) ),
#else
SendPropTime( SENDINFO( m_flLastCritCheckTime ) ),
SendPropTime( SENDINFO( m_flReloadPriorNextFire ) ),
SendPropTime( SENDINFO( m_flLastFireTime ) ),
SendPropTime( SENDINFO( m_flEffectBarRegenTime ) ),
SendPropFloat( SENDINFO( m_flObservedCritChance ), 16, SPROP_NOSCALE, 0.0, 100.0 ),
#endif
END_NETWORK_TABLE()
//-----------------------------------------------------------------------------
// Purpose: Variables sent at low precision to non-holding observers.
//-----------------------------------------------------------------------------
BEGIN_NETWORK_TABLE_NOBASE( CTFWeaponBase, DT_TFWeaponDataNonLocal )
END_NETWORK_TABLE()
BEGIN_NETWORK_TABLE( CTFWeaponBase, DT_TFWeaponBase )
// Client specific.
#ifdef CLIENT_DLL
RecvPropBool( RECVINFO( m_bLowered ) ),
RecvPropInt( RECVINFO( m_iReloadMode ) ),
RecvPropBool( RECVINFO( m_bResetParity ) ),
RecvPropBool( RECVINFO( m_bReloadedThroughAnimEvent ) ),
RecvPropBool( RECVINFO( m_bDisguiseWeapon ) ),
RecvPropDataTable("LocalActiveTFWeaponData", 0, 0, &REFERENCE_RECV_TABLE(DT_LocalTFWeaponData)),
RecvPropDataTable("NonLocalTFWeaponData", 0, 0, &REFERENCE_RECV_TABLE(DT_TFWeaponDataNonLocal)),
RecvPropFloat( RECVINFO(m_flEnergy) ),
RecvPropEHandle( RECVINFO( m_hExtraWearable ) ),
RecvPropEHandle( RECVINFO( m_hExtraWearableViewModel ) ),
RecvPropBool( RECVINFO( m_bBeingRepurposedForTaunt ) ),
RecvPropInt( RECVINFO( m_nKillComboClass ) ),
RecvPropInt( RECVINFO( m_nKillComboCount ) ),
RecvPropFloat( RECVINFO( m_flInspectAnimTime ) ),
RecvPropInt( RECVINFO( m_nInspectStage ) ),
#else
// Server specific.
SendPropBool( SENDINFO( m_bLowered ) ),
SendPropBool( SENDINFO( m_bResetParity ) ),
SendPropInt( SENDINFO( m_iReloadMode ), 4, SPROP_UNSIGNED ),
SendPropBool( SENDINFO( m_bReloadedThroughAnimEvent ) ),
SendPropBool( SENDINFO( m_bDisguiseWeapon ) ),
SendPropDataTable("LocalActiveTFWeaponData", 0, &REFERENCE_SEND_TABLE(DT_LocalTFWeaponData), SendProxy_SendActiveLocalWeaponDataTable ),
SendPropDataTable("NonLocalTFWeaponData", 0, &REFERENCE_SEND_TABLE(DT_TFWeaponDataNonLocal), SendProxy_SendNonLocalWeaponDataTable ),
SendPropFloat( SENDINFO(m_flEnergy) ),
SendPropEHandle( SENDINFO( m_hExtraWearable ) ),
SendPropEHandle( SENDINFO( m_hExtraWearableViewModel ) ),
SendPropBool( SENDINFO( m_bBeingRepurposedForTaunt ) ),
SendPropInt( SENDINFO( m_nKillComboClass ), 4, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nKillComboCount ), 2, SPROP_UNSIGNED ),
SendPropFloat( SENDINFO( m_flInspectAnimTime ) ),
SendPropInt( SENDINFO( m_nInspectStage ), -1, SPROP_VARINT ),
#endif
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFWeaponBase )
#ifdef CLIENT_DLL
DEFINE_PRED_FIELD( m_bLowered, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_iReloadMode, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bReloadedThroughAnimEvent, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bDisguiseWeapon, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD_TOL( m_flLastCritCheckTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flReloadPriorNextFire, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flLastFireTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD( m_bCurrentAttackIsCrit, FIELD_BOOLEAN, 0 ),
DEFINE_PRED_FIELD( m_iCurrentSeed, FIELD_INTEGER, 0 ),
DEFINE_PRED_FIELD( m_flEnergy, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD_TOL( m_flEffectBarRegenTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD( m_bBeingRepurposedForTaunt, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
#endif
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_base, CTFWeaponBase );
// Server specific.
#if !defined( CLIENT_DLL )
BEGIN_DATADESC( CTFWeaponBase )
DEFINE_THINKFUNC( FallThink ),
END_DATADESC()
// Client specific
#else
ConVar cl_crosshaircolor( "cl_crosshaircolor", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_dynamiccrosshair( "cl_dynamiccrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_scalecrosshair( "cl_scalecrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshairalpha( "cl_crosshairalpha", "200", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
int g_iScopeTextureID = 0;
int g_iScopeDustTextureID = 0;
#endif
ConVar tf_weapon_criticals( "tf_weapon_criticals", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Whether or not random crits are enabled" );
//=============================================================================
//
// TFWeaponBase shared functions.
//
// -----------------------------------------------------------------------------
// Purpose: Constructor.
// -----------------------------------------------------------------------------
CTFWeaponBase::CTFWeaponBase()
{
SetPredictionEligible( true );
// Nothing collides with these, but they get touch calls.
AddSolidFlags( FSOLID_TRIGGER );
// Weapons can fire underwater.
m_bFiresUnderwater = true;
m_bAltFiresUnderwater = true;
// Initialize the weapon modes.
m_iWeaponMode = TF_WEAPON_PRIMARY_MODE;
m_iReloadMode.Set( TF_RELOAD_START );
m_iAltFireHint = 0;
m_bInAttack = false;
m_bInAttack2 = false;
m_flCritTime = 0;
m_flLastCritCheckTime = 0;
m_flLastRapidFireCritCheckTime = 0;
m_iLastCritCheckFrame = 0;
m_flObservedCritChance = 0.f;
m_flLastFireTime = 0;
m_flEffectBarRegenTime = 0;
m_bCurrentAttackIsCrit = false;
m_bCurrentCritIsRandom = false;
m_bCurrentAttackIsDuringDemoCharge = false;
m_iCurrentSeed = -1;
m_flReloadPriorNextFire = 0;
m_flLastDeployTime = 0;
m_bDisguiseWeapon = false;
m_flEnergy = Energy_GetMaxEnergy();
m_iAmmoToAdd = 0;
#ifdef GAME_DLL
m_iHitsInTime = 1;
m_iFiredInTime = 1;
m_iKillStreak = 0;
m_flClipScale = 1.f;
#endif // GAME_DLL
#ifdef CLIENT_DLL
m_iCachedModelIndex = 0;
m_iEjectBrassAttachpoint = -2;
m_bInitViewmodelOffset = false;
m_vecViewmodelOffset = vec3_origin;
#endif // CLIENT_DLL
m_bBeingRepurposedForTaunt = false;
m_nKillComboClass = 0;
ClearKillComboCount();
m_flLastPrimaryAttackTime = 0.f;
m_eStrangeType = STRANGE_UNKNOWN;
m_eStatTrakModuleType = MODULE_UNKNOWN;
m_flInspectAnimTime = -1.f;
m_nInspectStage = INSPECT_INVALID;
}
CTFWeaponBase::~CTFWeaponBase()
{
#ifdef CLIENT_DLL
RemoveWorldmodelStatTrak();
RemoveViewmodelStatTrak();
#endif
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
void CTFWeaponBase::Spawn()
{
// Called manually, because CBaseCombatWeapon::Spawn doesn't call back.
InitializeAttributes();
m_bBeingRepurposedForTaunt = false;
m_nKillComboClass = 0;
ClearKillComboCount();
// Base class spawn.
BaseClass::Spawn();
// Set this here to allow players to shoot dropped weapons.
SetCollisionGroup( COLLISION_GROUP_WEAPON );
// Get the weapon information.
WEAPON_FILE_INFO_HANDLE hWpnInfo = LookupWeaponInfoSlot( GetClassname() );
Assert( hWpnInfo != GetInvalidWeaponInfoHandle() );
CTFWeaponInfo *pWeaponInfo = dynamic_cast<CTFWeaponInfo*>( GetFileWeaponInfoFromHandle( hWpnInfo ) );
Assert( pWeaponInfo && "Failed to get CTFWeaponInfo in weapon spawn" );
m_pWeaponInfo = pWeaponInfo;
if ( GetPlayerOwner() )
{
ChangeTeam( GetPlayerOwner()->GetTeamNumber() );
}
#ifdef GAME_DLL
// Move it up a little bit, otherwise it'll be at the guy's feet, and its sound origin
// will be in the ground so its EmitSound calls won't do anything.
Vector vecOrigin = GetAbsOrigin();
SetAbsOrigin( Vector( vecOrigin.x, vecOrigin.y, vecOrigin.z + 5.0f ) );
m_flRegenTime = 0.0f;
m_hLastDrainVictim = NULL;
m_lastDrainVictimTimer.Invalidate();
#endif
m_szTracerName[0] = '\0';
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem )
{
CEconItemDefinition* pData = pItem->GetStaticData();
if ( pData && pData->GetSubType() )
{
SetSubType( pData->GetSubType() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::Activate( void )
{
BaseClass::Activate();
// Reset our clip, in case we've had it modified
GiveDefaultAmmo();
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
void CTFWeaponBase::FallInit( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
void CTFWeaponBase::Precache()
{
BaseClass::Precache();
if ( GetMuzzleFlashModel() )
{
PrecacheModel( GetMuzzleFlashModel() );
}
const CTFWeaponInfo *pTFInfo = &GetTFWpnData();
if ( pTFInfo->m_szExplosionSound && pTFInfo->m_szExplosionSound[0] )
{
CBaseEntity::PrecacheScriptSound( pTFInfo->m_szExplosionSound );
}
if ( pTFInfo->m_szBrassModel[0] )
{
PrecacheModel( pTFInfo->m_szBrassModel );
}
if ( GetMuzzleFlashParticleEffect() )
{
PrecacheParticleSystem( GetMuzzleFlashParticleEffect() );
}
if ( pTFInfo->m_szExplosionEffect && pTFInfo->m_szExplosionEffect[0] )
{
PrecacheParticleSystem( pTFInfo->m_szExplosionEffect );
}
if ( pTFInfo->m_szExplosionPlayerEffect && pTFInfo->m_szExplosionPlayerEffect[0] )
{
PrecacheParticleSystem( pTFInfo->m_szExplosionPlayerEffect );
}
if ( pTFInfo->m_szExplosionWaterEffect && pTFInfo->m_szExplosionWaterEffect[0] )
{
PrecacheParticleSystem( pTFInfo->m_szExplosionWaterEffect );
}
const char *pszTracerEffect = pTFInfo->m_szTracerEffect;
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
const char *pszItemTracerEffect = pItem->GetStaticData()->GetTracerEffect( GetTeamNumber() );
if ( pszItemTracerEffect )
{
pszTracerEffect = pszItemTracerEffect;
}
}
if ( pszTracerEffect && pszTracerEffect[0] )
{
char pTracerEffect[128];
char pTracerEffectCrit[128];
Q_snprintf( pTracerEffect, sizeof(pTracerEffect), "%s_red", pszTracerEffect );
Q_snprintf( pTracerEffectCrit, sizeof(pTracerEffectCrit), "%s_red_crit", pszTracerEffect );
PrecacheParticleSystem( pTracerEffect );
PrecacheParticleSystem( pTracerEffectCrit );
Q_snprintf( pTracerEffect, sizeof(pTracerEffect), "%s_blue", pszTracerEffect );
Q_snprintf( pTracerEffectCrit, sizeof(pTracerEffectCrit), "%s_blue_crit", pszTracerEffect );
PrecacheParticleSystem( pTracerEffect );
PrecacheParticleSystem( pTracerEffectCrit );
}
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
{
CBaseEntity::PrecacheScriptSound( "Weapon_Upgrade.DamageBonus1" );
CBaseEntity::PrecacheScriptSound( "Weapon_Upgrade.DamageBonus2" );
CBaseEntity::PrecacheScriptSound( "Weapon_Upgrade.DamageBonus3" );
CBaseEntity::PrecacheScriptSound( "Weapon_Upgrade.DamageBonus4" );
}
PrecacheModel( "models/weapons/c_models/stattrack.mdl" );
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
const CTFWeaponInfo &CTFWeaponBase::GetTFWpnData() const
{
const FileWeaponInfo_t *pWeaponInfo = &GetWpnData();
const CTFWeaponInfo *pTFInfo = dynamic_cast< const CTFWeaponInfo* >( pWeaponInfo );
Assert( pTFInfo );
return *pTFInfo;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
int CTFWeaponBase::GetWeaponID( void ) const
{
Assert( false );
return TF_WEAPON_NONE;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
bool CTFWeaponBase::IsWeapon( int iWeapon ) const
{
return GetWeaponID() == iWeapon;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
int CTFWeaponBase::GetMaxClip1( void ) const
{
if ( IsEnergyWeapon() )
{
return Energy_GetMaxEnergy();
}
// Handle the itemdef mod first...
float flClip = BaseClass::GetMaxClip1();
if ( flClip >= 0 )
{
CALL_ATTRIB_HOOK_INT( flClip, mult_clipsize );
}
// Now handle in-game sources, otherwise we get weird numbers on things like the FAN
if ( flClip >= 0 )
{
#ifdef GAME_DLL
flClip *= m_flClipScale;
#endif
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer )
{
// Blast weps (low clip counts)
if ( IsBlastImpactWeapon() )
{
// MvM-specific upgrade attribute that handles rocket and grenade launchers
int nProjectiles = 0;
CALL_ATTRIB_HOOK_INT( nProjectiles, mult_clipsize_upgrade_atomic );
// Clipsize increase on kills
int iClipSizeOnKills = 0;
CALL_ATTRIB_HOOK_INT( iClipSizeOnKills, clipsize_increase_on_kill );
if ( iClipSizeOnKills )
{
nProjectiles += Min( pPlayer->m_Shared.GetDecapitations(), iClipSizeOnKills ); // max extra projectiles
}
if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
{
flClip *= 2;
}
if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
{
flClip *= 1.5f;
}
return ( flClip + nProjectiles );
}
else
{
CALL_ATTRIB_HOOK_INT( flClip, mult_clipsize_upgrade );
if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
{
flClip *= 2;
}
}
}
}
return flClip;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
int CTFWeaponBase::GetDefaultClip1( void ) const
{
return GetMaxClip1();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::UsesPrimaryAmmo( void )
{
if ( IsEnergyWeapon() )
return false;
else
return CBaseCombatWeapon::UsesPrimaryAmmo();
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
const char *CTFWeaponBase::GetViewModel( int iViewModel ) const
{
if ( GetPlayerOwner() == NULL )
return BaseClass::GetViewModel();
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
int iHandModelIndex = 0;
if ( pPlayer )
{
//CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayer, iHandModelIndex, override_hand_model_index ); // this is a cleaner way of doing it, but...
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayer, iHandModelIndex, wrench_builds_minisentry ); // ...the gunslinger is the only thing that uses this attribute for now
}
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pPlayer && pItem->IsValid() && pItem->GetStaticData()->ShouldAttachToHands() )
{
// Should always be valid, because players without classes shouldn't be carrying items
const char *pszHandModel = pPlayer->GetPlayerClass()->GetHandModelName( iHandModelIndex );
Assert( pszHandModel );
return pszHandModel;
}
return GetTFWpnData().szViewModel;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFWeaponBase::GetWorldModel( void ) const
{
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
if ( pItem->GetWorldDisplayModel() )
return pItem->GetWorldDisplayModel();
int iClass = 0;
int iTeam = 0;
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer )
{
iClass = pPlayer->GetPlayerClass()->GetClassIndex();
iTeam = pPlayer->GetTeamNumber();
}
return pItem->GetPlayerDisplayModel( iClass, iTeam );
}
return BaseClass::GetWorldModel();
}
bool CTFWeaponBase::IsInspectActivity( int iActivity )
{
return iActivity == GetInspectActivity( INSPECT_START ) || iActivity == GetInspectActivity( INSPECT_IDLE ) || iActivity == GetInspectActivity( INSPECT_END );
}
bool CTFWeaponBase::SendWeaponAnim( int iActivity )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return BaseClass::SendWeaponAnim( iActivity );
if ( m_nInspectStage != INSPECT_INVALID )
{
if ( iActivity == GetActivity() )
return true;
// ignore idle anim while inspect anim is still playing
if ( iActivity == ACT_VM_IDLE )
{
return true;
}
// allow other activity to override the inspect
if ( !IsInspectActivity( iActivity ) )
{
m_flInspectAnimTime = -1.f;
m_nInspectStage = INSPECT_INVALID;
return BaseClass::SendWeaponAnim( iActivity );
}
// let the idle loop while the inspect key is pressed
if ( pPlayer->IsInspecting() && m_nInspectStage == INSPECT_IDLE )
return true;
}
return BaseClass::SendWeaponAnim( iActivity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::Equip( CBaseCombatCharacter *pOwner )
{
SetOwner( pOwner );
SetOwnerEntity( pOwner );
ReapplyProvision();
BaseClass::Equip( pOwner );
// If we attach to our hands, we need to update our viewmodel when we get a new owner.
UpdateHands();
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
m_bFlipViewModel = pItem->GetStaticData()->ShouldFlipViewmodels();
// Also precache the vision filtered display models here.
if ( pItem->GetVisionFilteredDisplayModel() )
{
if ( modelinfo->GetModelIndex( pItem->GetVisionFilteredDisplayModel() ) == -1 )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Vision Filtered Display Model Late Precache", __FUNCTION__ );
CBaseEntity::PrecacheModel( pItem->GetVisionFilteredDisplayModel() );
}
}
#ifdef GAME_DLL
UpdateExtraWearables();
CTFPlayer *pTFPlayer = ToTFPlayer( pOwner );
if ( pTFPlayer )
{
pTFPlayer->ReapplyItemUpgrades(pItem);
}
#endif // GAME_DLL
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::UpdateHands( void )
{
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() && pItem->GetStaticData()->ShouldAttachToHands() )
{
m_iViewModelIndex = CBaseEntity::PrecacheModel( GetViewModel() );
}
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::UpdateExtraWearables()
{
CTFWearable *pOldWearable = m_hExtraWearable.Get();
CTFWearable *pOldWearableVM = m_hExtraWearableViewModel.Get();
if ( pOldWearable || pOldWearableVM )
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner )
{
if ( !( pOldWearable && pOldWearable->GetTeamNumber() != pOwner->GetTeamNumber() ) &&
!( pOldWearableVM && pOldWearableVM->GetTeamNumber() != pOwner->GetTeamNumber() ) )
{
// No need to destroy and recreate them, because they already match the owner's team
return;
}
}
RemoveExtraWearables();
}
bool bHasViewModel = false;
CEconItemView *pEconItemView = GetAttributeContainer()->GetItem();
if ( pEconItemView->GetExtraWearableViewModel() )
{
CTFWearable* pExtraWearableItem = dynamic_cast<CTFWearable*>( CreateEntityByName( "tf_wearable_vm" ) );
if ( pExtraWearableItem )
{
if ( modelinfo->GetModelIndex( pEconItemView->GetExtraWearableViewModel() ) == -1 ) {
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - View Model Late Precache", __FUNCTION__ );
// Precaching may be needed here, because we allow virtually everything to be loaded on demand now.
pExtraWearableItem->PrecacheModel( pEconItemView->GetExtraWearableViewModel() );
}
pExtraWearableItem->AddSpawnFlags( SF_NORESPAWN );
pExtraWearableItem->SetAlwaysAllow( true );
DispatchSpawn( pExtraWearableItem );
pExtraWearableItem->GiveTo( GetOwner() );
pExtraWearableItem->SetModel( pEconItemView->GetExtraWearableViewModel() );
bHasViewModel = true;
pExtraWearableItem->SetWeaponAssociatedWith( this );
ExtraWearableViewModelEquipped( pExtraWearableItem );
}
}
if ( pEconItemView->GetExtraWearableModel() )
{
CTFWearable* pExtraWearableItem = dynamic_cast<CTFWearable*>( CreateEntityByName( "tf_wearable" ) );
if ( pExtraWearableItem )
{
if ( modelinfo->GetModelIndex( pEconItemView->GetExtraWearableModel() ) == -1 ) {
tmZone(TELEMETRY_LEVEL0, TMZF_NONE, "%s - Model Late Precache", __FUNCTION__);
// Precaching may be needed here, because we allow virtually everything to be loaded on demand now.
pExtraWearableItem->PrecacheModel( pEconItemView->GetExtraWearableModel() );
}
pExtraWearableItem->AddSpawnFlags( SF_NORESPAWN );
pExtraWearableItem->SetAlwaysAllow( true );
DispatchSpawn( pExtraWearableItem );
pExtraWearableItem->GiveTo( GetOwner() );
pExtraWearableItem->SetModel( pEconItemView->GetExtraWearableModel() );
if ( bHasViewModel )
{
// If it has a view model we need to have the weapon control visibility of this wearable
pExtraWearableItem->SetWeaponAssociatedWith( this );
}
ExtraWearableEquipped( pExtraWearableItem );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ExtraWearableEquipped( CTFWearable *pExtraWearableItem )
{
Assert( m_hExtraWearable == NULL );
Assert( pExtraWearableItem != NULL );
m_hExtraWearable.Set( pExtraWearableItem );
CBasePlayer *pPlayerOwner = dynamic_cast<CBasePlayer *>( GetOwner() );
if ( pPlayerOwner )
{
pExtraWearableItem->Equip( pPlayerOwner );
}
}
void CTFWeaponBase::ExtraWearableViewModelEquipped( CTFWearable *pExtraWearableItem )
{
Assert( m_hExtraWearableViewModel == NULL );
Assert( pExtraWearableItem != NULL );
m_hExtraWearableViewModel.Set( pExtraWearableItem );
CBasePlayer *pPlayerOwner = dynamic_cast<CBasePlayer *>( GetOwner() );
if ( pPlayerOwner )
{
pExtraWearableItem->Equip( pPlayerOwner );
}
}
#else
void CTFWeaponBase::UpdateExtraWearablesVisibility()
{
if ( m_hExtraWearable.Get() )
{
m_hExtraWearable->ValidateModelIndex();
m_hExtraWearable->UpdateVisibility();
m_hExtraWearable->CreateShadow();
}
if ( m_hExtraWearableViewModel.Get() )
{
m_hExtraWearableViewModel->UpdateVisibility();
}
if ( m_viewmodelStatTrakAddon.Get() )
{
m_viewmodelStatTrakAddon->UpdateVisibility();
}
if ( m_worldmodelStatTrakAddon.Get() )
{
m_worldmodelStatTrakAddon->UpdateVisibility();
m_worldmodelStatTrakAddon->CreateShadow();
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::RemoveExtraWearables( void )
{
if ( m_hExtraWearable )
{
m_hExtraWearable->RemoveFrom( GetOwnerEntity() );
m_hExtraWearable = NULL;
}
if ( m_hExtraWearableViewModel )
{
m_hExtraWearableViewModel->RemoveFrom( GetOwnerEntity() );
m_hExtraWearableViewModel = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::Drop( const Vector &vecVelocity )
{
#ifndef CLIENT_DLL
if ( m_iAltFireHint )
{
CBasePlayer *pPlayer = GetPlayerOwner();
if ( pPlayer )
{
pPlayer->StopHintTimer( m_iAltFireHint );
}
}
#endif
BaseClass::Drop( vecVelocity );
ReapplyProvision();
RemoveExtraWearables();
#ifndef CLIENT_DLL
// Never allow weapons to lie around on the ground
UTIL_Remove( this );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::UpdateOnRemove( void )
{
RemoveExtraWearables();
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CanHolster( void ) const
{
// Honorbound weapons are unable to be holstered until they have killed someone
// since the last time they were brought out. We ignore this logic for the first
// block of time after a weapon is taken out to allow quickswitching.
// only check the first block of time logic if the weapon is active weapon
// Can always holster if you have enough life cause we'll take that away
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer && ( pPlayer->GetActiveWeapon() != this || gpGlobals->curtime >= pPlayer->m_Shared.m_flFirstPrimaryAttack ) )
{
if ( IsHonorBound() && pPlayer->m_Shared.m_iKillCountSinceLastDeploy == 0 && pPlayer->GetHealth() <= 50 )
{
#ifdef CLIENT_DLL
pPlayer->EmitSound( "Player.DenyWeaponSelection" );
#endif
return false;
}
}
return BaseClass::CanHolster();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Holster( CBaseCombatWeapon *pSwitchingTo )
{
#ifndef CLIENT_DLL
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && m_iAltFireHint )
{
pPlayer->StopHintTimer( m_iAltFireHint );
}
// Honorbound hurt yourself
if ( pPlayer && ( pPlayer->GetActiveWeapon() != this || gpGlobals->curtime >= pPlayer->m_Shared.m_flFirstPrimaryAttack ) )
{
if ( IsHonorBound() && pPlayer->m_Shared.m_iKillCountSinceLastDeploy == 0 && pPlayer->GetHealth() > 0 && pPlayer->IsAlive() )
{
pPlayer->TakeDamage( CTakeDamageInfo( pPlayer, pPlayer, vec3_origin, pPlayer->WorldSpaceCenter(), 50.f, GetDamageType() | DMG_PREVENT_PHYSICS_FORCE ) );
}
}
#endif
m_iReloadMode.Set( TF_RELOAD_START );
return BaseClass::Holster( pSwitchingTo );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Deploy( void )
{
#ifndef CLIENT_DLL
if ( m_iAltFireHint )
{
CBasePlayer *pPlayer = GetPlayerOwner();
if ( pPlayer )
{
pPlayer->StartHintTimer( m_iAltFireHint );
}
}
#endif
m_iReloadMode.Set( TF_RELOAD_START );
float flOriginalPrimaryAttack = m_flNextPrimaryAttack;
float flOriginalSecondaryAttack = m_flNextSecondaryAttack;
bool bDeploy = BaseClass::Deploy();
if ( bDeploy )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return false;
float flWeaponSwitchTime = 0.5f;
// Overrides the anim length for calculating ready time.
float flDeployTimeMultiplier = 1.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayer, flDeployTimeMultiplier, mult_deploy_time );
CALL_ATTRIB_HOOK_FLOAT( flDeployTimeMultiplier, mult_single_wep_deploy_time );
// don't apply mult_switch_from_wep_deploy_time attribute if the last weapon hasn't been deployed for more than 0.67 second to match to weapon script switch time
// unless the player latched to a hook target, then allow switching right away
CTFWeaponBase *pLastWeapon = dynamic_cast< CTFWeaponBase* >( pPlayer->GetLastWeapon() );
if ( pPlayer->GetGrapplingHookTarget() != NULL || ( pLastWeapon && gpGlobals->curtime - pLastWeapon->m_flLastDeployTime > flWeaponSwitchTime ) )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLastWeapon, flDeployTimeMultiplier, mult_switch_from_wep_deploy_time );
}
if ( pPlayer->m_Shared.InCond( TF_COND_BLASTJUMPING ) )
{
CALL_ATTRIB_HOOK_FLOAT( flDeployTimeMultiplier, mult_rocketjump_deploy_time );
}
int iIsSword = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pLastWeapon, iIsSword, is_a_sword );
CALL_ATTRIB_HOOK_INT( iIsSword, is_a_sword );
if ( iIsSword )
{
// swords deploy and holster 75% slower
flDeployTimeMultiplier *= 1.75f;
}
#ifdef STAGING_ONLY
if ( pPlayer->m_Shared.InCond( TF_COND_TRANQ_SPY_BOOST ) )
{
flDeployTimeMultiplier /= 2.0f;
}
#endif // STAGING_ONLY
if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_AGILITY )
{
flDeployTimeMultiplier /= 5.0f;
}
int numHealers = pPlayer->m_Shared.GetNumHealers();
if ( numHealers == 0 )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayer, flDeployTimeMultiplier, mod_medic_healed_deploy_time );
}
flDeployTimeMultiplier = MAX( flDeployTimeMultiplier, 0.00001f );
float flDeployTime = flWeaponSwitchTime * flDeployTimeMultiplier;
float flPlaybackRate = Clamp( ( 1.f / flDeployTimeMultiplier ) * ( 0.67f / flWeaponSwitchTime ), -4.f, 12.f ); // clamp between the range that's defined in send table
if ( pPlayer->GetViewModel(0) )
{
pPlayer->GetViewModel(0)->SetPlaybackRate( flPlaybackRate );
}
if ( pPlayer->GetViewModel(1) )
{
pPlayer->GetViewModel(1)->SetPlaybackRate( flPlaybackRate );
}
// Don't override primary attacks that are already further out than this. This prevents
// people exploiting weapon switches to allow weapons to fire faster.
m_flNextPrimaryAttack = MAX( flOriginalPrimaryAttack, gpGlobals->curtime + flDeployTime );
m_flNextSecondaryAttack = MAX( flOriginalSecondaryAttack, m_flNextPrimaryAttack.Get() );
pPlayer->SetNextAttack( m_flNextPrimaryAttack );
m_flLastDeployTime = gpGlobals->curtime;
#ifdef GAME_DLL
// Reset our deploy-lifetime kill counter.
pPlayer->m_Shared.m_iKillCountSinceLastDeploy = 0;
pPlayer->m_Shared.m_flFirstPrimaryAttack = m_flNextPrimaryAttack;
#endif // GAME_DLL
}
return bDeploy;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::ForceWeaponSwitch() const
{
// allow knockout rune to force switch to melee
CTFPlayer *pOwner = GetTFPlayerOwner();
if ( pOwner && pOwner->m_Shared.GetCarryingRuneType() == RUNE_KNOCKOUT )
{
int iClass = pOwner->GetPlayerClass()->GetClassIndex();
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData()->GetLoadoutSlot( iClass ) == LOADOUT_POSITION_MELEE )
{
return true;
}
}
// should force switch to this item
int iForceWeaponSwitch = 0;
CALL_ATTRIB_HOOK_INT( iForceWeaponSwitch, force_weapon_switch );
return iForceWeaponSwitch != 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::Detach( void )
{
BaseClass::Detach();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::OnActiveStateChanged( int iOldState )
{
UpdateHiddenParentBodygroup( m_iState == WEAPON_IS_ACTIVE );
// See if we need to reapply our provider based on our active state.
int iProvideMode = 0;
CALL_ATTRIB_HOOK_INT( iProvideMode, provide_on_active );
if ( 1 == iProvideMode )
{
ReapplyProvision();
}
// Check for a speed mod change.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer )
{
pPlayer->TeamFortress_SetSpeed();
}
CEconItemView *pScriptItem = GetAttributeContainer()->GetItem();
if ( pScriptItem && pScriptItem->GetStaticData()->GetHideBodyGroupsDeployedOnly() )
{
#ifdef CLIENT_DLL
if ( pPlayer )
{
pPlayer->SetBodygroupsDirty();
}
#else
int iState = 0;
if ( WeaponState() == WEAPON_IS_ACTIVE )
{
iState = 1;
}
if ( pPlayer )
{
UpdateBodygroups( pPlayer, iState );
}
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::VisibleInWeaponSelection( void )
{
if ( BaseClass::VisibleInWeaponSelection() == false )
{
return false;
}
if ( TFGameRules()->IsInTraining() )
{
ConVarRef training_can_select_weapon_primary ( "training_can_select_weapon_primary" );
ConVarRef training_can_select_weapon_secondary ( "training_can_select_weapon_secondary" );
ConVarRef training_can_select_weapon_melee ( "training_can_select_weapon_melee" );
ConVarRef training_can_select_weapon_building ( "training_can_select_weapon_building" );
ConVarRef training_can_select_weapon_pda ( "training_can_select_weapon_pda" );
ConVarRef training_can_select_weapon_item1 ( "training_can_select_weapon_item1" );
ConVarRef training_can_select_weapon_item2 ( "training_can_select_weapon_item2" );
bool bVisible = true;
switch ( GetTFWpnData().m_iWeaponType )
{
case TF_WPN_TYPE_PRIMARY: bVisible = training_can_select_weapon_primary.GetBool(); break;
case TF_WPN_TYPE_SECONDARY: bVisible = training_can_select_weapon_secondary.GetBool(); break;
case TF_WPN_TYPE_MELEE: bVisible = training_can_select_weapon_melee.GetBool(); break;
case TF_WPN_TYPE_BUILDING: bVisible = training_can_select_weapon_building.GetBool(); break;
case TF_WPN_TYPE_PDA: bVisible = training_can_select_weapon_pda.GetBool(); break;
case TF_WPN_TYPE_ITEM1: bVisible = training_can_select_weapon_item1.GetBool(); break;
case TF_WPN_TYPE_ITEM2: bVisible = training_can_select_weapon_item2.GetBool(); break;
} // switch
return bVisible;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::UpdateHiddenParentBodygroup( bool bHide )
{
#ifdef GAME_DLL
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if (!pPlayer)
return;
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
// Old style hidden bodygroups (weapon only):
int iHiddenBG = pItem->GetStaticData()->GetHiddenParentBodygroup( GetTeamNumber() );
if ( iHiddenBG != -1 )
{
pPlayer->SetBodygroup( iHiddenBG, bHide );
}
}
#endif
}
void CTFWeaponBase::Misfire( void )
{
CalcIsAttackCritical();
}
void CTFWeaponBase::FireFullClipAtOnce( void )
{
AssertMsg( 0, "weapon that has AutoFiresFullClipAllAtOnce should implement this function" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
void CTFWeaponBase::PrimaryAttack( void )
{
// Set the weapon mode.
m_iWeaponMode = TF_WEAPON_PRIMARY_MODE;
if ( !CanAttack() )
return;
BaseClass::PrimaryAttack();
if ( m_bReloadsSingly )
{
m_iReloadMode.Set( TF_RELOAD_START );
}
m_flLastPrimaryAttackTime = gpGlobals->curtime;
#ifdef STAGING_ONLY
// Remove Cond if I attack
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_NO_COMBAT_SPEED_BOOST ) )
{
pPlayer->m_Shared.RemoveCond( TF_COND_NO_COMBAT_SPEED_BOOST );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CTFWeaponBase::SecondaryAttack( void )
{
// Set the weapon mode.
m_iWeaponMode = TF_WEAPON_SECONDARY_MODE;
#ifdef STAGING_ONLY
// Remove Cond if I attack
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_NO_COMBAT_SPEED_BOOST ) )
{
pPlayer->m_Shared.RemoveCond( TF_COND_NO_COMBAT_SPEED_BOOST );
}
#endif
// Don't hook secondary for now.
return;
}
//-----------------------------------------------------------------------------
// Purpose: Most calls use the prediction seed
//-----------------------------------------------------------------------------
void CTFWeaponBase::CalcIsAttackCritical( void)
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return;
if ( gpGlobals->framecount == m_iLastCritCheckFrame )
return;
m_iLastCritCheckFrame = gpGlobals->framecount;
m_bCurrentCritIsRandom = false;
#if !defined( CLIENT_DLL )
// in training mode, the all bot team does not get crits
if ( TFGameRules()->IsInTraining() )
{
if ( pPlayer->IsBot() && TheTFBots().IsAllBotTeam( pPlayer->GetTeamNumber() ) )
{
// Support critboosted even in no crit mode
m_bCurrentAttackIsCrit = CalcIsAttackCriticalHelperNoCrits();
return;
}
}
if ( TFGameRules()->IsPVEModeActive() && TFGameRules()->IsPVEModeControlled( pPlayer ) )
{
// no crits for enemies in PvE
// Support critboosted even in no crit mode
m_bCurrentAttackIsCrit = CalcIsAttackCriticalHelperNoCrits();
return;
}
#endif
if ( (TFGameRules()->State_Get() == GR_STATE_TEAM_WIN) && (TFGameRules()->GetWinningTeam() == pPlayer->GetTeamNumber()) )
{
m_bCurrentAttackIsCrit = true;
}
else if ( !AreRandomCritsEnabled() )
{
// Support critboosted even in no crit mode
m_bCurrentAttackIsCrit = CalcIsAttackCriticalHelperNoCrits();
}
else
{
// call the weapon-specific helper method
m_bCurrentAttackIsCrit = CalcIsAttackCriticalHelper();
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CalcIsAttackCriticalHelperNoCrits()
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return false;
return pPlayer->m_Shared.IsCritBoosted();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ETFDmgCustom CTFWeaponBase::GetPenetrateType() const
{
int iMode = 0;
CALL_ATTRIB_HOOK_INT( iMode, projectile_penetration );
#ifdef STAGING_ONLY
// Prototype hack
if ( !iMode )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iMode, ability_master_sniper );
}
}
#endif // STAGING_ONLY
return iMode >= 1
? TF_DMG_CUSTOM_PENETRATE_ALL_PLAYERS
: TF_DMG_CUSTOM_NONE;
}
//-----------------------------------------------------------------------------
// Purpose: Weapon-specific helper method to calculate if attack is crit
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CalcIsAttackCriticalHelper()
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return false;
float flCritChance = 0.f;
float flPlayerCritMult = pPlayer->GetCritMult();
if ( !CanFireCriticalShot() )
return false;
// Crit boosted players fire all crits
if ( pPlayer->m_Shared.IsCritBoosted() )
return true;
// For rapid fire weapons, allow crits while period is active
bool bRapidFire = m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_bUseRapidFireCrits;
if ( bRapidFire && m_flCritTime > gpGlobals->curtime )
return true;
// --- Random crits from this point on ---
// Monitor and enforce short-term random crit rate - via bucket
// Figure out how much to add/remove from token bucket
int nProjectilesPerShot = m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_nBulletsPerShot;
if ( nProjectilesPerShot >= 1 )
{
CALL_ATTRIB_HOOK_FLOAT( nProjectilesPerShot, mult_bullets_per_shot );
}
else
{
nProjectilesPerShot = 1;
}
// Damage
float flDamage = m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_nDamage;
CALL_ATTRIB_HOOK_FLOAT( flDamage, mult_dmg );
flDamage *= nProjectilesPerShot;
AddToCritBucket( flDamage );
bool bCrit = false;
m_bCurrentCritIsRandom = true;
int iRandom = 0;
if ( bRapidFire )
{
// only perform one crit check per second for rapid fire weapons
if ( tf_weapon_criticals_nopred.GetBool() )
{
if ( gpGlobals->curtime < m_flLastRapidFireCritCheckTime + 1.f )
return false;
m_flLastRapidFireCritCheckTime = gpGlobals->curtime;
}
else
{
if ( gpGlobals->curtime < m_flLastCritCheckTime + 1.f )
return false;
m_flLastCritCheckTime = gpGlobals->curtime;
}
// get the total crit chance (ratio of total shots fired we want to be crits)
float flTotalCritChance = clamp( TF_DAMAGE_CRIT_CHANCE_RAPID * flPlayerCritMult, 0.01f, 0.99f );
// get the fixed amount of time that we start firing crit shots for
float flCritDuration = TF_DAMAGE_CRIT_DURATION_RAPID;
// calculate the amount of time, on average, that we want to NOT fire crit shots for in order to achieve the total crit chance we want
float flNonCritDuration = ( flCritDuration / flTotalCritChance ) - flCritDuration;
// calculate the chance per second of non-crit fire that we should transition into critting such that on average we achieve the total crit chance we want
float flStartCritChance = 1 / flNonCritDuration;
CALL_ATTRIB_HOOK_FLOAT( flStartCritChance, mult_crit_chance );
// if base entity seed has changed since last calculation, reseed with new seed
int iMask = ( entindex() << 8 ) | ( pPlayer->entindex() );
int iSeed = CBaseEntity::GetPredictionRandomSeed() ^ iMask;
if ( iSeed != m_iCurrentSeed )
{
m_iCurrentSeed = iSeed;
RandomSeed( m_iCurrentSeed );
}
// see if we should start firing crit shots
iRandom = RandomInt( 0, WEAPON_RANDOM_RANGE-1 );
if ( iRandom < flStartCritChance * WEAPON_RANDOM_RANGE )
{
bCrit = true;
flCritChance = flStartCritChance;
}
}
else
{
// single-shot weapon, just use random pct per shot
flCritChance = TF_DAMAGE_CRIT_CHANCE * flPlayerCritMult;
CALL_ATTRIB_HOOK_FLOAT( flCritChance, mult_crit_chance );
// mess with the crit chance seed so it's not based solely on the prediction seed
int iMask = ( entindex() << 8 ) | ( pPlayer->entindex() );
int iSeed = CBaseEntity::GetPredictionRandomSeed() ^ iMask;
if ( iSeed != m_iCurrentSeed )
{
m_iCurrentSeed = iSeed;
RandomSeed( m_iCurrentSeed );
}
iRandom = RandomInt( 0, WEAPON_RANDOM_RANGE - 1 );
bCrit = ( iRandom < flCritChance * WEAPON_RANDOM_RANGE );
}
#ifdef _DEBUG
if ( tf_weapon_criticals_debug.GetBool() )
{
#ifdef GAME_DLL
DevMsg( "Roll (server): %i out of %f (crit: %d)\n", iRandom, ( flCritChance * WEAPON_RANDOM_RANGE ), bCrit );
#else
if ( prediction->IsFirstTimePredicted() )
{
DevMsg( "\tRoll (client): %i out of %f (crit: %d)\n", iRandom, ( flCritChance * WEAPON_RANDOM_RANGE ), bCrit );
}
#endif // GAME_DLL
}
// Force seed to always say yes
if ( tf_weapon_criticals_force_random.GetInt() )
{
bCrit = true;
}
#endif // _DEBUG
// Track each check
#ifdef GAME_DLL
m_nCritChecks++;
#else
if ( prediction->IsFirstTimePredicted() )
{
m_nCritChecks++;
}
#endif // GAME_DLL
// Seed says crit. Run it by the manager.
if ( bCrit )
{
bool bAntiCheat = true;
#ifdef _DEBUG
bAntiCheat = tf_weapon_criticals_anticheat.GetBool();
#endif // _DEBUG
// Monitor and enforce long-term random crit rate - via stats
if ( bAntiCheat )
{
if ( !CanFireRandomCriticalShot( flCritChance ) )
return false;
// Make sure rapid fire weapons can pay the cost of the entire period up-front
if ( bRapidFire )
{
flDamage *= TF_DAMAGE_CRIT_DURATION_RAPID / m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flTimeFireDelay;
// Never try to drain more than cap
int nBucketCap = tf_weapon_criticals_bucket_cap.GetInt();
if ( flDamage * TF_DAMAGE_CRIT_MULTIPLIER > nBucketCap )
flDamage = (float)nBucketCap / TF_DAMAGE_CRIT_MULTIPLIER;
}
bCrit = IsAllowedToWithdrawFromCritBucket( flDamage );
}
if ( bCrit && bRapidFire )
{
m_flCritTime = gpGlobals->curtime + TF_DAMAGE_CRIT_DURATION_RAPID;
}
}
return bCrit;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this weapon has some ammo
//-----------------------------------------------------------------------------
bool CTFWeaponBase::HasAmmo( void )
{
if ( IsEnergyWeapon() )
return true;
else
return BaseClass::HasAmmo();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Reload( void )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return false;
if ( IsEnergyWeapon() && !Energy_FullyCharged() )
{
return ReloadSingly();
}
// If we're not already reloading, check to see if we have ammo to reload and check to see if we are max ammo.
if ( m_iReloadMode == TF_RELOAD_START )
{
// If I don't have any spare ammo, I can't reload
if ( GetOwner()->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
return false;
if ( !CanOverload() && Clip1() >= GetMaxClip1() )
return false;
}
// Reload one object at a time.
if ( m_bReloadsSingly )
return ReloadSingly();
// Normal reload.
DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::AbortReload( void )
{
BaseClass::AbortReload();
m_iReloadMode.Set( TF_RELOAD_START );
// Make sure our reloading bodygroup is hidden (shells/grenades/etc)
int indexR = FindBodygroupByName( "reload" );
if ( indexR >= 0 )
{
SetBodygroup( indexR, 0 );
}
}
//-----------------------------------------------------------------------------
// Is the weapon reloading right now?
bool CTFWeaponBase::IsReloading() const
{
return m_iReloadMode != TF_RELOAD_START;
}
bool CTFWeaponBase::AutoFiresFullClip( void ) const
{
int nAutoFiresFullClip = 0;
CALL_ATTRIB_HOOK_INT( nAutoFiresFullClip, auto_fires_full_clip );
return ( nAutoFiresFullClip != 0 );
}
bool CTFWeaponBase::AutoFiresFullClipAllAtOnce( void ) const
{
int nAutoFiresFullClipAllAtOnce = 0;
CALL_ATTRIB_HOOK_INT( nAutoFiresFullClipAllAtOnce, auto_fires_full_clip_all_at_once );
return ( nAutoFiresFullClipAllAtOnce != 0 );
}
bool CTFWeaponBase::CanOverload( void ) const
{
int nCanOverload = 0;
CALL_ATTRIB_HOOK_INT( nCanOverload, can_overload );
return ( nCanOverload != 0 );
}
float CTFWeaponBase::ApplyFireDelay( float flDelay ) const
{
float flDelayMult = 1.0f;
CALL_ATTRIB_HOOK_FLOAT( flDelayMult, mult_postfiredelay );
float flComboBoost = 0.0f;
CALL_ATTRIB_HOOK_FLOAT( flComboBoost, kill_combo_fire_rate_boost );
flComboBoost *= GetKillComboCount();
flDelayMult -= flComboBoost;
// Haste Powerup Rune adds multiplier to fire delay time
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( pPlayer && pPlayer->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
{
flDelayMult *= 0.5f;
}
else if ( pPlayer && ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_KING || pPlayer->m_Shared.InCond( TF_COND_KING_BUFFED ) ) )
{
flDelayMult *= 0.75f;
}
return flDelay * flDelayMult;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFWeaponBase::ReloadSingly( void )
{
// Don't reload.
if ( m_flNextPrimaryAttack > gpGlobals->curtime )
return false;
// Get the current player.
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return false;
// Anti Reload Cancelling Exploit (Beggers Bazooka)
// Force attack if we try to reload when we have ammo in the clip
if ( AutoFiresFullClip() && Clip1() > 0 && m_iReloadMode == TF_RELOAD_START )
{
PrimaryAttack();
m_bFiringWholeClip = true;
#ifdef CLIENT_DLL
pPlayer->SetFiredWeapon( true );
#endif
return false;
}
int nAutoFiresWhenFull = 0;
CALL_ATTRIB_HOOK_INT( nAutoFiresWhenFull, auto_fires_when_full );
if ( nAutoFiresWhenFull && ( Clip1() == GetMaxClip1() || pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 ) )
{
PrimaryAttack();
m_bFiringWholeClip = true;
#ifdef CLIENT_DLL
pPlayer->SetFiredWeapon( true );
#endif
return false;
}
// check to see if we're ready to reload
switch ( m_iReloadMode )
{
case TF_RELOAD_START:
{
// Play weapon and player animations.
if ( SendWeaponAnim( ACT_RELOAD_START ) )
{
SetReloadTimer( SequenceDuration() );
}
else
{
// Update the reload timers with script values.
UpdateReloadTimers( true );
}
// Next reload the shells.
m_iReloadMode.Set( TF_RELOADING );
m_iReloadStartClipAmount = Clip1();
return true;
}
case TF_RELOADING:
{
// Did we finish the reload start? Now we can reload a rocket.
if ( m_flTimeWeaponIdle > gpGlobals->curtime )
return false;
// Play weapon reload animations and sound.
if ( Clip1() == m_iReloadStartClipAmount )
{
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
}
else
{
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_LOOP );
}
m_bReloadedThroughAnimEvent = false;
if ( SendWeaponAnim( ACT_VM_RELOAD ) )
{
if ( GetWeaponID() == TF_WEAPON_GRENADELAUNCHER )
{
SetReloadTimer( GetTFWpnData().m_WeaponData[TF_WEAPON_PRIMARY_MODE].m_flTimeReload );
}
else
{
SetReloadTimer( SequenceDuration() );
}
}
else
{
// Update the reload timers.
UpdateReloadTimers( false );
}
// Play reload
#ifdef CLIENT_DLL
if ( ShouldPlayClientReloadSound() )
WeaponSound( RELOAD );
#else
WeaponSound( RELOAD );
#endif
// Next continue to reload shells?
m_iReloadMode.Set( TF_RELOADING_CONTINUE );
return true;
}
case TF_RELOADING_CONTINUE:
{
// Did we finish the reload start? Now we can finish reloading the rocket.
if ( m_flTimeWeaponIdle > gpGlobals->curtime )
return false;
IncrementAmmo();
if ( IsEnergyWeapon() )
{
if ( Energy_FullyCharged() )
{
m_iReloadMode.Set( TF_RELOAD_FINISH );
}
else
{
m_iReloadMode.Set( TF_RELOADING );
}
}
else
{
if ( ( !CanOverload() && ( Clip1() == GetMaxClip1() || pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 ) ) )
{
m_iReloadMode.Set( TF_RELOAD_FINISH );
}
else
{
m_iReloadMode.Set( TF_RELOADING );
}
}
return true;
}
case TF_RELOAD_FINISH:
default:
{
if ( SendWeaponAnim( ACT_RELOAD_FINISH ) )
{
// We're done, allow primary attack as soon as we like unless we're an energy weapon.
// if ( IsEnergyWeapon() )
// {
// SetReloadTimer( SequenceDuration() );
// }
}
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_END );
m_iReloadMode.Set( TF_RELOAD_START );
return true;
}
}
}
void CTFWeaponBase::IncrementAmmo( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
// If we have ammo, remove ammo and add it to clip
if ( !m_bReloadedThroughAnimEvent )
{
if ( IsEnergyWeapon() )
{
Energy_Recharge();
}
else if ( !CheckReloadMisfire() )
{
if ( pPlayer && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
{
m_iClip1 = MIN( ( m_iClip1 + 1 ), GetMaxClip1() );
pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEvent -
// *pOperator -
//-----------------------------------------------------------------------------
void CTFWeaponBase::Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator )
{
if ( (pEvent->type & AE_TYPE_NEWEVENTSYSTEM) /*&& (pEvent->type & AE_TYPE_SERVER)*/ )
{
if ( pEvent->event == AE_WPN_INCREMENTAMMO )
{
IncrementAmmo();
m_bReloadedThroughAnimEvent = true;
return;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFWeaponBase::GetInventoryModel( void )
{
// Return the world model when displaying this item in the inventory
const model_t *pWorldModel = modelinfo->GetModel( m_iWorldModelIndex );
if ( pWorldModel )
return modelinfo->GetModelName( pWorldModel );
return NULL;//BaseClass::GetInventoryModel();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::NeedsReloadForAmmo1( int iClipSize1 ) const
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner )
{
// If you don't have clips, then don't try to reload them.
if ( UsesClipsForAmmo1() )
{
// need to reload primary clip?
int primary = MIN( iClipSize1 - m_iClip1, pOwner->GetAmmoCount( m_iPrimaryAmmoType ) );
if ( primary != 0 )
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::NeedsReloadForAmmo2( int iClipSize2 ) const
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner )
{
if ( UsesClipsForAmmo2() )
{
// need to reload secondary clip?
int secondary = MIN( iClipSize2 - m_iClip2, pOwner->GetAmmoCount( m_iSecondaryAmmoType ) );
if ( secondary != 0 )
return true;
}
}
return false;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
bool CTFWeaponBase::DefaultReload( int iClipSize1, int iClipSize2, int iActivity )
{
// The the owning local player.
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return false;
// Setup and check for reload.
bool bReloadPrimary = NeedsReloadForAmmo1( iClipSize1 );
bool bReloadSecondary = NeedsReloadForAmmo2( iClipSize2 );
// We didn't reload.
if ( !( bReloadPrimary || bReloadSecondary ) )
return false;
// Play reload
#ifdef CLIENT_DLL
if ( ShouldPlayClientReloadSound() )
WeaponSound( RELOAD );
#else
WeaponSound( RELOAD );
#endif
// Play the player's reload animation
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
float flReloadTime;
// First, see if we have a reload animation
if ( SendWeaponAnim( iActivity ) )
{
// We consider the reload finished 0.2 sec before the anim is, so that players don't keep accidentally aborting their reloads
flReloadTime = SequenceDuration() - 0.2;
}
else
{
// No reload animation. Use the script time.
flReloadTime = GetTFWpnData().m_WeaponData[TF_WEAPON_PRIMARY_MODE].m_flTimeReload;
if ( bReloadSecondary )
{
flReloadTime = GetTFWpnData().m_WeaponData[TF_WEAPON_SECONDARY_MODE].m_flTimeReload;
}
}
SetReloadTimer( flReloadTime );
m_bInReload = true;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::UpdateReloadTimers( bool bStart )
{
// Starting a reload?
if ( bStart )
{
// Get the reload start time.
SetReloadTimer( m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flTimeReloadStart );
}
// In reload.
else
{
SetReloadTimer( m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flTimeReload );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::SetReloadTimer( float flReloadTime )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
float flBaseReloadTime = flReloadTime;
CALL_ATTRIB_HOOK_FLOAT( flReloadTime, mult_reload_time );
CALL_ATTRIB_HOOK_FLOAT( flReloadTime, mult_reload_time_hidden );
CALL_ATTRIB_HOOK_FLOAT( flReloadTime, fast_reload );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayer, flReloadTime, hwn_mult_reload_time );
//int iPanicAttack = 0;
//CALL_ATTRIB_HOOK_INT( iPanicAttack, panic_attack );
//if ( iPanicAttack )
//{
// if ( pPlayer->GetHealth() < pPlayer->GetMaxHealth() * 0.33f )
// {
// flReloadTime *= 0.3f;
// }
// else if ( pPlayer->GetHealth() < pPlayer->GetMaxHealth() * 0.66f )
// {
// flReloadTime *= 0.6f;
// }
//}
// Haste Powerup Rune adds multiplier to reload time
if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
{
flReloadTime *= 0.5f;
}
else if ( pPlayer->m_Shared.GetCarryingRuneType() == RUNE_KING || pPlayer->m_Shared.InCond( TF_COND_KING_BUFFED ) )
{
flReloadTime *= 0.75f;
}
int numHealers = pPlayer->m_Shared.GetNumHealers();
if ( numHealers == 1 )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayer, flReloadTime, mult_reload_time_while_healed );
}
flReloadTime = MAX( flReloadTime, 0.00001f );
if ( pPlayer->GetViewModel(0) )
{
pPlayer->GetViewModel(0)->SetPlaybackRate( flBaseReloadTime / flReloadTime );
}
if ( pPlayer->GetViewModel(1) )
{
pPlayer->GetViewModel(1)->SetPlaybackRate( flBaseReloadTime / flReloadTime );
}
m_flReloadPriorNextFire = m_flNextPrimaryAttack;
float flTime = gpGlobals->curtime + flReloadTime;
// Set next player attack time (weapon independent).
pPlayer->m_flNextAttack = flTime;
// Set next weapon attack times (based on reloading).
m_flNextPrimaryAttack = Max( flTime, (float)m_flReloadPriorNextFire);
// Don't push out secondary attack, because our secondary fire
// systems are all separate from primary fire (sniper zooming, demoman pipebomb detonating, etc)
//m_flNextSecondaryAttack = flTime;
// Set next idle time (based on reloading).
SetWeaponIdleTime( flTime );
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
bool CTFWeaponBase::PlayEmptySound()
{
CPASAttenuationFilter filter( this );
filter.UsePredictionRules();
// TFTODO: Add default empty sound here!
// EmitSound( filter, entindex(), "Default.ClipEmpty_Rifle" );
return false;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
void CTFWeaponBase::SendReloadEvents()
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
// Make the player play his reload animation.
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ItemBusyFrame( void )
{
// Call into the base ItemBusyFrame.
BaseClass::ItemBusyFrame();
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( !pOwner )
{
return;
}
if ( ( pOwner->m_nButtons & IN_ATTACK2 ) && /*m_bInReload == false &&*/ m_bInAttack2 == false )
{
pOwner->DoClassSpecialSkill();
m_bInAttack2 = true;
}
else if ( !(pOwner->m_nButtons & IN_ATTACK2) && m_bInAttack2 )
{
m_bInAttack2 = false;
}
// Interrupt a reload on reload singly weapons.
if ( ( pOwner->m_nButtons & IN_ATTACK ) && Clip1() > 0 )
{
bool bAbortReload = false;
if ( m_bReloadsSingly )
{
if ( m_iReloadMode != TF_RELOAD_START )
{
m_iReloadMode.Set( TF_RELOAD_START );
bAbortReload = true;
}
}
else if ( m_bInReload )
{
// We don't let them abort before the next fire point, so they can't use reload to fire before they would have fired if they hadn't reloaded
if ( gpGlobals->curtime >= m_flReloadPriorNextFire )
{
bAbortReload = true;
}
}
if ( bAbortReload )
{
AbortReload();
m_bInReload = false;
pOwner->m_flNextAttack = gpGlobals->curtime;
m_flNextPrimaryAttack = Max<float>( gpGlobals->curtime, m_flReloadPriorNextFire );
SetWeaponIdleTime( gpGlobals->curtime + m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flTimeIdle );
}
}
#ifdef GAME_DLL
// If we have an active-weapon-only regen, we accumulate regen time while active, so that
// they can't avoid the regen/degen by weapon switching rapidly.
ApplyItemRegen();
#endif
CheckEffectBarRegen();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ItemPostFrame( void )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( !pOwner )
{
return;
}
bool bNeedsReload = NeedsReloadForAmmo1( GetMaxClip1() ) || ( IsEnergyWeapon() && !Energy_FullyCharged() );
// If we're not shooting, and we want to autoreload, press our reload key
if ( !AutoFiresFullClip() && pOwner->ShouldAutoReload() && UsesClipsForAmmo1() && !(pOwner->m_nButtons & (IN_ATTACK|IN_ATTACK2)) && bNeedsReload )
{
pOwner->m_nButtons |= IN_RELOAD;
}
// debounce InAttack flags
if ( m_bInAttack && !( pOwner->m_nButtons & IN_ATTACK ) )
{
m_bInAttack = false;
}
if ( m_bInAttack2 && !( pOwner->m_nButtons & IN_ATTACK2 ) )
{
m_bInAttack2 = false;
}
#ifdef GAME_DLL
// If we have an active-weapon-only regen, we accumulate regen time while active, so that
// they can't avoid the regen/degen by weapon switching rapidly.
ApplyItemRegen();
#endif
CheckEffectBarRegen();
// If we're lowered, we're not allowed to fire
if ( m_bLowered )
return;
// Call the base item post frame.
BaseClass::ItemPostFrame();
// Check for reload singly interrupts.
if ( m_bReloadsSingly )
{
ReloadSinglyPostFrame();
}
if ( AutoFiresFullClip() && AutoFiresFullClipAllAtOnce() && m_iClip1 == GetMaxClip1() )
{
FireFullClipAtOnce();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFWeaponBase::GetInspectActivity( TFWeaponInspectStage inspectStage )
{
static int s_inspectActivities[][INSPECT_STAGE_COUNT] =
{
// LOADOUT_POSITION_PRIMARY
{
ACT_PRIMARY_VM_INSPECT_START,
ACT_PRIMARY_VM_INSPECT_IDLE,
ACT_PRIMARY_VM_INSPECT_END
},
//LOADOUT_POSITION_SECONDARY
{
ACT_SECONDARY_VM_INSPECT_START,
ACT_SECONDARY_VM_INSPECT_IDLE,
ACT_SECONDARY_VM_INSPECT_END
},
//LOADOUT_POSITION_MELEE
{
ACT_MELEE_VM_INSPECT_START,
ACT_MELEE_VM_INSPECT_IDLE,
ACT_MELEE_VM_INSPECT_END
},
};
loadout_positions_t iLoadoutSlot = LOADOUT_POSITION_INVALID;
CTFPlayer *pOwner = GetTFPlayerOwner();
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pOwner && pItem )
{
int iClass = pOwner->GetPlayerClass()->GetClassIndex();
iLoadoutSlot = (loadout_positions_t)pItem->GetStaticData()->GetLoadoutSlot( iClass );
}
if ( iLoadoutSlot < LOADOUT_POSITION_PRIMARY || iLoadoutSlot > LOADOUT_POSITION_MELEE )
{
// do primary animation for any loadout that we don't support yet
iLoadoutSlot = LOADOUT_POSITION_PRIMARY;
}
return s_inspectActivities[iLoadoutSlot][inspectStage];
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CanInspect() const
{
#ifdef STAGING_ONLY
if ( tf_weapon_force_allow_inspect.GetBool() )
return true;
#endif
float flInspect = 0.f;
CALL_ATTRIB_HOOK_FLOAT( flInspect, weapon_allow_inspect );
return flInspect != 0.f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::HandleInspect()
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( !CanInspect() )
return;
// first time pressing inspecting key
if ( !m_bInspecting && pPlayer->IsInspecting() )
{
m_nInspectStage = INSPECT_INVALID;
m_flInspectAnimTime = -1.f;
if ( SendWeaponAnim( GetInspectActivity( INSPECT_START ) ) )
{
m_flInspectAnimTime = gpGlobals->curtime + SequenceDuration();
m_nInspectStage = INSPECT_START;
}
}
else if ( !pPlayer->IsInspecting() && m_nInspectStage == INSPECT_IDLE )
{
// transition from idle to end when the inspect button is released
if ( SendWeaponAnim( GetInspectActivity( INSPECT_END ) ) )
{
m_flInspectAnimTime = gpGlobals->curtime + SequenceDuration();
m_nInspectStage = INSPECT_END;
}
}
else if ( m_nInspectStage != INSPECT_INVALID ) // inspecting
{
if ( gpGlobals->curtime > m_flInspectAnimTime )
{
if ( m_nInspectStage == INSPECT_START )
{
TFWeaponInspectStage inspectStage = pPlayer->IsInspecting() ? INSPECT_IDLE : INSPECT_END;
// transition from start to idle, or end if the inspect button is released
if ( SendWeaponAnim( GetInspectActivity( inspectStage ) ) )
{
m_flInspectAnimTime = gpGlobals->curtime + SequenceDuration();
m_nInspectStage = inspectStage;
}
}
else if ( m_nInspectStage == INSPECT_END )
{
m_flInspectAnimTime = -1.f;
m_nInspectStage = INSPECT_INVALID;
SendWeaponAnim( ACT_VM_IDLE );
}
}
}
m_bInspecting = pPlayer->IsInspecting();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ItemHolsterFrame( void )
{
BaseClass::ItemHolsterFrame();
CheckEffectBarRegen();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ReloadSinglyPostFrame( void )
{
if ( m_flTimeWeaponIdle > gpGlobals->curtime )
return;
// if the clip is empty and we have ammo remaining,
if ( IsEnergyWeapon() )
{
Reload();
}
else if ( ( !AutoFiresFullClip() && Clip1() == 0 && GetOwner()->GetAmmoCount( m_iPrimaryAmmoType ) > 0 ) ||
// or we are already in the process of reloading but not finished
( m_iReloadMode != TF_RELOAD_START ) )
{
// reload/continue reloading
Reload();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::WeaponShouldBeLowered( void )
{
// Can't be in the middle of another animation
if ( GetIdealActivity() != ACT_VM_IDLE_LOWERED && GetIdealActivity() != ACT_VM_IDLE &&
GetIdealActivity() != ACT_VM_IDLE_TO_LOWERED && GetIdealActivity() != ACT_VM_LOWERED_TO_IDLE )
return false;
if ( m_bLowered )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Ready( void )
{
// If we don't have the anim, just hide for now
if ( SelectWeightedSequence( ACT_VM_IDLE_LOWERED ) == ACTIVITY_NOT_AVAILABLE )
{
RemoveEffects( EF_NODRAW );
}
m_bLowered = false;
SendWeaponAnim( ACT_VM_IDLE );
// Prevent firing until our weapon is back up
CTFPlayer *pPlayer = GetTFPlayerOwner();
pPlayer->m_flNextAttack = gpGlobals->curtime + SequenceDuration();
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Lower( void )
{
AbortReload();
// If we don't have the anim, just hide for now
if ( SelectWeightedSequence( ACT_VM_IDLE_LOWERED ) == ACTIVITY_NOT_AVAILABLE )
{
AddEffects( EF_NODRAW );
}
m_bLowered = true;
SendWeaponAnim( ACT_VM_IDLE_LOWERED );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Show/hide weapon and corresponding view model if any
// Input : visible -
//-----------------------------------------------------------------------------
void CTFWeaponBase::SetWeaponVisible( bool visible )
{
if ( visible )
{
RemoveEffects( EF_NODRAW );
}
else
{
AddEffects( EF_NODRAW );
}
#ifdef CLIENT_DLL
UpdateVisibility();
// Force an update
PreDataUpdate( DATA_UPDATE_DATATABLE_CHANGED );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Allows the weapon to choose proper weapon idle animation
//-----------------------------------------------------------------------------
void CTFWeaponBase::WeaponIdle( void )
{
//See if we should idle high or low
if ( WeaponShouldBeLowered() )
{
// Move to lowered position if we're not there yet
if ( GetActivity() != ACT_VM_IDLE_LOWERED && GetActivity() != ACT_VM_IDLE_TO_LOWERED && GetActivity() != ACT_TRANSITION )
{
SendWeaponAnim( ACT_VM_IDLE_LOWERED );
}
else if ( HasWeaponIdleTimeElapsed() )
{
// Keep idling low
SendWeaponAnim( ACT_VM_IDLE_LOWERED );
}
}
else
{
// See if we need to raise immediately
if ( GetActivity() == ACT_VM_IDLE_LOWERED )
{
SendWeaponAnim( ACT_VM_IDLE );
}
else if ( HasWeaponIdleTimeElapsed() )
{
if ( !( m_bReloadsSingly && m_iReloadMode != TF_RELOAD_START ) )
{
SendWeaponAnim( ACT_VM_IDLE );
m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
}
#ifdef GAME_DLL
m_iHitsInTime = 1;
m_iFiredInTime = 1;
#endif // GAME_DLL
}
}
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
const char *CTFWeaponBase::GetMuzzleFlashModel( void )
{
const char *pszModel = GetTFWpnData().m_szMuzzleFlashModel;
if ( Q_strlen( pszModel ) > 0 )
{
return pszModel;
}
return NULL;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
const char *CTFWeaponBase::GetMuzzleFlashParticleEffect( void )
{
const char *pszPEffect = GetTFWpnData().m_szMuzzleFlashParticleEffect;
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
const char *pszItemMuzzleEffect = pItem->GetStaticData()->GetMuzzleFlash( GetTeamNumber() );
if ( pszItemMuzzleEffect )
{
pszPEffect = pszItemMuzzleEffect;
}
}
if ( Q_strlen( pszPEffect ) > 0 )
{
return pszPEffect;
}
return NULL;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
float CTFWeaponBase::GetMuzzleFlashModelLifetime( void )
{
return GetTFWpnData().m_flMuzzleFlashModelDuration;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFWeaponBase::GetTracerType( void )
{
const char* pszTracerEffect = GetTFWpnData().m_szTracerEffect;
if ( tf_useparticletracers.GetBool() )
{
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
// Look for a replacement effect specified in the item's visual attributes.
const char *pszItemTracerEffect = pItem->GetStaticData()->GetTracerEffect( GetTeamNumber() );
if ( pszItemTracerEffect )
{
pszTracerEffect = pszItemTracerEffect;
}
}
if ( pszTracerEffect && pszTracerEffect[0] )
{
if ( !m_szTracerName[0] )
{
Q_snprintf( m_szTracerName, MAX_TRACER_NAME, "%s_%s", pszTracerEffect,
(GetOwner() && GetOwner()->GetTeamNumber() == TF_TEAM_RED ) ? "red" : "blue" );
}
return m_szTracerName;
}
}
if ( GetWeaponID() == TF_WEAPON_MINIGUN )
return "BrightTracer";
return BaseClass::GetTracerType();
}
//=============================================================================
//
// TFWeaponBase functions (Server specific).
//
#if !defined( CLIENT_DLL )
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
void CTFWeaponBase::CheckRespawn()
{
// Do not respawn.
return;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
CBaseEntity *CTFWeaponBase::Respawn()
{
// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
// will decide when to make the weapon visible and touchable.
CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetAbsAngles(), GetOwner() );
if ( pNewWeapon )
{
pNewWeapon->AddEffects( EF_NODRAW );// invisible for now
pNewWeapon->SetTouch( NULL );// no touch
pNewWeapon->SetThink( &CTFWeaponBase::AttemptToMaterialize );
UTIL_DropToFloor( this, MASK_SOLID );
// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
// but when it should respawn is based on conditions belonging to the weapon that was taken.
pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );
}
else
{
Msg( "Respawn failed to create %s!\n", GetClassname() );
}
return pNewWeapon;
}
// -----------------------------------------------------------------------------
// Purpose: Make a weapon visible and tangible.
// -----------------------------------------------------------------------------
void CTFWeaponBase::Materialize()
{
if ( IsEffectActive( EF_NODRAW ) )
{
RemoveEffects( EF_NODRAW );
DoMuzzleFlash();
}
AddSolidFlags( FSOLID_TRIGGER );
SetThink ( &CTFWeaponBase::SUB_Remove );
SetNextThink( gpGlobals->curtime + 1 );
}
// -----------------------------------------------------------------------------
// Purpose: The item is trying to materialize, should it do so now or wait longer?
// -----------------------------------------------------------------------------
void CTFWeaponBase::AttemptToMaterialize()
{
float flTime = g_pGameRules->FlWeaponTryRespawn( this );
if ( flTime == 0 )
{
Materialize();
return;
}
SetNextThink( gpGlobals->curtime + flTime );
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
void CTFWeaponBase::SetDieThink( bool bDie )
{
if( bDie )
{
SetContextThink( &CTFWeaponBase::Die, gpGlobals->curtime + 30.0f, "DieContext" );
}
else
{
SetContextThink( NULL, gpGlobals->curtime, "DieContext" );
}
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
void CTFWeaponBase::Die( void )
{
UTIL_Remove( this );
}
void CTFWeaponBase::WeaponReset( void )
{
m_iReloadMode.Set( TF_RELOAD_START );
m_bResetParity = !m_bResetParity;
m_flEnergy = Energy_GetMaxEnergy();
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
const Vector &CTFWeaponBase::GetBulletSpread( void )
{
static Vector cone = VECTOR_CONE_15DEGREES;
return cone;
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
void CTFWeaponBase::OnBulletFire( int iEnemyPlayersHit )
{
if ( !iEnemyPlayersHit )
{
m_iConsecutiveKills = 0;
}
else
{
m_iHitsInTime++;
m_flLastHitTime = gpGlobals->curtime;
}
m_iFiredInTime++;
}
void CTFWeaponBase::OnPlayerKill( CTFPlayer *pVictim, const CTakeDamageInfo &info )
{
m_iConsecutiveKills++;
if ( pVictim )
{
int nClassIndex = pVictim->GetPlayerClass()->GetClassIndex();
float fKillComboFireRateBoost = 0.0f;
CALL_ATTRIB_HOOK_FLOAT( fKillComboFireRateBoost, kill_combo_fire_rate_boost );
if ( fKillComboFireRateBoost != 0.0f )
{
AddKillCombo( nClassIndex );
if ( GetKillComboCount() == 1 )
{
// Yell when we switch class combo type
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( pOwner )
{
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_COMBO_KILLED, CFmtStr( "victimclass:%s", g_aPlayerClassNames_NonLocalized[ nClassIndex ] ).Access() );
}
}
}
}
}
#else
void TE_DynamicLight( IRecipientFilter& filter, float delay,
const Vector* org, int r, int g, int b, int exponent, float radius, float time, float decay, int nLightIndex = LIGHT_INDEX_TE_DYNAMIC );
//=============================================================================
//
// TFWeaponBase functions (Client specific).
//
bool CTFWeaponBase::IsFirstPersonView()
{
C_TFPlayer *pPlayerOwner = GetTFPlayerOwner();
if ( pPlayerOwner == NULL )
{
return false;
}
return pPlayerOwner->InFirstPersonView();
}
bool CTFWeaponBase::UsingViewModel()
{
C_TFPlayer *pPlayerOwner = GetTFPlayerOwner();
bool bIsFirstPersonView = IsFirstPersonView();
bool bUsingViewModel = bIsFirstPersonView && ( pPlayerOwner != NULL ) && !pPlayerOwner->ShouldDrawThisPlayer();
return bUsingViewModel;
}
C_BaseAnimating *CTFWeaponBase::GetAppropriateWorldOrViewModel()
{
C_TFPlayer *pPlayerOwner = GetTFPlayerOwner();
if ( pPlayerOwner && UsingViewModel() )
{
// For w_* models the viewmodel itself is just arms+hands. And attached to them is the actual weapon.
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() && pItem->GetStaticData()->ShouldAttachToHands() )
{
C_BaseAnimating *pVMAttach = GetViewmodelAttachment();
if ( pVMAttach != NULL )
{
return pVMAttach;
}
}
// Nope - it's a standard viewmodel.
C_BaseAnimating *pViewModel = pPlayerOwner->GetViewModel();
if ( pViewModel != NULL )
{
return pViewModel;
}
// No viewmodel, so just return the normal model.
return this;
}
else
{
return this;
}
}
void CTFWeaponBase::CreateMuzzleFlashEffects( C_BaseEntity *pAttachEnt, int nIndex )
{
Vector vecOrigin;
QAngle angAngles;
if ( !pAttachEnt )
return;
if ( UsingViewModel() && !g_pClientMode->ShouldDrawViewModel() )
{
// Prevent effects when the ViewModel is hidden with r_drawviewmodel=0
return;
}
int iMuzzleFlashAttachment = pAttachEnt->LookupAttachment( "muzzle" );
const char *pszMuzzleFlashEffect = NULL;
const char *pszMuzzleFlashModel = GetMuzzleFlashModel();
const char *pszMuzzleFlashParticleEffect = GetMuzzleFlashParticleEffect();
// Pick the right muzzleflash (3rd / 1st person)
// (this uses IsFirstPersonView() rather than UsingViewModel() because even when NOT using the viewmodel, in 1st-person mode we still want the 1st-person muzzleflash effect)
if ( IsFirstPersonView() )
{
pszMuzzleFlashEffect = GetMuzzleFlashEffectName_1st();
}
else
{
pszMuzzleFlashEffect = GetMuzzleFlashEffectName_3rd();
}
// If we have an attachment, then stick a light on it.
if ( iMuzzleFlashAttachment > 0 && (pszMuzzleFlashEffect || pszMuzzleFlashModel || pszMuzzleFlashParticleEffect ) )
{
pAttachEnt->GetAttachment( iMuzzleFlashAttachment, vecOrigin, angAngles );
// Muzzleflash light
/*
CLocalPlayerFilter filter;
TE_DynamicLight( filter, 0.0f, &vecOrigin, 255, 192, 64, 5, 70.0f, 0.05f, 70.0f / 0.05f, LIGHT_INDEX_MUZZLEFLASH );
*/
if ( pszMuzzleFlashEffect )
{
// Using an muzzle flash dispatch effect
CEffectData muzzleFlashData;
muzzleFlashData.m_vOrigin = vecOrigin;
muzzleFlashData.m_vAngles = angAngles;
muzzleFlashData.m_hEntity = pAttachEnt->GetRefEHandle();
muzzleFlashData.m_nAttachmentIndex = iMuzzleFlashAttachment;
//muzzleFlashData.m_nHitBox = GetDODWpnData().m_iMuzzleFlashType;
//muzzleFlashData.m_flMagnitude = GetDODWpnData().m_flMuzzleFlashScale;
muzzleFlashData.m_flMagnitude = 0.2;
DispatchEffect( pszMuzzleFlashEffect, muzzleFlashData );
}
if ( pszMuzzleFlashModel )
{
float flEffectLifetime = GetMuzzleFlashModelLifetime();
// Using a model as a muzzle flash.
if ( m_hMuzzleFlashModel[nIndex] )
{
// Increase the lifetime of the muzzleflash
m_hMuzzleFlashModel[nIndex]->SetLifetime( flEffectLifetime );
}
else
{
m_hMuzzleFlashModel[nIndex] = C_MuzzleFlashModel::CreateMuzzleFlashModel( pszMuzzleFlashModel, pAttachEnt, iMuzzleFlashAttachment, flEffectLifetime );
// FIXME: This is an incredibly brutal hack to get muzzle flashes positioned correctly for recording
m_hMuzzleFlashModel[nIndex]->SetIs3rdPersonFlash( nIndex == 1 );
}
}
if ( pszMuzzleFlashParticleEffect )
{
DispatchMuzzleFlash( pszMuzzleFlashParticleEffect, pAttachEnt );
}
}
}
void CTFWeaponBase::DispatchMuzzleFlash( const char* effectName, C_BaseEntity* pAttachEnt )
{
DispatchParticleEffect( effectName, PATTACH_POINT_FOLLOW, pAttachEnt, "muzzle" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::ShouldDraw( void )
{
C_BaseCombatCharacter *pOwner = GetOwner();
if ( !pOwner )
return true;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return true;
if ( pOwner->IsPlayer() )
{
CTFPlayer *pTFOwner = ToTFPlayer( GetOwner() );
if ( !pTFOwner )
return true;
if ( pTFOwner->m_Shared.IsControlStunned() )
return false;
// Ghosts dont have weapons
if ( pTFOwner->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
return false;
if ( pTFOwner->m_Shared.GetDisguiseWeapon() )
{
if ( pTFOwner->m_Shared.InCond( TF_COND_DISGUISED ) )
{
int iLocalPlayerTeam = pLocalPlayer->GetTeamNumber();
if ( pLocalPlayer->m_bIsCoaching && pLocalPlayer->m_hStudent )
{
iLocalPlayerTeam = pLocalPlayer->m_hStudent->GetTeamNumber();
}
// If we are disguised we may want to draw the disguise weapon.
if ( iLocalPlayerTeam != pOwner->GetTeamNumber() && (iLocalPlayerTeam != TEAM_SPECTATOR) )
{
// We are a disguised enemy, so only draw the disguise weapon.
if ( pTFOwner->m_Shared.GetDisguiseWeapon() != this )
{
return false;
}
}
else
{
// We are a disguised friendly. Don't draw the disguise weapon.
if ( m_bDisguiseWeapon )
{
return false;
}
}
}
else
{
// We are not disguised. Never draw the disguise weapon.
if ( m_bDisguiseWeapon )
{
return false;
}
}
}
}
return BaseClass::ShouldDraw();
}
void CTFWeaponBase::UpdateVisibility( void )
{
BaseClass::UpdateVisibility();
UpdateExtraWearablesVisibility();
C_TFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( pOwner )
{
pOwner->SetBodygroupsDirty();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFWeaponBase::InternalDrawModel( int flags )
{
C_TFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
bool bNotViewModel = ( pOwner->ShouldDrawThisPlayer() );
bool bUseInvulnMaterial = ( bNotViewModel && pOwner && pOwner->m_Shared.IsInvulnerable() &&
( !pOwner->m_Shared.InCond( TF_COND_INVULNERABLE_HIDE_UNLESS_DAMAGED ) || gpGlobals->curtime < pOwner->GetLastDamageTime() + 2.0f ) );
if ( bUseInvulnMaterial )
{
modelrender->ForcedMaterialOverride( *pOwner->GetInvulnMaterialRef() );
}
int ret = BaseClass::InternalDrawModel( flags );
if ( bUseInvulnMaterial )
{
modelrender->ForcedMaterialOverride( NULL );
}
return ret;
}
void CTFWeaponBase::ProcessMuzzleFlashEvent( void )
{
C_BaseAnimating *pAttachEnt = GetAppropriateWorldOrViewModel();
C_TFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( pOwner == NULL )
return;
bool bDrawMuzzleFlashOnViewModel = ( pAttachEnt != this );
{
CRecordEffectOwner recordOwner( pOwner, bDrawMuzzleFlashOnViewModel );
CreateMuzzleFlashEffects( pAttachEnt, 0 );
}
// Quasi-evil
int nModelIndex = GetModelIndex();
int nWorldModelIndex = GetWorldModelIndex();
bool bInToolRecordingMode = ToolsEnabled() && clienttools->IsInRecordingMode();
if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex && pOwner->IsLocalPlayer() )
{
CRecordEffectOwner recordOwner( pOwner, false );
SetModelIndex( nWorldModelIndex );
CreateMuzzleFlashEffects( this, 1 );
SetModelIndex( nModelIndex );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
bool CTFWeaponBase::ShouldPredict()
{
if ( GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer() )
{
return true;
}
return BaseClass::ShouldPredict();
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
void CTFWeaponBase::WeaponReset( void )
{
UpdateVisibility();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : updateType -
//-----------------------------------------------------------------------------
void CTFWeaponBase::PostDataUpdate( DataUpdateType_t updateType )
{
// We need to do this before the C_BaseAnimating code starts to drive
// clientside animation sequences on this model, which will be using bad sequences for the world model.
int iDesiredModelIndex = 0;
C_BasePlayer *pOwner = ToBasePlayer(GetOwner());
if ( !pOwner->ShouldDrawThisPlayer() )
{
iDesiredModelIndex = m_iViewModelIndex;
}
else
{
iDesiredModelIndex = GetWorldModelIndex();
// Our world models never animate
SetSequence( 0 );
}
if ( GetModelIndex() != iDesiredModelIndex )
{
SetModelIndex( iDesiredModelIndex );
}
BaseClass::PostDataUpdate( updateType );
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
void CTFWeaponBase::OnPreDataChanged( DataUpdateType_t type )
{
BaseClass::OnPreDataChanged( type );
m_bOldResetParity = m_bResetParity;
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
void CTFWeaponBase::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_CREATED )
{
ListenForGameEvent( "localplayer_changeteam" );
}
if ( GetPredictable() && !ShouldPredict() )
{
ShutdownPredictable();
}
//If its a world (held or dropped) model then set the correct skin color here.
if ( m_nModelIndex == GetWorldModelIndex() )
{
m_nSkin = GetSkin();
}
if ( m_bResetParity != m_bOldResetParity )
{
WeaponReset();
}
//Here we go...
//Since we can't get a repro for the invisible weapon thing, I'll fix it right up here:
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
// Our owner is alive and not a loser.
if ( pOwner && pOwner->IsAlive() && !pOwner->m_Shared.IsLoser() && !pOwner->m_Shared.InCond( TF_COND_COMPETITIVE_LOSER ) && ( pOwner->GetActiveWeapon() == this ) )
{
// And he is NOT taunting or control stunned.
if ( !pOwner->m_Shared.InCond ( TF_COND_TAUNTING ) && !pOwner->m_Shared.InCond ( TF_COND_HALLOWEEN_KART ) &&
(!pOwner->m_Shared.IsControlStunned() || !pOwner->m_Shared.IsLoserStateStunned() || !HideWhileStunned()) )
{
if ( IsEffectActive( EF_NODRAW ) )
{
RemoveEffects( EF_NODRAW );
UpdateVisibility();
}
}
}
UpdateParticleSystems();
if ( m_iOldTeam != m_iTeamNum )
{
// Recompute our tracer name
m_szTracerName[0] = '\0';
}
//if ( m_hExtraWearable.Get() && m_hExtraWearable->IsVisible() != IsVisible() )
if ( m_hExtraWearable.Get() )
{
m_hExtraWearable->UpdateVisibility();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::FireGameEvent( IGameEvent *event )
{
// If we were the active weapon, we need to update our visibility
// because we may switch visibility due to Spy disguises.
const char *pszEventName = event->GetName();
if ( Q_strcmp( pszEventName, "localplayer_changeteam" ) == 0 )
{
UpdateVisibility();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// ----------------------------------------------------------------------------
int CTFWeaponBase::GetWorldModelIndex( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
// Guitar Riff taunt support.
if ( pPlayer )
{
bool bReplaceModel = true;
const char* pszCustomTauntProp = NULL;
if ( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) && ( pPlayer->m_Shared.GetTauntIndex() == TAUNT_MISC_ITEM || pPlayer->m_Shared.GetTauntIndex() == TAUNT_LONG ) )
{
int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
CEconItemView *pMiscItemView = pPlayer->GetTauntEconItemView();
if ( pMiscItemView && pMiscItemView->GetStaticData()->GetTauntData() )
{
// if prop has its own animation, don't replace weapon model
if ( !pMiscItemView->GetStaticData()->GetTauntData()->GetPropIntroScene( iClass ) )
{
pszCustomTauntProp = pMiscItemView->GetStaticData()->GetTauntData()->GetProp( iClass );
}
}
}
if ( pszCustomTauntProp )
{
m_iWorldModelIndex = modelinfo->GetModelIndex( pszCustomTauntProp );
}
else
{
bReplaceModel = false;
}
if ( bReplaceModel )
{
return m_iWorldModelIndex;
}
}
if ( m_iCachedModelIndex == 0 )
{
// Remember our normal world model index so we can quickly replace it later.
m_iCachedModelIndex = modelinfo->GetModelIndex( GetWorldModel() );
}
// We aren't taunting, so we want to use the cached model index.
if ( m_iWorldModelIndex != m_iCachedModelIndex )
{
m_iWorldModelIndex = m_iCachedModelIndex;
}
if ( IsEffectActive( EF_NODRAW ) && ShouldDraw() ) // Early-out if we are visible.
{
// Some taunts (guitar, bubble wand, etc.) hide us at the end of the animation.
// We want to re-enable drawing if we should be drawing now but aren't.
SetWeaponVisible( true );
}
if ( pPlayer )
{
// if we're a spy and we're disguised, we also
// want to disguise our weapon's world model
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return 0;
int iLocalTeam = pLocalPlayer->GetTeamNumber();
// We only show disguise weapon to the enemy team when owner is disguised
bool bUseDisguiseWeapon = ( pPlayer->GetTeamNumber() != iLocalTeam && iLocalTeam > LAST_SHARED_TEAM );
if ( bUseDisguiseWeapon && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
{
CTFWeaponBase *pDisguiseWeapon = pPlayer->m_Shared.GetDisguiseWeapon();
if ( !pDisguiseWeapon )
return BaseClass::GetWorldModelIndex();
if ( pDisguiseWeapon == this )
return BaseClass::GetWorldModelIndex();
else
return pDisguiseWeapon->GetWorldModelIndex();
}
}
return BaseClass::GetWorldModelIndex();
}
bool CTFWeaponBase::ShouldDrawCrosshair( void )
{
const char *crosshairfile = cl_crosshair_file.GetString();
if ( !crosshairfile || !crosshairfile[0] )
{
// Default crosshair.
return GetTFWpnData().m_WeaponData[TF_WEAPON_PRIMARY_MODE].m_bDrawCrosshair;
}
// Custom crosshair.
return true;
}
void CTFWeaponBase::Redraw()
{
if ( ShouldDrawCrosshair() && g_pClientMode->ShouldDrawCrosshair() )
{
DrawCrosshair();
}
}
#endif
acttable_t s_acttablePrimary[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_PRIMARY, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_PRIMARY, false },
{ ACT_MP_DEPLOYED, ACT_MP_DEPLOYED_PRIMARY, false },
{ ACT_MP_CROUCH_DEPLOYED, ACT_MP_CROUCHWALK_DEPLOYED, false },
{ ACT_MP_CROUCH_DEPLOYED_IDLE, ACT_MP_CROUCH_DEPLOYED_IDLE, false },
{ ACT_MP_RUN, ACT_MP_RUN_PRIMARY, false },
{ ACT_MP_WALK, ACT_MP_WALK_PRIMARY, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_PRIMARY, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_PRIMARY, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_PRIMARY, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_PRIMARY, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_PRIMARY, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_PRIMARY, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_PRIMARY, false },
{ ACT_MP_SWIM_DEPLOYED, ACT_MP_SWIM_DEPLOYED_PRIMARY, false },
{ ACT_MP_DOUBLEJUMP_CROUCH, ACT_MP_DOUBLEJUMP_CROUCH_PRIMARY, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_PRIMARY, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE_DEPLOYED, ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_PRIMARY, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE_DEPLOYED, ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_PRIMARY, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_PRIMARY, false },
{ ACT_MP_RELOAD_STAND, ACT_MP_RELOAD_STAND_PRIMARY, false },
{ ACT_MP_RELOAD_STAND_LOOP, ACT_MP_RELOAD_STAND_PRIMARY_LOOP, false },
{ ACT_MP_RELOAD_STAND_END, ACT_MP_RELOAD_STAND_PRIMARY_END, false },
{ ACT_MP_RELOAD_CROUCH, ACT_MP_RELOAD_CROUCH_PRIMARY, false },
{ ACT_MP_RELOAD_CROUCH_LOOP,ACT_MP_RELOAD_CROUCH_PRIMARY_LOOP, false },
{ ACT_MP_RELOAD_CROUCH_END, ACT_MP_RELOAD_CROUCH_PRIMARY_END, false },
{ ACT_MP_RELOAD_SWIM, ACT_MP_RELOAD_SWIM_PRIMARY, false },
{ ACT_MP_RELOAD_SWIM_LOOP, ACT_MP_RELOAD_SWIM_PRIMARY_LOOP, false },
{ ACT_MP_RELOAD_SWIM_END, ACT_MP_RELOAD_SWIM_PRIMARY_END, false },
{ ACT_MP_RELOAD_AIRWALK, ACT_MP_RELOAD_AIRWALK_PRIMARY, false },
{ ACT_MP_RELOAD_AIRWALK_LOOP, ACT_MP_RELOAD_AIRWALK_PRIMARY_LOOP, false },
{ ACT_MP_RELOAD_AIRWALK_END,ACT_MP_RELOAD_AIRWALK_PRIMARY_END, false },
{ ACT_MP_GESTURE_FLINCH, ACT_MP_GESTURE_FLINCH_PRIMARY, false },
{ ACT_MP_GRENADE1_DRAW, ACT_MP_PRIMARY_GRENADE1_DRAW, false },
{ ACT_MP_GRENADE1_IDLE, ACT_MP_PRIMARY_GRENADE1_IDLE, false },
{ ACT_MP_GRENADE1_ATTACK, ACT_MP_PRIMARY_GRENADE1_ATTACK, false },
{ ACT_MP_GRENADE2_DRAW, ACT_MP_PRIMARY_GRENADE2_DRAW, false },
{ ACT_MP_GRENADE2_IDLE, ACT_MP_PRIMARY_GRENADE2_IDLE, false },
{ ACT_MP_GRENADE2_ATTACK, ACT_MP_PRIMARY_GRENADE2_ATTACK, false },
{ ACT_MP_ATTACK_STAND_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_CROUCH_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_SWIM_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_AIRWALK_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_PRIMARY, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_PRIMARY, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_PRIMARY, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_PRIMARY, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_PRIMARY, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_PRIMARY, false },
};
acttable_t s_acttableSecondary[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_SECONDARY, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_SECONDARY, false },
{ ACT_MP_RUN, ACT_MP_RUN_SECONDARY, false },
{ ACT_MP_WALK, ACT_MP_WALK_SECONDARY, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_SECONDARY, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_SECONDARY, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_SECONDARY, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_SECONDARY, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_SECONDARY, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_SECONDARY, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_SECONDARY, false },
{ ACT_MP_DOUBLEJUMP_CROUCH, ACT_MP_DOUBLEJUMP_CROUCH_SECONDARY, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_SECONDARY, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_SECONDARY, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_SECONDARY, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_SECONDARY, false },
{ ACT_MP_RELOAD_STAND, ACT_MP_RELOAD_STAND_SECONDARY, false },
{ ACT_MP_RELOAD_STAND_LOOP, ACT_MP_RELOAD_STAND_SECONDARY_LOOP, false },
{ ACT_MP_RELOAD_STAND_END, ACT_MP_RELOAD_STAND_SECONDARY_END, false },
{ ACT_MP_RELOAD_CROUCH, ACT_MP_RELOAD_CROUCH_SECONDARY, false },
{ ACT_MP_RELOAD_CROUCH_LOOP,ACT_MP_RELOAD_CROUCH_SECONDARY_LOOP,false },
{ ACT_MP_RELOAD_CROUCH_END, ACT_MP_RELOAD_CROUCH_SECONDARY_END, false },
{ ACT_MP_RELOAD_SWIM, ACT_MP_RELOAD_SWIM_SECONDARY, false },
{ ACT_MP_RELOAD_SWIM_LOOP, ACT_MP_RELOAD_SWIM_SECONDARY_LOOP, false },
{ ACT_MP_RELOAD_SWIM_END, ACT_MP_RELOAD_SWIM_SECONDARY_END, false },
{ ACT_MP_RELOAD_AIRWALK, ACT_MP_RELOAD_AIRWALK_SECONDARY, false },
{ ACT_MP_RELOAD_AIRWALK_LOOP, ACT_MP_RELOAD_AIRWALK_SECONDARY_LOOP, false },
{ ACT_MP_RELOAD_AIRWALK_END,ACT_MP_RELOAD_AIRWALK_SECONDARY_END,false },
{ ACT_MP_GESTURE_FLINCH, ACT_MP_GESTURE_FLINCH_SECONDARY, false },
{ ACT_MP_GRENADE1_DRAW, ACT_MP_SECONDARY_GRENADE1_DRAW, false },
{ ACT_MP_GRENADE1_IDLE, ACT_MP_SECONDARY_GRENADE1_IDLE, false },
{ ACT_MP_GRENADE1_ATTACK, ACT_MP_SECONDARY_GRENADE1_ATTACK, false },
{ ACT_MP_GRENADE2_DRAW, ACT_MP_SECONDARY_GRENADE2_DRAW, false },
{ ACT_MP_GRENADE2_IDLE, ACT_MP_SECONDARY_GRENADE2_IDLE, false },
{ ACT_MP_GRENADE2_ATTACK, ACT_MP_SECONDARY_GRENADE2_ATTACK, false },
{ ACT_MP_ATTACK_STAND_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_CROUCH_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_SWIM_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_AIRWALK_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_SECONDARY, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_SECONDARY, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_SECONDARY, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_SECONDARY, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_SECONDARY, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_SECONDARY, false },
};
acttable_t s_acttablePrimary2[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_PRIMARY, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_PRIMARY, false },
{ ACT_MP_DEPLOYED, ACT_MP_DEPLOYED_PRIMARY, false },
{ ACT_MP_CROUCH_DEPLOYED, ACT_MP_CROUCHWALK_DEPLOYED, false },
{ ACT_MP_CROUCH_DEPLOYED_IDLE, ACT_MP_CROUCH_DEPLOYED_IDLE, false },
{ ACT_MP_RUN, ACT_MP_RUN_PRIMARY, false },
{ ACT_MP_WALK, ACT_MP_WALK_PRIMARY, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_PRIMARY, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_PRIMARY, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_PRIMARY, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_PRIMARY, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_PRIMARY, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_PRIMARY, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_PRIMARY, false },
{ ACT_MP_SWIM_DEPLOYED, ACT_MP_SWIM_DEPLOYED_PRIMARY, false },
{ ACT_MP_DOUBLEJUMP_CROUCH, ACT_MP_DOUBLEJUMP_CROUCH_PRIMARY, false },
{ ACT_MP_ATTACK_STAND_PRIMARY_SUPER, ACT_MP_ATTACK_STAND_PRIMARY_SUPER, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARY_SUPER, ACT_MP_ATTACK_CROUCH_PRIMARY_SUPER, false },
{ ACT_MP_ATTACK_SWIM_PRIMARY_SUPER, ACT_MP_ATTACK_SWIM_PRIMARY_SUPER, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_PRIMARY_ALT, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_PRIMARY_ALT, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_PRIMARY_ALT, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_PRIMARY, false },
{ ACT_MP_RELOAD_STAND, ACT_MP_RELOAD_STAND_PRIMARY_ALT, false },
{ ACT_MP_RELOAD_STAND_LOOP, ACT_MP_RELOAD_STAND_PRIMARY_LOOP_ALT, false },
{ ACT_MP_RELOAD_STAND_END, ACT_MP_RELOAD_STAND_PRIMARY_END_ALT, false },
{ ACT_MP_RELOAD_CROUCH, ACT_MP_RELOAD_CROUCH_PRIMARY_ALT, false },
{ ACT_MP_RELOAD_CROUCH_LOOP,ACT_MP_RELOAD_CROUCH_PRIMARY_LOOP_ALT, false },
{ ACT_MP_RELOAD_CROUCH_END, ACT_MP_RELOAD_CROUCH_PRIMARY_END_ALT, false },
{ ACT_MP_RELOAD_SWIM, ACT_MP_RELOAD_SWIM_PRIMARY_ALT, false },
{ ACT_MP_RELOAD_SWIM_LOOP, ACT_MP_RELOAD_SWIM_PRIMARY_LOOP, false },
{ ACT_MP_RELOAD_SWIM_END, ACT_MP_RELOAD_SWIM_PRIMARY_END, false },
{ ACT_MP_RELOAD_AIRWALK, ACT_MP_RELOAD_AIRWALK_PRIMARY_ALT, false },
{ ACT_MP_RELOAD_AIRWALK_LOOP, ACT_MP_RELOAD_AIRWALK_PRIMARY_LOOP_ALT, false },
{ ACT_MP_RELOAD_AIRWALK_END,ACT_MP_RELOAD_AIRWALK_PRIMARY_END_ALT, false },
{ ACT_MP_ATTACK_STAND_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_CROUCH_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_SWIM_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_AIRWALK_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_PRIMARY, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_PRIMARY, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_PRIMARY, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_PRIMARY, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_PRIMARY, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_PRIMARY, false },
};
acttable_t s_acttableSecondary2[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_SECONDARY2, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_SECONDARY2, false },
{ ACT_MP_RUN, ACT_MP_RUN_SECONDARY2, false },
{ ACT_MP_WALK, ACT_MP_WALK_SECONDARY2, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_SECONDARY2, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_SECONDARY2, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_SECONDARY2, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_SECONDARY2, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_SECONDARY2, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_SECONDARY2, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_SECONDARY2, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_SECONDARY2, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_SECONDARY2, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_SECONDARY2, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_SECONDARY2, false },
{ ACT_MP_RELOAD_STAND, ACT_MP_RELOAD_STAND_SECONDARY2, false },
{ ACT_MP_RELOAD_STAND_LOOP, ACT_MP_RELOAD_STAND_SECONDARY2_LOOP, false },
{ ACT_MP_RELOAD_STAND_END, ACT_MP_RELOAD_STAND_SECONDARY2_END, false },
{ ACT_MP_RELOAD_CROUCH, ACT_MP_RELOAD_CROUCH_SECONDARY2, false },
{ ACT_MP_RELOAD_CROUCH_LOOP,ACT_MP_RELOAD_CROUCH_SECONDARY2_LOOP,false },
{ ACT_MP_RELOAD_CROUCH_END, ACT_MP_RELOAD_CROUCH_SECONDARY2_END, false },
{ ACT_MP_RELOAD_SWIM, ACT_MP_RELOAD_SWIM_SECONDARY2, false },
{ ACT_MP_RELOAD_SWIM_LOOP, ACT_MP_RELOAD_SWIM_SECONDARY2_LOOP, false },
{ ACT_MP_RELOAD_SWIM_END, ACT_MP_RELOAD_SWIM_SECONDARY2_END, false },
{ ACT_MP_RELOAD_AIRWALK, ACT_MP_RELOAD_AIRWALK_SECONDARY2, false },
{ ACT_MP_RELOAD_AIRWALK_LOOP, ACT_MP_RELOAD_AIRWALK_SECONDARY2_LOOP, false },
{ ACT_MP_RELOAD_AIRWALK_END,ACT_MP_RELOAD_AIRWALK_SECONDARY2_END,false },
{ ACT_MP_ATTACK_STAND_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_CROUCH_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_SWIM_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_ATTACK_AIRWALK_GRENADE, ACT_MP_ATTACK_STAND_GRENADE, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_SECONDARY, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_SECONDARY, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_SECONDARY, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_SECONDARY, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_SECONDARY, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_SECONDARY, false },
};
acttable_t s_acttableMelee[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_MELEE, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_MELEE, false },
{ ACT_MP_RUN, ACT_MP_RUN_MELEE, false },
{ ACT_MP_WALK, ACT_MP_WALK_MELEE, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_MELEE, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_MELEE, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_MELEE, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_MELEE, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_MELEE, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_MELEE, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_MELEE, false },
{ ACT_MP_DOUBLEJUMP_CROUCH, ACT_MP_DOUBLEJUMP_CROUCH_MELEE, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_MELEE, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_MELEE, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_MELEE, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_MELEE, false },
{ ACT_MP_ATTACK_STAND_SECONDARYFIRE, ACT_MP_ATTACK_STAND_MELEE_SECONDARY, false },
{ ACT_MP_ATTACK_CROUCH_SECONDARYFIRE, ACT_MP_ATTACK_CROUCH_MELEE_SECONDARY,false },
{ ACT_MP_ATTACK_SWIM_SECONDARYFIRE, ACT_MP_ATTACK_SWIM_MELEE, false },
{ ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE, ACT_MP_ATTACK_AIRWALK_MELEE, false },
{ ACT_MP_GESTURE_FLINCH, ACT_MP_GESTURE_FLINCH_MELEE, false },
{ ACT_MP_GRENADE1_DRAW, ACT_MP_MELEE_GRENADE1_DRAW, false },
{ ACT_MP_GRENADE1_IDLE, ACT_MP_MELEE_GRENADE1_IDLE, false },
{ ACT_MP_GRENADE1_ATTACK, ACT_MP_MELEE_GRENADE1_ATTACK, false },
{ ACT_MP_GRENADE2_DRAW, ACT_MP_MELEE_GRENADE2_DRAW, false },
{ ACT_MP_GRENADE2_IDLE, ACT_MP_MELEE_GRENADE2_IDLE, false },
{ ACT_MP_GRENADE2_ATTACK, ACT_MP_MELEE_GRENADE2_ATTACK, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_MELEE, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_MELEE, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_MELEE, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_MELEE, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_MELEE, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_MELEE, false },
};
acttable_t s_acttableItem1[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_ITEM1, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_ITEM1, false },
{ ACT_MP_RUN, ACT_MP_RUN_ITEM1, false },
{ ACT_MP_WALK, ACT_MP_WALK_ITEM1, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_ITEM1, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_ITEM1, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_ITEM1, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_ITEM1, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_ITEM1, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_ITEM1, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_ITEM1, false },
{ ACT_MP_DOUBLEJUMP_CROUCH, ACT_MP_DOUBLEJUMP_CROUCH_ITEM1, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_ITEM1, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_ITEM1, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_ITEM1, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_ITEM1, false },
{ ACT_MP_ATTACK_STAND_SECONDARYFIRE, ACT_MP_ATTACK_STAND_ITEM1_SECONDARY, false },
{ ACT_MP_ATTACK_CROUCH_SECONDARYFIRE, ACT_MP_ATTACK_CROUCH_ITEM1_SECONDARY,false },
{ ACT_MP_ATTACK_SWIM_SECONDARYFIRE, ACT_MP_ATTACK_SWIM_ITEM1, false },
{ ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE, ACT_MP_ATTACK_AIRWALK_ITEM1, false },
{ ACT_MP_DEPLOYED, ACT_MP_DEPLOYED_ITEM1, false },
{ ACT_MP_DEPLOYED_IDLE, ACT_MP_DEPLOYED_IDLE_ITEM1, false },
{ ACT_MP_CROUCH_DEPLOYED, ACT_MP_CROUCHWALK_DEPLOYED_ITEM1, false },
{ ACT_MP_CROUCH_DEPLOYED_IDLE, ACT_MP_CROUCH_DEPLOYED_IDLE_ITEM1, false },
//{ ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED, ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED_ITEM1, false },
//{ ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED,ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED_ITEM1, false },
{ ACT_MP_GESTURE_FLINCH, ACT_MP_GESTURE_FLINCH_ITEM1, false },
{ ACT_MP_GRENADE1_DRAW, ACT_MP_ITEM1_GRENADE1_DRAW, false },
{ ACT_MP_GRENADE1_IDLE, ACT_MP_ITEM1_GRENADE1_IDLE, false },
{ ACT_MP_GRENADE1_ATTACK, ACT_MP_ITEM1_GRENADE1_ATTACK, false },
{ ACT_MP_GRENADE2_DRAW, ACT_MP_ITEM1_GRENADE2_DRAW, false },
{ ACT_MP_GRENADE2_IDLE, ACT_MP_ITEM1_GRENADE2_IDLE, false },
{ ACT_MP_GRENADE2_ATTACK, ACT_MP_ITEM1_GRENADE2_ATTACK, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_ITEM1, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_ITEM1, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_ITEM1, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_ITEM1, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_ITEM1, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_ITEM1, false },
};
acttable_t s_acttableItem2[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_ITEM2, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_ITEM2, false },
{ ACT_MP_RUN, ACT_MP_RUN_ITEM2, false },
{ ACT_MP_WALK, ACT_MP_WALK_ITEM2, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_ITEM2, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_ITEM2, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_ITEM2, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_ITEM2, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_ITEM2, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_ITEM2, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_ITEM2, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_ITEM2, false },
{ ACT_MP_DOUBLEJUMP_CROUCH, ACT_MP_DOUBLEJUMP_CROUCH_ITEM2, false },
{ ACT_MP_RELOAD_STAND, ACT_MP_RELOAD_STAND_ITEM2, false },
{ ACT_MP_RELOAD_CROUCH, ACT_MP_RELOAD_CROUCH_ITEM2, false },
{ ACT_MP_RELOAD_SWIM, ACT_MP_RELOAD_SWIM_ITEM2, false },
{ ACT_MP_RELOAD_AIRWALK, ACT_MP_RELOAD_AIRWALK_ITEM2, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_ITEM2, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_ITEM2, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_ITEM2, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_ITEM2, false },
{ ACT_MP_DEPLOYED, ACT_MP_DEPLOYED_ITEM2, false },
{ ACT_MP_DEPLOYED_IDLE, ACT_MP_DEPLOYED_IDLE_ITEM2, false },
{ ACT_MP_CROUCH_DEPLOYED, ACT_MP_CROUCHWALK_DEPLOYED_ITEM2, false },
{ ACT_MP_CROUCH_DEPLOYED_IDLE, ACT_MP_CROUCH_DEPLOYED_IDLE_ITEM2, false },
//{ ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED, ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED_ITEM2, false },
//{ ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED,ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED_ITEM2, false },
{ ACT_MP_ATTACK_STAND_SECONDARYFIRE, ACT_MP_ATTACK_STAND_ITEM2_SECONDARY, false },
{ ACT_MP_ATTACK_CROUCH_SECONDARYFIRE, ACT_MP_ATTACK_CROUCH_ITEM2_SECONDARY,false },
{ ACT_MP_ATTACK_SWIM_SECONDARYFIRE, ACT_MP_ATTACK_SWIM_ITEM2, false },
{ ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE, ACT_MP_ATTACK_AIRWALK_ITEM2, false },
{ ACT_MP_GESTURE_FLINCH, ACT_MP_GESTURE_FLINCH_ITEM2, false },
{ ACT_MP_GRENADE1_DRAW, ACT_MP_ITEM2_GRENADE1_DRAW, false },
{ ACT_MP_GRENADE1_IDLE, ACT_MP_ITEM2_GRENADE1_IDLE, false },
{ ACT_MP_GRENADE1_ATTACK, ACT_MP_ITEM2_GRENADE1_ATTACK, false },
{ ACT_MP_GRENADE2_DRAW, ACT_MP_ITEM2_GRENADE2_DRAW, false },
{ ACT_MP_GRENADE2_IDLE, ACT_MP_ITEM2_GRENADE2_IDLE, false },
{ ACT_MP_GRENADE2_ATTACK, ACT_MP_ITEM2_GRENADE2_ATTACK, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_ITEM2, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_ITEM2, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_ITEM2, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_ITEM2, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_ITEM2, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_ITEM2, false },
};
acttable_t s_acttableBuilding[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_BUILDING, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_BUILDING, false },
{ ACT_MP_RUN, ACT_MP_RUN_BUILDING, false },
{ ACT_MP_WALK, ACT_MP_WALK_BUILDING, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_BUILDING, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_BUILDING, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_BUILDING, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_BUILDING, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_BUILDING, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_BUILDING, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_BUILDING, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_BUILDING, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_BUILDING, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_BUILDING, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_BUILDING, false },
{ ACT_MP_ATTACK_STAND_GRENADE, ACT_MP_ATTACK_STAND_GRENADE_BUILDING, false },
{ ACT_MP_ATTACK_CROUCH_GRENADE, ACT_MP_ATTACK_STAND_GRENADE_BUILDING, false },
{ ACT_MP_ATTACK_SWIM_GRENADE, ACT_MP_ATTACK_STAND_GRENADE_BUILDING, false },
{ ACT_MP_ATTACK_AIRWALK_GRENADE, ACT_MP_ATTACK_STAND_GRENADE_BUILDING, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_BUILDING, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_BUILDING, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_BUILDING, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_BUILDING, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_BUILDING, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_BUILDING, false },
};
acttable_t s_acttablePDA[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_PDA, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_PDA, false },
{ ACT_MP_RUN, ACT_MP_RUN_PDA, false },
{ ACT_MP_WALK, ACT_MP_WALK_PDA, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_PDA, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_PDA, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_PDA, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_PDA, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_PDA, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_PDA, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_PDA, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_PDA, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_PDA, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_PDA, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_PDA, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_PDA, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_PDA, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_PDA, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_PDA, false },
};
acttable_t s_acttableMeleeAllclass[] =
{
{ ACT_MP_STAND_IDLE, ACT_MP_STAND_MELEE_ALLCLASS, false },
{ ACT_MP_CROUCH_IDLE, ACT_MP_CROUCH_MELEE_ALLCLASS, false },
{ ACT_MP_RUN, ACT_MP_RUN_MELEE_ALLCLASS, false },
{ ACT_MP_WALK, ACT_MP_WALK_MELEE_ALLCLASS, false },
{ ACT_MP_AIRWALK, ACT_MP_AIRWALK_MELEE_ALLCLASS, false },
{ ACT_MP_CROUCHWALK, ACT_MP_CROUCHWALK_MELEE_ALLCLASS, false },
{ ACT_MP_JUMP, ACT_MP_JUMP_MELEE_ALLCLASS, false },
{ ACT_MP_JUMP_START, ACT_MP_JUMP_START_MELEE_ALLCLASS, false },
{ ACT_MP_JUMP_FLOAT, ACT_MP_JUMP_FLOAT_MELEE_ALLCLASS, false },
{ ACT_MP_JUMP_LAND, ACT_MP_JUMP_LAND_MELEE_ALLCLASS, false },
{ ACT_MP_SWIM, ACT_MP_SWIM_MELEE_ALLCLASS, false },
{ ACT_MP_DOUBLEJUMP_CROUCH, ACT_MP_DOUBLEJUMP_CROUCH_MELEE, false },
{ ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_MP_ATTACK_STAND_MELEE_ALLCLASS, false },
{ ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_MP_ATTACK_CROUCH_MELEE_ALLCLASS, false },
{ ACT_MP_ATTACK_SWIM_PRIMARYFIRE, ACT_MP_ATTACK_SWIM_MELEE_ALLCLASS, false },
{ ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE, ACT_MP_ATTACK_AIRWALK_MELEE_ALLCLASS, false },
{ ACT_MP_ATTACK_STAND_SECONDARYFIRE, ACT_MP_ATTACK_STAND_MELEE_SECONDARY, false },
{ ACT_MP_ATTACK_CROUCH_SECONDARYFIRE, ACT_MP_ATTACK_CROUCH_MELEE_SECONDARY,false },
{ ACT_MP_ATTACK_SWIM_SECONDARYFIRE, ACT_MP_ATTACK_SWIM_MELEE_ALLCLASS, false },
{ ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE, ACT_MP_ATTACK_AIRWALK_MELEE_ALLCLASS, false },
{ ACT_MP_GESTURE_FLINCH, ACT_MP_GESTURE_FLINCH_MELEE, false },
{ ACT_MP_GRENADE1_DRAW, ACT_MP_MELEE_GRENADE1_DRAW, false },
{ ACT_MP_GRENADE1_IDLE, ACT_MP_MELEE_GRENADE1_IDLE, false },
{ ACT_MP_GRENADE1_ATTACK, ACT_MP_MELEE_GRENADE1_ATTACK, false },
{ ACT_MP_GRENADE2_DRAW, ACT_MP_MELEE_GRENADE2_DRAW, false },
{ ACT_MP_GRENADE2_IDLE, ACT_MP_MELEE_GRENADE2_IDLE, false },
{ ACT_MP_GRENADE2_ATTACK, ACT_MP_MELEE_GRENADE2_ATTACK, false },
{ ACT_MP_GESTURE_VC_HANDMOUTH, ACT_MP_GESTURE_VC_HANDMOUTH_MELEE, false },
{ ACT_MP_GESTURE_VC_FINGERPOINT, ACT_MP_GESTURE_VC_FINGERPOINT_MELEE, false },
{ ACT_MP_GESTURE_VC_FISTPUMP, ACT_MP_GESTURE_VC_FISTPUMP_MELEE, false },
{ ACT_MP_GESTURE_VC_THUMBSUP, ACT_MP_GESTURE_VC_THUMBSUP_MELEE, false },
{ ACT_MP_GESTURE_VC_NODYES, ACT_MP_GESTURE_VC_NODYES_MELEE, false },
{ ACT_MP_GESTURE_VC_NODNO, ACT_MP_GESTURE_VC_NODNO_MELEE, false },
};
ConVar mp_forceactivityset( "mp_forceactivityset", "-1", FCVAR_CHEAT|FCVAR_REPLICATED|FCVAR_DEVELOPMENTONLY );
int CTFWeaponBase::GetActivityWeaponRole() const
{
int iWeaponRole = GetTFWpnData().m_iWeaponType;
const CEconItemView *pEconItemView = GetAttributeContainer()->GetItem();
if ( pEconItemView )
{
int iMaybeOverrideAnimSlot = pEconItemView->GetAnimationSlot();
if ( iMaybeOverrideAnimSlot >= 0 )
{
iWeaponRole = iMaybeOverrideAnimSlot;
}
}
if ( mp_forceactivityset.GetInt() >= 0 )
{
iWeaponRole = mp_forceactivityset.GetInt();
}
return iWeaponRole;
}
acttable_t *CTFWeaponBase::ActivityList( int &iActivityCount )
{
int iWeaponRole = GetActivityWeaponRole();
#ifdef CLIENT_DLL
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pPlayer->IsEnemyPlayer() )
{
CTFWeaponBase *pDisguiseWeapon = pPlayer->m_Shared.GetDisguiseWeapon();
if ( pDisguiseWeapon && pDisguiseWeapon != this )
{
return pDisguiseWeapon->ActivityList( iActivityCount );
}
}
#endif
acttable_t *pTable;
switch( iWeaponRole )
{
case TF_WPN_TYPE_PRIMARY:
default:
iActivityCount = ARRAYSIZE( s_acttablePrimary );
pTable = s_acttablePrimary;
break;
case TF_WPN_TYPE_SECONDARY:
iActivityCount = ARRAYSIZE( s_acttableSecondary );
pTable = s_acttableSecondary;
break;
case TF_WPN_TYPE_MELEE:
iActivityCount = ARRAYSIZE( s_acttableMelee );
pTable = s_acttableMelee;
break;
case TF_WPN_TYPE_BUILDING:
iActivityCount = ARRAYSIZE( s_acttableBuilding );
pTable = s_acttableBuilding;
break;
case TF_WPN_TYPE_PDA:
iActivityCount = ARRAYSIZE( s_acttablePDA );
pTable = s_acttablePDA;
break;
case TF_WPN_TYPE_ITEM1:
iActivityCount = ARRAYSIZE( s_acttableItem1 );
pTable = s_acttableItem1;
break;
case TF_WPN_TYPE_ITEM2:
iActivityCount = ARRAYSIZE( s_acttableItem2 );
pTable = s_acttableItem2;
break;
case TF_WPN_TYPE_MELEE_ALLCLASS:
iActivityCount = ARRAYSIZE( s_acttableMeleeAllclass );
pTable = s_acttableMeleeAllclass;
break;
case TF_WPN_TYPE_SECONDARY2:
iActivityCount = ARRAYSIZE( s_acttableSecondary2 );
pTable = s_acttableSecondary2;
break;
case TF_WPN_TYPE_PRIMARY2:
iActivityCount = ARRAYSIZE( s_acttablePrimary2 );
pTable = s_acttablePrimary2;
break;
}
return pTable;
}
typedef struct
{
int baseAct;
int weaponAct;
int weaponRole;
} viewmodelacttable_t;
// Remaps viewmodel activities to specific ones for the weapon role.
// Needed this for weapons that bonemerge themselves to the hand models to create their viewmodel.
// The hand model needs to have all the animations, and be able to choose the right anims to play for the active weapon.
// We use this acttable to remap the base viewmodel anims to the right one for the weapon.
viewmodelacttable_t s_viewmodelacttable[] =
{
{ ACT_VM_DRAW, ACT_PRIMARY_VM_DRAW, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_HOLSTER, ACT_PRIMARY_VM_HOLSTER, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_IDLE, ACT_PRIMARY_VM_IDLE, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_PULLBACK, ACT_PRIMARY_VM_PULLBACK, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_PRIMARYATTACK, ACT_PRIMARY_VM_PRIMARYATTACK, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_SECONDARYATTACK, ACT_PRIMARY_VM_SECONDARYATTACK, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_RELOAD, ACT_PRIMARY_VM_RELOAD, TF_WPN_TYPE_PRIMARY },
{ ACT_RELOAD_START, ACT_PRIMARY_RELOAD_START, TF_WPN_TYPE_PRIMARY },
{ ACT_RELOAD_FINISH, ACT_PRIMARY_RELOAD_FINISH, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_DRYFIRE, ACT_PRIMARY_VM_DRYFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_IDLE_TO_LOWERED, ACT_PRIMARY_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_IDLE_LOWERED, ACT_PRIMARY_VM_IDLE_LOWERED, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_LOWERED_TO_IDLE, ACT_PRIMARY_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_PRIMARY },
{ ACT_MP_ATTACK_STAND_PREFIRE, ACT_PRIMARY_ATTACK_STAND_PREFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_MP_ATTACK_STAND_POSTFIRE, ACT_PRIMARY_ATTACK_STAND_POSTFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_MP_ATTACK_STAND_STARTFIRE, ACT_PRIMARY_ATTACK_STAND_STARTFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_MP_ATTACK_CROUCH_PREFIRE, ACT_PRIMARY_ATTACK_CROUCH_PREFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_MP_ATTACK_CROUCH_POSTFIRE, ACT_PRIMARY_ATTACK_CROUCH_POSTFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_MP_ATTACK_SWIM_PREFIRE, ACT_PRIMARY_ATTACK_SWIM_PREFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_MP_ATTACK_SWIM_POSTFIRE, ACT_PRIMARY_ATTACK_SWIM_POSTFIRE, TF_WPN_TYPE_PRIMARY },
{ ACT_VM_DRAW, ACT_SECONDARY_VM_DRAW, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_HOLSTER, ACT_SECONDARY_VM_HOLSTER, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_IDLE, ACT_SECONDARY_VM_IDLE, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_PULLBACK, ACT_SECONDARY_VM_PULLBACK, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_PRIMARYATTACK, ACT_SECONDARY_VM_PRIMARYATTACK, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_SECONDARYATTACK, ACT_SECONDARY_VM_SECONDARYATTACK, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_RELOAD, ACT_SECONDARY_VM_RELOAD, TF_WPN_TYPE_SECONDARY },
{ ACT_RELOAD_START, ACT_SECONDARY_RELOAD_START, TF_WPN_TYPE_SECONDARY },
{ ACT_RELOAD_FINISH, ACT_SECONDARY_RELOAD_FINISH, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_DRYFIRE, ACT_SECONDARY_VM_DRYFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_IDLE_TO_LOWERED, ACT_SECONDARY_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_IDLE_LOWERED, ACT_SECONDARY_VM_IDLE_LOWERED, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_LOWERED_TO_IDLE, ACT_SECONDARY_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_SECONDARY },
{ ACT_MP_ATTACK_STAND_PREFIRE, ACT_SECONDARY_ATTACK_STAND_PREFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_MP_ATTACK_STAND_POSTFIRE, ACT_SECONDARY_ATTACK_STAND_POSTFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_MP_ATTACK_STAND_STARTFIRE, ACT_SECONDARY_ATTACK_STAND_STARTFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_MP_ATTACK_CROUCH_PREFIRE, ACT_SECONDARY_ATTACK_CROUCH_PREFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_MP_ATTACK_CROUCH_POSTFIRE, ACT_SECONDARY_ATTACK_CROUCH_POSTFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_MP_ATTACK_SWIM_PREFIRE, ACT_SECONDARY_ATTACK_SWIM_PREFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_MP_ATTACK_SWIM_POSTFIRE, ACT_SECONDARY_ATTACK_SWIM_POSTFIRE, TF_WPN_TYPE_SECONDARY },
{ ACT_VM_DRAW, ACT_MELEE_VM_DRAW, TF_WPN_TYPE_MELEE },
{ ACT_VM_HOLSTER, ACT_MELEE_VM_HOLSTER, TF_WPN_TYPE_MELEE },
{ ACT_VM_IDLE, ACT_MELEE_VM_IDLE, TF_WPN_TYPE_MELEE },
{ ACT_VM_PULLBACK, ACT_MELEE_VM_PULLBACK, TF_WPN_TYPE_MELEE },
{ ACT_VM_PRIMARYATTACK, ACT_MELEE_VM_PRIMARYATTACK, TF_WPN_TYPE_MELEE },
{ ACT_VM_SECONDARYATTACK, ACT_MELEE_VM_SECONDARYATTACK, TF_WPN_TYPE_MELEE },
{ ACT_VM_RELOAD, ACT_MELEE_VM_RELOAD, TF_WPN_TYPE_MELEE },
{ ACT_VM_DRYFIRE, ACT_MELEE_VM_DRYFIRE, TF_WPN_TYPE_MELEE },
{ ACT_VM_IDLE_TO_LOWERED, ACT_MELEE_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_MELEE },
{ ACT_VM_IDLE_LOWERED, ACT_MELEE_VM_IDLE_LOWERED, TF_WPN_TYPE_MELEE },
{ ACT_VM_LOWERED_TO_IDLE, ACT_MELEE_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_MELEE },
{ ACT_VM_HITCENTER, ACT_MELEE_VM_HITCENTER, TF_WPN_TYPE_MELEE },
{ ACT_VM_SWINGHARD, ACT_MELEE_VM_SWINGHARD, TF_WPN_TYPE_MELEE },
{ ACT_MP_ATTACK_STAND_PREFIRE, ACT_MELEE_ATTACK_STAND_PREFIRE, TF_WPN_TYPE_MELEE },
{ ACT_MP_ATTACK_STAND_POSTFIRE, ACT_MELEE_ATTACK_STAND_POSTFIRE, TF_WPN_TYPE_MELEE },
{ ACT_MP_ATTACK_STAND_STARTFIRE, ACT_MELEE_ATTACK_STAND_STARTFIRE, TF_WPN_TYPE_MELEE },
{ ACT_MP_ATTACK_CROUCH_PREFIRE, ACT_MELEE_ATTACK_CROUCH_PREFIRE, TF_WPN_TYPE_MELEE },
{ ACT_MP_ATTACK_CROUCH_POSTFIRE, ACT_MELEE_ATTACK_CROUCH_POSTFIRE, TF_WPN_TYPE_MELEE },
{ ACT_MP_ATTACK_SWIM_PREFIRE, ACT_MELEE_ATTACK_SWIM_PREFIRE, TF_WPN_TYPE_MELEE },
{ ACT_MP_ATTACK_SWIM_POSTFIRE, ACT_MELEE_ATTACK_SWIM_POSTFIRE, TF_WPN_TYPE_MELEE },
// Scout Pack -- Bat Special State Support
{ ACT_VM_DRAW_SPECIAL, ACT_VM_DRAW_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_HOLSTER_SPECIAL, ACT_VM_HOLSTER_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_IDLE_SPECIAL, ACT_VM_IDLE_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_PULLBACK_SPECIAL, ACT_VM_PULLBACK_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_PRIMARYATTACK_SPECIAL, ACT_VM_PRIMARYATTACK_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_SECONDARYATTACK_SPECIAL, ACT_VM_SECONDARYATTACK_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_HITCENTER_SPECIAL, ACT_VM_HITCENTER_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_SWINGHARD_SPECIAL, ACT_VM_SWINGHARD_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_IDLE_TO_LOWERED_SPECIAL, ACT_VM_IDLE_TO_LOWERED_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_IDLE_LOWERED_SPECIAL, ACT_VM_IDLE_LOWERED_SPECIAL, TF_WPN_TYPE_MELEE },
{ ACT_VM_LOWERED_TO_IDLE_SPECIAL, ACT_VM_LOWERED_TO_IDLE_SPECIAL, TF_WPN_TYPE_MELEE },
// Spy Pack -- New Knife Anims
{ ACT_BACKSTAB_VM_DOWN, ACT_BACKSTAB_VM_DOWN, TF_WPN_TYPE_MELEE },
{ ACT_BACKSTAB_VM_UP, ACT_BACKSTAB_VM_UP, TF_WPN_TYPE_MELEE },
{ ACT_BACKSTAB_VM_IDLE, ACT_BACKSTAB_VM_IDLE, TF_WPN_TYPE_MELEE },
{ ACT_VM_DRAW, ACT_PDA_VM_DRAW, TF_WPN_TYPE_PDA },
{ ACT_VM_HOLSTER, ACT_PDA_VM_HOLSTER, TF_WPN_TYPE_PDA },
{ ACT_VM_IDLE, ACT_PDA_VM_IDLE, TF_WPN_TYPE_PDA },
{ ACT_VM_PULLBACK, ACT_PDA_VM_PULLBACK, TF_WPN_TYPE_PDA },
{ ACT_VM_PRIMARYATTACK, ACT_PDA_VM_PRIMARYATTACK, TF_WPN_TYPE_PDA },
{ ACT_VM_SECONDARYATTACK, ACT_PDA_VM_SECONDARYATTACK, TF_WPN_TYPE_PDA },
{ ACT_VM_RELOAD, ACT_PDA_VM_RELOAD, TF_WPN_TYPE_PDA },
{ ACT_VM_DRYFIRE, ACT_PDA_VM_DRYFIRE, TF_WPN_TYPE_PDA },
{ ACT_VM_IDLE_TO_LOWERED, ACT_PDA_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_PDA },
{ ACT_VM_IDLE_LOWERED, ACT_PDA_VM_IDLE_LOWERED, TF_WPN_TYPE_PDA },
{ ACT_VM_LOWERED_TO_IDLE, ACT_PDA_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_PDA },
// ITEM1
{ ACT_VM_DRAW, ACT_ITEM1_VM_DRAW, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_HOLSTER, ACT_ITEM1_VM_HOLSTER, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_IDLE, ACT_ITEM1_VM_IDLE, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_PULLBACK, ACT_ITEM1_VM_PULLBACK, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_PRIMARYATTACK, ACT_ITEM1_VM_PRIMARYATTACK, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_SECONDARYATTACK, ACT_ITEM1_VM_SECONDARYATTACK, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_RELOAD, ACT_ITEM1_VM_RELOAD, TF_WPN_TYPE_ITEM1 },
{ ACT_RELOAD_START, ACT_ITEM1_RELOAD_START, TF_WPN_TYPE_ITEM1 },
{ ACT_RELOAD_FINISH, ACT_ITEM1_RELOAD_FINISH, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_DRYFIRE, ACT_ITEM1_VM_DRYFIRE, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_IDLE_TO_LOWERED, ACT_ITEM1_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_IDLE_LOWERED, ACT_ITEM1_VM_IDLE_LOWERED, TF_WPN_TYPE_ITEM1 },
{ ACT_VM_LOWERED_TO_IDLE, ACT_ITEM1_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_ITEM1 },
{ ACT_MP_ATTACK_STAND_PREFIRE, ACT_ITEM1_ATTACK_STAND_PREFIRE, TF_WPN_TYPE_ITEM1 },
{ ACT_MP_ATTACK_STAND_POSTFIRE, ACT_ITEM1_ATTACK_STAND_POSTFIRE, TF_WPN_TYPE_ITEM1 },
{ ACT_MP_ATTACK_STAND_STARTFIRE, ACT_ITEM1_ATTACK_STAND_STARTFIRE, TF_WPN_TYPE_ITEM1 },
{ ACT_MP_ATTACK_CROUCH_PREFIRE, ACT_ITEM1_ATTACK_CROUCH_PREFIRE, TF_WPN_TYPE_ITEM1 },
{ ACT_MP_ATTACK_CROUCH_POSTFIRE, ACT_ITEM1_ATTACK_CROUCH_POSTFIRE, TF_WPN_TYPE_ITEM1 },
{ ACT_MP_ATTACK_SWIM_PREFIRE, ACT_ITEM1_ATTACK_SWIM_PREFIRE, TF_WPN_TYPE_ITEM1 },
{ ACT_MP_ATTACK_SWIM_POSTFIRE, ACT_ITEM1_ATTACK_SWIM_POSTFIRE, TF_WPN_TYPE_ITEM1 },
// ITEM2
{ ACT_VM_DRAW, ACT_ITEM2_VM_DRAW, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_HOLSTER, ACT_ITEM2_VM_HOLSTER, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_IDLE, ACT_ITEM2_VM_IDLE, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_PULLBACK, ACT_ITEM2_VM_PULLBACK, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_PRIMARYATTACK, ACT_ITEM2_VM_PRIMARYATTACK, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_SECONDARYATTACK, ACT_ITEM2_VM_SECONDARYATTACK, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_RELOAD, ACT_ITEM2_VM_RELOAD, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_DRYFIRE, ACT_ITEM2_VM_DRYFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_IDLE_TO_LOWERED, ACT_ITEM2_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_IDLE_LOWERED, ACT_ITEM2_VM_IDLE_LOWERED, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_LOWERED_TO_IDLE, ACT_ITEM2_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_ITEM2 },
{ ACT_MP_ATTACK_STAND_PREFIRE, ACT_ITEM2_ATTACK_STAND_PREFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_MP_ATTACK_STAND_POSTFIRE, ACT_ITEM2_ATTACK_STAND_POSTFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_MP_ATTACK_STAND_STARTFIRE, ACT_ITEM2_ATTACK_STAND_STARTFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_MP_ATTACK_CROUCH_PREFIRE, ACT_ITEM2_ATTACK_CROUCH_PREFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_MP_ATTACK_CROUCH_POSTFIRE, ACT_ITEM2_ATTACK_CROUCH_POSTFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_MP_ATTACK_SWIM_PREFIRE, ACT_ITEM2_ATTACK_SWIM_PREFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_MP_ATTACK_SWIM_POSTFIRE, ACT_ITEM2_ATTACK_SWIM_POSTFIRE, TF_WPN_TYPE_ITEM2 },
{ ACT_VM_DRAW, ACT_MELEE_ALLCLASS_VM_DRAW, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_HOLSTER, ACT_MELEE_ALLCLASS_VM_HOLSTER, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_IDLE, ACT_MELEE_ALLCLASS_VM_IDLE, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_PULLBACK, ACT_MELEE_ALLCLASS_VM_PULLBACK, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_PRIMARYATTACK, ACT_MELEE_ALLCLASS_VM_PRIMARYATTACK, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_SECONDARYATTACK, ACT_MELEE_ALLCLASS_VM_SECONDARYATTACK, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_RELOAD, ACT_MELEE_ALLCLASS_VM_RELOAD, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_DRYFIRE, ACT_MELEE_ALLCLASS_VM_DRYFIRE, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_IDLE_TO_LOWERED, ACT_MELEE_ALLCLASS_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_IDLE_LOWERED, ACT_MELEE_ALLCLASS_VM_IDLE_LOWERED, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_LOWERED_TO_IDLE, ACT_MELEE_ALLCLASS_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_HITCENTER, ACT_MELEE_ALLCLASS_VM_HITCENTER, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_SWINGHARD, ACT_MELEE_ALLCLASS_VM_SWINGHARD, TF_WPN_TYPE_MELEE_ALLCLASS },
{ ACT_VM_DRAW, ACT_SECONDARY2_VM_DRAW, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_HOLSTER, ACT_SECONDARY2_VM_HOLSTER, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_IDLE, ACT_SECONDARY2_VM_IDLE, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_PULLBACK, ACT_SECONDARY2_VM_PULLBACK, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_PRIMARYATTACK, ACT_SECONDARY2_VM_PRIMARYATTACK, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_RELOAD, ACT_SECONDARY2_VM_RELOAD, TF_WPN_TYPE_SECONDARY2 },
{ ACT_RELOAD_START, ACT_SECONDARY2_RELOAD_START, TF_WPN_TYPE_SECONDARY2 },
{ ACT_RELOAD_FINISH, ACT_SECONDARY2_RELOAD_FINISH, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_DRYFIRE, ACT_SECONDARY2_VM_DRYFIRE, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_IDLE_TO_LOWERED, ACT_SECONDARY2_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_IDLE_LOWERED, ACT_SECONDARY2_VM_IDLE_LOWERED, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_LOWERED_TO_IDLE, ACT_SECONDARY2_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_SECONDARY2 },
{ ACT_VM_DRAW, ACT_PRIMARY_VM_DRAW, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_HOLSTER, ACT_PRIMARY_VM_HOLSTER, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_IDLE, ACT_PRIMARY_VM_IDLE, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_PULLBACK, ACT_PRIMARY_VM_PULLBACK, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_PRIMARYATTACK, ACT_PRIMARY_VM_PRIMARYATTACK, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_RELOAD, ACT_PRIMARY_VM_RELOAD_3, TF_WPN_TYPE_PRIMARY2 },
{ ACT_RELOAD_START, ACT_PRIMARY_RELOAD_START_3, TF_WPN_TYPE_PRIMARY2 },
{ ACT_RELOAD_FINISH, ACT_PRIMARY_RELOAD_FINISH_3, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_DRYFIRE, ACT_PRIMARY_VM_DRYFIRE, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_IDLE_TO_LOWERED, ACT_PRIMARY_VM_IDLE_TO_LOWERED, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_IDLE_LOWERED, ACT_PRIMARY_VM_IDLE_LOWERED, TF_WPN_TYPE_PRIMARY2 },
{ ACT_VM_LOWERED_TO_IDLE, ACT_PRIMARY_VM_LOWERED_TO_IDLE, TF_WPN_TYPE_PRIMARY2 },
};
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
Activity CTFWeaponBase::TranslateViewmodelHandActivityInternal( Activity actBase )
{
CEconItemView *pEconItemView = GetAttributeContainer()->GetItem();
if ( pEconItemView && pEconItemView->IsValid() && GetOwnerEntity() )
{
Activity translatedActivity = pEconItemView->GetStaticData()->GetActivityOverride( GetOwnerEntity()->GetTeamNumber(), actBase );
if ( translatedActivity != actBase )
return translatedActivity;
}
int iWeaponRole = GetViewModelWeaponRole();
if ( pEconItemView )
{
int iMaybeOverrideAnimSlot = pEconItemView->GetAnimationSlot();
if ( iMaybeOverrideAnimSlot >= 0 )
{
iWeaponRole = iMaybeOverrideAnimSlot;
}
}
viewmodelacttable_t *pTable = s_viewmodelacttable;
for ( int i = 0; i < ARRAYSIZE(s_viewmodelacttable); i++ )
{
const viewmodelacttable_t &act = pTable[i];
if ( actBase == act.baseAct && act.weaponRole == iWeaponRole )
return (Activity)act.weaponAct;
}
return actBase;
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
CBasePlayer *CTFWeaponBase::GetPlayerOwner() const
{
return dynamic_cast<CBasePlayer*>( GetOwner() );
}
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
CTFPlayer *CTFWeaponBase::GetTFPlayerOwner() const
{
return dynamic_cast<CTFPlayer*>( GetOwner() );
}
#ifdef CLIENT_DLL
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
C_BaseEntity *CTFWeaponBase::GetWeaponForEffect()
{
return GetAppropriateWorldOrViewModel();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ShadowType_t CTFWeaponBase::ShadowCastType( void )
{
// Some weapons (fists) don't actually get set to NODRAW when holstered so we
// need some extra checks
if ( IsEffectActive( EF_NODRAW | EF_NOSHADOW ) || m_iState != WEAPON_IS_ACTIVE )
return SHADOWS_NONE;
return BaseClass::ShadowCastType();
}
#endif
// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
bool CTFWeaponBase::CanAttack()
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer )
return pPlayer->CanAttack( GetCanAttackFlags() );
return false;
}
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CanFireCriticalShot( bool bIsHeadshot )
{
#ifdef GAME_DLL
CTFPlayer *player = GetTFPlayerOwner();
if ( TFGameRules()->IsPVEModeControlled( player ) )
{
// scenario bots cant crit (unless they always do)
CTFBot *bot = ToTFBot( player );
return ( bot && bot->HasAttribute( CTFBot::ALWAYS_CRIT ) );
}
#ifdef TF_CREEP_MODE
if ( TFGameRules()->IsCreepWaveMode() && player )
{
CTFBot *bot = ToTFBot( player );
if ( bot && bot->HasAttribute( CTFBot::IS_NPC ) )
{
// creeps can't crit
return false;
}
}
#endif // TF_CREEP_MODE
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CanFireRandomCriticalShot( float flCritChance )
{
#ifdef GAME_DLL
// Todo: Create a version of this in tf_weaponbase_melee
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return false;
PlayerStats_t *pPlayerStats = CTF_GameStats.FindPlayerStats( pPlayer );
if ( pPlayerStats )
{
// Compare total damage done against total crit damage done. If this
// ratio is out of range for the expected crit chance, deny the crit.
int nRandomRangedCritDamage = pPlayerStats->statsCurrentRound.m_iStat[TFSTAT_DAMAGE_RANGED_CRIT_RANDOM];
int nTotalDamage = pPlayerStats->statsCurrentRound.m_iStat[TFSTAT_DAMAGE_RANGED];
// Early out
if ( !nTotalDamage )
return true;
float flNormalizedDamage = (float)nRandomRangedCritDamage / TF_DAMAGE_CRIT_MULTIPLIER;
m_flObservedCritChance.Set( flNormalizedDamage / ( flNormalizedDamage + ( nTotalDamage - nRandomRangedCritDamage ) ) );
// DevMsg ( "SERVER: CritChance: %f Observed: %f\n", flCritChance, m_flObservedCritChance.Get() );
}
#else
// DevMsg ( "CLIENT: CritChance: %f Observed: %f\n", flCritChance, m_flObservedCritChance.Get() );
#endif // GAME_DLL
if ( m_flObservedCritChance.Get() > flCritChance + 0.1f )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
char const *CTFWeaponBase::GetShootSound( int iIndex ) const
{
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
int nTeam = GetTeamNumber();
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && nTeam == TF_TEAM_PVE_INVADERS )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer && pPlayer->IsMiniBoss() )
{
// Not a real team - just a define used in replacing visuals via itemdefs ("visuals_mvm")
nTeam = TF_TEAM_PVE_INVADERS_GIANTS;
}
}
const char *pszSound = pItem->GetStaticData()->GetWeaponReplacementSound( nTeam, (WeaponSound_t)iIndex );
if ( pszSound )
return pszSound;
}
return BaseClass::GetShootSound(iIndex);
}
//-----------------------------------------------------------------------------
// Purpose: Owner is stunned.
//-----------------------------------------------------------------------------
void CTFWeaponBase::OnControlStunned( void )
{
// Abort reloading.
AbortReload();
// Hide the weapon.
SetWeaponVisible( false );
}
#if defined( CLIENT_DLL )
static ConVar cl_bobcycle( "cl_bobcycle","0.8", FCVAR_CHEAT );
static ConVar cl_bobup( "cl_bobup","0.5", FCVAR_CHEAT );
//-----------------------------------------------------------------------------
// Purpose: Helper function to calculate head bob
//-----------------------------------------------------------------------------
float CalcViewModelBobHelper( CBasePlayer *player, BobState_t *pBobState )
{
Assert( pBobState );
if ( !pBobState )
return 0;
float cycle;
// Don't allow zeros, because we divide by them.
float flBobup = cl_bobup.GetFloat();
if ( flBobup <= 0 )
{
flBobup = 0.01;
}
float flBobCycle = cl_bobcycle.GetFloat();
if ( flBobCycle <= 0 )
{
flBobCycle = 0.01;
}
//NOTENOTE: For now, let this cycle continue when in the air, because it snaps badly without it
if ( ( !gpGlobals->frametime ) || ( player == NULL ) )
{
//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
return 0.0f;// just use old value
}
//Find the speed of the player
float speed = player->GetLocalVelocity().Length2D();
float flmaxSpeedDelta = MAX( 0, (gpGlobals->curtime - pBobState->m_flLastBobTime ) * 320.0f );
// don't allow too big speed changes
speed = clamp( speed, pBobState->m_flLastSpeed-flmaxSpeedDelta, pBobState->m_flLastSpeed+flmaxSpeedDelta );
speed = clamp( speed, -320.f, 320.f );
pBobState->m_flLastSpeed = speed;
//FIXME: This maximum speed value must come from the server.
// MaxSpeed() is not sufficient for dealing with sprinting - jdw
float bob_offset = RemapVal( speed, 0, 320, 0.0f, 1.0f );
pBobState->m_flBobTime += ( gpGlobals->curtime - pBobState->m_flLastBobTime ) * bob_offset;
pBobState->m_flLastBobTime = gpGlobals->curtime;
//Calculate the vertical bob
cycle = pBobState->m_flBobTime - (int)(pBobState->m_flBobTime/flBobCycle)*flBobCycle;
cycle /= flBobCycle;
if ( cycle < flBobup )
{
cycle = M_PI * cycle / flBobup;
}
else
{
cycle = M_PI + M_PI*(cycle-flBobup)/(1.0 - flBobup);
}
pBobState->m_flVerticalBob = speed*0.005f;
pBobState->m_flVerticalBob = pBobState->m_flVerticalBob*0.3 + pBobState->m_flVerticalBob*0.7*sin(cycle);
pBobState->m_flVerticalBob = clamp( pBobState->m_flVerticalBob, -7.0f, 4.0f );
//Calculate the lateral bob
cycle = pBobState->m_flBobTime - (int)(pBobState->m_flBobTime/flBobCycle*2)*flBobCycle*2;
cycle /= flBobCycle*2;
if ( cycle < flBobup )
{
cycle = M_PI * cycle / flBobup;
}
else
{
cycle = M_PI + M_PI*(cycle-flBobup)/(1.0 - flBobup);
}
pBobState->m_flLateralBob = speed*0.005f;
pBobState->m_flLateralBob = pBobState->m_flLateralBob*0.3 + pBobState->m_flLateralBob*0.7*sin(cycle);
pBobState->m_flLateralBob = clamp( pBobState->m_flLateralBob, -7.0f, 4.0f );
//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Helper function to add head bob
//-----------------------------------------------------------------------------
void AddViewModelBobHelper( Vector &origin, QAngle &angles, BobState_t *pBobState )
{
Assert( pBobState );
if ( !pBobState )
return;
Vector forward, right;
AngleVectors( angles, &forward, &right, NULL );
// Apply bob, but scaled down to 40%
VectorMA( origin, pBobState->m_flVerticalBob * 0.4f, forward, origin );
// Z bob a bit more
origin[2] += pBobState->m_flVerticalBob * 0.1f;
// bob the angles
angles[ ROLL ] += pBobState->m_flVerticalBob * 0.5f;
angles[ PITCH ] -= pBobState->m_flVerticalBob * 0.4f;
angles[ YAW ] -= pBobState->m_flLateralBob * 0.3f;
VectorMA( origin, pBobState->m_flLateralBob * 0.2f, right, origin );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CTFWeaponBase::CalcViewmodelBob( void )
{
CBasePlayer *player = ToBasePlayer( GetOwner() );
//Assert( player );
BobState_t *pBobState = GetBobState();
if ( pBobState )
return ::CalcViewModelBobHelper( player, pBobState );
else
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &origin -
// &angles -
// viewmodelindex -
//-----------------------------------------------------------------------------
void CTFWeaponBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
{
// call helper functions to do the calculation
BobState_t *pBobState = GetBobState();
if ( pBobState )
{
CalcViewmodelBob();
::AddViewModelBobHelper( origin, angles, pBobState );
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns the head bob state for this weapon, which is stored
// in the view model. Note that this this function can return
// NULL if the player is dead or the view model is otherwise not present.
//-----------------------------------------------------------------------------
BobState_t *CTFWeaponBase::GetBobState()
{
// get the view model for this weapon
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return NULL;
CBaseViewModel *baseViewModel = pOwner->GetViewModel( m_nViewModelIndex );
if ( baseViewModel == NULL )
return NULL;
CTFViewModel *viewModel = dynamic_cast<CTFViewModel *>(baseViewModel);
Assert( viewModel );
// get the bob state out of the view model
return &( viewModel->GetBobState() );
}
#endif // defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose: Used for spy invisiblity material, skin overrides, and team colors
//-----------------------------------------------------------------------------
int CTFWeaponBase::GetSkin()
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return 0;
int iTeamNumber = pPlayer->GetTeamNumber();
#if defined( CLIENT_DLL )
// Run client-only "is the viewer on the same team as the wielder" logic. Assumed to
// always be false on the server.
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return 0;
int iLocalTeam = pLocalPlayer->GetTeamNumber();
// We only show disguise weapon to the enemy team when owner is disguised
bool bUseDisguiseWeapon = ( iTeamNumber != iLocalTeam && iLocalTeam > LAST_SHARED_TEAM );
if ( bUseDisguiseWeapon && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
{
if ( pLocalPlayer != pPlayer )
{
iTeamNumber = pPlayer->m_Shared.GetDisguiseTeam();
}
}
#endif // defined( CLIENT_DLL )
// See if the item wants to override the skin
int nSkin = GetSkinOverride(); // give custom gameplay code a chance to set whatever
if ( nSkin == -1 )
{
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( pItem->IsValid() )
{
nSkin = pItem->GetSkin( iTeamNumber ); // if we didn't have custom code, fall back to the item definition
}
}
// If it didn't, fall back to the base skins
if ( nSkin == -1 )
{
switch( iTeamNumber )
{
case TF_TEAM_RED:
nSkin = 0;
break;
case TF_TEAM_BLUE:
nSkin = 1;
break;
default:
nSkin = 0;
break;
}
}
return nSkin;
}
#if defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
{
if ( event == 6002 && ShouldEjectBrass() )
{
if ( UsingViewModel() && !g_pClientMode->ShouldDrawViewModel() )
{
// Prevent effects when the ViewModel is hidden with r_drawviewmodel=0
return true;
}
CEffectData data;
// Look for 'eject_brass' attachment first instead of using options which is a seemingly magic number
if ( m_iEjectBrassAttachpoint == -2 )
{
m_iEjectBrassAttachpoint = pViewModel->LookupAttachment( "eject_brass" );
}
if ( m_iEjectBrassAttachpoint > 0 )
{
pViewModel->GetAttachment( m_iEjectBrassAttachpoint, data.m_vOrigin, data.m_vAngles );
}
else
{
pViewModel->GetAttachment( atoi(options), data.m_vOrigin, data.m_vAngles );
}
data.m_nDamageType = GetAttributeContainer()->GetItem() ? GetAttributeContainer()->GetItem()->GetItemDefIndex() : 0;
data.m_nHitBox = GetWeaponID();
DispatchEffect( "TF_EjectBrass", data );
return true;
}
if ( event == AE_WPN_INCREMENTAMMO )
{
IncrementAmmo();
m_bReloadedThroughAnimEvent = true;
return true;
}
return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
}
//-----------------------------------------------------------------------------
// Purpose: Used for spy invisiblity material
//-----------------------------------------------------------------------------
class CWeaponInvisProxy : public CBaseInvisMaterialProxy
{
public:
virtual void OnBind( C_BaseEntity *pBaseEntity ) OVERRIDE;
};
extern ConVar tf_teammate_max_invis;
//-----------------------------------------------------------------------------
// Purpose:
// Input :
//-----------------------------------------------------------------------------
void CWeaponInvisProxy::OnBind( C_BaseEntity *pBaseEntity )
{
if( !m_pPercentInvisible )
return;
C_BaseEntity *pMoveParent = pBaseEntity->GetMoveParent();
if ( !pMoveParent )
{
m_pPercentInvisible->SetFloatValue( 0.0f );
return;
}
if ( !pMoveParent->IsPlayer() )
{
C_TFPlayer *pOwningPlayer = ToTFPlayer( pMoveParent->GetOwnerEntity() );
if ( pOwningPlayer )
{
// mimic the owner's invisibility
float flInvis = pOwningPlayer->GetEffectiveInvisibilityLevel();
m_pPercentInvisible->SetFloatValue( flInvis );
}
else
{
m_pPercentInvisible->SetFloatValue( 0.0f );
}
return;
}
CTFPlayer *pPlayer = ToTFPlayer( pMoveParent );
Assert( pPlayer );
float flInvis = pPlayer->GetEffectiveInvisibilityLevel();
m_pPercentInvisible->SetFloatValue( flInvis );
}
EXPOSE_INTERFACE( CWeaponInvisProxy, IMaterialProxy, "weapon_invis" IMATERIAL_PROXY_INTERFACE_VERSION );
#endif // CLIENT_DLL
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ConVar tf_dev_marked_for_death_lifetime( "tf_dev_marked_for_death_lifetime", "15.0", FCVAR_DEVELOPMENTONLY );
ConVar tf_dev_health_on_damage_recover_percentage( "tf_dev_health_on_damage_recover_percentage", "0.35", FCVAR_DEVELOPMENTONLY );
void CTFWeaponBase::ApplyOnHitAttributes( CBaseEntity *pVictimBaseEntity, CTFPlayer *pAttacker, const CTakeDamageInfo &info )
{
if ( !pAttacker )
return;
CTFPlayer *pVictim = ToTFPlayer( pVictimBaseEntity );
// Ammo on hit
int iModAmmoOnHit = 0;
CALL_ATTRIB_HOOK_INT( iModAmmoOnHit, add_onhit_addammo );
if ( iModAmmoOnHit > 0 )
{
// this will save the value so we can add it after we're doing firing
// the projectile and have subtracted the ammo for the current shot
float flPercentage = (float)iModAmmoOnHit / 100.0f;
// No ammo for disguised Spies that are NOT stealthed so you can't use this to check for Spies
if ( pVictim &&
pVictim->IsPlayerClass( TF_CLASS_SPY ) &&
pVictim->m_Shared.InCond( TF_COND_DISGUISED ) &&
!( pVictim->m_Shared.IsStealthed() || pVictim->m_Shared.InCond( TF_COND_STEALTHED_BLINK ) ) )
{
flPercentage = 0.0f;
}
m_iAmmoToAdd += (int)( flPercentage * info.GetDamage() );
}
int iExtraDamageOnHit = 0;
CALL_ATTRIB_HOOK_INT( iExtraDamageOnHit, extra_damage_on_hit );
if ( iExtraDamageOnHit )
{
// Adds 'Heads'. Reusing this data field
int iDecap = pAttacker->m_Shared.GetDecapitations();
pAttacker->m_Shared.SetDecapitations( Min( 200, iDecap + iExtraDamageOnHit ) );
}
// Everything else is only for player enemies or Halloween bosses
// We don't want buildables or the tank doing things like giving health or increasing ubercharge
if ( !( pVictim || dynamic_cast< CHalloweenBaseBoss* >( pVictimBaseEntity ) ) )
{
return;
}
bool bIsSpyRevealed = false;
if ( pVictim )
{
// Reveal cloaked Spy on hit
if ( pVictim->IsPlayerClass( TF_CLASS_SPY ) && pVictim->m_Shared.IsStealthed() )
{
int iRevealCloakedSpyOnHit = 0;
CALL_ATTRIB_HOOK_INT( iRevealCloakedSpyOnHit, reveal_cloaked_victim_on_hit );
if ( iRevealCloakedSpyOnHit > 0 )
{
pVictim->RemoveInvisibility();
bIsSpyRevealed = true;
}
}
// Reveal disguised Spy on hit
if ( pVictim->IsPlayerClass( TF_CLASS_SPY ) && pVictim->m_Shared.InCond( TF_COND_DISGUISED ) )
{
int iRevealDisguisedSpyOnHit = 0;
CALL_ATTRIB_HOOK_INT( iRevealDisguisedSpyOnHit, reveal_disguised_victim_on_hit );
if ( iRevealDisguisedSpyOnHit > 0 )
{
pVictim->RemoveDisguise();
bIsSpyRevealed = true;
}
}
if ( bIsSpyRevealed )
{
color32 colorHit = { 255, 255, 255, 255 };
UTIL_ScreenFade( pVictim, colorHit, 0.25f, 0.1f, FFADE_IN );
// pVictim->EmitSound( "Weapon_DRG_Wrench.RevealSpy" );
}
// On hit attributes don't work when you shoot disguised spies
if ( pVictim->m_Shared.InCond( TF_COND_DISGUISED ) )
return;
}
// Or from burn damage
if ( (info.GetDamageType() & DMG_BURN) )
return;
// Heal on hits
int iModHealthOnHit = 0;
CALL_ATTRIB_HOOK_INT( iModHealthOnHit, add_onhit_addhealth );
if ( iModHealthOnHit )
{
// Scale Health mod with damage dealt, input being the maximum amount of health possible
float flScale = Clamp( info.GetDamage() / info.GetBaseDamage(), 0.f, 1.0f );
iModHealthOnHit = (int)((float)iModHealthOnHit * flScale );
}
// Charge meter on hit
float flChargeRefill = 0.0f;
CALL_ATTRIB_HOOK_FLOAT( flChargeRefill, charge_meter_on_hit );
if ( flChargeRefill > 0 )
{
pAttacker->m_Shared.SetDemomanChargeMeter( pAttacker->m_Shared.GetDemomanChargeMeter() + flChargeRefill * 100.0f );
}
// Speed on hit
int iSpeedBoostOnHit = 0;
CALL_ATTRIB_HOOK_INT( iSpeedBoostOnHit, speed_boost_on_hit );
if ( iSpeedBoostOnHit )
{
pAttacker->m_Shared.AddCond( TF_COND_SPEED_BOOST, iSpeedBoostOnHit );
}
if ( pVictim )
{
if ( pVictim->m_Shared.InCond( TF_COND_MAD_MILK ) )
{
int nAmount = info.GetDamage() * 0.6f;
iModHealthOnHit += nAmount;
CTFPlayer *pProvider = ToTFPlayer( pVictim->m_Shared.GetConditionProvider( TF_COND_MAD_MILK ) );
if ( pProvider )
{
// Only give points for the portion they're responsible for
if ( pProvider != pAttacker )
{
CTF_GameStats.Event_PlayerHealedOtherAssist( pProvider, nAmount );
}
// Show in the medic's UI as primary healing
IGameEvent *event = gameeventmanager->CreateEvent( "player_healed" );
if ( event )
{
event->SetInt( "priority", 1 ); // HLTV event priority
event->SetInt( "patient", pAttacker->GetUserID() );
event->SetInt( "healer", pProvider->GetUserID() );
event->SetInt( "amount", iModHealthOnHit );
gameeventmanager->FireEvent( event );
}
// Give them a little bit of Uber
CWeaponMedigun *pMedigun = static_cast<CWeaponMedigun *>( pProvider->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
if ( pMedigun )
{
int iHealedAmount = Max( Min( (int)pAttacker->GetMaxHealth() - (int)pAttacker->GetHealth(), nAmount ), 0 );
// On Mediguns, per frame, the amount of uber added is based on
// Default heal rate is 24per second, we scale based on that and frametime
pMedigun->AddCharge( (iHealedAmount / 24.0f ) * gpGlobals->frametime );
}
}
}
}
if ( pAttacker->m_Shared.InCond( TF_COND_REGENONDAMAGEBUFF ) )
{
int nAmount = info.GetDamage() * tf_dev_health_on_damage_recover_percentage.GetFloat();
iModHealthOnHit += nAmount;
// Increment provider's healing assist stat
CTFPlayer *pProvider = ToTFPlayer( pAttacker->m_Shared.GetConditionProvider( TF_COND_REGENONDAMAGEBUFF ) );
if ( pProvider && pProvider != pAttacker )
{
// Only give points for the portion they're responsible for
CTF_GameStats.Event_PlayerHealedOtherAssist( pProvider, nAmount );
}
}
if ( iModHealthOnHit )
{
if ( iModHealthOnHit > 0 )
{
int iHealed = pAttacker->TakeHealth( iModHealthOnHit, DMG_GENERIC );
// Increment attacker's healing stat
if ( iHealed )
{
CTF_GameStats.Event_PlayerHealedOther( pAttacker, iHealed );
}
}
else
{
pAttacker->TakeDamage( CTakeDamageInfo( pAttacker, this, (iModHealthOnHit * -1), DMG_GENERIC ) );
}
IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
if ( event )
{
event->SetInt( "amount", iModHealthOnHit );
event->SetInt( "entindex", pAttacker->entindex() );
item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
if ( GetAttributeContainer() && GetAttributeContainer()->GetItem() )
{
healingItemDef = GetAttributeContainer()->GetItem()->GetItemDefIndex();
}
event->SetInt( "weapon_def_index", healingItemDef );
gameeventmanager->FireEvent( event );
}
}
// Add ubercharge on hit
if ( pAttacker->IsPlayerClass( TF_CLASS_MEDIC ) )
{
float flUberChargeBonus = 0;
CALL_ATTRIB_HOOK_FLOAT( flUberChargeBonus, add_onhit_ubercharge );
if ( flUberChargeBonus )
{
CWeaponMedigun *pMedigun = (CWeaponMedigun *)pAttacker->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN );
if ( pMedigun )
{
pMedigun->AddCharge( flUberChargeBonus );
}
}
}
// Lower rage on hit.
if ( pAttacker->IsPlayerClass( TF_CLASS_SOLDIER ) || pAttacker->IsPlayerClass( TF_CLASS_PYRO ) )
{
int iRageOnHit = 0;
CALL_ATTRIB_HOOK_INT( iRageOnHit, rage_on_hit );
pAttacker->m_Shared.ModifyRage( iRageOnHit );
}
// rune charge on hit
if ( pAttacker->m_Shared.CanRuneCharge() )
{
const float flMaxRuneCharge = 400.f;
float flAdd = (float)info.GetDamage() * ( 100.f / flMaxRuneCharge );
pAttacker->m_Shared.SetRuneCharge( pAttacker->m_Shared.GetRuneCharge() + flAdd );
}
// Increase Boost on hit
int iBoostOnDamage = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iBoostOnDamage, boost_on_damage );
if ( iBoostOnDamage != 0 )
{
float fHype = MIN( tf_scout_hype_pep_max.GetFloat(), pAttacker->m_Shared.GetScoutHypeMeter() + ( MAX( tf_scout_hype_pep_min_damage.GetFloat(), info.GetDamage() ) / tf_scout_hype_pep_mod.GetFloat() ) );
pAttacker->m_Shared.SetScoutHypeMeter( fHype );
pAttacker->TeamFortress_SetSpeed();
}
// Procs!
if( pVictim )
{
// Detemine weapon speed
float flFireDelay = ApplyFireDelay( m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flTimeFireDelay );
// Proc chance for AOE Heal
float flPPM = 0.f;
CALL_ATTRIB_HOOK_FLOAT( flPPM, aoe_heal_chance );
float flProcChance = flFireDelay * (flPPM / 60.f);
if( RandomFloat() < flProcChance )
{
pAttacker->m_Shared.AddCond( TF_COND_RADIUSHEAL_ON_DAMAGE, 1.0f );
}
// Proc chance for crit boost
flPPM = 0.f;
CALL_ATTRIB_HOOK_FLOAT( flPPM, crits_on_damage );
flProcChance = flFireDelay * (flPPM / 60.f);
if( RandomFloat() < flProcChance )
{
pAttacker->m_Shared.AddCond( TF_COND_CRITBOOSTED_CARD_EFFECT, 3 );
}
// Proc chance for stun
flPPM = 0.f;
CALL_ATTRIB_HOOK_FLOAT( flPPM, stun_on_damage );
flProcChance = flFireDelay * (flPPM / 60.f);
if( RandomFloat() < flProcChance )
{
pVictim->m_Shared.StunPlayer( 3.0, 1.f, TF_STUN_MOVEMENT | TF_STUN_CONTROLS, pAttacker );
}
// Proc chance for AOE Blast
flPPM = 0.f;
CALL_ATTRIB_HOOK_FLOAT ( flPPM, aoe_blast_on_damage );
flProcChance = flFireDelay * (flPPM / 60.f);
if ( (RandomFloat() < flProcChance) )
{
// Stun the source
float flStunDuration = 2.f;
float flStunAmt = 1.f;
pVictim->m_Shared.StunPlayer( flStunDuration, flStunAmt, TF_STUN_MOVEMENT | TF_STUN_CONTROLS | TF_STUN_NO_EFFECTS, pAttacker );
pVictim->m_Shared.MakeBleed( ToTFPlayer( pAttacker ), NULL, flStunDuration, 75 );
// Generate an explosion and look for nearby bots
float flDmgRange = 100.f;
const int nMaxEnts = 12;
CBaseEntity *pObjects[ nMaxEnts ];
CTFPlayer* pPrevTFPlayer = NULL;
int nCount = UTIL_EntitiesInSphere( pObjects, nMaxEnts, pVictim->GetAbsOrigin(), flDmgRange, FL_CLIENT );
for ( int i = 0; i < nCount; i++ )
{
if ( !pObjects[i] )
continue;
if ( !pObjects[i]->IsAlive() )
continue;
if ( pObjects[i]->GetTeamNumber() != pVictim->GetTeamNumber() )
continue;
if ( !FVisible( pObjects[i], MASK_OPAQUE ) )
continue;
CTFPlayer *pTFPlayer = static_cast<CTFPlayer *>( pObjects[i] );
if ( !pTFPlayer )
continue;
if ( pTFPlayer == pVictim )
continue;
if ( !pTFPlayer->IsBot() )
continue;
if ( pVictim->m_Shared.InCond( TF_COND_PHASE ) || pVictim->m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
continue;
if ( pVictim->m_Shared.IsInvulnerable() )
continue;
// Stun
pTFPlayer->m_Shared.StunPlayer( flStunDuration, flStunAmt, TF_STUN_MOVEMENT | TF_STUN_CONTROLS | TF_STUN_NO_EFFECTS, pAttacker );
// DoT
pTFPlayer->m_Shared.MakeBleed( ToTFPlayer( pAttacker ), NULL, flStunDuration, 75.f );
// Shoot a beam at them
CPVSFilter filter( pTFPlayer->WorldSpaceCenter() );
Vector vStart = pPrevTFPlayer == NULL ? pVictim->EyePosition() : pPrevTFPlayer->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" );
pPrevTFPlayer = pTFPlayer;
}
}
}
// Damage bonus on hit
// Disabled because we have no attributes that use it
/*
float flAddDamageDoneBonusOnHit = 0;
CALL_ATTRIB_HOOK_FLOAT( flAddDamageDoneBonusOnHit, addperc_ondmgdone_tmpbuff );
if ( flAddDamageDoneBonusOnHit )
{
pAttacker->m_Shared.AddTmpDamageBonus( flAddDamageDoneBonusOnHit, 10.0 );
}
*/
if ( pVictim )
{
int iRageStun = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iRageStun, generate_rage_on_dmg );
if ( iRageStun && pAttacker->m_Shared.IsRageDraining() )
{
// MvM: Heavies can purchase a rage-based knockback+stun effect
if ( pAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
int iStunFlags = TF_STUN_MOVEMENT | TF_STUN_NO_EFFECTS;
pVictim->m_Shared.StunPlayer( 0.25f, 1.f, iStunFlags, pAttacker );
}
}
// Slow enemy on hit, unless they're being healed by a medic
if ( !pVictim->m_Shared.InCond( TF_COND_HEALTH_BUFF ) )
{
float flSlowEnemy = 0.0;
CALL_ATTRIB_HOOK_FLOAT( flSlowEnemy, mult_onhit_enemyspeed );
if ( flSlowEnemy )
{
if ( RandomFloat() < flSlowEnemy )
{
// Adjust the stun amount based on distance to the target
// close range full stun, falls off to zero at 1536 (1024 window size)
Vector vecDistance = pVictim->GetAbsOrigin() - pAttacker->GetAbsOrigin();
float flStunAmount = RemapValClamped( vecDistance.LengthSqr(), (512.0f * 512.0f), (1536.0f * 1536.0f), 0.60f, 0.0f );
pVictim->m_Shared.StunPlayer( 0.2, flStunAmount, TF_STUN_MOVEMENT, pAttacker );
}
}
flSlowEnemy = 0.0;
CALL_ATTRIB_HOOK_FLOAT( flSlowEnemy, mult_onhit_enemyspeed_major );
if ( flSlowEnemy )
{
pVictim->m_Shared.StunPlayer( flSlowEnemy, 0.4, TF_STUN_MOVEMENT, pAttacker );
}
}
// Mark for death on hit.
int iMarkForDeath = 0;
CALL_ATTRIB_HOOK_INT( iMarkForDeath, mark_for_death );
if ( iMarkForDeath )
{
// Note: this logic isn't perfect, and can do non-obvious things in certain situations. For example,
// imagine that we've got two scouts -- if the first scout marks someone, and then the second scout marks
// the same guy, and then the first scout marks someone else, the original victim will lose his marked-
// for-death status. Conditions don't have any concept of owner. This could be manually tracked for this
// condition if it becomes a problem.
if ( pAttacker->m_pMarkedForDeathTarget != NULL && pAttacker->m_pMarkedForDeathTarget->m_Shared.InCond( TF_COND_MARKEDFORDEATH ) )
{
pAttacker->m_pMarkedForDeathTarget->m_Shared.RemoveCond( TF_COND_MARKEDFORDEATH );
}
float flDuration = pVictim->IsMiniBoss() ? tf_dev_marked_for_death_lifetime.GetFloat() / 2 : tf_dev_marked_for_death_lifetime.GetFloat();
pVictim->m_Shared.AddCond( TF_COND_MARKEDFORDEATH, flDuration, pAttacker );
pAttacker->m_pMarkedForDeathTarget = pVictim;
// ACHIEVEMENT_TF_MVM_SCOUT_MARK_FOR_DEATH
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
if ( pAttacker->IsPlayerClass( TF_CLASS_SCOUT ) && ( GetWeaponID() == TF_WEAPON_BAT_WOOD ) )
{
if ( pVictim->IsBot() && ( pVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
{
IGameEvent *event = gameeventmanager->CreateEvent( "mvm_scout_marked_for_death" );
if ( event )
{
event->SetInt( "player", pAttacker->entindex() );
gameeventmanager->FireEvent( event );
}
}
}
}
}
// Stun airborne enemies who are half a body length higher than attacker
bool bIsVictimAirborne = !( pVictim->GetFlags() & FL_ONGROUND ) && ( pVictim->GetWaterLevel() == WL_NotInWater );
int iStunWaistHighAirborne = 0;
CALL_ATTRIB_HOOK_INT( iStunWaistHighAirborne, stun_waist_high_airborne );
if ( iStunWaistHighAirborne > 0 && bIsVictimAirborne )
{
if ( pVictim->WorldSpaceCenter().z >= pAttacker->EyePosition().z )
{
// right in the jimmy!
pVictim->m_Shared.StunPlayer( iStunWaistHighAirborne, 0.5f, TF_STUN_LOSER_STATE | TF_STUN_BOTH, pAttacker );
pVictim->EmitSound( "Halloween.PlayerScream" );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: When owner of this weapon is hit
//-----------------------------------------------------------------------------
void CTFWeaponBase::ApplyOnInjuredAttributes( CTFPlayer *pVictim, CTFPlayer *pAttacker, const CTakeDamageInfo &info )
{
if ( CanDeploy() )
{
int iBecomeFireproofOnHitByFire = 0;
CALL_ATTRIB_HOOK_INT( iBecomeFireproofOnHitByFire, become_fireproof_on_hit_by_fire );
if ( iBecomeFireproofOnHitByFire > 0 && info.GetDamageType() & DMG_BURN )
{
pVictim->m_Shared.AddCond( TF_COND_FIRE_IMMUNE, 1.0 );
if ( pVictim->m_Shared.InCond( TF_COND_BURNING ) )
{
pVictim->EmitSound( "TFPlayer.FlameOut" );
pVictim->m_Shared.RemoveCond( TF_COND_BURNING );
}
// STAGING_SPY
pVictim->m_Shared.AddCond( TF_COND_AFTERBURN_IMMUNE, iBecomeFireproofOnHitByFire );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ApplyPostHitEffects( const CTakeDamageInfo &info, CTFPlayer *pVictim )
{
bool bDidDrain = false;
CTFPlayer *pAttacker = ToTFPlayer( info.GetAttacker() );
if ( !pAttacker || !pVictim )
return;
// only drain a victim once per shot, even with penetrating weapons
if ( pVictim != m_hLastDrainVictim || m_lastDrainVictimTimer.IsElapsed() )
{
// Subtract victim's Medigun charge on hit
int iSubtractVictimMedigunChargeOnHit = 0;
CALL_ATTRIB_HOOK_INT( iSubtractVictimMedigunChargeOnHit, subtract_victim_medigun_charge_onhit );
if ( iSubtractVictimMedigunChargeOnHit > 0 )
{
CWeaponMedigun *pMedigun = (CWeaponMedigun *)pVictim->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN );
if ( pMedigun && !pMedigun->IsReleasingCharge() )
{
// STAGING_ENGY
// Scale drain after 512 Hu to 1536Hu ( 50% drain at 1024, 0 drain at 1536 units )
Vector toEnt = pVictim->GetAbsOrigin() - pAttacker->GetAbsOrigin();
if ( toEnt.LengthSqr() > Square( 512.0f ) )
{
iSubtractVictimMedigunChargeOnHit *= RemapValClamped( toEnt.LengthSqr(), (512.0f * 512.0f), (1536.0f * 1536.0f), 1.0f, 0.0f );
}
pMedigun->SubtractCharge( iSubtractVictimMedigunChargeOnHit / 100.0f );
bDidDrain = true;
}
}
// Subtract victim's cloak on hit
int iSubtractVictimCloakOnHit = 0;
CALL_ATTRIB_HOOK_INT( iSubtractVictimCloakOnHit, subtract_victim_cloak_on_hit );
if ( iSubtractVictimCloakOnHit > 0 && pVictim->IsPlayerClass( TF_CLASS_SPY ) )
{
// STAGING_ENGY
// Scale drain after 512 Hu to 1536Hu ( 50% drain at 1024, 0 drain at 1536 units )
Vector toEnt = pVictim->GetAbsOrigin() - pAttacker->GetAbsOrigin();
if ( toEnt.LengthSqr() > Square( 512.0f ) )
{
iSubtractVictimCloakOnHit *= RemapValClamped( toEnt.LengthSqr(), (512.0f * 512.0f), (1536.0f * 1536.0f), 1.0f, 0.0f );
}
float flCloak = pVictim->m_Shared.GetSpyCloakMeter();
flCloak -= iSubtractVictimCloakOnHit;
if ( flCloak < 0.0f )
{
flCloak = 0.0f;
}
pVictim->m_Shared.SetSpyCloakMeter( flCloak );
bDidDrain = true;
}
// don't play effects to attacker if he hit a disguised/cloaked spy
if ( !pVictim->m_Shared.InCond( TF_COND_DISGUISED ) &&
!pVictim->m_Shared.IsStealthed() )
{
if ( bDidDrain )
{
DispatchParticleEffect( "drg_pomson_impact_drain", PATTACH_POINT, pVictim, "head", GetParticleColor( 1 ), GetParticleColor( 2 ) );
if ( pAttacker )
{
// play drain sound effect, louder for the attacker
EmitSound_t params;
params.m_flSoundTime = 0;
params.m_pSoundName = "Weapon_Pomson.DrainedVictim";
params.m_pflSoundDuration = 0;
CPASFilter filter( pVictim->GetAbsOrigin() );
filter.RemoveRecipient( pAttacker );
EmitSound( filter, pVictim->entindex(), params );
CSingleUserRecipientFilter attackerFilter( pAttacker );
EmitSound( attackerFilter, pAttacker->entindex(), params );
}
m_hLastDrainVictim = pVictim;
m_lastDrainVictimTimer.Start( 0.3f );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// Deliberately disabled to prevent players picking up fallen weapons.
return;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::DisguiseWeaponThink( void )
{
// Periodically check to make sure we are valid.
// Disguise weapons are attached to a player, but not managed through the owned weapons list.
CTFPlayer *pTFOwner = ToTFPlayer( GetOwner() );
if ( !pTFOwner )
{
// We must have an owner to be valid.
Drop( Vector( 0,0,0 ) );
return;
}
if ( pTFOwner->m_Shared.GetDisguiseWeapon() != this )
{
// The owner's disguise weapon must be us, otherwise we are invalid.
Drop( Vector( 0,0,0 ) );
return;
}
SetContextThink( &CTFWeaponBase::DisguiseWeaponThink, gpGlobals->curtime + 0.5, "DisguiseWeaponThink" );
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::IsViewModelFlipped( void )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return false;
#ifdef GAME_DLL
if ( m_bFlipViewModel != pPlayer->m_bFlipViewModels )
{
return true;
}
#else
if ( m_bFlipViewModel != cl_flipviewmodels.GetBool() )
{
return true;
}
#endif
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ReapplyProvision( void )
{
// Disguise items never provide
if ( m_bDisguiseWeapon )
{
#ifdef GAME_DLL
UpdateModelToClass();
#endif
return;
}
int iProvideMode = 0;
CALL_ATTRIB_HOOK_INT( iProvideMode, provide_on_active );
if ( 1 == iProvideMode )
{
if ( m_iState == WEAPON_IS_ACTIVE )
{
// We are active, provide to our owner.
BaseClass::ReapplyProvision();
}
else
{
// We aren't active so stop providing to our owner.
GetAttributeManager()->StopProvidingTo( GetPlayerOwner() );
m_hOldProvidee = NULL;
}
}
else
{
BaseClass::ReapplyProvision();
}
}
//-----------------------------------------------------------------------------
// Purpose: Return the origin & angles for a projectile fired from the player's gun
//-----------------------------------------------------------------------------
void CTFWeaponBase::GetProjectileFireSetup( CTFPlayer *pPlayer, Vector vecOffset, Vector *vecSrc, QAngle *angForward, bool bHitTeammates /* = true */, float flEndDist /* = 2000 */)
{
// @todo third person code!!
// Flip the firing offset if our view model is flipped.
if ( IsViewModelFlipped() )
{
vecOffset.y *= -1;
}
int iCenterFireProjectile = 0;
CALL_ATTRIB_HOOK_INT( iCenterFireProjectile, centerfire_projectile );
if ( iCenterFireProjectile == 1 )
{
vecOffset.y = 0;
}
QAngle angSpread = GetSpreadAngles();
Vector vecForward, vecRight, vecUp;
AngleVectors( angSpread, &vecForward, &vecRight, &vecUp );
Vector vecShootPos = pPlayer->Weapon_ShootPosition();
// Estimate end point
Vector endPos = vecShootPos + vecForward * flEndDist;
// Trace forward and find what's in front of us, and aim at that
trace_t tr;
if ( bHitTeammates )
{
CTraceFilterSimple traceFilter( pPlayer, COLLISION_GROUP_NONE );
ITraceFilter *pFilterChain = NULL;
CTraceFilterIgnoreFriendlyCombatItems traceFilterCombatItem( pPlayer, COLLISION_GROUP_NONE, GetTeamNumber() );
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
{
// Ignore teammates and their (physical) upgrade items in MvM
pFilterChain = &traceFilterCombatItem;
}
CTraceFilterChain traceFilterChain( &traceFilter, pFilterChain );
UTIL_TraceLine( vecShootPos, endPos, MASK_SOLID, &traceFilterChain, &tr );
}
else
{
CTraceFilterIgnoreTeammates filter( pPlayer, COLLISION_GROUP_NONE, pPlayer->GetTeamNumber() );
UTIL_TraceLine( vecShootPos, endPos, MASK_SOLID, &filter, &tr );
}
// Offset actual start point
*vecSrc = vecShootPos + (vecForward * vecOffset.x) + (vecRight * vecOffset.y) + (vecUp * vecOffset.z);
// Find angles that will get us to our desired end point
// Only use the trace end if it wasn't too close, which results
// in visually bizarre forward angles
if ( tr.fraction > 0.1 )
{
VectorAngles( tr.endpos - *vecSrc, *angForward );
}
else
{
VectorAngles( endPos - *vecSrc, *angForward );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
QAngle CTFWeaponBase::GetSpreadAngles( void )
{
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
Assert( pOwner );
QAngle angEyes = pOwner->EyeAngles();
float flSpreadAngle = 0.0f;
CALL_ATTRIB_HOOK_FLOAT( flSpreadAngle, projectile_spread_angle );
if ( flSpreadAngle )
{
QAngle angSpread = RandomAngle( -flSpreadAngle, flSpreadAngle );
angSpread.z = 0.0f;
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
{
if ( CanOverload() && AutoFiresFullClip() && Clip1() == 1 && !m_bFiringWholeClip )
{
float flTimeSinceLastAttack = gpGlobals->curtime - GetLastPrimaryAttackTime();
if ( flTimeSinceLastAttack < 0.9f )
{
// Punish upgraded single-fire spam for this class of weapon
float flPenaltyAngle = RemapValClamped( flTimeSinceLastAttack, 0.4f, 0.9f, 6.f, 1.f );
angSpread += RandomAngle( -flPenaltyAngle, flPenaltyAngle );
}
}
}
angEyes += angSpread;
}
return angEyes;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CanPerformSecondaryAttack() const
{
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
// Demo shields are allowed to charge whenever
if ( pOwner->m_Shared.HasDemoShieldEquipped() )
return true;
return BaseClass::CanPerformSecondaryAttack();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::AreRandomCritsEnabled( void )
{
if ( TFGameRules() )
{
if ( TFGameRules()->IsPowerupMode() )
return false;
const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
if ( pMatchDesc )
return pMatchDesc->m_params.m_bRandomWeaponCrits;
}
return tf_weapon_criticals.GetBool();
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::ChangeTeam( int iTeamNum )
{
BaseClass::ChangeTeam( iTeamNum );
// We need to set the team for our econ item view as well
if ( GetAttributeContainer() && GetAttributeContainer()->GetItem() )
{
GetAttributeContainer()->GetItem()->SetTeamNumber( GetTeamNumber() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::DeflectProjectiles()
{
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
if ( !pOwner )
return false;
if ( pOwner->GetWaterLevel() == WL_Eyes )
return false;
lagcompensation->StartLagCompensation( pOwner, pOwner->GetCurrentCommand() );
Vector vecEye = pOwner->EyePosition();
Vector vecForward, vecRight, vecUp;
AngleVectors( pOwner->EyeAngles(), &vecForward, &vecRight, &vecUp );
Vector vecSize = GetDeflectionSize();
float flMaxElement = 0.0f;
for ( int i = 0; i < 3; ++i )
{
flMaxElement = MAX( flMaxElement, vecSize[i] );
}
Vector vecCenter = vecEye + vecForward * flMaxElement;
// Get a list of entities in the box defined by vecSize at VecCenter.
// We will then try to deflect everything in the box.
const int maxCollectedEntities = 64;
CBaseEntity *pObjects[ maxCollectedEntities ];
int count = UTIL_EntitiesInBox( pObjects, maxCollectedEntities, vecCenter - vecSize, vecCenter + vecSize, FL_CLIENT | FL_GRENADE );
// NDebugOverlay::Box( vecCenter, -vecSize, vecSize, 0, 255, 0, 40, 3 );
bool bDeflected = false;
bool bDeflectedPlayer = false;
int iEnemyTeam = GetEnemyTeam( pOwner->GetTeamNumber() );
bool bTruce = TFGameRules() && TFGameRules()->IsTruceActive() && pOwner->IsTruceValidForEnt();
for ( int i = 0; i < count; i++ )
{
if ( pObjects[i] == pOwner )
continue;
if ( pObjects[i]->IsPlayer() && pObjects[i]->GetTeamNumber() == TEAM_SPECTATOR )
continue;
if ( !pObjects[i]->IsDeflectable() && !FClassnameIs( pObjects[i], "prop_physics" ) )
continue;
if ( pOwner->FVisible( pObjects[i], MASK_SOLID ) == false )
continue;
if ( bTruce && ( pObjects[i]->GetTeamNumber() == iEnemyTeam ) )
continue;
if ( pObjects[i]->IsPlayer() == true )
{
CTFPlayer *pTarget = ToTFPlayer( pObjects[i] );
if ( pTarget )
{
bool bRes = DeflectPlayer( pTarget, pOwner, vecForward, vecCenter, vecSize );
bDeflectedPlayer |= bRes;
bDeflected |= bRes;
}
}
else
{
bDeflected |= DeflectEntity( pObjects[i], pOwner, vecForward, vecCenter, vecSize );
}
}
if ( bDeflected )
{
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_DEFLECTED, "victim:0" );
PlayDeflectionSound( bDeflectedPlayer );
}
lagcompensation->FinishLagCompensation( pOwner );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::DeflectPlayer( CTFPlayer *pTarget, CTFPlayer *pOwner, Vector &vecForward, Vector &vecCenter, Vector &vecSize )
{
return true;
}
//-----------------------------------------------------------------------------
// This filter checks against friendly players, buildings, shields
//-----------------------------------------------------------------------------
class CTraceFilterDeflection : public CTraceFilterSimple
{
public:
DECLARE_CLASS( CTraceFilterDeflection, CTraceFilterSimple );
CTraceFilterDeflection( const IHandleEntity *passentity, int collisionGroup, int iIgnoreTeam )
: CTraceFilterSimple( passentity, collisionGroup ), m_iIgnoreTeam( iIgnoreTeam )
{
}
virtual bool ShouldHitEntity( IHandleEntity *passentity, int contentsMask ) OVERRIDE
{
CBaseEntity *pEntity = EntityFromEntityHandle( passentity );
if ( !pEntity )
return false;
if ( pEntity->IsPlayer() )
return false;
if ( pEntity->IsBaseObject() )
return false;
if ( pEntity->IsCombatItem() )
return false;
return BaseClass::ShouldHitEntity( passentity, contentsMask );
}
int m_iIgnoreTeam;
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::DeflectEntity( CBaseEntity *pTarget, CTFPlayer *pOwner, Vector &vecForward, Vector &vecCenter, Vector &vecSize )
{
Assert( pTarget );
Assert( pOwner );
Vector vecEye = pOwner->EyePosition();
Vector vecVel = pTarget->GetAbsVelocity();
// apply an impulse instead if this is a prop physics object
if ( FClassnameIs( pTarget, "prop_physics" ) )
{
IPhysicsObject *pPhysicsObject = pTarget->VPhysicsGetObject();
if ( pPhysicsObject && pTarget->CollisionProp() )
{
Vector vecDir = pTarget->WorldSpaceCenter() - vecEye;
VectorNormalize( vecDir );
float flVel = 50.0f * CTFWeaponBase::DeflectionForce( pTarget->CollisionProp()->OBBSize(), 90, 12.0f );
pPhysicsObject->ApplyForceOffset( vecDir * flVel, vecEye );
}
return true;
}
AngularImpulse angularimp;
CTraceFilterDeflection filter( pOwner, COLLISION_GROUP_NONE, pOwner->GetTeamNumber() );
trace_t tr;
UTIL_TraceLine( vecEye, vecEye + vecForward * MAX_TRACE_LENGTH, MASK_SOLID, &filter, &tr );
Vector vecDir = pTarget->WorldSpaceCenter() - tr.endpos;
VectorNormalize( vecDir );
// Send the entity back where it came.
// If we want per-entity physical deflection behavior this could move into ::Deflected
IPhysicsObject *pPhysicsObject = pTarget->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->GetVelocity( &vecVel, &angularimp );
}
float flVel = vecVel.Length();
vecVel = -flVel * vecDir;
if ( pPhysicsObject )
{
if ( pPhysicsObject->IsMotionEnabled() == false )
{
vecDir = pOwner->WorldSpaceCenter() - pTarget->WorldSpaceCenter();
VectorNormalize( vecDir );
vecVel = -flVel * vecDir;
}
pPhysicsObject->EnableMotion( true );
pPhysicsObject->SetVelocity( &vecVel, &angularimp );
}
else
{
pTarget->SetAbsVelocity( vecVel );
}
// Perform entity specific deflection behavior like team changing.
pTarget->Deflected( pOwner, vecDir );
QAngle newAngles;
VectorAngles( -vecDir, newAngles );
pTarget->SetAbsAngles( newAngles );
pOwner->AwardAchievement( ACHIEVEMENT_TF_PYRO_REFLECT_PROJECTILES );
CDisablePredictionFiltering disabler;
DispatchParticleEffect( "deflect_fx", PATTACH_ABSORIGIN_FOLLOW, pTarget );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Static deflection helper.
//-----------------------------------------------------------------------------
float CTFWeaponBase::DeflectionForce( const Vector &size, float damage, float scale )
{
float force = damage * ((48 * 48 * 82.0) / (size.x * size.y * size.z)) * scale;
if ( force > 1000.0)
{
force = 1000.0;
}
return force;
}
//-----------------------------------------------------------------------------
// Purpose: Static deflection helper.
//-----------------------------------------------------------------------------
void CTFWeaponBase::SendObjectDeflectedEvent( CTFPlayer *pNewOwner, CTFPlayer *pPrevOwner, int iWeaponID, CBaseAnimating *pObject )
{
if ( pNewOwner && pPrevOwner )
{
IGameEvent * event = gameeventmanager->CreateEvent( "object_deflected" );
if ( event )
{
event->SetInt( "userid", pNewOwner->GetUserID() );
event->SetInt( "ownerid", pPrevOwner->GetUserID() );
event->SetInt( "weaponid", iWeaponID );
// Community request. We don't use object_entindex, but some server plugins do.
event->SetInt( "object_entindex", pObject ? pObject->entindex() : 0 );
gameeventmanager->FireEvent( event );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Separate Regen function to handle item-specific cases
//-----------------------------------------------------------------------------
void CTFWeaponBase::ApplyItemRegen( void )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( !pOwner )
return;
m_flRegenTime += gpGlobals->frametime;
if ( m_flRegenTime > 1.0f )
{
m_flRegenTime -= 1.0;
float flRegenAmount = 0;
CALL_ATTRIB_HOOK_FLOAT( flRegenAmount, active_item_health_regen );
if ( (int)flRegenAmount != 0 )
{
pOwner->TakeDamage( CTakeDamageInfo( pOwner, pOwner, vec3_origin, WorldSpaceCenter(), (int)flRegenAmount * -1, DMG_GENERIC ) );
IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
if ( event )
{
event->SetInt( "amount", (int)flRegenAmount );
event->SetInt( "entindex", pOwner->entindex() );
item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
if ( GetAttributeContainer() && GetAttributeContainer()->GetItem() )
{
healingItemDef = GetAttributeContainer()->GetItem()->GetItemDefIndex();
}
event->SetInt( "weapon_def_index", healingItemDef );
gameeventmanager->FireEvent( event );
}
}
}
}
kill_eater_event_t CTFWeaponBase::GetKillEaterKillEventType() const
{
uint32 unEventType = kKillEaterEvent_PlayerKill;
CALL_ATTRIB_HOOK_INT( unEventType, kill_eater_kill_type );
return (kill_eater_event_t)unEventType;
}
#endif // GAME_DLL
bool CTFWeaponBase::IsSilentKiller()
{
int iSilentKiller = 0;
CALL_ATTRIB_HOOK_INT( iSilentKiller, set_silent_killer );
if ( iSilentKiller == 1 )
return true;
else
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Ensures that a player's correct body groups are enabled on client respawn.
//-----------------------------------------------------------------------------
void CTFWeaponBase::UpdateWeaponBodyGroups( CTFPlayer* pPlayer, bool bHandleDeployedBodygroups )
{
if ( !pPlayer )
return;
for ( int i = 0; i < pPlayer->WeaponCount(); i++)
{
CTFWeaponBase *pWpn = ( CTFWeaponBase *) pPlayer->GetWeapon(i);
if ( !pWpn )
continue;
// If this weapon if repurposed for a taunt, dont modify bodygroups. This is so
// things like the Heavy's boxing gloves can change to a different model (ie. a guitar)
// and then his hands will draw like normal
if( pWpn->IsBeingRepurposedForTaunt() )
continue;
// Dynamic models which are not yet rendering do not modify bodygroups
if ( pWpn->IsDynamicModelLoading() )
continue;
// These are updated later or have already been updated.
CEconItemView *pScriptItem = pWpn->GetAttributeContainer()->GetItem();
const bool bHideBodygroupsDeployedOnly = pScriptItem ? pScriptItem->GetStaticData()->GetHideBodyGroupsDeployedOnly() : false;
if ( bHideBodygroupsDeployedOnly != bHandleDeployedBodygroups )
continue;
// If we're supposed to hide bodygroups when deployed and we aren't deployed, don't do anything.
if ( bHideBodygroupsDeployedOnly && pPlayer->GetActiveWeapon() != pWpn )
continue;
pWpn->UpdateBodygroups( pPlayer, 1 );
}
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Weapon Level Notification
//-----------------------------------------------------------------------------
class CTFKillEaterNotification : public CEconNotification
{
public:
CTFKillEaterNotification( const CSteamID& KillerID, const wchar_t *wszWeaponName, const wchar_t *wszLevelName )
: CEconNotification()
{
SetLifetime( 20.0f );
SetSteamID( KillerID );
SetText( "#TF_HUD_Event_KillEater_Leveled" );
AddStringToken( "weapon_name", wszWeaponName );
AddStringToken( "rank_name", wszLevelName );
SetSoundFilename( "misc/happy_birthday.wav" );
}
virtual EType NotificationType() { return eType_Basic; }
};
//-----------------------------------------------------------------------------
// Purpose: GC Msg handler to receive the server response that we've killed a player.
//-----------------------------------------------------------------------------
class CGCPlayerKilledResponse : public GCSDK::CGCClientJob
{
public:
CGCPlayerKilledResponse( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg<CMsgGCIncrementKillCountResponse> msg( pNetPacket );
if ( !steamapicontext || !steamapicontext->SteamFriends() || !steamapicontext->SteamUser() || !steamapicontext->SteamUtils() )
return true;
item_definition_index_t unItemDef = msg.Body().item_def();
const CEconItemDefinition* pItemDef = ItemSystem()->GetStaticDataForItemByDefIndex( unItemDef );
if ( !pItemDef )
return true;
const char *pszKillerName = InventoryManager()->PersonaName_Get( msg.Body().killer_account_id() );
if ( !pszKillerName )
return true;
wchar_t wszPlayerName[1024];
g_pVGuiLocalize->ConvertANSIToUnicode( pszKillerName, wszPlayerName, sizeof(wszPlayerName) );
wchar_t* wszWeaponName = g_pVGuiLocalize->Find( pItemDef->GetItemBaseName() );
uint32 unLevelBlock = msg.Body().level_type();
const char *pszLevelBlockName = GetItemSchema()->GetKillEaterScoreTypeLevelingDataName( unLevelBlock );
const CItemLevelingDefinition *pLevelDef = GetItemSchema()->GetItemLevelForScore( pszLevelBlockName, msg.Body().num_kills() );
if ( !pLevelDef )
return true;
wchar_t* wszLevelName = g_pVGuiLocalize->Find( pLevelDef->GetNameLocalizationKey() );
// Kyle says: the notifications were annoying people so instead of doing a full
// flashy thing we display a HUD message for everyone except the guy whose
// weapon it is. Basically, *you* get the flashy notification that your
// weapon leveled up, but everyone else just gets the HUD text.
if ( steamapicontext->SteamUser()->GetSteamID().GetAccountID() == msg.Body().killer_account_id() )
{
NotificationQueue_Add( new CTFKillEaterNotification( CSteamID( msg.Body().killer_account_id(), GetUniverse(), k_EAccountTypeIndividual ), wszWeaponName, wszLevelName ) );
}
// Everyone gets the HUD notification text.
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
if ( pHUDChat )
{
wchar_t wszNotification[1024]=L"";
g_pVGuiLocalize->ConstructString_safe( wszNotification,
g_pVGuiLocalize->Find( "#TF_HUD_Event_KillEater_Leveled_Chat" ),
3, wszPlayerName, wszWeaponName, wszLevelName );
char szAnsi[1024];
g_pVGuiLocalize->ConvertUnicodeToANSI( wszNotification, szAnsi, sizeof(szAnsi) );
pHUDChat->Printf( CHAT_FILTER_NONE, "%s", szAnsi );
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCPlayerKilledResponse, "CGCPlayerKilledResponse", k_EMsgGC_IncrementKillCountResponse, GCSDK::k_EServerTypeGCClient );
#endif
bool WeaponID_IsSniperRifle( int iWeaponID )
{
#ifdef STAGING_ONLY
if ( iWeaponID == TF_WEAPON_SNIPERRIFLE ||
iWeaponID == TF_WEAPON_SNIPERRIFLE_DECAP ||
iWeaponID == TF_WEAPON_SNIPERRIFLE_CLASSIC ||
iWeaponID == TF_WEAPON_SNIPERRIFLE_REVOLVER )
#else
if ( iWeaponID == TF_WEAPON_SNIPERRIFLE ||
iWeaponID == TF_WEAPON_SNIPERRIFLE_DECAP ||
iWeaponID == TF_WEAPON_SNIPERRIFLE_CLASSIC )
#endif
return true;
else
return false;
}
bool WeaponID_IsSniperRifleOrBow( int iWeaponID )
{
if ( iWeaponID == TF_WEAPON_COMPOUND_BOW )
return true;
else
return WeaponID_IsSniperRifle( iWeaponID );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFWeaponBase::Energy_GetMaxEnergy( void ) const
{
// This is a terrible hack to support clip size upgrades.
// Basically -- figure out the desired number of shots,
// and return the amount of energy required for that.
int iNumShots = ENERGY_WEAPON_MAX_CHARGE / Energy_GetShotCost();
CALL_ATTRIB_HOOK_FLOAT( iNumShots, mult_clipsize_upgrade );
return ( iNumShots * Energy_GetShotCost() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Energy_FullyCharged( void ) const
{
if ( m_flEnergy >= Energy_GetMaxEnergy() )
return true;
else
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Energy_HasEnergy( void )
{
if ( m_flEnergy >= Energy_GetShotCost() )
return true;
else
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::Energy_DrainEnergy( void )
{
Energy_DrainEnergy( Energy_GetShotCost() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::Energy_DrainEnergy( float flDrain )
{
m_flEnergy -= flDrain;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::Energy_Recharge( void )
{
m_flEnergy += Energy_GetRechargeCost();
if ( Energy_FullyCharged() )
{
m_flEnergy = Energy_GetMaxEnergy();
return true;
}
else
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::WeaponRegenerate( void )
{
m_flEnergy = Energy_GetMaxEnergy();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::FinishReload( void )
{
if ( IsEnergyWeapon() )
{
m_bInReload = false;
return;
}
BaseClass::FinishReload();
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer )
{
int iAttr = 0;
CALL_ATTRIB_HOOK_INT( iAttr, last_shot_crits );
if ( iAttr )
{
if ( m_iClip1 == 1 )
{
pPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED );
}
else
{
pPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::CheckReload( void )
{
if ( IsEnergyWeapon() )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( !pOwner )
return;
if ( !Energy_HasEnergy() )
{
Reload();
return;
}
if ((m_bInReload) && (m_flNextPrimaryAttack <= gpGlobals->curtime))
{
if ( pOwner->m_nButtons & (IN_ATTACK | IN_ATTACK2) && Energy_HasEnergy() )
{
m_bInReload = false;
return;
}
if ( !Energy_FullyCharged() )
{
Reload();
}
else
{
FinishReload();
m_flNextPrimaryAttack = gpGlobals->curtime;
m_flNextSecondaryAttack = gpGlobals->curtime;
}
}
}
else
{
BaseClass::CheckReload();
}
}
//-----------------------------------------------------------------------------
// Purpose: Get the current bar state (will return a value from 0.0 to 1.0)
//-----------------------------------------------------------------------------
float CTFWeaponBase::GetEffectBarProgress( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && (pPlayer->GetAmmoCount( GetEffectBarAmmo() ) < pPlayer->GetMaxAmmo( GetEffectBarAmmo() )) )
{
float flTime = GetEffectBarRechargeTime();
float flProgress = (flTime - (m_flEffectBarRegenTime - gpGlobals->curtime)) / flTime;
return flProgress;
}
return 1.f;
}
//-----------------------------------------------------------------------------
// Purpose: Start the regeneration bar charging from this moment in time
//-----------------------------------------------------------------------------
void CTFWeaponBase::StartEffectBarRegen( void )
{
// Only reset regen if its less then curr time or we were full
CTFPlayer *pPlayer = GetTFPlayerOwner();
bool bWasFull = false;
if ( pPlayer && (pPlayer->GetAmmoCount( GetEffectBarAmmo() ) + 1 == pPlayer->GetMaxAmmo( GetEffectBarAmmo() ) ) )
{
bWasFull = true;
}
if ( m_flEffectBarRegenTime < gpGlobals->curtime || bWasFull )
{
m_flEffectBarRegenTime = gpGlobals->curtime + GetEffectBarRechargeTime();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::CheckEffectBarRegen( void )
{
if ( !m_flEffectBarRegenTime )
return;
// If we're full stop the timer. Fixes a bug with "double" throws after respawning or touching a supply cab
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer->GetAmmoCount( GetEffectBarAmmo() ) == pPlayer->GetMaxAmmo( GetEffectBarAmmo() ) )
{
m_flEffectBarRegenTime = 0;
return;
}
if ( m_flEffectBarRegenTime < gpGlobals->curtime )
{
m_flEffectBarRegenTime = 0;
EffectBarRegenFinished();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBase::EffectBarRegenFinished( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( pPlayer && (pPlayer->GetAmmoCount( GetEffectBarAmmo() ) < pPlayer->GetMaxAmmo( GetEffectBarAmmo() )) )
{
#ifdef GAME_DLL
pPlayer->GiveAmmo( 1, GetEffectBarAmmo(), true );
#endif
#ifdef GAME_DLL
// If we still have more ammo space, recharge
if ( pPlayer->GetAmmoCount( GetEffectBarAmmo() ) < pPlayer->GetMaxAmmo( GetEffectBarAmmo() ) )
#else
// On the client, we assume we'll get 1 more ammo as soon as the server updates us, so only restart if that still won't make us full.
if ( pPlayer->GetAmmoCount( GetEffectBarAmmo() ) + 1 < pPlayer->GetMaxAmmo( GetEffectBarAmmo() ) )
#endif
{
StartEffectBarRegen();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Vector CTFWeaponBase::GetParticleColor( int iColor )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return Vector(0,0,0);
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( !pItem->IsValid() )
return Vector(0,0,0);
int iModifiedRGB = pItem->GetModifiedRGBValue( pOwner->GetTeamNumber() == TF_TEAM_BLUE );
if ( iModifiedRGB > 0 )
{
Color clr = Color( ((iModifiedRGB & 0xFF0000) >> 16), ((iModifiedRGB & 0xFF00) >> 8), (iModifiedRGB & 0xFF) );
float fColorMod = 1.f;
if ( iColor == 2 )
{
fColorMod = 0.5f;
}
Vector vResult;
vResult.x = clamp( fColorMod * clr.r() * (1.f/255), 0.f, 1.0f );
vResult.y = clamp( fColorMod * clr.g() * (1.f/255), 0.f, 1.0f );
vResult.z = clamp( fColorMod * clr.b() * (1.f/255), 0.f, 1.0f );
return vResult;
}
if ( iColor == 1 )
{
if ( pOwner->GetTeamNumber() == TF_TEAM_RED )
return TF_PARTICLE_WEAPON_RED_1;
else
return TF_PARTICLE_WEAPON_BLUE_1;
}
else
{
if ( pOwner->GetTeamNumber() == TF_TEAM_RED )
return TF_PARTICLE_WEAPON_RED_2;
else
return TF_PARTICLE_WEAPON_BLUE_2;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBase::CanBeCritBoosted( void )
{
int iNoCritBoost = 0;
CALL_ATTRIB_HOOK_FLOAT( iNoCritBoost, no_crit_boost );
return iNoCritBoost == 0;
}
bool CTFWeaponBase::CanHaveRevengeCrits( void )
{
int iSapperCrits = 0;
CALL_ATTRIB_HOOK_INT( iSapperCrits, sapper_kills_collect_crits );
if ( iSapperCrits != 0 )
return true;
int iExtinguishCrits = 0;
CALL_ATTRIB_HOOK_INT( iExtinguishCrits, extinguish_revenge );
if ( iExtinguishCrits != 0 )
return true;
int iRevengeCrits = 0;
CALL_ATTRIB_HOOK_INT( iRevengeCrits, sentry_killed_revenge );
if ( iRevengeCrits )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: This is an accent sound that plays in addition to the base shoot sound
//-----------------------------------------------------------------------------
void CTFWeaponBase::PlayUpgradedShootSound( const char *pszSound )
{
if ( TFGameRules()->GameModeUsesUpgrades() )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( pOwner )
{
float flDmgMod = 1.f;
CALL_ATTRIB_HOOK_FLOAT( flDmgMod, mult_dmg );
if ( flDmgMod > 1.f )
{
// This is pretty hacky as it assumes a cap of +100% damage for picking
// sounds -- anything more and the 1-4 scale below falls apart.
int nLevel = RemapValClamped( flDmgMod, 1.f, 1.8f, 1.f, 4.f );
const char *pszSoundname = CFmtStr( "%s%d", pszSound, nLevel );
CSoundParameters params;
if ( !GetParametersForSound( pszSoundname, params, NULL ) )
return;
CPASAttenuationFilter filter( GetOwner(), params.soundlevel );
if ( IsPredicted() && CBaseEntity::GetPredictionPlayer() )
{
filter.UsePredictionRules();
}
EmitSound( filter, pOwner->entindex(), pszSoundname );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Is this honorbound weapon?
//-----------------------------------------------------------------------------
bool CTFWeaponBase::IsHonorBound( void ) const
{
int iHonorbound = 0;
CALL_ATTRIB_HOOK_INT( iHonorbound, honorbound );
return iHonorbound != 0;
}
EWeaponStrangeType_t CTFWeaponBase::GetStrangeType()
{
// verify stattrak module and add if necessary
if ( m_eStrangeType == STRANGE_UNKNOWN )
{
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( !pItem )
return STRANGE_UNKNOWN;
int iStrangeType = -1;
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
{
if ( pItem->FindAttribute( GetKillEaterAttr_Score( i ) ) )
{
iStrangeType = i;
break;
}
}
m_eStrangeType = iStrangeType == -1 ? STRANGE_NOT_STRANGE : STRANGE_IS_STRANGE;
}
return m_eStrangeType;
}
bool CTFWeaponBase::BHasStatTrakModule()
{
if ( m_eStatTrakModuleType == MODULE_UNKNOWN )
{
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( !pItem )
return false;
EWeaponStrangeType_t eStrangeType = GetStrangeType();
if ( eStrangeType != STRANGE_IS_STRANGE)
{
m_eStatTrakModuleType = MODULE_NONE;
return false;
}
// Does it have a module
CAttribute_String attrModule;
static CSchemaAttributeDefHandle pAttr_module( "weapon_uses_stattrak_module" );
if ( pItem->FindAttribute( pAttr_module, &attrModule ) && attrModule.has_value() )
{
m_eStatTrakModuleType = MODULE_FOUND;
return true;;
}
}
if ( m_eStatTrakModuleType != MODULE_FOUND )
return false;
return true;
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
void CTFWeaponBase::UpdateAllViewmodelAddons( void )
{
C_TFPlayer *pPlayer = ToTFPlayer( GetOwner() );
// Remove any view model add ons if we're spectating.
if ( !pPlayer )
{
RemoveViewmodelStatTrak();
return;
}
// econ-related addons follow, so bail out if we can't get at the econitemview
CEconItemView *pItem = GetAttributeContainer()->GetItem();
if ( !pItem )
{
RemoveViewmodelStatTrak();
return;
}
if ( GetStrangeType() > -1 )
{
CSteamID HolderSteamID;
pPlayer->GetSteamID( &HolderSteamID );
AddStatTrakModel( pItem, m_eStrangeType, HolderSteamID.GetAccountID() );
}
else
{
RemoveViewmodelStatTrak();
}
}
// StatTrak Module Testing
void CTFWeaponBase::AddStatTrakModel( CEconItemView *pItem, int nStatTrakType, AccountID_t holderAcctId )
{
// Already has module, just early out
if ( m_viewmodelStatTrakAddon && m_viewmodelStatTrakAddon.Get() && m_viewmodelStatTrakAddon->GetMoveParent() )
{
return;
}
// Something is missing, remove and return
if ( !pItem )
{
RemoveViewmodelStatTrak();
RemoveWorldmodelStatTrak();
return;
}
if ( GetStrangeType() != STRANGE_IS_STRANGE )
{
RemoveViewmodelStatTrak();
RemoveWorldmodelStatTrak();
return;
}
if ( !BHasStatTrakModule() )
{
RemoveViewmodelStatTrak();
RemoveWorldmodelStatTrak();
return;
}
// Get Module Data
CAttribute_String attrModule;
static CSchemaAttributeDefHandle pAttr_module( "weapon_uses_stattrak_module" );
if ( !pItem->FindAttribute( pAttr_module, &attrModule ) || !attrModule.has_value() )
{
RemoveViewmodelStatTrak();
RemoveWorldmodelStatTrak();
return;
}
float flScale = 1.0f;
CALL_ATTRIB_HOOK_FLOAT( flScale, weapon_stattrak_module_scale );
// Skin
int nSkin = pItem->GetTeamNumber() - TF_TEAM_RED;
if ( pItem->GetAccountID() != holderAcctId )
{
nSkin += 2; // sad skin
}
// View Model / third person
if ( GetViewmodelAttachment() )
{
// Already has a module, early out
if ( !( m_viewmodelStatTrakAddon && m_viewmodelStatTrakAddon.Get() && m_viewmodelStatTrakAddon->GetMoveParent() ) )
{
RemoveViewmodelStatTrak();
CTFWeaponAttachmentModel *pStatTrakEnt = new class CTFWeaponAttachmentModel;
if ( pStatTrakEnt )
{
pStatTrakEnt->InitializeAsClientEntity( attrModule.value().c_str(), RENDER_GROUP_VIEW_MODEL_OPAQUE );
pStatTrakEnt->Init( GetViewmodelAttachment(), this, true );
pStatTrakEnt->m_nSkin = nSkin;
m_viewmodelStatTrakAddon = pStatTrakEnt;
if ( cl_flipviewmodels.GetBool() )
{
pStatTrakEnt->SetBodygroup( 1, 1 ); // use a special mirror-image stattrak module that appears correct for lefties
flScale *= -1.0f; // flip scale
}
pStatTrakEnt->SetModelScale( flScale );
//RemoveEffects( EF_NODRAW );
}
}
}
// World Model
if ( !(m_worldmodelStatTrakAddon && m_worldmodelStatTrakAddon.Get() && m_worldmodelStatTrakAddon->GetMoveParent() ) )
{
RemoveWorldmodelStatTrak();
CTFWeaponAttachmentModel *pStatTrakEnt = new class CTFWeaponAttachmentModel;
if ( pStatTrakEnt )
{
pStatTrakEnt->InitializeAsClientEntity( attrModule.value().c_str(), RENDER_GROUP_OPAQUE_ENTITY );
pStatTrakEnt->SetModelScale( flScale );
pStatTrakEnt->Init( this, this, false );
pStatTrakEnt->m_nSkin = nSkin;
m_worldmodelStatTrakAddon = pStatTrakEnt;
// //if ( !cl_flipviewmodels.GetBool() )
// //{
// // pStatTrakEnt->SetBodygroup( 0, 1 ); // use a special mirror-image stattrak module that appears correct for lefties
// //}
//RemoveEffects( EF_NODRAW );
}
}
}
//-----------------------------------------------------------------------------
void CTFWeaponBase::RemoveViewmodelStatTrak( void )
{
if ( m_viewmodelStatTrakAddon.Get() )
{
m_viewmodelStatTrakAddon->Remove();
m_viewmodelStatTrakAddon = NULL;
}
}
//-----------------------------------------------------------------------------
void CTFWeaponBase::RemoveWorldmodelStatTrak( void )
{
if ( m_worldmodelStatTrakAddon )
{
m_worldmodelStatTrakAddon->Remove();
m_worldmodelStatTrakAddon = NULL;
}
}
//-----------------------------------------------------------------------------
const Vector& CTFWeaponBase::GetViewmodelOffset()
{
if ( !m_bInitViewmodelOffset )
{
CAttribute_String attr_min_viewmodel_offset;
CALL_ATTRIB_HOOK_STRING( attr_min_viewmodel_offset, min_viewmodel_offset );
const char* pszMinViewmodelOffset = attr_min_viewmodel_offset.value().c_str();
if ( pszMinViewmodelOffset && *pszMinViewmodelOffset )
{
UTIL_StringToVector( m_vecViewmodelOffset.Base(), pszMinViewmodelOffset );
}
m_bInitViewmodelOffset = true;
}
return m_vecViewmodelOffset;
}
//-----------------------------------------------------------------------------
// CTFWeaponAttachmentModel
//-----------------------------------------------------------------------------
void CTFWeaponAttachmentModel::Init( CBaseEntity *pParent, CTFWeaponBase *pAssociatedWeapon, bool bIsViewModel )
{
SetParent( pParent );
SetLocalOrigin( vec3_origin );
UpdatePartitionListEntry();
CollisionProp()->MarkPartitionHandleDirty();
//UpdateVisibility();
SetWeaponAssociatedWith( pAssociatedWeapon );
AddEffects( EF_BONEMERGE );
AddEffects( EF_BONEMERGE_FASTCULL );
AddEffects( EF_NODRAW );
m_bIsViewModelAttachment = bIsViewModel;
}
//-----------------------------------------------------------------------------
bool CTFWeaponAttachmentModel::ShouldDraw( void )
{
// Follow my associated weapon
if ( !m_hWeaponAssociatedWith.Get() )
return false;
// some code is overriding the weapon model (taunt), don't show the attachment model
if ( m_hWeaponAssociatedWith->IsUsingOverrideModel() )
return false;
if ( m_hWeaponAssociatedWith->IsFirstPersonView() && !m_bIsViewModelAttachment )
{
return false;
}
bool bShouldDraw = m_hWeaponAssociatedWith->ShouldDraw();
if ( bShouldDraw )
{
return !m_bIsViewModelAttachment;
}
return false;
//if ( pWeapon )
//{
// // If the weapon isn't active, don't draw
// if ( pOwner && pOwner->GetActiveWeapon() != pWeapon )
// {
// return false;
// }
// if ( !IsViewModelWearable() )
// {
// // If it's the 3rd person wearable, don't draw it when the weapon is hidden
// if ( !pWeapon->ShouldDraw() )
// {
// return false;
// }
// }
// // If the weapon is being repurposed for a taunt dont draw.
// // The Brutal Legend taunt changes your weapon's model to be the guitar,
// // but we dont want things like bot-killer skulls or festive lights
// // to continue to draw
// if ( pWeapon->IsBeingRepurposedForTaunt() )
// {
// return false;
// }
//}
//
}
#endif // CLIENT_DLL