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

14162 lines
413 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "tf_gamerules.h"
#include "tf_player_shared.h"
#include "takedamageinfo.h"
#include "tf_weaponbase.h"
#include "effect_dispatch_data.h"
#include "tf_item.h"
#include "entity_capture_flag.h"
#include "tf_weapon_medigun.h"
#include "tf_weapon_pipebomblauncher.h"
#include "tf_weapon_invis.h"
#include "tf_weapon_sniperrifle.h"
#include "tf_weapon_shovel.h"
#include "tf_weapon_sword.h"
#include "tf_weapon_shotgun.h"
#include "in_buttons.h"
#include "tf_weapon_lunchbox.h"
#include "tf_weapon_flaregun.h"
#include "tf_weapon_wrench.h"
#include "econ_wearable.h"
#include "econ_item_system.h"
#include "tf_weapon_knife.h"
#include "tf_weapon_syringegun.h"
#include "tf_weapon_flamethrower.h"
#include "econ_entity_creation.h"
#include "tf_mapinfo.h"
#include "tf_dropped_weapon.h"
#include "tf_weapon_passtime_gun.h"
// Client specific.
#ifdef CLIENT_DLL
#include "c_tf_player.h"
#include "c_te_effect_dispatch.h"
#include "c_tf_fx.h"
#include "soundenvelope.h"
#include "c_tf_playerclass.h"
#include "iviewrender.h"
#include "prediction.h"
#include "achievementmgr.h"
#include "baseachievement.h"
#include "achievements_tf.h"
#include "c_tf_weapon_builder.h"
#include "dt_utlvector_recv.h"
#include "recvproxy.h"
#include "c_tf_weapon_builder.h"
#include "c_func_capture_zone.h"
#include "tf_hud_target_id.h"
#include "tempent.h"
#include "cam_thirdperson.h"
#include "vgui/IInput.h"
#define CTFPlayerClass C_TFPlayerClass
#define CCaptureZone C_CaptureZone
#define CRecipientFilter C_RecipientFilter
#include "c_tf_objective_resource.h"
#include "tf_weapon_buff_item.h"
#include "c_tf_passtime_logic.h"
// Server specific.
#else
#include "tf_player.h"
#include "te_effect_dispatch.h"
#include "tf_fx.h"
#include "util.h"
#include "tf_team.h"
#include "tf_gamestats.h"
#include "tf_playerclass.h"
#include "SpriteTrail.h"
#include "tf_weapon_builder.h"
#include "nav_mesh/tf_nav_area.h"
#include "nav_pathfind.h"
#include "tf_obj_dispenser.h"
#include "dt_utlvector_send.h"
#include "tf_item_wearable.h"
#include "NextBotManager.h"
#include "tf_weapon_builder.h"
#include "func_capture_zone.h"
#include "hl2orange.spa.h"
#include "bot/tf_bot.h"
#include "tf_objective_resource.h"
#include "halloween/tf_weapon_spellbook.h"
#include "tf_weapon_buff_item.h"
#include "tf_passtime_logic.h"
#include "tf_weapon_passtime_gun.h"
#include "entity_healthkit.h"
#include "halloween/merasmus/merasmus.h"
#include "tf_weapon_grapplinghook.h"
#include "tf_wearable_levelable_item.h"
#include "tf_obj_sentrygun.h"
#endif
#include "tf_wearable_item_demoshield.h"
#include "tf_weapon_bonesaw.h"
static ConVar tf_demoman_charge_frametime_scaling( "tf_demoman_charge_frametime_scaling", "1", FCVAR_REPLICATED | FCVAR_CHEAT, "When enabled, scale yaw limiting based on client performance (frametime)." );
static const float YAW_CAP_SCALE_MIN = 0.2f;
static const float YAW_CAP_SCALE_MAX = 2.f;
ConVar tf_halloween_kart_boost_recharge( "tf_halloween_kart_boost_recharge", "5.0f", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar tf_halloween_kart_boost_duration( "tf_halloween_kart_boost_duration", "1.5f", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar tf_scout_air_dash_count( "tf_scout_air_dash_count", "1", FCVAR_REPLICATED | FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_spy_invis_time( "tf_spy_invis_time", "1.0", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "Transition time in and out of spy invisibility", true, 0.1, true, 5.0 );
ConVar tf_spy_invis_unstealth_time( "tf_spy_invis_unstealth_time", "2.0", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "Transition time in and out of spy invisibility", true, 0.1, true, 5.0 );
ConVar tf_spy_max_cloaked_speed( "tf_spy_max_cloaked_speed", "999", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED ); // no cap
ConVar tf_whip_speed_increase( "tf_whip_speed_increase", "105", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED );
ConVar tf_max_health_boost( "tf_max_health_boost", "1.5", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "Max health factor that players can be boosted to by healers.", true, 1.0, false, 0 );
ConVar tf_invuln_time( "tf_invuln_time", "1.0", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "Time it takes for invulnerability to wear off." );
ConVar tf_player_movement_stun_time( "tf_player_movement_stun_time", "0.5", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED );
extern ConVar tf_player_movement_restart_freeze;
extern ConVar mp_tournament_readymode_countdown;
extern ConVar tf_max_charge_speed;
ConVar tf_always_loser( "tf_always_loser", "0", FCVAR_CHEAT | FCVAR_REPLICATED, "Force loserstate to true." );
ConVar tf_mvm_bot_flag_carrier_movement_penalty( "tf_mvm_bot_flag_carrier_movement_penalty", "0.5", FCVAR_REPLICATED | FCVAR_CHEAT );
//ConVar tf_scout_dodge_move_penalty_duration( "tf_scout_dodge_move_penalty_duration", "3.0", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED );
//ConVar tf_scout_dodge_move_penalty( "tf_scout_dodge_move_penalty", "0.5", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED );
#ifdef GAME_DLL
ConVar tf_boost_drain_time( "tf_boost_drain_time", "15.0", FCVAR_DEVELOPMENTONLY, "Time is takes for a full health boost to drain away from a player.", true, 0.1, false, 0 );
#ifdef _DEBUG
CON_COMMAND_F( tf_add_bombhead, "Add Merasmus Bomb Head Condition", 0 )
{
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, TF_TEAM_RED, true );
FOR_EACH_VEC ( playerVector, i )
{
float flBuffDuration = 7.0f;
playerVector[i]->m_Shared.StunPlayer( flBuffDuration, 0.f, TF_STUN_LOSER_STATE );
playerVector[i]->m_Shared.AddCond( TF_COND_HALLOWEEN_BOMB_HEAD, flBuffDuration );
playerVector[i]->m_Shared.AddCond( TF_COND_SPEED_BOOST, flBuffDuration );
//playerVector[i]->m_Shared.AddCond( TF_COND_HALLOWEEN_BOMB_HEAD, 7 );
}
}
ConVar tf_debug_bullets( "tf_debug_bullets", "0", FCVAR_DEVELOPMENTONLY, "Visualize bullet traces." );
#endif // _DEBUG
ConVar tf_damage_events_track_for( "tf_damage_events_track_for", "30", FCVAR_DEVELOPMENTONLY );
extern ConVar tf_halloween_giant_health_scale;
ConVar tf_allow_sliding_taunt( "tf_allow_sliding_taunt", "0", FCVAR_NONE, "1 - Allow player to slide for a bit after taunting" );
#endif // GAME_DLL
#ifdef STAGING_ONLY
ConVar tf_force_allow_move_during_taunt( "tf_force_allow_move_during_taunt", "0", FCVAR_REPLICATED );
#endif // STAGING_ONLY
ConVar tf_useparticletracers( "tf_useparticletracers", "1", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "Use particle tracers instead of old style ones." );
ConVar tf_spy_cloak_consume_rate( "tf_spy_cloak_consume_rate", "10.0", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "cloak to use per second while cloaked, from 100 max )" ); // 10 seconds of invis
ConVar tf_spy_cloak_regen_rate( "tf_spy_cloak_regen_rate", "3.3", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "cloak to regen per second, up to 100 max" ); // 30 seconds to full charge
ConVar tf_spy_cloak_no_attack_time( "tf_spy_cloak_no_attack_time", "2.0", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "time after uncloaking that the spy is prohibited from attacking" );
ConVar tf_tournament_hide_domination_icons( "tf_tournament_hide_domination_icons", "0", FCVAR_REPLICATED, "Tournament mode server convar that forces clients to not display the domination icons above players dominating them." );
ConVar tf_damage_disablespread( "tf_damage_disablespread", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Toggles the random damage spread applied to all player damage." );
ConVar tf_scout_energydrink_regen_rate( "tf_scout_energydrink_regen_rate", "3.3", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "energy drink regen per second, up to 100 max" );
ConVar tf_scout_energydrink_consume_rate( "tf_scout_energydrink_consume_rate", "12.5", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "energy drink to use per second while boosted, from 100 max" );
ConVar tf_scout_energydrink_activation( "tf_scout_energydrink_activation", "0.0", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "how long it takes for the energy buff to become active" );
ConVar tf_demoman_charge_regen_rate( "tf_demoman_charge_regen_rate", "8.3", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "" );
ConVar tf_demoman_charge_drain_time( "tf_demoman_charge_drain_time", "1.5", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED, "" );
// STAGING_SPY
ConVar tf_feign_death_duration( "tf_feign_death_duration", "3.0", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Time that feign death buffs last." );
ConVar tf_feign_death_speed_duration( "tf_feign_death_speed_duration", "3.0", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Time that feign death speed boost last." );
ConVar tf_allow_taunt_switch( "tf_allow_taunt_switch", "0", FCVAR_REPLICATED, "0 - players are not allowed to switch weapons while taunting, 1 - players can switch weapons at the start of a taunt (old bug behavior), 2 - players can switch weapons at any time during a taunt." );
ConVar tf_allow_all_team_partner_taunt( "tf_allow_all_team_partner_taunt", "1", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
#ifdef STAGING_ONLY
ConVar tf_random_item_min( "tf_random_item_min", "-1", FCVAR_REPLICATED, "Min Itemdef for random cosmetics" );
ConVar tf_random_item_max( "tf_random_item_max", "-1", FCVAR_REPLICATED, "Max Itemdef for random cosmetics" );
ConVar tf_killstreak_eyeglow( "tf_killstreak_eyeglow", "0", FCVAR_REPLICATED, "Force Kill Streak effect index for Eye Glows. -1 to disable regardless of equipped items. Stats at 2002" );
ConVar tf_killstreak_color( "tf_killstreak_color", "0", FCVAR_REPLICATED, "Force Kill Streak color." );
ConVar tf_eyeglow_wip( "tf_eyeglow_wip", "0", FCVAR_REPLICATED, "Activate to Always have specific wip eyeglow (DEV)" );
#endif // Staging only
#ifdef CLIENT_DLL
ConVar tf_colorblindassist( "tf_colorblindassist", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Setting this to 1 turns on colorblind mode." );
extern ConVar cam_idealdist;
extern ConVar cam_idealdistright;
#endif // CLIENT_DLL
extern ConVar tf_flamethrower_flametime;
extern ConVar weapon_medigun_chargerelease_rate;
#if defined( _DEBUG ) || defined( STAGING_ONLY )
extern ConVar mp_developer;
#endif // _DEBUG || STAGING_ONLY
//ConVar tf_spy_stealth_blink_time( "tf_spy_stealth_blink_time", "0.3", FCVAR_DEVELOPMENTONLY, "time after being hit the spy blinks into view" );
//ConVar tf_spy_stealth_blink_scale( "tf_spy_stealth_blink_scale", "0.85", FCVAR_DEVELOPMENTONLY, "percentage visible scalar after being hit the spy blinks into view" );
#define TF_SPY_STEALTH_BLINKTIME 0.3f
#define TF_SPY_STEALTH_BLINKSCALE 0.85f
#define TF_BUILDING_PICKUP_RANGE 150
#define TF_BUILDING_RESCUE_MIN_RANGE_SQ 62500 //250 * 250
#define TF_BUILDING_RESCUE_MAX_RANGE 5500
#define TF_PLAYER_CONDITION_CONTEXT "TFPlayerConditionContext"
#define TF_SCREEN_OVERLAY_MATERIAL_BURNING "effects/imcookin"
#define TF_SCREEN_OVERLAY_MATERIAL_INVULN_RED "effects/invuln_overlay_red"
#define TF_SCREEN_OVERLAY_MATERIAL_INVULN_BLUE "effects/invuln_overlay_blue"
#define TF_SCREEN_OVERLAY_MATERIAL_MILK "effects/milk_screen"
#define TF_SCREEN_OVERLAY_MATERIAL_URINE "effects/jarate_overlay"
#define TF_SCREEN_OVERLAY_MATERIAL_BLEED "effects/bleed_overlay"
#define TF_SCREEN_OVERLAY_MATERIAL_STEALTH "effects/stealth_overlay"
#define TF_SCREEN_OVERLAY_MATERIAL_SWIMMING_CURSE "effects/jarate_overlay"
#define TF_SCREEN_OVERLAY_MATERIAL_PHASE "effects/dodge_overlay"
#define MAX_DAMAGE_EVENTS 128
const char *g_pszBDayGibs[22] =
{
"models/effects/bday_gib01.mdl",
"models/effects/bday_gib02.mdl",
"models/effects/bday_gib03.mdl",
"models/effects/bday_gib04.mdl",
"models/player/gibs/gibs_balloon.mdl",
"models/player/gibs/gibs_burger.mdl",
"models/player/gibs/gibs_boot.mdl",
"models/player/gibs/gibs_bolt.mdl",
"models/player/gibs/gibs_can.mdl",
"models/player/gibs/gibs_clock.mdl",
"models/player/gibs/gibs_fish.mdl",
"models/player/gibs/gibs_gear1.mdl",
"models/player/gibs/gibs_gear2.mdl",
"models/player/gibs/gibs_gear3.mdl",
"models/player/gibs/gibs_gear4.mdl",
"models/player/gibs/gibs_gear5.mdl",
"models/player/gibs/gibs_hubcap.mdl",
"models/player/gibs/gibs_licenseplate.mdl",
"models/player/gibs/gibs_spring1.mdl",
"models/player/gibs/gibs_spring2.mdl",
"models/player/gibs/gibs_teeth.mdl",
"models/player/gibs/gibs_tire.mdl"
};
ETFCond g_SoldierBuffAttributeIDToConditionMap[kSoldierBuffCount + 1] =
{
TF_COND_LAST, // dummy entry to deal with attribute value of "1" being the lowest value we store in the attribute itself
TF_COND_OFFENSEBUFF,
TF_COND_DEFENSEBUFF,
TF_COND_REGENONDAMAGEBUFF,
TF_COND_NOHEALINGDAMAGEBUFF,
TF_COND_CRITBOOSTED_RAGE_BUFF,
TF_COND_SNIPERCHARGE_RAGE_BUFF
};
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void RecvProxy_BuildablesListChanged( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
RecvProxy_Int32ToInt32( pData, pStruct, pOut );
C_TFPlayer* pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer || pLocalPlayer->entindex() != pData->m_ObjectID )
return;
int index = pData->m_pRecvProp->GetOffset() / sizeof(int);
int object = pData->m_Value.m_Int;
IGameEvent *event = gameeventmanager->CreateEvent( "update_status_item" );
if ( event )
{
event->SetInt( "index", index );
event->SetInt( "object", object );
gameeventmanager->FireEventClientSide( event );
}
}
#endif
//=============================================================================
//
// Tables.
//
// Client specific.
#ifdef CLIENT_DLL
BEGIN_RECV_TABLE_NOBASE( localplayerscoring_t, DT_TFPlayerScoringDataExclusive )
RecvPropInt( RECVINFO( m_iCaptures ) ),
RecvPropInt( RECVINFO( m_iDefenses ) ),
RecvPropInt( RECVINFO( m_iKills ) ),
RecvPropInt( RECVINFO( m_iDeaths ) ),
RecvPropInt( RECVINFO( m_iSuicides ) ),
RecvPropInt( RECVINFO( m_iDominations ) ),
RecvPropInt( RECVINFO( m_iRevenge ) ),
RecvPropInt( RECVINFO( m_iBuildingsBuilt ) ),
RecvPropInt( RECVINFO( m_iBuildingsDestroyed ) ),
RecvPropInt( RECVINFO( m_iHeadshots ) ),
RecvPropInt( RECVINFO( m_iBackstabs ) ),
RecvPropInt( RECVINFO( m_iHealPoints ) ),
RecvPropInt( RECVINFO( m_iInvulns ) ),
RecvPropInt( RECVINFO( m_iTeleports ) ),
RecvPropInt( RECVINFO( m_iResupplyPoints ) ),
RecvPropInt( RECVINFO( m_iKillAssists ) ),
RecvPropInt( RECVINFO( m_iPoints ) ),
RecvPropInt( RECVINFO( m_iBonusPoints ) ),
RecvPropInt( RECVINFO( m_iDamageDone ) ),
RecvPropInt( RECVINFO( m_iCrits ) ),
END_RECV_TABLE()
EXTERN_RECV_TABLE(DT_TFPlayerConditionListExclusive);
BEGIN_RECV_TABLE_NOBASE( CTFPlayerShared, DT_TFPlayerSharedLocal )
RecvPropInt( RECVINFO( m_nDesiredDisguiseTeam ) ),
RecvPropInt( RECVINFO( m_nDesiredDisguiseClass ) ),
RecvPropTime( RECVINFO( m_flStealthNoAttackExpire ) ),
RecvPropTime( RECVINFO( m_flStealthNextChangeTime ) ),
RecvPropBool( RECVINFO( m_bLastDisguisedAsOwnTeam ) ),
RecvPropFloat( RECVINFO( m_flRageMeter ) ),
RecvPropBool( RECVINFO( m_bRageDraining ) ),
RecvPropTime( RECVINFO( m_flNextRageEarnTime ) ),
RecvPropBool( RECVINFO( m_bInUpgradeZone ) ),
RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominated ), RecvPropBool( RECVINFO( m_bPlayerDominated[0] ) ) ),
RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominatingMe ), RecvPropBool( RECVINFO( m_bPlayerDominatingMe[0] ) ) ),
RecvPropDataTable( RECVINFO_DT(m_ScoreData),0, &REFERENCE_RECV_TABLE(DT_TFPlayerScoringDataExclusive) ),
RecvPropDataTable( RECVINFO_DT(m_RoundScoreData),0, &REFERENCE_RECV_TABLE(DT_TFPlayerScoringDataExclusive) ),
END_RECV_TABLE()
BEGIN_RECV_TABLE_NOBASE( condition_source_t, DT_TFPlayerConditionSource )
//RecvPropInt( RECVINFO( m_nPreventedDamageFromCondition ) ),
//RecvPropFloat( RECVINFO( m_flExpireTime ) ),
RecvPropEHandle( RECVINFO( m_pProvider ) ),
//RecvPropBool( RECVINFO( m_bPrevActive ) ),
END_RECV_TABLE()
BEGIN_RECV_TABLE_NOBASE( CTFPlayerShared, DT_TFPlayerShared )
RecvPropInt( RECVINFO( m_nPlayerCond ) ),
RecvPropInt( RECVINFO( m_bJumping) ),
RecvPropInt( RECVINFO( m_nNumHealers ) ),
RecvPropInt( RECVINFO( m_iCritMult ) ),
RecvPropInt( RECVINFO( m_iAirDash ) ),
RecvPropInt( RECVINFO( m_nAirDucked ) ),
RecvPropFloat( RECVINFO( m_flDuckTimer ) ),
RecvPropInt( RECVINFO( m_nPlayerState ) ),
RecvPropInt( RECVINFO( m_iDesiredPlayerClass ) ),
RecvPropFloat( RECVINFO( m_flMovementStunTime ) ),
RecvPropInt( RECVINFO( m_iMovementStunAmount ) ),
RecvPropInt( RECVINFO( m_iMovementStunParity ) ),
RecvPropEHandle( RECVINFO( m_hStunner ) ),
RecvPropInt( RECVINFO( m_iStunFlags ) ),
RecvPropInt( RECVINFO( m_nArenaNumChanges ) ),
RecvPropBool( RECVINFO( m_bArenaFirstBloodBoost ) ),
RecvPropInt( RECVINFO( m_iWeaponKnockbackID ) ),
RecvPropBool( RECVINFO( m_bLoadoutUnavailable ) ),
RecvPropInt( RECVINFO( m_iItemFindBonus ) ),
RecvPropBool( RECVINFO( m_bShieldEquipped ) ),
RecvPropBool( RECVINFO( m_bParachuteEquipped ) ),
RecvPropInt( RECVINFO( m_iNextMeleeCrit ) ),
RecvPropInt( RECVINFO( m_iDecapitations ) ),
RecvPropInt( RECVINFO( m_iRevengeCrits ) ),
RecvPropInt( RECVINFO( m_iDisguiseBody ) ),
RecvPropEHandle( RECVINFO( m_hCarriedObject ) ),
RecvPropBool( RECVINFO( m_bCarryingObject ) ),
RecvPropFloat( RECVINFO( m_flNextNoiseMakerTime ) ),
RecvPropInt( RECVINFO( m_iSpawnRoomTouchCount ) ),
RecvPropInt( RECVINFO( m_iKillCountSinceLastDeploy ) ),
RecvPropFloat( RECVINFO( m_flFirstPrimaryAttack ) ),
//Scout
RecvPropFloat( RECVINFO( m_flEnergyDrinkMeter) ),
RecvPropFloat( RECVINFO( m_flHypeMeter) ),
// Demoman
RecvPropFloat( RECVINFO( m_flChargeMeter) ),
// Spy.
RecvPropTime( RECVINFO( m_flInvisChangeCompleteTime ) ),
RecvPropInt( RECVINFO( m_nDisguiseTeam ) ),
RecvPropInt( RECVINFO( m_nDisguiseClass ) ),
RecvPropInt( RECVINFO( m_nDisguiseSkinOverride ) ),
RecvPropInt( RECVINFO( m_nMaskClass ) ),
RecvPropInt( RECVINFO( m_iDisguiseTargetIndex ) ),
RecvPropInt( RECVINFO( m_iDisguiseHealth ) ),
RecvPropBool( RECVINFO( m_bFeignDeathReady ) ),
RecvPropEHandle( RECVINFO( m_hDisguiseWeapon ) ),
RecvPropInt( RECVINFO( m_nTeamTeleporterUsed ) ),
RecvPropFloat( RECVINFO( m_flCloakMeter ) ),
RecvPropFloat( RECVINFO( m_flSpyTranqBuffDuration ) ),
// Local Data.
RecvPropDataTable( "tfsharedlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_TFPlayerSharedLocal) ),
RecvPropDataTable( RECVINFO_DT(m_ConditionList),0, &REFERENCE_RECV_TABLE(DT_TFPlayerConditionListExclusive) ),
RecvPropInt( RECVINFO( m_iTauntIndex ) ),
RecvPropInt( RECVINFO( m_iTauntConcept ) ),
RecvPropInt( RECVINFO( m_nPlayerCondEx ) ),
RecvPropInt( RECVINFO( m_iStunIndex ) ),
RecvPropInt( RECVINFO( m_nHalloweenBombHeadStage ) ),
RecvPropInt( RECVINFO( m_nPlayerCondEx2 ) ),
RecvPropInt( RECVINFO( m_nPlayerCondEx3 ) ),
RecvPropArray3( RECVINFO_ARRAY( m_nStreaks ), RecvPropInt( RECVINFO( m_nStreaks[0] ) ) ),
RecvPropInt( RECVINFO( m_unTauntSourceItemID_Low ) ),
RecvPropInt( RECVINFO( m_unTauntSourceItemID_High ) ),
RecvPropFloat( RECVINFO( m_flRuneCharge ) ),
#ifdef STAGING_ONLY
RecvPropFloat( RECVINFO( m_flSpaceJumpCharge ) ),
#endif
RecvPropBool( RECVINFO( m_bHasPasstimeBall ) ),
RecvPropBool( RECVINFO( m_bIsTargetedForPasstimePass ) ),
RecvPropEHandle( RECVINFO( m_hPasstimePassTarget ) ),
RecvPropFloat( RECVINFO( m_askForBallTime ) ),
RecvPropBool( RECVINFO( m_bKingRuneBuffActive ) ),
RecvPropUtlVectorDataTable( m_ConditionData, TF_COND_LAST, DT_TFPlayerConditionSource ),
END_RECV_TABLE()
BEGIN_PREDICTION_DATA_NO_BASE( CTFPlayerShared )
DEFINE_PRED_FIELD( m_nPlayerState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nPlayerCond, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flCloakMeter, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flRageMeter, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bRageDraining, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flNextRageEarnTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flEnergyDrinkMeter, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flHypeMeter, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flChargeMeter, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bJumping, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_iAirDash, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nAirDucked, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flDuckTimer, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flInvisChangeCompleteTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nDisguiseTeam, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nDisguiseClass, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nDisguiseSkinOverride, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nMaskClass, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nDesiredDisguiseTeam, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nDesiredDisguiseClass, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bLastDisguisedAsOwnTeam, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bFeignDeathReady, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nPlayerCondEx, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nPlayerCondEx2, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nPlayerCondEx3, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( m_hDisguiseWeapon, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
DEFINE_FIELD( m_flDisguiseCompleteTime, FIELD_FLOAT ),
DEFINE_PRED_FIELD( m_bHasPasstimeBall, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bIsTargetedForPasstimePass, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), // does this belong here?
DEFINE_PRED_FIELD( m_askForBallTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
END_PREDICTION_DATA()
// Server specific.
#else
BEGIN_SEND_TABLE_NOBASE( localplayerscoring_t, DT_TFPlayerScoringDataExclusive )
SendPropInt( SENDINFO( m_iCaptures ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDefenses ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iKills ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDeaths ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iSuicides ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDominations ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iRevenge ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iBuildingsBuilt ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iBuildingsDestroyed ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iHeadshots ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iBackstabs ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iHealPoints ), 20, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iInvulns ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iTeleports ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDamageDone ), 20, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iCrits ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iResupplyPoints ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iKillAssists ), 12, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iBonusPoints ), 10, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iPoints ), 10, SPROP_UNSIGNED ),
END_SEND_TABLE()
EXTERN_SEND_TABLE(DT_TFPlayerConditionListExclusive);
BEGIN_SEND_TABLE_NOBASE( CTFPlayerShared, DT_TFPlayerSharedLocal )
SendPropInt( SENDINFO( m_nDesiredDisguiseTeam ), 3, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nDesiredDisguiseClass ), 4, SPROP_UNSIGNED ),
SendPropBool( SENDINFO( m_bLastDisguisedAsOwnTeam ) ),
SendPropTime( SENDINFO( m_flStealthNoAttackExpire ) ),
SendPropTime( SENDINFO( m_flStealthNextChangeTime ) ),
SendPropFloat( SENDINFO( m_flRageMeter ), 0, SPROP_NOSCALE, 0.0, 100.0 ),
SendPropBool( SENDINFO( m_bRageDraining ) ),
SendPropTime( SENDINFO( m_flNextRageEarnTime ) ),
SendPropBool( SENDINFO( m_bInUpgradeZone ) ),
SendPropArray3( SENDINFO_ARRAY3( m_bPlayerDominated ), SendPropBool( SENDINFO_ARRAY( m_bPlayerDominated ) ) ),
SendPropArray3( SENDINFO_ARRAY3( m_bPlayerDominatingMe ), SendPropBool( SENDINFO_ARRAY( m_bPlayerDominatingMe ) ) ),
SendPropDataTable( SENDINFO_DT(m_ScoreData), &REFERENCE_SEND_TABLE(DT_TFPlayerScoringDataExclusive) ),
SendPropDataTable( SENDINFO_DT(m_RoundScoreData), &REFERENCE_SEND_TABLE(DT_TFPlayerScoringDataExclusive) ),
END_SEND_TABLE()
BEGIN_SEND_TABLE_NOBASE( condition_source_t, DT_TFPlayerConditionSource )
//SendPropInt( SENDINFO( m_nPreventedDamageFromCondition ) ),
//SendPropFloat( SENDINFO( m_flExpireTime ) ),
SendPropEHandle( SENDINFO( m_pProvider ) ),
//SendPropBool( SENDINFO( m_bPrevActive ) ),
END_SEND_TABLE()
BEGIN_SEND_TABLE_NOBASE( CTFPlayerShared, DT_TFPlayerShared )
SendPropInt( SENDINFO( m_nPlayerCond ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bJumping ), 1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nNumHealers ), 5, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iCritMult ), 8, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iAirDash ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nAirDucked ), 2, SPROP_UNSIGNED ),
SendPropFloat( SENDINFO( m_flDuckTimer ) ),
SendPropInt( SENDINFO( m_nPlayerState ), Q_log2( TF_STATE_COUNT )+1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDesiredPlayerClass ), Q_log2( TF_CLASS_COUNT_ALL )+1, SPROP_UNSIGNED ),
SendPropFloat( SENDINFO( m_flMovementStunTime ) ),
SendPropInt( SENDINFO( m_iMovementStunAmount ), 8, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iMovementStunParity ), MOVEMENTSTUN_PARITY_BITS, SPROP_UNSIGNED ),
SendPropEHandle( SENDINFO( m_hStunner ) ),
SendPropInt( SENDINFO( m_iStunFlags ), 12, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nArenaNumChanges ), 5, SPROP_UNSIGNED ),
SendPropBool( SENDINFO( m_bArenaFirstBloodBoost ) ),
SendPropInt( SENDINFO( m_iWeaponKnockbackID ) ),
SendPropBool( SENDINFO( m_bLoadoutUnavailable ) ),
SendPropInt( SENDINFO( m_iItemFindBonus ) ),
SendPropBool( SENDINFO( m_bShieldEquipped ) ),
SendPropBool( SENDINFO( m_bParachuteEquipped ) ),
SendPropInt( SENDINFO( m_iNextMeleeCrit ) ),
SendPropInt( SENDINFO( m_iDecapitations ), 8, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iRevengeCrits ), 7, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDisguiseBody ) ),
SendPropEHandle( SENDINFO( m_hCarriedObject ) ),
SendPropBool( SENDINFO( m_bCarryingObject ) ),
SendPropFloat( SENDINFO( m_flNextNoiseMakerTime ) ),
SendPropInt( SENDINFO( m_iSpawnRoomTouchCount ) ),
SendPropInt( SENDINFO( m_iKillCountSinceLastDeploy ) ),
SendPropFloat( SENDINFO( m_flFirstPrimaryAttack ) ),
//Scout
SendPropFloat( SENDINFO( m_flEnergyDrinkMeter ), 0, SPROP_NOSCALE, 0.0, 100.0 ),
SendPropFloat( SENDINFO( m_flHypeMeter ), 0, SPROP_NOSCALE, 0.0, 100.0 ),
// Demoman
SendPropFloat( SENDINFO( m_flChargeMeter ), 8, SPROP_NOSCALE, 0.0, 100.0 ),
// Spy
SendPropTime( SENDINFO( m_flInvisChangeCompleteTime ) ),
SendPropInt( SENDINFO( m_nDisguiseTeam ), 3, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nDisguiseClass ), 4, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nDisguiseSkinOverride ), 1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nMaskClass ), 4, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDisguiseTargetIndex ), 7, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iDisguiseHealth ), -1, SPROP_VARINT ),
SendPropBool( SENDINFO( m_bFeignDeathReady ) ),
SendPropEHandle( SENDINFO( m_hDisguiseWeapon ) ),
SendPropInt( SENDINFO( m_nTeamTeleporterUsed ), 3, SPROP_UNSIGNED ),
SendPropFloat( SENDINFO( m_flCloakMeter ), 16, SPROP_NOSCALE, 0.0, 100.0 ),
SendPropFloat( SENDINFO( m_flSpyTranqBuffDuration ), 16, SPROP_NOSCALE, 0.0, 100.0 ),
// Local Data.
SendPropDataTable( "tfsharedlocaldata", 0, &REFERENCE_SEND_TABLE( DT_TFPlayerSharedLocal ), SendProxy_SendLocalDataTable ),
SendPropDataTable( SENDINFO_DT(m_ConditionList), &REFERENCE_SEND_TABLE(DT_TFPlayerConditionListExclusive) ),
SendPropInt( SENDINFO( m_iTauntIndex ), 8, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iTauntConcept ), 8, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nPlayerCondEx ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_iStunIndex ), 8 ),
SendPropInt( SENDINFO( m_nHalloweenBombHeadStage ), 2, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nPlayerCondEx2 ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nPlayerCondEx3 ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
SendPropArray3( SENDINFO_ARRAY3( m_nStreaks ), SendPropInt( SENDINFO_ARRAY( m_nStreaks ) ) ),
SendPropInt( SENDINFO( m_unTauntSourceItemID_Low ), -1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_unTauntSourceItemID_High ), -1, SPROP_UNSIGNED ),
SendPropFloat( SENDINFO( m_flRuneCharge ), 8, 0, 0.0, 100.0 ),
#ifdef STAGING_ONLY
SendPropFloat( SENDINFO( m_flSpaceJumpCharge ), 8, 0, 0.0, 100.0 ),
#endif
SendPropBool( SENDINFO( m_bHasPasstimeBall ) ),
SendPropBool( SENDINFO( m_bIsTargetedForPasstimePass ) ),
SendPropEHandle( SENDINFO( m_hPasstimePassTarget ) ),
SendPropFloat( SENDINFO( m_askForBallTime ) ),
SendPropBool( SENDINFO( m_bKingRuneBuffActive ) ),
SendPropUtlVectorDataTable( m_ConditionData, TF_COND_LAST, DT_TFPlayerConditionSource ),
END_SEND_TABLE()
#endif
extern void HandleRageGain( CTFPlayer *pPlayer, unsigned int iRequiredBuffFlags, float flDamage, float fInverseRageGainScale );
CTFWearableDemoShield* GetEquippedDemoShield( CTFPlayer * pPlayer )
{
// Loop through our wearables in search of a shield
for ( int i=0; i<pPlayer->GetNumWearables(); ++i )
{
CTFWearableDemoShield *pWearableShield = dynamic_cast<CTFWearableDemoShield*>( pPlayer->GetWearable( i ) );
if ( pWearableShield )
{
return pWearableShield;
}
}
return NULL;
}
CTFPlayer *GetRuneCarrier( RuneTypes_t type, int iTeam = TEAM_ANY )
{
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pPlayer )
continue;
if ( iTeam != TEAM_ANY && pPlayer->GetTeamNumber() != iTeam )
continue;
if ( pPlayer->m_Shared.GetCarryingRuneType() == type )
{
return pPlayer;
}
}
return NULL;
}
// --------------------------------------------------------------------------------------------------- //
// Shared CTFPlayer implementation.
// --------------------------------------------------------------------------------------------------- //
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::HasCampaignMedal( int iMedal )
{
return ( ( m_iCampaignMedals & iMedal ) != 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::IsAllowedToTaunt( void )
{
if ( !IsAlive() )
return false;
// Check to see if we can taunt again!
if ( m_Shared.InCond( TF_COND_TAUNTING ) )
return false;
if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
return false;
if ( m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
return false;
// Can't taunt while charging.
if ( m_Shared.InCond( TF_COND_SHIELD_CHARGE ) )
return false;
if ( m_Shared.InCond( TF_COND_COMPETITIVE_LOSER ) )
return false;
if ( IsLerpingFOV() )
return false;
// Check for things that prevent taunting
if ( ShouldStopTaunting() )
return false;
// Check to see if we are on the ground.
if ( GetGroundEntity() == NULL && !m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
return false;
CTFWeaponBase *pActiveWeapon = m_Shared.GetActiveTFWeapon();
if ( pActiveWeapon )
{
if ( !pActiveWeapon->OwnerCanTaunt() )
return false;
// ignore taunt key if one of these if active weapon
if ( pActiveWeapon->GetWeaponID() == TF_WEAPON_PDA_ENGINEER_BUILD
|| pActiveWeapon->GetWeaponID() == TF_WEAPON_PDA_ENGINEER_DESTROY )
return false;
}
// can't taunt while carrying an object
if ( m_Shared.IsCarryingObject() )
return false;
// Can't taunt if hooked into a player
if ( m_Shared.InCond( TF_COND_GRAPPLED_TO_PLAYER ) )
return false;
if ( IsPlayerClass( TF_CLASS_SCOUT ) )
{
if ( pActiveWeapon && pActiveWeapon->GetWeaponID() == TF_WEAPON_LUNCHBOX )
{
//Scouts can't drink while they're already phasing.
if ( m_Shared.InCond( TF_COND_ENERGY_BUFF ) || m_Shared.InCond( TF_COND_PHASE ) )
return false;
// Or if their energy drink meter isn't refilled
if ( m_Shared.GetScoutEnergyDrinkMeter() < 100 )
return false;
//They can't drink the default (phase) item while carrying a flag
pActiveWeapon = m_Shared.GetActiveTFWeapon();
if ( pActiveWeapon && pActiveWeapon->GetWeaponID() == TF_WEAPON_LUNCHBOX )
{
CTFLunchBox *pLunchbox = (CTFLunchBox*)pActiveWeapon;
if ( ( pLunchbox->GetLunchboxType() == LUNCHBOX_STANDARD ) || ( pLunchbox->GetLunchboxType() == LUNCHBOX_STANDARD_ROBO ) )
{
if ( !TFGameRules()->IsMannVsMachineMode() && HasItem() )
return false;
}
}
}
}
if ( IsPlayerClass( TF_CLASS_SPY ) )
{
if ( m_Shared.IsStealthed() || m_Shared.InCond( TF_COND_STEALTHED_BLINK ) ||
m_Shared.InCond( TF_COND_DISGUISED ) || m_Shared.InCond( TF_COND_DISGUISING ) )
{
return false;
}
}
return true;
}
// --------------------------------------------------------------------------------------------------- //
// CTFPlayerShared implementation.
// --------------------------------------------------------------------------------------------------- //
CTFPlayerShared::CTFPlayerShared()
{
// If you hit this assert, CONGRATULATIONS! You've added a condition that has gone
// beyond the amount of bits we network for conditions. Take a look at the pattern
// of m_nPlayerCond, m_nPlayerCondEx, m_nPlayerCondEx2, and m_nPlayerCondEx3 to get more bits.
// This pattern is as such to preserve replays.
// Don't forget to add an m_nOldCond* and m_nForceCond*
COMPILE_TIME_ASSERT( TF_COND_LAST < (32 + 32 + 32 + 32) );
m_nPlayerState.Set( TF_STATE_WELCOME );
m_bJumping = false;
m_iAirDash = 0;
m_nAirDucked = 0;
m_flDuckTimer = 0.0f;
m_flStealthNoAttackExpire = 0.0f;
m_flStealthNextChangeTime = 0.0f;
m_iCritMult = 0;
m_flInvisibility = 0.0f;
m_flPrevInvisibility = 0.f;
m_flTmpDamageBonusAmount = 1.0f;
m_bFeignDeathReady = false;
m_fCloakConsumeRate = tf_spy_cloak_consume_rate.GetFloat();
m_fCloakRegenRate = tf_spy_cloak_regen_rate.GetFloat();
m_fEnergyDrinkConsumeRate = tf_scout_energydrink_consume_rate.GetFloat();
m_fEnergyDrinkRegenRate = tf_scout_energydrink_regen_rate.GetFloat();
m_bMotionCloak = false;
m_hStunner = NULL;
m_iStunFlags = 0;
m_hAssist = NULL;
m_bLastDisguisedAsOwnTeam = false;
m_bRageDraining = false;
m_bInUpgradeZone = false;
m_bPhaseFXOn = false;
ResetRageBuffs();
m_iPhaseDamage = 0;
Q_memset(m_pPhaseTrail, 0, sizeof(m_pPhaseTrail));
m_iWeaponKnockbackID = -1;
m_bLoadoutUnavailable = false;
m_nMaskClass = 0;
m_iItemFindBonus = 0;
m_nTeamTeleporterUsed = TEAM_UNASSIGNED;
m_bShieldEquipped = false;
m_bPostShieldCharge = false;
m_iNextMeleeCrit = 0;
m_bParachuteEquipped = false;
m_iDecapitations = m_iOldDecapitations = 0;
m_iOldKillStreak = 0;
m_iOldKillStreakWepSlot = 0;
m_flNextNoiseMakerTime = 0;
m_iSpawnRoomTouchCount = 0;
m_iKillCountSinceLastDeploy = 0;
m_flFirstPrimaryAttack = 0.0f;
#ifdef GAME_DLL
m_flBestOverhealDecayMult = -1;
m_hPeeAttacker = NULL;
m_flHealedPerSecondTimer = -1000;
m_bPulseRadiusHeal = false;
m_flRadiusCurrencyCollectionTime = 0;
m_flRadiusSpyScanTime = 0;
m_flCloakStartTime = -1.0f;
ListenForGameEvent( "player_disconnect" );
#else
m_pWheelEffect = NULL;
m_angVehicleMoveAngles = QAngle( 0.f, 0.f, 0.f );
m_angVehicleMovePitchLast = 0.0f;
// Save Prediction value
m_bPreKartPredictionState = cl_predict->GetBool();
m_hKartParachuteEntity = NULL;
#endif
m_nForceConditions = 0;
m_nForceConditionsEx = 0;
m_nForceConditionsEx2 = 0;
m_nForceConditionsEx3 = 0;
m_flChargeEndTime = -1000;
m_flLastChargeTime = -1000;
m_flLastNoChargeTime = 0;
m_bChargeGlowing = false;
m_bChargeOffSounded = false;
m_bBiteEffectWasApplied = false;
m_flLastMovementStunChange = 0;
m_bStunNeedsFadeOut = false;
m_flChargeMeter = 100;
m_flEnergyDrinkMeter = 0;
m_flHypeMeter = 0;
m_bCarryingObject = false;
m_hCarriedObject = NULL;
m_iStunIndex = -1;
m_flLastNoMovementTime = -1.f;
m_flRuneCharge = 0.f;
#ifdef STAGING_ONLY
m_flSpaceJumpCharge = 100.0f;
m_flSpyTranqBuffDuration = 0.0f;
#endif
m_iPasstimeThrowAnimState = PASSTIME_THROW_ANIM_NONE;
m_bHasPasstimeBall = false;
m_bIsTargetedForPasstimePass = false;
m_askForBallTime = 0.0f;
// make sure we have all conditions in the list
m_ConditionData.EnsureCount( TF_COND_LAST );
}
void CTFPlayerShared::Init( CTFPlayer *pPlayer )
{
m_pOuter = pPlayer;
m_flNextBurningSound = 0;
m_bArenaFirstBloodBoost = false;
m_iStunAnimState = STUN_ANIM_NONE;
m_iPhaseDamage = 0;
m_iWeaponKnockbackID = -1;
m_hStunner = NULL;
m_iPasstimeThrowAnimState = PASSTIME_THROW_ANIM_NONE;
m_bHasPasstimeBall = false;
m_bIsTargetedForPasstimePass = false;
m_askForBallTime = 0.0f;
m_bMotionCloak = false;
m_bShieldEquipped = false;
m_bPostShieldCharge = false;
m_iNextMeleeCrit = 0;
m_bParachuteEquipped = false;
m_iDecapitations = m_iOldDecapitations = 0;
m_iOldKillStreak = 0;
m_iOldKillStreakWepSlot = 0;
SetJumping( false );
SetAssist( NULL );
m_flInvulnerabilityRemoveTime = -1;
SetNextMeleeCrit( MELEE_NOCRIT );
Spawn();
}
void CTFPlayerShared::ResetRageBuffs( void )
{
for ( int i = 0; i < kBuffSlot_MAX; i++ )
{
m_RageBuffSlots[i].m_iBuffTypeActive = 0;
m_RageBuffSlots[i].m_iBuffPulseCount = 0;
m_RageBuffSlots[i].m_flNextBuffPulseTime = 0.0f;
}
}
void CTFPlayerShared::Spawn( void )
{
#ifdef GAME_DLL
m_hPeeAttacker = NULL;
if ( m_bCarryingObject )
{
CBaseObject* pObj = GetCarriedObject();
if ( pObj )
{
pObj->DetonateObject();
}
}
m_bCarryingObject = false;
m_hCarriedObject = NULL;
m_flRadiusHealCheckTime = 0;
m_flKingRuneBuffCheckTime = 0.f;
m_bBiteEffectWasApplied = false;
m_flNextRocketPackTime = 0.f;
m_iSpawnRoomTouchCount = 0;
SetRevengeCrits( 0 );
m_PlayerStuns.RemoveAll();
m_iStunIndex = -1;
m_iPasstimeThrowAnimState = PASSTIME_THROW_ANIM_NONE;
m_bHasPasstimeBall = false;
m_bIsTargetedForPasstimePass = false;
m_askForBallTime = 0.0f;
#else
m_bSyncingConditions = false;
#endif
m_bKingRuneBuffActive = false;
// Reset our assist here incase something happens before we get killed
// again that checks this (getting slapped with a fish)
SetAssist( NULL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
template < typename tIntType >
class CConditionVars
{
public:
CConditionVars( tIntType& nPlayerCond, tIntType& nPlayerCondEx, tIntType& nPlayerCondEx2, tIntType& nPlayerCondEx3, ETFCond eCond )
{
if ( eCond >= 96 )
{
Assert( eCond < 96 + 32 );
m_pnCondVar = &nPlayerCondEx3;
m_nCondBit = eCond - 96;
}
else if( eCond >= 64 )
{
Assert( eCond < (64 + 32) );
m_pnCondVar = &nPlayerCondEx2;
m_nCondBit = eCond - 64;
}
else if ( eCond >= 32 )
{
Assert( eCond < (32 + 32) );
m_pnCondVar = &nPlayerCondEx;
m_nCondBit = eCond - 32;
}
else
{
m_pnCondVar = &nPlayerCond;
m_nCondBit = eCond;
}
}
tIntType& CondVar() const
{
return *m_pnCondVar;
}
int CondBit() const
{
return 1 << m_nCondBit;
}
private:
tIntType *m_pnCondVar;
int m_nCondBit;
};
//-----------------------------------------------------------------------------
// Purpose: Add a condition and duration
// duration of PERMANENT_CONDITION means infinite duration
//-----------------------------------------------------------------------------
void CTFPlayerShared::AddCond( ETFCond eCond, float flDuration /* = PERMANENT_CONDITION */, CBaseEntity *pProvider /*= NULL */)
{
Assert( eCond >= 0 && eCond < TF_COND_LAST );
Assert( eCond < m_ConditionData.Count() );
// If we're dead, don't take on any new conditions
if( !m_pOuter || !m_pOuter->IsAlive() )
{
return;
}
#ifdef CLEINT_DLL
if ( m_pOuter->IsDormant() )
{
return;
}
#endif
// sanity check to prevent servers from adding these conditions when they shouldn't
if ( ( eCond == TF_COND_COMPETITIVE_WINNER ) || ( eCond == TF_COND_COMPETITIVE_LOSER ) )
{
if ( TFGameRules() && !TFGameRules()->ShowMatchSummary() )
return;
}
// Which bitfield are we tracking this condition variable in? Which bit within
// that variable will we track it as?
CConditionVars<int> cPlayerCond( m_nPlayerCond.m_Value, m_nPlayerCondEx.m_Value, m_nPlayerCondEx2.m_Value, m_nPlayerCondEx3.m_Value, eCond );
// See if there is an object representation of the condition.
bool bAddedToExternalConditionList = m_ConditionList.Add( eCond, flDuration, m_pOuter, pProvider );
if ( !bAddedToExternalConditionList )
{
// Set the condition bit for this condition.
cPlayerCond.CondVar() |= cPlayerCond.CondBit();
// Flag for gamecode to query
m_ConditionData[eCond].m_bPrevActive = ( m_ConditionData[eCond].m_flExpireTime != 0.f ) ? true : false;
if ( flDuration != PERMANENT_CONDITION )
{
// if our current condition is permanent or we're trying to set a new
// time that's less our current time remaining, use our current time instead
if ( ( m_ConditionData[eCond].m_flExpireTime == PERMANENT_CONDITION ) ||
( flDuration < m_ConditionData[eCond].m_flExpireTime ) )
{
flDuration = m_ConditionData[eCond].m_flExpireTime;
}
}
m_ConditionData[eCond].m_flExpireTime = flDuration;
m_ConditionData[eCond].m_pProvider = pProvider;
m_ConditionData[ eCond ].m_nPreventedDamageFromCondition = 0;
OnConditionAdded( eCond );
}
}
//-----------------------------------------------------------------------------
// Purpose: Forcibly remove a condition
//-----------------------------------------------------------------------------
void CTFPlayerShared::RemoveCond( ETFCond eCond, bool ignore_duration )
{
Assert( eCond >= 0 && eCond < TF_COND_LAST );
Assert( eCond < m_ConditionData.Count() );
if ( !InCond( eCond ) )
return;
CConditionVars<int> cPlayerCond( m_nPlayerCond.m_Value, m_nPlayerCondEx.m_Value, m_nPlayerCondEx2.m_Value, m_nPlayerCondEx3.m_Value, eCond );
// If this variable is handled by the condition list, abort before doing the
// work for the condition flags.
if ( m_ConditionList.Remove( eCond, ignore_duration ) )
return;
cPlayerCond.CondVar() &= ~cPlayerCond.CondBit();
OnConditionRemoved( eCond );
if ( m_ConditionData[ eCond ].m_nPreventedDamageFromCondition )
{
IGameEvent *pEvent = gameeventmanager->CreateEvent( "damage_prevented" );
if ( pEvent )
{
pEvent->SetInt( "preventor", m_ConditionData[eCond].m_pProvider ? m_ConditionData[eCond].m_pProvider->entindex() : m_pOuter->entindex() );
pEvent->SetInt( "victim", m_pOuter->entindex() );
pEvent->SetInt( "amount", m_ConditionData[ eCond ].m_nPreventedDamageFromCondition );
pEvent->SetInt( "condition", eCond );
gameeventmanager->FireEvent( pEvent, true );
}
m_ConditionData[ eCond ].m_nPreventedDamageFromCondition = 0;
}
m_ConditionData[eCond].m_flExpireTime = 0;
m_ConditionData[eCond].m_pProvider = NULL;
m_ConditionData[eCond].m_bPrevActive = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::InCond( ETFCond eCond ) const
{
Assert( eCond >= 0 && eCond < TF_COND_LAST );
// Old condition system, only used for the first 32 conditions
if ( eCond < 32 && m_ConditionList.InCond( eCond ) )
return true;
CConditionVars<const int> cPlayerCond( m_nPlayerCond.m_Value, m_nPlayerCondEx.m_Value, m_nPlayerCondEx2.m_Value, m_nPlayerCondEx3.m_Value, eCond );
return (cPlayerCond.CondVar() & cPlayerCond.CondBit()) != 0;
}
//-----------------------------------------------------------------------------
// Purpose: Return whether or not we were in this condition before.
//-----------------------------------------------------------------------------
bool CTFPlayerShared::WasInCond( ETFCond eCond ) const
{
// I don't know if this actually works for conditions < 32, because we definitely cannot peak into m_ConditionList (back in time).
// But others think that m_ConditionList is propogated into m_nOldConditions, so just check if you hit the assert. (And then remove the
// assert. And this comment).
Assert( eCond >= 32 && eCond < TF_COND_LAST );
CConditionVars<const int> cPlayerCond( m_nOldConditions, m_nOldConditionsEx, m_nOldConditionsEx2, m_nOldConditionsEx3, eCond );
return (cPlayerCond.CondVar() & cPlayerCond.CondBit()) != 0;
}
//-----------------------------------------------------------------------------
// Purpose: Set a bit to force this condition off and then back on next time we sync bits from the server.
//-----------------------------------------------------------------------------
void CTFPlayerShared::ForceRecondNextSync( ETFCond eCond )
{
// I don't know if this actually works for conditions < 32. We may need to set this bit in m_ConditionList, too.
// Please check if you hit the assert. (And then remove the assert. And this comment).
Assert(eCond >= 32 && eCond < TF_COND_LAST);
CConditionVars<int> playerCond( m_nForceConditions, m_nForceConditionsEx, m_nForceConditionsEx2, m_nForceConditionsEx3, eCond );
playerCond.CondVar() |= playerCond.CondBit();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFPlayerShared::GetConditionDuration( ETFCond eCond ) const
{
Assert( eCond >= 0 && eCond < TF_COND_LAST );
Assert( eCond < m_ConditionData.Count() );
if ( InCond( eCond ) )
{
return m_ConditionData[eCond].m_flExpireTime;
}
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the entity that provided the passed in condition
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayerShared::GetConditionProvider( ETFCond eCond ) const
{
Assert( eCond >= 0 && eCond < TF_COND_LAST );
Assert( eCond < m_ConditionData.Count() );
CBaseEntity *pProvider = NULL;
if ( InCond( eCond ) )
{
if ( eCond == TF_COND_CRITBOOSTED )
{
pProvider = m_ConditionList.GetProvider( eCond );
}
else
{
pProvider = m_ConditionData[eCond].m_pProvider;
}
}
return pProvider;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the entity that applied this condition to us - for granting an assist when we die
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayerShared::GetConditionAssistFromVictim( void )
{
// We only give an assist to one person. That means this list is order
// sensitive, so consider how "powerful" an effect is when adding it here.
static const ETFCond nTrackedConditions[] =
{
TF_COND_URINE,
TF_COND_MAD_MILK,
TF_COND_MARKEDFORDEATH,
};
CBaseEntity *pProvider = NULL;
for ( int i = 0; i < ARRAYSIZE( nTrackedConditions ); i++ )
{
if ( InCond( nTrackedConditions[i] ) )
{
pProvider = GetConditionProvider( nTrackedConditions[i] );
break;
}
}
return pProvider;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the entity that applied this condition to us - for granting an assist when we kill someone
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayerShared::GetConditionAssistFromAttacker( void )
{
// We only give an assist to one person. That means this list is order
// sensitive, so consider how "powerful" an effect is when adding it here.
static const ETFCond nTrackedConditions[] =
{
TF_COND_OFFENSEBUFF, // Highest priority
TF_COND_DEFENSEBUFF,
TF_COND_REGENONDAMAGEBUFF,
TF_COND_NOHEALINGDAMAGEBUFF, // Lowest priority
};
CBaseEntity *pProvider = NULL;
for ( int i = 0; i < ARRAYSIZE( nTrackedConditions ); i++ )
{
if ( InCond( nTrackedConditions[i] ) )
{
CBaseEntity* pPotentialProvider = GetConditionProvider( nTrackedConditions[i] );
// Check to make sure we're not providing the condition to ourselves
if( pPotentialProvider != m_pOuter )
{
pProvider = pPotentialProvider;
break;
}
}
}
return pProvider;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::DebugPrintConditions( void )
{
#ifndef CLIENT_DLL
const char *szDll = "Server";
#else
const char *szDll = "Client";
#endif
Msg( "( %s ) Conditions for player ( %d )\n", szDll, m_pOuter->entindex() );
int i;
int iNumFound = 0;
for ( i=0;i<TF_COND_LAST;i++ )
{
if ( InCond( (ETFCond)i ) )
{
if ( m_ConditionData[i].m_flExpireTime == PERMANENT_CONDITION )
{
Msg( "( %s ) Condition %d - ( permanent cond )\n", szDll, i );
}
else
{
Msg( "( %s ) Condition %d - ( %.1f left )\n", szDll, i, m_ConditionData[i].m_flExpireTime );
}
iNumFound++;
}
}
if ( iNumFound == 0 )
{
Msg( "( %s ) No active conditions\n", szDll );
}
}
void CTFPlayerShared::InstantlySniperUnzoom( void )
{
// Unzoom if we are a sniper zoomed!
if ( m_pOuter->GetPlayerClass()->GetClassIndex() == TF_CLASS_SNIPER )
{
CTFWeaponBase *pWpn = m_pOuter->GetActiveTFWeapon();
if ( pWpn && WeaponID_IsSniperRifle( pWpn->GetWeaponID() ) )
{
CTFSniperRifle *pRifle = static_cast<CTFSniperRifle*>( pWpn );
if ( pRifle->IsZoomed() )
{
// Let the rifle clean up conditions and state
pRifle->ToggleZoom();
// Slam the FOV right now
m_pOuter->SetFOV( m_pOuter, 0, 0.0f );
}
}
}
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnPreDataChanged( void )
{
m_ConditionList.OnPreDataChanged();
m_nOldConditions = m_nPlayerCond;
m_nOldConditionsEx = m_nPlayerCondEx;
m_nOldConditionsEx2 = m_nPlayerCondEx2;
m_nOldConditionsEx3 = m_nPlayerCondEx3;
m_nOldDisguiseClass = GetDisguiseClass();
m_nOldDisguiseTeam = GetDisguiseTeam();
m_iOldMovementStunParity = m_iMovementStunParity;
InvisibilityThink();
ConditionThink();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnDataChanged( void )
{
m_ConditionList.OnDataChanged( m_pOuter );
if ( m_iOldMovementStunParity != m_iMovementStunParity )
{
m_flStunFade = gpGlobals->curtime + m_flMovementStunTime;
m_flStunEnd = m_flStunFade;
if ( IsControlStunned() && (m_iStunAnimState == STUN_ANIM_NONE) )
{
m_flStunEnd += CONTROL_STUN_ANIM_TIME;
}
UpdateLegacyStunSystem();
}
// Update conditions from last network change
SyncConditions( m_nOldConditions, m_nPlayerCond, m_nForceConditions, 0 );
SyncConditions( m_nOldConditionsEx, m_nPlayerCondEx, m_nForceConditionsEx, 32 );
SyncConditions( m_nOldConditionsEx2, m_nPlayerCondEx2, m_nForceConditionsEx2, 64 );
SyncConditions( m_nOldConditionsEx3, m_nPlayerCondEx3, m_nForceConditionsEx3, 96 );
// Make sure these items are present
m_nPlayerCond |= m_nForceConditions;
m_nPlayerCondEx |= m_nForceConditionsEx;
m_nPlayerCondEx2 |= m_nForceConditionsEx2;
m_nPlayerCondEx3 |= m_nForceConditionsEx3;
// Clear our force bits now that we've used them.
m_nForceConditions = 0;
m_nForceConditionsEx = 0;
m_nForceConditionsEx2 = 0;
m_nForceConditionsEx3 = 0;
if ( m_nOldDisguiseClass != GetDisguiseClass() || m_nOldDisguiseTeam != GetDisguiseTeam() )
{
OnDisguiseChanged();
}
if ( m_hDisguiseWeapon )
{
m_hDisguiseWeapon->UpdateVisibility();
m_hDisguiseWeapon->UpdateParticleSystems();
}
if ( ( IsLoser() || InCond( TF_COND_COMPETITIVE_LOSER ) ) && GetActiveTFWeapon() && !GetActiveTFWeapon()->IsEffectActive( EF_NODRAW ) )
{
GetActiveTFWeapon()->SetWeaponVisible( false );
}
}
//-----------------------------------------------------------------------------
// Purpose: check the newly networked conditions for changes
//-----------------------------------------------------------------------------
void CTFPlayerShared::SyncConditions( int nPreviousConditions, int nNewConditions, int nForceConditions, int nBaseCondBit )
{
if ( nPreviousConditions == nNewConditions )
return;
int nCondChanged = nNewConditions ^ nPreviousConditions;
int nCondAdded = nCondChanged & nNewConditions;
int nCondRemoved = nCondChanged & nPreviousConditions;
m_bSyncingConditions = true;
for ( int i=0;i<32;i++ )
{
const int testBit = 1<<i;
if ( nForceConditions & testBit )
{
if ( nPreviousConditions & testBit )
{
OnConditionRemoved((ETFCond)(nBaseCondBit + i));
}
OnConditionAdded((ETFCond)(nBaseCondBit + i));
}
else
{
if ( nCondAdded & testBit )
{
OnConditionAdded( (ETFCond)(nBaseCondBit + i) );
}
else if ( nCondRemoved & testBit )
{
OnConditionRemoved( (ETFCond)(nBaseCondBit + i) );
}
}
}
m_bSyncingConditions = false;
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Remove any conditions affecting players
//-----------------------------------------------------------------------------
void CTFPlayerShared::RemoveAllCond()
{
m_ConditionList.RemoveAll();
int i;
for ( i=0;i<TF_COND_LAST;i++ )
{
if ( InCond( (ETFCond)i ) )
{
RemoveCond( (ETFCond)i );
}
}
// Now remove all the rest
m_nPlayerCond = 0;
m_nPlayerCondEx = 0;
m_nPlayerCondEx2 = 0;
m_nPlayerCondEx3 = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Called on both client and server. Server when we add the bit,
// and client when it receives the new cond bits and finds one added
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnConditionAdded( ETFCond eCond )
{
switch( eCond )
{
case TF_COND_ZOOMED:
OnAddZoomed();
break;
case TF_COND_HEALTH_BUFF:
#ifdef GAME_DLL
m_flHealFraction = 0;
m_flDisguiseHealFraction = 0;
m_flHealedPerSecondTimer = gpGlobals->curtime + 1.0f;
#endif
break;
case TF_COND_HEALTH_OVERHEALED:
OnAddOverhealed();
break;
case TF_COND_FEIGN_DEATH:
OnAddFeignDeath();
break;
case TF_COND_STEALTHED:
case TF_COND_STEALTHED_USER_BUFF:
OnAddStealthed();
break;
case TF_COND_INVULNERABLE:
case TF_COND_INVULNERABLE_USER_BUFF:
case TF_COND_INVULNERABLE_CARD_EFFECT:
OnAddInvulnerable();
break;
case TF_COND_TELEPORTED:
OnAddTeleported();
break;
case TF_COND_BURNING:
OnAddBurning();
break;
case TF_COND_CRITBOOSTED:
Assert( !"TF_COND_CRITBOOSTED should be handled by the condition list!" );
break;
case TF_COND_CRITBOOSTED_DEMO_CHARGE:
OnAddDemoCharge();
break;
// First blood falls through on purpose.
case TF_COND_CRITBOOSTED_FIRST_BLOOD:
SetFirstBloodBoosted( true );
case TF_COND_CRITBOOSTED_PUMPKIN:
case TF_COND_CRITBOOSTED_USER_BUFF:
case TF_COND_CRITBOOSTED_BONUS_TIME:
case TF_COND_CRITBOOSTED_CTF_CAPTURE:
case TF_COND_CRITBOOSTED_ON_KILL:
case TF_COND_CRITBOOSTED_RAGE_BUFF:
case TF_COND_SNIPERCHARGE_RAGE_BUFF:
case TF_COND_CRITBOOSTED_CARD_EFFECT:
case TF_COND_CRITBOOSTED_RUNE_TEMP:
OnAddCritBoost();
break;
case TF_COND_SODAPOPPER_HYPE:
OnAddSodaPopperHype();
break;
case TF_COND_DISGUISING:
OnAddDisguising();
break;
case TF_COND_DISGUISED:
OnAddDisguised();
break;
case TF_COND_URINE:
OnAddUrine();
break;
case TF_COND_MARKEDFORDEATH:
OnAddMarkedForDeath();
break;
case TF_COND_BLEEDING:
OnAddBleeding();
break;
case TF_COND_TAUNTING:
OnAddTaunting();
break;
case TF_COND_STUNNED:
OnAddStunned();
break;
case TF_COND_PHASE:
OnAddPhase();
break;
case TF_COND_OFFENSEBUFF:
OnAddOffenseBuff();
break;
case TF_COND_DEFENSEBUFF:
case TF_COND_DEFENSEBUFF_NO_CRIT_BLOCK:
case TF_COND_DEFENSEBUFF_HIGH:
OnAddDefenseBuff();
break;
case TF_COND_REGENONDAMAGEBUFF:
OnAddOffenseHealthRegenBuff();
break;
case TF_COND_NOHEALINGDAMAGEBUFF:
OnAddNoHealingDamageBuff();
break;
case TF_COND_SHIELD_CHARGE:
OnAddShieldCharge();
break;
case TF_COND_DEMO_BUFF:
OnAddDemoBuff();
break;
case TF_COND_ENERGY_BUFF:
OnAddEnergyDrinkBuff();
break;
case TF_COND_RADIUSHEAL:
OnAddRadiusHeal();
break;
case TF_COND_MEGAHEAL:
OnAddMegaHeal();
break;
case TF_COND_MAD_MILK:
OnAddMadMilk();
break;
case TF_COND_SPEED_BOOST: OnAddSpeedBoost( false ); break;
#ifdef STAGING_ONLY //STAGING_ENGY
case TF_COND_NO_COMBAT_SPEED_BOOST: OnAddSpeedBoost( true ); break;
#endif
case TF_COND_SAPPED:
OnAddSapped();
break;
case TF_COND_REPROGRAMMED:
OnAddReprogrammed();
break;
case TF_COND_PASSTIME_PENALTY_DEBUFF:
case TF_COND_MARKEDFORDEATH_SILENT:
OnAddMarkedForDeathSilent();
break;
case TF_COND_DISGUISED_AS_DISPENSER:
OnAddDisguisedAsDispenser();
break;
case TF_COND_HALLOWEEN_BOMB_HEAD:
OnAddHalloweenBombHead();
break;
case TF_COND_HALLOWEEN_THRILLER:
OnAddHalloweenThriller();
break;
case TF_COND_RADIUSHEAL_ON_DAMAGE:
OnAddRadiusHealOnDamage();
break;
case TF_COND_MEDIGUN_UBER_BULLET_RESIST:
OnAddMedEffectUberBulletResist();
break;
case TF_COND_MEDIGUN_UBER_BLAST_RESIST:
OnAddMedEffectUberBlastResist();
break;
case TF_COND_MEDIGUN_UBER_FIRE_RESIST:
OnAddMedEffectUberFireResist();
break;
case TF_COND_MEDIGUN_SMALL_BULLET_RESIST:
OnAddMedEffectSmallBulletResist();
break;
case TF_COND_MEDIGUN_SMALL_BLAST_RESIST:
OnAddMedEffectSmallBlastResist();
break;
case TF_COND_MEDIGUN_SMALL_FIRE_RESIST:
OnAddMedEffectSmallFireResist();
break;
case TF_COND_STEALTHED_USER_BUFF_FADING:
OnAddStealthedUserBuffFade();
break;
case TF_COND_BULLET_IMMUNE:
OnAddBulletImmune();
break;
case TF_COND_BLAST_IMMUNE:
OnAddBlastImmune();
break;
case TF_COND_FIRE_IMMUNE:
OnAddFireImmune();
break;
case TF_COND_MVM_BOT_STUN_RADIOWAVE:
OnAddMVMBotRadiowave();
break;
case TF_COND_HALLOWEEN_SPEED_BOOST:
OnAddHalloweenSpeedBoost();
break;
case TF_COND_HALLOWEEN_QUICK_HEAL:
OnAddHalloweenQuickHeal();
break;
case TF_COND_HALLOWEEN_GIANT:
OnAddHalloweenGiant();
break;
case TF_COND_HALLOWEEN_TINY:
OnAddHalloweenTiny();
break;
case TF_COND_HALLOWEEN_GHOST_MODE:
OnAddHalloweenGhostMode();
break;
case TF_COND_PARACHUTE_DEPLOYED:
OnAddCondParachute();
break;
case TF_COND_HALLOWEEN_KART_DASH:
OnAddHalloweenKartDash();
break;
case TF_COND_HALLOWEEN_KART:
OnAddHalloweenKart();
break;
case TF_COND_BALLOON_HEAD:
OnAddBalloonHead();
break;
case TF_COND_MELEE_ONLY:
OnAddMeleeOnly();
break;
case TF_COND_SWIMMING_CURSE:
OnAddSwimmingCurse();
break;
case TF_COND_HALLOWEEN_KART_CAGE:
OnAddHalloweenKartCage();
break;
case TF_COND_RUNE_RESIST:
OnAddRuneResist();
break;
case TF_COND_GRAPPLINGHOOK_LATCHED:
OnAddGrapplingHookLatched();
break;
case TF_COND_PASSTIME_INTERCEPTION:
OnAddPasstimeInterception();
break;
case TF_COND_RUNE_PLAGUE:
OnAddRunePlague();
break;
case TF_COND_PLAGUE:
OnAddPlague();
break;
case TF_COND_PURGATORY:
OnAddInPurgatory();
break;
case TF_COND_COMPETITIVE_WINNER:
OnAddCompetitiveWinner();
break;
case TF_COND_COMPETITIVE_LOSER:
OnAddCompetitiveLoser();
break;
#ifdef STAGING_ONLY
case TF_COND_SPY_CLASS_STEAL:
OnAddCondSpyClassSteal();
break;
case TF_COND_TRANQ_MARKED:
OnAddTranqMark();
break;
/*
case TF_COND_SPACE_GRAVITY:
OnAddSpaceGravity();
break;
case TF_COND_SELF_CONC:
OnAddSelfConc();
break;
*/
case TF_COND_ROCKETPACK:
OnAddRocketPack();
break;
case TF_COND_STEALTHED_PHASE:
OnAddStealthedPhase();
break;
case TF_COND_CLIP_OVERLOAD:
OnAddClipOverload();
break;
case TF_COND_KING_BUFFED:
OnAddKingBuff();
break;
#endif // STAGING_ONLY
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Called on both client and server. Server when we remove the bit,
// and client when it receives the new cond bits and finds one removed
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnConditionRemoved( ETFCond eCond )
{
switch( eCond )
{
case TF_COND_ZOOMED:
OnRemoveZoomed();
break;
case TF_COND_BURNING:
OnRemoveBurning();
break;
case TF_COND_CRITBOOSTED:
Assert( !"TF_COND_CRITBOOSTED should be handled by the condition list!" );
break;
case TF_COND_CRITBOOSTED_DEMO_CHARGE:
OnRemoveDemoCharge();
break;
// First blood falls through on purpose.
case TF_COND_CRITBOOSTED_FIRST_BLOOD:
SetFirstBloodBoosted( false );
case TF_COND_CRITBOOSTED_PUMPKIN:
case TF_COND_CRITBOOSTED_USER_BUFF:
case TF_COND_CRITBOOSTED_BONUS_TIME:
case TF_COND_CRITBOOSTED_CTF_CAPTURE:
case TF_COND_CRITBOOSTED_ON_KILL:
case TF_COND_CRITBOOSTED_RAGE_BUFF:
case TF_COND_SNIPERCHARGE_RAGE_BUFF:
case TF_COND_CRITBOOSTED_CARD_EFFECT:
case TF_COND_CRITBOOSTED_RUNE_TEMP:
OnRemoveCritBoost();
break;
case TF_COND_SODAPOPPER_HYPE:
OnRemoveSodaPopperHype();
break;
case TF_COND_TMPDAMAGEBONUS:
OnRemoveTmpDamageBonus();
break;
case TF_COND_HEALTH_BUFF:
#ifdef GAME_DLL
m_flHealFraction = 0;
m_flDisguiseHealFraction = 0;
#endif
break;
case TF_COND_HEALTH_OVERHEALED:
OnRemoveOverhealed();
break;
case TF_COND_FEIGN_DEATH:
OnRemoveFeignDeath();
break;
case TF_COND_STEALTHED:
case TF_COND_STEALTHED_USER_BUFF:
OnRemoveStealthed();
break;
case TF_COND_DISGUISED:
OnRemoveDisguised();
break;
case TF_COND_DISGUISING:
OnRemoveDisguising();
break;
case TF_COND_INVULNERABLE:
case TF_COND_INVULNERABLE_USER_BUFF:
case TF_COND_INVULNERABLE_CARD_EFFECT:
OnRemoveInvulnerable();
break;
case TF_COND_TELEPORTED:
OnRemoveTeleported();
break;
case TF_COND_STUNNED:
OnRemoveStunned();
break;
case TF_COND_PHASE:
OnRemovePhase();
break;
case TF_COND_URINE:
OnRemoveUrine();
break;
case TF_COND_MARKEDFORDEATH:
OnRemoveMarkedForDeath();
break;
case TF_COND_BLEEDING:
OnRemoveBleeding();
break;
case TF_COND_INVULNERABLE_WEARINGOFF:
OnRemoveInvulnerableWearingOff();
break;
case TF_COND_OFFENSEBUFF:
OnRemoveOffenseBuff();
break;
case TF_COND_DEFENSEBUFF:
case TF_COND_DEFENSEBUFF_NO_CRIT_BLOCK:
case TF_COND_DEFENSEBUFF_HIGH:
OnRemoveDefenseBuff();
break;
case TF_COND_REGENONDAMAGEBUFF:
OnRemoveOffenseHealthRegenBuff();
break;
case TF_COND_NOHEALINGDAMAGEBUFF:
OnRemoveNoHealingDamageBuff();
break;
case TF_COND_SHIELD_CHARGE:
OnRemoveShieldCharge();
break;
case TF_COND_DEMO_BUFF:
OnRemoveDemoBuff();
break;
case TF_COND_ENERGY_BUFF:
OnRemoveEnergyDrinkBuff();
break;
case TF_COND_RADIUSHEAL:
OnRemoveRadiusHeal();
break;
case TF_COND_MEGAHEAL:
OnRemoveMegaHeal();
break;
case TF_COND_MAD_MILK:
OnRemoveMadMilk();
break;
case TF_COND_TAUNTING:
OnRemoveTaunting();
break;
case TF_COND_SPEED_BOOST: OnRemoveSpeedBoost( false ); break;
#ifdef STAGING_ONLY
case TF_COND_NO_COMBAT_SPEED_BOOST: OnRemoveSpeedBoost( true ); break;
#endif
case TF_COND_SAPPED:
OnRemoveSapped();
break;
case TF_COND_REPROGRAMMED:
OnRemoveReprogrammed();
break;
case TF_COND_PASSTIME_PENALTY_DEBUFF:
case TF_COND_MARKEDFORDEATH_SILENT:
OnRemoveMarkedForDeathSilent();
break;
case TF_COND_DISGUISED_AS_DISPENSER:
OnRemoveDisguisedAsDispenser();
break;
case TF_COND_HALLOWEEN_BOMB_HEAD:
OnRemoveHalloweenBombHead();
break;
case TF_COND_HALLOWEEN_THRILLER:
OnRemoveHalloweenThriller();
break;
case TF_COND_RADIUSHEAL_ON_DAMAGE:
OnRemoveRadiusHealOnDamage();
break;
case TF_COND_MEDIGUN_UBER_BULLET_RESIST:
OnRemoveMedEffectUberBulletResist();
break;
case TF_COND_MEDIGUN_UBER_BLAST_RESIST:
OnRemoveMedEffectUberBlastResist();
break;
case TF_COND_MEDIGUN_UBER_FIRE_RESIST:
OnRemoveMedEffectUberFireResist();
break;
case TF_COND_MEDIGUN_SMALL_BULLET_RESIST:
OnRemoveMedEffectSmallBulletResist();
break;
case TF_COND_MEDIGUN_SMALL_BLAST_RESIST:
OnRemoveMedEffectSmallBlastResist();
break;
case TF_COND_MEDIGUN_SMALL_FIRE_RESIST:
OnRemoveMedEffectSmallFireResist();
break;
case TF_COND_STEALTHED_USER_BUFF_FADING:
OnRemoveStealthedUserBuffFade();
break;
case TF_COND_BULLET_IMMUNE:
OnRemoveBulletImmune();
break;
case TF_COND_BLAST_IMMUNE:
OnRemoveBlastImmune();
break;
case TF_COND_FIRE_IMMUNE:
OnRemoveFireImmune();
break;
case TF_COND_MVM_BOT_STUN_RADIOWAVE:
OnRemoveMVMBotRadiowave();
break;
case TF_COND_HALLOWEEN_SPEED_BOOST:
OnRemoveHalloweenSpeedBoost();
break;
case TF_COND_HALLOWEEN_QUICK_HEAL:
OnRemoveHalloweenQuickHeal();
break;
case TF_COND_HALLOWEEN_GIANT:
OnRemoveHalloweenGiant();
break;
case TF_COND_HALLOWEEN_TINY:
OnRemoveHalloweenTiny();
break;
case TF_COND_HALLOWEEN_GHOST_MODE:
OnRemoveHalloweenGhostMode();
break;
case TF_COND_PARACHUTE_DEPLOYED:
OnRemoveCondParachute();
break;
case TF_COND_HALLOWEEN_KART_DASH:
OnRemoveHalloweenKartDash();
break;
case TF_COND_HALLOWEEN_KART:
OnRemoveHalloweenKart();
break;
case TF_COND_BALLOON_HEAD:
OnRemoveBalloonHead();
break;
case TF_COND_MELEE_ONLY:
OnRemoveMeleeOnly();
break;
case TF_COND_SWIMMING_CURSE:
OnRemoveSwimmingCurse();
case TF_COND_HALLOWEEN_KART_CAGE:
OnRemoveHalloweenKartCage();
break;
case TF_COND_RUNE_RESIST:
OnRemoveRuneResist();
break;
case TF_COND_GRAPPLINGHOOK_LATCHED:
OnRemoveGrapplingHookLatched();
break;
case TF_COND_PASSTIME_INTERCEPTION:
OnRemovePasstimeInterception();
break;
case TF_COND_RUNE_PLAGUE:
OnRemoveRunePlague();
break;
case TF_COND_PLAGUE:
OnRemovePlague();
break;
case TF_COND_PURGATORY:
OnRemoveInPurgatory();
break;
case TF_COND_RUNE_KING:
OnRemoveRuneKing();
break;
case TF_COND_KING_BUFFED:
OnRemoveKingBuff();
break;
case TF_COND_RUNE_SUPERNOVA:
OnRemoveRuneSupernova();
break;
case TF_COND_COMPETITIVE_WINNER:
OnRemoveCompetitiveWinner();
break;
case TF_COND_COMPETITIVE_LOSER:
OnRemoveCompetitiveLoser();
break;
#ifdef STAGING_ONLY
case TF_COND_SPY_CLASS_STEAL:
OnRemoveCondSpyClassSteal();
break;
case TF_COND_TRANQ_MARKED:
OnRemoveTranqMark();
break;
/*
case TF_COND_SPACE_GRAVITY:
OnRemoveSpaceGravity();
break;
case TF_COND_SELF_CONC:
OnRemoveSelfConc();
break;
*/
case TF_COND_ROCKETPACK:
OnRemoveRocketPack();
break;
case TF_COND_STEALTHED_PHASE:
OnRemoveStealthedPhase();
break;
case TF_COND_CLIP_OVERLOAD:
OnRemoveClipOverload();
break;
#endif // STAGING_ONLY
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns the overheal bonus the specified healer is capable of buffing to
//-----------------------------------------------------------------------------
int CTFPlayerShared::GetMaxBuffedHealth( bool bIgnoreAttributes /*= false*/, bool bIgnoreHealthOverMax /*= false*/ )
{
// Find the healer we have who's providing the most overheal
float flBoostMax = m_pOuter->GetMaxHealthForBuffing() * tf_max_health_boost.GetFloat();
#ifdef GAME_DLL
if ( !bIgnoreAttributes )
{
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
float flOverheal = m_pOuter->GetMaxHealthForBuffing() * m_aHealers[i].flOverhealBonus;
if ( flOverheal > flBoostMax )
{
flBoostMax = flOverheal;
}
}
}
#endif
int iRoundDown = floor( flBoostMax / 5 );
iRoundDown = iRoundDown * 5;
if ( !bIgnoreHealthOverMax )
{
// Don't allow overheal total to be less than the buffable + unbuffable max health or the current health
int nBoostMin = MAX( m_pOuter->GetMaxHealth(), m_pOuter->GetHealth() );
if ( iRoundDown < nBoostMin )
{
iRoundDown = nBoostMin;
}
}
return iRoundDown;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerShared::GetDisguiseMaxBuffedHealth( bool bIgnoreAttributes /*= false*/, bool bIgnoreHealthOverMax /*= false*/ )
{
// Find the healer we have who's providing the most overheal
float flBoostMax = GetDisguiseMaxHealth() * tf_max_health_boost.GetFloat();
#ifdef GAME_DLL
if ( !bIgnoreAttributes )
{
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
float flOverheal = GetDisguiseMaxHealth() * m_aHealers[i].flOverhealBonus;
if ( flOverheal > flBoostMax )
{
flBoostMax = flOverheal;
}
}
}
#endif
int iRoundDown = floor( flBoostMax / 5 );
iRoundDown = iRoundDown * 5;
if ( !bIgnoreHealthOverMax )
{
// Don't allow overheal total to be less than the buffable + unbuffable max health or the current health
int nBoostMin = MAX(GetDisguiseMaxHealth(), GetDisguiseHealth() );
if ( iRoundDown < nBoostMin )
{
iRoundDown = nBoostMin;
}
}
return iRoundDown;
}
//-----------------------------------------------------------------------------
bool ShouldRemoveConditionOnTimeout( ETFCond eCond )
{
switch( eCond )
{
case TF_COND_HALLOWEEN_GHOST_MODE:
case TF_COND_HALLOWEEN_IN_HELL:
case TF_COND_HALLOWEEN_KART:
break;
return !TFGameRules()->ArePlayersInHell();
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Runs SERVER SIDE only Condition Think
// If a player needs something to be updated no matter what do it here (invul, etc).
//-----------------------------------------------------------------------------
void CTFPlayerShared::ConditionGameRulesThink( void )
{
#ifdef GAME_DLL
m_ConditionList.ServerThink();
if ( m_flNextCritUpdate < gpGlobals->curtime )
{
UpdateCritMult();
m_flNextCritUpdate = gpGlobals->curtime + 0.5;
}
for ( int i=0; i < TF_COND_LAST; ++i )
{
// if we're in this condition and it's not already being handled by the condition list
if ( InCond( (ETFCond)i ) && ((i >= 32) || !m_ConditionList.InCond( (ETFCond)i )) )
{
// Ignore permanent conditions
if ( m_ConditionData[i].m_flExpireTime != PERMANENT_CONDITION )
{
float flReduction = gpGlobals->frametime;
// If we're being healed, we reduce bad conditions faster
if ( ConditionExpiresFast( (ETFCond)i) && m_aHealers.Count() > 0 )
{
if ( i == TF_COND_URINE )
{
flReduction += (m_aHealers.Count() * flReduction);
}
else
{
flReduction += (m_aHealers.Count() * flReduction * 4);
}
}
m_ConditionData[i].m_flExpireTime = MAX( m_ConditionData[i].m_flExpireTime - flReduction, 0 );
if ( m_ConditionData[i].m_flExpireTime == 0 )
{
RemoveCond( (ETFCond)i );
}
}
else
{
#if !defined( DEBUG )
// Prevent hacked usercommand exploits
if ( m_pOuter->GetTimeSinceLastUserCommand() > 5.f || m_pOuter->GetTimeSinceLastThink() > 5.f )
{
ETFCond eCond = (ETFCond)i;
if ( GetCarryingRuneType() != RUNE_NONE )
{
m_pOuter->DropRune();
}
if ( ShouldRemoveConditionOnTimeout( eCond ) )
{
RemoveCond( eCond );
// Reset active weapon to prevent stale-state bugs
CTFWeaponBase *pTFWeapon = m_pOuter->GetActiveTFWeapon();
if ( pTFWeapon )
{
pTFWeapon->WeaponReset();
}
m_pOuter->TeamFortress_SetSpeed();
}
}
#endif
}
}
}
// Our health will only decay ( from being medic buffed ) if we are not being healed by a medic
// Dispensers can give us the TF_COND_HEALTH_BUFF, but will not maintain or give us health above 100%s
bool bDecayHealth = true;
bool bDecayDisguiseHealth = true;
// If we're being healed, heal ourselves
if ( InCond( TF_COND_HEALTH_BUFF ) )
{
// Heal faster if we haven't been in combat for a while
float flTimeSinceDamage = gpGlobals->curtime - m_pOuter->GetLastDamageReceivedTime();
float flScale = RemapValClamped( flTimeSinceDamage, 10, 15, 1.0, 3.0 );
float flAttribModScale = 1.0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flAttribModScale, mult_health_fromhealers );
float flCurOverheal = (float)m_pOuter->GetHealth() / (float)m_pOuter->GetMaxHealth();
if ( flCurOverheal > 1.0f )
{
// If they're over their max health the overheal calculation is relative to the max buffable amount scale
float flMaxHealthForBuffing = m_pOuter->GetMaxHealthForBuffing();
float flBuffableRangeHealth = m_pOuter->GetHealth() - ( m_pOuter->GetMaxHealth() - flMaxHealthForBuffing );
flCurOverheal = flBuffableRangeHealth / flMaxHealthForBuffing;
}
float flCurDisguiseOverheal = ( GetDisguiseMaxHealth() != 0 ) ? ( (float)GetDisguiseHealth() / (float)GetDisguiseMaxHealth() ) : ( flCurOverheal );
float fTotalHealAmount = 0.0f;
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
Assert( m_aHealers[i].pHealer );
float flPerHealerAttribModScale = 1.f;
// Check if the healer has an attribute that modifies their overheal rate
if( flCurOverheal > 1.f && !m_aHealers[i].bDispenserHeal )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_aHealers[i].pHealer, flPerHealerAttribModScale, overheal_fill_rate );
}
bool bHealDisguise = InCond( TF_COND_DISGUISED );
bool bHealActual = true;
// dispensers heal cloak
if ( m_aHealers[i].bDispenserHeal )
{
AddToSpyCloakMeter( gpGlobals->frametime * m_aHealers[i].flAmount );
}
// Don't heal over the healer's overheal bonus
if ( flCurOverheal >= m_aHealers[i].flOverhealBonus )
{
bHealActual = false;
}
// Same overheal check, but for fake health
if ( InCond( TF_COND_DISGUISED ) && flCurDisguiseOverheal >= m_aHealers[i].flOverhealBonus )
{
// Fake over-heal
bHealDisguise = false;
}
CTFPlayer *pTFHealer = ToTFPlayer( m_aHealers[i].pHealer );
if ( !bHealActual && !bHealDisguise )
{
if ( pTFHealer )
{
// Quick fix never lets health decay, even when they're at or above max overheal
CWeaponMedigun *pMedigun = dynamic_cast< CWeaponMedigun* >( pTFHealer->GetActiveTFWeapon() );
if ( pMedigun && pMedigun->GetMedigunType() == MEDIGUN_QUICKFIX )
{
bDecayHealth = false;
bDecayDisguiseHealth = false;
}
}
continue;
}
// Being healed by a medigun, don't decay our health
if ( bHealActual )
{
bDecayHealth = false;
}
if ( bHealDisguise )
{
bDecayDisguiseHealth = false;
}
// What we multiply the heal amount by (can be changed by conditions or items).
float flHealAmountMult = 1.0f;
// Quick-Fix uber
if ( InCond( TF_COND_MEGAHEAL ) )
{
flHealAmountMult = 3.0f;
}
flScale *= flHealAmountMult;
// Dispensers heal at a constant rate
if ( m_aHealers[i].bDispenserHeal )
{
// Dispensers heal at a slower rate, but ignore flScale
if ( bHealActual )
{
float flDispenserFraction = gpGlobals->frametime * m_aHealers[i].flAmount * flAttribModScale;
m_flHealFraction += flDispenserFraction;
// track how much this healer has actually done so far
m_aHealers[i].flHealAccum += clamp( flDispenserFraction, 0.f, (float) GetMaxBuffedHealth() - m_pOuter->GetHealth() );
}
if ( bHealDisguise )
{
m_flDisguiseHealFraction += gpGlobals->frametime * m_aHealers[i].flAmount * flAttribModScale;
}
}
else // player heals are affected by the last damage time
{
if ( bHealActual )
{
// Scale this if needed
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flScale, mult_healing_from_medics );
m_flHealFraction += gpGlobals->frametime * m_aHealers[i].flAmount * flScale * flAttribModScale * flPerHealerAttribModScale;
}
if ( bHealDisguise )
{
m_flDisguiseHealFraction += gpGlobals->frametime * m_aHealers[i].flAmount * flScale * flAttribModScale * flPerHealerAttribModScale;
}
}
fTotalHealAmount += m_aHealers[i].flAmount;
// Keep our decay multiplier uptodate
if ( m_flBestOverhealDecayMult == -1 || m_aHealers[i].flOverhealDecayMult < m_flBestOverhealDecayMult )
{
m_flBestOverhealDecayMult = m_aHealers[i].flOverhealDecayMult;
}
}
if ( InCond( TF_COND_HEALING_DEBUFF ) )
{
m_flHealFraction *= 0.75f;
}
int nHealthToAdd = (int)m_flHealFraction;
int nDisguiseHealthToAdd = (int)m_flDisguiseHealFraction;
if ( nHealthToAdd > 0 || nDisguiseHealthToAdd > 0 )
{
if ( nHealthToAdd > 0 )
{
m_flHealFraction -= nHealthToAdd;
}
if ( nDisguiseHealthToAdd > 0 )
{
m_flDisguiseHealFraction -= nDisguiseHealthToAdd;
}
int iBoostMax = GetMaxBuffedHealth();
if ( InCond( TF_COND_DISGUISED ) )
{
// Separate cap for disguised health
int nFakeHealthToAdd = clamp( nDisguiseHealthToAdd, 0, GetDisguiseMaxBuffedHealth() - m_iDisguiseHealth );
m_iDisguiseHealth += nFakeHealthToAdd;
}
// Track health prior to healing
int nPrevHealth = m_pOuter->GetHealth();
// Cap it to the max we'll boost a player's health
nHealthToAdd = clamp( nHealthToAdd, 0, iBoostMax - m_pOuter->GetHealth() );
m_pOuter->TakeHealth( nHealthToAdd, DMG_IGNORE_MAXHEALTH | DMG_IGNORE_DEBUFFS );
m_pOuter->AdjustDrownDmg( -1.0 * nHealthToAdd ); // subtract this from the drowndmg in case they're drowning and being healed at the same time
// split up total healing based on the amount each healer contributes
if ( fTotalHealAmount > 0 )
{
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
Assert( m_aHealers[i].pHealScorer );
Assert( m_aHealers[i].pHealer );
if ( m_aHealers[i].pHealScorer.IsValid() && m_aHealers[i].pHealer.IsValid() )
{
CBaseEntity *pHealer = m_aHealers[i].pHealer;
float flHealAmount = nHealthToAdd * ( m_aHealers[i].flAmount / fTotalHealAmount );
if ( pHealer && IsAlly( pHealer ) )
{
CTFPlayer *pHealScorer = ToTFPlayer( m_aHealers[i].pHealScorer );
if ( pHealScorer )
{
// Don't report healing when we're close to the buff cap and haven't taken damage recently.
// This avoids sending bogus heal stats while maintaining our max overheal. Ideally we
// wouldn't decay in this scenario, but that would be a risky change.
if ( iBoostMax - nPrevHealth > 1 || gpGlobals->curtime - m_pOuter->GetLastDamageReceivedTime() <= 1.f )
{
CTF_GameStats.Event_PlayerHealedOther( pHealScorer, flHealAmount );
}
// Add this to the one-second-healing counter
m_aHealers[i].flHealedLastSecond += flHealAmount;
HandleRageGain( m_pOuter, kRageBuffFlag_OnMedicHealingReceived, flHealAmount / 2.f, 1.0f );
float flRage = flHealAmount;
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() &&
TFObjectiveResource() && TFObjectiveResource()->GetMannVsMachineIsBetweenWaves() )
{
flRage = Max( flHealAmount, 10.f );
}
HandleRageGain( pHealScorer, kRageBuffFlag_OnHeal, flRage, 1.0f );
// If it's been one second, or we know healing beyond this point will be overheal, generate an event
if ( ( m_flHealedPerSecondTimer <= gpGlobals->curtime || m_pOuter->GetHealth() >= m_pOuter->GetMaxHealth() )
&& m_aHealers[i].flHealedLastSecond > 1 )
{
// Make sure this isn't pure overheal
if ( m_pOuter->GetHealth() - m_aHealers[i].flHealedLastSecond < m_pOuter->GetMaxHealth() )
{
float flOverHeal = m_pOuter->GetHealth() - m_pOuter->GetMaxHealth();
if ( flOverHeal > 0 )
{
m_aHealers[i].flHealedLastSecond -= flOverHeal;
}
// TEST THIS
// Give the medic some uber if it is from their (AoE heal) which has no overheal
if ( m_aHealers[i].flOverhealBonus <= 1.0f )
{
// Give a litte bit of uber based on actual healing
// Give them a little bit of Uber
CWeaponMedigun *pMedigun = static_cast<CWeaponMedigun *>( pHealScorer->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
if ( pMedigun )
{
// 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( ( m_aHealers[i].flHealedLastSecond / 24.0f ) * gpGlobals->frametime * 0.33f );
}
}
IGameEvent * event = gameeventmanager->CreateEvent( "player_healed" );
if ( event )
{
// HLTV event priority, not transmitted
event->SetInt( "priority", 1 );
// Healed by another player.
event->SetInt( "patient", m_pOuter->GetUserID() );
event->SetInt( "healer", pHealScorer->GetUserID() );
event->SetInt( "amount", m_aHealers[i].flHealedLastSecond );
gameeventmanager->FireEvent( event );
}
// Can we figure out which item is doing this healing?
if ( pHealScorer )
{
// Can be Mediguns or anything that gives off 'heal' buff like amputator aoe heal
EconEntity_OnOwnerKillEaterEvent_Batched( pHealScorer->GetActiveTFWeapon(), pHealScorer, m_pOuter, kKillEaterEvent_AllyHealingDone, m_aHealers[i].flHealedLastSecond );
}
}
m_aHealers[i].flHealedLastSecond = 0;
m_flHealedPerSecondTimer = gpGlobals->curtime + 1.0f;
}
}
}
else
{
CTF_GameStats.Event_PlayerLeachedHealth( m_pOuter, m_aHealers[i].bDispenserHeal, flHealAmount );
}
}
}
}
}
if ( InCond( TF_COND_BURNING ) )
{
// Reduce the duration of this burn
float flReduction = 2; // ( flReduction + 1 ) x faster reduction
m_flFlameRemoveTime -= flReduction * gpGlobals->frametime;
}
if ( InCond( TF_COND_BLEEDING ) )
{
// Reduce the duration of this bleeding
float flReduction = 2; // ( flReduction + 1 ) x faster reduction
FOR_EACH_VEC( m_PlayerBleeds, i )
{
m_PlayerBleeds[i].flBleedingRemoveTime -= flReduction * gpGlobals->frametime;
}
}
}
if ( !InCond( TF_COND_HEALTH_OVERHEALED ) && m_pOuter->GetHealth() > ( m_pOuter->GetMaxHealth() - m_pOuter->GetRuneHealthBonus() ) )
{
AddCond( TF_COND_HEALTH_OVERHEALED, PERMANENT_CONDITION );
}
else if ( InCond( TF_COND_HEALTH_OVERHEALED ) && m_pOuter->GetHealth() <= ( m_pOuter->GetMaxHealth() - m_pOuter->GetRuneHealthBonus() ) )
{
RemoveCond( TF_COND_HEALTH_OVERHEALED );
}
if ( bDecayHealth )
{
float flOverheal = GetMaxBuffedHealth( false, true );
// If we're not being buffed, our health drains back to our max
if ( m_pOuter->GetHealth() > m_pOuter->GetMaxHealth() )
{
// Items exist that get us over max health, without ever being healed, in which case our m_flBestOverhealDecayMult will still be -1.
float flDrainMult = (m_flBestOverhealDecayMult == -1) ? 1.0 : m_flBestOverhealDecayMult;
float flBoostMaxAmount = flOverheal - m_pOuter->GetMaxHealth();
float flDrain = flBoostMaxAmount / (tf_boost_drain_time.GetFloat() * flDrainMult);
m_flHealFraction += (gpGlobals->frametime * flDrain);
int nHealthToDrain = (int)m_flHealFraction;
if ( nHealthToDrain > 0 )
{
m_flHealFraction -= nHealthToDrain;
// Manually subtract the health so we don't generate pain sounds / etc
m_pOuter->m_iHealth -= nHealthToDrain;
}
}
else if ( m_flBestOverhealDecayMult != -1 )
{
m_flBestOverhealDecayMult = -1;
}
}
if ( bDecayDisguiseHealth )
{
float flOverheal = GetDisguiseMaxBuffedHealth( false, true );
if ( InCond( TF_COND_DISGUISED ) && (GetDisguiseHealth() > GetDisguiseMaxHealth()) )
{
// Items exist that get us over max health, without ever being healed, in which case our m_flBestOverhealDecayMult will still be -1.
float flDrainMult = (m_flBestOverhealDecayMult == -1) ? 1.0 : m_flBestOverhealDecayMult;
float flBoostMaxAmount = flOverheal - GetDisguiseMaxHealth();
float flDrain = (flBoostMaxAmount / tf_boost_drain_time.GetFloat()) * flDrainMult;
m_flDisguiseHealFraction += (gpGlobals->frametime * flDrain);
int nHealthToDrain = (int)m_flDisguiseHealFraction;
if ( nHealthToDrain > 0 )
{
m_flDisguiseHealFraction -= nHealthToDrain;
// Reduce our fake disguised health by roughly the same amount
m_iDisguiseHealth -= nHealthToDrain;
}
}
}
// Taunt
if ( InCond( TF_COND_TAUNTING ) )
{
if ( m_pOuter->IsAllowedToRemoveTaunt() && gpGlobals->curtime > m_pOuter->GetTauntRemoveTime() )
{
RemoveCond( TF_COND_TAUNTING );
}
}
if ( InCond( TF_COND_BURNING ) && !m_pOuter->m_bInPowerPlay )
{
if ( TFGameRules() && TFGameRules()->IsTruceActive() && m_hBurnAttacker && m_hBurnAttacker->IsTruceValidForEnt() )
{
RemoveCond( TF_COND_BURNING );
}
else if ( gpGlobals->curtime > m_flFlameRemoveTime || m_pOuter->GetWaterLevel() >= WL_Waist )
{
// If we're underwater, put the fire out
if ( m_pOuter->GetWaterLevel() >= WL_Waist )
{
// General achievement for jumping into water while you're on fire
m_pOuter->AwardAchievement( ACHIEVEMENT_TF_FIRE_WATERJUMP );
// Pyro achievement for forcing players into water
if ( m_hBurnAttacker )
{
m_hBurnAttacker->AwardAchievement( ACHIEVEMENT_TF_PYRO_FORCE_WATERJUMP );
}
}
RemoveCond( TF_COND_BURNING );
if ( InCond( TF_COND_HEALTH_BUFF ) )
{
// one or more players is healing us, send a "player_extinguished" event. We
// need to send one for each player who's healing us.
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
Assert( m_aHealers[i].pHealer );
if ( m_aHealers[i].bDispenserHeal )
{
CObjectDispenser *pDispenser = dynamic_cast<CObjectDispenser*>( m_aHealers[i].pHealer.Get() );
if ( pDispenser )
{
CTFPlayer *pTFPlayer = pDispenser->GetBuilder();
if ( pTFPlayer )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" triggered \"player_extinguished\" against \"%s<%i><%s><%s>\" with \"dispenser\" (attacker_position \"%d %d %d\") (victim_position \"%d %d %d\")\n",
pTFPlayer->GetPlayerName(),
pTFPlayer->GetUserID(),
pTFPlayer->GetNetworkIDString(),
pTFPlayer->GetTeam()->GetName(),
m_pOuter->GetPlayerName(),
m_pOuter->GetUserID(),
m_pOuter->GetNetworkIDString(),
m_pOuter->GetTeam()->GetName(),
(int)m_aHealers[i].pHealer->GetAbsOrigin().x,
(int)m_aHealers[i].pHealer->GetAbsOrigin().y,
(int)m_aHealers[i].pHealer->GetAbsOrigin().z,
(int)m_pOuter->GetAbsOrigin().x,
(int)m_pOuter->GetAbsOrigin().y,
(int)m_pOuter->GetAbsOrigin().z );
}
}
// continue;
}
EHANDLE pHealer = m_aHealers[i].pHealer;
if ( m_aHealers[i].bDispenserHeal || !pHealer || !pHealer->IsPlayer() )
pHealer = m_aHealers[i].pHealScorer;
if ( !pHealer )
continue;
CTFPlayer *pTFPlayer = ToTFPlayer( pHealer );
if ( pTFPlayer && !m_aHealers[i].bDispenserHeal )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" triggered \"player_extinguished\" against \"%s<%i><%s><%s>\" with \"%s\" (attacker_position \"%d %d %d\") (victim_position \"%d %d %d\")\n",
pTFPlayer->GetPlayerName(),
pTFPlayer->GetUserID(),
pTFPlayer->GetNetworkIDString(),
pTFPlayer->GetTeam()->GetName(),
m_pOuter->GetPlayerName(),
m_pOuter->GetUserID(),
m_pOuter->GetNetworkIDString(),
m_pOuter->GetTeam()->GetName(),
( pTFPlayer->GetActiveTFWeapon() ) ? pTFPlayer->GetActiveTFWeapon()->GetName() : "tf_weapon_medigun",
(int)pTFPlayer->GetAbsOrigin().x,
(int)pTFPlayer->GetAbsOrigin().y,
(int)pTFPlayer->GetAbsOrigin().z,
(int)m_pOuter->GetAbsOrigin().x,
(int)m_pOuter->GetAbsOrigin().y,
(int)m_pOuter->GetAbsOrigin().z );
}
// Tell the clients involved
CRecipientFilter involved_filter;
CBasePlayer *pBasePlayerHealer = ToBasePlayer( pHealer );
if ( pBasePlayerHealer )
{
involved_filter.AddRecipient( pBasePlayerHealer );
}
involved_filter.AddRecipient( m_pOuter );
UserMessageBegin( involved_filter, "PlayerExtinguished" );
WRITE_BYTE( pHealer->entindex() );
WRITE_BYTE( m_pOuter->entindex() );
MessageEnd();
IGameEvent *event = gameeventmanager->CreateEvent( "player_extinguished" );
if ( event )
{
event->SetInt( "victim", m_pOuter->entindex() );
event->SetInt( "healer", pHealer->entindex() );
gameeventmanager->FireEvent( event, true );
}
}
}
}
else if ( ( gpGlobals->curtime >= m_flFlameBurnTime ) && ( TF_CLASS_PYRO != m_pOuter->GetPlayerClass()->GetClassIndex() ) )
{
// Burn the player (if not pyro, who does not take persistent burning damage)
float flBurnDamage = TF_BURNING_DMG;
int nKillType = TF_DMG_CUSTOM_BURNING;
if ( m_hBurnWeapon )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_hBurnWeapon, flBurnDamage, mult_wpn_burndmg );
if ( m_hBurnWeapon.Get()->GetWeaponID() == TF_WEAPON_FLAREGUN )
{
nKillType = TF_DMG_CUSTOM_BURNING_FLARE;
}
else if ( m_hBurnWeapon.Get()->GetWeaponID() == TF_WEAPON_COMPOUND_BOW )
{
nKillType = TF_DMG_CUSTOM_BURNING_ARROW;
}
}
// Halloween Spell
if ( TF_IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
{
int iHalloweenSpell = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( m_hBurnWeapon, iHalloweenSpell, halloween_green_flames );
if ( iHalloweenSpell > 0 )
{
const char *pEffectName = "halloween_burningplayer_flyingbits";
// Extra Halloween Particles
DispatchParticleEffect( pEffectName, PATTACH_ABSORIGIN_FOLLOW, m_pOuter, 0, false );
}
}
CTakeDamageInfo info( m_hBurnAttacker, m_hBurnAttacker, m_hBurnWeapon, flBurnDamage, DMG_BURN | DMG_PREVENT_PHYSICS_FORCE, nKillType );
m_pOuter->TakeDamage( info );
// Give health to attacker if they are carrying the Vampire Powerup.
if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
{
CTFPlayer *pTFAttacker = ToTFPlayer( GetConditionProvider( TF_COND_BURNING ) );
if ( pTFAttacker && pTFAttacker != m_pOuter )
{
if ( pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE )
{
pTFAttacker->TakeHealth( flBurnDamage, DMG_GENERIC );
}
}
}
m_flFlameBurnTime = gpGlobals->curtime + TF_BURNING_FREQUENCY;
}
if ( m_flNextBurningSound < gpGlobals->curtime )
{
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_ONFIRE );
m_flNextBurningSound = gpGlobals->curtime + 2.5;
}
}
// Stops the drain hack.
if ( m_pOuter->IsPlayerClass( TF_CLASS_MEDIC ) )
{
CWeaponMedigun *pWeapon = ( CWeaponMedigun* )m_pOuter->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN );
if ( pWeapon && pWeapon->IsReleasingCharge() )
{
pWeapon->DrainCharge();
}
}
TestAndExpireChargeEffect( MEDIGUN_CHARGE_INVULN );
TestAndExpireChargeEffect( MEDIGUN_CHARGE_CRITICALBOOST );
TestAndExpireChargeEffect( MEDIGUN_CHARGE_MEGAHEAL );
//TestAndExpireChargeEffect( MEDIGUN_CHARGE_BULLET_RESIST );
//TestAndExpireChargeEffect( MEDIGUN_CHARGE_BLAST_RESIST );
//TestAndExpireChargeEffect( MEDIGUN_CHARGE_FIRE_RESIST );
if ( InCond( TF_COND_STEALTHED_BLINK ) )
{
float flBlinkTime = TF_SPY_STEALTH_BLINKTIME;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flBlinkTime, cloak_blink_time_penalty );
if ( flBlinkTime < ( gpGlobals->curtime - m_flLastStealthExposeTime ) )
{
RemoveCond( TF_COND_STEALTHED_BLINK );
}
}
if ( InCond( TF_COND_FEIGN_DEATH ) )
{
if ( m_flFeignDeathEnd < gpGlobals->curtime )
{
RemoveCond( TF_COND_FEIGN_DEATH );
}
}
if ( m_pOuter->GetWaterLevel() >= WL_Waist )
{
if ( InCond( TF_COND_URINE ) )
{
// If we're underwater, wash off the urine.
RemoveCond( TF_COND_URINE );
}
if ( InCond( TF_COND_MAD_MILK ) )
{
// If we're underwater, wash off the Mad Milk.
RemoveCond( TF_COND_MAD_MILK );
}
}
if ( !InCond( TF_COND_DISGUISED ) )
{
// Remove our disguise weapon if we are ever not disguised and we have one.
RemoveDisguiseWeapon();
// also clear the disguise weapon list
m_pOuter->ClearDisguiseWeaponList();
}
if ( InCond( TF_COND_BLEEDING ) )
{
FOR_EACH_VEC_BACK( m_PlayerBleeds, i )
{
bleed_struct_t& bleed = m_PlayerBleeds[i];
if ( TFGameRules() && TFGameRules()->IsTruceActive() && bleed.hBleedingAttacker && ( bleed.hBleedingAttacker != m_pOuter ) && bleed.hBleedingAttacker->IsTruceValidForEnt() )
{
m_PlayerBleeds.FastRemove( i );
}
else if ( gpGlobals->curtime >= bleed.flBleedingRemoveTime && !bleed.bPermanentBleeding )
{
m_PlayerBleeds.FastRemove( i );
}
else if ( ( gpGlobals->curtime >= bleed.flBleedingTime ) )
{
bleed.flBleedingTime = gpGlobals->curtime + TF_BLEEDING_FREQUENCY;
CTakeDamageInfo info( bleed.hBleedingAttacker, bleed.hBleedingAttacker, bleed.hBleedingWeapon, bleed.nBleedDmg, DMG_SLASH, TF_DMG_CUSTOM_BLEEDING );
m_pOuter->TakeDamage( info );
// It's very possible we died from the take damage, which clears all our conditions
// and nukes m_PlayerBleeds. If that happens, bust out of this loop.
if( m_PlayerBleeds.Count() == 0 )
break;
}
}
if ( !m_PlayerBleeds.Count() )
{
RemoveCond( TF_COND_BLEEDING );
}
}
#ifdef STAGING_ONLY
if ( InCond( TF_COND_TRANQ_SPY_BOOST ) )
{
m_flSpyTranqBuffDuration = GetConditionDuration( TF_COND_TRANQ_SPY_BOOST );
}
else
#endif // STAGING_ONLY
{
m_flSpyTranqBuffDuration = 0;
}
if ( TFGameRules()->IsMannVsMachineMode() || TFGameRules()->IsPlayingRobotDestructionMode() )
{
RadiusCurrencyCollectionCheck();
}
if ( TFGameRules()->IsMannVsMachineMode() && m_pOuter->IsPlayerClass( TF_CLASS_SPY) )
{
// In MvM, Spies reveal other spies in a radius around them
RadiusSpyScan();
}
if ( GetCarryingRuneType() == RUNE_PLAGUE )
{
RadiusHealthkitCollectionCheck();
}
#endif // GAME_DLL
}
//-----------------------------------------------------------------------------
// Purpose: Do CLIENT/SERVER SHARED condition thinks.
//-----------------------------------------------------------------------------
void CTFPlayerShared::ConditionThink( void )
{
// Client Only Updates Meters for Local Only
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
#endif
{
UpdateCloakMeter();
UpdateRageBuffsAndRage();
UpdateEnergyDrinkMeter();
UpdateChargeMeter();
DemoShieldChargeThink();
#ifdef STAGING_ONLY
UpdateRocketPack();
#endif // STAGING_ONLY
}
VehicleThink();
if ( m_pOuter->GetFlags() & FL_ONGROUND && InCond( TF_COND_PARACHUTE_DEPLOYED ))
{
RemoveCond( TF_COND_PARACHUTE_DEPLOYED );
}
// See if we should be pulsing our radius heal
PulseMedicRadiusHeal();
PulseKingRuneBuff();
m_ConditionList.Think();
if ( InCond( TF_COND_STUNNED ) )
{
#ifdef GAME_DLL
if ( IsControlStunned() )
{
m_pOuter->SetAbsAngles( m_pOuter->m_angTauntCamera );
m_pOuter->SetLocalAngles( m_pOuter->m_angTauntCamera );
}
#endif
if ( GetActiveStunInfo() && gpGlobals->curtime > GetActiveStunInfo()->flExpireTime )
{
#ifdef GAME_DLL
m_PlayerStuns.Remove( m_iStunIndex );
m_iStunIndex = -1;
// Apply our next stun
if ( m_PlayerStuns.Count() )
{
int iStrongestIdx = 0;
for ( int i = 1; i < m_PlayerStuns.Count(); i++ )
{
if ( m_PlayerStuns[i].flStunAmount > m_PlayerStuns[iStrongestIdx].flStunAmount )
{
iStrongestIdx = i;
}
}
m_iStunIndex = iStrongestIdx;
AddCond( TF_COND_STUNNED, -1.f, m_PlayerStuns[m_iStunIndex].hPlayer );
m_iMovementStunParity = ( m_iMovementStunParity + 1 ) & ( ( 1 << MOVEMENTSTUN_PARITY_BITS ) - 1 );
Assert( GetActiveStunInfo() );
}
else
{
RemoveCond( TF_COND_STUNNED );
}
#endif // GAME_DLL
UpdateLegacyStunSystem();
}
else if ( IsControlStunned() && GetActiveStunInfo() && ( gpGlobals->curtime > GetActiveStunInfo()->flStartFadeTime ) )
{
// Control stuns have a final anim to play.
ControlStunFading();
}
#ifdef CLIENT_DLL
// turn off stun effect that gets turned on when incomplete stun msg is received on the client
if ( GetActiveStunInfo() && GetActiveStunInfo()->iStunFlags & TF_STUN_NO_EFFECTS )
{
if ( m_pOuter->m_pStunnedEffect )
{
// Remove stun stars if they are still around.
// They might be if we died, etc.
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pStunnedEffect );
m_pOuter->m_pStunnedEffect = NULL;
}
}
#endif
}
if ( InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) )
{
#ifdef GAME_DLL
static struct
{
float flTimeLeft;
int nStage;
} s_vecBombStages[] = { { 8.0f, 0 }, { 3.0f, 1 }, { 0.0f, 2 } };
for ( int i = 0; i < ARRAYSIZE( s_vecBombStages ); ++i )
{
if ( m_ConditionData[TF_COND_HALLOWEEN_BOMB_HEAD].m_flExpireTime >= s_vecBombStages[i].flTimeLeft )
{
m_nHalloweenBombHeadStage = s_vecBombStages[i].nStage;
break;
}
}
if ( TFGameRules() && TFGameRules()->GetActiveBoss() && ( TFGameRules()->GetActiveBoss()->GetBossType() == HALLOWEEN_BOSS_MERASMUS ) )
{
if ( m_pOuter->IsAlive() )
{
Vector vToBoss = m_pOuter->EyePosition() - TFGameRules()->GetActiveBoss()->WorldSpaceCenter();
if ( vToBoss.IsLengthLessThan( 100.f ) )
{
CMerasmus* pMerasmus = assert_cast< CMerasmus* >( TFGameRules()->GetActiveBoss() );
if ( pMerasmus )
{
pMerasmus->AddStun( m_pOuter );
}
}
}
}
#else
m_pOuter->HalloweenBombHeadUpdate();
#endif
}
else
{
#ifdef GAME_DLL
m_nHalloweenBombHeadStage = 0;
#endif
}
#ifdef GAME_DLL
if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_VIADUCT ) && InCond( TF_COND_PURGATORY ) )
{
// escalating injury multiplier while in purgatory
if ( m_pOuter->m_purgatoryPainMultiplierTimer.IsElapsed() )
{
++m_pOuter->m_purgatoryPainMultiplier;
// injury multiplies rapidly after initial period
m_pOuter->m_purgatoryPainMultiplierTimer.Start( 10.0f );
}
}
#endif
CheckDisguiseTimer();
#ifdef CLIENT_DLL
if ( InCond( TF_COND_TAUNTING ) && m_flTauntParticleRefireTime > 0.0f && gpGlobals->curtime >= m_flTauntParticleRefireTime )
{
FireClientTauntParticleEffects();
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::CheckDisguiseTimer( void )
{
if ( InCond( TF_COND_DISGUISING ) && GetDisguiseCompleteTime() > 0 )
{
if ( gpGlobals->curtime > GetDisguiseCompleteTime() )
{
CompleteDisguise();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddZoomed( void )
{
#ifdef CLIENT_DLL
// hide cosmetic while zoom in thirdperson
if ( m_pOuter == C_TFPlayer::GetLocalTFPlayer() && ::input->CAM_IsThirdPerson() )
{
m_pOuter->UpdateWearables();
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveZoomed( void )
{
#ifdef GAME_DLL
m_pOuter->SetFOV( m_pOuter, 0, 0.1f );
#endif // GAME_DLL
#ifdef CLIENT_DLL
// unhide cosmetic after zoom in thirdperson
if ( m_pOuter == C_TFPlayer::GetLocalTFPlayer() && ::input->CAM_IsThirdPerson() )
{
m_pOuter->UpdateWearables();
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddDisguising( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->GetPredictable() && ( !prediction->IsFirstTimePredicted() || m_bSyncingConditions ) )
return;
if ( m_pOuter->m_pDisguisingEffect )
{
// m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pDisguisingEffect );
}
if ( !m_pOuter->IsLocalPlayer() && ( !IsStealthed() || !m_pOuter->IsEnemyPlayer() ) )
{
const char *pEffectName = ( m_pOuter->GetTeamNumber() == TF_TEAM_RED ) ? "spy_start_disguise_red" : "spy_start_disguise_blue";
m_pOuter->m_pDisguisingEffect = m_pOuter->ParticleProp()->Create( pEffectName, PATTACH_ABSORIGIN_FOLLOW );
m_pOuter->m_flDisguiseEffectStartTime = gpGlobals->curtime;
}
m_pOuter->EmitSound( "Player.Spy_Disguise" );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: set up effects for when player finished disguising
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddDisguised( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pDisguisingEffect )
{
// turn off disguising particles
// m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pDisguisingEffect );
m_pOuter->m_pDisguisingEffect = NULL;
}
m_pOuter->m_flDisguiseEndEffectStartTime = gpGlobals->curtime;
UpdateCritBoostEffect( kCritBoost_ForceRefresh );
m_pOuter->UpdateSpyStateChange();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddDemoCharge( void )
{
#ifdef CLIENT_DLL
m_pOuter->StopSound( "DemoCharge.ChargeCritOn" );
m_pOuter->EmitSound( "DemoCharge.ChargeCritOn" );
UpdateCritBoostEffect();
#endif // CLIENT_DLL
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Return the team that the spy is displayed as.
// Not disguised: His own team
// Disguised: The team he is disguised as
//-----------------------------------------------------------------------------
int CTFPlayerShared::GetDisplayedTeam( void ) const
{
int iVisibleTeam = m_pOuter->GetTeamNumber();
// if this player is disguised and on the other team, use disguise team
if ( InCond( TF_COND_DISGUISED ) && m_pOuter->IsEnemyPlayer() )
{
iVisibleTeam = GetDisguiseTeam();
}
return iVisibleTeam;
}
//-----------------------------------------------------------------------------
// Purpose: start, end, and changing disguise classes
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnDisguiseChanged( void )
{
// recalc disguise model index
//RecalcDisguiseWeapon( true );
m_pOuter->UpdateSpyStateChange();
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddInvulnerable( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
const char *pEffectName = NULL;
switch( m_pOuter->GetTeamNumber() )
{
case TF_TEAM_BLUE:
default:
pEffectName = TF_SCREEN_OVERLAY_MATERIAL_INVULN_BLUE;
break;
case TF_TEAM_RED:
pEffectName = TF_SCREEN_OVERLAY_MATERIAL_INVULN_RED;
break;
}
IMaterial *pMaterial = materials->FindMaterial( pEffectName, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
if ( m_pOuter->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
g_AchievementMgrTF.OnAchievementEvent( ACHIEVEMENT_TF_HEAVY_RECEIVE_UBER_GRIND );
}
}
#else
// remove any persistent damaging conditions
if ( InCond( TF_COND_BURNING ) )
{
RemoveCond( TF_COND_BURNING );
}
if ( InCond( TF_COND_URINE ) )
{
RemoveCond( TF_COND_URINE );
}
if ( InCond( TF_COND_BLEEDING ) )
{
RemoveCond( TF_COND_BLEEDING );
}
if ( InCond( TF_COND_MAD_MILK ) )
{
RemoveCond( TF_COND_MAD_MILK );
}
if ( InCond( TF_COND_PLAGUE ) )
{
RemoveCond( TF_COND_PLAGUE );
}
#ifdef STAGING_ONLY
if ( InCond( TF_COND_TRANQ_MARKED ) )
{
RemoveCond( TF_COND_TRANQ_MARKED );
}
#endif // STAGING_ONLY
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveInvulnerable( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
// only remove the overlay if it is an invuln material
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial &&
( FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_INVULN_BLUE ) ||
FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_INVULN_RED ) ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveInvulnerableWearingOff( void )
{
#ifdef CLIENT_DLL
m_flInvulnerabilityRemoveTime = gpGlobals->curtime;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddPhase( void )
{
UpdatePhaseEffects();
#ifdef CLIENT_DLL
#else
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_DODGING, "started_dodging:1" );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemovePhase( void )
{
RemovePhaseEffects();
#ifdef CLIENT_DLL
#else
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_DODGING, "started_dodging:0" );
// Tell this player how much damage they dodged.
CSingleUserRecipientFilter user( m_pOuter );
UserMessageBegin( user, "DamageDodged" );
WRITE_SHORT( clamp( m_iPhaseDamage, 0, 10000 ) );
MessageEnd();
m_iPhaseDamage = 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddUrine( void )
{
#ifdef CLIENT_DLL
if ( tf_colorblindassist.GetBool() )
{
m_pOuter->AddOverheadEffect( "peejar_icon" );
}
if ( !m_pOuter->m_pUrineEffect )
{
m_pOuter->m_pUrineEffect = m_pOuter->ParticleProp()->Create( "peejar_drips", PATTACH_ABSORIGIN_FOLLOW ); // pEffect! Kek!
}
if ( m_pOuter->m_pUrineEffect )
{
m_pOuter->ParticleProp()->AddControlPoint( m_pOuter->m_pUrineEffect, 1, m_pOuter, PATTACH_ABSORIGIN_FOLLOW );
}
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_URINE, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
#else
// m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_DODGING, "urine_on" );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveUrine( void )
{
#ifdef CLIENT_DLL
m_pOuter->RemoveOverheadEffect( "peejar_icon", true );
if ( m_pOuter->m_pUrineEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pUrineEffect );
m_pOuter->m_pUrineEffect = NULL;
}
if ( m_pOuter->IsLocalPlayer() )
{
// only remove the overlay if it is urine
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_URINE ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
#else
// m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_DODGING, "urine_off" );
if ( m_hPeeAttacker )
{
// Tell the clients involved in the jarate
CRecipientFilter involved_filter;
involved_filter.AddRecipient( m_pOuter );
involved_filter.AddRecipient( m_hPeeAttacker );
UserMessageBegin( involved_filter, "PlayerJaratedFade" );
WRITE_BYTE( m_hPeeAttacker->entindex() );
WRITE_BYTE( m_pOuter->entindex() );
MessageEnd();
}
m_hPeeAttacker = NULL;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddMarkedForDeath( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdatedMarkedForDeathEffect();
if ( m_pOuter->IsLocalPlayer() )
{
m_pOuter->EmitSound( "Weapon_Marked_for_Death.Indicator" );
}
else if ( !InCond( TF_COND_DISGUISED ) && !IsStealthed() )
{
m_pOuter->EmitSound( "Weapon_Marked_for_Death.Initial" );
}
/*
// Do we want to have a screen overlay effect?
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_URINE, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
*/
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveMarkedForDeath( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdatedMarkedForDeathEffect();
/*
if ( m_pOuter->IsLocalPlayer() )
{
// only remove the overlay if it is urine
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_URINE ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
*/
#endif
}
#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddTranqMark( void )
{
#ifdef CLIENT_DLL
//if ( !InCond( TF_COND_DISGUISED ) && !IsStealthed() )
//{
m_pOuter->UpdateTranqMark( true );
//}
//if ( m_pOuter->IsLocalPlayer() )
//{
// m_pOuter->EmitSound( "Weapon_Marked_for_Death.Indicator" );
//}
//else if ( !InCond( TF_COND_DISGUISED ) && !IsStealthed() )
//{
// m_pOuter->EmitSound( "Weapon_Marked_for_Death.Initial" );
//}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveTranqMark( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateTranqMark( false );
#endif
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddCondSpyClassSteal( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateSpyClassStealParticle( true );
#endif
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveCondSpyClassSteal( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateSpyClassStealParticle( false );
#endif
}
#endif // STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose: PARACHUTE
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddCondParachute( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->GetPredictable() && ( prediction->IsFirstTimePredicted() && !m_bSyncingConditions ) )
{
m_pOuter->EmitSound( "Parachute_open" );
}
if ( InCond( TF_COND_HALLOWEEN_KART ) )
{
if ( !m_hKartParachuteEntity )
{
C_BaseAnimating* pBanner = new C_BaseAnimating;
//if ( pBanner )
// return;
pBanner->m_nSkin = 0;
pBanner->InitializeAsClientEntity( "models/workshop/weapons/c_models/c_paratooper_pack/c_paratrooper_parachute.mdl", RENDER_GROUP_OPAQUE_ENTITY );
pBanner->ForceClientSideAnimationOn();
int iSpine = m_pOuter->LookupBone( "bip_spine_3" );
Assert( iSpine != -1 );
if ( iSpine != -1 )
{
pBanner->AttachEntityToBone( m_pOuter, iSpine );
}
int sequence = pBanner->SelectWeightedSequence( ACT_PARACHUTE_DEPLOY_IDLE );
pBanner->ResetSequence( sequence );
m_hKartParachuteEntity.Set( pBanner );
}
}
else
{
IGameEvent *event = gameeventmanager->CreateEvent( "parachute_deploy" );
if ( event )
{
event->SetInt( "index", m_pOuter->entindex() );
gameeventmanager->FireEventClientSide( event );
}
}
#endif
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveCondParachute( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->GetPredictable() && ( prediction->IsFirstTimePredicted() && !m_bSyncingConditions ) )
{
m_pOuter->EmitSound( "Parachute_close" );
}
if ( m_hKartParachuteEntity )
{
m_hKartParachuteEntity->Release();
m_hKartParachuteEntity = NULL;
}
if ( !InCond( TF_COND_HALLOWEEN_KART ) )
{
IGameEvent *event = gameeventmanager->CreateEvent( "parachute_holster" );
if ( event )
{
event->SetInt( "index", m_pOuter->entindex() );
gameeventmanager->FireEventClientSide( event );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddMadMilk( void )
{
#ifdef GAME_DLL
Assert( InCond( TF_COND_MAD_MILK ) );
// Check for the attribute that extends duration on successive hits
if ( m_ConditionData[TF_COND_MAD_MILK].m_bPrevActive )
{
CBaseEntity *pProvider = GetConditionProvider( TF_COND_MAD_MILK );
if ( pProvider )
{
int iMadMilkSyringes = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pProvider, iMadMilkSyringes, mad_milk_syringes );
if ( iMadMilkSyringes )
{
float flDuration = GetConditionDuration( TF_COND_MAD_MILK ) + 0.5f;
SetConditionDuration( TF_COND_MAD_MILK, Min( flDuration , 4.f ) );
}
}
}
#else
if ( !m_pOuter->m_pMilkEffect )
{
m_pOuter->m_pMilkEffect = m_pOuter->ParticleProp()->Create( "peejar_drips_milk", PATTACH_ABSORIGIN_FOLLOW );
}
m_pOuter->ParticleProp()->AddControlPoint( m_pOuter->m_pMilkEffect, 1, m_pOuter, PATTACH_ABSORIGIN_FOLLOW );
// if ( m_pOuter->IsLocalPlayer() )
// {
// IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_MILK, TEXTURE_GROUP_CLIENT_EFFECTS, false );
// if ( !IsErrorMaterial( pMaterial ) )
// {
// view->SetScreenOverlayMaterial( pMaterial );
// }
// }
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveMadMilk( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pMilkEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pMilkEffect );
m_pOuter->m_pMilkEffect = NULL;
}
if ( m_pOuter->IsLocalPlayer() )
{
// IMaterial *pMaterial = view->GetScreenOverlayMaterial();
// if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_MILK ) )
// {
// view->SetScreenOverlayMaterial( NULL );
// }
}
#endif
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFPlayerShared::taunt_particle_state_t CTFPlayerShared::GetClientTauntParticleDesiredState() const
{
const itemid_t unTauntSourceItemID = GetTauntSourceItemID();
if ( unTauntSourceItemID != INVALID_ITEM_ID )
{
CSteamID steamIDForPlayer;
m_pOuter->GetSteamID( &steamIDForPlayer );
CPlayerInventory *pInventory = InventoryManager()->GetInventoryForAccount( steamIDForPlayer.GetAccountID() );
CEconItemView *pTauntItem = pInventory ? pInventory->GetInventoryItemByItemID( unTauntSourceItemID ) : NULL;
if ( pTauntItem )
{
// do community_sparkle effect if this is a community item?
const int iQualityParticleType = pTauntItem->GetQualityParticleType();
if ( iQualityParticleType > 0 )
{
const attachedparticlesystem_t *pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( iQualityParticleType );
if ( pParticleSystem )
{
return taunt_particle_state_t( pParticleSystem->pszSystemName, pParticleSystem->fRefireTime );
}
}
static CSchemaAttributeDefHandle pAttrDef_OnTauntAttachParticleIndex( "on taunt attach particle index" );
uint32 unUnusualEffectIndex = 0;
if ( pTauntItem->FindAttribute( pAttrDef_OnTauntAttachParticleIndex, &unUnusualEffectIndex ) && unUnusualEffectIndex > 0 )
{
const attachedparticlesystem_t *pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( unUnusualEffectIndex );
if ( pParticleSystem )
{
// TF Team Color Particles
if ( m_pOuter->GetTeamNumber() == TF_TEAM_BLUE && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_red" ) )
{
static char pBlue[256];
V_StrSubst( pParticleSystem->pszSystemName, "_teamcolor_red", "_teamcolor_blue", pBlue, 256 );
pParticleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pBlue );
}
else if ( m_pOuter->GetTeamNumber() == TF_TEAM_RED && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_blue" ) )
{
// Guard against accidentally giving out the blue team color (support tool)
static char pRed[256];
V_StrSubst( pParticleSystem->pszSystemName, "_teamcolor_blue", "_teamcolor_red", pRed, 256 );
pParticleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pRed );
}
return taunt_particle_state_t( pParticleSystem->pszSystemName, pParticleSystem->fRefireTime );
}
}
for ( int i=0; i<m_pOuter->GetNumWearables(); ++i )
{
C_EconWearable *pWearable = m_pOuter->GetWearable( i );
CEconItemView *pItem = pWearable && pWearable->GetAttributeContainer() && pWearable->GetAttributeContainer()->GetItem() ? pWearable->GetAttributeContainer()->GetItem() : NULL;
// check for Unusual Cap def index (1173)
if ( pItem && pItem->GetItemDefIndex() == 1173 && pItem->FindAttribute( pAttrDef_OnTauntAttachParticleIndex, &unUnusualEffectIndex ) && unUnusualEffectIndex > 0 )
{
const attachedparticlesystem_t *pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( unUnusualEffectIndex );
if ( pParticleSystem )
{
// TF Team Color Particles
if ( m_pOuter->GetTeamNumber() == TF_TEAM_BLUE && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_red" ) )
{
static char pBlue[256];
V_StrSubst( pParticleSystem->pszSystemName, "_teamcolor_red", "_teamcolor_blue", pBlue, 256 );
pParticleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pBlue );
}
else if ( m_pOuter->GetTeamNumber() == TF_TEAM_RED && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_blue" ) )
{
// Guard against accidentally giving out the blue team color (support tool)
static char pRed[256];
V_StrSubst( pParticleSystem->pszSystemName, "_teamcolor_blue", "_teamcolor_red", pRed, 256 );
pParticleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pRed );
}
return taunt_particle_state_t( pParticleSystem->pszSystemName, pParticleSystem->fRefireTime );
}
}
}
}
}
return taunt_particle_state_t( NULL, 0.0f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::FireClientTauntParticleEffects()
{
taunt_particle_state_t TauntParticleState = GetClientTauntParticleDesiredState();
if ( TauntParticleState.first )
{
if ( m_pOuter->m_pTauntEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pTauntEffect );
}
if ( !m_pOuter->GetTauntEconItemView() )
return;
if ( !m_pOuter->GetTauntEconItemView()->GetStaticData() )
return;
if ( !m_pOuter->GetTauntEconItemView()->GetStaticData()->GetTauntData() )
return;
const char *pszAttachment = m_pOuter->GetTauntEconItemView()->GetStaticData()->GetTauntData()->GetParticleAttachment();
int iAttachment = pszAttachment ? m_pOuter->LookupAttachment( pszAttachment ) : INVALID_PARTICLE_ATTACHMENT;
m_pOuter->m_pTauntEffect = m_pOuter->ParticleProp()->Create( TauntParticleState.first, iAttachment != INVALID_PARTICLE_ATTACHMENT ? PATTACH_POINT_FOLLOW : PATTACH_ABSORIGIN_FOLLOW, iAttachment, vec3_origin );
if ( TauntParticleState.second > 0.0f )
{
m_flTauntParticleRefireTime = gpGlobals->curtime + TauntParticleState.second;
}
}
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddTaunting( void )
{
CTFWeaponBase *pWpn = m_pOuter->GetActiveTFWeapon();
if ( pWpn )
{
// cancel any reload in progress.
pWpn->AbortReload();
// Check for taunt healing.
if ( GetTauntIndex() == TAUNT_BASE_WEAPON )
{
int iAOEHeal = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWpn, iAOEHeal, enables_aoe_heal );
if ( iAOEHeal == 1 )
{
Heal_Radius( true );
}
}
}
// Unzoom if we are a sniper zoomed!
InstantlySniperUnzoom();
if ( ( m_pOuter->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) || m_pOuter->IsPlayerClass( TF_CLASS_SCOUT ) ) && GetTauntIndex() == TAUNT_BASE_WEAPON )
{
CTFLunchBox *pLunchBox = dynamic_cast <CTFLunchBox *> ( pWpn );
if ( pLunchBox )
{
pLunchBox->DrainAmmo();
}
}
#ifdef GAME_DLL
m_pOuter->PlayWearableAnimsForPlaybackEvent( WAP_START_TAUNTING );
#else
FireClientTauntParticleEffects();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveTaunting( void )
{
#ifdef GAME_DLL
#ifdef STAGING_ONLY
if ( !m_pOuter->m_hTauntScene.Get() )
{
Warning( "Why do we not have taunt scene?\n" );
}
#endif
m_pOuter->StopTaunt();
if ( IsControlStunned() )
{
m_pOuter->SetAbsAngles( m_pOuter->m_angTauntCamera );
m_pOuter->SetLocalAngles( m_pOuter->m_angTauntCamera );
}
#endif // GAME_DLL
// Stop aoe healing if it's active.
Heal_Radius( false );
// We're done taunting, our weapons are not being repurposed anymore
for ( int i = 0; i < m_pOuter->WeaponCount(); i++)
{
CTFWeaponBase *pWpn = ( CTFWeaponBase *) m_pOuter->GetWeapon(i);
if ( !pWpn )
continue;
pWpn->SetIsBeingRepurposedForTaunt( false );
}
#ifdef GAME_DLL
// Switch to our melee weapon, if we are at the end of a type 2 lunchbox taunt.
if ( m_bBiteEffectWasApplied && InCond( TF_COND_CANNOT_SWITCH_FROM_MELEE ) )
{
CBaseCombatWeapon *pWpn = m_pOuter->Weapon_GetSlot( TF_WPN_TYPE_MELEE );
if ( pWpn )
{
m_pOuter->Weapon_Switch( pWpn );
}
else
{
// Safety net
RemoveCond( TF_COND_ENERGY_BUFF );
RemoveCond( TF_COND_CANNOT_SWITCH_FROM_MELEE );
}
}
m_bBiteEffectWasApplied = false;
if ( m_pOuter->m_hTauntItem != NULL )
{
// destroy the item we were showing off
UTIL_Remove( m_pOuter->m_hTauntItem );
m_pOuter->m_hTauntItem = NULL;
}
m_pOuter->ClearTauntAttack();
m_pOuter->PlayWearableAnimsForPlaybackEvent( WAP_STOP_TAUNTING );
m_pOuter->HandleWeaponSlotAfterTaunt();
#else
CSteamID steamIDForPlayer;
m_pOuter->GetSteamID( &steamIDForPlayer );
int nMapDonationAmount = MapInfo_GetDonationAmount( steamIDForPlayer.GetAccountID(), engine->GetLevelName() );
m_pOuter->SetFootStamps( nMapDonationAmount );
if ( m_pOuter->m_pTauntEffect )
{
m_pOuter->ParticleProp()->StopEmissionAndDestroyImmediately( m_pOuter->m_pTauntEffect );
m_pOuter->m_pTauntEffect = NULL;
}
m_flTauntParticleRefireTime = 0.0f;
#endif
m_pOuter->m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_VCD );
// when we stop taunting, make sure active weapon is visible
if ( m_pOuter->GetActiveWeapon() )
{
m_pOuter->GetActiveWeapon()->SetWeaponVisible( true );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddBleeding( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_BLEED, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
#else
// We should have at least one bleed entry
Assert( m_PlayerBleeds.Count() );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveBleeding( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_BLEED ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
#else
m_PlayerBleeds.RemoveAll();
#endif
}
const char* CTFPlayerShared::GetSoldierBuffEffectName( void )
{
if ( TFGameRules()->IsMannVsMachineMode() )
{
if ( m_pOuter->GetTeamNumber() == TF_TEAM_BLUE )
{
// MVM robot version has fewer particles. Helps keep the framerate up.
return "soldierbuff_mvm";
}
else
{
return "soldierbuff_red_soldier";
}
}
else
{
if ( m_pOuter->GetTeamNumber() == TF_TEAM_BLUE )
{
return "soldierbuff_blue_soldier";
}
else
{
return "soldierbuff_red_soldier";
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddSoldierOffensiveBuff( void )
{
#ifdef CLIENT_DLL
const char* strBuffName = GetSoldierBuffEffectName();
if ( !m_pOuter->m_pSoldierOffensiveBuffEffect )
{
m_pOuter->m_pSoldierOffensiveBuffEffect = m_pOuter->ParticleProp()->Create( strBuffName, PATTACH_ABSORIGIN_FOLLOW );
}
#endif
}
void CTFPlayerShared::OnRemoveSoldierOffensiveBuff( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pSoldierOffensiveBuffEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pSoldierOffensiveBuffEffect );
m_pOuter->m_pSoldierOffensiveBuffEffect = NULL;
}
#endif
}
void CTFPlayerShared::OnAddSoldierDefensiveBuff( void )
{
#ifdef CLIENT_DLL
const char* strBuffName = GetSoldierBuffEffectName();
if ( !m_pOuter->m_pSoldierDefensiveBuffEffect )
{
m_pOuter->m_pSoldierDefensiveBuffEffect = m_pOuter->ParticleProp()->Create( strBuffName, PATTACH_ABSORIGIN_FOLLOW );
}
#endif
}
void CTFPlayerShared::OnRemoveSoldierDefensiveBuff( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pSoldierDefensiveBuffEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pSoldierDefensiveBuffEffect );
m_pOuter->m_pSoldierDefensiveBuffEffect = NULL;
}
#endif
}
void CTFPlayerShared::OnAddSoldierOffensiveHealthRegenBuff( void )
{
#ifdef GAME_DLL
AddCond( TF_COND_SPEED_BOOST );
#else
const char* strBuffName = GetSoldierBuffEffectName();
if ( !m_pOuter->m_pSoldierOffensiveHealthRegenBuffEffect )
{
m_pOuter->m_pSoldierOffensiveHealthRegenBuffEffect = m_pOuter->ParticleProp()->Create( strBuffName, PATTACH_ABSORIGIN_FOLLOW );
}
#endif
}
void CTFPlayerShared::OnRemoveSoldierOffensiveHealthRegenBuff( void )
{
#ifdef GAME_DLL
RemoveCond( TF_COND_SPEED_BOOST );
#else
if ( m_pOuter->m_pSoldierOffensiveHealthRegenBuffEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pSoldierOffensiveHealthRegenBuffEffect );
m_pOuter->m_pSoldierOffensiveHealthRegenBuffEffect = NULL;
}
#endif
}
void CTFPlayerShared::OnAddSoldierNoHealingDamageBuff( void )
{
#ifdef CLIENT_DLL
const char* strBuffName = GetSoldierBuffEffectName();
if ( !m_pOuter->m_pSoldierNoHealingDamageBuffEffect )
{
m_pOuter->m_pSoldierNoHealingDamageBuffEffect = m_pOuter->ParticleProp()->Create( strBuffName, PATTACH_ABSORIGIN_FOLLOW );
}
#endif
}
void CTFPlayerShared::OnRemoveSoldierNoHealingDamageBuff( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pSoldierNoHealingDamageBuffEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pSoldierNoHealingDamageBuffEffect );
m_pOuter->m_pSoldierNoHealingDamageBuffEffect = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddOffenseBuff( void )
{
OnAddSoldierOffensiveBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveOffenseBuff( void )
{
OnRemoveSoldierOffensiveBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddDefenseBuff( void )
{
OnAddSoldierDefensiveBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveDefenseBuff( void )
{
OnRemoveSoldierDefensiveBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddOffenseHealthRegenBuff( void )
{
OnAddSoldierOffensiveHealthRegenBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveOffenseHealthRegenBuff( void )
{
OnRemoveSoldierOffensiveHealthRegenBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddNoHealingDamageBuff( void )
{
OnAddSoldierNoHealingDamageBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveNoHealingDamageBuff( void )
{
OnRemoveSoldierNoHealingDamageBuff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddSpeedBoost( bool IsNonCombat )
{
#ifdef CLIENT_DLL
const char* strBuffName = "speed_boost_trail";
if ( !m_pOuter->m_pSpeedBoostEffect )
{
// No speedlines at all for stealth or feign death
if ( !InCond( TF_COND_STEALTHED ) && !InCond(TF_COND_FEIGN_DEATH) )
{
m_pOuter->m_pSpeedBoostEffect = m_pOuter->ParticleProp()->Create( strBuffName, PATTACH_ABSORIGIN_FOLLOW );
}
}
// InCombat is played on the teleporter for all players to here
// "Building_Speedpad.BoostStart"
if ( !IsNonCombat && m_pOuter->IsLocalPlayer())
{
m_pOuter->EmitSound( "DisciplineDevice.PowerUp" );
}
#else // !CLIENT_DLL
m_pOuter->TeamFortress_SetSpeed();
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveSpeedBoost( bool IsNonCombat )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pSpeedBoostEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pSpeedBoostEffect );
m_pOuter->m_pSpeedBoostEffect = NULL;
}
if ( !IsNonCombat && m_pOuter->IsLocalPlayer() )
{
m_pOuter->EmitSound( "DisciplineDevice.PowerDown" );
}
else
{
m_pOuter->EmitSound( "Building_Speedpad.BoostStop" );
}
#else // !CLIENT_DLL
m_pOuter->TeamFortress_SetSpeed();
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose: Applied to bots
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddSapped( void )
{
#ifdef CLIENT_DLL
if ( !m_pOuter->m_pSappedPlayerEffect )
{
const char* szParticle = "sapper_sentry1_fx";
m_pOuter->m_pSappedPlayerEffect = m_pOuter->ParticleProp()->Create( szParticle, PATTACH_POINT_FOLLOW, "head" );
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveSapped( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pSappedPlayerEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pSappedPlayerEffect );
m_pOuter->m_pSappedPlayerEffect = NULL;
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose: Applied to bots
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddReprogrammed( void )
{
#ifdef STAGING_ONLY
#ifdef GAME_DLL
CTFBot *pBot = ToTFBot( m_pOuter );
if ( pBot )
{
pBot->ChangeTeam( GetEnemyTeam( pBot->GetTeamNumber() ), false, true );
pBot->SetMission( CTFBot::MISSION_REPROGRAMMED );
pBot->Update();
pBot->MarkAsMissionEnemy();
}
#endif // GAME_DLL
#endif // STAGING_ONLY
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveReprogrammed( void )
{
}
void CTFPlayerShared::OnAddDisguisedAsDispenser( void )
{
m_pOuter->TeamFortress_SetSpeed();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddHalloweenBombHead( void )
{
#ifdef CLIENT_DLL
m_pOuter->HalloweenBombHeadUpdate();
m_pOuter->CreateBombonomiconHint();
#else
if ( InCond( TF_COND_HALLOWEEN_KART ) )
{
RemoveAttributeFromPlayer( "head scale" );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveHalloweenBombHead( void )
{
#ifdef CLIENT_DLL
m_pOuter->HalloweenBombHeadUpdate();
m_pOuter->DestroyBombonomiconHint();
#else
if ( InCond( TF_COND_HALLOWEEN_KART ) )
{
ApplyAttributeToPlayer( "head scale", 3.f );
}
if ( m_pOuter->IsAlive() )
{
m_pOuter->MerasmusPlayerBombExplode( false );
Vector vecOrigin = m_pOuter->GetAbsOrigin();
// explode has a small force but we want to increase it
if ( InCond ( TF_COND_HALLOWEEN_KART ) )
{
if ( !m_pOuter->GetKartBombHeadTarget() )
{
m_pOuter->AddHalloweenKartPushEvent( m_pOuter, NULL, NULL, Vector( 0, 0, 100 ), 50 );
}
m_pOuter->SetKartBombHeadTarget( NULL );
}
else if ( !TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_LAKESIDE ) )
{
TFGameRules()->PushAllPlayersAway( vecOrigin, 150, 400, TEAM_ANY );
}
// Particle
CPVSFilter filter( vecOrigin );
TE_TFParticleEffect( filter, 0.0, "bombinomicon_burningdebris", vecOrigin, vec3_angle );
}
#endif // GAME_DLL
}
void CTFPlayerShared::OnAddHalloweenThriller( void )
{
#ifdef CLIENT_DLL
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
if ( pLocalPlayer == m_pOuter )
{
m_pOuter->EmitSound( "Halloween.dance_howl" );
m_pOuter->EmitSound( "Halloween.dance_loop" );
}
}
#endif
}
void CTFPlayerShared::OnRemoveHalloweenThriller( void )
{
#ifdef CLIENT_DLL
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
if ( pLocalPlayer == m_pOuter )
{
m_pOuter->StopSound( "Halloween.dance_loop" );
}
}
#else
// If this is hightower, players will be healing themselves while dancing
StopHealing( m_pOuter );
#endif
}
void CTFPlayerShared::OnAddRadiusHealOnDamage( void )
{
Heal_Radius( true );
}
void CTFPlayerShared::OnRemoveRadiusHealOnDamage( void )
{
Heal_Radius( false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddMarkedForDeathSilent( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdatedMarkedForDeathEffect();
#endif
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveMarkedForDeathSilent( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdatedMarkedForDeathEffect();
#endif
}
void CTFPlayerShared::OnRemoveDisguisedAsDispenser( void )
{
m_pOuter->TeamFortress_SetSpeed();
}
#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddRocketPack( void )
{
#ifdef CLIENT_DLL
if ( !m_pOuter->m_pRocketPackEffect )
{
const char* szParticle = "rocketbackblast";
m_pOuter->m_pRocketPackEffect = m_pOuter->ParticleProp()->Create( szParticle, PATTACH_POINT_FOLLOW, "flag" );
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveRocketPack( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pRocketPackEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pRocketPackEffect );
m_pOuter->m_pRocketPackEffect = NULL;
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateRocketPack( void )
{
if ( !m_pOuter->IsPlayerClass( TF_CLASS_PYRO ) )
return;
if ( InCond( TF_COND_ROCKETPACK ) )
{
#ifdef GAME_DLL
// Check for landing
if ( m_pOuter->GetFlags() & FL_ONGROUND )
{
RemoveCond( TF_COND_ROCKETPACK );
}
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::ApplyRocketPackStun( float flStunDuration )
{
if ( flStunDuration < 0.1f )
return;
#ifdef GAME_DLL
const int nMaxEnts = 24;
CBaseEntity *pObjects[ nMaxEnts ];
int nCount = UTIL_EntitiesInSphere( pObjects, nMaxEnts, m_pOuter->GetAbsOrigin(), 192.f, FL_CLIENT );
for ( int i = 0; i < nCount; i++ )
{
if ( !pObjects[i] )
continue;
if ( !pObjects[i]->IsAlive() )
continue;
if ( m_pOuter->InSameTeam( pObjects[i] ) )
continue;
if ( !m_pOuter->FVisible( pObjects[i], MASK_OPAQUE ) )
continue;
CTFPlayer *pTFPlayer = static_cast< CTFPlayer* >( pObjects[i] );
if ( !pTFPlayer )
continue;
pTFPlayer->m_Shared.StunPlayer( flStunDuration, 0.75f, TF_STUN_CONTROLS );
}
#endif // GAME_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::CanBuildSpyTraps( void )
{
if ( !m_pOuter->IsPlayerClass( TF_CLASS_SPY ) )
return false;
if ( m_pOuter->IsBot() )
return false;
if ( TFGameRules()->IsMannVsMachineMode() )
return true;
int iTraps = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( m_pOuter, iTraps, ability_spy_traps );
return ( iTraps > 0 );
}
#endif // STAGING_ONLY
#ifdef CLIENT_DLL
static void AddUberScreenEffect( const CTFPlayer* pPlayer )
{
// Add the uber effect onto the local player's screen
if ( pPlayer && pPlayer->IsLocalPlayer() )
{
const char *pEffectName = NULL;
if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
{
pEffectName = TF_SCREEN_OVERLAY_MATERIAL_INVULN_RED;
}
else
{
pEffectName = TF_SCREEN_OVERLAY_MATERIAL_INVULN_BLUE;
}
IMaterial *pMaterial = materials->FindMaterial( pEffectName, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
}
static void RemoveUberScreenEffect( const CTFPlayer* pPlayer )
{
if ( pPlayer && pPlayer->IsLocalPlayer() )
{
// only remove the overlay if it is an invuln material
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial &&
( FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_INVULN_BLUE ) ||
FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_INVULN_RED ) ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
}
static const char* s_pszRedResistOverheadEffectName[] =
{
"vaccinator_red_buff1",
"vaccinator_red_buff2",
"vaccinator_red_buff3",
};
static const char* s_pszBlueResistOverheadEffectName[] =
{
"vaccinator_blue_buff1",
"vaccinator_blue_buff2",
"vaccinator_blue_buff3",
};
COMPILE_TIME_ASSERT( ARRAYSIZE( s_pszRedResistOverheadEffectName ) == MEDIGUN_NUM_RESISTS && ARRAYSIZE( s_pszBlueResistOverheadEffectName ) == MEDIGUN_NUM_RESISTS );
static void AddResistParticle( CTFPlayer* pPlayer, medigun_resist_types_t nResistType, ETFCond eYeildToCond = TF_COND_LAST )
{
// Don't spawn it over the local player's head
if ( !pPlayer || pPlayer->IsLocalPlayer() )
return;
// do not add if stealthed
if ( pPlayer->m_Shared.IsStealthed() )
return;
// Don't add this effect if the yield effect is passed in
if( eYeildToCond != TF_COND_LAST && pPlayer->m_Shared.InCond( eYeildToCond ) )
return;
if ( pPlayer->m_Shared.GetDisplayedTeam() == TF_TEAM_RED )
{
pPlayer->AddOverheadEffect( s_pszRedResistOverheadEffectName[ nResistType ] );
}
else
{
pPlayer->AddOverheadEffect( s_pszBlueResistOverheadEffectName[ nResistType ] );
}
}
static void RemoveResistParticle( CTFPlayer* pPlayer, medigun_resist_types_t nResistType )
{
if ( !pPlayer || pPlayer->IsLocalPlayer() )
return;
bool bKeep = false;
switch ( nResistType )
{
case MEDIGUN_BULLET_RESIST:
bKeep = pPlayer->m_Shared.InCond( TF_COND_MEDIGUN_UBER_BULLET_RESIST );
break;
case MEDIGUN_BLAST_RESIST:
bKeep = pPlayer->m_Shared.InCond( TF_COND_MEDIGUN_UBER_BLAST_RESIST );
break;
case MEDIGUN_FIRE_RESIST:
bKeep = pPlayer->m_Shared.InCond( TF_COND_MEDIGUN_UBER_FIRE_RESIST );
break;
default:
AssertMsg( 0, "Invalid medigun resist type" );
break;
}
// don't remove overhead effect if the uber's still active
if ( bKeep )
return;
if ( pPlayer->m_Shared.GetDisplayedTeam() == TF_TEAM_RED )
{
pPlayer->RemoveOverheadEffect( s_pszRedResistOverheadEffectName[ nResistType ], true );
}
else
{
pPlayer->RemoveOverheadEffect( s_pszBlueResistOverheadEffectName[ nResistType ], true );
}
}
static int GetResistShieldSkinForResistType( ETFCond eCond )
{
switch( eCond )
{
case TF_COND_MEDIGUN_UBER_BULLET_RESIST:
return 2;
case TF_COND_MEDIGUN_UBER_BLAST_RESIST:
return 3;
case TF_COND_MEDIGUN_UBER_FIRE_RESIST:
return 4;
default:
AssertMsg( 0, "Invalid condition passed into AddResistShield" );
return 0;
}
}
static void AddResistShield( C_LocalTempEntity** pShield, CTFPlayer* pPlayer, ETFCond eCond )
{
if( CBasePlayer::GetLocalPlayer() == pPlayer )
return;
// do not add if stealthed
if ( pPlayer->m_Shared.IsStealthed() )
return;
// Don't create a new shield if we already have one
if( *pShield )
return;
model_t *pModel = (model_t*) engine->LoadModel( "models/effects/resist_shield/resist_shield.mdl" );
(*pShield) = tempents->SpawnTempModel( pModel, pPlayer->GetAbsOrigin(), pPlayer->GetAbsAngles(), Vector(0, 0, 0), 1, FTENT_NEVERDIE | FTENT_PLYRATTACHMENT );
if ( *pShield )
{
(*pShield)->ChangeTeam( pPlayer->m_Shared.GetDisplayedTeam() );
if( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
(*pShield)->m_nSkin = GetResistShieldSkinForResistType( eCond );
}
else
{
(*pShield)->m_nSkin = ( pPlayer->m_Shared.GetDisplayedTeam() == TF_TEAM_RED ) ? 0 : 1;
}
(*pShield)->clientIndex = pPlayer->entindex();
(*pShield)->SetModelScale( pPlayer->GetModelScale() );
}
}
static void RemoveResistShield( C_LocalTempEntity** pShield, CTFPlayer* pPlayer )
{
if ( *pShield )
{
ETFCond eCond = TF_COND_INVALID;
// Check if we still have one of the other resist types on us
eCond = pPlayer->m_Shared.InCond( TF_COND_MEDIGUN_UBER_BULLET_RESIST ) ? TF_COND_MEDIGUN_UBER_BULLET_RESIST : eCond;
eCond = pPlayer->m_Shared.InCond( TF_COND_MEDIGUN_UBER_BLAST_RESIST ) ? TF_COND_MEDIGUN_UBER_BLAST_RESIST : eCond;
eCond = pPlayer->m_Shared.InCond( TF_COND_MEDIGUN_UBER_FIRE_RESIST ) ? TF_COND_MEDIGUN_UBER_FIRE_RESIST : eCond;
eCond = ( pPlayer->m_Shared.InCond( TF_COND_RUNE_RESIST ) && !pPlayer->m_Shared.IsStealthed() ) ? TF_COND_RUNE_RESIST : eCond;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer )
{
eCond = ( pPlayer->IsEnemyPlayer() && pPlayer->m_Shared.InCond( TF_COND_RUNE_PLAGUE ) && pLocalPlayer->m_Shared.InCond( TF_COND_PLAGUE ) ) ? TF_COND_RUNE_PLAGUE : eCond;
}
// Still have one, don't remove the shield
if( eCond != TF_COND_INVALID )
{
// If we're in MvM, and we're one of the bots, change the shield color
if( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
(*pShield)->m_nSkin = GetResistShieldSkinForResistType( eCond );
}
return;
}
else // No more bubble
{
(*pShield)->flags = FTENT_FADEOUT | FTENT_PLYRATTACHMENT;
(*pShield)->die = gpGlobals->curtime;
(*pShield)->fadeSpeed = 1.0f;
(*pShield) = NULL;
}
}
}
#endif // CLIENT_DLL
void CTFPlayerShared::OnAddMedEffectUberBulletResist( void )
{
#ifdef CLIENT_DLL
AddResistParticle( m_pOuter, MEDIGUN_BULLET_RESIST );
AddUberScreenEffect( m_pOuter );
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_MEDIGUN_UBER_BULLET_RESIST );
#endif
}
void CTFPlayerShared::OnRemoveMedEffectUberBulletResist( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_BULLET_RESIST );
RemoveUberScreenEffect( m_pOuter );
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
OnAddMedEffectSmallBulletResist();
#endif
}
void CTFPlayerShared::OnAddMedEffectUberBlastResist( void )
{
#ifdef CLIENT_DLL
AddResistParticle( m_pOuter, MEDIGUN_BLAST_RESIST );
AddUberScreenEffect( m_pOuter );
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_MEDIGUN_UBER_BLAST_RESIST );
#endif
}
void CTFPlayerShared::OnRemoveMedEffectUberBlastResist( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_BLAST_RESIST );
RemoveUberScreenEffect( m_pOuter );
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
OnAddMedEffectSmallBlastResist();
#endif
}
void CTFPlayerShared::OnAddMedEffectUberFireResist( void )
{
#ifdef CLIENT_DLL
AddResistParticle( m_pOuter, MEDIGUN_FIRE_RESIST );
AddUberScreenEffect( m_pOuter );
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_MEDIGUN_UBER_FIRE_RESIST );
#endif
}
void CTFPlayerShared::OnRemoveMedEffectUberFireResist( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_FIRE_RESIST );
RemoveUberScreenEffect( m_pOuter );
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
OnAddMedEffectSmallFireResist();
#endif
}
void CTFPlayerShared::OnAddMedEffectSmallBulletResist( void )
{
#ifdef CLIENT_DLL
if( InCond( TF_COND_MEDIGUN_SMALL_BULLET_RESIST ) )
{
AddResistParticle( m_pOuter, MEDIGUN_BULLET_RESIST, TF_COND_MEDIGUN_UBER_BULLET_RESIST );
}
#endif
}
void CTFPlayerShared::OnRemoveMedEffectSmallBulletResist( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_BULLET_RESIST );
#endif
}
void CTFPlayerShared::OnAddMedEffectSmallBlastResist( void )
{
#ifdef CLIENT_DLL
if( InCond( TF_COND_MEDIGUN_SMALL_BLAST_RESIST ) )
{
AddResistParticle( m_pOuter, MEDIGUN_BLAST_RESIST, TF_COND_MEDIGUN_UBER_BLAST_RESIST );
}
#endif
}
void CTFPlayerShared::OnRemoveMedEffectSmallBlastResist( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_BLAST_RESIST );
#endif
}
void CTFPlayerShared::OnAddMedEffectSmallFireResist( void )
{
#ifdef CLIENT_DLL
if( InCond( TF_COND_MEDIGUN_SMALL_FIRE_RESIST ) )
{
AddResistParticle( m_pOuter, MEDIGUN_FIRE_RESIST, TF_COND_MEDIGUN_UBER_FIRE_RESIST );
}
#endif
}
void CTFPlayerShared::OnRemoveMedEffectSmallFireResist( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_FIRE_RESIST );
#endif
}
void CTFPlayerShared::OnAddRuneResist( void )
{
#ifdef CLIENT_DLL
// Do use the condition bit here, it's passed along and is expected to be a cond.
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_RUNE_RESIST );
#endif
}
void CTFPlayerShared::OnRemoveRuneResist( void )
{
#ifdef CLIENT_DLL
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
#endif
}
void CTFPlayerShared::OnRemoveRuneKing( void )
{
#ifdef CLIENT_DLL
EndKingBuffRadiusEffect();
#endif
}
void CTFPlayerShared::OnAddGrapplingHookLatched( void )
{
m_pOuter->DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, ACT_GRAPPLE_PULL_START );
}
void CTFPlayerShared::OnRemoveGrapplingHookLatched( void )
{
// DO NOTHING
}
void CTFPlayerShared::OnAddBulletImmune( void )
{
#ifdef CLIENT_DLL
AddResistParticle( m_pOuter, MEDIGUN_BULLET_RESIST );
AddUberScreenEffect( m_pOuter );
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_MEDIGUN_UBER_BULLET_RESIST );
#endif
}
void CTFPlayerShared::OnRemoveBulletImmune( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_BULLET_RESIST );
RemoveUberScreenEffect( m_pOuter );
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
#endif
}
void CTFPlayerShared::OnAddBlastImmune( void )
{
#ifdef CLIENT_DLL
AddResistParticle( m_pOuter, MEDIGUN_BLAST_RESIST );
AddUberScreenEffect( m_pOuter );
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_MEDIGUN_UBER_BLAST_RESIST );
#endif
}
void CTFPlayerShared::OnRemoveBlastImmune( void )
{
#ifdef CLIENT_DLL
RemoveResistParticle( m_pOuter, MEDIGUN_BLAST_RESIST );
RemoveUberScreenEffect( m_pOuter );
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
#endif
}
void CTFPlayerShared::OnAddFireImmune( void )
{
#ifdef CLIENT_DLL
AddUberScreenEffect( m_pOuter );
if ( !m_pOuter->IsPlayerClass( TF_CLASS_SPY ) )
{
AddResistParticle( m_pOuter, MEDIGUN_FIRE_RESIST );
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_MEDIGUN_UBER_FIRE_RESIST );
}
#endif
}
void CTFPlayerShared::OnRemoveFireImmune( void )
{
#ifdef CLIENT_DLL
RemoveUberScreenEffect( m_pOuter );
if ( !m_pOuter->IsPlayerClass( TF_CLASS_SPY ) )
{
RemoveResistParticle( m_pOuter, MEDIGUN_FIRE_RESIST );
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
}
#endif
}
void CTFPlayerShared::OnAddMVMBotRadiowave( void )
{
#ifdef CLIENT_DLL
if ( !m_pOuter->IsABot() )
return;
if ( !m_pOuter->m_pMVMBotRadiowave )
{
m_pOuter->m_pMVMBotRadiowave = m_pOuter->ParticleProp()->Create( "bot_radio_waves", PATTACH_POINT_FOLLOW, "head" );
}
#else
if ( !m_pOuter->IsBot() )
return;
StunPlayer( GetConditionDuration( TF_COND_MVM_BOT_STUN_RADIOWAVE ), 1.0, TF_STUN_BOTH | TF_STUN_NO_EFFECTS );
#endif
}
void CTFPlayerShared::OnRemoveMVMBotRadiowave( void )
{
#ifdef CLIENT_DLL
if ( !m_pOuter->IsABot() )
return;
if ( m_pOuter->m_pMVMBotRadiowave )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pMVMBotRadiowave );
m_pOuter->m_pMVMBotRadiowave = NULL;
}
#endif
}
void CTFPlayerShared::OnAddHalloweenSpeedBoost( void )
{
#ifdef GAME_DLL
AddCond( TF_COND_SPEED_BOOST );
ApplyAttributeToPlayer( "halloween reload time decreased", 0.5f );
ApplyAttributeToPlayer( "halloween fire rate bonus", 0.5f );
ApplyAttributeToPlayer( "halloween increased jump height", 1.5f );
//
#endif
}
void CTFPlayerShared::OnRemoveHalloweenSpeedBoost( void )
{
#ifdef GAME_DLL
RemoveCond( TF_COND_SPEED_BOOST );
RemoveAttributeFromPlayer( "halloween reload time decreased" );
RemoveAttributeFromPlayer( "halloween fire rate bonus" );
RemoveAttributeFromPlayer( "halloween increased jump height" );
#endif
}
void CTFPlayerShared::OnAddHalloweenQuickHeal( void )
{
#ifdef GAME_DLL
AddCond( TF_COND_MEGAHEAL );
Heal( m_pOuter, 30.0f, 2.0f, 1.0f );
#endif
}
void CTFPlayerShared::OnRemoveHalloweenQuickHeal( void )
{
#ifdef GAME_DLL
RemoveCond( TF_COND_MEGAHEAL );
StopHealing( m_pOuter );
#endif
}
void CTFPlayerShared::OnAddHalloweenGiant( void )
{
#ifdef GAME_DLL
m_pOuter->SetModelScale( 2.f );
int nNewHP = tf_halloween_giant_health_scale.GetFloat() * m_pOuter->GetPlayerClass()->GetMaxHealth();
m_pOuter->SetHealth( nNewHP );
m_pOuter->SetMaxHealth( nNewHP );
#else
cam_idealdist.SetValue( 300.f );
cam_idealdistright.SetValue( 40.f );
#endif
}
void CTFPlayerShared::OnRemoveHalloweenGiant( void )
{
#ifdef GAME_DLL
m_pOuter->SetModelScale( 1.f );
int nNewHP = m_pOuter->GetPlayerClass()->GetMaxHealth();
m_pOuter->SetHealth( nNewHP );
m_pOuter->SetMaxHealth( nNewHP );
#else
cam_idealdist.SetValue( cam_idealdist.GetDefault() );
cam_idealdistright.SetValue( cam_idealdistright.GetDefault() );
#endif
}
void CTFPlayerShared::OnAddHalloweenTiny( void )
{
#ifdef GAME_DLL
m_pOuter->SetModelScale( 0.5f );
ApplyAttributeToPlayer( "voice pitch scale", 1.3f );
ApplyAttributeToPlayer( "head scale", 3.f );
#endif
}
void CTFPlayerShared::OnAddHalloweenGhostMode( void )
{
m_pOuter->SetGroundEntity( NULL );
m_pOuter->SetSolid( SOLID_NONE );
m_pOuter->SetSolidFlags( FSOLID_NOT_SOLID );
m_pOuter->AddFlag( FL_NOTARGET );
#ifdef GAME_DLL
CSingleUserRecipientFilter filter( m_pOuter );
if ( TFGameRules() )
{
if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
TFGameRules()->SendHudNotification( filter, HUD_NOTIFY_HOW_TO_CONTROL_GHOST );
}
else
{
TFGameRules()->SendHudNotification( filter, HUD_NOTIFY_HOW_TO_CONTROL_GHOST_NO_RESPAWN );
}
}
// The game rules listens for this event
IGameEvent *event = gameeventmanager->CreateEvent( "player_turned_to_ghost" );
if ( event )
{
event->SetInt( "userid", m_pOuter->GetUserID() );
gameeventmanager->FireEvent( event );
}
// Push them up a little bit
Vector vecNewVel( 0, 0, 40 );
m_pOuter->Teleport( NULL, NULL, &vecNewVel );
if ( m_pOuter->GetActiveWeapon() )
{
m_pOuter->GetActiveWeapon()->SendViewModelAnim( ACT_IDLE );
m_pOuter->GetActiveWeapon()->Holster();
}
m_pOuter->SetActiveWeapon( NULL );
CBaseObject * pCarriedObj = GetCarriedObject();
if ( pCarriedObj )
{
pCarriedObj->DetonateObject();
}
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( m_pOuter->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pSpellBook )
{
pSpellBook->ClearSpell();
}
#else
// Go thirdperson
SetAppropriateCamera( m_pOuter );
Color color;
m_pOuter->GetTeamColor( color );
m_pOuter->SetRenderColor( color.r(), color.g(), color.b() );
#endif
}
void CTFPlayerShared::OnAddHalloweenKartDash()
{
m_pOuter->SetFOV( m_pOuter, 110.f, 1.f, 0.f );
m_pOuter->DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, ACT_KART_ACTION_DASH );
#ifdef CLIENT_DLL
#else // CLIENT_DLL
m_pOuter->EmitSound( "BumperCar.SpeedBoostStart" );
#endif // GAME_DLL
}
void CTFPlayerShared::OnRemoveHalloweenKartDash()
{
m_pOuter->SetFOV( m_pOuter, 0.f, 1.f, 0.f );
#ifdef CLIENT_DLL
if ( m_pOuter->m_pSpeedBoostEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pSpeedBoostEffect );
m_pOuter->m_pSpeedBoostEffect = NULL;
}
#else // CLIENT_DLL
m_pOuter->EmitSound( "BumperCar.SpeedBoostStop" );
#endif // GAME_DLL
}
void CTFPlayerShared::OnRemoveHalloweenTiny( void )
{
#ifdef GAME_DLL
m_pOuter->SetModelScale( 1.f );
RemoveAttributeFromPlayer( "voice pitch scale" );
RemoveAttributeFromPlayer( "head scale" );
const Vector& vOrigin = m_pOuter->GetAbsOrigin();
const QAngle& qAngle = m_pOuter->GetAbsAngles();
const Vector& vHullMins = m_pOuter->GetFlags() & FL_DUCKING ? VEC_DUCK_HULL_MIN : VEC_HULL_MIN;
const Vector& vHullMaxs = m_pOuter->GetFlags() & FL_DUCKING ? VEC_DUCK_HULL_MAX : VEC_HULL_MAX;
trace_t result;
CTraceFilterIgnoreTeammates filter( m_pOuter, COLLISION_GROUP_NONE, m_pOuter->GetTeamNumber() );
UTIL_TraceHull( vOrigin, vOrigin, vHullMins, vHullMaxs, MASK_PLAYERSOLID, &filter, &result );
// am I stuck? try to resolve it
if ( result.DidHit() )
{
float flPlayerHeight = vHullMaxs.z - vHullMins.z;
float flExtraHeight = 10;
static Vector vTest[] =
{
Vector( 32, 32, flExtraHeight ),
Vector( -32, -32, flExtraHeight ),
Vector( -32, 32, flExtraHeight ),
Vector( 32, -32, flExtraHeight ),
Vector( 0, 0, flPlayerHeight + flExtraHeight ),
Vector( 0, 0, -flPlayerHeight - flExtraHeight )
};
for ( int i=0; i<ARRAYSIZE( vTest ); ++i )
{
Vector vTestPos = vOrigin + vTest[i];
UTIL_TraceHull( vOrigin, vTestPos, vHullMins, vHullMaxs, MASK_PLAYERSOLID, &filter, &result );
if ( !result.DidHit() )
{
//NDebugOverlay::Box( vTestPos, vHullMins, vHullMaxs, 0, 255, 0, 0, 5.f );
m_pOuter->Teleport( &vTestPos, &qAngle, NULL );
return;
}
else
{
//NDebugOverlay::Box( vTestPos, vHullMins, vHullMaxs, 255, 0, 0, 0, 5.f );
}
}
// just kill the player if we can't resolve getting stuck
m_pOuter->CommitSuicide( false, true );
}
#endif
}
void CTFPlayerShared::OnRemoveHalloweenGhostMode( void )
{
#ifdef CLIENT_DLL
m_pOuter->ParticleProp()->StopEmission();
m_pOuter->SetRenderColor( 255, 255, 255 );
m_pOuter->UpdateWearables();
#else
// We don't do the rest if we're a spectator
if ( m_pOuter->GetTeamNumber() == TEAM_SPECTATOR )
return;
m_pOuter->RemoveFlag( FL_NOTARGET );
// Restore solid
m_pOuter->SetSolid( SOLID_BBOX );
m_pOuter->SetSolidFlags( FSOLID_NOT_STANDABLE );
m_pOuter->SetCollisionGroup( COLLISION_GROUP_PLAYER );
// Bring their gun back
m_pOuter->SetActiveWeapon( m_pOuter->GetLastWeapon() );
if ( m_pOuter->GetActiveWeapon() )
{
m_pOuter->GetActiveWeapon()->Deploy();
}
#endif
}
#ifdef STAGING_ONLY
void CTFPlayerShared::OnAddSpaceGravity()
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
m_pOuter->EmitSound( "RD.SpaceGravityTransition" );
}
#endif
}
void CTFPlayerShared::OnRemoveSpaceGravity()
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
m_pOuter->EmitSound( "RD.SpaceGravityTransition" );
}
#endif
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddSelfConc()
{
UpdatePhaseEffects();
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveSelfConc()
{
RemovePhaseEffects();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddStealthedPhase( void )
{
#ifdef GAME_DLL
AddCond( TF_COND_SPEED_BOOST );
m_pOuter->m_takedamage = DAMAGE_NO;
#else
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_STEALTH, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveStealthedPhase( void )
{
#ifdef GAME_DLL
RemoveCond( TF_COND_SPEED_BOOST );
m_pOuter->m_takedamage = DAMAGE_YES;
// See if the spy is inside another player or object
Vector vecPos = m_pOuter->GetAbsOrigin();
trace_t trace;
UTIL_TraceHull( vecPos, vecPos, VEC_HULL_MIN_SCALED( m_pOuter ), VEC_HULL_MAX_SCALED( m_pOuter ), ( MASK_SOLID | CONTENTS_PLAYERCLIP ), m_pOuter, COLLISION_GROUP_NONE, &trace );
if ( trace.fraction < 1.f )
{
// Telefrag!
m_pOuter->TakeDamage( CTakeDamageInfo( m_pOuter, m_pOuter, 1000, DMG_CRUSH, TF_DMG_CUSTOM_TELEFRAG ) );
}
#else
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_STEALTH ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
#endif
}
void CTFPlayerShared::OnAddClipOverload( void )
{
#ifdef GAME_DLL
m_pOuter->GiveAmmo( 1000, TF_AMMO_PRIMARY );
m_pOuter->GiveAmmo( 1000, TF_AMMO_SECONDARY );
m_pOuter->GiveAmmo( 1000, TF_AMMO_METAL );
m_pOuter->GiveAmmo( 1000, TF_AMMO_GRENADES1 );
m_pOuter->GiveAmmo( 1000, TF_AMMO_GRENADES2 );
m_pOuter->GiveAmmo( 1000, TF_AMMO_GRENADES3 );
// Refills weapon clips, too
for ( int i = 0; i < MAX_WEAPONS; i++ )
{
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* >( m_pOuter->GetWeapon( i ) );
if ( !pWeapon )
continue;
float flPrevClipScale = pWeapon->GetClipScale();
if ( m_pOuter->GetActiveTFWeapon() == pWeapon )
{
pWeapon->AbortReload(); // Abort reload or else their reload will "fix" their clip size
pWeapon->SendWeaponAnim( ACT_VM_IDLE );
}
pWeapon->SetClipScale( 3.f );
pWeapon->GiveDefaultAmmo();
pWeapon->SetClipScale( flPrevClipScale );
if ( pWeapon->IsEnergyWeapon() )
{
pWeapon->WeaponRegenerate();
}
}
#endif
}
void CTFPlayerShared::OnRemoveClipOverload( void )
{
// Nothing required
}
#endif // STAGING_ONLY
void CTFPlayerShared::OnAddHalloweenKart( void )
{
#ifdef GAME_DLL
CSingleUserRecipientFilter filter( m_pOuter );
TFGameRules()->SendHudNotification( filter, HUD_NOTIFY_HOW_TO_CONTROL_KART );
ApplyAttributeToPlayer( "head scale", 3.f );
//ResetKartDamage
m_pOuter->ResetKartDamage();
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( m_pOuter->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pSpellBook )
{
pSpellBook->ClearSpell();
}
m_pOuter->m_flKartNextAvailableBoost = gpGlobals->curtime + 3.0f;
// Switch to melee to make sure Spies and Engies don't have build menus open
CTFWeaponBase *pMeleeWeapon = dynamic_cast<CTFWeaponBase*>( m_pOuter->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) );
Assert( pMeleeWeapon );
if ( pMeleeWeapon )
{
m_pOuter->Weapon_Switch( pMeleeWeapon );
}
m_pOuter->m_flNextBonusDucksVOAllowedTime = gpGlobals->curtime + 17.f; // The longest Merasmus line + 1 second
#else
extern ConVar tf_halloween_kart_cam_dist;
m_pOuter->SetTauntCameraTargets( tf_halloween_kart_cam_dist.GetFloat(), 0.0f );
m_pOuter->CreateKart();
// Set vehicle angles to be our current angles so we don't spin around
// when we get in the car
//$ This is handled in the ForcePlayerViewAngles user message.
//$ m_angVehicleMoveAngles = m_pOuter->GetAbsAngles();
if ( m_pOuter->GetActiveWeapon() )
{
m_pOuter->GetActiveWeapon()->SetWeaponVisible( false );
}
#endif
}
void CTFPlayerShared::OnRemoveHalloweenKart( void )
{
#ifdef GAME_DLL
RemoveAttributeFromPlayer( "head scale" );
//ResetKartDamage
m_pOuter->ResetKartDamage();
CTFSpellBook *pSpellBook = dynamic_cast<CTFSpellBook*>( m_pOuter->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pSpellBook )
{
pSpellBook->ClearSpell();
}
#else
// When we have every taunt cam use this system, we should clean up after ourselves. But for now, this causes a bad interaction
// with other systems.
// m_pOuter->SetTauntCameraTargets( 0.0f, 0.0f );
m_pOuter->RemoveKart();
// Reset any tilting now that we're out of the karts
if ( m_pOuter->m_PlayerAnimState )
{
QAngle renderAngles = m_pOuter->m_PlayerAnimState->GetRenderAngles();
renderAngles[ ROLL ] = renderAngles[ PITCH ] = 0.f;
m_pOuter->m_PlayerAnimState->SetRenderangles( renderAngles );
}
if ( m_pOuter->GetActiveWeapon() )
{
m_pOuter->GetActiveWeapon()->SetWeaponVisible( true );
}
if ( m_hKartParachuteEntity )
{
m_hKartParachuteEntity->Release();
m_hKartParachuteEntity = NULL;
}
#endif
}
void CTFPlayerShared::OnAddBalloonHead( void )
{
#ifdef GAME_DLL
ApplyAttributeToPlayer( "voice pitch scale", 0.85f );
ApplyAttributeToPlayer( "head scale", 4.f );
ApplyAttributeToPlayer( "increased jump height", 0.8f );
ApplyAttributeToPlayer( "increased air control", 0.2f );
#endif // GAME_DLL
m_pOuter->SetGravity( 0.3f );
}
void CTFPlayerShared::OnRemoveBalloonHead( void )
{
#ifdef GAME_DLL
RemoveAttributeFromPlayer( "voice pitch scale" );
RemoveAttributeFromPlayer( "head scale" );
RemoveAttributeFromPlayer( "increased jump height" );
RemoveAttributeFromPlayer( "increased air control" );
#endif // GAME_DLL
m_pOuter->SetGravity( 0.f );
}
void CTFPlayerShared::OnAddMeleeOnly( void )
{
#ifdef GAME_DLL
CTFWeaponBase *pMeleeWeapon = dynamic_cast<CTFWeaponBase*>( m_pOuter->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) );
Assert( pMeleeWeapon );
if ( pMeleeWeapon )
{
m_pOuter->Weapon_Switch( pMeleeWeapon );
}
ApplyAttributeToPlayer( "disable weapon switch", true );
ApplyAttributeToPlayer( "hand scale", 3.f );
AddCond( TF_COND_HALLOWEEN_TINY );
AddCond( TF_COND_SPEED_BOOST );
#endif // GAME_DLL
}
void CTFPlayerShared::OnRemoveMeleeOnly( void )
{
#ifdef GAME_DLL
RemoveAttributeFromPlayer( "disable weapon switch" );
RemoveAttributeFromPlayer( "hand scale" );
RemoveCond( TF_COND_HALLOWEEN_TINY );
RemoveCond( TF_COND_SPEED_BOOST );
#endif // GAME_DLL
}
void CTFPlayerShared::OnAddSwimmingCurse( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_SWIMMING_CURSE, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
#endif // CLIENT_DLL
}
void CTFPlayerShared::OnRemoveSwimmingCurse( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
// only remove the overlay if it is urine
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_SWIMMING_CURSE ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
#else
AddCond( TF_COND_URINE, 10.0f );
#endif // CLIENT_DLL
}
void CTFPlayerShared::OnAddHalloweenKartCage( void )
{
#ifdef CLIENT_DLL
Assert( !m_pOuter->m_hHalloweenKartCage );
if ( !m_pOuter->m_hHalloweenKartCage )
{
m_pOuter->m_hHalloweenKartCage = C_PlayerAttachedModel::Create( "models/props_halloween/bumpercar_cage.mdl", m_pOuter, 0, vec3_origin, PAM_PERMANENT, 0 );
m_pOuter->m_hHalloweenKartCage->FollowEntity( m_pOuter, true );
}
#else
AddCond( TF_COND_FREEZE_INPUT );
#endif // CLIENT_DLL
}
void CTFPlayerShared::OnRemoveHalloweenKartCage( void )
{
#ifdef CLIENT_DLL
Assert( m_pOuter->m_hHalloweenKartCage );
if ( m_pOuter->m_hHalloweenKartCage )
{
m_pOuter->m_hHalloweenKartCage->StopFollowingEntity();
m_pOuter->m_hHalloweenKartCage->Release();
}
#else
RemoveCond( TF_COND_FREEZE_INPUT );
DispatchParticleEffect( "ghost_appearation", PATTACH_ABSORIGIN, m_pOuter );
#endif // CLIENT_DLL
}
void CTFPlayerShared::OnAddPasstimeInterception( void )
{
#ifdef CLIENT_DLL
if ( !m_pOuter->m_pPhaseStandingEffect )
{
m_pOuter->m_pPhaseStandingEffect = m_pOuter->ParticleProp()->Create( "warp_version", PATTACH_ABSORIGIN_FOLLOW );
}
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_PHASE, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
#else
if ( !m_bPhaseFXOn )
{
AddPhaseEffects();
}
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_DODGING, "started_dodging:1" );
#endif
}
void CTFPlayerShared::OnRemovePasstimeInterception( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pPhaseStandingEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pPhaseStandingEffect );
m_pOuter->m_pPhaseStandingEffect = NULL;
}
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_PHASE ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
#else
if ( m_bPhaseFXOn )
{
RemovePhaseEffects();
}
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_DODGING, "started_dodging:0" );
#endif
}
void CTFPlayerShared::OnAddRunePlague( void )
{
#ifdef CLIENT_DLL
m_pOuter->m_pRunePlagueEffect = m_pOuter->ParticleProp()->Create( "powerup_plague_carrier", PATTACH_ABSORIGIN_FOLLOW );
// show resist effect on enemy player that has plague rune if local player is in plague cond
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer != m_pOuter && pLocalPlayer->m_Shared.InCond( TF_COND_PLAGUE ) && m_pOuter->IsEnemyPlayer() )
{
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_RUNE_PLAGUE );
}
#endif // CLIENT_DLL
}
void CTFPlayerShared::OnRemoveRunePlague( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pRunePlagueEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pRunePlagueEffect );
m_pOuter->m_pRunePlagueEffect = NULL;
}
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
#endif // CLIENT_DLL
}
void CTFPlayerShared::OnAddPlague( void )
{
#ifdef CLIENT_DLL
m_pOuter->EmitSound( "Powerup.PickUpPlagueInfected" );
#endif
CTFPlayer *pProvider = ToTFPlayer( m_ConditionData[TF_COND_PLAGUE].m_pProvider );
//plague damage is a percentage of player health so everyone has the same life expectancy
float flPlagueDmg = 0.05f * m_pOuter->GetMaxHealth();
if ( pProvider )
{
MakeBleed( pProvider, NULL, 0.f, flPlagueDmg, true );
CSingleUserRecipientFilter localFilter( pProvider );
pProvider->EmitSound( localFilter, pProvider->entindex(), "Powerup.PickUpPlagueInfected" );
}
m_pOuter->EmitSound( "Powerup.PickUpPlagueInfectedLoop" );
ClientPrint( m_pOuter, HUD_PRINTCENTER, "#TF_Powerup_Contract_Plague" );
#ifdef CLIENT_DLL
// show resist effect on enemy player that has plague rune if local player is in plague cond
if ( m_pOuter->IsLocalPlayer() && pProvider && pProvider->IsEnemyPlayer() )
{
AddResistShield( &pProvider->m_pTempShield, pProvider, TF_COND_RUNE_PLAGUE );
}
#endif // CLIENT_DLL
}
void CTFPlayerShared::OnRemovePlague( void )
{
m_pOuter->StopSound( "Powerup.PickUpPlagueInfectedLoop" );
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_BLEED ) )
{
view->SetScreenOverlayMaterial( NULL );
}
// remove shield from the current plague rune carrier
int iEnemyTeam = m_pOuter->GetTeamNumber() == TF_TEAM_RED ? TF_TEAM_BLUE : TF_TEAM_RED;
CTFPlayer *pCurrentRuneCarrier = GetRuneCarrier( RUNE_PLAGUE, iEnemyTeam );
if ( pCurrentRuneCarrier )
{
RemoveResistShield( &pCurrentRuneCarrier->m_pTempShield, pCurrentRuneCarrier );
}
}
#endif
// RemoveCond( TF_COND_BLEEDING );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddInPurgatory( void )
{
#ifdef GAME_DLL
// just entered
m_pOuter->m_purgatoryPainMultiplierTimer.Start( 40.0f );
m_pOuter->m_purgatoryPainMultiplier = 1;
// Set our health to full
m_pOuter->SetHealth( m_pOuter->GetMaxHealth() );
// Remove our projectiles
m_pOuter->RemoveOwnedProjectiles();
// Give us a brief period of invuln while we drop into purgatory
AddCond( TF_COND_INVULNERABLE, 1.5f );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveInPurgatory( void )
{
#ifdef GAME_DLL
if ( m_pOuter->IsAlive() )
{
// we escaped purgatory alive!
const float buffDuration = 10.0f;
AddCond( TF_COND_CRITBOOSTED_PUMPKIN, buffDuration );
AddCond( TF_COND_SPEED_BOOST, buffDuration );
AddCond( TF_COND_INVULNERABLE, buffDuration );
m_pOuter->SetHealth( 2.0f * m_pOuter->GetMaxHealth() );
m_pOuter->m_purgatoryBuffTimer.Start( buffDuration );
TFGameRules()->BroadcastSound( 255, "Halloween.PlayerEscapedUnderworld" );
// Remove our projectiles
m_pOuter->RemoveOwnedProjectiles();
CReliableBroadcastRecipientFilter filter;
const char* pszEscapeMessage = "#TF_Halloween_Underworld";
if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_LAKESIDE ) )
{
pszEscapeMessage = "#TF_Halloween_Skull_Island_Escape";
}
UTIL_SayText2Filter( filter, m_pOuter, false, pszEscapeMessage, m_pOuter->GetPlayerName() );
IGameEvent *pEvent = gameeventmanager->CreateEvent( "escaped_loot_island" );
if ( pEvent )
{
pEvent->SetInt( "player", m_pOuter->GetUserID() );
gameeventmanager->FireEvent( pEvent, true );
}
if ( m_pOuter->GetTeam() )
{
const char* pszLogMessage = "purgatory_escaped";
if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_LAKESIDE ) )
{
pszEscapeMessage = "skull_island_escaped";
}
UTIL_LogPrintf( "HALLOWEEN: \"%s<%i><%s><%s>\" %s\n",
m_pOuter->GetPlayerName(),
m_pOuter->GetUserID(),
m_pOuter->GetNetworkIDString(),
m_pOuter->GetTeam()->GetName(),
pszLogMessage );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddCompetitiveWinner( void )
{
#ifdef GAME_DLL
#else
if ( m_pOuter->IsLocalPlayer() )
{
gHUD.LockRenderGroup( gHUD.LookupRenderGroupIndexByName( "mid" ) );
m_pOuter->UpdateVisibility();
m_pOuter->UpdateWearables();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveCompetitiveWinner( void )
{
#ifdef GAME_DLL
#else
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddCompetitiveLoser( void )
{
#ifdef GAME_DLL
#else
if ( m_pOuter->IsLocalPlayer() )
{
gHUD.LockRenderGroup( gHUD.LookupRenderGroupIndexByName( "mid" ) );
m_pOuter->UpdateVisibility();
m_pOuter->UpdateWearables();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveCompetitiveLoser( void )
{
#ifdef GAME_DLL
#else
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateChargeMeter( void )
{
if ( !m_pOuter->IsPlayerClass( TF_CLASS_DEMOMAN ) )
return;
if ( InCond( TF_COND_SHIELD_CHARGE ) )
{
// Drain the meter while we are charging.
float flChargeDrainTime = tf_demoman_charge_drain_time.GetFloat();
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flChargeDrainTime, mod_charge_time );
float flChargeDrainMod = 100.f / flChargeDrainTime;
m_flChargeMeter -= gpGlobals->frametime * flChargeDrainMod;
if ( m_flChargeMeter <= 0 )
{
m_flChargeMeter = 0;
RemoveCond( TF_COND_SHIELD_CHARGE );
}
m_flLastNoChargeTime = gpGlobals->curtime;
}
else if ( m_flChargeMeter < 100.f )
{
// Recharge the meter while we are not charging.
float flChargeRegenMod = tf_demoman_charge_regen_rate.GetFloat();
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flChargeRegenMod, charge_recharge_rate );
if ( TFGameRules() && TFGameRules()->IsPowerupMode() && GetCarryingRuneType() == RUNE_KNOCKOUT )
{
flChargeRegenMod *= 0.2f;
}
flChargeRegenMod = Max( flChargeRegenMod, 1.f );
m_flChargeMeter += gpGlobals->frametime * flChargeRegenMod;
if ( m_flChargeMeter > 100.f )
{
m_flChargeMeter = 100.f;
}
// Used for the weapon glow cooldown.
if ( !m_bChargeGlowing )
{
m_flLastNoChargeTime = gpGlobals->curtime;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::EndCharge()
{
if ( !InCond( TF_COND_SHIELD_CHARGE ) )
return;
#ifdef GAME_DLL
if ( GetDemomanChargeMeter() < 90 )
{
// Impacts drain the charge meter completely.
float flMeterAtImpact = m_flChargeMeter;
CTFWearableDemoShield *pWearableShield = GetEquippedDemoShield( m_pOuter );
if ( pWearableShield )
{
pWearableShield->ShieldBash( m_pOuter, flMeterAtImpact );
}
CalcChargeCrit();
// Removing the condition here would cause issues with prediction, so we set the
// duration to zero so that it will be removed during the next condition think.
SetConditionDuration( TF_COND_SHIELD_CHARGE, 0 );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFPlayerShared::CalculateChargeCap( void ) const
{
float flCap = 0.45f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flCap, charge_turn_control );
// Scale yaw cap based on frametime to prevent differences in turn effectiveness due to variable framerate (between clients mainly)
if ( tf_demoman_charge_frametime_scaling.GetBool() )
{
// There's probably something better to use here as a baseline, instead of TICK_INTERVAL
float flMod = RemapValClamped( gpGlobals->frametime, ( TICK_INTERVAL * YAW_CAP_SCALE_MIN ), ( TICK_INTERVAL * YAW_CAP_SCALE_MAX ), 0.25f, 2.f );
flCap *= flMod;
}
return flCap;
}
bool CTFPlayerShared::HasDemoShieldEquipped() const
{
return GetEquippedDemoShield( m_pOuter ) != NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::CalcChargeCrit( bool bForceCrit )
{
#ifdef GAME_DLL
// Keying on TideTurner
int iDemoChargeDamagePenalty = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( m_pOuter, iDemoChargeDamagePenalty, lose_demo_charge_on_damage_when_charging );
if ( iDemoChargeDamagePenalty && GetDemomanChargeMeter() <= 75 )
{
SetNextMeleeCrit( MELEE_MINICRIT );
}
else if ( GetDemomanChargeMeter() <= 40 || bForceCrit)
{
SetNextMeleeCrit( MELEE_CRIT );
}
else if ( GetDemomanChargeMeter() <= 75 )
{
SetNextMeleeCrit( MELEE_MINICRIT );
}
m_pOuter->SetContextThink( &CTFPlayer::RemoveMeleeCrit, gpGlobals->curtime + 0.3f, "RemoveMeleeCrit" );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddShieldCharge( void )
{
UpdatePhaseEffects();
m_pOuter->TeamFortress_SetSpeed();
#ifdef CLIENT_DLL
m_pOuter->EmitSound( "DemoCharge.Charging" );
#else
m_hPlayersVisibleAtChargeStart.Purge();
// Remove debuffs
for ( int i = 0; g_aDebuffConditions[i] != TF_COND_LAST; i++ )
{
RemoveCond( g_aDebuffConditions[i] );
}
// store the players we CAN see for the TF_DEMOMAN_KILL_PLAYER_YOU_DIDNT_SEE achievement
CUtlVector<CTFPlayer *> vecPlayers;
CollectPlayers( &vecPlayers, ( m_pOuter->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED, true );
FOR_EACH_VEC( vecPlayers, i )
{
if ( !vecPlayers[i] )
continue;
if ( vecPlayers[i]->m_Shared.InCond( TF_COND_STEALTHED ) )
continue;
// can we see them?
if ( m_pOuter->FVisible( vecPlayers[i], MASK_OPAQUE ) == false )
continue;
// are they in our field of view? (might be behind us)
if ( m_pOuter->IsInFieldOfView( vecPlayers[i]) == false )
continue;
m_hPlayersVisibleAtChargeStart.AddToTail( vecPlayers[i] );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveShieldCharge( void )
{
RemovePhaseEffects();
m_pOuter->TeamFortress_SetSpeed();
m_bPostShieldCharge = true;
m_flChargeEndTime = gpGlobals->curtime;
m_flChargeMeter = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::InterruptCharge( void )
{
if ( !InCond( TF_COND_SHIELD_CHARGE ) )
return;
SetConditionDuration( TF_COND_SHIELD_CHARGE, 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef GAME_DLL
void CTFPlayer::RemoveMeleeCrit( void )
{
m_Shared.SetNextMeleeCrit( MELEE_NOCRIT );
m_Shared.m_bPostShieldCharge = false;
// Remove crit boost right away. DemoShieldChargeThink depends on m_bPostShieldCharge being true
// to attempt to remove crits (which we just cleared) so clear crits here as well.
if ( m_Shared.InCond( TF_COND_CRITBOOSTED_DEMO_CHARGE ) )
{
m_Shared.RemoveCond( TF_COND_CRITBOOSTED_DEMO_CHARGE );
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::DemoShieldChargeThink( void )
{
if ( InCond( TF_COND_SHIELD_CHARGE ) || m_bPostShieldCharge )
{
if ( m_bPostShieldCharge && (gpGlobals->curtime - m_flChargeEndTime) >= 0.3f )
{
if ( InCond( TF_COND_CRITBOOSTED_DEMO_CHARGE ) )
{
RemoveCond( TF_COND_CRITBOOSTED_DEMO_CHARGE );
}
m_bPostShieldCharge = false;
}
else if ( InCond( TF_COND_SHIELD_CHARGE ) && GetDemomanChargeMeter() < 75 )
{
if ( !InCond( TF_COND_CRITBOOSTED_DEMO_CHARGE ) )
{
AddCond( TF_COND_CRITBOOSTED_DEMO_CHARGE );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddDemoBuff( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateDemomanEyeEffect( m_iDecapitations );
#else
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddEnergyDrinkBuff( void )
{
#ifdef CLIENT_DLL
UpdateCritBoostEffect();
#endif
#ifdef GAME_DLL
if ( m_pOuter->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) || m_pOuter->IsPlayerClass( TF_CLASS_SCOUT ) )
{
// Begin berzerker speed buff.
m_pOuter->TeamFortress_SetSpeed();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveEnergyDrinkBuff( void )
{
#ifdef CLIENT_DLL
UpdateCritBoostEffect();
#endif
#ifdef GAME_DLL
if ( m_pOuter->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) || m_pOuter->IsPlayerClass( TF_CLASS_SCOUT ) )
{
// End berzerker speed buff.
m_pOuter->TeamFortress_SetSpeed();
}
#endif
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::EndRadiusHealEffect( void )
{
if ( m_pOuter->m_pRadiusHealEffect )
{
m_pOuter->m_pRadiusHealEffect->StopEmission();
m_pOuter->m_pRadiusHealEffect = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::EndKingBuffRadiusEffect( void )
{
// For buffed player
if ( m_pOuter->m_pKingBuffRadiusEffect )
{
m_pOuter->m_pKingBuffRadiusEffect->StopEmission();
m_pOuter->m_pKingBuffRadiusEffect = NULL;
}
// For carrier of King Rune
if ( m_pOuter->m_pKingRuneRadiusEffect )
{
m_pOuter->m_pKingRuneRadiusEffect->StopEmission();
m_pOuter->m_pKingRuneRadiusEffect = NULL;
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddRadiusHeal( void )
{
#ifdef CLIENT_DLL
if ( InCond( TF_COND_RADIUSHEAL ) )
{
if ( IsStealthed() )
{
EndRadiusHealEffect();
return;
}
const char *pszRadiusHealEffect;
int nTeamNumber = m_pOuter->GetTeamNumber();
if ( m_pOuter->IsPlayerClass( TF_CLASS_SPY ) && InCond( TF_COND_DISGUISED ) && ( GetDisguiseTeam() == GetLocalPlayerTeam() ) )
{
nTeamNumber = GetLocalPlayerTeam();
}
if ( nTeamNumber == TF_TEAM_RED )
{
pszRadiusHealEffect = "medic_healradius_red_buffed";
}
else
{
pszRadiusHealEffect = "medic_healradius_blue_buffed";
}
if ( !m_pOuter->m_pRadiusHealEffect )
{
m_pOuter->m_pRadiusHealEffect = m_pOuter->ParticleProp()->Create( pszRadiusHealEffect, PATTACH_ABSORIGIN_FOLLOW );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveRadiusHeal( void )
{
#ifdef CLIENT_DLL
EndRadiusHealEffect();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddMegaHeal( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
const char *pEffectName = NULL;
if ( m_pOuter->GetTeamNumber() == TF_TEAM_RED )
{
pEffectName = TF_SCREEN_OVERLAY_MATERIAL_INVULN_RED;
}
else
{
pEffectName = TF_SCREEN_OVERLAY_MATERIAL_INVULN_BLUE;
}
IMaterial *pMaterial = materials->FindMaterial( pEffectName, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
if ( InCond( TF_COND_MEGAHEAL ) )
{
const char *pszMegaHealEffectName;
if ( m_pOuter->GetTeamNumber() == TF_TEAM_RED )
{
pszMegaHealEffectName = "medic_megaheal_red";
}
else
{
pszMegaHealEffectName = "medic_megaheal_blue";
}
if ( !m_pOuter->m_pMegaHealEffect )
{
m_pOuter->m_pMegaHealEffect = m_pOuter->ParticleProp()->Create( pszMegaHealEffectName, PATTACH_ABSORIGIN_FOLLOW );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveMegaHeal( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pMegaHealEffect )
{
m_pOuter->m_pMegaHealEffect->StopEmission();
m_pOuter->m_pMegaHealEffect = NULL;
}
if ( m_pOuter->IsLocalPlayer() )
{
// only remove the overlay if it is an invuln material
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial &&
( FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_INVULN_BLUE ) ||
FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_INVULN_RED ) ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddKingBuff( void )
{
#ifdef CLIENT_DLL
if ( IsStealthed() )
{
EndKingBuffRadiusEffect();
return;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveKingBuff( void )
{
#ifdef CLIENT_DLL
EndKingBuffRadiusEffect();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveRuneSupernova( void )
{
SetRuneCharge( 0.f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveDemoBuff( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateDemomanEyeEffect( 0 );
#else
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL
void CTFPlayerShared::ClientDemoBuffThink( void )
{
if ( m_iDecapitations > 0 )
{
if ( m_iDecapitations != m_iOldDecapitations )
{
m_iOldDecapitations = m_iDecapitations;
m_pOuter->UpdateDemomanEyeEffect( m_iDecapitations );
}
}
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::ClientKillStreakBuffThink( void )
{
int nLoadoutSlot = m_pOuter->GetActiveTFWeapon() ? m_pOuter->GetActiveTFWeapon()->GetAttributeContainer()->GetItem()->GetStaticData()->GetLoadoutSlot( m_pOuter->GetPlayerClass()->GetClassIndex() ) : LOADOUT_POSITION_PRIMARY;
int nKillStreak = GetStreak(kTFStreak_Kills);
if ( nKillStreak != m_iOldKillStreak || m_iOldKillStreakWepSlot != nLoadoutSlot )
{
m_pOuter->UpdateKillStreakEffects( nKillStreak, m_iOldKillStreak < nKillStreak );
m_iOldKillStreak = nKillStreak;
m_iOldKillStreakWepSlot = nLoadoutSlot;
}
else if ( !m_pOuter->IsAlive() )
{
m_pOuter->UpdateKillStreakEffects( 0, false );
}
else
{
static bool bAlternate = false;
Vector vColor = bAlternate ? m_pOuter->m_vEyeGlowColor1 : m_pOuter->m_vEyeGlowColor2;
if ( m_pOuter->m_pEyeGlowEffect[0] )
{
m_pOuter->m_pEyeGlowEffect[0]->SetControlPoint( CUSTOM_COLOR_CP1, vColor );
}
if ( m_pOuter->m_pEyeGlowEffect[1] )
{
m_pOuter->m_pEyeGlowEffect[1]->SetControlPoint( CUSTOM_COLOR_CP1, vColor );
}
//
bAlternate = !bAlternate;
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddTeleported( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateRecentlyTeleportedEffect();
m_flGotTeleEffectAt = gpGlobals->curtime;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveTeleported( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateRecentlyTeleportedEffect();
#endif
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::ShouldShowRecentlyTeleported( void )
{
if ( IsStealthed() )
{
return false;
}
if ( m_pOuter->IsPlayerClass( TF_CLASS_SPY ) )
{
// disguised as an enemy
if ( InCond( TF_COND_DISGUISED ) && GetDisguiseTeam() != m_pOuter->GetTeamNumber() )
{
// was this my own team's teleporter?
if ( GetTeamTeleporterUsed() == m_pOuter->GetTeamNumber() )
{
// don't show my trail
return false;
}
else
{
// okay to show the local player the trail, but not his team (might confuse them)
if ( !m_pOuter->IsLocalPlayer() && m_pOuter->GetTeamNumber() == GetLocalPlayerTeam() )
{
return false;
}
}
}
else
{
if ( GetTeamTeleporterUsed() != m_pOuter->GetTeamNumber() )
{
return false;
}
}
}
return InCond( TF_COND_TELEPORTED );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::Burn( CTFPlayer *pAttacker, CTFWeaponBase *pWeapon, float flBurningTime /*=-1*/ )
{
#ifdef CLIENT_DLL
#else
// Don't bother igniting players who have just been killed by the fire damage.
if ( !m_pOuter->IsAlive() )
return;
//Don't ignite if I'm in phase mode.
if ( InCond( TF_COND_PHASE ) || InCond( TF_COND_PASSTIME_INTERCEPTION ) )
return;
// pyros don't burn persistently or take persistent burning damage, but we show brief burn effect so attacker can tell they hit
bool bVictimIsPyro = ( TF_CLASS_PYRO == m_pOuter->GetPlayerClass()->GetClassIndex() );
if ( !InCond( TF_COND_BURNING ) )
{
// Start burning
AddCond( TF_COND_BURNING, -1.f, pAttacker );
m_flFlameBurnTime = gpGlobals->curtime; //asap
// let the attacker know he burned me
if ( pAttacker && !bVictimIsPyro )
{
pAttacker->OnBurnOther( m_pOuter, pWeapon );
m_hOriginalBurnAttacker = pAttacker;
}
}
int nAfterburnImmunity = 0;
// Check my weapon
CTFWeaponBase *pMyWeapon = GetActiveTFWeapon();
if ( pMyWeapon )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pMyWeapon, nAfterburnImmunity, afterburn_immunity );
}
// STAGING_SPY
if ( InCond( TF_COND_AFTERBURN_IMMUNE ) )
{
nAfterburnImmunity = 1;
m_flFlameRemoveTime = 0;
}
// Check shield
if ( !nAfterburnImmunity && IsShieldEquipped() )
{
CTFWearableDemoShield *pWearableShield = GetEquippedDemoShield( m_pOuter );
if ( pWearableShield && !pWearableShield->IsDisguiseWearable() )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWearableShield, nAfterburnImmunity, afterburn_immunity );
}
}
bool bIsFlareGun = ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_FLAREGUN );
float flFlameLife;
if ( bVictimIsPyro || nAfterburnImmunity )
{
flFlameLife = TF_BURNING_FLAME_LIFE_PYRO;
}
else if ( flBurningTime > 0 )
{
flFlameLife = flBurningTime;
}
else if ( bIsFlareGun )
{
flFlameLife = TF_BURNING_FLAME_LIFE_FLARE;
}
else if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_PARTICLE_CANNON )
{
flFlameLife = TF_BURNING_FLAME_LIFE_PLASMA;
}
else
{
flFlameLife = TF_BURNING_FLAME_LIFE;
}
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flFlameLife, mult_wpn_burntime );
float flBurnEnd = gpGlobals->curtime + flFlameLife;
if ( flBurnEnd > m_flFlameRemoveTime )
{
m_flFlameRemoveTime = flBurnEnd;
}
m_hBurnAttacker = pAttacker;
m_hBurnWeapon = pWeapon;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: A non-TF Player burned us
// Used for Bosses, they inflict self burn
//-----------------------------------------------------------------------------
void CTFPlayerShared::SelfBurn( float flBurningTime )
{
#ifdef GAME_DLL
Burn( m_pOuter, NULL, flBurningTime );
#endif // GAME_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::MakeBleed( CTFPlayer *pPlayer, CTFWeaponBase *pWeapon, float flBleedingTime, int nBleedDmg /* = TF_BLEEDING_DMG */, bool bPermanentBleeding /*= false*/ )
{
#ifdef CLIENT_DLL
#else
// Don't bother if they are dead
if ( !m_pOuter->IsAlive() )
return;
// Required for the CTakeDamageInfo we create later
Assert( pPlayer && pWeapon );
if ( !pPlayer && !pWeapon )
return;
float flExpireTime = gpGlobals->curtime + flBleedingTime;
// See if this weapon has already applied a bleed and extend the time
FOR_EACH_VEC( m_PlayerBleeds, i )
{
if ( m_PlayerBleeds[i].hBleedingAttacker && m_PlayerBleeds[i].hBleedingAttacker == pPlayer &&
m_PlayerBleeds[i].hBleedingWeapon && m_PlayerBleeds[i].hBleedingWeapon == pWeapon )
{
if ( flExpireTime > m_PlayerBleeds[i].flBleedingRemoveTime )
{
m_PlayerBleeds[i].flBleedingRemoveTime = flExpireTime;
return;
}
}
}
// New bleed source
bleed_struct_t bleedinfo =
{
pPlayer, // hBleedingAttacker
pWeapon, // hBleedingWeapon
flBleedingTime, // flBleedingTime
flExpireTime, // flBleedingRemoveTime
nBleedDmg, // nBleedDmg
bPermanentBleeding
};
m_PlayerBleeds.AddToTail( bleedinfo );
if ( !InCond( TF_COND_BLEEDING ) )
{
AddCond( TF_COND_BLEEDING, -1.f, pPlayer );
}
#endif
}
#ifdef GAME_DLL
void CTFPlayerShared::StopBleed( CTFPlayer *pPlayer, CTFWeaponBase *pWeapon )
{
FOR_EACH_VEC_BACK( m_PlayerBleeds, i )
{
const bleed_struct_t& bleed = m_PlayerBleeds[i];
if ( bleed.hBleedingAttacker == pPlayer && bleed.hBleedingWeapon == pWeapon )
{
m_PlayerBleeds.FastRemove( i );
}
}
// remove condition right away when the list is empty
if ( !m_PlayerBleeds.Count() )
{
RemoveCond( TF_COND_BLEEDING );
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveBurning( void )
{
#ifdef CLIENT_DLL
m_pOuter->StopBurningSound();
if ( m_pOuter->m_nOldWaterLevel > 0 )
{
m_pOuter->ParticleProp()->Create( "water_burning_steam", PATTACH_ABSORIGIN );
}
if ( m_pOuter->m_pBurningEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pBurningEffect );
m_pOuter->m_pBurningEffect = NULL;
}
if ( m_pOuter->IsLocalPlayer() )
{
// only remove the overlay if it is the burning
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_BURNING ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
m_pOuter->m_flBurnEffectStartTime = 0;
#else
m_hBurnAttacker = NULL;
m_hOriginalBurnAttacker = NULL;
m_hBurnWeapon = NULL;
m_pOuter->ClearBurnFromBehindAttackers();
// If we were on fire and now we're not, and we're still alive, then give ourself some credit
// for surviving this fire if we have any items that track it.
if ( m_nPlayerState == TF_STATE_ACTIVE )
{
HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( m_pOuter, kKillEaterEvent_FiresSurvived );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveOverhealed( void )
{
#ifdef CLIENT_DLL
if ( !m_pOuter->IsLocalPlayer() )
{
m_pOuter->UpdateOverhealEffect();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveDemoCharge( void )
{
#ifdef CLIENT_DLL
m_pOuter->StopSound( "DemoCharge.ChargeCritOn" );
m_pOuter->EmitSound( "DemoCharge.ChargeCritOff" );
UpdateCritBoostEffect();
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveCritBoost( void )
{
#ifdef CLIENT_DLL
UpdateCritBoostEffect();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveTmpDamageBonus( void )
{
m_flTmpDamageBonusAmount = 1.0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddStealthed( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->GetPredictable() && ( !prediction->IsFirstTimePredicted() || m_bSyncingConditions ) )
return;
if ( !InCond( TF_COND_FEIGN_DEATH ) )
{
m_pOuter->EmitSound( "Player.Spy_Cloak" );
}
m_pOuter->RemoveAllDecals();
UpdateCritBoostEffect();
if ( m_pOuter->m_pTempShield && GetCarryingRuneType() == RUNE_RESIST )
{
RemoveResistShield( &m_pOuter->m_pTempShield, m_pOuter );
}
#endif
bool bSetInvisChangeTime = true;
#ifdef CLIENT_DLL
if ( !m_pOuter->IsLocalPlayer() )
{
// We only clientside predict changetime for the local player
bSetInvisChangeTime = false;
}
if ( InCond( TF_COND_STEALTHED_USER_BUFF ) && m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_STEALTH, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
#endif
if ( bSetInvisChangeTime )
{
if ( !InCond( TF_COND_FEIGN_DEATH ) && !InCond( TF_COND_STEALTHED_USER_BUFF ) )
{
float flInvisTime = tf_spy_invis_time.GetFloat();
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flInvisTime, mult_cloak_rate );
m_flInvisChangeCompleteTime = gpGlobals->curtime + flInvisTime;
}
else
{
m_flInvisChangeCompleteTime = gpGlobals->curtime; // Stealth immediately if we are in feign death.
}
}
// set our offhand weapon to be the invis weapon, but only for the spy's stealth
if ( InCond( TF_COND_STEALTHED ) )
{
for (int i = 0; i < m_pOuter->WeaponCount(); i++)
{
CTFWeaponInvis *pWpn = (CTFWeaponInvis *) m_pOuter->GetWeapon(i);
if ( !pWpn )
continue;
if ( pWpn->GetWeaponID() != TF_WEAPON_INVIS )
continue;
// try to switch to this weapon
m_pOuter->SetOffHandWeapon( pWpn );
m_bMotionCloak = pWpn->HasMotionCloak();
break;
}
}
m_pOuter->TeamFortress_SetSpeed();
#ifdef CLIENT_DLL
// Remove water balloon effect if it on player
m_pOuter->ParticleProp()->StopParticlesNamed( "balloontoss_drip", true );
m_pOuter->UpdateSpyStateChange();
m_pOuter->UpdateKillStreakEffects( GetStreak( kTFStreak_Kills ) );
#endif
#ifdef GAME_DLL
m_flCloakStartTime = gpGlobals->curtime;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveStealthed( void )
{
#ifdef CLIENT_DLL
if ( !m_bSyncingConditions )
return;
CTFWeaponInvis *pWpn = (CTFWeaponInvis *) m_pOuter->Weapon_OwnsThisID( TF_WEAPON_INVIS );
int iReducedCloak = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( m_pOuter, iReducedCloak, set_quiet_unstealth );
if ( iReducedCloak == 1 )
{
m_pOuter->EmitSound( "Player.Spy_UnCloakReduced" );
}
else if ( pWpn && pWpn->HasFeignDeath() )
{
m_pOuter->EmitSound( "Player.Spy_UnCloakFeignDeath" );
}
else
{
m_pOuter->EmitSound( "Player.Spy_UnCloak" );
}
UpdateCritBoostEffect( kCritBoost_ForceRefresh );
if ( m_pOuter->IsLocalPlayer() && !InCond( TF_COND_STEALTHED_USER_BUFF_FADING ) )
{
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_STEALTH ) )
{
view->SetScreenOverlayMaterial( NULL );
}
}
if ( !m_pOuter->m_pTempShield && GetCarryingRuneType() == RUNE_RESIST )
{
AddResistShield( &m_pOuter->m_pTempShield, m_pOuter, TF_COND_RUNE_RESIST );
}
#else
if ( m_flCloakStartTime > 0 )
{
// Calc a time and report every minute
float flCloaktime = ( gpGlobals->curtime - m_flCloakStartTime );
if ( flCloaktime > 0 )
{
EconEntity_OnOwnerKillEaterEventNoPartner(
dynamic_cast<CEconEntity *>( m_pOuter->GetEntityForLoadoutSlot( LOADOUT_POSITION_PDA2 ) ),
m_pOuter,
kKillEaterEvent_TimeCloaked,
(int)flCloaktime
);
}
m_flCloakStartTime = 0;
}
#endif
// End feign death if we leave stealth for some reason.
if ( InCond( TF_COND_FEIGN_DEATH ) )
{
RemoveCond( TF_COND_FEIGN_DEATH );
}
m_pOuter->HolsterOffHandWeapon();
m_pOuter->TeamFortress_SetSpeed();
m_bMotionCloak = false;
#ifdef CLIENT_DLL
m_pOuter->UpdateSpyStateChange();
m_pOuter->UpdateKillStreakEffects( GetStreak( kTFStreak_Kills ) );
#endif
#ifdef STAGING_ONLY
if ( HasPhaseCloakAbility() )
{
RemoveCond( TF_COND_STEALTHED_PHASE );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddStealthedUserBuffFade( void )
{
#ifdef CLIENT_DLL
// If a player is firing their weapon while radius stealth hits them, we never
// get a chance to apply the screenoverlay effect, so apply it here instead.
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_STEALTH, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveStealthedUserBuffFade( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = view->GetScreenOverlayMaterial();
if ( pMaterial && FStrEq( pMaterial->GetName(), TF_SCREEN_OVERLAY_MATERIAL_STEALTH ) )
{
view->SetScreenOverlayMaterial( NULL );
return;
}
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddFeignDeath( void )
{
#ifdef CLIENT_DLL
// STAGING_SPY
AddUberScreenEffect( m_pOuter );
#else
#endif
// Go stealth w/o sound or fade out.
if ( !IsStealthed() )
{
AddCond( TF_COND_STEALTHED, -1.f, m_pOuter );
}
// STAGING_SPY
// Add a speed boost while feigned and afterburn immunity while running away
AddCond( TF_COND_SPEED_BOOST, tf_feign_death_speed_duration.GetFloat() );
AddCond( TF_COND_AFTERBURN_IMMUNE, tf_feign_death_speed_duration.GetFloat() );
SetFeignDeathReady( false );
m_flFeignDeathEnd = gpGlobals->curtime + tf_feign_death_speed_duration.GetFloat();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveFeignDeath( void )
{
#ifdef CLIENT_DLL
// STAGING_SPY
RemoveUberScreenEffect( m_pOuter );
#endif
// Previous code removed cloak meter, this has been moved to on RemoveStealth checking for steath type
// FeignDeath is the duration of cloak where speed, no shimmer and damage reduction take place
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveDisguising( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pDisguisingEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pDisguisingEffect );
m_pOuter->m_pDisguisingEffect = NULL;
}
#else
m_nDesiredDisguiseTeam = TF_SPY_UNDEFINED;
// Do not reset this value, we use the last desired disguise class for the
// 'lastdisguise' command
//m_nDesiredDisguiseClass = TF_CLASS_UNDEFINED;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveDisguised( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->GetPredictable() && ( !prediction->IsFirstTimePredicted() || m_bSyncingConditions ) )
return;
// if local player is on the other team, reset the model of this player
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !m_pOuter->InSameTeam( pLocalPlayer ) )
{
TFPlayerClassData_t *pData = GetPlayerClassData( TF_CLASS_SPY );
int iIndex = modelinfo->GetModelIndex( pData->GetModelName() );
m_pOuter->SetModelIndex( iIndex );
}
m_pOuter->EmitSound( "Player.Spy_Disguise" );
// They may have called for medic and created a visible medic bubble
m_pOuter->StopSaveMeEffect( true );
m_pOuter->StopTauntWithMeEffect();
UpdateCritBoostEffect( kCritBoost_ForceRefresh );
m_pOuter->UpdateSpyStateChange();
#else
m_nDisguiseTeam = TF_SPY_UNDEFINED;
m_nDisguiseClass.Set( TF_CLASS_UNDEFINED );
m_nDisguiseSkinOverride = 0;
m_hDisguiseTarget.Set( NULL );
m_iDisguiseTargetIndex = TF_DISGUISE_TARGET_INDEX_NONE;
m_iDisguiseHealth = 0;
SetDisguiseBody( 0 );
m_iDisguiseAmmo = 0;
// Update the player model and skin.
m_pOuter->UpdateModel();
m_pOuter->ClearExpression();
m_pOuter->ClearDisguiseWeaponList();
RemoveDisguiseWeapon();
RemoveDisguiseWearables();
#endif
m_pOuter->TeamFortress_SetSpeed();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddBurning( void )
{
#ifdef CLIENT_DLL
// Start the burning effect
if ( !m_pOuter->m_pBurningEffect )
{
if ( !( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) && m_pOuter->IsLocalPlayer() ) )
{
const char *pEffectName = ( m_pOuter->GetTeamNumber() == TF_TEAM_RED ) ? "burningplayer_red" : "burningplayer_blue";
m_pOuter->m_pBurningEffect = m_pOuter->ParticleProp()->Create( pEffectName, PATTACH_ABSORIGIN_FOLLOW );
}
m_pOuter->m_flBurnEffectStartTime = gpGlobals->curtime;
}
// set the burning screen overlay
if ( m_pOuter->IsLocalPlayer() )
{
IMaterial *pMaterial = materials->FindMaterial( TF_SCREEN_OVERLAY_MATERIAL_BURNING, TEXTURE_GROUP_CLIENT_EFFECTS, false );
if ( !IsErrorMaterial( pMaterial ) )
{
view->SetScreenOverlayMaterial( pMaterial );
}
}
#endif
// play a fire-starting sound
m_pOuter->EmitSound( "Fire.Engulf" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddOverhealed( void )
{
#ifdef CLIENT_DLL
// Start the Overheal effect
if ( !m_pOuter->IsLocalPlayer() )
{
m_pOuter->UpdateOverhealEffect();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddStunned( void )
{
if ( IsControlStunned() || IsLoserStateStunned() )
{
#ifdef CLIENT_DLL
if ( GetActiveStunInfo() )
{
if ( !m_pOuter->m_pStunnedEffect && !( GetActiveStunInfo()->iStunFlags & TF_STUN_NO_EFFECTS ) )
{
if ( ( GetActiveStunInfo()->iStunFlags & TF_STUN_BY_TRIGGER ) || InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) )
{
const char* pEffectName = "yikes_fx";
m_pOuter->m_pStunnedEffect = m_pOuter->ParticleProp()->Create( pEffectName, PATTACH_POINT_FOLLOW, "head" );
}
else
{
const char* pEffectName = "conc_stars";
m_pOuter->m_pStunnedEffect = m_pOuter->ParticleProp()->Create( pEffectName, PATTACH_POINT_FOLLOW, "head" );
}
}
}
#endif
// Notify our weapon that we have been stunned.
CTFWeaponBase* pWpn = m_pOuter->GetActiveTFWeapon();
if ( pWpn )
{
pWpn->OnControlStunned();
}
if ( InCond( TF_COND_SHIELD_CHARGE ) )
{
SetDemomanChargeMeter( 0 );
RemoveCond( TF_COND_SHIELD_CHARGE );
}
m_pOuter->TeamFortress_SetSpeed();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveStunned( void )
{
m_iStunFlags = 0;
m_hStunner = NULL;
#ifdef CLIENT_DLL
if ( m_pOuter->m_pStunnedEffect )
{
// Remove stun stars if they are still around.
// They might be if we died, etc.
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pStunnedEffect );
m_pOuter->m_pStunnedEffect = NULL;
}
#else
m_iStunIndex = -1;
m_PlayerStuns.RemoveAll();
#endif
m_pOuter->TeamFortress_SetSpeed();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::ControlStunFading( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pStunnedEffect )
{
// Remove stun stars early...
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pStunnedEffect );
m_pOuter->m_pStunnedEffect = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetStunExpireTime( float flTime )
{
#ifdef GAME_DLL
if ( GetActiveStunInfo() )
{
GetActiveStunInfo()->flExpireTime = flTime;
}
#else
m_flStunEnd = flTime;
#endif
UpdateLegacyStunSystem();
}
//-----------------------------------------------------------------------------
// Purpose: Mirror stun info to the old system for networking
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateLegacyStunSystem( void )
{
// What a mess.
#ifdef GAME_DLL
stun_struct_t *pStun = GetActiveStunInfo();
if ( pStun )
{
m_hStunner = pStun->hPlayer;
m_flStunFade = gpGlobals->curtime + pStun->flDuration;
m_flMovementStunTime = pStun->flDuration;
m_flStunEnd = pStun->flExpireTime;
if ( pStun->iStunFlags & TF_STUN_CONTROLS )
{
m_flStunEnd = pStun->flExpireTime;
}
m_iMovementStunAmount = pStun->flStunAmount;
m_iStunFlags = pStun->iStunFlags;
m_iMovementStunParity = ( m_iMovementStunParity + 1 ) & ( ( 1 << MOVEMENTSTUN_PARITY_BITS ) - 1 );
}
#else
m_ActiveStunInfo.hPlayer = m_hStunner;
m_ActiveStunInfo.flDuration = m_flMovementStunTime;
m_ActiveStunInfo.flExpireTime = m_flStunEnd;
m_ActiveStunInfo.flStartFadeTime = m_flStunEnd;
m_ActiveStunInfo.flStunAmount = m_iMovementStunAmount;
m_ActiveStunInfo.iStunFlags = m_iStunFlags;
#endif // GAME_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
stun_struct_t *CTFPlayerShared::GetActiveStunInfo( void ) const
{
#ifdef GAME_DLL
return ( m_PlayerStuns.IsValidIndex( m_iStunIndex ) ) ? const_cast<stun_struct_t*>( &m_PlayerStuns[m_iStunIndex] ) : NULL;
#else
return ( m_iStunIndex >= 0 ) ? const_cast<stun_struct_t*>( &m_ActiveStunInfo ) : NULL;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFPlayer *CTFPlayerShared::GetStunner( void )
{
return GetActiveStunInfo() ? GetActiveStunInfo()->hPlayer : NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddCritBoost( void )
{
#ifdef CLIENT_DLL
UpdateCritBoostEffect();
#endif
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateCritBoostEffect( ECritBoostUpdateType eUpdateType )
{
bool bShouldDisplayCritBoostEffect = IsCritBoosted()
|| InCond( TF_COND_ENERGY_BUFF )
//|| IsHypeBuffed()
|| InCond( TF_COND_SNIPERCHARGE_RAGE_BUFF );
if ( m_pOuter->GetActiveTFWeapon() )
{
bShouldDisplayCritBoostEffect &= m_pOuter->GetActiveTFWeapon()->CanBeCritBoosted();
}
// Never show crit boost effects when stealthed
bShouldDisplayCritBoostEffect &= !IsStealthed();
// Never show crit boost effects when disguised unless we're the local player (so crits show on our viewmodel)
if ( !m_pOuter->IsLocalPlayer() )
{
bShouldDisplayCritBoostEffect &= !InCond( TF_COND_DISGUISED );
}
// Remove our current crit-boosted effect if we're forcing a refresh (in which case we'll
// regenerate an effect below) or if we aren't supposed to have an effect active.
if ( eUpdateType == kCritBoost_ForceRefresh || !bShouldDisplayCritBoostEffect )
{
if ( m_pOuter->m_pCritBoostEffect )
{
Assert( m_pOuter->m_pCritBoostEffect->IsValid() );
if ( m_pOuter->m_pCritBoostEffect->GetOwner() )
{
m_pOuter->m_pCritBoostEffect->GetOwner()->ParticleProp()->StopEmissionAndDestroyImmediately( m_pOuter->m_pCritBoostEffect );
}
else
{
m_pOuter->m_pCritBoostEffect->StopEmission();
}
m_pOuter->m_pCritBoostEffect = NULL;
}
#ifdef CLIENT_DLL
if ( m_pCritBoostSoundLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pCritBoostSoundLoop );
m_pCritBoostSoundLoop = NULL;
}
#endif
}
// Should we have an active crit effect?
if ( bShouldDisplayCritBoostEffect )
{
CBaseEntity *pWeapon = NULL;
// Use GetRenderedWeaponModel() instead?
if ( m_pOuter->IsLocalPlayer() )
{
pWeapon = m_pOuter->GetViewModel(0);
}
else
{
// is this player an enemy?
if ( m_pOuter->GetTeamNumber() != GetLocalPlayerTeam() )
{
// are they a cloaked spy? or disguised as someone who almost assuredly isn't also critboosted?
if ( IsStealthed() || InCond( TF_COND_STEALTHED_BLINK ) || InCond( TF_COND_DISGUISED ) )
return;
}
pWeapon = m_pOuter->GetActiveWeapon();
}
if ( pWeapon )
{
if ( !m_pOuter->m_pCritBoostEffect )
{
if ( InCond( TF_COND_DISGUISED ) && !m_pOuter->IsLocalPlayer() && m_pOuter->GetTeamNumber() != GetLocalPlayerTeam() )
{
const char *pEffectName = ( GetDisguiseTeam() == TF_TEAM_RED ) ? "critgun_weaponmodel_red" : "critgun_weaponmodel_blu";
m_pOuter->m_pCritBoostEffect = pWeapon->ParticleProp()->Create( pEffectName, PATTACH_ABSORIGIN_FOLLOW );
}
else
{
const char *pEffectName = ( m_pOuter->GetTeamNumber() == TF_TEAM_RED ) ? "critgun_weaponmodel_red" : "critgun_weaponmodel_blu";
m_pOuter->m_pCritBoostEffect = pWeapon->ParticleProp()->Create( pEffectName, PATTACH_ABSORIGIN_FOLLOW );
}
if ( m_pOuter->IsLocalPlayer() )
{
if ( m_pOuter->m_pCritBoostEffect )
{
ClientLeafSystem()->SetRenderGroup( m_pOuter->m_pCritBoostEffect->RenderHandle(), RENDER_GROUP_VIEW_MODEL_TRANSLUCENT );
}
}
}
else
{
m_pOuter->m_pCritBoostEffect->StartEmission();
}
Assert( m_pOuter->m_pCritBoostEffect->IsValid() );
}
#ifdef CLIENT_DLL
if ( m_pOuter->GetActiveTFWeapon() && !m_pCritBoostSoundLoop )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
CLocalPlayerFilter filter;
m_pCritBoostSoundLoop = controller.SoundCreate( filter, m_pOuter->entindex(), "Weapon_General.CritPower" );
controller.Play( m_pCritBoostSoundLoop, 1.0, 100 );
}
#endif
}
}
#endif
//-----------------------------------------------------------------------------
// Soda Popper Condition
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnAddSodaPopperHype( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
m_pOuter->EmitSound( "DisciplineDevice.PowerUp" );
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnRemoveSodaPopperHype( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->IsLocalPlayer() )
{
m_pOuter->EmitSound( "DisciplineDevice.PowerDown" );
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFPlayerShared::GetStealthNoAttackExpireTime( void )
{
return m_flStealthNoAttackExpire;
}
//-----------------------------------------------------------------------------
// Purpose: Sets whether this player is dominating the specified other player
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetPlayerDominated( CTFPlayer *pPlayer, bool bDominated )
{
int iPlayerIndex = pPlayer->entindex();
m_bPlayerDominated.Set( iPlayerIndex, bDominated );
pPlayer->m_Shared.SetPlayerDominatingMe( m_pOuter, bDominated );
}
//-----------------------------------------------------------------------------
// Purpose: Sets whether this player is being dominated by the other player
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetPlayerDominatingMe( CTFPlayer *pPlayer, bool bDominated )
{
int iPlayerIndex = pPlayer->entindex();
m_bPlayerDominatingMe.Set( iPlayerIndex, bDominated );
#ifdef GAME_DLL
if ( bDominated )
{
CTFPlayer *pDominatingPlayer = ToTFPlayer( pPlayer );
if ( pDominatingPlayer && pDominatingPlayer->IsPlayerClass( TF_CLASS_MEDIC ) )
{
CBaseEntity *pHealedEntity = pPlayer->MedicGetHealTarget();
CTFPlayer *pHealedPlayer = ToTFPlayer( pHealedEntity );
if ( pHealedPlayer && pHealedPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
pHealedPlayer->AwardAchievement( ACHIEVEMENT_TF_HEAVY_EARN_MEDIC_DOMINATION );
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether this player is dominating the specified other player
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsPlayerDominated( int iPlayerIndex )
{
#ifdef CLIENT_DLL
// On the client, we only have data for the local player.
// As a result, it's only valid to ask for dominations related to the local player
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return false;
Assert( m_pOuter->IsLocalPlayer() || pLocalPlayer->entindex() == iPlayerIndex );
if ( m_pOuter->IsLocalPlayer() )
return m_bPlayerDominated.Get( iPlayerIndex );
return pLocalPlayer->m_Shared.IsPlayerDominatingMe( m_pOuter->entindex() );
#else
// Server has all the data.
return m_bPlayerDominated.Get( iPlayerIndex );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsPlayerDominatingMe( int iPlayerIndex )
{
return m_bPlayerDominatingMe.Get( iPlayerIndex );
}
//-----------------------------------------------------------------------------
// Purpose: True if the given player is a spy disguised as our team.
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsSpyDisguisedAsMyTeam( CTFPlayer *pPlayer )
{
if ( !pPlayer )
return false;
if ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) &&
pPlayer->GetTeamNumber() != m_pOuter->GetTeamNumber() &&
pPlayer->m_Shared.GetDisguiseTeam() == m_pOuter->GetTeamNumber() )
{
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::NoteLastDamageTime( int nDamage )
{
// we took damage
if ( ( nDamage > 5 || InCond( TF_COND_BLEEDING ) ) && !InCond( TF_COND_FEIGN_DEATH ) && InCond( TF_COND_STEALTHED ) )
{
m_flLastStealthExposeTime = gpGlobals->curtime;
AddCond( TF_COND_STEALTHED_BLINK );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::OnSpyTouchedByEnemy( void )
{
if ( !InCond( TF_COND_FEIGN_DEATH ) && InCond( TF_COND_STEALTHED ) )
{
m_flLastStealthExposeTime = gpGlobals->curtime;
AddCond( TF_COND_STEALTHED_BLINK );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsEnteringOrExitingFullyInvisible( void )
{
return ( ( GetPercentInvisiblePrevious() != 1.f && GetPercentInvisible() == 1.f ) ||
( GetPercentInvisiblePrevious() == 1.f && GetPercentInvisible() != 1.f ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::CanRuneCharge() const
{
return InCond( TF_COND_RUNE_SUPERNOVA );
}
#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::HasPhaseCloakAbility( void )
{
int iPhaseStealth = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( m_pOuter, iPhaseStealth, ability_cloak_phase );
return iPhaseStealth > 0;
}
#endif // STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::FadeInvis( float fAdditionalRateScale )
{
ETFCond nExpiringCondition = TF_COND_LAST;
if ( InCond( TF_COND_STEALTHED ) )
{
nExpiringCondition = TF_COND_STEALTHED;
RemoveCond( TF_COND_STEALTHED );
}
else if ( InCond( TF_COND_STEALTHED_USER_BUFF ) )
{
nExpiringCondition = TF_COND_STEALTHED_USER_BUFF;
RemoveCond( TF_COND_STEALTHED_USER_BUFF );
}
#ifdef GAME_DLL
// inform the bots
CTFWeaponInvis *pInvis = dynamic_cast< CTFWeaponInvis * >( m_pOuter->Weapon_OwnsThisID( TF_WEAPON_INVIS ) );
if ( pInvis )
{
TheNextBots().OnWeaponFired( m_pOuter, pInvis );
}
#endif
// If present, give our invisibility weapon a chance to override our decloak
// rate scale.
float flDecloakRateScale = 0.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, flDecloakRateScale, mult_decloak_rate );
// This comes from script, so sanity check the result.
if ( flDecloakRateScale <= 0.0f )
{
flDecloakRateScale = 1.0f;
}
float flInvisFadeTime = fAdditionalRateScale
* (tf_spy_invis_unstealth_time.GetFloat() * flDecloakRateScale);
if ( flInvisFadeTime < 0.15 )
{
// this was a force respawn, they can attack whenever
}
else if ( ( nExpiringCondition != TF_COND_STEALTHED_USER_BUFF ) && !InCond( TF_COND_STEALTHED_USER_BUFF_FADING ) )
{
// next attack in some time
m_flStealthNoAttackExpire = gpGlobals->curtime + (tf_spy_cloak_no_attack_time.GetFloat() * flDecloakRateScale * fAdditionalRateScale);
}
m_flInvisChangeCompleteTime = gpGlobals->curtime + flInvisFadeTime;
}
//-----------------------------------------------------------------------------
// Purpose: Approach our desired level of invisibility
//-----------------------------------------------------------------------------
void CTFPlayerShared::InvisibilityThink( void )
{
if ( m_pOuter->GetPlayerClass()->GetClassIndex() != TF_CLASS_SPY && InCond( TF_COND_STEALTHED ) )
{
// Shouldn't happen, but it's a safety net
m_flInvisibility = 0.0f;
if ( InCond( TF_COND_STEALTHED ) )
{
RemoveCond( TF_COND_STEALTHED );
}
return;
}
float flTargetInvis = 0.0f;
float flTargetInvisScale = 1.0f;
if ( InCond( TF_COND_STEALTHED_BLINK ) || InCond( TF_COND_URINE ) )
{
// We were bumped into or hit for some damage.
flTargetInvisScale = TF_SPY_STEALTH_BLINKSCALE;
}
// Go invisible or appear.
if ( m_flInvisChangeCompleteTime > gpGlobals->curtime )
{
if ( IsStealthed() )
{
flTargetInvis = 1.0f - ( ( m_flInvisChangeCompleteTime - gpGlobals->curtime ) );
}
else
{
flTargetInvis = ( ( m_flInvisChangeCompleteTime - gpGlobals->curtime ) * 0.5f );
}
}
else
{
if ( IsStealthed() )
{
flTargetInvis = 1.0f;
m_flLastNoMovementTime = -1.f;
if ( m_bMotionCloak )
{
if ( m_flCloakMeter == 0.f )
{
Vector vVel = m_pOuter->GetAbsVelocity();
float fSpdSqr = vVel.LengthSqr();
flTargetInvis = RemapVal( fSpdSqr, 0, m_pOuter->MaxSpeed()*m_pOuter->MaxSpeed(), 1.0f, 0.5f );
}
else
{
flTargetInvis = 1.f;
}
}
}
else
{
flTargetInvis = 0.0f;
}
}
flTargetInvis *= flTargetInvisScale;
m_flPrevInvisibility = m_flInvisibility;
m_flInvisibility = clamp( flTargetInvis, 0.0f, 1.0f );
#ifdef STAGING_ONLY
// Sniper cloak
int iSniperCloak = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( m_pOuter, iSniperCloak, ability_cloak_sniper );
if ( iSniperCloak )
{
static const float flSniperCloakDelay = 2.f;
bool bMoving = !m_pOuter->GetAbsVelocity().IsZero();
bool bAiming = IsAiming();
if ( !bMoving && !bAiming && !IsCarryingObject() )
{
if ( m_flLastNoMovementTime == -1.f )
{
m_flLastNoMovementTime = gpGlobals->curtime;
}
if ( !InCond( TF_COND_STEALTHED_USER_BUFF ) && !m_flInvisibility && m_flLastNoMovementTime > 0.f && gpGlobals->curtime - m_flLastNoMovementTime > flSniperCloakDelay )
{
AddCond( TF_COND_STEALTHED_USER_BUFF, -1.f, m_pOuter );
}
}
else
{
if ( IsStealthed() )
{
FadeInvis( 0.1f );
}
m_flLastNoMovementTime = -1.f;
}
}
#endif // STAGING_ONLY
}
//-----------------------------------------------------------------------------
// Purpose: How invisible is the player [0..1]
//-----------------------------------------------------------------------------
float CTFPlayerShared::GetPercentInvisible( void ) const
{
#ifdef STAGING_ONLY
#ifdef CLIENT_DLL
// This is a client hack to make everyone else invisible to the local player
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalTFPlayer && pLocalTFPlayer->m_Shared.InCond( TF_COND_STEALTHED_PHASE ) && pLocalTFPlayer != m_pOuter )
return 1.f;
#endif // CLIENT_DLL
#endif // STAGING_ONLY
return m_flInvisibility;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsCritBoosted( void ) const
{
bool bAllWeaponCritActive = ( InCond( TF_COND_CRITBOOSTED ) ||
InCond( TF_COND_CRITBOOSTED_PUMPKIN ) ||
InCond( TF_COND_CRITBOOSTED_USER_BUFF ) ||
#ifdef CLIENT_DLL
InCond( TF_COND_CRITBOOSTED_DEMO_CHARGE ) ||
#endif
InCond( TF_COND_CRITBOOSTED_FIRST_BLOOD ) ||
InCond( TF_COND_CRITBOOSTED_BONUS_TIME ) ||
InCond( TF_COND_CRITBOOSTED_CTF_CAPTURE ) ||
InCond( TF_COND_CRITBOOSTED_ON_KILL ) ||
InCond( TF_COND_CRITBOOSTED_CARD_EFFECT ) ||
InCond( TF_COND_CRITBOOSTED_RUNE_TEMP ) );
if ( bAllWeaponCritActive )
return true;
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* >( m_pOuter->GetActiveWeapon() );
if ( pWeapon )
{
if ( InCond( TF_COND_CRITBOOSTED_RAGE_BUFF ) && pWeapon->GetTFWpnData().m_iWeaponType == TF_WPN_TYPE_PRIMARY )
{
// Only primary weapon can be crit boosted by pyro rage
return true;
}
float flCritHealthPercent = 1.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flCritHealthPercent, mult_crit_when_health_is_below_percent );
if ( flCritHealthPercent < 1.0f && m_pOuter->HealthFraction() < flCritHealthPercent )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsInvulnerable( void ) const
{
bool bInvuln = InCond( TF_COND_INVULNERABLE ) ||
InCond( TF_COND_INVULNERABLE_USER_BUFF ) ||
InCond( TF_COND_INVULNERABLE_HIDE_UNLESS_DAMAGED ) ||
InCond( TF_COND_INVULNERABLE_CARD_EFFECT );
return bInvuln;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsStealthed( void ) const
{
#ifdef STAGING_ONLY
#ifdef CLIENT_DLL
// This is a client hack to make everyone else invisible to the local player
C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalTFPlayer && pLocalTFPlayer->m_Shared.InCond( TF_COND_STEALTHED_PHASE ) && pLocalTFPlayer != m_pOuter )
return true;
#endif // CLIENT_DLL
#endif // STAGING_ONLY
return ( InCond( TF_COND_STEALTHED ) || InCond( TF_COND_STEALTHED_USER_BUFF ) || InCond( TF_COND_STEALTHED_USER_BUFF_FADING ) );
}
bool CTFPlayerShared::CanBeDebuffed( void ) const
{
if ( IsInvulnerable() )
return false;
if ( InCond( TF_COND_PHASE ) || InCond( TF_COND_PASSTIME_INTERCEPTION ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Start the process of disguising
//-----------------------------------------------------------------------------
void CTFPlayerShared::Disguise( int nTeam, int nClass, CTFPlayer* pDesiredTarget, bool bOnKill )
{
int nRealTeam = m_pOuter->GetTeamNumber();
int nRealClass = m_pOuter->GetPlayerClass()->GetClassIndex();
Assert ( ( nClass >= TF_CLASS_SCOUT ) && ( nClass <= TF_CLASS_ENGINEER ) );
// we're not a spy
if ( nRealClass != TF_CLASS_SPY )
{
return;
}
if ( InCond( TF_COND_TAUNTING ) )
{
// not allowed to disguise while taunting
return;
}
// we're not disguising as anything but ourselves (so reset everything)
if ( nRealTeam == nTeam && nRealClass == nClass )
{
RemoveDisguise();
return;
}
// Ignore disguise of the same type, unless we're using 'Your Eternal Reward'
if ( nTeam == m_nDisguiseTeam && nClass == m_nDisguiseClass && !bOnKill )
{
#ifdef GAME_DLL
DetermineDisguiseWeapon( false );
#endif
return;
}
// invalid team
if ( nTeam <= TEAM_SPECTATOR || nTeam >= TF_TEAM_COUNT )
{
return;
}
// invalid class
if ( nClass <= TF_CLASS_UNDEFINED || nClass >= TF_CLASS_COUNT )
{
return;
}
// are we already in the middle of disguising as this class?
// (the lastdisguise key might get pushed multiple times before the disguise is complete)
if ( InCond( TF_COND_DISGUISING ) )
{
if ( nTeam == m_nDesiredDisguiseTeam && nClass == m_nDesiredDisguiseClass )
{
return;
}
}
m_hDesiredDisguiseTarget.Set( pDesiredTarget );
m_nDesiredDisguiseClass = nClass;
m_nDesiredDisguiseTeam = nTeam;
m_bLastDisguisedAsOwnTeam = ( m_nDesiredDisguiseTeam == m_pOuter->GetTeamNumber() );
AddCond( TF_COND_DISGUISING );
// Start the think to complete our disguise
float flTimeToDisguise = TF_TIME_TO_DISGUISE;
//CALL_ATTRIB_HOOK_INT_ON_OTHER( m_pOuter, iTimeToDisguise, disguise_speed_penalty ); // Unused Attr
// STAGING_SPY
// Quick disguise if you already disguised
if ( InCond( TF_COND_DISGUISED ) )
{
flTimeToDisguise = TF_TIME_TO_QUICK_DISGUISE;
}
if ( pDesiredTarget )
{
flTimeToDisguise = 0;
}
m_flDisguiseCompleteTime = gpGlobals->curtime + flTimeToDisguise;
}
//-----------------------------------------------------------------------------
// Purpose: Set our target with a player we've found to emulate
//-----------------------------------------------------------------------------
#ifndef CLIENT_DLL
void CTFPlayerShared::FindDisguiseTarget( void )
{
if ( m_hDesiredDisguiseTarget )
{
m_hDisguiseTarget.Set( m_hDesiredDisguiseTarget.Get() );
m_hDesiredDisguiseTarget.Set( NULL );
}
else
{
m_hDisguiseTarget = m_pOuter->TeamFortress_GetDisguiseTarget( m_nDisguiseTeam, m_nDisguiseClass );
}
if ( m_hDisguiseTarget )
{
m_iDisguiseTargetIndex.Set( m_hDisguiseTarget.Get()->entindex() );
Assert( m_iDisguiseTargetIndex >= 1 && m_iDisguiseTargetIndex <= MAX_PLAYERS );
}
else
{
m_iDisguiseTargetIndex.Set( TF_DISGUISE_TARGET_INDEX_NONE );
}
m_pOuter->CreateDisguiseWeaponList( ToTFPlayer( m_hDisguiseTarget.Get() ) );
}
#endif
int CTFPlayerShared::GetDisguiseTeam( void ) const
{
return InCond( TF_COND_DISGUISED_AS_DISPENSER ) ? (int)( ( m_pOuter->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED ) : m_nDisguiseTeam;
}
//-----------------------------------------------------------------------------
// Purpose: Complete our disguise
//-----------------------------------------------------------------------------
void CTFPlayerShared::CompleteDisguise( void )
{
AddCond( TF_COND_DISGUISED );
m_nDisguiseClass = m_nDesiredDisguiseClass;
m_nDisguiseTeam = m_nDesiredDisguiseTeam;
if ( m_nDisguiseClass == TF_CLASS_SPY )
{
m_nMaskClass = rand()%9+1;
}
RemoveCond( TF_COND_DISGUISING );
#ifdef GAME_DLL
// Update the player model and skin.
m_pOuter->UpdateModel();
m_pOuter->ClearExpression();
FindDisguiseTarget();
if ( GetDisguiseTarget() )
{
m_iDisguiseHealth = GetDisguiseTarget()->GetHealth();
if ( m_iDisguiseHealth <= 0 || !GetDisguiseTarget()->IsAlive() )
{
// If we disguised as an enemy who is currently dead, just set us to full health.
m_iDisguiseHealth = GetDisguiseMaxHealth();
}
}
else
{
int iMaxHealth = m_pOuter->GetMaxHealth();
m_iDisguiseHealth = (int)random->RandomInt( iMaxHealth / 2, iMaxHealth );
}
// In Medieval mode, don't force primary weapon because most classes just have melee weapons
DetermineDisguiseWeapon( !TFGameRules()->IsInMedievalMode() );
DetermineDisguiseWearables();
#endif
m_pOuter->TeamFortress_SetSpeed();
m_flDisguiseCompleteTime = 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetDisguiseHealth( int iDisguiseHealth )
{
m_iDisguiseHealth = iDisguiseHealth;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerShared::GetDisguiseMaxHealth( void )
{
TFPlayerClassData_t *pClass = g_pTFPlayerClassDataMgr->Get( GetDisguiseClass() );
if ( pClass )
{
return pClass->m_nMaxHealth;
}
else
{
return m_pOuter->GetMaxHealth();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::RemoveDisguise( void )
{
if ( GetDisguiseTeam() != m_pOuter->GetTeamNumber() )
{
if ( InCond( TF_COND_TELEPORTED ) )
{
RemoveCond( TF_COND_TELEPORTED );
}
}
RemoveCond( TF_COND_DISGUISED );
RemoveCond( TF_COND_DISGUISING );
AddCond( TF_COND_DISGUISE_WEARINGOFF, 0.5f );
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::DetermineDisguiseWeapon( bool bForcePrimary )
{
Assert( m_pOuter->GetPlayerClass()->GetClassIndex() == TF_CLASS_SPY );
const char* strDisguiseWeapon = NULL;
CTFPlayer *pDisguiseTarget = ToTFPlayer( m_hDisguiseTarget.Get() );
TFPlayerClassData_t *pData = GetPlayerClassData( m_nDisguiseClass );
if ( pDisguiseTarget && (pDisguiseTarget->GetPlayerClass()->GetClassIndex() != m_nDisguiseClass) )
{
pDisguiseTarget = NULL;
}
// Determine which slot we have active.
int iCurrentSlot = 0;
if ( m_pOuter->GetActiveTFWeapon() && !bForcePrimary )
{
iCurrentSlot = m_pOuter->GetActiveTFWeapon()->GetSlot();
if ( (iCurrentSlot == 3) && // Cig Case, so they are using the menu not a key bind to disguise.
m_pOuter->GetLastWeapon() )
{
iCurrentSlot = m_pOuter->GetLastWeapon()->GetSlot();
}
}
CTFWeaponBase *pItemWeapon = NULL;
if ( pDisguiseTarget )
{
CTFWeaponBase *pLastDisguiseWeapon = m_hDisguiseWeapon;
CTFWeaponBase *pFirstValidWeapon = NULL;
// Cycle through the target's weapons and see if we have a match.
// Note that it's possible the disguise target doesn't have a weapon in the slot we want,
// for example if they have replaced it with an unlockable that isn't a weapon (wearable).
for ( int i=0; i<m_pOuter->m_hDisguiseWeaponList.Count(); ++i )
{
CTFWeaponBase *pWeapon = m_pOuter->m_hDisguiseWeaponList[i];
if ( !pWeapon )
continue;
if ( !pFirstValidWeapon )
{
pFirstValidWeapon = pWeapon;
}
// skip passtime gun
if ( pWeapon->GetWeaponID() == TF_WEAPON_PASSTIME_GUN )
{
continue;
}
if ( pWeapon->GetSlot() == iCurrentSlot )
{
pItemWeapon = pWeapon;
break;
}
}
if ( !pItemWeapon )
{
if ( pLastDisguiseWeapon )
{
pItemWeapon = pLastDisguiseWeapon;
}
else if ( pFirstValidWeapon )
{
pItemWeapon = pFirstValidWeapon;
}
}
if ( pItemWeapon )
{
strDisguiseWeapon = pItemWeapon->GetClassname();
}
}
if ( !pItemWeapon && pData )
{
// We have not found our item yet, so cycle through the class's default weapons
// to find a match.
for ( int i=0; i<TF_PLAYER_WEAPON_COUNT; ++i )
{
if ( pData->m_aWeapons[i] == TF_WEAPON_NONE )
continue;
const char *pWpnName = WeaponIdToAlias( pData->m_aWeapons[i] );
WEAPON_FILE_INFO_HANDLE hWpnInfo = LookupWeaponInfoSlot( pWpnName );
Assert( hWpnInfo != GetInvalidWeaponInfoHandle() );
CTFWeaponInfo *pWeaponInfo = dynamic_cast<CTFWeaponInfo*>( GetFileWeaponInfoFromHandle( hWpnInfo ) );
if ( pWeaponInfo->iSlot == iCurrentSlot )
{
strDisguiseWeapon = pWeaponInfo->szClassName;
}
}
}
if ( strDisguiseWeapon )
{
// Remove the old disguise weapon, if any.
RemoveDisguiseWeapon();
CEconItemView *pItem = NULL;
if ( pItemWeapon )
{
// We are copying a generated, non-base item.
CAttributeContainer *pContainer = pItemWeapon->GetAttributeContainer();
if ( pContainer )
{
pItem = pContainer->GetItem();
}
}
// We may need a sub-type if we're a builder. Otherwise we'll always appear as a engineer's workbox.
int iSubType = 0;
if ( Q_strcmp( strDisguiseWeapon, "tf_weapon_builder" ) == 0 )
{
return; // Temporary.
}
m_hDisguiseWeapon.Set( dynamic_cast<CTFWeaponBase*>(m_pOuter->GiveNamedItem( strDisguiseWeapon, iSubType, pItem, true )) );
if ( m_hDisguiseWeapon )
{
m_hDisguiseWeapon->SetTouch( NULL );// no touch
m_hDisguiseWeapon->SetOwner( dynamic_cast<CBaseCombatCharacter*>(m_pOuter) );
m_hDisguiseWeapon->SetOwnerEntity( m_pOuter );
m_hDisguiseWeapon->SetParent( m_pOuter );
m_hDisguiseWeapon->FollowEntity( m_pOuter, true );
m_hDisguiseWeapon->m_iState = WEAPON_IS_ACTIVE;
m_hDisguiseWeapon->m_bDisguiseWeapon = true;
m_hDisguiseWeapon->SetContextThink( &CTFWeaponBase::DisguiseWeaponThink, gpGlobals->curtime + 0.5, "DisguiseWeaponThink" );
// Ammo/clip state is displayed to attached medics
m_iDisguiseAmmo = 0;
if ( !m_hDisguiseWeapon->IsMeleeWeapon() )
{
// Use the player we're disguised as if possible
if ( pDisguiseTarget )
{
CTFWeaponBase *pWeapon = pDisguiseTarget->GetActiveTFWeapon();
if ( pWeapon && pWeapon->GetWeaponID() == m_hDisguiseWeapon->GetWeaponID() )
{
m_iDisguiseAmmo = pWeapon->UsesClipsForAmmo1() ?
pWeapon->Clip1() :
pDisguiseTarget->GetAmmoCount( pWeapon->GetPrimaryAmmoType() );
}
}
// Otherwise display a faked ammo count
if ( !m_iDisguiseAmmo )
{
int nMaxCount = m_hDisguiseWeapon->UsesClipsForAmmo1() ?
m_hDisguiseWeapon->GetMaxClip1() :
m_pOuter->GetMaxAmmo( m_hDisguiseWeapon->GetPrimaryAmmoType(), m_nDisguiseClass );
m_iDisguiseAmmo = (int)random->RandomInt( 1, nMaxCount );
}
}
}
}
}
void CTFPlayerShared::DetermineDisguiseWearables()
{
CTFPlayer *pDisguiseTarget = ToTFPlayer( m_hDisguiseTarget.Get() );
if ( !pDisguiseTarget )
return;
// Remove any existing disguise wearables.
RemoveDisguiseWearables();
if ( GetDisguiseClass() != pDisguiseTarget->GetPlayerClass()->GetClassIndex() )
return;
// Equip us with copies of our disguise target's wearables.
int iPlayerSkinOverride = 0;
for ( int i=0; i<pDisguiseTarget->GetNumWearables(); ++i )
{
CTFWearable *pWearable = dynamic_cast<CTFWearable*>( pDisguiseTarget->GetWearable( i ) );
if ( pWearable )
{
if ( pWearable->IsDisguiseWearable() )
continue; // Never copy a target's disguise wearables.
CEconItemView *pScriptItem = pWearable->GetAttributeContainer()->GetItem();
if ( pScriptItem && pScriptItem->IsValid() && pScriptItem->GetStaticData()->GetItemClass() )
{
CEconEntity *pNewItem = dynamic_cast<CEconEntity*>( m_pOuter->GiveNamedItem( pScriptItem->GetStaticData()->GetItemClass(), 0, pScriptItem ) );
CTFWearable *pNewWearable = dynamic_cast<CTFWearable*>( pNewItem );
Assert( pNewWearable );
if ( pNewWearable )
{
pNewWearable->SetDisguiseWearable( true );
pNewWearable->GiveTo( m_pOuter );
// copy over the level for levelable items
CTFWearableLevelableItem *pLevelableItem = dynamic_cast<CTFWearableLevelableItem*>( pWearable );
CTFWearableLevelableItem *pNewLevelableItem = dynamic_cast<CTFWearableLevelableItem*>( pNewWearable );
if ( pLevelableItem && pNewLevelableItem )
{
int nBodyGroup = pNewLevelableItem->FindBodygroupByName( LEVELABLE_ITEM_BODYGROUP_NAME );
if ( nBodyGroup != -1 )
{
pNewLevelableItem->SetBodygroup( nBodyGroup, pLevelableItem->GetLevel() );
}
}
// find the first skin override item
if ( iPlayerSkinOverride == 0 )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pNewWearable, iPlayerSkinOverride, player_skin_override );
}
}
}
}
}
m_nDisguiseSkinOverride = iPlayerSkinOverride;
}
void CTFPlayerShared::RemoveDisguiseWearables()
{
bool bFoundDisguiseWearable = true;
while ( bFoundDisguiseWearable )
{
int i = 0;
for ( ; i<m_pOuter->GetNumWearables(); ++i )
{
CTFWearable *pWearable = dynamic_cast<CTFWearable*>( m_pOuter->GetWearable( i ) );
if ( pWearable && pWearable->IsDisguiseWearable() )
{
// Every time we do this the list changes, so we have to loop through again.
pWearable->RemoveFrom( m_pOuter );
break;
}
}
if ( i == m_pOuter->GetNumWearables() )
{
bFoundDisguiseWearable = false;
}
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::ProcessDisguiseImpulse( CTFPlayer *pPlayer )
{
// Get the player owning the weapon.
if ( !pPlayer )
return;
if ( pPlayer->GetImpulse() > 200 )
{
char szImpulse[6];
Q_snprintf( szImpulse, sizeof( szImpulse ), "%d", pPlayer->GetImpulse() );
char szTeam[3];
Q_snprintf( szTeam, sizeof( szTeam ), "%c", szImpulse[1] );
char szClass[3];
Q_snprintf( szClass, sizeof( szClass ), "%c", szImpulse[2] );
// 'Your Eternal Reward' handling
bool bSwitchWeaponOnly = false;
if ( pPlayer->CanDisguise_OnKill() && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
{
// Only trying to change the disguise weapon via 'lastdisguise'
if ( Q_atoi( szClass ) == pPlayer->m_Shared.GetDisguiseClass() && Q_atoi( szTeam ) == pPlayer->m_Shared.GetDisguiseTeam() )
{
bSwitchWeaponOnly = true;
}
}
if ( pPlayer->CanDisguise() || bSwitchWeaponOnly )
{
// intercepting the team value and reassigning what gets passed into Disguise()
// because the team numbers in the client menu don't match the #define values for the teams
pPlayer->m_Shared.Disguise( Q_atoi( szTeam ), Q_atoi( szClass ) );
// Switch from the PDA to our previous weapon
if ( GetActiveTFWeapon() && GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_PDA_SPY )
{
pPlayer->SelectLastItem();
}
}
}
}
bool CTFPlayerShared::CanRecieveMedigunChargeEffect( medigun_charge_types eType ) const
{
bool bCanRecieve = true;
const CTFItem *pItem = m_pOuter->GetItem();
if ( pItem && pItem->GetItemID() == TF_ITEM_CAPTURE_FLAG )
{
bCanRecieve = false;
// The "flag" in Player Destruction doesn't block uber
const CCaptureFlag* pFlag = static_cast< const CCaptureFlag* >( pItem );
if ( pFlag->GetType() == TF_FLAGTYPE_PLAYER_DESTRUCTION )
{
bCanRecieve = true;
}
if ( TFGameRules()->IsMannVsMachineMode() )
{
// allow bot flag carriers to be ubered
bCanRecieve = true;
}
if ( ( eType == MEDIGUN_CHARGE_MEGAHEAL )
|| ( eType == MEDIGUN_CHARGE_BULLET_RESIST )
|| ( eType == MEDIGUN_CHARGE_BLAST_RESIST )
|| ( eType == MEDIGUN_CHARGE_FIRE_RESIST ) )
{
bCanRecieve = true;
}
}
if( TFGameRules() && TFGameRules()->IsPasstimeMode() )
{
bCanRecieve &= ! HasPasstimeBall();
}
return bCanRecieve;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Heal players.
// pPlayer is person who healed us
//-----------------------------------------------------------------------------
void CTFPlayerShared::Heal( CBaseEntity *pHealer, float flAmount, float flOverhealBonus, float flOverhealDecayMult, bool bDispenserHeal /* = false */, CTFPlayer *pHealScorer /* = NULL */ )
{
// If already healing, stop healing
float flHealAccum = 0;
if ( FindHealerIndex(pHealer) != m_aHealers.InvalidIndex() )
{
flHealAccum = StopHealing( pHealer );
}
healers_t newHealer;
newHealer.pHealer = pHealer;
newHealer.flAmount = flAmount;
newHealer.flHealAccum = flHealAccum;
newHealer.iKillsWhileBeingHealed = 0;
newHealer.flOverhealBonus = flOverhealBonus;
newHealer.flOverhealDecayMult = flOverhealDecayMult;
newHealer.bDispenserHeal = bDispenserHeal;
newHealer.flHealedLastSecond = 0;
if ( pHealScorer )
{
newHealer.pHealScorer = pHealScorer;
}
else
{
//Assert( pHealer->IsPlayer() );
newHealer.pHealScorer = pHealer;
}
m_aHealers.AddToTail( newHealer );
AddCond( TF_COND_HEALTH_BUFF, PERMANENT_CONDITION, pHealer );
RecalculateChargeEffects();
m_nNumHealers = m_aHealers.Count();
if ( pHealer && pHealer->IsPlayer() )
{
CTFPlayer *pPlayer = ToTFPlayer( pHealer );
Assert(pPlayer);
pPlayer->m_AchievementData.AddTargetToHistory( m_pOuter );
pPlayer->TeamFortress_SetSpeed();
}
}
//-----------------------------------------------------------------------------
// Purpose: Heal players.
// pPlayer is person who healed us
//-----------------------------------------------------------------------------
float CTFPlayerShared::StopHealing( CBaseEntity *pHealer )
{
int iIndex = FindHealerIndex(pHealer);
if ( iIndex == m_aHealers.InvalidIndex() )
return 0;
float flHealingDone = 0.f;
if ( iIndex != m_aHealers.InvalidIndex() )
{
flHealingDone = m_aHealers[iIndex].flHealAccum;
m_aHealers.Remove( iIndex );
}
if ( !m_aHealers.Count() )
{
RemoveCond( TF_COND_HEALTH_BUFF );
}
RecalculateChargeEffects();
m_nNumHealers = m_aHealers.Count();
return flHealingDone;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::RecalculateChargeEffects( bool bInstantRemove )
{
struct medic_charges_t
{
bool bActive;
CTFPlayer *pProvider;
};
medic_charges_t aCharges[MEDIGUN_NUM_CHARGE_TYPES];
for ( int i = 0; i < ARRAYSIZE( aCharges ); i++ )
{
aCharges[i].bActive = m_pOuter->m_bInPowerPlay;
aCharges[i].pProvider = NULL;
}
medigun_charge_types iMyCharge = m_pOuter->GetChargeEffectBeingProvided();
if ( iMyCharge != MEDIGUN_CHARGE_INVALID )
{
Assert( iMyCharge >= 0 && iMyCharge < MEDIGUN_NUM_CHARGE_TYPES );
aCharges[iMyCharge].bActive = true;
aCharges[iMyCharge].pProvider = m_pOuter;
}
// Loop through our medics and get all their charges
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
if ( !m_aHealers[i].pHealer )
continue;
CTFPlayer *pPlayer = ToTFPlayer( m_aHealers[i].pHealer );
if ( !pPlayer )
continue;
medigun_charge_types iCharge = pPlayer->GetChargeEffectBeingProvided();
if ( iCharge != MEDIGUN_CHARGE_INVALID )
{
Assert( iCharge >= 0 && iCharge < MEDIGUN_NUM_CHARGE_TYPES );
aCharges[iCharge].bActive = true;
aCharges[iCharge].pProvider = pPlayer;
}
}
if ( !CanRecieveMedigunChargeEffect( iMyCharge ) )
{
aCharges[MEDIGUN_CHARGE_INVULN].bActive = false;
}
SetChargeEffect( MEDIGUN_CHARGE_INVULN, aCharges[MEDIGUN_CHARGE_INVULN].bActive, bInstantRemove, g_MedigunEffects[ MEDIGUN_CHARGE_INVULN ], tf_invuln_time.GetFloat(), aCharges[MEDIGUN_CHARGE_INVULN].pProvider );
SetChargeEffect( MEDIGUN_CHARGE_CRITICALBOOST, aCharges[MEDIGUN_CHARGE_CRITICALBOOST].bActive, bInstantRemove, g_MedigunEffects[ MEDIGUN_CHARGE_CRITICALBOOST ], 0.0f, aCharges[MEDIGUN_CHARGE_CRITICALBOOST].pProvider );
SetChargeEffect( MEDIGUN_CHARGE_MEGAHEAL, aCharges[MEDIGUN_CHARGE_MEGAHEAL].bActive, bInstantRemove, g_MedigunEffects[ MEDIGUN_CHARGE_MEGAHEAL ], 0.0f, aCharges[MEDIGUN_CHARGE_MEGAHEAL].pProvider );
SetChargeEffect( MEDIGUN_CHARGE_BULLET_RESIST, aCharges[MEDIGUN_CHARGE_BULLET_RESIST].bActive, bInstantRemove, g_MedigunEffects[ MEDIGUN_CHARGE_BULLET_RESIST ], 0.0f, aCharges[MEDIGUN_CHARGE_BULLET_RESIST].pProvider );
SetChargeEffect( MEDIGUN_CHARGE_BLAST_RESIST, aCharges[MEDIGUN_CHARGE_BLAST_RESIST].bActive, bInstantRemove, g_MedigunEffects[ MEDIGUN_CHARGE_BLAST_RESIST ], 0.0f, aCharges[MEDIGUN_CHARGE_BLAST_RESIST].pProvider );
SetChargeEffect( MEDIGUN_CHARGE_FIRE_RESIST, aCharges[MEDIGUN_CHARGE_FIRE_RESIST].bActive, bInstantRemove, g_MedigunEffects[ MEDIGUN_CHARGE_FIRE_RESIST ], 0.0f, aCharges[MEDIGUN_CHARGE_FIRE_RESIST].pProvider );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::TestAndExpireChargeEffect( medigun_charge_types iCharge )
{
const MedigunEffects_t& effects = g_MedigunEffects[iCharge];
if ( InCond( effects.eCondition ) )
{
bool bRemoveEffect = false;
bool bGameInWinState = TFGameRules()->State_Get() == GR_STATE_TEAM_WIN;
bool bPlayerOnWinningTeam = TFGameRules()->GetWinningTeam() == m_pOuter->GetTeamNumber();
// Lose all charge effects in post-win state if we're the losing team
if ( bGameInWinState && !bPlayerOnWinningTeam )
{
bRemoveEffect = true;
}
if ( m_flChargeEffectOffTime[iCharge] )
{
if ( gpGlobals->curtime > m_flChargeEffectOffTime[iCharge] )
{
bRemoveEffect = true;
}
if (iCharge == MEDIGUN_CHARGE_CRITICALBOOST && ( bGameInWinState && bPlayerOnWinningTeam ) )
{
bRemoveEffect = false;
m_flChargeEffectOffTime[iCharge] = 0;
}
if ( GetRevengeCrits() > 0 && effects.eCondition == TF_COND_CRITBOOSTED )
{
// Don't remove while we have a weapon deployed that can consume revenge crits
CTFWeaponBase *pWeapon = m_pOuter->GetActiveTFWeapon();
if ( pWeapon && pWeapon->CanHaveRevengeCrits() )
bRemoveEffect = false;
}
}
// Check healers for possible usercommand invuln exploit
FOR_EACH_VEC( m_aHealers, i )
{
CTFPlayer *pTFHealer = ToTFPlayer( m_aHealers[i].pHealer );
if ( !pTFHealer )
continue;
CTFPlayer *pTFProvider = ToTFPlayer( GetConditionProvider( effects.eCondition ) );
if ( !pTFProvider )
continue;
if ( pTFProvider == pTFHealer && pTFHealer->GetTimeSinceLastUserCommand() > weapon_medigun_chargerelease_rate.GetFloat() + 1.f )
{
// Force remove uber and detach the medigun
bRemoveEffect = true;
pTFHealer->Weapon_Switch( pTFHealer->Weapon_GetSlot( TF_WPN_TYPE_MELEE ) );
}
}
if ( bRemoveEffect )
{
m_flChargeEffectOffTime[iCharge] = 0;
RemoveCond( effects.eCondition );
if ( effects.eWearingOffCondition != TF_COND_LAST )
{
RemoveCond( effects.eWearingOffCondition );
}
}
}
else if ( m_bChargeSoundEffectsOn[iCharge] )
{
if ( effects.pszChargeOnSound[0] )
{
m_pOuter->StopSound( effects.pszChargeOnSound );
}
m_bChargeSoundEffectsOn[iCharge] = false;
}
}
//-----------------------------------------------------------------------------
// Purpose: We've started a new charge effect
//-----------------------------------------------------------------------------
void CTFPlayerShared::SendNewInvulnGameEvent( void )
{
// for each medic healing me
for ( int i=0;i<m_aHealers.Count();i++ )
{
CTFPlayer *pMedic = ToTFPlayer( GetHealerByIndex(i) );
if ( !pMedic )
continue;
// ACHIEVEMENT_TF_MEDIC_CHARGE_FRIENDS
IGameEvent *event = gameeventmanager->CreateEvent( "player_invulned" );
if ( event )
{
event->SetInt( "userid", m_pOuter->GetUserID() );
event->SetInt( "medic_userid", pMedic->GetUserID() );
gameeventmanager->FireEvent( event );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetChargeEffect( medigun_charge_types iCharge, bool bState, bool bInstant, const MedigunEffects_t& effects, float flWearOffTime, CTFPlayer *pProvider /*= NULL*/ )
{
if ( effects.eCondition == TF_COND_CRITBOOSTED )
{
// Don't remove while we have a weapon deployed that can consume revenge crits
CTFWeaponBase *pWeapon = m_pOuter->GetActiveTFWeapon();
if ( pWeapon )
{
if ( pWeapon->CanHaveRevengeCrits() && GetRevengeCrits() > 0 )
{
return;
}
if ( pWeapon->HasLastShotCritical() )
{
return;
}
}
}
bool bCurrentState = InCond( effects.eCondition );
if ( bCurrentState == bState )
{
if ( bState && m_flChargeEffectOffTime[iCharge] )
{
m_flChargeEffectOffTime[iCharge] = 0;
if ( effects.eWearingOffCondition != TF_COND_LAST )
{
RemoveCond( effects.eWearingOffCondition );
}
SendNewInvulnGameEvent();
}
return;
}
// Avoid infinite duration, because... the internet.
float flMaxDuration = ( pProvider && pProvider->IsBot() ) ? PERMANENT_CONDITION : weapon_medigun_chargerelease_rate.GetFloat() + ( ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() ) ? 8.f : 1.f );
if ( bState )
{
if ( m_flChargeEffectOffTime[iCharge] )
{
m_pOuter->StopSound( effects.pszChargeOffSound );
m_flChargeEffectOffTime[iCharge] = 0;
if ( effects.eWearingOffCondition != TF_COND_LAST )
{
RemoveCond( effects.eWearingOffCondition );
}
}
// Invulnerable turning on
AddCond( effects.eCondition, flMaxDuration, pProvider );
SendNewInvulnGameEvent();
CSingleUserRecipientFilter filter( m_pOuter );
m_pOuter->EmitSound( filter, m_pOuter->entindex(), effects.pszChargeOnSound );
m_bChargeOffSounded = false;
m_bChargeSoundEffectsOn[iCharge] = true;
}
else
{
if ( m_bChargeSoundEffectsOn[iCharge] )
{
m_pOuter->StopSound( effects.pszChargeOnSound );
m_bChargeSoundEffectsOn[iCharge] = false;
}
if ( !m_flChargeEffectOffTime[iCharge] && !m_bChargeOffSounded )
{
// Make sure we don't have duplicate Off sounds playing
m_pOuter->StopSound( effects.pszChargeOffSound );
CSingleUserRecipientFilter filter( m_pOuter );
m_pOuter->EmitSound( filter, m_pOuter->entindex(), effects.pszChargeOffSound );
m_bChargeOffSounded = true;
}
if ( bInstant )
{
m_flChargeEffectOffTime[iCharge] = 0;
RemoveCond( effects.eCondition );
if ( effects.eWearingOffCondition != TF_COND_LAST )
{
RemoveCond( effects.eWearingOffCondition );
}
}
else
{
// We're already in the process of turning it off
if ( m_flChargeEffectOffTime[iCharge] )
return;
if ( effects.eWearingOffCondition != TF_COND_LAST )
{
AddCond( effects.eWearingOffCondition, PERMANENT_CONDITION, pProvider );
}
m_flChargeEffectOffTime[iCharge] = gpGlobals->curtime + flWearOffTime;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Collect currency packs in a radius around the scout
//-----------------------------------------------------------------------------
void CTFPlayerShared::RadiusCurrencyCollectionCheck( void )
{
if ( m_pOuter->GetTeamNumber() != TF_TEAM_PVE_DEFENDERS && TFGameRules()->IsMannVsMachineMode() )
return;
if ( !m_pOuter->IsAlive() )
return;
if ( m_flRadiusCurrencyCollectionTime > gpGlobals->curtime )
return;
bool bScout = m_pOuter->GetPlayerClass()->GetClassIndex() == TF_CLASS_SCOUT;
const int nRadiusSqr = bScout ? 288 * 288 : 72 * 72;
Vector vecPos = m_pOuter->GetAbsOrigin();
// NDebugOverlay::Sphere( vecPos, nRadius, 0, 255, 0, 40, 5 );
for ( int i = 0; i < ICurrencyPackAutoList::AutoList().Count(); ++i )
{
CCurrencyPack *pCurrencyPack = static_cast< CCurrencyPack* >( ICurrencyPackAutoList::AutoList()[i] );
if ( !pCurrencyPack )
continue;
if ( !pCurrencyPack->AffectedByRadiusCollection() )
continue;
if ( ( vecPos - pCurrencyPack->GetAbsOrigin() ).LengthSqr() > nRadiusSqr )
continue;
if ( pCurrencyPack->IsClaimed() )
continue;
if ( m_pOuter->FVisible( pCurrencyPack, MASK_OPAQUE ) == false )
continue;
if ( !pCurrencyPack->ValidTouch( m_pOuter ) )
continue;
// Currencypack's seek classes with a large collection radius
if ( bScout )
{
bool bFound = false;
FOR_EACH_VEC( m_CurrencyPacks, i )
{
pulledcurrencypacks_t packinfo = m_CurrencyPacks[i];
if ( packinfo.hPack == pCurrencyPack )
bFound = true;
}
if ( !bFound )
{
// Mark as claimed to prevent other players from grabbing
pCurrencyPack->SetClaimed();
pulledcurrencypacks_t packinfo;
packinfo.hPack = pCurrencyPack;
packinfo.flTime = gpGlobals->curtime + 1.f;
m_CurrencyPacks.AddToTail( packinfo );
}
}
else
{
pCurrencyPack->Touch( m_pOuter );
}
}
FOR_EACH_VEC_BACK( m_CurrencyPacks, i )
{
if ( m_CurrencyPacks[i].hPack )
{
// If the timeout hits, force a touch
if ( m_CurrencyPacks[i].flTime <= gpGlobals->curtime )
{
m_CurrencyPacks[i].hPack->Touch( m_pOuter );
}
else
{
// Seek the player
const float flForce = 550.0f;
Vector vToPlayer = m_pOuter->GetAbsOrigin() - m_CurrencyPacks[i].hPack->GetAbsOrigin();
vToPlayer.z = 0.0f;
vToPlayer.NormalizeInPlace();
vToPlayer.z = 0.25f;
Vector vPush = flForce * vToPlayer;
m_CurrencyPacks[i].hPack->RemoveFlag( FL_ONGROUND );
m_CurrencyPacks[i].hPack->ApplyAbsVelocityImpulse( vPush );
}
}
else
{
// Automatic clean-up
m_CurrencyPacks.Remove( i );
}
}
m_flRadiusCurrencyCollectionTime = bScout ? gpGlobals->curtime + 0.15f : gpGlobals->curtime + 0.25f;
}
//-----------------------------------------------------------------------------
// Purpose: Collect objects in a radius around the player
//-----------------------------------------------------------------------------
void CTFPlayerShared::RadiusHealthkitCollectionCheck( void )
{
if ( GetCarryingRuneType() != RUNE_PLAGUE )
return;
if ( !m_pOuter->IsAlive() )
return;
if ( m_flRadiusCurrencyCollectionTime > gpGlobals->curtime )
return;
const int nRadiusSqr = 600 * 600;
const Vector& vecPos = m_pOuter->WorldSpaceCenter();
// NDebugOverlay::Sphere( vecPos, 600, 0, 255, 0, false, 2.f );
for ( int i = 0; i < IHealthKitAutoList::AutoList().Count(); ++i )
{
CHealthKit *pHealthKit = static_cast<CHealthKit*>( IHealthKitAutoList::AutoList()[i] );
if ( !pHealthKit )
continue;
if ( ( vecPos - pHealthKit->GetAbsOrigin() ).LengthSqr() > nRadiusSqr )
continue;
if ( !pHealthKit->ValidTouch( m_pOuter ) )
continue;
if ( pHealthKit->IsEffectActive( EF_NODRAW ) )
continue;
pHealthKit->ItemTouch( m_pOuter );
}
m_flRadiusCurrencyCollectionTime = gpGlobals->curtime + 0.15f;
}
//-----------------------------------------------------------------------------
// Purpose: Scan for and reveal spies in a radius around the player
//-----------------------------------------------------------------------------
void CTFPlayerShared::RadiusSpyScan( void )
{
if ( m_pOuter->GetTeamNumber() != TF_TEAM_PVE_DEFENDERS )
return;
if ( !m_pOuter->IsAlive() )
return;
if ( m_flRadiusSpyScanTime <= gpGlobals->curtime )
{
// bool bRevealed = false;
const int iRange = 750;
CUtlVector<CTFPlayer *> vecPlayers;
CollectPlayers( &vecPlayers, TF_TEAM_PVE_INVADERS, true );
FOR_EACH_VEC( vecPlayers, i )
{
if ( !vecPlayers[i] )
continue;
if ( vecPlayers[i]->GetPlayerClass()->GetClassIndex() != TF_CLASS_SPY )
continue;
if ( !vecPlayers[i]->m_Shared.InCond( TF_COND_STEALTHED ) )
continue;
if ( m_pOuter->FVisible( vecPlayers[i], MASK_OPAQUE ) == false )
continue;
Vector vDist = vecPlayers[i]->GetAbsOrigin() - m_pOuter->GetAbsOrigin();
if ( vDist.LengthSqr() <= iRange * iRange )
{
vecPlayers[i]->m_Shared.OnSpyTouchedByEnemy();
// bRevealed = true;
}
}
// if ( bRevealed )
// {
// bRevealed = false;
// CSingleUserRecipientFilter filter( m_pOuter );
// m_pOuter->EmitSound( filter, m_pOuter->entindex(), "Recon.Ping" );
// }
m_flRadiusSpyScanTime = gpGlobals->curtime + 0.3f;
}
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::ApplyAttributeToPlayer( const char* pszAttribName, float flValue )
{
const CEconItemAttributeDefinition *pDef = GetItemSchema()->GetAttributeDefinitionByName( pszAttribName );
m_pOuter->GetAttributeList()->SetRuntimeAttributeValue( pDef, flValue );
m_pOuter->TeamFortress_SetSpeed();
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::RemoveAttributeFromPlayer( const char* pszAttribName )
{
const CEconItemAttributeDefinition *pDef = GetItemSchema()->GetAttributeDefinitionByName( pszAttribName );
m_pOuter->GetAttributeList()->RemoveAttribute( pDef );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::AddTmpDamageBonus( float flBonus, float flExpiration )
{
AddCond( TF_COND_TMPDAMAGEBONUS, flExpiration );
m_flTmpDamageBonusAmount += flBonus;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerShared::FindHealerIndex( CBaseEntity *pHealer )
{
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
if ( m_aHealers[i].pHealer == pHealer )
return i;
}
return m_aHealers.InvalidIndex();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayerShared::GetHealerByIndex( int index )
{
int iNumHealers = m_aHealers.Count();
if ( index < 0 || index >= iNumHealers )
return NULL;
return m_aHealers[index].pHealer;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::HealerIsDispenser( int index )
{
int iNumHealers = m_aHealers.Count();
if ( index < 0 || index >= iNumHealers )
return false;
return m_aHealers[index].bDispenserHeal;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the first healer in the healer array. Note that this
// is an arbitrary healer.
//-----------------------------------------------------------------------------
EHANDLE CTFPlayerShared::GetFirstHealer()
{
if ( m_aHealers.Count() > 0 )
return m_aHealers.Head().pHealer;
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: External code has decided that the trigger event for an achievement
// has occurred. Go through our data and give it to the right people.
//-----------------------------------------------------------------------------
void CTFPlayerShared::CheckForAchievement( int iAchievement )
{
if ( iAchievement == ACHIEVEMENT_TF_MEDIC_SAVE_TEAMMATE ||
(iAchievement == ACHIEVEMENT_TF_MEDIC_CHARGE_BLOCKER && InCond( TF_COND_INVULNERABLE ) ) )
{
// ACHIEVEMENT_TF_MEDIC_SAVE_TEAMMATE : We were just saved from death by invuln. See if any medics deployed
// their charge on us recently, and if so, give them the achievement.
// ACHIEVEMENT_TF_MEDIC_CHARGE_BLOCKER: We just blocked a capture, and we're invuln. Whoever's invulning us gets the achievement.
for ( int i = 0; i < m_aHealers.Count(); i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( m_aHealers[i].pHealer );
if ( !pPlayer )
continue;
if ( !pPlayer->IsPlayerClass(TF_CLASS_MEDIC) )
continue;
CTFWeaponBase *pWpn = pPlayer->GetActiveTFWeapon();
if ( !pWpn )
continue;
CWeaponMedigun *pMedigun = dynamic_cast<CWeaponMedigun*>(pWpn);
if ( pMedigun && pMedigun->IsReleasingCharge() )
{
// Save teammate requires us to have deployed the charge within the last second
if ( iAchievement != ACHIEVEMENT_TF_MEDIC_SAVE_TEAMMATE || (gpGlobals->curtime - pMedigun->GetReleaseStartedAt()) < 1.0 )
{
pPlayer->AwardAchievement( iAchievement );
}
}
}
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Get all of our conditions in a nice CBitVec
//-----------------------------------------------------------------------------
void CTFPlayerShared::GetConditionsBits( CBitVec< TF_COND_LAST >& vbConditions ) const
{
vbConditions.Set( 0u, (uint32)m_nPlayerCond );
vbConditions.Set( 1u, (uint32)m_nPlayerCondEx );
vbConditions.Set( 2u, (uint32)m_nPlayerCondEx2 );
vbConditions.Set( 3u, (uint32)m_nPlayerCondEx3 );
COMPILE_TIME_ASSERT( 32 + 32 + 32 + 32 > TF_COND_LAST );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFWeaponBase *CTFPlayerShared::GetActiveTFWeapon() const
{
return m_pOuter->GetActiveTFWeapon();
}
//-----------------------------------------------------------------------------
// Purpose: Team check.
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsAlly( CBaseEntity *pEntity )
{
return ( pEntity->GetTeamNumber() == m_pOuter->GetTeamNumber() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerShared::GetDesiredPlayerClassIndex( void )
{
return m_iDesiredPlayerClass;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetJumping( bool bJumping )
{
m_bJumping = bJumping;
}
void CTFPlayerShared::SetAirDash( int iAirDash )
{
m_iAirDash = iAirDash;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFPlayerShared::GetCritMult( void )
{
float flRemapCritMul = RemapValClamped( m_iCritMult, 0, 255, 1.0, 4.0 );
/*#ifdef CLIENT_DLL
Msg("CLIENT: Crit mult %.2f - %d\n",flRemapCritMul, m_iCritMult);
#else
Msg("SERVER: Crit mult %.2f - %d\n", flRemapCritMul, m_iCritMult );
#endif*/
return flRemapCritMul;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateCritMult( void )
{
const float flMinMult = 1.0;
const float flMaxMult = TF_DAMAGE_CRITMOD_MAXMULT;
if ( m_DamageEvents.Count() == 0 )
{
m_iCritMult = RemapValClamped( flMinMult, 1.0, 4.0, 0, 255 );
return;
}
//Msg( "Crit mult update for %s\n", m_pOuter->GetPlayerName() );
//Msg( " Entries: %d\n", m_DamageEvents.Count() );
// Go through the damage multipliers and remove expired ones, while summing damage of the others
float flTotalDamage = 0;
for ( int i = m_DamageEvents.Count() - 1; i >= 0; i-- )
{
float flDelta = gpGlobals->curtime - m_DamageEvents[i].flTime;
if ( flDelta > tf_damage_events_track_for.GetFloat() )
{
//Msg( " Discarded (%d: time %.2f, now %.2f)\n", i, m_DamageEvents[i].flTime, gpGlobals->curtime );
m_DamageEvents.Remove(i);
continue;
}
// Ignore damage we've just done. We do this so that we have time to get those damage events
// to the client in time for using them in prediction in this code.
if ( flDelta < TF_DAMAGE_CRITMOD_MINTIME )
{
//Msg( " Ignored (%d: time %.2f, now %.2f)\n", i, m_DamageEvents[i].flTime, gpGlobals->curtime );
continue;
}
if ( flDelta > TF_DAMAGE_CRITMOD_MAXTIME )
continue;
//Msg( " Added %.2f (%d: time %.2f, now %.2f)\n", m_DamageEvents[i].flDamage, i, m_DamageEvents[i].flTime, gpGlobals->curtime );
flTotalDamage += m_DamageEvents[i].flDamage * m_DamageEvents[i].flDamageCritScaleMultiplier;
}
float flMult = RemapValClamped( flTotalDamage, 0, TF_DAMAGE_CRITMOD_DAMAGE, flMinMult, flMaxMult );
// Msg( " TotalDamage: %.2f -> Mult %.2f\n", flTotalDamage, flMult );
m_iCritMult = (int)RemapValClamped( flMult, flMinMult, flMaxMult, 0, 255 );
}
#define CRIT_DAMAGE_TIME 0.1f
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::RecordDamageEvent( const CTakeDamageInfo &info, bool bKill, int nVictimPrevHealth )
{
if ( m_DamageEvents.Count() >= MAX_DAMAGE_EVENTS )
{
// Remove the oldest event
m_DamageEvents.Remove( m_DamageEvents.Count()-1 );
}
// Don't count critical damage toward the critical multiplier.
float flDamage = info.GetDamage() - info.GetDamageBonus();
float flDamageCriticalScale = info.GetDamageType() & DMG_DONT_COUNT_DAMAGE_TOWARDS_CRIT_RATE
? 0.0f
: 1.0f;
// cap the damage at our current health amount since it's going to kill us
if ( bKill && flDamage > nVictimPrevHealth )
{
flDamage = nVictimPrevHealth;
}
// Don't allow explosions to stack up damage toward the critical modifier.
bool bOverride = false;
if ( info.GetDamageType() & DMG_BLAST )
{
int nDamageCount = m_DamageEvents.Count();
for ( int iDamage = 0; iDamage < nDamageCount; ++iDamage )
{
// Was the older event I am checking against an explosion as well?
if ( m_DamageEvents[iDamage].nDamageType & DMG_BLAST )
{
// Did it happen very recently?
if ( ( gpGlobals->curtime - m_DamageEvents[iDamage].flTime ) < CRIT_DAMAGE_TIME )
{
if ( bKill )
{
m_DamageEvents[iDamage].nKills++;
if ( m_pOuter->IsPlayerClass( TF_CLASS_DEMOMAN ) )
{
// Make sure the previous & the current are stickybombs, and go with it.
if ( m_DamageEvents[iDamage].nDamageType == info.GetDamageType() &&
m_DamageEvents[iDamage].nDamageType == g_aWeaponDamageTypes[TF_WEAPON_PIPEBOMBLAUNCHER] )
{
if ( TFGameRules()->IsMannVsMachineMode() && m_DamageEvents[iDamage].nKills >= 10 )
{
m_pOuter->AwardAchievement( ACHIEVEMENT_TF_MVM_DEMO_GROUP_KILL );
}
else if ( m_DamageEvents[iDamage].nKills >= 3 )
{
m_pOuter->AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_KILL3_WITH_DETONATION );
}
}
}
}
// Take the max damage done in the time frame.
if ( flDamage > m_DamageEvents[iDamage].flDamage )
{
m_DamageEvents[iDamage].flDamage = flDamage;
m_DamageEvents[iDamage].flDamageCritScaleMultiplier = flDamageCriticalScale;
m_DamageEvents[iDamage].flTime = gpGlobals->curtime;
m_DamageEvents[iDamage].nDamageType = info.GetDamageType();
// Msg( "Update Damage Event: D:%f, T:%f\n", m_DamageEvents[iDamage].flDamage, m_DamageEvents[iDamage].flTime );
}
bOverride = true;
}
}
}
}
// We overrode a value, don't add this to the list.
if ( bOverride )
return;
int iIndex = m_DamageEvents.AddToTail();
m_DamageEvents[iIndex].flDamage = flDamage;
m_DamageEvents[iIndex].flDamageCritScaleMultiplier = flDamageCriticalScale;
m_DamageEvents[iIndex].nDamageType = info.GetDamageType();
m_DamageEvents[iIndex].flTime = gpGlobals->curtime;
m_DamageEvents[iIndex].nKills = bKill;
// Msg( "Damage Event: D:%f, T:%f\n", m_DamageEvents[iIndex].flDamage, m_DamageEvents[iIndex].flTime );
if ( TFGameRules()->IsMannVsMachineMode() && m_pOuter->IsPlayerClass( TF_CLASS_SNIPER ) )
{
int nKillCount = 0;
int nDamageCount = m_DamageEvents.Count();
for ( int iDamage = 0; iDamage < nDamageCount; ++iDamage )
{
// Did it happen very recently?
if ( ( gpGlobals->curtime - m_DamageEvents[iDamage].flTime ) < CRIT_DAMAGE_TIME )
{
nKillCount += m_DamageEvents[iDamage].nKills;
}
}
if ( nKillCount >= 4 )
{
m_pOuter->AwardAchievement( ACHIEVEMENT_TF_MVM_SNIPER_KILL_GROUP );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::AddTempCritBonus( float flAmount )
{
if ( m_DamageEvents.Count() >= MAX_DAMAGE_EVENTS )
{
// Remove the oldest event
m_DamageEvents.Remove( m_DamageEvents.Count()-1 );
}
int iIndex = m_DamageEvents.AddToTail();
m_DamageEvents[iIndex].flDamage = RemapValClamped( flAmount, 0, 1, 0, TF_DAMAGE_CRITMOD_DAMAGE ) / (TF_DAMAGE_CRITMOD_MAXMULT - 1.0);
m_DamageEvents[iIndex].flDamageCritScaleMultiplier = 1.0f;
m_DamageEvents[iIndex].nDamageType = DMG_GENERIC;
m_DamageEvents[iIndex].flTime = gpGlobals->curtime;
m_DamageEvents[iIndex].nKills = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerShared::GetNumKillsInTime( float flTime )
{
if ( tf_damage_events_track_for.GetFloat() < flTime )
{
Warning("Player asking for damage events for time %.0f, but tf_damage_events_track_for is only tracking events for %.0f\n", flTime, tf_damage_events_track_for.GetFloat() );
}
int iKills = 0;
for ( int i = m_DamageEvents.Count() - 1; i >= 0; i-- )
{
float flDelta = gpGlobals->curtime - m_DamageEvents[i].flTime;
if ( flDelta < flTime )
{
iKills += m_DamageEvents[i].nKills;
}
}
return iKills;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::AddToSpyCloakMeter( float val, bool bForce )
{
CTFWeaponInvis *pWpn = (CTFWeaponInvis *) m_pOuter->Weapon_OwnsThisID( TF_WEAPON_INVIS );
if ( !pWpn )
return false;
// STAGING_SPY
// Special cloaks only get cloak if not active and receive a smaller portion
int iNoCloakedPickup = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWpn, iNoCloakedPickup, NoCloakWhenCloaked );
if ( !bForce )
{
if ( InCond( TF_COND_STEALTHED ) && iNoCloakedPickup )
{
return false;
}
else
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWpn, val, ReducedCloakFromAmmo );
}
}
bool bResult = ( val > 0 && m_flCloakMeter < 100.0f );
m_flCloakMeter = clamp( m_flCloakMeter + val, 0.0f, 100.0f );
return bResult;
}
#endif
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Stun & Snare Application
//-----------------------------------------------------------------------------
void CTFPlayerShared::StunPlayer( float flTime, float flReductionAmount, int iStunFlags, CTFPlayer* pAttacker )
{
// Insanity prevention
if ( ( m_PlayerStuns.Count() + 1 ) >= 250 )
return;
if ( InCond( TF_COND_PHASE ) || InCond( TF_COND_PASSTIME_INTERCEPTION ) )
return;
if ( InCond( TF_COND_MEGAHEAL ) )
return;
if ( InCond( TF_COND_INVULNERABLE_HIDE_UNLESS_DAMAGED ) && !InCond( TF_COND_MVM_BOT_STUN_RADIOWAVE ) )
return;
if ( pAttacker && TFGameRules() && TFGameRules()->IsTruceActive() && pAttacker->IsTruceValidForEnt() )
{
if ( ( pAttacker->GetTeamNumber() == TF_TEAM_RED ) || ( pAttacker->GetTeamNumber() == TF_TEAM_BLUE ) )
return;
}
float flRemapAmount = RemapValClamped( flReductionAmount, 0.0, 1.0, 0, 255 );
int iOldStunFlags = GetStunFlags();
// Already stunned
bool bStomp = false;
if ( InCond( TF_COND_STUNNED ) )
{
if ( GetActiveStunInfo() )
{
// Is it stronger than the active?
if ( flRemapAmount > GetActiveStunInfo()->flStunAmount || iStunFlags & TF_STUN_CONTROLS || iStunFlags & TF_STUN_LOSER_STATE )
{
bStomp = true;
}
// It's weaker. Would it expire before the active?
else if ( gpGlobals->curtime + flTime < GetActiveStunInfo()->flExpireTime )
{
// Ignore
return;
}
}
}
else if ( GetActiveStunInfo() )
{
// Something yanked our TF_COND_STUNNED in an unexpected way
if ( !HushAsserts() )
Assert( !"Something yanked out TF_COND_STUNNED." );
m_PlayerStuns.RemoveAll();
return;
}
// Add it to the stack
stun_struct_t stunEvent =
{
pAttacker, // hPlayer
flTime, // flDuration
gpGlobals->curtime + flTime, // flExpireTime
gpGlobals->curtime + flTime, // flStartFadeTime
flRemapAmount, // flStunAmount
iStunFlags // iStunFlags
};
// Should this become the active stun?
if ( bStomp || !GetActiveStunInfo() )
{
// If stomping, see if the stun we're replacing has a stronger slow.
// This can happen when stuns use TF_STUN_CONTROLS or TF_STUN_LOSER_STATE.
float flOldStun = GetActiveStunInfo() ? GetActiveStunInfo()->flStunAmount : 0.f;
m_iStunIndex = m_PlayerStuns.AddToTail( stunEvent );
if ( flOldStun > flRemapAmount )
{
GetActiveStunInfo()->flStunAmount = flOldStun;
}
}
else
{
// Done for now
m_PlayerStuns.AddToTail( stunEvent );
return;
}
// Add in extra time when TF_STUN_CONTROLS
if ( GetActiveStunInfo()->iStunFlags & TF_STUN_CONTROLS )
{
if ( !InCond( TF_COND_HALLOWEEN_KART ) )
{
GetActiveStunInfo()->flExpireTime += CONTROL_STUN_ANIM_TIME;
}
}
GetActiveStunInfo()->flStartFadeTime = gpGlobals->curtime + GetActiveStunInfo()->flDuration;
// Update old system for networking
UpdateLegacyStunSystem();
if ( GetActiveStunInfo()->iStunFlags & TF_STUN_CONTROLS || GetActiveStunInfo()->iStunFlags & TF_STUN_LOSER_STATE )
{
m_pOuter->m_angTauntCamera = m_pOuter->EyeAngles();
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_STUNNED );
if ( pAttacker )
{
pAttacker->SpeakConceptIfAllowed( MP_CONCEPT_STUNNED_TARGET );
}
}
if ( !( GetActiveStunInfo()->iStunFlags & TF_STUN_NO_EFFECTS ) )
{
m_pOuter->StunSound( pAttacker, GetActiveStunInfo()->iStunFlags, iOldStunFlags );
}
// Event for achievements.
IGameEvent *event = gameeventmanager->CreateEvent( "player_stunned" );
if ( event )
{
if ( pAttacker )
{
event->SetInt( "stunner", pAttacker->GetUserID() );
}
event->SetInt( "victim", m_pOuter->GetUserID() );
event->SetBool( "victim_capping", m_pOuter->IsCapturingPoint() );
event->SetBool( "big_stun", ( GetActiveStunInfo()->iStunFlags & TF_STUN_SPECIAL_SOUND ) != 0 );
gameeventmanager->FireEvent( event );
}
// Clear off all taunts, expressions, and scenes.
if ( ( GetActiveStunInfo()->iStunFlags & TF_STUN_CONTROLS) == TF_STUN_CONTROLS || ( GetActiveStunInfo()->iStunFlags & TF_STUN_LOSER_STATE) == TF_STUN_LOSER_STATE )
{
m_pOuter->StopTaunt();
m_pOuter->ClearExpression();
m_pOuter->ClearWeaponFireScene();
}
AddCond( TF_COND_STUNNED, -1.f, pAttacker );
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Returns the intensity of the current stun effect, if we have the type of stun indicated.
//-----------------------------------------------------------------------------
float CTFPlayerShared::GetAmountStunned( int iStunFlags )
{
if ( GetActiveStunInfo() )
{
if ( InCond( TF_COND_STUNNED ) && ( iStunFlags & GetActiveStunInfo()->iStunFlags ) && ( GetActiveStunInfo()->flExpireTime > gpGlobals->curtime ) )
return MIN( MAX( GetActiveStunInfo()->flStunAmount, 0 ), 255 ) * ( 1.f/255.f );
}
return 0.f;
}
//-----------------------------------------------------------------------------
// Purpose: Indicates that our controls are stunned.
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsControlStunned( void )
{
if ( GetActiveStunInfo() )
{
if ( InCond( TF_COND_STUNNED ) && ( m_iStunFlags & TF_STUN_CONTROLS ) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Indicates that our controls are stunned.
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsLoserStateStunned( void ) const
{
if ( GetActiveStunInfo() )
{
if ( InCond( TF_COND_STUNNED ) && ( m_iStunFlags & TF_STUN_LOSER_STATE ) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Indicates that our movement is slowed, but our controls are still free.
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsSnared( void )
{
if ( InCond( TF_COND_STUNNED ) && !IsControlStunned() )
return true;
else
return false;
}
//=============================================================================
//
// Shared player code that isn't CTFPlayerShared
//
//-----------------------------------------------------------------------------
struct penetrated_target_list
{
CBaseEntity *pTarget;
float flDistanceFraction;
};
//-----------------------------------------------------------------------------
class CBulletPenetrateEnum : public IEntityEnumerator
{
public:
CBulletPenetrateEnum( Ray_t *pRay, CBaseEntity *pShooter, int nCustomDamageType, bool bIgnoreTeammates = true )
{
m_pRay = pRay;
m_pShooter = pShooter;
m_nCustomDamageType = nCustomDamageType;
m_bIgnoreTeammates = bIgnoreTeammates;
}
// We need to sort the penetrated targets into order, with the closest target first
class PenetratedTargetLess
{
public:
bool Less( const penetrated_target_list &src1, const penetrated_target_list &src2, void *pCtx )
{
return src1.flDistanceFraction < src2.flDistanceFraction;
}
};
virtual bool EnumEntity( IHandleEntity *pHandleEntity )
{
trace_t tr;
CBaseEntity *pEnt = static_cast<CBaseEntity*>(pHandleEntity);
// Ignore collisions with the shooter
if ( pEnt == m_pShooter )
return true;
if ( pEnt->IsCombatCharacter() || pEnt->IsBaseObject() )
{
if ( m_bIgnoreTeammates && pEnt->GetTeam() == m_pShooter->GetTeam() )
return true;
enginetrace->ClipRayToEntity( *m_pRay, MASK_SOLID | CONTENTS_HITBOX, pHandleEntity, &tr );
if (tr.fraction < 1.0f)
{
penetrated_target_list newEntry;
newEntry.pTarget = pEnt;
newEntry.flDistanceFraction = tr.fraction;
m_Targets.Insert( newEntry );
return true;
}
}
return true;
}
public:
Ray_t *m_pRay;
int m_nCustomDamageType;
CBaseEntity *m_pShooter;
bool m_bIgnoreTeammates;
CUtlSortVector<penetrated_target_list, PenetratedTargetLess> m_Targets;
};
CTargetOnlyFilter::CTargetOnlyFilter( CBaseEntity *pShooter, CBaseEntity *pTarget )
: CTraceFilterSimple( pShooter, COLLISION_GROUP_NONE )
{
m_pShooter = pShooter;
m_pTarget = pTarget;
}
bool CTargetOnlyFilter::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
CBaseEntity *pEnt = static_cast<CBaseEntity*>(pHandleEntity);
if ( pEnt && pEnt == m_pTarget )
return true;
else if ( !pEnt || pEnt != m_pTarget )
{
// If we hit a solid piece of the world, we're done.
if ( pEnt->IsBSPModel() && pEnt->IsSolid() )
return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
return false;
}
else
return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input: info
// bDoEffects - effects (blood, etc.) should only happen client-side.
//-----------------------------------------------------------------------------
void CTFPlayer::MaybeDrawRailgunBeam( IRecipientFilter *pFilter, CTFWeaponBase *pWeapon, const Vector& vStartPos, const Vector& vEndPos )
{
#ifdef GAME_DLL
Assert( pFilter );
#else // !GAME_DLL
Assert( !pFilter );
#endif
Assert( pWeapon );
int iShouldFireTracer = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iShouldFireTracer, sniper_fires_tracer );
if ( !iShouldFireTracer )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iShouldFireTracer, sniper_fires_tracer_HIDDEN );
}
// Check for heatmaker
if ( !iShouldFireTracer )
{
iShouldFireTracer = m_Shared.InCond( TF_COND_SNIPERCHARGE_RAGE_BUFF ) && pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() );
}
if ( iShouldFireTracer )
{
const char *pParticleSystemName = pWeapon->GetTeamNumber() == TF_TEAM_BLUE ? "dxhr_sniper_rail_blue" : "dxhr_sniper_rail_red";
CTFSniperRifle *pRifle = dynamic_cast< CTFSniperRifle* >( pWeapon );
if ( pRifle && ( pRifle->GetRifleType() == RIFLE_CLASSIC ) )
{
pParticleSystemName = "tfc_sniper_distortion_trail";
}
#ifdef GAME_DLL
te_tf_particle_effects_control_point_t controlPoint = { PATTACH_WORLDORIGIN, vEndPos };
TE_TFParticleEffectComplex( *pFilter, 0.0f, pParticleSystemName, vStartPos, QAngle( 0, 0, 0 ), NULL, &controlPoint, pWeapon, PATTACH_CUSTOMORIGIN );
#else // !GAME_DLL
CSmartPtr<CNewParticleEffect> pEffect = pWeapon->ParticleProp()->Create( pParticleSystemName, PATTACH_CUSTOMORIGIN, 0 );
if ( pEffect.IsValid() && pEffect->IsValid() )
{
pEffect->SetSortOrigin( vStartPos );
pEffect->SetControlPoint( 0, vStartPos );
pEffect->SetControlPoint( 1, vEndPos );
}
#endif // GAME_DLL
}
}
void CTFPlayer::GetHorriblyHackedRailgunPosition( const Vector& vStart, Vector *out_pvStartPos )
{
Assert( out_pvStartPos != NULL );
// DO NOT LOOK BEHIND THE MAGIC CURTAIN
Vector vForward, vRight, vUp;
AngleVectors( EyeAngles(), &vForward, &vRight, &vUp );
*out_pvStartPos = vStart
+ (vForward * 60.9f)
+ (vRight * 13.1f)
+ (vUp * -15.1f);
}
static bool OnOpposingTFTeams( int iTeam0, int iTeam1 )
{
// This logic is weird because we want to make sure that we're actually shooting someone on the
// other team, not just someone on a different team. This prevents weirdness where we count shooting
// the BSP as an enemy because they aren't on our team.
if ( iTeam0 == TF_TEAM_BLUE ) // if we're on the blue team...
return iTeam1 == TF_TEAM_RED; // ...and we shot someone on the red team, then we're opposing.
if ( iTeam0 == TF_TEAM_RED ) // if we're on the blue team...
return iTeam1 == TF_TEAM_BLUE; // ...and we shot someone on the red team, then we're opposing.
return iTeam0 != iTeam1; // if we're neither red nor blue, then anyone different from us is opposing
}
#ifdef GAME_DLL
extern void ExtinguishPlayer( CEconEntity *pExtinguisher, CTFPlayer *pOwner, CTFPlayer *pTarget, const char *pExtinguisherName );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::ModifyDamageInfo( CTakeDamageInfo *pInfo, const CBaseEntity *pTarget )
{
if ( pInfo && pTarget )
{
// Increased damage vs sentry's target?
if ( IsPlayerClass( TF_CLASS_ENGINEER ) )
{
float flDamageMod = 1.f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetActiveWeapon(), flDamageMod, mult_dmg_bullet_vs_sentry_target );
if ( flDamageMod > 1.f )
{
CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>( GetObjectOfType( OBJ_SENTRYGUN ) );
if ( pSentry && ( pSentry->GetTarget() == pTarget ) )
{
pInfo->SetDamage( pInfo->GetDamage() * flDamageMod );
}
}
}
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::FireBullet( CTFWeaponBase *pWpn, const FireBulletsInfo_t &info, bool bDoEffects, int nDamageType, int nCustomDamageType /*= TF_DMG_CUSTOM_NONE*/ )
{
// Fire a bullet (ignoring the shooter).
Vector vecStart = info.m_vecSrc;
Vector vecEnd = vecStart + info.m_vecDirShooting * info.m_flDistance;
trace_t trace;
ETFDmgCustom ePenetrateType = pWpn ? pWpn->GetPenetrateType() : TF_DMG_CUSTOM_NONE;
if ( ePenetrateType == TF_DMG_CUSTOM_NONE )
{
ePenetrateType = (ETFDmgCustom)nCustomDamageType;
}
Ray_t ray;
ray.Init( vecStart, vecEnd );
// Ignore teammates and their (physical) upgrade items when shooting in MvM
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
{
CTraceFilterIgnoreFriendlyCombatItems traceFilter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID | CONTENTS_HITBOX, &traceFilter, &trace );
}
else
{
UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID | CONTENTS_HITBOX, this, COLLISION_GROUP_NONE, &trace );
}
#ifndef CLIENT_DLL
CUtlVector<CBaseEntity *> vecTracedEntities;
bool bPenetratingShot = ( (ePenetrateType == TF_DMG_CUSTOM_PENETRATE_ALL_PLAYERS) || (ePenetrateType == TF_DMG_CUSTOM_PENETRATE_MY_TEAM) || (ePenetrateType == TF_DMG_CUSTOM_PENETRATE_NONBURNING_TEAMMATE) );
if ( bPenetratingShot && trace.m_pEnt )
{
if ( trace.m_pEnt->IsCombatCharacter() || trace.m_pEnt->IsBaseObject() )
{
// Penetrating shot: Strikes everything along the bullet's path.
CBulletPenetrateEnum bulletpenetrate( &ray, this, ePenetrateType, ePenetrateType == TF_DMG_CUSTOM_PENETRATE_MY_TEAM );
enginetrace->EnumerateEntities( ray, false, &bulletpenetrate );
FOR_EACH_VEC( bulletpenetrate.m_Targets, i )
{
vecTracedEntities.AddToTail( bulletpenetrate.m_Targets[i].pTarget );
}
}
else
{
// We traced into something we don't understand (sticky bomb? pumpkin bomb?) -- just apply our
// hit logic to whatever we traced first.
vecTracedEntities.AddToTail( trace.m_pEnt );
}
}
else
#endif
{
ePenetrateType = TF_DMG_CUSTOM_NONE;
}
#ifndef CLIENT_DLL
CTakeDamageInfo dmgInfo( this, info.m_pAttacker, info.m_flDamage, nDamageType );
dmgInfo.SetWeapon( GetActiveWeapon() );
dmgInfo.SetDamageCustom( nCustomDamageType );
int iPenetratedPlayerCount = 0;
int iEnemyPlayersHit = 0;
if ( bPenetratingShot )
{
int iChargedPenetration = 0;
CALL_ATTRIB_HOOK_INT( iChargedPenetration, sniper_penetrate_players_when_charged );
int iPenetrationLimit = 0;
CALL_ATTRIB_HOOK_INT( iPenetrationLimit, projectile_penetration );
// Damage every enemy player struck by the bullet along its path.
trace_t pen_trace;
FOR_EACH_VEC( vecTracedEntities, i )
{
// Limit the number of pen targets in MvM if we're not charge-based
if ( TFGameRules()->IsMannVsMachineMode() && iChargedPenetration == 0 )
{
// For sniper class, treat iPenetrationLimit as a bool
bool bIsSniper = IsPlayerClass( TF_CLASS_SNIPER );
if ( bIsSniper && iPenetrationLimit == 0 && iPenetratedPlayerCount > 0 )
break;
if ( !bIsSniper && iPenetratedPlayerCount > iPenetrationLimit )
break;
}
CBaseEntity *pTarget = vecTracedEntities[i];
if ( !pTarget )
continue;
trace_t *pTraceToUse = &pen_trace;
if ( ePenetrateType == TF_DMG_CUSTOM_PENETRATE_MY_TEAM )
{
// Skip friendlies if we're looking for the first enemy
if ( GetTeamNumber() == pTarget->GetTeamNumber() )
continue;
pTraceToUse = &trace;
}
else if ( ePenetrateType == TF_DMG_CUSTOM_PENETRATE_NONBURNING_TEAMMATE )
{
if ( GetTeamNumber() == pTarget->GetTeamNumber() )
{
if ( pTarget->IsPlayer() )
{
// skip friendlies that are not on burning
CTFPlayer *pTeammate = ToTFPlayer( pTarget );
if ( !pTeammate->m_Shared.InCond( TF_COND_BURNING ) )
continue;
}
}
pTraceToUse = &trace;
}
CTargetOnlyFilter penetrateFilter( this, pTarget );
UTIL_TraceLine( vecStart, vecEnd, (MASK_SOLID|CONTENTS_HITBOX), &penetrateFilter, pTraceToUse );
if ( pTraceToUse->m_pEnt == pTarget )
{
CTFPlayer *pTargetPlayer = NULL;
if ( pTarget->IsPlayer() )
pTargetPlayer = ToTFPlayer( pTarget );
// put out fire for burning teammate
if ( nCustomDamageType == TF_DMG_CUSTOM_PENETRATE_NONBURNING_TEAMMATE )
{
if ( pTargetPlayer && GetTeamNumber() == pTargetPlayer->GetTeamNumber() && pTargetPlayer->m_Shared.InCond( TF_COND_BURNING ) )
{
ExtinguishPlayer( GetActiveWeapon(), ToTFPlayer( GetActiveWeapon()->GetOwner() ), pTargetPlayer, GetActiveWeapon()->GetName() );
}
}
ModifyDamageInfo( &dmgInfo, pTarget );
CalculateBulletDamageForce( &dmgInfo, info.m_iAmmoType, info.m_vecDirShooting, pTraceToUse->endpos, 1.0 );
dmgInfo.SetPlayerPenetrationCount( iPenetratedPlayerCount );
pTarget->DispatchTraceAttack( dmgInfo, info.m_vecDirShooting, pTraceToUse, GetActiveWeapon() ? GetActiveWeapon()->GetDmgAccumulator() : NULL );
const bool bIsPenetratingPlayer = pTargetPlayer != NULL;
if ( bIsPenetratingPlayer )
{
iPenetratedPlayerCount++;
float flPenetrationPenalty = 1.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWpn, flPenetrationPenalty, penetration_damage_penalty );
dmgInfo.SetDamage( dmgInfo.GetDamage() * flPenetrationPenalty );
}
// If we're only supposed to penetrate players and this thing isn't a player, stop here.
if ( !bIsPenetratingPlayer && (ePenetrateType == TF_DMG_CUSTOM_PENETRATE_ALL_PLAYERS) )
break;
}
else
{
// We hit something solid that said we should stop tracing.
break;
}
if( pTarget->IsPlayer() && OnOpposingTFTeams( GetTeamNumber(), pTarget->GetTeamNumber() ) )
{
iEnemyPlayersHit++;
}
// If we're penetrating team mates, but we've just hit an enemy, we're done.
if ( ePenetrateType == TF_DMG_CUSTOM_PENETRATE_MY_TEAM )
break;
// just hit an enemy or a burning teammate
if ( ePenetrateType == TF_DMG_CUSTOM_PENETRATE_NONBURNING_TEAMMATE )
break;
}
}
else
{
// Damage only the first entity encountered on the bullet's path.
if ( trace.m_pEnt )
{
ModifyDamageInfo( &dmgInfo, trace.m_pEnt );
CalculateBulletDamageForce( &dmgInfo, info.m_iAmmoType, info.m_vecDirShooting, trace.endpos, 1.0 );
trace.m_pEnt->DispatchTraceAttack( dmgInfo, info.m_vecDirShooting, &trace );
if ( trace.m_pEnt->IsPlayer() && OnOpposingTFTeams( GetTeamNumber(), trace.m_pEnt->GetTeamNumber() ) )
{
iEnemyPlayersHit++;
}
}
}
if ( pWpn )
{
pWpn->OnBulletFire( iEnemyPlayersHit );
if ( iEnemyPlayersHit )
{ // Guarantee that the bullet that hit an enemy trumps the player viewangles
// that are locked in for the duration of the server simulation ticks
m_iLockViewanglesTickNumber = gpGlobals->tickcount;
m_qangLockViewangles = pl.v_angle;
}
}
#endif
#ifdef GAME_DLL
#ifdef _DEBUG
if ( tf_debug_bullets.GetBool() )
{
NDebugOverlay::Line( vecStart, trace.endpos, 0,255,0, true, 30 );
}
#endif // _DEBUG
#endif
if ( trace.fraction < 1.0 )
{
// Verify we have an entity at the point of impact.
Assert( trace.m_pEnt );
#ifdef GAME_DLL
// We intentionally do this logic here outside our client-side "should we do effects?" logic. We send this
// to everyone except our local owner (ourself) as we'll do our own fire effects below.
Vector vMuzzleOrigin;
if ( pWpn )
{
Vector vStartPos;
GetHorriblyHackedRailgunPosition( trace.startpos, &vStartPos );
CBroadcastNonOwnerRecipientFilter filter( this );
MaybeDrawRailgunBeam( &filter, pWpn, vStartPos, trace.endpos );
}
#endif // GAME_DLL
if ( bDoEffects )
{
// If shot starts out of water and ends in water
if ( !( enginetrace->GetPointContents( trace.startpos ) & ( CONTENTS_WATER | CONTENTS_SLIME ) ) &&
( enginetrace->GetPointContents( trace.endpos ) & ( CONTENTS_WATER | CONTENTS_SLIME ) ) )
{
// Water impact effects.
ImpactWaterTrace( trace, vecStart );
}
else
{
// Regular impact effects.
// don't decal your teammates or objects on your team
if ( trace.m_pEnt && trace.m_pEnt->GetTeamNumber() != GetTeamNumber() )
{
UTIL_ImpactTrace( &trace, nDamageType );
}
}
#ifdef CLIENT_DLL
if ( pWpn )
{
Vector vStartPos;
GetHorriblyHackedRailgunPosition( trace.startpos, &vStartPos );
MaybeDrawRailgunBeam( NULL, pWpn, vStartPos, trace.endpos );
}
static int tracerCount;
if ( ( ( info.m_iTracerFreq != 0 ) && ( tracerCount++ % info.m_iTracerFreq ) == 0 ) || (ePenetrateType == TF_DMG_CUSTOM_PENETRATE_ALL_PLAYERS) )
{
// if this is a local player, start at attachment on view model
// else start on attachment on weapon model
int iUseAttachment = TRACER_DONT_USE_ATTACHMENT;
int iAttachment = 1;
{
C_BaseCombatWeapon *pWeapon = GetActiveWeapon();
if ( pWeapon )
{
iAttachment = pWeapon->LookupAttachment( "muzzle" );
}
}
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
bool bInToolRecordingMode = clienttools->IsInRecordingMode();
// If we're using a viewmodel, override vecStart with the muzzle of that - just for the visual effect, not gameplay.
if ( ( pLocalPlayer != NULL ) && !pLocalPlayer->ShouldDrawThisPlayer() && !bInToolRecordingMode && pWpn )
{
C_BaseAnimating *pAttachEnt = pWpn->GetAppropriateWorldOrViewModel();
if ( pAttachEnt != NULL )
{
pAttachEnt->GetAttachment( iAttachment, vecStart );
}
}
else if ( !IsDormant() )
{
// fill in with third person weapon model index
C_BaseCombatWeapon *pWeapon = GetActiveWeapon();
if( pWeapon )
{
int nModelIndex = pWeapon->GetModelIndex();
int nWorldModelIndex = pWeapon->GetWorldModelIndex();
if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
{
pWeapon->SetModelIndex( nWorldModelIndex );
}
pWeapon->GetAttachment( iAttachment, vecStart );
if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
{
pWeapon->SetModelIndex( nModelIndex );
}
}
}
if ( tf_useparticletracers.GetBool() )
{
const char *pszTracerEffect = GetTracerType();
if ( pszTracerEffect && pszTracerEffect[0] )
{
char szTracerEffect[128];
if ( nDamageType & DMG_CRITICAL )
{
Q_snprintf( szTracerEffect, sizeof(szTracerEffect), "%s_crit", pszTracerEffect );
pszTracerEffect = szTracerEffect;
}
UTIL_ParticleTracer( pszTracerEffect, vecStart, trace.endpos, entindex(), iUseAttachment, true );
}
}
else
{
UTIL_Tracer( vecStart, trace.endpos, entindex(), iUseAttachment, 5000, true, GetTracerType() );
}
}
#endif
}
}
}
#ifdef CLIENT_DLL
static ConVar tf_impactwatertimeenable( "tf_impactwatertimeenable", "0", FCVAR_CHEAT, "Draw impact debris effects." );
static ConVar tf_impactwatertime( "tf_impactwatertime", "1.0f", FCVAR_CHEAT, "Draw impact debris effects." );
#endif
//-----------------------------------------------------------------------------
// Purpose: Trace from the shooter to the point of impact (another player,
// world, etc.), but this time take into account water/slime surfaces.
// Input: trace - initial trace from player to point of impact
// vecStart - starting point of the trace
//-----------------------------------------------------------------------------
void CTFPlayer::ImpactWaterTrace( trace_t &trace, const Vector &vecStart )
{
#ifdef CLIENT_DLL
if ( tf_impactwatertimeenable.GetBool() )
{
if ( m_flWaterImpactTime > gpGlobals->curtime )
return;
}
#endif
trace_t traceWater;
UTIL_TraceLine( vecStart, trace.endpos, ( MASK_SHOT | CONTENTS_WATER | CONTENTS_SLIME ),
this, COLLISION_GROUP_NONE, &traceWater );
if( traceWater.fraction < 1.0f )
{
CEffectData data;
data.m_vOrigin = traceWater.endpos;
data.m_vNormal = traceWater.plane.normal;
data.m_flScale = random->RandomFloat( 8, 12 );
if ( traceWater.contents & CONTENTS_SLIME )
{
data.m_fFlags |= FX_WATER_IN_SLIME;
}
const char *pszEffectName = "tf_gunshotsplash";
CTFWeaponBase *pWeapon = GetActiveTFWeapon();
if ( pWeapon && ( TF_WEAPON_MINIGUN == pWeapon->GetWeaponID() ) )
{
// for the minigun, use a different, cheaper splash effect because it can create so many of them
pszEffectName = "tf_gunshotsplash_minigun";
}
DispatchEffect( pszEffectName, data );
#ifdef CLIENT_DLL
if ( tf_impactwatertimeenable.GetBool() )
{
m_flWaterImpactTime = gpGlobals->curtime + tf_impactwatertime.GetFloat();
}
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFWeaponBase *CTFPlayer::GetActiveTFWeapon( void ) const
{
CBaseCombatWeapon *pRet = GetActiveWeapon();
if ( pRet )
{
Assert( dynamic_cast< CTFWeaponBase* >( pRet ) != NULL );
return static_cast< CTFWeaponBase * >( pRet );
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if we are currently wielding a weapon that
// matches the given item def handle.
//-----------------------------------------------------------------------------
bool CTFPlayer::IsActiveTFWeapon( CEconItemDefinition *weaponHandle ) const
{
return ( GetActiveTFWeapon() &&
GetActiveTFWeapon()->GetAttributeContainer() &&
GetActiveTFWeapon()->GetAttributeContainer()->GetItem() &&
GetActiveTFWeapon()->GetAttributeContainer()->GetItem()->GetItemDefinition() == weaponHandle );
}
//-----------------------------------------------------------------------------
// Purpose: Return true if we are currently wielding a weapon that
// matches the given item def handle.
bool CTFPlayer::IsActiveTFWeapon( const CSchemaItemDefHandle &weaponHandle ) const
{
return ( GetActiveTFWeapon() &&
GetActiveTFWeapon()->GetAttributeContainer() &&
GetActiveTFWeapon()->GetAttributeContainer()->GetItem() &&
GetActiveTFWeapon()->GetAttributeContainer()->GetItem()->GetItemDefinition() == weaponHandle );
}
//-----------------------------------------------------------------------------
// Purpose: How much build resource ( metal ) does this player have
//-----------------------------------------------------------------------------
int CTFPlayer::GetBuildResources( void )
{
return GetAmmoCount( TF_AMMO_METAL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
template < typename T >
class CScopedFlag
{
public:
CScopedFlag( T& ref_ )
: ref( ref_ )
{
Assert( !ref );
ref = true;
}
~CScopedFlag()
{
Assert( ref );
ref = false;
}
private:
T& ref;
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFPlayer::GetMovementForwardPull( void ) const
{
CTFWeaponBase *pWpn = GetActiveTFWeapon();
if ( pWpn && pWpn->IsFiring() )
{
float flFiringForwardPull = 0.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWpn, flFiringForwardPull, firing_forward_pull );
return flFiringForwardPull;
}
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::CanPlayerMove() const
{
// No one can move when in a final countdown transition.
if ( TFGameRules() && TFGameRules()->BInMatchStartCountdown() )
{ return false; }
bool bFreezeOnRestart = tf_player_movement_restart_freeze.GetBool();
if ( bFreezeOnRestart )
{
#if defined( _DEBUG ) || defined( STAGING_ONLY )
if ( mp_developer.GetBool() )
bFreezeOnRestart = false;
#endif // _DEBUG || STAGING_ONLY
if ( TFGameRules() && TFGameRules()->UsePlayerReadyStatusMode() && ( TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS ) )
bFreezeOnRestart = false;
}
bool bInRoundRestart = TFGameRules() && TFGameRules()->InRoundRestart();
if ( bInRoundRestart && TFGameRules()->IsCompetitiveMode() )
{
if ( TFGameRules()->GetRoundsPlayed() > 0 )
{
if ( gpGlobals->curtime < TFGameRules()->GetPreroundCountdownTime() )
{
bFreezeOnRestart = true;
}
}
else
{
bFreezeOnRestart = false;
}
}
bool bNoMovement = bInRoundRestart && bFreezeOnRestart;
return !bNoMovement;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFPlayer::TeamFortress_CalculateMaxSpeed( bool bIgnoreSpecialAbility /*= false*/ ) const
{
if ( !GameRules() )
return 0.0f;
int playerclass = GetPlayerClass()->GetClassIndex();
// Spectators can move while in Classic Observer mode
if ( IsObserver() )
{
if ( GetObserverMode() == OBS_MODE_ROAMING )
return GetPlayerClassData( TF_CLASS_SCOUT )->m_flMaxSpeed;
return 0.0f;
}
// Check for any reason why they can't move at all
if ( playerclass == TF_CLASS_UNDEFINED || !CanPlayerMove() )
return 1.0f; // this can't return 0 because other parts of the code interpret that as "use default speed" during setup
// First, get their max class speed
float default_speed = GetPlayerClassData( playerclass )->m_flMaxSpeed;
// Avoid re-entering and calculating our velocity while we're calculating our velocity.
// This can happen if we have two characters trying to match each other's velocity, for
// example if you have two medics with Quick-Fixes healing each other.
//
// In the case where we run into this, we end the recursion with someone running default
// speed.
if ( m_bIsCalculatingMaximumSpeed )
return default_speed;
CScopedFlag<char> flagAvoidReentrancy( m_bIsCalculatingMaximumSpeed );
// Slow us down if we're disguised as a slower class
// unless we're cloaked..
float maxfbspeed = default_speed;
bool bAllowSlowing = m_Shared.InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) ? false : true;
if ( m_Shared.InCond( TF_COND_DISGUISED_AS_DISPENSER ) && !m_Shared.IsStealthed() )
{
maxfbspeed = 0.0f;
}
else if ( m_Shared.InCond( TF_COND_DISGUISED ) && !m_Shared.IsStealthed() )
{
float flMaxDisguiseSpeed = GetPlayerClassData( m_Shared.GetDisguiseClass() )->m_flMaxSpeed;
maxfbspeed = MIN( flMaxDisguiseSpeed, maxfbspeed );
}
if ( !TFGameRules()->IsMannVsMachineMode() || !IsMiniBoss() ) // No aiming slowdown penalties for MiniBoss players in MVM
{
// if they're a sniper, and they're aiming, their speed must be 80 or less
if ( m_Shared.InCond( TF_COND_AIMING ) )
{
float flAimMax = 0;
// Heavies are allowed to move slightly faster than a sniper when spun-up
if ( playerclass == TF_CLASS_HEAVYWEAPONS )
{
{
flAimMax = 110;
}
}
else
{
if ( GetActiveTFWeapon() && (GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_COMPOUND_BOW) )
{
flAimMax = 160;
}
else
{
flAimMax = 80;
}
}
CALL_ATTRIB_HOOK_FLOAT( flAimMax, mult_player_aiming_movespeed );
maxfbspeed = MIN( maxfbspeed, flAimMax );
}
}
#ifdef GAME_DLL
#ifdef STAGING_ONLY
if ( m_Shared.InCond( TF_COND_SPEED_BOOST ) || m_Shared.InCond( TF_COND_NO_COMBAT_SPEED_BOOST ) )
#else
if ( m_Shared.InCond( TF_COND_SPEED_BOOST ) )
#endif
{
// We only allow our speed boost to apply if we have a base speed to work with. If we're supposed
// to be stationary for whatever reason we don't allow a speed to allow us to move.
if ( maxfbspeed > 0.0f )
{
maxfbspeed += MIN( maxfbspeed * 0.4f, tf_whip_speed_increase.GetFloat() );
}
}
#endif
if ( m_Shared.InCond( TF_COND_STEALTHED ) )
{
if (maxfbspeed > tf_spy_max_cloaked_speed.GetFloat() )
{
maxfbspeed = tf_spy_max_cloaked_speed.GetFloat();
}
}
// if we're in bonus time because a team has won, give the winners 110% speed and the losers 90% speed
if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
{
int iWinner = TFGameRules()->GetWinningTeam();
if ( iWinner != TEAM_UNASSIGNED )
{
if ( iWinner == GetTeamNumber() )
{
maxfbspeed *= 1.1f;
}
else
{
maxfbspeed *= 0.9f;
}
}
}
CTFWeaponBase* pWeapon = GetActiveTFWeapon();
if ( pWeapon )
{
maxfbspeed *= pWeapon->GetSpeedMod();
}
if ( playerclass == TF_CLASS_DEMOMAN )
{
CTFSword *pSword = dynamic_cast<CTFSword*>(Weapon_OwnsThisID( TF_WEAPON_SWORD ));
if ( pSword )
{
maxfbspeed *= pSword->GetSwordSpeedMod();
}
if ( !bIgnoreSpecialAbility && m_Shared.InCond( TF_COND_SHIELD_CHARGE ) )
{
maxfbspeed = tf_max_charge_speed.GetFloat();
}
}
bool bCarryPenalty = true;
if ( TFGameRules()->IsMannVsMachineMode() )
{
bCarryPenalty = false;
}
if ( m_Shared.IsCarryingObject() && bCarryPenalty && bAllowSlowing )
{
#ifdef STAGING_ONLY
CBaseObject* pObject = m_Shared.GetCarriedObject();
if ( pObject && pObject->GetType() == OBJ_TELEPORTER )
{
CALL_ATTRIB_HOOK_FLOAT( maxfbspeed, teleporter_carry_speed );
}
#endif // STAGING_ONLY
// STAGING_ENGY
maxfbspeed *= 0.90f;
}
if ( m_Shared.IsLoserStateStunned() && bAllowSlowing )
{
// Yikes is not as slow, terrible gotcha
if ( m_Shared.GetActiveStunInfo()->iStunFlags & TF_STUN_BY_TRIGGER )
{
maxfbspeed *= 0.75f;
}
else
{
maxfbspeed *= 0.5f;
}
}
// If we have an item with a move speed modification, apply it to the final speed.
CALL_ATTRIB_HOOK_FLOAT( maxfbspeed, mult_player_movespeed );
if ( m_Shared.IsShieldEquipped() )
{
CALL_ATTRIB_HOOK_FLOAT( maxfbspeed, mult_player_movespeed_shieldrequired );
}
if ( playerclass == TF_CLASS_MEDIC )
{
if ( pWeapon )
{
CWeaponMedigun *pMedigun = dynamic_cast< CWeaponMedigun* >( pWeapon );
if ( pMedigun )
{
// Medics match faster classes when healing them
CTFPlayer *pHealTarget = ToTFPlayer( pMedigun->GetHealTarget() );
if ( pHealTarget )
{
// The Quick-Fix attaches to charging demos
bool bCharge = ( pMedigun->GetMedigunType() == MEDIGUN_QUICKFIX && pHealTarget->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) );
const float flHealTargetMaxSpeed = ( bCharge ) ? tf_max_charge_speed.GetFloat() : pHealTarget->TeamFortress_CalculateMaxSpeed( true );
maxfbspeed = Max( maxfbspeed, flHealTargetMaxSpeed );
}
}
}
// Special bone saw
int iTakeHeads = 0;
CALL_ATTRIB_HOOK_INT( iTakeHeads, add_head_on_hit );
if ( iTakeHeads )
{
CTFBonesaw *pSaw = dynamic_cast<CTFBonesaw*>(Weapon_OwnsThisID( TF_WEAPON_HARVESTER_SAW ));
if ( pSaw )
{
maxfbspeed *= pSaw->GetBoneSawSpeedMod();
}
}
}
float flClassResourceLevelMod = 1.f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flClassResourceLevelMod, mult_player_movespeed_resource_level );
if ( flClassResourceLevelMod != 1.f )
{
// Medic Uber
if ( playerclass == TF_CLASS_MEDIC )
{
CWeaponMedigun *pMedigun = dynamic_cast< CWeaponMedigun* >( Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
if ( pMedigun )
{
maxfbspeed *= RemapValClamped( pMedigun->GetChargeLevel(), 0.f, 1.f, 1.f, flClassResourceLevelMod );
}
}
}
// If we're a heavy with berzerker mode...
if ( playerclass == TF_CLASS_HEAVYWEAPONS )
{
float heavy_max_speed = default_speed * 1.35f;
if ( m_Shared.InCond( TF_COND_ENERGY_BUFF ) )
{
maxfbspeed *= 1.35f;
if ( maxfbspeed > heavy_max_speed )
{
// Prevent other speed modifiers like GRU from making berzerker mode too fast.
maxfbspeed = heavy_max_speed;
}
}
}
if ( playerclass == TF_CLASS_SCOUT )
{
if ( Weapon_OwnsThisID( TF_WEAPON_PEP_BRAWLER_BLASTER ) )
{
// Make this change based on attrs, hardcode right now
maxfbspeed *= RemapValClamped( m_Shared.GetScoutHypeMeter(), 0.0f, 100.0f, 1.0f, 1.45f );
}
// Crit-a-Cola gives a move bonus while active
if ( m_Shared.InCond( TF_COND_ENERGY_BUFF ) )
{
maxfbspeed *= 1.25f;
}
}
// Mann Vs Machine mode has a speed penalty for carrying the flag
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
if ( GetTeamNumber() == TF_TEAM_PVE_INVADERS )
{
if ( HasTheFlag() && !IsMiniBoss() )
{
maxfbspeed *= tf_mvm_bot_flag_carrier_movement_penalty.GetFloat();
}
}
}
#ifdef STAGING_ONLY
// Overloaded circuits!
if ( m_Shared.InCond( TF_COND_REPROGRAMMED ) )
{
maxfbspeed *= 2.f;
}
#endif // STAGING_ONLY
if ( m_Shared.GetCarryingRuneType() == RUNE_HASTE )
{
maxfbspeed *= 1.3f;
}
if ( m_Shared.GetCarryingRuneType() == RUNE_AGILITY )
{
// light classes get more benefit due to movement speed cap of 520
switch ( GetPlayerClass()->GetClassIndex() )
{
case TF_CLASS_DEMOMAN:
case TF_CLASS_SOLDIER:
case TF_CLASS_HEAVYWEAPONS:
maxfbspeed *= 1.4f;
break;
default:
maxfbspeed *= 1.5f;
break;
}
}
return maxfbspeed;
}
void CTFPlayer::TeamFortress_SetSpeed()
{
#ifdef GAME_DLL
if ( TFGameRules() && TFGameRules()->IsPasstimeMode() && g_pPasstimeLogic )
{
float flPackSpeed = g_pPasstimeLogic->GetPackSpeed( this );
if ( flPackSpeed > 0 )
{
SetMaxSpeed( flPackSpeed );
return;
}
}
#endif
const float fMaxSpeed = TeamFortress_CalculateMaxSpeed();
// Set the speed
SetMaxSpeed( fMaxSpeed );
if ( fMaxSpeed <= 0.0f )
{
SetAbsVelocity( vec3_origin );
}
#ifdef GAME_DLL
// Anyone that's watching our speed should know that our speed changed so they can
// update their own speed.
//
// We guard against re-entrancy here as well to avoid the case where two medics are
// healing each other with Quick-Fixes.
//
// This can also happen when a quickfix medic is healing a player that gets a speed
// boost. And it doesn't work because the recursive call will just return the healed
// character's default speed instead of current speed.
// TODO fix this. why not just set the medic's speed directly at this point?
//
if ( !m_bIsCalculatingMaximumSpeed )
{
CScopedFlag<char> flagAvoidReentrancy( m_bIsCalculatingMaximumSpeed );
CUtlVector<CTFPlayer *> vecSpeedWatchers;
m_Shared.GetSpeedWatchersList( &vecSpeedWatchers );
FOR_EACH_VEC( vecSpeedWatchers, i )
{
vecSpeedWatchers[i]->TeamFortress_SetSpeed();
}
}
#endif // GAME_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::HasItem( void ) const
{
return ( m_hItem != NULL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::SetItem( CTFItem *pItem )
{
m_hItem = pItem;
#ifndef CLIENT_DLL
if ( pItem )
{
AddGlowEffect();
}
else
{
RemoveGlowEffect();
}
if ( pItem && pItem->GetItemID() == TF_ITEM_CAPTURE_FLAG )
{
RemoveInvisibility();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFItem *CTFPlayer::GetItem( void ) const
{
return m_hItem;
}
//-----------------------------------------------------------------------------
// Purpose: Is the player carrying the flag?
//-----------------------------------------------------------------------------
bool CTFPlayer::HasTheFlag( ETFFlagType exceptionTypes[], int nNumExceptions ) const
{
if ( HasItem() && GetItem()->GetItemID() == TF_ITEM_CAPTURE_FLAG )
{
CCaptureFlag* pFlag = static_cast< CCaptureFlag* >( GetItem() );
for( int i=0; i < nNumExceptions; ++i )
{
if ( exceptionTypes[ i ] == pFlag->GetType() )
return false;
}
return true;
}
return false;
}
bool CTFPlayer::IsAllowedToPickUpFlag( void ) const
{
int iCannotPickUpIntelligence = 0;
CALL_ATTRIB_HOOK_INT( iCannotPickUpIntelligence, cannot_pick_up_intelligence );
if ( iCannotPickUpIntelligence )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CCaptureZone *CTFPlayer::GetCaptureZoneStandingOn( void )
{
touchlink_t *root = ( touchlink_t * )GetDataObject( TOUCHLINK );
if ( root )
{
for ( touchlink_t *link = root->nextLink; link != root; link = link->nextLink )
{
CBaseEntity *pTouch = link->entityTouched;
if ( pTouch && pTouch->IsSolidFlagSet( FSOLID_TRIGGER ) && pTouch->IsBSPModel() )
{
CCaptureZone *pAreaTrigger = dynamic_cast< CCaptureZone* >(pTouch);
if ( pAreaTrigger )
{
return pAreaTrigger;
}
}
}
}
return NULL;
}
CCaptureZone *CTFPlayer::GetClosestCaptureZone( void )
{
CCaptureZone *pCaptureZone = NULL;
float flClosestDistance = FLT_MAX;
for ( int i=0; i<ICaptureZoneAutoList::AutoList().Count(); ++i )
{
CCaptureZone *pTempCaptureZone = static_cast< CCaptureZone* >( ICaptureZoneAutoList::AutoList()[i] );
if ( !pTempCaptureZone->IsDisabled() && pTempCaptureZone->GetTeamNumber() == GetTeamNumber() )
{
float fCurrentDistance = GetAbsOrigin().DistTo( pTempCaptureZone->WorldSpaceCenter() );
if ( flClosestDistance > fCurrentDistance )
{
pCaptureZone = pTempCaptureZone;
flClosestDistance = fCurrentDistance;
}
}
}
return pCaptureZone;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this player's allowed to build another one of the specified object
//-----------------------------------------------------------------------------
int CTFPlayer::CanBuild( int iObjectType, int iObjectMode )
{
if ( iObjectType < 0 || iObjectType >= OBJ_LAST )
return CB_UNKNOWN_OBJECT;
const CObjectInfo *pInfo = GetObjectInfo( iObjectType );
if ( pInfo && ((iObjectMode > pInfo->m_iNumAltModes) || (iObjectMode < 0)) )
return CB_CANNOT_BUILD;
// Does this type require a specific builder?
bool bHasSubType = false;
CTFWeaponBuilder *pBuilder = CTFPlayerSharedUtils::GetBuilderForObjectType( this, iObjectType );
if ( pBuilder )
{
bHasSubType = true;
}
if ( TFGameRules() )
{
if ( TFGameRules()->IsTruceActive() && ( iObjectType == OBJ_ATTACHMENT_SAPPER ) )
return CB_CANNOT_BUILD;
if ( TFGameRules()->IsMannVsMachineMode() )
{
// If a human is placing a sapper
if ( !IsBot() && iObjectType == OBJ_ATTACHMENT_SAPPER )
{
// Only allow one Sapper of any kind in MvM
if ( GetNumObjects( iObjectType, BUILDING_MODE_ANY ) )
return CB_LIMIT_REACHED;
return ( ( GetAmmoCount( TF_AMMO_GRENADES2 ) > 0 ) ? CB_CAN_BUILD : CB_CANNOT_BUILD );
}
}
}
#ifndef CLIENT_DLL
CTFPlayerClass *pCls = GetPlayerClass();
if ( !bHasSubType && pCls && pCls->CanBuildObject( iObjectType ) == false )
{
return CB_CANNOT_BUILD;
}
#endif
// We can redeploy the object if we are carrying it.
CBaseObject* pObjType = GetObjectOfType( iObjectType, iObjectMode );
if ( pObjType && pObjType->IsCarried() )
{
return CB_CAN_BUILD;
}
// Special handling of "disposable" sentries
if ( TFGameRules()->GameModeUsesUpgrades() && iObjectType == OBJ_SENTRYGUN )
{
// If we have our main sentry, see if we're allowed to build disposables
if ( GetNumObjects( iObjectType, iObjectMode ) )
{
bool bHasPrimary = false;
int nDisposableCount = 0;
int nMaxDisposableCount = 0;
CALL_ATTRIB_HOOK_INT( nMaxDisposableCount, engy_disposable_sentries );
if ( nMaxDisposableCount )
{
for ( int i = GetObjectCount()-1; i >= 0; i-- )
{
CBaseObject *pObj = GetObject( i );
if ( pObj )
{
if ( !pObj->IsDisposableBuilding() )
{
bHasPrimary = true;
}
else
{
nDisposableCount++;
}
}
}
if ( bHasPrimary )
{
if ( nDisposableCount < nMaxDisposableCount )
{
return CB_CAN_BUILD;
}
else
{
return CB_LIMIT_REACHED;
}
}
}
}
}
// Allow MVM engineer bots to have multiple sentries. Currently they only need this so
// they can appear to be carrying a new building when advancing their nest rather than
// transporting an existing building.
if( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && IsBot() )
{
return CB_CAN_BUILD;
}
// Make sure we haven't hit maximum number
int iObjectCount = GetNumObjects( iObjectType, iObjectMode );
if ( iObjectCount >= GetObjectInfo( iObjectType )->m_nMaxObjects && GetObjectInfo( iObjectType )->m_nMaxObjects != -1)
{
return CB_LIMIT_REACHED;
}
// Find out how much the object should cost
int iCost = m_Shared.CalculateObjectCost( this, iObjectType );
// Make sure we have enough resources
if ( GetBuildResources() < iCost )
{
return CB_NEED_RESOURCES;
}
return CB_CAN_BUILD;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsAiming( void )
{
if ( !m_pOuter )
return false;
bool bAiming = InCond( TF_COND_AIMING ) && !m_pOuter->IsPlayerClass( TF_CLASS_SOLDIER );
if ( m_pOuter->IsPlayerClass( TF_CLASS_SNIPER ) && m_pOuter->GetActiveTFWeapon() && ( m_pOuter->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_SNIPERRIFLE_CLASSIC ) )
{
bAiming = InCond( TF_COND_ZOOMED );
}
return bAiming;
}
//-----------------------------------------------------------------------------
// Purpose: Set what type of rune we are carrying--or that we are not carrying any.
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetCarryingRuneType( RuneTypes_t rt )
{
#ifdef GAME_DLL
// Stat Tracking
if ( rt != RUNE_NONE )
{
// if getting a rune, start timer
m_flRuneAcquireTime = gpGlobals->curtime;
}
else if ( IsCarryingRune() )
{
// if setting to none (death or drop) and I have a power up, report and set timer to -1
float duration = gpGlobals->curtime - m_flRuneAcquireTime;
m_flRuneAcquireTime = -1;
CTF_GameStats.Event_PowerUpRuneDuration( m_pOuter, (int)duration, GetCarryingRuneType() );
}
// clear rune charge
SetRuneCharge( 0.f );
#endif
// Not 100% sure AddCond does what I want to do if we already have that cond, so
// let's assert so we can debug it if it ever comes up.
Assert( rt != GetCarryingRuneType() );
// We are only ever allowed to carry one rune type at a time, this logic ensures that.
for ( int i = 0; i < RUNE_TYPES_MAX; ++i )
{
if ( i == rt )
{
AddCond( GetConditionFromRuneType( (RuneTypes_t) i ) );
}
else
{
RemoveCond( GetConditionFromRuneType( (RuneTypes_t) i ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Return the currently carried rune type, or RUNE_NONE if we are not carrying one.
//-----------------------------------------------------------------------------
RuneTypes_t CTFPlayerShared::GetCarryingRuneType( void ) const
{
RuneTypes_t retVal = RUNE_NONE;
for ( int i = 0; i < RUNE_TYPES_MAX; ++i )
{
if ( InCond( GetConditionFromRuneType( (RuneTypes_t) i ) ) )
{
// You are only allowed to have one rune type, if this hits we somehow erroneously
// have two condition bits set for different types of runes.
Assert( retVal == RUNE_NONE );
retVal = (RuneTypes_t)i;
break;
}
}
return retVal;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerShared::CalculateObjectCost( CTFPlayer* pBuilder, int iObjectType )
{
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
#ifdef STAGING_ONLY
if ( ( TFGameRules()->InSetup() || TFObjectiveResource()->GetMannVsMachineIsBetweenWaves() ) && iObjectType != OBJ_SPY_TRAP )
#else
if ( TFGameRules()->InSetup() || TFObjectiveResource()->GetMannVsMachineIsBetweenWaves() )
#endif
{
return 0;
}
}
int nCost = InternalCalculateObjectCost( iObjectType );
// Mini sentires are 30 metal cheaper
CTFWrench* pWrench = dynamic_cast<CTFWrench*>( pBuilder->Weapon_OwnsThisID( TF_WEAPON_WRENCH ) );
if ( pWrench && pWrench->IsPDQ() && ( iObjectType == OBJ_SENTRYGUN ) )
{
nCost -= 30;
}
#ifdef STAGING_ONLY
// Mini dispensers are 30 metal cheaper
int nMiniDispenserEnabled = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pBuilder, nMiniDispenserEnabled, allows_building_mini_dispenser );
if ( nMiniDispenserEnabled != 0 && iObjectType == OBJ_DISPENSER )
{
nCost -= 30;
}
// Speed Pads are cheaper
int nSpeedPad = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pBuilder, nSpeedPad, teleporter_is_speedpad );
if ( nSpeedPad != 0 && iObjectType == OBJ_TELEPORTER )
{
nCost -= 25;
}
#endif
if ( iObjectType == OBJ_TELEPORTER )
{
float flCostMod = 1.f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pBuilder, flCostMod, mod_teleporter_cost );
if ( flCostMod != 1.f )
{
nCost *= flCostMod;
}
}
CALL_ATTRIB_HOOK_INT_ON_OTHER( pBuilder, nCost, building_cost_reduction );
return nCost;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::HealthKitPickupEffects( int iHealthGiven /*= 0*/ )
{
// Healthkits also contain a fire blanket.
if ( InCond( TF_COND_BURNING ) )
{
RemoveCond( TF_COND_BURNING );
}
// and sutures
if ( InCond( TF_COND_BLEEDING ) )
{
RemoveCond( TF_COND_BLEEDING );
}
// and cures plague
if ( InCond( TF_COND_PLAGUE ) )
{
RemoveCond( TF_COND_PLAGUE );
}
// Spawns a number on the player's health bar in the HUD, and also
// spawns a "+" particle over their head for enemies to see
if ( iHealthGiven && !IsStealthed() && m_pOuter )
{
IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
if ( event )
{
event->SetInt( "amount", iHealthGiven );
event->SetInt( "entindex", m_pOuter->entindex() );
event->SetInt( "weapon_def_index", INVALID_ITEM_DEF_INDEX );
gameeventmanager->FireEvent( event );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Get the number of objects of the specified type that this player has
//-----------------------------------------------------------------------------
int CTFPlayer::GetNumObjects( int iObjectType, int iObjectMode /*= 0*/ )
{
int iCount = 0;
for (int i = 0; i < GetObjectCount(); i++)
{
if ( !GetObject(i) )
continue;
if ( GetObject(i)->IsDisposableBuilding() )
continue;
if ( GetObject(i)->GetType() == iObjectType &&
( GetObject(i)->GetObjectMode() == iObjectMode || iObjectMode == BUILDING_MODE_ANY ) )
{
iCount++;
}
}
return iCount;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::ItemPostFrame()
{
if ( m_hOffHandWeapon.Get() && m_hOffHandWeapon->IsWeaponVisible() )
{
if ( gpGlobals->curtime < m_flNextAttack )
{
m_hOffHandWeapon->ItemBusyFrame();
}
else
{
#if defined( CLIENT_DLL )
// Not predicting this weapon
if ( m_hOffHandWeapon->IsPredicted() )
#endif
{
m_hOffHandWeapon->ItemPostFrame( );
}
}
}
#ifdef GAME_DLL
CTFWeaponBase *pActiveWeapon = GetActiveTFWeapon();
if ( pActiveWeapon )
{
pActiveWeapon->HandleInspect();
}
#endif // GAME_DLL
BaseClass::ItemPostFrame();
}
void CTFPlayer::SetOffHandWeapon( CTFWeaponBase *pWeapon )
{
m_hOffHandWeapon = pWeapon;
if ( m_hOffHandWeapon.Get() )
{
m_hOffHandWeapon->Deploy();
}
}
// Set to NULL at the end of the holster?
void CTFPlayer::HolsterOffHandWeapon( void )
{
if ( m_hOffHandWeapon.Get() )
{
m_hOffHandWeapon->Holster();
}
}
//-----------------------------------------------------------------------------
// Purpose: Return true if we should record our last weapon when switching between the two specified weapons
//-----------------------------------------------------------------------------
bool CTFPlayer::Weapon_ShouldSetLast( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon )
{
// if the weapon doesn't want to be auto-switched to, don't!
CTFWeaponBase *pTFOldWeapon = dynamic_cast< CTFWeaponBase * >( pOldWeapon );
if ( pTFOldWeapon )
{
if ( pTFOldWeapon->AllowsAutoSwitchTo() == false )
{
return false;
}
}
return BaseClass::Weapon_ShouldSetLast( pOldWeapon, pNewWeapon );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::SelectItem( const char *pstr, int iSubType /*= 0*/ )
{
// This is basically a copy from the base class with addition of Weapon_CanSwitchTo
// We're not calling BaseClass::SelectItem on purpose to prevent breaking other games
// that might rely on not calling Weapon_CanSwitchTo
if (!pstr)
return;
CBaseCombatWeapon *pItem = Weapon_OwnsThisType( pstr, iSubType );
if (!pItem)
return;
if( GetObserverMode() != OBS_MODE_NONE )
return;// Observers can't select things.
if ( !Weapon_ShouldSelectItem( pItem ) )
return;
// FIX, this needs to queue them up and delay
// Make sure the current weapon can be holstered
if ( !Weapon_CanSwitchTo( pItem ) )
return;
ResetAutoaim();
Weapon_Switch( pItem );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex )
{
// Ghosts cant switch weapons!
if ( m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
{
return false;
}
// set last weapon before we switch to a new weapon to make sure that we can get the correct last weapon in Deploy/Holster
// This should be done in CBasePlayer::Weapon_Switch, but we don't want to break other games
CBaseCombatWeapon *pPreviousLastWeapon = GetLastWeapon();
CBaseCombatWeapon *pPreviousActiveWeapon = GetActiveWeapon();
// always set last for Weapon_Switch code to get attribute from the correct last item
Weapon_SetLast( GetActiveWeapon() );
bool bSwitched = BaseClass::Weapon_Switch( pWeapon, viewmodelindex );
if ( bSwitched )
{
m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_ATTACK_AND_RELOAD );
// valid last weapon
if ( Weapon_ShouldSetLast( pPreviousActiveWeapon, pWeapon ) )
{
Weapon_SetLast( pPreviousActiveWeapon );
SetSecondaryLastWeapon( pPreviousLastWeapon );
}
// previous active weapon is not valid to be last weapon, but the new active weapon is
else if ( Weapon_ShouldSetLast( pWeapon, pPreviousLastWeapon ) )
{
// this will skip the logic to ignore first time block and allow weapon to check for honorbound attribute right away
CTFWeaponBase *pTFWeapon = assert_cast< CTFWeaponBase * >( pWeapon );
if ( pTFWeapon && pTFWeapon->IsHonorBound() )
{
m_Shared.m_flFirstPrimaryAttack = gpGlobals->curtime;
}
if ( pWeapon != GetSecondaryLastWeapon() )
{
Weapon_SetLast( GetSecondaryLastWeapon() );
SetSecondaryLastWeapon( pPreviousLastWeapon );
}
else
{
// new active weapon is the same as the secondary last weapon, leave the last weapon alone
Weapon_SetLast( pPreviousLastWeapon );
}
}
// both previous and new active weapons are not not valid for last weapon
else
{
Weapon_SetLast( pPreviousLastWeapon );
}
}
else
{
// restore to the previous last weapon if we failed to switch to a new weapon
Weapon_SetLast( pPreviousLastWeapon );
}
#ifdef GAME_DLL
if ( bSwitched && TFGameRules() && TFGameRules()->IsInTraining() && TFGameRules()->GetTrainingModeLogic() && IsFakeClient() == false)
{
TFGameRules()->GetTrainingModeLogic()->OnPlayerSwitchedWeapons( this );
}
#endif
#ifdef CLIENT_DLL
m_Shared.UpdateCritBoostEffect();
#endif
return bSwitched;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFWearable *CTFPlayer::GetEquippedWearableForLoadoutSlot( int iLoadoutSlot )
{
int iClass = GetPlayerClass()->GetClassIndex();
for ( int i = 0; i < GetNumWearables(); ++i )
{
CTFWearable *pWearableItem = dynamic_cast< CTFWearable * >( GetWearable( i ) );
if ( !pWearableItem )
continue;
if ( !pWearableItem->GetAttributeContainer() )
continue;
CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem();
if ( !pEconItemView )
continue;
CTFItemDefinition *pItemDef = pEconItemView->GetStaticData();
if ( !pItemDef )
continue;
if ( pItemDef->GetLoadoutSlot(iClass) == iLoadoutSlot )
return pWearableItem;
}
return NULL;
}
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayer::GetEntityForLoadoutSlot( int iLoadoutSlot )
{
CBaseEntity *pEntity = NULL;
if ( IsWearableSlot( iLoadoutSlot ) )
{
// Search Wearables first otherwise search Weapons as a fall back
pEntity = GetEquippedWearableForLoadoutSlot( iLoadoutSlot );
if ( pEntity )
{
return pEntity;
}
}
int iClass = GetPlayerClass()->GetClassIndex();
for ( int i = 0; i < MAX_WEAPONS; i++ )
{
if ( GetWeapon(i) )
{
CEconItemView *pEconItemView = GetWeapon(i)->GetAttributeContainer()->GetItem();
if ( !pEconItemView )
continue;
CTFItemDefinition *pItemDef = pEconItemView->GetStaticData();
if ( !pItemDef )
continue;
if ( pItemDef->GetLoadoutSlot( iClass ) == iLoadoutSlot )
return GetWeapon(i);
}
}
return NULL;
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StopViewModelParticles( C_BaseEntity *pParticleEnt )
{
pParticleEnt->ParticleProp()->StopParticlesInvolving( pParticleEnt );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::GetStepSoundVelocities( float *velwalk, float *velrun )
{
float flMaxSpeed = MaxSpeed();
if ( ( GetFlags() & FL_DUCKING ) || ( GetMoveType() == MOVETYPE_LADDER ) )
{
if ( m_Shared.IsLoser() )
{
*velwalk = 0;
*velrun = 0;
}
else
{
*velwalk = flMaxSpeed * 0.25;
*velrun = flMaxSpeed * 0.3;
}
}
else
{
*velwalk = flMaxSpeed * 0.3;
*velrun = flMaxSpeed * 0.8;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::SetStepSoundTime( stepsoundtimes_t iStepSoundTime, bool bWalking )
{
float flMaxSpeed = MaxSpeed();
switch ( iStepSoundTime )
{
case STEPSOUNDTIME_NORMAL:
case STEPSOUNDTIME_WATER_FOOT:
m_flStepSoundTime = RemapValClamped( flMaxSpeed, 200, 450, 400, 200 );
if ( bWalking )
{
m_flStepSoundTime += 100;
}
break;
case STEPSOUNDTIME_ON_LADDER:
m_flStepSoundTime = 350;
break;
case STEPSOUNDTIME_WATER_KNEE:
m_flStepSoundTime = RemapValClamped( flMaxSpeed, 200, 450, 600, 400 );
break;
default:
Assert(0);
break;
}
if ( ( GetFlags() & FL_DUCKING) || ( GetMoveType() == MOVETYPE_LADDER ) )
{
m_flStepSoundTime += 100;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFPlayer::GetOverrideStepSound( const char *pszBaseStepSoundName )
{
if( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS && !IsMiniBoss() && !m_Shared.InCond( TF_COND_DISGUISED ) )
{
return "MVM.BotStep";
}
Assert( pszBaseStepSoundName );
struct override_sound_entry_t { int iOverrideIndex; const char *pszBaseSoundName; const char *pszNewSoundName; };
enum
{
kFootstepSoundSet_Default = 0,
kFootstepSoundSet_SoccerCleats = 1,
kFootstepSoundSet_HeavyGiant = 2,
kFootstepSoundSet_SoldierGiant = 3,
kFootstepSoundSet_DemoGiant = 4,
kFootstepSoundSet_ScoutGiant = 5,
kFootstepSoundSet_PyroGiant = 6,
kFootstepSoundSet_SentryBuster = 7,
kFootstepSoundSet_TreasureChest = 8,
kFootstepSoundSet_Octopus = 9,
};
int iOverrideFootstepSoundSet = kFootstepSoundSet_Default;
CALL_ATTRIB_HOOK_INT( iOverrideFootstepSoundSet, override_footstep_sound_set );
if ( iOverrideFootstepSoundSet != kFootstepSoundSet_Default )
{
static const override_sound_entry_t s_ReplacementSounds[] =
{
{ kFootstepSoundSet_SoccerCleats, "Default.StepLeft", "cleats_conc.StepLeft" },
{ kFootstepSoundSet_SoccerCleats, "Default.StepRight", "cleats_conc.StepRight" },
{ kFootstepSoundSet_SoccerCleats, "Dirt.StepLeft", "cleats_dirt.StepLeft" },
{ kFootstepSoundSet_SoccerCleats, "Dirt.StepRight", "cleats_dirt.StepRight" },
{ kFootstepSoundSet_SoccerCleats, "Concrete.StepLeft", "cleats_conc.StepLeft" },
{ kFootstepSoundSet_SoccerCleats, "Concrete.StepRight", "cleats_conc.StepRight" },
//
{ kFootstepSoundSet_Octopus, "Default.StepLeft", "Octopus.StepCommon" },
{ kFootstepSoundSet_Octopus, "Default.StepRight", "Octopus.StepCommon" },
{ kFootstepSoundSet_Octopus, "Dirt.StepLeft", "Octopus.StepCommon" },
{ kFootstepSoundSet_Octopus, "Dirt.StepRight", "Octopus.StepCommon" },
{ kFootstepSoundSet_Octopus, "Concrete.StepLeft", "Octopus.StepCommon" },
{ kFootstepSoundSet_Octopus, "Concrete.StepRight", "Octopus.StepCommon" },
//
{ kFootstepSoundSet_HeavyGiant, "", "MVM.GiantHeavyStep" },
//
{ kFootstepSoundSet_SoldierGiant, "", "MVM.GiantSoldierStep" },
//
{ kFootstepSoundSet_DemoGiant, "", "MVM.GiantDemomanStep" },
//
{ kFootstepSoundSet_ScoutGiant, "", "MVM.GiantScoutStep" },
//
{ kFootstepSoundSet_PyroGiant, "", "MVM.GiantPyroStep" },
//
{ kFootstepSoundSet_SentryBuster, "", "MVM.SentryBusterStep" },
//
{ kFootstepSoundSet_TreasureChest, "", "Chest.Step" },
};
for ( int i = 0; i < ARRAYSIZE( s_ReplacementSounds ); i++ )
{
if ( iOverrideFootstepSoundSet == s_ReplacementSounds[i].iOverrideIndex )
{
if ( !s_ReplacementSounds[i].pszBaseSoundName[0] ||
!Q_stricmp( pszBaseStepSoundName, s_ReplacementSounds[i].pszBaseSoundName ) )
return s_ReplacementSounds[i].pszNewSoundName;
}
}
}
// Fallback.
return BaseClass::GetOverrideStepSound( pszBaseStepSoundName );
}
void CTFPlayer::OnEmitFootstepSound( const CSoundParameters& params, const Vector& vecOrigin, float fVolume )
{
// play jingles in addition to normal footstep sounds,
// and play them quietly to the local player so they don't go insane
int iJingle = 0;
CALL_ATTRIB_HOOK_INT( iJingle, add_jingle_to_footsteps );
if ( iJingle > 0 )
{
CRecipientFilter filter;
filter.AddRecipientsByPAS( vecOrigin );
#ifndef CLIENT_DLL
// in MP, server removes all players in the vecOrigin's PVS, these players generate the footsteps client side
if ( gpGlobals->maxClients > 1 )
{
filter.RemoveRecipientsByPVS( vecOrigin );
}
#endif
EmitSound_t ep;
ep.m_nChannel = CHAN_BODY;
ep.m_pSoundName = ( iJingle == 1 ) ? "xmas.jingle" : "xmas.jingle_higher";
#ifdef CLIENT_DLL
ep.m_flVolume = IsLocalPlayer() ? 0.3f * fVolume : fVolume; // quieter for local player
#else
ep.m_flVolume = fVolume;
#endif
ep.m_SoundLevel = params.soundlevel;
ep.m_nFlags = SND_CHANGE_VOL;
ep.m_nPitch = params.pitch;
ep.m_pOrigin = &vecOrigin;
EmitSound( filter, entindex(), ep );
}
#ifdef CLIENT_DLL
// Halloween-specific bonus footsteps for viewmodel-rendering only. Real model footsteps will happen in the real
// footstep code in response to animation events. THIS IS A HACK!
if ( !ShouldDrawThisPlayer() && !m_Shared.IsStealthed() && !m_Shared.InCond( TF_COND_DISGUISED ) )
{
int iHalloweenFootstepType = 0;
if ( TF_IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
{
CALL_ATTRIB_HOOK_INT( iHalloweenFootstepType, halloween_footstep_type );
}
if ( m_nFootStamps > 0 )
{
// White color!
iHalloweenFootstepType = 0xFFFFFFFF;
}
if ( iHalloweenFootstepType != 0 )
{
CNewParticleEffect *pEffect = SpawnHalloweenSpellFootsteps( PATTACH_CUSTOMORIGIN, iHalloweenFootstepType );
if ( pEffect )
{
pEffect->SetControlPoint( 0, GetAbsOrigin() );
}
}
if ( m_nFootStamps > 0 )
{
m_nFootStamps--;
}
}
#endif
}
void CTFPlayer::ModifyEmitSoundParams( EmitSound_t &params )
{
BaseClass::ModifyEmitSoundParams( params );
CTFWeaponBase *pWeapon = GetActiveTFWeapon();
if ( pWeapon )
{
pWeapon->ModifyEmitSoundParams( params );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::CanAttack( int iCanAttackFlags )
{
CTFGameRules *pRules = TFGameRules();
Assert( pRules );
if ( m_Shared.HasPasstimeBall() )
{
// Always allow throwing the ball.
return true;
}
if ( ( m_Shared.GetStealthNoAttackExpireTime() > gpGlobals->curtime && !m_Shared.InCond( TF_COND_STEALTHED_USER_BUFF ) ) || m_Shared.InCond( TF_COND_STEALTHED ) )
{
if ( !( iCanAttackFlags & TF_CAN_ATTACK_FLAG_GRAPPLINGHOOK ) )
{
#ifdef CLIENT_DLL
HintMessage( HINT_CANNOT_ATTACK_WHILE_CLOAKED, true, true );
#endif
return false;
}
}
if ( m_Shared.IsFeignDeathReady() )
{
#ifdef CLIENT_DLL
HintMessage( HINT_CANNOT_ATTACK_WHILE_FEIGN_ARMED, true, true );
#endif
return false;
}
if ( IsTaunting() )
return false;
if ( m_Shared.InCond( TF_COND_PHASE ) == true )
return false;
if ( ( pRules->State_Get() == GR_STATE_TEAM_WIN ) && ( pRules->GetWinningTeam() != GetTeamNumber() ) )
{
return false;
}
if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Weapons can call this on secondary attack and it will link to the class
// ability
//-----------------------------------------------------------------------------
bool CTFPlayer::DoClassSpecialSkill( void )
{
if ( !IsAlive() )
return false;
if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
return false;
bool bDoSkill = false;
// powerup charge activation has higher priority than any class special skill
if ( m_Shared.IsRuneCharged() && GetActiveTFWeapon() && GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_GRAPPLINGHOOK )
{
#ifdef GAME_DLL
CTFGrapplingHook *pHook = static_cast<CTFGrapplingHook*>( GetActiveTFWeapon() );
if ( pHook )
{
pHook->ActivateRune();
}
#endif // GAME_DLL
return true;
}
switch( GetPlayerClass()->GetClassIndex() )
{
case TF_CLASS_SPY:
{
if ( !m_Shared.InCond( TF_COND_TAUNTING ) )
{
if ( m_Shared.m_flStealthNextChangeTime <= gpGlobals->curtime )
{
// Feign death if we have the right equipment mod.
CTFWeaponInvis* pInvisWatch = static_cast<CTFWeaponInvis*>( Weapon_OwnsThisID( TF_WEAPON_INVIS ) );
if ( pInvisWatch )
{
pInvisWatch->ActivateInvisibilityWatch();
}
}
}
}
break;
case TF_CLASS_DEMOMAN:
if ( !m_Shared.HasPasstimeBall() )
{
CTFPipebombLauncher *pPipebombLauncher = static_cast<CTFPipebombLauncher*>( Weapon_OwnsThisID( TF_WEAPON_PIPEBOMBLAUNCHER ) );
if ( pPipebombLauncher )
{
pPipebombLauncher->SecondaryAttack();
}
else
{
CTFWearableDemoShield *pWearableShield = GetEquippedDemoShield( this );
if ( pWearableShield )
{
pWearableShield->DoSpecialAction( this );
break;
}
}
}
bDoSkill = true;
break;
case TF_CLASS_ENGINEER:
if ( !m_Shared.HasPasstimeBall() )
{
bDoSkill = TryToPickupBuilding();
}
break;
default:
break;
}
return bDoSkill;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::EndClassSpecialSkill( void )
{
if ( !IsAlive() )
return false;
switch( GetPlayerClass()->GetClassIndex() )
{
case TF_CLASS_DEMOMAN:
{
CTFPipebombLauncher *pPipebombLauncher = static_cast<CTFPipebombLauncher*>( Weapon_OwnsThisID( TF_WEAPON_PIPEBOMBLAUNCHER ) );
if ( !pPipebombLauncher )
{
CTFWearableDemoShield *pWearableShield = GetEquippedDemoShield( this );
if ( pWearableShield )
{
pWearableShield->EndSpecialAction( this );
break;
}
}
}
break;
default:
break;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::CanPickupBuilding( CBaseObject *pPickupObject )
{
if ( !pPickupObject )
return false;
if ( pPickupObject->IsBuilding() )
return false;
if ( pPickupObject->IsUpgrading() )
return false;
if ( pPickupObject->HasSapper() )
return false;
if ( pPickupObject->IsPlasmaDisabled() )
return false;
// If we were recently carried & placed we may still be upgrading up to our old level.
if ( pPickupObject->GetUpgradeLevel() != pPickupObject->GetHighestUpgradeLevel() )
return false;
if ( m_Shared.IsCarryingObject() )
return false;
if ( m_Shared.IsLoserStateStunned() || m_Shared.IsControlStunned() )
return false;
if ( m_Shared.IsLoser() )
return false;
if ( TFGameRules()->State_Get() != GR_STATE_RND_RUNNING && TFGameRules()->State_Get() != GR_STATE_STALEMATE && TFGameRules()->State_Get() != GR_STATE_BETWEEN_RNDS )
return false;
// don't allow to pick up building while grappling hook
if ( m_Shared.InCond( TF_COND_GRAPPLINGHOOK ) )
return false;
// There's ammo in the clip... no switching away!
if ( GetActiveTFWeapon() && GetActiveTFWeapon()->AutoFiresFullClip() && GetActiveTFWeapon()->Clip1() > 0 )
return false;
// Knockout powerup restricts user to melee only, so cannot equip other items such as building pickups
if ( m_Shared.GetCarryingRuneType() == RUNE_KNOCKOUT )
// ClientPrint( this, HUD_PRINTCENTER, "#TF_Powerup_Pickup_Deny" );
{
ClientPrint( this, HUD_PRINTCENTER, "You can't pickup buildings while holding the KNOCKOUT powerup" );
return false;
}
// Check it's within range
int nPickUpRangeSq = TF_BUILDING_PICKUP_RANGE * TF_BUILDING_PICKUP_RANGE;
int iIncreasedRangeCost = 0;
int nSqrDist = (EyePosition() - pPickupObject->GetAbsOrigin()).LengthSqr();
// Extra range only works with primary weapon
CTFWeaponBase * pWeapon = GetActiveTFWeapon();
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iIncreasedRangeCost, building_teleporting_pickup );
if ( iIncreasedRangeCost != 0 )
{
// False on deadzone
if ( nSqrDist > nPickUpRangeSq && nSqrDist < TF_BUILDING_RESCUE_MIN_RANGE_SQ )
return false;
if ( nSqrDist >= TF_BUILDING_RESCUE_MIN_RANGE_SQ && GetAmmoCount( TF_AMMO_METAL ) < iIncreasedRangeCost )
return false;
return true;
}
else if ( nSqrDist > nPickUpRangeSq )
return false;
if ( TFGameRules()->IsInTraining() )
{
ConVarRef training_can_pickup_sentry( "training_can_pickup_sentry" );
ConVarRef training_can_pickup_dispenser( "training_can_pickup_dispenser" );
ConVarRef training_can_pickup_tele_entrance( "training_can_pickup_tele_entrance" );
ConVarRef training_can_pickup_tele_exit( "training_can_pickup_tele_exit" );
switch ( pPickupObject->GetType() )
{
case OBJ_DISPENSER:
return training_can_pickup_dispenser.GetBool();
case OBJ_TELEPORTER:
return pPickupObject->GetObjectMode() == MODE_TELEPORTER_ENTRANCE ? training_can_pickup_tele_entrance.GetBool() : training_can_pickup_tele_exit.GetBool();
case OBJ_SENTRYGUN:
return training_can_pickup_sentry.GetBool();
} // switch
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::TryToPickupBuilding()
{
if ( m_Shared.IsCarryingObject() )
return false;
if ( m_Shared.InCond( TF_COND_TAUNTING ) )
return false;
if ( m_Shared.InCond( TF_COND_HALLOWEEN_TINY ) )
return false;
if ( m_Shared.InCond( TF_COND_MELEE_ONLY ) )
return false;
if ( m_Shared.InCond( TF_COND_SWIMMING_CURSE ) )
return false;
#ifdef GAME_DLL
if ( m_bIsTeleportingUsingEurekaEffect )
return false;
int iCannotPickUpBuildings = 0;
CALL_ATTRIB_HOOK_INT( iCannotPickUpBuildings, cannot_pick_up_buildings );
if ( iCannotPickUpBuildings )
{
return false;
}
#endif
// Check to see if a building we own is in front of us.
Vector vecForward;
AngleVectors( EyeAngles(), &vecForward, NULL, NULL );
int iPickUpRange = TF_BUILDING_PICKUP_RANGE;
int iIncreasedRangeCost = 0;
CTFWeaponBase * pWeapon = GetActiveTFWeapon();
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iIncreasedRangeCost, building_teleporting_pickup );
if ( iIncreasedRangeCost != 0 )
{
iPickUpRange = TF_BUILDING_RESCUE_MAX_RANGE;
}
// Create a ray a see if any of my objects touch it
Ray_t ray;
ray.Init( EyePosition(), EyePosition() + vecForward * iPickUpRange );
CBulletPenetrateEnum ePickupPenetrate( &ray, this, TF_DMG_CUSTOM_PENETRATE_ALL_PLAYERS, false );
enginetrace->EnumerateEntities( ray, false, &ePickupPenetrate );
CBaseObject *pPickupObject = NULL;
float flCurrDistanceSq = iPickUpRange * iPickUpRange;
for ( int i=0; i<GetObjectCount(); i++ )
{
CBaseObject *pObj = GetObject(i);
if ( !pObj )
continue;
float flDistToObjSq = ( pObj->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr();
if ( flDistToObjSq > flCurrDistanceSq )
continue;
FOR_EACH_VEC( ePickupPenetrate.m_Targets, iTarget )
{
if ( ePickupPenetrate.m_Targets[iTarget].pTarget == pObj )
{
CTargetOnlyFilter penetrateFilter( this, pObj );
trace_t pTraceToUse;
UTIL_TraceLine( EyePosition(), EyePosition() + vecForward * iPickUpRange, ( MASK_SOLID | CONTENTS_HITBOX ), &penetrateFilter, &pTraceToUse );
if ( pTraceToUse.m_pEnt == pObj )
{
pPickupObject = pObj;
flCurrDistanceSq = flDistToObjSq;
break;
}
}
if ( ePickupPenetrate.m_Targets[iTarget].pTarget->IsWorld() )
{
break;
}
}
}
if ( !CanPickupBuilding(pPickupObject) )
{
if ( pPickupObject )
{
CSingleUserRecipientFilter filter( this );
EmitSound( filter, entindex(), "Player.UseDeny", NULL, 0.0f );
}
return false;
}
#ifdef CLIENT_DLL
return (bool) pPickupObject;
#elif GAME_DLL
if ( pPickupObject )
{
// remove rage for long range
if ( iIncreasedRangeCost )
{
int nSqrDist = (EyePosition() - pPickupObject->GetAbsOrigin()).LengthSqr();
if ( nSqrDist > TF_BUILDING_RESCUE_MIN_RANGE_SQ )
{
RemoveAmmo( iIncreasedRangeCost, TF_AMMO_METAL );
// Particles
// Spawn a railgun
Vector origin = pPickupObject->GetAbsOrigin();
CPVSFilter filter( origin );
const char *pRailParticleName = GetTeamNumber() == TF_TEAM_BLUE ? "dxhr_sniper_rail_blue" : "dxhr_sniper_rail_red";
const char *pTeleParticleName = GetTeamNumber() == TF_TEAM_BLUE ? "teleported_blue" : "teleported_red";
TE_TFParticleEffect( filter, 0.0, pTeleParticleName, origin, vec3_angle );
te_tf_particle_effects_control_point_t controlPoint = { PATTACH_WORLDORIGIN, pPickupObject->GetAbsOrigin() + Vector(0,0,32) };
TE_TFParticleEffectComplex( filter, 0.0f, pRailParticleName, GetAbsOrigin() + Vector(0,0,32), QAngle( 0, 0, 0 ), NULL, &controlPoint );
// Play Sounds
pPickupObject->EmitSound( "Building_Teleporter.Send" );
EmitSound( "Building_Teleporter.Receive" );
}
}
pPickupObject->MakeCarriedObject( this );
CTFWeaponBuilder *pBuilder = dynamic_cast<CTFWeaponBuilder*>(Weapon_OwnsThisID( TF_WEAPON_BUILDER ));
if ( pBuilder )
{
if ( GetActiveTFWeapon() == pBuilder )
SetActiveWeapon( NULL );
Weapon_Switch( pBuilder );
pBuilder->m_flNextSecondaryAttack = gpGlobals->curtime + 0.5f;
}
SpeakConceptIfAllowed( MP_CONCEPT_PICKUP_BUILDING, pPickupObject->GetResponseRulesModifier() );
m_flCommentOnCarrying = gpGlobals->curtime + random->RandomFloat( 6.f, 12.f );
return true;
}
else
{
return false;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::CanGoInvisible( bool bAllowWhileCarryingFlag )
{
// The "flag" in Player Destruction doesn't block cloak
ETFFlagType ignoreTypes[] = { TF_FLAGTYPE_PLAYER_DESTRUCTION };
if ( !bAllowWhileCarryingFlag && ( HasTheFlag( ignoreTypes, ARRAYSIZE( ignoreTypes ) ) || m_Shared.HasPasstimeBall() ) )
{
HintMessage( HINT_CANNOT_CLOAK_WITH_FLAG );
return false;
}
CTFGameRules *pRules = TFGameRules();
Assert( pRules );
if ( ( pRules->State_Get() == GR_STATE_TEAM_WIN ) && ( pRules->GetWinningTeam() != GetTeamNumber() ) )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::CanStartPhase( void )
{
if ( HasTheFlag() || m_Shared.HasPasstimeBall() )
{
HintMessage( HINT_CANNOT_PHASE_WITH_FLAG );
return false;
}
CTFGameRules *pRules = TFGameRules();
Assert( pRules );
if ( ( pRules->State_Get() == GR_STATE_TEAM_WIN ) && ( pRules->GetWinningTeam() != GetTeamNumber() ) )
{
return false;
}
return true;
}
//ConVar testclassviewheight( "testclassviewheight", "0", FCVAR_DEVELOPMENTONLY );
//Vector vecTestViewHeight(0,0,0);
//-----------------------------------------------------------------------------
// Purpose: Return class-specific standing eye height
//-----------------------------------------------------------------------------
Vector CTFPlayer::GetClassEyeHeight( void )
{
CTFPlayerClass *pClass = GetPlayerClass();
if ( !pClass )
return VEC_VIEW_SCALED( this );
//if ( testclassviewheight.GetFloat() > 0 )
//{
// vecTestViewHeight.z = test.GetFloat();
// return vecTestViewHeight;
//}
int iClassIndex = pClass->GetClassIndex();
if ( iClassIndex < TF_FIRST_NORMAL_CLASS || iClassIndex > TF_LAST_NORMAL_CLASS )
return VEC_VIEW_SCALED( this );
return g_TFClassViewVectors[pClass->GetClassIndex()] * GetModelScale();
}
CTFWeaponBase *CTFPlayer::Weapon_OwnsThisID( int iWeaponID ) const
{
for (int i = 0;i < WeaponCount(); i++)
{
CTFWeaponBase *pWpn = ( CTFWeaponBase *)GetWeapon( i );
if ( pWpn == NULL )
continue;
if ( pWpn->GetWeaponID() == iWeaponID )
{
return pWpn;
}
}
return NULL;
}
CTFWeaponBase *CTFPlayer::Weapon_GetWeaponByType( int iType )
{
for (int i = 0;i < WeaponCount(); i++)
{
CTFWeaponBase *pWpn = ( CTFWeaponBase *)GetWeapon( i );
if ( pWpn == NULL )
continue;
int iWeaponRole = pWpn->GetTFWpnData().m_iWeaponType;
if ( iWeaponRole == iType )
{
return pWpn;
}
}
return NULL;
}
bool CTFPlayer::Weapon_CanSwitchTo( CBaseCombatWeapon *pWeapon )
{
bool bCanSwitch = BaseClass::Weapon_CanSwitchTo( pWeapon );
if ( bCanSwitch )
{
if ( GetActiveTFWeapon() )
{
// There's ammo in the clip while auto firing... no switching away!
if ( GetActiveTFWeapon()->AutoFiresFullClip() && GetActiveTFWeapon()->Clip1() > 0 )
return false;
}
if ( m_Shared.IsCarryingObject() && (GetPlayerClass()->GetClassIndex() == TF_CLASS_ENGINEER) )
{
CTFWeaponBase *pTFWeapon = dynamic_cast<CTFWeaponBase*>( pWeapon );
if ( pTFWeapon && (pTFWeapon->GetWeaponID() != TF_WEAPON_BUILDER) )
{
return false;
}
}
// prevents script exploits, like switching to the minigun while eating a sandvich
if ( IsTaunting() && tf_allow_taunt_switch.GetInt() == 0 )
{
return false;
}
int iDisableWeaponSwitch = 0;
CALL_ATTRIB_HOOK_INT( iDisableWeaponSwitch, disable_weapon_switch );
if ( iDisableWeaponSwitch != 0 )
return false;
}
return bCanSwitch;
}
//-----------------------------------------------------------------------------
// Purpose: Gives the player an opportunity to abort a double jump.
//-----------------------------------------------------------------------------
bool CTFPlayer::CanAirDash( void ) const
{
if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
return false;
if ( m_Shared.InCond( TF_COND_HALLOWEEN_SPEED_BOOST ) )
return true;
bool bScout = GetPlayerClass()->IsClass( TF_CLASS_SCOUT );
if ( !bScout )
return false;
if ( m_Shared.InCond( TF_COND_SODAPOPPER_HYPE ) )
{
if ( m_Shared.GetAirDash() < 5 )
return true;
else
return false;
}
int iDashCount = tf_scout_air_dash_count.GetInt();
CALL_ATTRIB_HOOK_INT( iDashCount, air_dash_count );
if ( m_Shared.GetAirDash() >= iDashCount )
return false;
int iNoAirDash = 0;
CALL_ATTRIB_HOOK_INT( iNoAirDash, set_scout_doublejump_disabled );
if ( 1 == iNoAirDash )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Should be immune to Jarate and Mad Milk?
//-----------------------------------------------------------------------------
bool CTFPlayer::CanGetWet( void ) const
{
int iWetImmune = 0;
CALL_ATTRIB_HOOK_INT( iWetImmune, wet_immunity );
return iWetImmune ? false : true;
}
//-----------------------------------------------------------------------------
// Purpose: Remove disguise
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveDisguise( void )
{
// remove quickly
if ( m_Shared.InCond( TF_COND_DISGUISED ) || m_Shared.InCond( TF_COND_DISGUISING ) )
{
m_Shared.RemoveDisguise();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::RemoveDisguiseWeapon( void )
{
#ifdef GAME_DLL
if ( m_hDisguiseWeapon )
{
m_hDisguiseWeapon->Drop( Vector(0,0,0) );
m_hDisguiseWeapon = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::CanDisguise( void )
{
if ( !IsAlive() )
return false;
if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_SPY )
return false;
bool bHasFlag = false;
ETFFlagType ignoreTypes[] = { TF_FLAGTYPE_PLAYER_DESTRUCTION };
if ( HasTheFlag( ignoreTypes, ARRAYSIZE( ignoreTypes ) ) )
{
bHasFlag = true;
}
if ( bHasFlag || m_Shared.HasPasstimeBall() )
{
HintMessage( HINT_CANNOT_DISGUISE_WITH_FLAG );
return false;
}
if ( !Weapon_GetWeaponByType( TF_WPN_TYPE_PDA ) )
return false;
int iCannotDisguise = 0;
CALL_ATTRIB_HOOK_INT( iCannotDisguise, set_cannot_disguise );
if ( iCannotDisguise == 1 )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: 'Your Eternal Reward' handling for Disguise testing
//-----------------------------------------------------------------------------
bool CTFPlayer::CanDisguise_OnKill( void )
{
if ( !IsAlive() )
return false;
if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_SPY )
return false;
CTFKnife *pKnife = dynamic_cast<CTFKnife *>( Weapon_GetWeaponByType( TF_WPN_TYPE_MELEE ) );
if ( pKnife && pKnife->GetKnifeType() != KNIFE_DISGUISE_ONKILL )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayer::GetMaxAmmo( int iAmmoIndex, int iClassIndex /*= -1*/ )
{
int iMax = ( iClassIndex == -1 ) ? m_PlayerClass.GetData()->m_aAmmoMax[iAmmoIndex] : GetPlayerClassData( iClassIndex )->m_aAmmoMax[iAmmoIndex];
if ( iAmmoIndex == TF_AMMO_PRIMARY )
{
CALL_ATTRIB_HOOK_INT( iMax, mult_maxammo_primary );
}
else if ( iAmmoIndex == TF_AMMO_SECONDARY )
{
CALL_ATTRIB_HOOK_INT( iMax, mult_maxammo_secondary );
}
else if ( iAmmoIndex == TF_AMMO_METAL )
{
CALL_ATTRIB_HOOK_INT( iMax, mult_maxammo_metal );
}
else if ( iAmmoIndex == TF_AMMO_GRENADES1 )
{
CALL_ATTRIB_HOOK_INT( iMax, mult_maxammo_grenades1 );
}
else if ( iAmmoIndex == TF_AMMO_GRENADES3 )
{
// All classes by default can carry a max of 1 "Grenade3" which is being used as ACTIONSLOT Throwables
iMax = 1;
}
// Haste Powerup Rune adds multiplier to Max Ammo
if ( m_Shared.GetCarryingRuneType() == RUNE_HASTE )
{
iMax *= 2.0f;
}
return iMax;
}
bool CTFPlayer::IsMiniBoss( void ) const
{
return m_bIsMiniBoss;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayer::MedicGetHealTarget( void )
{
if ( IsPlayerClass(TF_CLASS_MEDIC) )
{
CWeaponMedigun *pWeapon = dynamic_cast <CWeaponMedigun*>( GetActiveWeapon() );
if ( pWeapon )
return pWeapon->GetHealTarget();
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFPlayer::MedicGetChargeLevel( CTFWeaponBase **pRetMedigun )
{
if ( IsPlayerClass(TF_CLASS_MEDIC) )
{
CTFWeaponBase *pWpn = ( CTFWeaponBase *)Weapon_OwnsThisID( TF_WEAPON_MEDIGUN );
if ( pWpn == NULL )
return 0;
CWeaponMedigun *pMedigun = dynamic_cast <CWeaponMedigun*>( pWpn );
if ( pRetMedigun )
{
*pRetMedigun = pMedigun;
}
if ( pMedigun )
return pMedigun->GetChargeLevel();
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayer::GetNumActivePipebombs( void )
{
if ( IsPlayerClass( TF_CLASS_DEMOMAN ) )
{
CTFPipebombLauncher *pWeapon = dynamic_cast < CTFPipebombLauncher*>( Weapon_OwnsThisID( TF_WEAPON_PIPEBOMBLAUNCHER ) );
if ( pWeapon )
{
return pWeapon->GetPipeBombCount();
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Fills out the vector with the sets that are currently active on this player
//-----------------------------------------------------------------------------
void CTFPlayer::GetActiveSets( CUtlVector<const CEconItemSetDefinition *> *pItemSets )
{
pItemSets->Purge();
CSteamID steamIDForPlayer;
GetSteamID( &steamIDForPlayer );
TFInventoryManager()->GetActiveSets( pItemSets, steamIDForPlayer, GetPlayerClass()->GetClassIndex() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::CanMoveDuringTaunt()
{
if ( TFGameRules() && TFGameRules()->IsCompetitiveMode() )
{
if ( ( TFGameRules()->GetRoundRestartTime() > -1.f ) && ( (int)( TFGameRules()->GetRoundRestartTime() - gpGlobals->curtime ) <= mp_tournament_readymode_countdown.GetInt() ) )
return false;
if ( TFGameRules()->PlayersAreOnMatchSummaryStage() )
return false;
}
if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
return true;
if ( m_Shared.InCond( TF_COND_TAUNTING ) || m_Shared.InCond( TF_COND_HALLOWEEN_THRILLER ) )
{
#ifdef GAME_DLL
if ( tf_allow_sliding_taunt.GetBool() )
{
return true;
}
#endif // GAME_DLL
#ifdef STAGING_ONLY
if ( tf_force_allow_move_during_taunt.GetBool() )
{
return true;
}
#endif // STAGING_ONLY
if ( m_bAllowMoveDuringTaunt )
{
return true;
}
if ( IsReadyToTauntWithPartner() || CTFPlayerSharedUtils::ConceptIsPartnerTaunt( m_Shared.m_iTauntConcept ) )
{
return false;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldStopTaunting()
{
// stop taunt if we're under water
return GetWaterLevel() > WL_Waist;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#if defined( CLIENT_DLL ) && defined( STAGING_ONLY )
static ConVar tf_tauntcam_dist_override( "tf_tauntcam_dist_override", "0", FCVAR_CHEAT );
static ConVar tf_tauntcam_distup_override( "tf_tauntcam_distup_override", "0", FCVAR_CHEAT );
#endif // CLIENT_DLL && STAGING_ONLY
void CTFPlayer::ParseSharedTauntDataFromEconItemView( CEconItemView *pEconItemView )
{
static CSchemaAttributeDefHandle pAttrDef_TauntForceMoveForward( "taunt force move forward" );
attrib_value_t attrTauntForceMoveForward = 0;
pEconItemView->FindAttribute( pAttrDef_TauntForceMoveForward, &attrTauntForceMoveForward );
m_bTauntForceMoveForward = attrTauntForceMoveForward != 0;
static CSchemaAttributeDefHandle pAttrDef_TauntMoveSpeed( "taunt move speed" );
attrib_value_t attrTauntMoveSpeed = 0;
pEconItemView->FindAttribute( pAttrDef_TauntMoveSpeed, &attrTauntMoveSpeed );
m_flTauntForceMoveForwardSpeed = (float&)attrTauntMoveSpeed;
static CSchemaAttributeDefHandle pAttrDef_TauntMoveAccelerationTime( "taunt move acceleration time" );
attrib_value_t attrTauntMoveAccelerationTime = 0;
pEconItemView->FindAttribute( pAttrDef_TauntMoveAccelerationTime, &attrTauntMoveAccelerationTime );
m_flTauntMoveAccelerationTime = (float&)attrTauntMoveAccelerationTime;
static CSchemaAttributeDefHandle pAttrDef_TauntTurnSpeed( "taunt turn speed" );
attrib_value_t attrTauntTurnSpeed = 0;
pEconItemView->FindAttribute( pAttrDef_TauntTurnSpeed, &attrTauntTurnSpeed );
m_flTauntTurnSpeed = (float&)attrTauntTurnSpeed;
static CSchemaAttributeDefHandle pAttrDef_TauntTurnAccelerationTime( "taunt turn acceleration time" );
attrib_value_t attrTauntTurnAccelerationTime = 0;
pEconItemView->FindAttribute( pAttrDef_TauntTurnAccelerationTime, &attrTauntTurnAccelerationTime );
m_flTauntTurnAccelerationTime = (float&)attrTauntTurnAccelerationTime;
#ifdef CLIENT_DLL
CTFTauntInfo *pTauntInfo = pEconItemView->GetStaticData()->GetTauntData();
if ( pTauntInfo )
{
if ( pTauntInfo->GetCameraDist() != 0 )
m_flTauntCamTargetDist = pTauntInfo->GetCameraDist();
if ( pTauntInfo->GetCameraDistUp() != 0 )
m_flTauntCamTargetDistUp = pTauntInfo->GetCameraDistUp();
#ifdef STAGING_ONLY
if ( tf_tauntcam_dist_override.GetFloat() != 0 )
m_flTauntCamTargetDist = tf_tauntcam_dist_override.GetFloat();
if ( tf_tauntcam_distup_override.GetFloat() != 0 )
m_flTauntCamTargetDistUp = tf_tauntcam_distup_override.GetFloat();
#endif // STAGING_ONLY
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::SetTauntYaw( float flTauntYaw )
{
m_flPrevTauntYaw = m_flTauntYaw;
m_flTauntYaw = flTauntYaw;
QAngle angle = GetLocalAngles();
angle.y = flTauntYaw;
SetLocalAngles( angle );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StartBuildingObjectOfType( int iType, int iMode )
{
// early out if we can't build this type of object
if ( CanBuild( iType, iMode ) != CB_CAN_BUILD )
return;
// Does this type require a specific builder?
CTFWeaponBuilder *pBuilder = CTFPlayerSharedUtils::GetBuilderForObjectType( this, iType );
if ( pBuilder )
{
#ifdef GAME_DLL
pBuilder->SetSubType( iType );
pBuilder->SetObjectMode( iMode );
if ( GetActiveTFWeapon() == pBuilder )
{
SetActiveWeapon( NULL );
}
#endif
// try to switch to this weapon
Weapon_Switch( pBuilder );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdatePhaseEffects( void )
{
bool bRunning;
float flSpeed = m_pOuter->MaxSpeed();
flSpeed *= flSpeed;
CTFPlayer *pPlayer = ToTFPlayer( m_pOuter );
if ( InCond( TF_COND_SHIELD_CHARGE ) || (pPlayer->GetAbsVelocity().LengthSqr() >= (flSpeed* 0.1f)) )
{
bRunning = true;
}
else
{
bRunning = false;
}
#ifdef CLIENT_DLL
if ( m_pOuter )
{
if ( !bRunning && !m_pOuter->m_pPhaseStandingEffect && m_flEnergyDrinkMeter < 100.0f )
{
m_pOuter->m_pPhaseStandingEffect = m_pOuter->ParticleProp()->Create( "warp_version", PATTACH_ABSORIGIN_FOLLOW );
}
else if ( bRunning && m_pOuter->m_pPhaseStandingEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pPhaseStandingEffect );
m_pOuter->m_pPhaseStandingEffect = NULL;
}
}
#else
// #ifdef STAGING_ONLY
// if ( !InCond( TF_COND_PHASE ) && !InCond( TF_COND_SHIELD_CHARGE ) && !InCond( TF_COND_SELF_CONC ) )
// #else
if ( !InCond( TF_COND_PHASE ) && !InCond( TF_COND_SHIELD_CHARGE ) )
//#endif // STAGING_ONLY
return;
if ( bRunning )
{
if ( !m_bPhaseFXOn )
{
AddPhaseEffects();
}
else
{
if ( m_flEnergyDrinkMeter <= 10.0f )
{
float fAlpha = ( m_flEnergyDrinkMeter / 10 ) * 255;
for ( int i = 0; i < TF_SCOUT_NUMBEROFPHASEATTACHMENTS; ++i )
{
CSpriteTrail *pTempTrail = dynamic_cast< CSpriteTrail*>( m_pPhaseTrail[i].Get() );
if ( pTempTrail )
{
pTempTrail->SetBrightness( int(fAlpha) );
}
}
}
// #ifdef STAGING_ONLY
// else if ( InCond( TF_COND_SHIELD_CHARGE ) || InCond( TF_COND_SELF_CONC ) )
// #else
else if ( InCond( TF_COND_SHIELD_CHARGE ) )
//#endif // STAGING_ONLY
{
for ( int i = 0; i < TF_SCOUT_NUMBEROFPHASEATTACHMENTS; ++i )
{
CSpriteTrail *pTempTrail = dynamic_cast< CSpriteTrail*>( m_pPhaseTrail[i].Get() );
if ( pTempTrail )
{
pTempTrail->SetBrightness( 0 );
}
}
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::AddPhaseEffects( void )
{
#ifdef CLIENT_DLL
#else
const char *pTrailTeamName = ( m_pOuter->GetTeamNumber() == TF_TEAM_RED ) ? "effects/beam001_red.vmt" : "effects/beam001_blu.vmt";
CSpriteTrail *pTempTrail = NULL;
pTempTrail = CSpriteTrail::SpriteTrailCreate( pTrailTeamName, m_pOuter->GetAbsOrigin(), true );
pTempTrail->FollowEntity( m_pOuter );
pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 255, kRenderFxNone );
pTempTrail->SetStartWidth( 12 );
pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
pTempTrail->SetLifeTime( 1 );
pTempTrail->TurnOn();
pTempTrail->SetAttachment( m_pOuter, m_pOuter->LookupAttachment( "back_upper" ) );
m_pPhaseTrail[0] = pTempTrail;
pTempTrail = CSpriteTrail::SpriteTrailCreate( pTrailTeamName, m_pOuter->GetAbsOrigin(), true );
pTempTrail->FollowEntity( m_pOuter );
pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 255, kRenderFxNone );
pTempTrail->SetStartWidth( 16 );
pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
pTempTrail->SetLifeTime( 1 );
pTempTrail->TurnOn();
pTempTrail->SetAttachment( m_pOuter, m_pOuter->LookupAttachment( "back_lower" ) );
m_pPhaseTrail[1] = pTempTrail;
pTempTrail = CSpriteTrail::SpriteTrailCreate( "effects/beam001_white.vmt", m_pOuter->GetAbsOrigin(), true );
pTempTrail->FollowEntity( m_pOuter );
pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 255, kRenderFxNone );
pTempTrail->SetStartWidth( 8 );
pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
pTempTrail->SetLifeTime( 0.5f );
pTempTrail->TurnOn();
pTempTrail->SetAttachment( m_pOuter, m_pOuter->LookupAttachment( "foot_R" ) );
m_pPhaseTrail[2] = pTempTrail;
pTempTrail = CSpriteTrail::SpriteTrailCreate( "effects/beam001_white.vmt", m_pOuter->GetAbsOrigin(), true );
pTempTrail->FollowEntity( m_pOuter );
pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 255, kRenderFxNone );
pTempTrail->SetStartWidth( 8 );
pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
pTempTrail->SetLifeTime( 0.5f );
pTempTrail->TurnOn();
pTempTrail->SetAttachment( m_pOuter, m_pOuter->LookupAttachment( "foot_L" ) );
m_pPhaseTrail[3] = pTempTrail;
pTempTrail = CSpriteTrail::SpriteTrailCreate( pTrailTeamName, m_pOuter->GetAbsOrigin(), true );
pTempTrail->FollowEntity( m_pOuter );
pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 255, kRenderFxNone );
pTempTrail->SetStartWidth( 8 );
pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
pTempTrail->SetLifeTime( 0.5f );
pTempTrail->TurnOn();
pTempTrail->SetAttachment( m_pOuter, m_pOuter->LookupAttachment( "hand_L" ) );
m_pPhaseTrail[4] = pTempTrail;
m_bPhaseFXOn = true;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::RemovePhaseEffects( void )
{
#ifdef CLIENT_DLL
if ( m_pOuter->m_pPhaseStandingEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pPhaseStandingEffect );
m_pOuter->m_pPhaseStandingEffect = NULL;
}
#else
for ( int i = 0; i < TF_SCOUT_NUMBEROFPHASEATTACHMENTS; ++i )
{
UTIL_Remove(m_pPhaseTrail[i]);
}
m_bPhaseFXOn = false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerShared::GetSequenceForDeath( CBaseAnimating* pRagdoll, bool bBurning, int nCustomDeath )
{
if ( !pRagdoll )
return -1;
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
if ( m_pOuter && ( m_pOuter->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
return -1;
}
int iDeathSeq = -1;
// if ( bBurning )
// {
// iDeathSeq = pRagdoll->LookupSequence( "primary_death_burning" );
// }
switch ( nCustomDeath )
{
case TF_DMG_CUSTOM_HEADSHOT_DECAPITATION:
case TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING:
case TF_DMG_CUSTOM_DECAPITATION:
case TF_DMG_CUSTOM_HEADSHOT:
iDeathSeq = pRagdoll->LookupSequence( "primary_death_headshot" );
break;
case TF_DMG_CUSTOM_BACKSTAB:
iDeathSeq = pRagdoll->LookupSequence( "primary_death_backstab" );
break;
}
return iDeathSeq;
}
extern ConVar tf_halloween_kart_dash_speed;
ConVar tf_halloween_kart_slow_turn_accel_speed( "tf_halloween_kart_slow_turn_accel_speed", "200", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_fast_turn_accel_speed( "tf_halloween_kart_fast_turn_accel_speed", "400", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_return_turn_accell( "tf_halloween_kart_return_turn_accell", "200", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_slow_turn_speed( "tf_halloween_kart_slow_turn_speed", "100", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_fast_turn_speed( "tf_halloween_kart_fast_turn_speed", "60", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_turning_curve_peak_position( "tf_halloween_kart_turning_curve_peak_position", "0.5", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_stationary_turn_speed( "tf_halloween_kart_stationary_turn_speed", "50", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_reverse_turn_speed( "tf_halloween_kart_reverse_turn_speed", "50", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_halloween_kart_air_turn_scale( "tf_halloween_kart_air_turn_scale", "1.2f", FCVAR_CHEAT | FCVAR_REPLICATED );
#ifdef CLIENT_DLL
ConVar tf_halloween_kart_pitch( "tf_halloween_kart_pitch", "10", FCVAR_ARCHIVE );
ConVar tf_halloween_kart_pitch_slow_follow_rate( "tf_halloween_kart_pitch_slow_follow_rate", "0.5", FCVAR_ARCHIVE );
ConVar tf_halloween_kart_pitch_fast_follow_rate( "tf_halloween_kart_pitch_fast_follow_rate", "2", FCVAR_ARCHIVE );
#endif // CLIENT_DLL
void CTFPlayerShared::CreateVehicleMove( float flInputSampleTime, CUserCmd *pCmd )
{
const float flSign = pCmd->sidemove == 0.f ? 0.f : Sign( pCmd->sidemove );
// Compute target turn speed
const float flVel = m_pOuter->GetAbsVelocity().Length2D();
const float flNormalizedSpeed = Clamp( flVel / tf_halloween_kart_dash_speed.GetFloat(), 0.0f, 1.0f );
float flTargetTurnSpeed;
if ( flNormalizedSpeed == 0.f )
{
flTargetTurnSpeed = flSign * tf_halloween_kart_stationary_turn_speed.GetFloat();
}
else if ( Sign( m_pOuter->GetCurrentTauntMoveSpeed() ) < 0 )
{
flTargetTurnSpeed = Sign( m_pOuter->GetCurrentTauntMoveSpeed() ) * flSign * tf_halloween_kart_reverse_turn_speed.GetFloat();
}
else
{
const float flSmoothCurveVal = SmoothCurve_Tweak( flNormalizedSpeed, tf_halloween_kart_turning_curve_peak_position.GetFloat() );
flTargetTurnSpeed = Sign( m_pOuter->GetCurrentTauntMoveSpeed() ) * flSign * RemapValClamped( flSmoothCurveVal, 0.f, 1.f, tf_halloween_kart_slow_turn_speed.GetFloat(), tf_halloween_kart_fast_turn_speed.GetFloat() );
}
float flTurnAccel = 0.f;
// Compute turn accelleration
if ( flSign == Sign( m_flCurrentTauntTurnSpeed ) )
{
flTurnAccel = RemapValClamped( flNormalizedSpeed, 0.f, 1.f, tf_halloween_kart_slow_turn_accel_speed.GetFloat(), tf_halloween_kart_fast_turn_accel_speed.GetFloat() );
}
else
{ // When not trying to turn, or turning the opposite way you're already turning
// accelerate much faster
flTurnAccel = tf_halloween_kart_return_turn_accell.GetFloat();
}
// Turn faster in the air
if ( !(m_pOuter->GetFlags() & FL_ONGROUND) )
{
flTurnAccel *= tf_halloween_kart_air_turn_scale.GetFloat();
}
// Get actual turn speed
m_flCurrentTauntTurnSpeed = Approach( flTargetTurnSpeed, m_flCurrentTauntTurnSpeed, flTurnAccel * flInputSampleTime );
const float flMaxPossibleTurnSpeed = Max( tf_halloween_kart_slow_turn_speed.GetFloat(), tf_halloween_kart_fast_turn_speed.GetFloat() );
m_flCurrentTauntTurnSpeed = clamp( m_flCurrentTauntTurnSpeed, -flMaxPossibleTurnSpeed, flMaxPossibleTurnSpeed );
#ifdef DEBUG
#ifdef CLIENT_DLL
engine->Con_NPrintf( 4, "Turn: %3.2f", m_flCurrentTauntTurnSpeed );
engine->Con_NPrintf( 5, "TargetTurn: %3.2f", flTargetTurnSpeed );
engine->Con_NPrintf( 6, "TurnAccell: %3.2f", flTurnAccel );
#else
engine->Con_NPrintf( 4+3, "Turn: %3.2f", m_flCurrentTauntTurnSpeed );
engine->Con_NPrintf( 5+3, "TargetTurn: %3.2f", flTargetTurnSpeed );
engine->Con_NPrintf( 6+3, "TurnAccell: %3.2f", flTurnAccel );
#endif
#endif
#ifdef CLIENT_DLL
// Turn!
m_angVehicleMoveAngles -= QAngle( 0.f, m_flCurrentTauntTurnSpeed * flInputSampleTime, 0.f );
// We want our pitch to slowly catch up to the pitch of the player's model
const float flTargetPitch = tf_halloween_kart_pitch.GetFloat() + m_pOuter->m_PlayerAnimState->GetRenderAngles()[PITCH];
const float flStepSpeed = fabs( flTargetPitch - tf_halloween_kart_pitch.GetFloat() ) < fabs( m_angVehicleMovePitchLast - tf_halloween_kart_pitch.GetFloat() ) ? tf_halloween_kart_pitch_fast_follow_rate.GetFloat() : tf_halloween_kart_pitch_slow_follow_rate.GetFloat();
const float flPitchDiff = fabs( flTargetPitch - m_angVehicleMovePitchLast );
const float flPitchStep = flPitchDiff * flStepSpeed;
m_angVehicleMovePitchLast = Approach( flTargetPitch, m_angVehicleMovePitchLast, flPitchStep * gpGlobals->frametime );
m_angVehicleMoveAngles[PITCH] = m_angVehicleMovePitchLast;
pCmd->weaponselect = 0;
pCmd->buttons &= IN_MOVELEFT | IN_MOVERIGHT | IN_ATTACK | IN_ATTACK2 | IN_FORWARD | IN_BACK | IN_JUMP;
VectorCopy( m_angVehicleMoveAngles, pCmd->viewangles );
m_pOuter->SetLocalAngles( m_angVehicleMoveAngles );
// Fill out our kart state for the local client
m_pOuter->m_iKartState = 0;
// Hitting the gas
if ( pCmd->buttons & IN_FORWARD )
{
m_pOuter->m_iKartState |= CTFPlayerShared::kKartState_Driving;
}
else if ( pCmd->buttons & IN_BACK ) // Hitting the brakes
{
// slowing down
if ( m_pOuter->GetCurrentTauntMoveSpeed() > 0 )
{
m_pOuter->m_iKartState |= CTFPlayerShared::kKartState_Braking;
}
// if we are already stopped, look for new input to start going backwards
else
{
// check for new input, else do nothing
if ( ( pCmd->buttons & IN_BACK )
|| m_pOuter->GetCurrentTauntMoveSpeed() < 0
|| m_pOuter->GetVehicleReverseTime() < gpGlobals->curtime
)
{
m_pOuter->m_iKartState |= CTFPlayerShared::kKartState_Reversing;
}
else
{
m_pOuter->m_iKartState |= CTFPlayerShared::kKartState_Stopped;
}
}
}
#endif
}
void CTFPlayerShared::VehicleThink( void )
{
#ifdef CLIENT_DLL
m_pOuter->UpdateKartSounds();
// Ordered list of effects. Lower on the list has higher prescedence
static WheelEffect_t wheelEffects[] =
{
WheelEffect_t( 20.f, "kart_dust_trail_red", "kart_dust_trail_blue" )
};
const float flCurrentSpeed = m_pOuter->GetCurrentTauntMoveSpeed();
const WheelEffect_t* pDesiredEffect = NULL;
if ( InCond( TF_COND_HALLOWEEN_KART ) )
{
// Go through the effects, and figure out which effect to use
for( int i=0; i < ARRAYSIZE(wheelEffects); ++ i )
{
const WheelEffect_t& effect = wheelEffects[ i ];
if ( effect.m_flMinTriggerSpeed <= flCurrentSpeed )
{
pDesiredEffect = &effect;
}
}
}
// Start/stop effects if the desired effect is different
if ( pDesiredEffect != m_pWheelEffect )
{
C_BaseAnimating * pKart = m_pOuter->GetKart();
if ( !pKart )
return;
m_pWheelEffect = pDesiredEffect;
// New effect
if ( pDesiredEffect )
{
const char *pszEffectName = pDesiredEffect->m_pszParticleName[ m_pOuter->GetTeamNumber() ];
m_pOuter->CreateKartEffect( pszEffectName );
}
else // Turn off current effect
{
m_pOuter->StopKartEffect();
}
}
#endif
}
//-----------------------------------------------------------------------------
float CTFPlayer::GetKartSpeedBoost( void )
{
if ( m_flKartNextAvailableBoost < gpGlobals->curtime )
return 1.0f;
if ( m_flKartNextAvailableBoost > gpGlobals->curtime + tf_halloween_kart_boost_recharge.GetFloat() )
return 0.0f;
// Calculate time
return RemapValClamped( gpGlobals->curtime, m_flKartNextAvailableBoost - tf_halloween_kart_boost_recharge.GetFloat(), m_flKartNextAvailableBoost, 0.0f, 1.0f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerShared::IsLoser( void )
{
if ( tf_always_loser.GetBool() )
return true;
if ( !TFGameRules() )
return false;
// No loser mode in competitive
if ( TFGameRules()->IsMatchTypeCompetitive() )
return false;
if ( TFGameRules()->State_Get() != GR_STATE_TEAM_WIN )
{
if ( IsLoserStateStunned() )
return true;
else
return false;
}
bool bLoser = TFGameRules()->GetWinningTeam() != m_pOuter->GetTeamNumber();
int iClass = m_pOuter->GetPlayerClass()->GetClassIndex();
// don't reveal disguised spies
if ( bLoser && iClass == TF_CLASS_SPY )
{
if ( InCond( TF_COND_DISGUISED ) && GetDisguiseTeam() == TFGameRules()->GetWinningTeam() )
{
bLoser = false;
}
}
return bLoser;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::RecalculatePlayerBodygroups( void )
{
// We have to clear the m_nBody bitfield.
// Leaving bits on from previous player classes can have weird effects
// like if we switch to a class that uses those bits for other things.
m_pOuter->m_nBody = 0;
// Update our weapon bodygroups that change state purely based on whether they're
// equipped or not.
CTFWeaponBase::UpdateWeaponBodyGroups( m_pOuter, false );
// Update our wearable bodygroups.
CEconWearable::UpdateWearableBodyGroups( m_pOuter );
// Update our weapon bodygroups for weapons that only change state when active.
CTFWeaponBase::UpdateWeaponBodyGroups( m_pOuter, true );
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::GetSpeedWatchersList( CUtlVector<CTFPlayer *> *out_pVecSpeedWatchers ) const
{
Assert( out_pVecSpeedWatchers != NULL );
// Are any medics healing us with the Quick-Fix?
FOR_EACH_VEC( m_aHealers, i )
{
CTFPlayer *pTFHealer = ToTFPlayer( m_aHealers[i].pHealer );
if ( !pTFHealer )
continue;
if ( !pTFHealer->GetActiveTFWeapon() || pTFHealer->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_MEDIGUN )
continue;
// QuickFix medics heal themselves when deploying an Uber
if ( m_aHealers[i].pHealer == m_pOuter )
continue;
out_pVecSpeedWatchers->AddToTail( pTFHealer );
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetupRageBuffTimer( int iBuffType, int iPulseCount, ERageBuffSlot eBuffSlot )
{
m_RageBuffSlots[eBuffSlot].m_iBuffTypeActive = iBuffType;
m_RageBuffSlots[eBuffSlot].m_iBuffPulseCount = iPulseCount;
m_RageBuffSlots[eBuffSlot].m_flNextBuffPulseTime = gpGlobals->curtime + 1.0f;
PulseRageBuff( eBuffSlot );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::ActivateRageBuff( CBaseEntity *pBuffItem, int iBuffType )
{
// Sniper Focus can be activated at all times
if ( GetRageMeter() < 100.f && iBuffType != 6 )
return;
Assert( iBuffType > 0 && iBuffType < ARRAYSIZE( g_RageBuffTypes ) ); // 0 is valid in the array, but an invalid buff
if ( iBuffType < 0 || iBuffType >= ARRAYSIZE( g_RageBuffTypes ) )
{
DevMsg( "Invalid rage buff type %i for entindex %i\n", iBuffType, m_pOuter->entindex() );
ResetRageSystem();
return;
}
int nBuffPulses = g_RageBuffTypes[iBuffType].m_nMaxPulses;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, nBuffPulses, mod_buff_duration );
#ifdef GAME_DLL
switch ( iBuffType )
{
case 1:
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_BATTLECRY );
break;
case 2:
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_INCOMING );
break;
case 3:
// FIXME: new sound file for samurai buff?
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_BATTLECRY );
case 5:
// Pyro Rage
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_BATTLECRY );
break;
case 6 :
// Sniper Focus
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_BATTLECRY );
nBuffPulses *= (m_flRageMeter / 100);
break;
}
#endif
m_bRageDraining = true;
SetupRageBuffTimer( iBuffType, nBuffPulses, kBuffSlot_Rage );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateRageBuffsAndRage( void )
{
// We allow this for all classes to allow item creators and plugin authors to give rage to any class.
// If we're dead, reset both our rage and our active buffs.
if ( !m_pOuter->IsAlive() )
{
ResetRageSystem();
return;
}
// Find out whether we've run out of rage.
if ( m_bRageDraining )
{
int nBuffType = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, nBuffType, set_buff_type );
Assert( nBuffType >= 0 && nBuffType < ARRAYSIZE( g_RageBuffTypes ) ); // 0 is valid in the array, but an invalid buff
if ( nBuffType < 0 || nBuffType >= ARRAYSIZE( g_RageBuffTypes ) )
{
DevMsg( "Invalid rage buff type %i for entindex %i\n", nBuffType, m_pOuter->entindex() );
ResetRageSystem();
return;
}
int nBuffPulses = g_RageBuffTypes[nBuffType].m_nMaxPulses;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, nBuffPulses, mod_buff_duration );
if ( nBuffPulses > 0 )
{
m_flRageMeter -= gpGlobals->frametime * ( 100 / nBuffPulses );
if ( m_flRageMeter <= 0.0f )
{
m_flRageMeter = 0.0f;
m_bRageDraining = false;
if ( g_SoldierBuffAttributeIDToConditionMap[ nBuffType ] == TF_COND_CRITBOOSTED_RAGE_BUFF )
{
// Pyro rage needs a cooldown so that the final crit flames
// don't significantly fill up his next rage meter
m_flNextRageEarnTime = gpGlobals->curtime + tf_flamethrower_flametime.GetFloat() + 0.1f;
}
}
}
else
{
ResetRageSystem();
}
}
#ifdef STAGING_ONLY
if ( m_flRageMeter >= 100.f )
{
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
{
if ( CanBuildSpyTraps() )
{
// Whenever a spy fills their rage meter, give them a speed boost and grenade (used by traps)
if ( m_pOuter->GetAmmoCount( TF_AMMO_GRENADES1 ) <= m_pOuter->GetMaxAmmo( TF_AMMO_GRENADES1 ) )
{
#ifdef GAME_DLL
m_pOuter->GiveAmmo( 1, TF_AMMO_GRENADES1 );
AddCond( TF_COND_SPEED_BOOST, 5.f );
#endif // GAME_DLL
m_flRageMeter = 0.f;
}
}
}
}
#endif // STAGING_ONLY
// Handle pulsing all of our active rage buffs.
for ( int i = 0; i < ARRAYSIZE( m_RageBuffSlots ); i++ )
{
RageBuff& rageBuff = m_RageBuffSlots[i];
if ( gpGlobals->curtime > rageBuff.m_flNextBuffPulseTime && rageBuff.m_iBuffPulseCount > 0 )
{
rageBuff.m_flNextBuffPulseTime += 1.0f;
--rageBuff.m_iBuffPulseCount;
PulseRageBuff( (ERageBuffSlot)i );
}
}
}
static const int k_RageBuffType_Sniper = 6;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetRageMeter( float val )
{
// Allow Sniper to gain rage on kills even when buffed
if ( !InCond( TF_COND_SNIPERCHARGE_RAGE_BUFF ) && !m_pOuter->IsPlayerClass( TF_CLASS_SPY ) )
{
if ( IsRageDraining() )
return;
// Can't earn rage until the time is past this delay
if ( val > m_flRageMeter && gpGlobals->curtime < m_flNextRageEarnTime )
return;
}
m_flRageMeter = MIN( val, 100.0f );
if ( InCond( TF_COND_SNIPERCHARGE_RAGE_BUFF ) )
{
Assert( k_RageBuffType_Sniper > 0 && k_RageBuffType_Sniper < ARRAYSIZE( g_RageBuffTypes ) ); // 0 is valid in the array, but an invalid buff
if ( k_RageBuffType_Sniper < 0 || k_RageBuffType_Sniper >= ARRAYSIZE( g_RageBuffTypes ) )
return;
int nBuffPulses = g_RageBuffTypes[k_RageBuffType_Sniper].m_nMaxPulses;
m_bRageDraining = true;
nBuffPulses *= (m_flRageMeter / 100);
m_RageBuffSlots[kBuffSlot_Rage].m_iBuffPulseCount = nBuffPulses;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::ModifyRage( float fDelta )
{
SetRageMeter( GetRageMeter() + fDelta );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::ResetRageMeter( void )
{
m_flRageMeter = 0.0f;
m_flNextRageEarnTime = 0.0f;
ResetRageBuffs();
UpdateRageBuffsAndRage();
}
//-----------------------------------------------------------------------------
// Purpose: Apply the buff effect to everyone within a radius around the player.
//-----------------------------------------------------------------------------
void CTFPlayerShared::PulseRageBuff( ERageBuffSlot eBuffSlot )
{
Assert( m_RageBuffSlots[eBuffSlot].m_iBuffTypeActive != 0 );
#ifdef CLIENT_DLL
// if this is not the local player, we don't want to do anything
if ( !m_pOuter->IsLocalPlayer() )
return;
int nBuffedFriends = 0;
#else
int nBuffedPlayers = 0;
#endif
int iSoldierBuffType = m_RageBuffSlots[eBuffSlot].m_iBuffTypeActive;
ETFCond eBuffCond = TF_COND_LAST;
if ( iSoldierBuffType > 0 || iSoldierBuffType <= kSoldierBuffCount )
{
eBuffCond = g_SoldierBuffAttributeIDToConditionMap[iSoldierBuffType];
}
float fMaxRadius = 450.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_pOuter, fMaxRadius, mod_soldier_buff_range );
const float fMaxRadiusSq = fMaxRadius * fMaxRadius;
for( int iPlayerIndex=1; iPlayerIndex<=MAX_PLAYERS; ++iPlayerIndex )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pTFPlayer || !pTFPlayer->IsAlive() )
continue;
if ( pTFPlayer->GetTeamNumber() != m_pOuter->GetTeamNumber() )
continue;
if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && (pTFPlayer->m_Shared.GetDisguiseTeam() != m_pOuter->GetTeamNumber()) )
continue; // For now don't give the buff to spies on our team who are disguised as enemies.
if ( pTFPlayer->m_Shared.IsStealthed() )
continue; // Don't give the buff to cloaked spies
Vector vDist = pTFPlayer->GetAbsOrigin() - m_pOuter->GetAbsOrigin();
if ( vDist.LengthSqr() > fMaxRadiusSq )
continue;
#ifdef CLIENT_DLL
if ( pTFPlayer != m_pOuter )
{
if ( eBuffCond == TF_COND_CRITBOOSTED_RAGE_BUFF || eBuffCond == TF_COND_SNIPERCHARGE_RAGE_BUFF )
{
// Pyro and sniper only buffs themselves
continue;
}
// this is not the localplayer, are they a friend?
if ( !steamapicontext->SteamFriends() || !steamapicontext->SteamUtils() )
return;
player_info_t pi;
if ( !engine->GetPlayerInfo( pTFPlayer->entindex(), &pi ) )
return;
if ( !pi.friendsID )
return;
// check and see if they're on the local player's friends list
CSteamID steamID( pi.friendsID, 1, GetUniverse(), k_EAccountTypeIndividual );
if ( steamapicontext->SteamFriends()->HasFriend( steamID, k_EFriendFlagImmediate ) )
{
nBuffedFriends++;
}
}
#else
if ( pTFPlayer != m_pOuter )
{
if ( eBuffCond == TF_COND_CRITBOOSTED_RAGE_BUFF || eBuffCond == TF_COND_SNIPERCHARGE_RAGE_BUFF )
{
// Pyro and sniper only buffs themselves
continue;
}
}
if ( eBuffCond != TF_COND_LAST )
{
pTFPlayer->m_Shared.AddCond( eBuffCond, 1.2f, m_pOuter );
nBuffedPlayers++;
IGameEvent* event = gameeventmanager->CreateEvent( "player_buff" );
if ( event )
{
event->SetInt( "userid", pTFPlayer->GetUserID() );
event->SetInt( "buff_owner", m_pOuter->GetUserID() );
event->SetInt( "buff_type", iSoldierBuffType );
gameeventmanager->FireEvent( event );
}
}
#endif
}
#ifdef CLIENT_DLL
if ( nBuffedFriends >= 5 )
{
g_AchievementMgrTF.OnAchievementEvent( ACHIEVEMENT_TF_SOLDIER_BUFF_FRIENDS );
}
#else
// ACHIEVEMENT_TF_MVM_SOLDIER_BUFF_TEAM
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
if ( ( m_pOuter->GetTeamNumber() == TF_TEAM_PVE_DEFENDERS ) && m_pOuter->IsPlayerClass( TF_CLASS_SOLDIER ) )
{
if ( nBuffedPlayers >= 5 )
{
m_pOuter->AwardAchievement( ACHIEVEMENT_TF_MVM_SOLDIER_BUFF_TEAM );
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::ResetRageSystem( void )
{
m_flRageMeter = 0.f;
m_bRageDraining = false;
m_flNextRageEarnTime = 0.f;
ResetRageBuffs();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateEnergyDrinkMeter( void )
{
if ( !m_pOuter->IsPlayerClass( TF_CLASS_SCOUT ) )
return;
bool bIsLocalPlayer = false;
#ifdef CLIENT_DLL
bIsLocalPlayer = m_pOuter->IsLocalPlayer();
#else
bIsLocalPlayer = true;
#endif
if ( bIsLocalPlayer )
{
if ( IsHypeBuffed() )
{
m_flHypeMeter -= gpGlobals->frametime * (m_fEnergyDrinkConsumeRate*0.75f);
if ( m_flHypeMeter <= 0.0f )
{
RemoveCond( TF_COND_SODAPOPPER_HYPE );
}
}
if ( InCond( TF_COND_PHASE ) || InCond( TF_COND_ENERGY_BUFF ) )
{
// Drain the meter
m_flEnergyDrinkMeter -= gpGlobals->frametime * m_fEnergyDrinkConsumeRate;
// If we've drained the meter, remove the condition
if ( m_flEnergyDrinkMeter <= 0.f )
{
if ( InCond( TF_COND_ENERGY_BUFF ) )
{
AddCond( TF_COND_MARKEDFORDEATH_SILENT, 2.f );
}
RemoveCond( TF_COND_PHASE );
RemoveCond( TF_COND_ENERGY_BUFF );
#ifdef GAME_DLL
m_pOuter->SpeakConceptIfAllowed( MP_CONCEPT_TIRED );
#endif
}
// Update the effect on phasing only
else if ( InCond( TF_COND_PHASE ) )
{
UpdatePhaseEffects();
}
}
else if ( m_flEnergyDrinkMeter < 100.0f )
{
// Regen the meter
m_flEnergyDrinkMeter += gpGlobals->frametime * m_fEnergyDrinkRegenRate;
CTFLunchBox_Drink *pDrink = static_cast< CTFLunchBox_Drink* >( m_pOuter->Weapon_OwnsThisID( TF_WEAPON_LUNCHBOX ) );
if ( pDrink )
{
// This is here in case something replenishes grenades
if ( m_flEnergyDrinkMeter < 100.0f && m_pOuter->GetAmmoCount( TF_AMMO_GRENADES2 ) == m_pOuter->GetMaxAmmo( TF_AMMO_GRENADES2 ) )
{
m_flEnergyDrinkMeter = 100.0f;
}
}
else if ( m_flEnergyDrinkMeter >= 100.0f )
{
m_flEnergyDrinkMeter = 100.0f;
}
}
}
}
void CTFPlayerShared::SetScoutHypeMeter( float val )
{
if ( IsHypeBuffed() )
return;
m_flHypeMeter = Clamp(val, 0.0f, 100.0f);
//if ( m_flHypeMeter >= 100.f )
//{
// if ( m_pOuter->IsPlayerClass( TF_CLASS_SCOUT ) )
// {
// CTFWeaponBase* pWeapon = m_pOuter->GetActiveTFWeapon();
// if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_SODA_POPPER )
// {
// AddCond( TF_COND_CRITBOOSTED_HYPE );
// }
// }
//}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::UpdateCloakMeter( void )
{
if ( !m_pOuter->IsPlayerClass( TF_CLASS_SPY ) )
return;
if ( InCond( TF_COND_STEALTHED ) )
{
if ( m_bMotionCloak )
{
// Motion cloak: drain based on our movement rate.
Vector vVel = m_pOuter->GetAbsVelocity();
float fSpdSqr = vVel.LengthSqr();
if ( fSpdSqr == 0.f )
{
if ( gpGlobals->curtime - m_flLastStealthExposeTime > 1.f )
{
m_flCloakMeter += gpGlobals->frametime * m_fCloakRegenRate;
if ( m_flCloakMeter >= 100.0f )
{
m_flCloakMeter = 100.0f;
}
}
}
else
{
float fFactor = RemapVal( fSpdSqr, 0, m_pOuter->MaxSpeed()*m_pOuter->MaxSpeed(), 0.f, 1.f );
if ( fFactor > 1.f )
{
fFactor = 1.f;
}
m_flCloakMeter -= gpGlobals->frametime * m_fCloakConsumeRate * fFactor * 1.5f;
if ( m_flCloakMeter < 0.f )
{
m_flCloakMeter = 0.f;
}
}
}
else
{
// Classic cloak: drain at a fixed rate.
m_flCloakMeter -= gpGlobals->frametime * m_fCloakConsumeRate;
}
if ( m_flCloakMeter <= 0.0f && !m_bMotionCloak)
{
FadeInvis( 1.0f );
}
// Update Debuffs
// Decrease duration if cloaked
#ifdef GAME_DLL
// staging_spy
float flReduction = gpGlobals->frametime * 0.75f;
for ( int i = 0; g_aDebuffConditions[i] != TF_COND_LAST; i++ )
{
if ( InCond( g_aDebuffConditions[i] ) )
{
if ( m_ConditionData[g_aDebuffConditions[i]].m_flExpireTime != PERMANENT_CONDITION )
{
m_ConditionData[g_aDebuffConditions[i]].m_flExpireTime = MAX( m_ConditionData[g_aDebuffConditions[i]].m_flExpireTime - flReduction, 0 );
}
// Burning and Bleeding and extra timers
if ( g_aDebuffConditions[i] == TF_COND_BURNING )
{
// Reduce the duration of this burn
m_flFlameRemoveTime -= flReduction;
}
else if ( g_aDebuffConditions[i] == TF_COND_BLEEDING )
{
// Reduce the duration of this bleeding
FOR_EACH_VEC( m_PlayerBleeds, i )
{
m_PlayerBleeds[i].flBleedingRemoveTime -= flReduction;
}
}
}
}
#endif
}
else
{
m_flCloakMeter += gpGlobals->frametime * m_fCloakRegenRate;
if ( m_flCloakMeter >= 100.0f )
{
m_flCloakMeter = 100.0f;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Whether we should be doing a radius heal (does not stack with a medigun)
//-----------------------------------------------------------------------------
void CTFPlayerShared::Heal_Radius( bool bActive )
{
if ( bActive )
{
m_bPulseRadiusHeal = true;
}
else
{
m_bPulseRadiusHeal = false;
#ifdef GAME_DLL
// Stop any Radius healing
if ( m_iRadiusHealTargets.Count() > 0 )
{
for ( int iIndex = 0; iIndex < m_iRadiusHealTargets.Count(); iIndex++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( m_iRadiusHealTargets[iIndex] ) );
if ( !pTFPlayer )
continue;
pTFPlayer->m_Shared.StopHealing( m_pOuter );
}
m_iRadiusHealTargets.RemoveAll();
}
#endif // GAME_DLL
#ifdef CLIENT_DLL
if ( m_pOuter && m_pOuter->m_pRadiusHealEffect )
{
m_pOuter->ParticleProp()->StopEmission( m_pOuter->m_pRadiusHealEffect );
}
m_pOuter->m_pRadiusHealEffect = NULL;
#endif // CLIENT_DLL
}
}
#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ConVar tf_rocket_pack_cooldown( "tf_rocket_pack_cooldown", "1.f", FCVAR_CHEAT | FCVAR_REPLICATED );
ConVar tf_rocket_pack_enabled( "tf_rocket_pack_enabled", "0", FCVAR_CHEAT | FCVAR_REPLICATED );
void CTFPlayerShared::DoRocketPack()
{
if ( !tf_rocket_pack_enabled.GetBool() )
return;
if ( !( m_pOuter->m_nButtons & IN_ATTACK3 ) )
return;
if ( gpGlobals->curtime < m_flNextRocketPackTime )
return;
#ifdef GAME_DLL
// Launch
if ( !InCond( TF_COND_ROCKETPACK ) )
{
AddCond( TF_COND_ROCKETPACK );
StunPlayer( 0.5f, 1.0f, TF_STUN_MOVEMENT );
}
#endif
Vector vecDir;
m_pOuter->EyeVectors( &vecDir );
m_pOuter->SetAbsVelocity( vec3_origin );
Vector vecFlightDir = -vecDir;
VectorNormalize( vecFlightDir );
float flForce = 450.f;
const float flPushScale = ( m_pOuter->GetFlags() & FL_ONGROUND ) ? 1.2f : 1.8f; // Greater force while airborne
const float flVertPushScale = ( m_pOuter->GetFlags() & FL_ONGROUND ) ? 1.2f : 0.25f; // Less vertical force while airborne
Vector vecForce = vecFlightDir * -flForce * flPushScale;
vecForce.z += 1.f * flForce * flVertPushScale;
m_pOuter->RemoveFlag( FL_ONGROUND );
m_pOuter->ApplyAbsVelocityImpulse( vecForce );
m_pOuter->EmitSound( "Equipment.RocketPack_Activate" );
m_flNextRocketPackTime = gpGlobals->curtime + tf_rocket_pack_cooldown.GetFloat();
}
#endif // STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose: Emits an area-of-effect heal around the medic
//-----------------------------------------------------------------------------
void CTFPlayerShared::PulseMedicRadiusHeal( void )
{
if ( !m_bPulseRadiusHeal )
{
#ifdef GAME_DLL
Assert( m_iRadiusHealTargets.Count() == 0 );
if ( m_iRadiusHealTargets.Count() > 0 )
{
// We shouldn't have any heal targets if we aren't pulsing.
Heal_Radius( false );
}
#endif
return;
}
// If we're set to heal, make sure it's still valid
if ( !m_pOuter->IsAlive() || ( !m_pOuter->IsPlayerClass( TF_CLASS_MEDIC ) && !InCond( TF_COND_RADIUSHEAL_ON_DAMAGE ) ) )
{
Heal_Radius( false );
return;
}
#ifdef GAME_DLL
if ( gpGlobals->curtime >= m_flRadiusHealCheckTime )
{
for( int iPlayerIndex = 1; iPlayerIndex <= MAX_PLAYERS; ++iPlayerIndex )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pTFPlayer || !pTFPlayer->IsAlive() )
continue;
// Don't heal ourselves, unless this is due to radius heal on damage proc
if ( pTFPlayer == m_pOuter && !InCond( TF_COND_RADIUSHEAL_ON_DAMAGE ) )
continue;
if ( !pTFPlayer->InSameTeam( m_pOuter ) )
{
if ( !pTFPlayer->m_Shared.IsStealthed() && !pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
continue;
if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && ( pTFPlayer->m_Shared.GetDisguiseTeam() != m_pOuter->GetTeamNumber() ) )
continue;
}
// Don't heal players with weapon_blocks_healing
CTFWeaponBase *pTFWeapon = pTFPlayer->GetActiveTFWeapon();
if ( pTFWeapon )
{
int iBlockHealing = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFWeapon, iBlockHealing, weapon_blocks_healing );
if ( iBlockHealing )
continue;
}
Vector vDist = pTFPlayer->GetAbsOrigin() - m_pOuter->GetAbsOrigin();
if ( vDist.LengthSqr() <= 450 * 450 )
{
// Ignore players we can't see
trace_t trace;
UTIL_TraceLine( pTFPlayer->WorldSpaceCenter(), m_pOuter->WorldSpaceCenter(), MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace );
if ( trace.fraction < 1.0f )
continue;
// Refresh this condition, which we use to give players a particle effect
pTFPlayer->m_Shared.AddCond( TF_COND_RADIUSHEAL, 1.2f );
// Make sure we're not already healing them
if ( m_iRadiusHealTargets.Find( iPlayerIndex ) == m_iRadiusHealTargets.InvalidIndex() )
{
m_iRadiusHealTargets.AddToTail( iPlayerIndex );
pTFPlayer->m_Shared.Heal( m_pOuter, 25, 1, 1 );
}
}
else
{
if ( m_iRadiusHealTargets.Find( iPlayerIndex ) != m_iRadiusHealTargets.InvalidIndex() )
{
m_iRadiusHealTargets.FindAndRemove( iPlayerIndex );
pTFPlayer->m_Shared.StopHealing( m_pOuter );
}
}
}
m_flRadiusHealCheckTime = gpGlobals->curtime + 1.0f;
}
#endif // GAME_DLL
#ifdef CLIENT_DLL
// Radius healer gets an effect to broadcast to others what they're doing
if ( !m_pOuter->m_pRadiusHealEffect )
{
const char *pszRadiusHealEffect;
if ( m_pOuter->GetTeamNumber() == TF_TEAM_RED )
{
pszRadiusHealEffect = "medic_healradius_red_buffed";
}
else
{
pszRadiusHealEffect = "medic_healradius_blue_buffed";
}
m_pOuter->m_pRadiusHealEffect = m_pOuter->ParticleProp()->Create( pszRadiusHealEffect, PATTACH_ABSORIGIN_FOLLOW, NULL, Vector( 0, 0, 0 ) );
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose: Emits an area-of-effect buff around the King Rune carrier
//-----------------------------------------------------------------------------
void CTFPlayerShared::PulseKingRuneBuff( void )
{
// Make sure we have the King Powerup and are not invisible
if ( !m_pOuter->IsAlive() || IsStealthed() || GetCarryingRuneType() != RUNE_KING )
{
return;
}
#ifdef GAME_DLL
if ( gpGlobals->curtime >= m_flKingRuneBuffCheckTime )
{
m_bKingRuneBuffActive = false;
// Plague blocks king team buff
if ( !InCond( TF_COND_PLAGUE ) )
{
for ( int iPlayerIndex = 1; iPlayerIndex <= MAX_PLAYERS; ++iPlayerIndex )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pTFPlayer || !pTFPlayer->IsAlive() )
continue;
// Ignore players outside of the buff radius
Vector vDist = pTFPlayer->GetAbsOrigin() - m_pOuter->GetAbsOrigin();
if ( vDist.LengthSqr() >= 768 * 768 )
continue;
// If King is the only player, there's no effect
if ( pTFPlayer == m_pOuter )
continue;
// Spies who are invisible or disguised as the King's enemy team are ignored
if ( pTFPlayer->m_Shared.IsStealthed() || ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pTFPlayer->m_Shared.GetDisguiseTeam() != m_pOuter->GetTeamNumber() ) )
continue;
// Enemies - ignore unless they are disguised as the King's team
if ( !pTFPlayer->InSameTeam( m_pOuter ) && !pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
continue;
pTFPlayer->m_Shared.AddCond( TF_COND_KING_BUFFED, 1.f );
m_bKingRuneBuffActive = true;
}
}
m_flKingRuneBuffCheckTime = gpGlobals->curtime + 0.5f;
}
#endif // GAME_DLL
#ifdef CLIENT_DLL
// King Rune carrier gets an effect to show that he's buffing someone
if ( m_bKingRuneBuffActive && !InCond( TF_COND_PLAGUE ) )
{
if ( !m_pOuter->m_pKingRuneRadiusEffect )
{
const char *pszRadiusEffect;
if ( m_pOuter->GetTeamNumber() == TF_TEAM_RED )
{
pszRadiusEffect = "powerup_king_red";
}
else
{
pszRadiusEffect = "powerup_king_blue";
}
m_pOuter->m_pKingRuneRadiusEffect = m_pOuter->ParticleProp()->Create( pszRadiusEffect, PATTACH_ABSORIGIN_FOLLOW, NULL, Vector( 0, 0, 0 ) );
}
}
else
{
EndKingBuffRadiusEffect();
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::IncrementRevengeCrits( void )
{
SetRevengeCrits( m_iRevengeCrits + 1 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetRevengeCrits( int iVal )
{
m_iRevengeCrits = clamp( iVal, 0, 35 );
CTFWeaponBase *pWeapon = m_pOuter->GetActiveTFWeapon();
if ( ( pWeapon && pWeapon->CanHaveRevengeCrits() ) )
{
if ( m_iRevengeCrits > 0 && !InCond( TF_COND_CRITBOOSTED ) )
{
AddCond( TF_COND_CRITBOOSTED );
}
else if ( m_iRevengeCrits == 0 && InCond( TF_COND_CRITBOOSTED ) )
{
RemoveCond( TF_COND_CRITBOOSTED );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerShared::FireGameEvent( IGameEvent *event )
{
#ifdef GAME_DLL
const char *eventName = event->GetName();
if ( !Q_strcmp( eventName, "player_disconnect" ) )
{
CBasePlayer *pPlayer = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
if ( pPlayer )
{
int iIndex = m_iRadiusHealTargets.Find( pPlayer->entindex() );
if ( iIndex != m_iRadiusHealTargets.InvalidIndex() )
{
m_iRadiusHealTargets.FastRemove( iIndex );
}
}
}
#endif //GAME_DLL
}
//-----------------------------------------------------------------------------
void CTFPlayerShared::SetPasstimePassTarget( CTFPlayer *pEnt )
{
if ( CBaseEntity *pTarget = m_hPasstimePassTarget )
{
CTFPlayer *pPlayerTarget = ToTFPlayer( pTarget );
if ( pPlayerTarget )
pPlayerTarget->m_Shared.m_bIsTargetedForPasstimePass = false;
}
Assert( pEnt != m_pOuter );
m_hPasstimePassTarget = pEnt;
if ( CBaseEntity *pTarget = m_hPasstimePassTarget )
{
CTFPlayer *pPlayerTarget = ToTFPlayer( pTarget );
if ( pPlayerTarget )
pPlayerTarget->m_Shared.m_bIsTargetedForPasstimePass = true;
}
}
//-----------------------------------------------------------------------------
CTFPlayer *CTFPlayerShared::GetPasstimePassTarget() const { return m_hPasstimePassTarget.Get(); }
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTraceFilterIgnoreTeammatesAndTeamObjects::ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );
if ( pEntity->GetTeamNumber() == m_iIgnoreTeam )
{
return false;
}
CTFPlayer *pPlayer = dynamic_cast<CTFPlayer*>( pEntity );
if ( pPlayer )
{
if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pPlayer->m_Shared.GetDisguiseTeam() == m_iIgnoreTeam )
return false;
if ( pPlayer->m_Shared.IsStealthed() )
return false;
}
return BaseClass::ShouldHitEntity( pServerEntity, contentsMask );
}
void CTFPlayerShared::SetCarriedObject( CBaseObject* pObj )
{
m_bCarryingObject = (pObj != NULL);
m_hCarriedObject.Set( pObj );
#ifdef GAME_DLL
if ( m_pOuter )
m_pOuter->TeamFortress_SetSpeed();
#endif
}
void localplayerscoring_t::UpdateStats( RoundStats_t& roundStats, CTFPlayer *pPlayer, bool bIsRoundData )
{
m_iCaptures = roundStats.m_iStat[TFSTAT_CAPTURES];
m_iDefenses = roundStats.m_iStat[TFSTAT_DEFENSES];
m_iKills = roundStats.m_iStat[TFSTAT_KILLS];
m_iDeaths = roundStats.m_iStat[TFSTAT_DEATHS];
m_iSuicides = roundStats.m_iStat[TFSTAT_SUICIDES];
m_iKillAssists = roundStats.m_iStat[TFSTAT_KILLASSISTS];
m_iBuildingsBuilt = roundStats.m_iStat[TFSTAT_BUILDINGSBUILT];
m_iBuildingsDestroyed = roundStats.m_iStat[TFSTAT_BUILDINGSDESTROYED];
m_iHeadshots = roundStats.m_iStat[TFSTAT_HEADSHOTS];
m_iDominations = roundStats.m_iStat[TFSTAT_DOMINATIONS];
m_iRevenge = roundStats.m_iStat[TFSTAT_REVENGE];
m_iInvulns = roundStats.m_iStat[TFSTAT_INVULNS];
m_iTeleports = roundStats.m_iStat[TFSTAT_TELEPORTS];
m_iDamageDone = roundStats.m_iStat[TFSTAT_DAMAGE];
m_iCrits = roundStats.m_iStat[TFSTAT_CRITS];
m_iBackstabs = roundStats.m_iStat[TFSTAT_BACKSTABS];
int iHealthPointsHealed = (int) roundStats.m_iStat[TFSTAT_HEALING];
// send updated healing data every 10 health points, and round off what we send to nearest 10 points
int iHealPointsDelta = abs( iHealthPointsHealed - m_iHealPoints );
if ( iHealPointsDelta > 10 )
{
m_iHealPoints = ( iHealthPointsHealed / 10 ) * 10;
}
m_iBonusPoints = roundStats.m_iStat[TFSTAT_BONUS_POINTS] / TF_SCORE_BONUS_POINT_DIVISOR;
const int nPoints = TFGameRules()->CalcPlayerScore( &roundStats, pPlayer );
const int nDelta = nPoints - m_iPoints;
m_iPoints = nPoints;
if ( nDelta > 0 && !bIsRoundData )
{
IGameEvent *event = gameeventmanager->CreateEvent( "player_score_changed" );
if ( event )
{
event->SetInt( "player", pPlayer->entindex() );
event->SetInt( "delta", nDelta );
gameeventmanager->FireEvent( event );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconItemView *CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( CTFPlayer *pTFPlayer, int iSlot, CEconEntity **pEntity )
{
int iClass = pTFPlayer->GetPlayerClass()->GetClassIndex();
// See if it's a weapon first
for ( int i = 0; i < MAX_WEAPONS; i++ )
{
CTFWeaponBase *pWeapon = (CTFWeaponBase *)pTFPlayer->GetWeapon(i);
if ( !pWeapon )
continue;
CEconItemView *pEconItemView = pWeapon->GetAttributeContainer()->GetItem();
if ( !pEconItemView )
continue;
int iLoadoutSlot = pEconItemView->GetStaticData()->GetLoadoutSlot( iClass );
if ( iLoadoutSlot == iSlot )
{
if ( pEntity )
{
*pEntity = pWeapon;
}
return pEconItemView;
}
}
// Go through each of the actual items we have equipped right now...
for ( int i = 0; i < pTFPlayer->GetNumWearables(); ++i )
{
CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pTFPlayer->GetWearable( i ) );
if ( !pWearableItem )
continue;
if ( !pWearableItem->GetAttributeContainer() )
continue;
CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem();
if ( !pEconItemView )
continue;
CTFItemDefinition *pItemDef = pEconItemView->GetStaticData();
if ( !pItemDef )
continue;
if ( pItemDef->GetLoadoutSlot(iClass) != iSlot )
continue;
// Yay!
if ( pEntity )
{
*pEntity = pWearableItem;
}
return pEconItemView;
}
// Nothing we currently have equipped claims to be in this slot.
if ( pEntity )
{
*pEntity = NULL;
}
return NULL;
}
bool CTFPlayerSharedUtils::ConceptIsPartnerTaunt( int iConcept )
{
return iConcept == MP_CONCEPT_HIGHFIVE_SUCCESS_FULL || iConcept == MP_CONCEPT_HIGHFIVE_SUCCESS;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFWeaponBuilder *CTFPlayerSharedUtils::GetBuilderForObjectType( CTFPlayer *pTFPlayer, int iObjectType )
{
const int OBJ_ANY = -1;
if ( !pTFPlayer )
return NULL;
for ( int i = 0; i < MAX_WEAPONS; i++ )
{
CTFWeaponBuilder *pBuilder = dynamic_cast< CTFWeaponBuilder* >( pTFPlayer->GetWeapon( i ) );
if ( !pBuilder )
continue;
// Any builder will do - return first
if ( iObjectType == OBJ_ANY )
return pBuilder;
// Requires a specific builder for this type
if ( pBuilder->CanBuildObjectType( iObjectType ) )
return pBuilder;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Can player pick up this weapon?
//-----------------------------------------------------------------------------
bool CTFPlayer::CanPickupDroppedWeapon( const CTFDroppedWeapon *pWeapon )
{
if ( !pWeapon->GetItem()->IsValid() )
return false;
int iClass = GetPlayerClass()->GetClassIndex();
if ( iClass == TF_CLASS_SPY && ( m_Shared.InCond( TF_COND_DISGUISED ) || m_Shared.GetPercentInvisible() > 0 ) )
return false;
if ( IsTaunting() )
return false;
if ( !IsAlive() )
return false;
// There's a rare case that the player doesn't have an active weapon. This shouldn't happen.
// If you hit this assert, figure out and fix WHY the player doesn't have a weapon.
Assert( GetActiveTFWeapon() );
if ( !GetActiveTFWeapon() || !GetActiveTFWeapon()->CanPickupOtherWeapon() )
return false;
int iItemSlot = pWeapon->GetItem()->GetStaticData()->GetLoadoutSlot( iClass );
CBaseEntity *pOwnedWeaponToDrop = GetEntityForLoadoutSlot( iItemSlot );
return pOwnedWeaponToDrop && pWeapon->GetItem()->GetStaticData()->CanBeUsedByClass( iClass ) && IsValidPickupWeaponSlot( iItemSlot );
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if player is in range to pick up this weapon
//-----------------------------------------------------------------------------
CTFDroppedWeapon* CTFPlayer::GetDroppedWeaponInRange()
{
// Check to see if a building we own is in front of us.
Vector vecForward;
AngleVectors( EyeAngles(), &vecForward );
trace_t tr;
UTIL_TraceLine( EyePosition(), EyePosition() + vecForward * TF_WEAPON_PICKUP_RANGE, MASK_SOLID | CONTENTS_DEBRIS, this, COLLISION_GROUP_NONE, &tr );
CTFDroppedWeapon *pDroppedWeapon = dynamic_cast< CTFDroppedWeapon * >( tr.m_pEnt );
if ( !pDroppedWeapon )
return NULL;
if ( !CanPickupDroppedWeapon( pDroppedWeapon ) )
return NULL;
// too far?
if ( EyePosition().DistToSqr( pDroppedWeapon->GetAbsOrigin() ) > Square( TF_WEAPON_PICKUP_RANGE ) )
return NULL;
return pDroppedWeapon;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if player is inspecting
//-----------------------------------------------------------------------------
bool CTFPlayer::IsInspecting() const
{
return m_flInspectTime != 0.f && gpGlobals->curtime - m_flInspectTime > 0.2f;
}