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.
3002 lines
86 KiB
3002 lines
86 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose: The Medic's Medikit weapon
|
||
|
//
|
||
|
//
|
||
|
// $Workfile: $
|
||
|
// $Date: $
|
||
|
// $NoKeywords: $
|
||
|
//=============================================================================//
|
||
|
#include "cbase.h"
|
||
|
#include "in_buttons.h"
|
||
|
#include "engine/IEngineSound.h"
|
||
|
#include "tf_gamerules.h"
|
||
|
#include "tf_item.h"
|
||
|
#include "entity_capture_flag.h"
|
||
|
|
||
|
#if defined( CLIENT_DLL )
|
||
|
#include <vgui_controls/Panel.h>
|
||
|
#include <vgui/ISurface.h>
|
||
|
#include "particles_simple.h"
|
||
|
#include "c_tf_player.h"
|
||
|
#include "soundenvelope.h"
|
||
|
#include "tf_hud_mediccallers.h"
|
||
|
#include "c_tf_playerresource.h"
|
||
|
#include "prediction.h"
|
||
|
#else
|
||
|
#include "ndebugoverlay.h"
|
||
|
#include "tf_player.h"
|
||
|
#include "tf_team.h"
|
||
|
#include "tf_gamestats.h"
|
||
|
#include "ilagcompensationmanager.h"
|
||
|
#include "tf_obj.h"
|
||
|
#include "inetchannel.h"
|
||
|
#include "IEffects.h"
|
||
|
#include "baseprojectile.h"
|
||
|
#include "soundenvelope.h"
|
||
|
#include "effect_dispatch_data.h"
|
||
|
#include "func_respawnroom.h"
|
||
|
#endif
|
||
|
|
||
|
#include "tf_revive.h"
|
||
|
#include "tf_weapon_medigun.h"
|
||
|
#include "tf_weapon_shovel.h"
|
||
|
|
||
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
#include "tier0/memdbgon.h"
|
||
|
|
||
|
|
||
|
MedigunEffects_t g_MedigunEffects[MEDIGUN_NUM_CHARGE_TYPES] =
|
||
|
{
|
||
|
{ TF_COND_INVULNERABLE, TF_COND_INVULNERABLE_WEARINGOFF, "TFPlayer.InvulnerableOn", "TFPlayer.InvulnerableOff" }, // MEDIGUN_CHARGE_INVULN = 0,
|
||
|
{ TF_COND_CRITBOOSTED, TF_COND_LAST, "TFPlayer.CritBoostOn", "TFPlayer.CritBoostOff" }, // MEDIGUN_CHARGE_CRITICALBOOST,
|
||
|
{ TF_COND_MEGAHEAL, TF_COND_LAST, "TFPlayer.QuickFixInvulnerableOn", "TFPlayer.MegaHealOff" }, // MEDIGUN_CHARGE_MEGAHEAL,
|
||
|
{ TF_COND_MEDIGUN_UBER_BULLET_RESIST, TF_COND_LAST, "WeaponMedigun_Vaccinator.InvulnerableOn", "WeaponMedigun_Vaccinator.InvulnerableOff" }, // TF_COND_MEDIGUN_UBER_BULLET_RESIST,
|
||
|
{ TF_COND_MEDIGUN_UBER_BLAST_RESIST, TF_COND_LAST, "WeaponMedigun_Vaccinator.InvulnerableOn", "WeaponMedigun_Vaccinator.InvulnerableOff" }, // TF_COND_MEDIGUN_UBER_BLAST_RESIST,
|
||
|
{ TF_COND_MEDIGUN_UBER_FIRE_RESIST, TF_COND_LAST, "WeaponMedigun_Vaccinator.InvulnerableOn", "WeaponMedigun_Vaccinator.InvulnerableOff" }, // TF_COND_MEDIGUN_UBER_FIRE_RESIST,
|
||
|
};
|
||
|
|
||
|
struct MedigunResistConditions_t
|
||
|
{
|
||
|
medigun_resist_types_t eResistType;
|
||
|
ETFCond passiveCond;
|
||
|
ETFCond uberCond;
|
||
|
};
|
||
|
|
||
|
MedigunResistConditions_t g_MedigunResistConditions[MEDIGUN_NUM_RESISTS] =
|
||
|
{
|
||
|
{ MEDIGUN_BULLET_RESIST, TF_COND_MEDIGUN_SMALL_BULLET_RESIST, TF_COND_MEDIGUN_UBER_BULLET_RESIST },
|
||
|
{ MEDIGUN_BLAST_RESIST, TF_COND_MEDIGUN_SMALL_BLAST_RESIST, TF_COND_MEDIGUN_UBER_BLAST_RESIST },
|
||
|
{ MEDIGUN_FIRE_RESIST, TF_COND_MEDIGUN_SMALL_FIRE_RESIST, TF_COND_MEDIGUN_UBER_FIRE_RESIST }
|
||
|
};
|
||
|
|
||
|
// Buff ranges
|
||
|
ConVar weapon_medigun_damage_modifier( "weapon_medigun_damage_modifier", "1.5", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Scales the damage a player does while being healed with the medigun." );
|
||
|
ConVar weapon_medigun_construction_rate( "weapon_medigun_construction_rate", "10", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Constructing object health healed per second by the medigun." );
|
||
|
ConVar weapon_medigun_charge_rate( "weapon_medigun_charge_rate", "40", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Amount of time healing it takes to fully charge the medigun." );
|
||
|
ConVar weapon_medigun_chargerelease_rate( "weapon_medigun_chargerelease_rate", "8", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Amount of time it takes the a full charge of the medigun to be released." );
|
||
|
ConVar weapon_medigun_resist_num_chunks( "weapon_medigun_resist_num_chunks", "4", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "How many uber bar chunks the vaccinator has." );
|
||
|
ConVar tf_vaccinator_uber_charge_rate_modifier( "tf_vaccinator_uber_charge_rate_modifier", "1.0", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY , "Vaccinator uber charge rate." );
|
||
|
|
||
|
#if defined (CLIENT_DLL)
|
||
|
ConVar tf_medigun_autoheal( "tf_medigun_autoheal", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE | FCVAR_USERINFO, "Setting this to 1 will cause the Medigun's primary attack to be a toggle instead of needing to be held down." );
|
||
|
#endif
|
||
|
|
||
|
#if !defined (CLIENT_DLL)
|
||
|
ConVar tf_medigun_lagcomp( "tf_medigun_lagcomp", "1", FCVAR_DEVELOPMENTONLY );
|
||
|
#endif
|
||
|
|
||
|
static const char *s_pszMedigunHealTargetThink = "MedigunHealTargetThink";
|
||
|
|
||
|
extern ConVar tf_invuln_time;
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void RecvProxy_HealingTarget( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
||
|
{
|
||
|
CWeaponMedigun *pMedigun = ((CWeaponMedigun*)(pStruct));
|
||
|
if ( pMedigun != NULL )
|
||
|
{
|
||
|
pMedigun->ForceHealingTargetUpdate();
|
||
|
}
|
||
|
|
||
|
RecvProxy_IntToEHandle( pData, pStruct, pOut );
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( tf_weapon_medigun, CWeaponMedigun );
|
||
|
PRECACHE_WEAPON_REGISTER( tf_weapon_medigun );
|
||
|
|
||
|
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMedigun, DT_WeaponMedigun )
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
void* SendProxy_SendActiveLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID );
|
||
|
void* SendProxy_SendNonLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID );
|
||
|
#endif
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Only sent when a player's holding it.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
BEGIN_NETWORK_TABLE_NOBASE( CWeaponMedigun, DT_LocalTFWeaponMedigunData )
|
||
|
#if defined( CLIENT_DLL )
|
||
|
RecvPropFloat( RECVINFO(m_flChargeLevel) ),
|
||
|
#else
|
||
|
SendPropFloat( SENDINFO(m_flChargeLevel), 0, SPROP_NOSCALE | SPROP_CHANGES_OFTEN ),
|
||
|
#endif
|
||
|
END_NETWORK_TABLE()
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Variables sent at low precision to non-holding observers.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
BEGIN_NETWORK_TABLE_NOBASE( CWeaponMedigun, DT_TFWeaponMedigunDataNonLocal )
|
||
|
#if defined( CLIENT_DLL )
|
||
|
RecvPropFloat( RECVINFO(m_flChargeLevel) ),
|
||
|
#else
|
||
|
SendPropFloat( SENDINFO(m_flChargeLevel), 12, SPROP_NOSCALE | SPROP_CHANGES_OFTEN, 0.0, 100.0f ),
|
||
|
#endif
|
||
|
END_NETWORK_TABLE()
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Variables always sent
|
||
|
//-----------------------------------------------------------------------------
|
||
|
BEGIN_NETWORK_TABLE( CWeaponMedigun, DT_WeaponMedigun )
|
||
|
#if !defined( CLIENT_DLL )
|
||
|
// SendPropFloat( SENDINFO(m_flChargeLevel), 0, SPROP_NOSCALE | SPROP_CHANGES_OFTEN ),
|
||
|
SendPropEHandle( SENDINFO( m_hHealingTarget ) ),
|
||
|
SendPropBool( SENDINFO( m_bHealing ) ),
|
||
|
SendPropBool( SENDINFO( m_bAttacking ) ),
|
||
|
SendPropBool( SENDINFO( m_bChargeRelease ) ),
|
||
|
SendPropBool( SENDINFO( m_bHolstered ) ),
|
||
|
SendPropInt( SENDINFO( m_nChargeResistType ) ),
|
||
|
SendPropDataTable("LocalTFWeaponMedigunData", 0, &REFERENCE_SEND_TABLE(DT_LocalTFWeaponMedigunData), SendProxy_SendLocalWeaponDataTable ),
|
||
|
SendPropDataTable("NonLocalTFWeaponMedigunData", 0, &REFERENCE_SEND_TABLE(DT_TFWeaponMedigunDataNonLocal), SendProxy_SendNonLocalWeaponDataTable ),
|
||
|
#else
|
||
|
// RecvPropFloat( RECVINFO(m_flChargeLevel) ),
|
||
|
RecvPropEHandle( RECVINFO( m_hHealingTarget ), RecvProxy_HealingTarget ),
|
||
|
RecvPropBool( RECVINFO( m_bHealing ) ),
|
||
|
RecvPropBool( RECVINFO( m_bAttacking ) ),
|
||
|
RecvPropBool( RECVINFO( m_bChargeRelease ) ),
|
||
|
RecvPropBool( RECVINFO( m_bHolstered ) ),
|
||
|
RecvPropInt( RECVINFO( m_nChargeResistType ) ),
|
||
|
RecvPropDataTable("LocalTFWeaponMedigunData", 0, 0, &REFERENCE_RECV_TABLE(DT_LocalTFWeaponMedigunData)),
|
||
|
RecvPropDataTable("NonLocalTFWeaponMedigunData", 0, 0, &REFERENCE_RECV_TABLE(DT_TFWeaponMedigunDataNonLocal)),
|
||
|
#endif
|
||
|
END_NETWORK_TABLE()
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
BEGIN_PREDICTION_DATA( CWeaponMedigun )
|
||
|
|
||
|
DEFINE_PRED_FIELD( m_bHealing, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
|
||
|
DEFINE_PRED_FIELD( m_bAttacking, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
|
||
|
DEFINE_PRED_FIELD( m_bHolstered, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
|
||
|
DEFINE_PRED_FIELD( m_hHealingTarget, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
|
||
|
|
||
|
DEFINE_FIELD( m_bCanChangeTarget, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_flHealEffectLifetime, FIELD_FLOAT ),
|
||
|
|
||
|
DEFINE_PRED_FIELD( m_flChargeLevel, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
|
||
|
DEFINE_PRED_FIELD( m_bChargeRelease, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
|
||
|
|
||
|
// DEFINE_PRED_FIELD( m_bPlayingSound, FIELD_BOOLEAN ),
|
||
|
// DEFINE_PRED_FIELD( m_bUpdateHealingTargets, FIELD_BOOLEAN ),
|
||
|
|
||
|
END_PREDICTION_DATA()
|
||
|
#endif
|
||
|
|
||
|
#define PARTICLE_PATH_VEL 140.0
|
||
|
#define NUM_PATH_PARTICLES_PER_SEC 300.0f
|
||
|
#define NUM_MEDIGUN_PATH_POINTS 8
|
||
|
|
||
|
|
||
|
extern ConVar tf_max_health_boost;
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: For HUD auto medic callers
|
||
|
//-----------------------------------------------------------------------------
|
||
|
#ifdef CLIENT_DLL
|
||
|
ConVar hud_medicautocallers( "hud_medicautocallers", "0", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX );
|
||
|
ConVar hud_medicautocallersthreshold( "hud_medicautocallersthreshold", "75", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX );
|
||
|
ConVar hud_medichealtargetmarker ( "hud_medichealtargetmarker", "0", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX );
|
||
|
#endif
|
||
|
|
||
|
const char *g_pszMedigunHealSounds[MEDIGUN_NUM_CHARGE_TYPES] =
|
||
|
{
|
||
|
"WeaponMedigun.Healing", // MEDIGUN_CHARGE_INVULN = 0,
|
||
|
"WeaponMedigun.Healing", // MEDIGUN_CHARGE_CRITICALBOOST,
|
||
|
"Weapon_Quick_Fix.Healing", // MEDIGUN_CHARGE_MEGAHEAL,
|
||
|
"WeaponMedigun_Vaccinator.Healing", // MEDIGUN_CHARGE_RESIST,
|
||
|
};
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CWeaponMedigun::CWeaponMedigun( void )
|
||
|
{
|
||
|
WeaponReset();
|
||
|
|
||
|
SetPredictionEligible( true );
|
||
|
}
|
||
|
|
||
|
CWeaponMedigun::~CWeaponMedigun()
|
||
|
{
|
||
|
#ifdef CLIENT_DLL
|
||
|
StopChargeEffect( true );
|
||
|
|
||
|
if ( m_pChargedSound )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pChargedSound );
|
||
|
}
|
||
|
|
||
|
if ( m_pDisruptSound )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pDisruptSound );
|
||
|
}
|
||
|
|
||
|
m_flAutoCallerCheckTime = 0.0f;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::WeaponReset( void )
|
||
|
{
|
||
|
BaseClass::WeaponReset();
|
||
|
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( m_bHealing && pOwner && pOwner->m_Shared.InState( TF_STATE_DYING ) )
|
||
|
{
|
||
|
m_bWasHealingBeforeDeath = true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_bWasHealingBeforeDeath = false;
|
||
|
}
|
||
|
|
||
|
m_flHealEffectLifetime = 0;
|
||
|
|
||
|
m_bHealing = false;
|
||
|
m_bAttacking = false;
|
||
|
m_bChargeRelease = false;
|
||
|
m_DetachedTargets.Purge();
|
||
|
m_flEndResistCharge = 0.f;
|
||
|
|
||
|
m_bCanChangeTarget = true;
|
||
|
|
||
|
m_flNextBuzzTime = 0;
|
||
|
m_flReleaseStartedAt = 0;
|
||
|
|
||
|
int iPreserveUber = 0;
|
||
|
if ( TFGameRules()->State_Get() == GR_STATE_RND_RUNNING )
|
||
|
{
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pOwner, iPreserveUber, preserve_ubercharge );
|
||
|
m_flChargeLevel = MIN( m_flChargeLevel, iPreserveUber / 100.f );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_flChargeLevel = 0;
|
||
|
}
|
||
|
|
||
|
RemoveHealingTarget( true );
|
||
|
|
||
|
m_bAttack2Down = false;
|
||
|
m_bAttack3Down = false;
|
||
|
m_bReloadDown = false;
|
||
|
|
||
|
m_nChargeResistType = 0;
|
||
|
|
||
|
#if defined( GAME_DLL )
|
||
|
StopHealingOwner();
|
||
|
m_hLastHealingTarget = NULL;
|
||
|
RecalcEffectOnTarget( ToTFPlayer( GetOwnerEntity() ), true );
|
||
|
m_nHealTargetClass = 0;
|
||
|
m_nChargesReleased = 0;
|
||
|
#endif
|
||
|
|
||
|
#if defined( CLIENT_DLL )
|
||
|
m_nOldChargeResistType = 0;
|
||
|
m_bPlayingSound = false;
|
||
|
m_bUpdateHealingTargets = false;
|
||
|
m_bOldChargeRelease = false;
|
||
|
|
||
|
UpdateEffects();
|
||
|
StopChargeEffect( true );
|
||
|
|
||
|
m_pChargeEffectOwner = NULL;
|
||
|
m_pChargeEffect = NULL;
|
||
|
m_pChargedSound = NULL;
|
||
|
m_pDisruptSound = NULL;
|
||
|
m_flDenySecondary = 0.f;
|
||
|
#endif
|
||
|
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::Precache()
|
||
|
{
|
||
|
BaseClass::Precache();
|
||
|
PrecacheModel( "models/weapons/c_models/c_proto_backpack/c_proto_backpack.mdl" );
|
||
|
PrecacheScriptSound( "WeaponMedigun.NoTarget" );
|
||
|
PrecacheScriptSound( "WeaponMedigun.Healing" );
|
||
|
PrecacheScriptSound( "Weapon_Quick_Fix.Healing" );
|
||
|
PrecacheScriptSound( "WeaponMedigun.Charged" );
|
||
|
PrecacheParticleSystem( "medicgun_invulnstatus_fullcharge_blue" );
|
||
|
PrecacheParticleSystem( "medicgun_invulnstatus_fullcharge_red" );
|
||
|
PrecacheParticleSystem( "medicgun_beam_red_invun" );
|
||
|
PrecacheParticleSystem( "medicgun_beam_red" );
|
||
|
PrecacheParticleSystem( "medicgun_beam_red_targeted" );
|
||
|
PrecacheParticleSystem( "medicgun_beam_blue_invun" );
|
||
|
PrecacheParticleSystem( "medicgun_beam_blue" );
|
||
|
PrecacheParticleSystem( "medicgun_beam_blue_targeted" );
|
||
|
PrecacheParticleSystem( "vaccinator_red_buff1" );
|
||
|
PrecacheParticleSystem( "vaccinator_red_buff2" );
|
||
|
PrecacheParticleSystem( "vaccinator_red_buff3" );
|
||
|
PrecacheParticleSystem( "vaccinator_blue_buff1" );
|
||
|
PrecacheParticleSystem( "vaccinator_blue_buff2" );
|
||
|
PrecacheParticleSystem( "vaccinator_blue_buff3" );
|
||
|
PrecacheParticleSystem( "drain_effect" );
|
||
|
PrecacheScriptSound( "WeaponMedigun_Vaccinator.Charged_tier_01");
|
||
|
PrecacheScriptSound( "WeaponMedigun_Vaccinator.Charged_tier_02");
|
||
|
PrecacheScriptSound( "WeaponMedigun_Vaccinator.Charged_tier_03");
|
||
|
PrecacheScriptSound( "WeaponMedigun_Vaccinator.Charged_tier_04");
|
||
|
PrecacheScriptSound( "WeaponMedigun.HealingDisrupt" );
|
||
|
// PrecacheParticleSystem( "medicgun_beam_machinery" );
|
||
|
|
||
|
for( int i=0; i<ARRAYSIZE(g_MedigunEffects); ++i )
|
||
|
{
|
||
|
if( g_MedigunEffects[i].pszChargeOnSound[0] )
|
||
|
PrecacheScriptSound( g_MedigunEffects[i].pszChargeOnSound );
|
||
|
|
||
|
if( g_MedigunEffects[i].pszChargeOffSound[0] )
|
||
|
PrecacheScriptSound( g_MedigunEffects[i].pszChargeOffSound );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::Deploy( void )
|
||
|
{
|
||
|
if ( BaseClass::Deploy() )
|
||
|
{
|
||
|
m_bHolstered = false;
|
||
|
|
||
|
m_bWasHealingBeforeDeath = false;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( m_bChargeRelease )
|
||
|
{
|
||
|
RecalcEffectOnTarget( pOwner );
|
||
|
}
|
||
|
|
||
|
if ( pOwner && pOwner->m_Shared.IsRageDraining() )
|
||
|
{
|
||
|
CreateMedigunShield();
|
||
|
}
|
||
|
|
||
|
// Resume healing self for Quick-Fix if we're still ubering and switch back to the Quick-Fix.
|
||
|
if ( ( GetMedigunType() == MEDIGUN_QUICKFIX ) && m_bChargeRelease && !m_bHealingSelf )
|
||
|
{
|
||
|
StartHealingTarget( pOwner );
|
||
|
m_bHealingSelf = true;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
ManageChargeEffect();
|
||
|
#endif
|
||
|
|
||
|
m_flNextTargetCheckTime = gpGlobals->curtime;
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::Holster( CBaseCombatWeapon *pSwitchingTo )
|
||
|
{
|
||
|
RemoveHealingTarget( true );
|
||
|
m_bAttacking = false;
|
||
|
m_bHolstered = true;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
RecalcEffectOnTarget( ToTFPlayer( GetOwnerEntity() ), true );
|
||
|
StopHealingOwner();
|
||
|
#endif
|
||
|
|
||
|
RemoveMedigunShield();
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
UpdateEffects();
|
||
|
ManageChargeEffect();
|
||
|
#endif
|
||
|
|
||
|
return BaseClass::Holster( pSwitchingTo );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::UpdateOnRemove( void )
|
||
|
{
|
||
|
RemoveHealingTarget( true );
|
||
|
m_bAttacking = false;
|
||
|
m_bChargeRelease = false;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
RecalcEffectOnTarget( ToTFPlayer( GetOwnerEntity() ), true );
|
||
|
StopHealingOwner();
|
||
|
#endif
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
if ( m_bPlayingSound )
|
||
|
{
|
||
|
m_bPlayingSound = false;
|
||
|
StopHealSound();
|
||
|
}
|
||
|
|
||
|
UpdateEffects();
|
||
|
#endif
|
||
|
|
||
|
RemoveMedigunShield();
|
||
|
|
||
|
BaseClass::UpdateOnRemove();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
float CWeaponMedigun::GetTargetRange( void )
|
||
|
{
|
||
|
return (float)m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flRange;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
float CWeaponMedigun::GetStickRange( void )
|
||
|
{
|
||
|
return (GetTargetRange() * 1.2);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
float CWeaponMedigun::GetHealRate( void )
|
||
|
{
|
||
|
float flHealRate = m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_nDamage;
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwnerEntity(), flHealRate, mult_medigun_healrate );
|
||
|
|
||
|
// This attribute represents a bucket of attributes.
|
||
|
int iHealingMastery = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( GetOwnerEntity(), iHealingMastery, healing_mastery );
|
||
|
if ( iHealingMastery )
|
||
|
{
|
||
|
float flPerc = RemapValClamped( (float)iHealingMastery, 1.f, 4.f, 1.25f, 2.f );
|
||
|
flHealRate *= flPerc;
|
||
|
}
|
||
|
|
||
|
if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
|
||
|
if ( pOwner && pOwner->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
|
||
|
{
|
||
|
flHealRate *= 2.f;
|
||
|
}
|
||
|
else if ( pOwner && ( pOwner->m_Shared.GetCarryingRuneType() == RUNE_KING || pOwner->m_Shared.InCond( TF_COND_KING_BUFFED ) ) )
|
||
|
{
|
||
|
flHealRate *= 1.5f;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
return flHealRate;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::HealingTarget( CBaseEntity *pTarget )
|
||
|
{
|
||
|
if ( pTarget == m_hHealingTarget )
|
||
|
return true;
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::AllowedToHealTarget( CBaseEntity *pTarget )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return false;
|
||
|
|
||
|
if ( !pTarget )
|
||
|
return false;
|
||
|
|
||
|
if ( pTarget->IsPlayer() )
|
||
|
{
|
||
|
CTFPlayer *pTFPlayer = ToTFPlayer( pTarget );
|
||
|
if ( !pTFPlayer )
|
||
|
return false;
|
||
|
|
||
|
if ( !pTFPlayer->IsAlive() )
|
||
|
return false;
|
||
|
|
||
|
// We cannot heal teammates who are using the Equalizer.
|
||
|
CTFWeaponBase *pTFWeapon = pTFPlayer->GetActiveTFWeapon();
|
||
|
int iWeaponBlocksHealing = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFWeapon, iWeaponBlocksHealing, weapon_blocks_healing );
|
||
|
if ( iWeaponBlocksHealing == 1 )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
bool bStealthed = pTFPlayer->m_Shared.IsStealthed() && !pOwner->m_Shared.IsStealthed(); // Allow stealthed medics to heal stealthed targets
|
||
|
bool bDisguised = pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED );
|
||
|
|
||
|
// We can heal teammates and enemies that are disguised as teammates
|
||
|
if ( !bStealthed &&
|
||
|
( pTFPlayer->InSameTeam( pOwner ) ||
|
||
|
( bDisguised && pTFPlayer->m_Shared.GetDisguiseTeam() == pOwner->GetTeamNumber() ) ) )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( !pTarget->InSameTeam( pOwner ) )
|
||
|
return false;
|
||
|
|
||
|
#ifdef STAGING_ONLY
|
||
|
if ( pTarget->IsBaseObject() && IsAllowedToTargetBuildings() )
|
||
|
return true;
|
||
|
#else
|
||
|
if ( pTarget->IsBaseObject() )
|
||
|
return false;
|
||
|
#endif // STAGING_ONLY
|
||
|
|
||
|
CTFReviveMarker *pReviveMarker = dynamic_cast< CTFReviveMarker* >( pTarget );
|
||
|
if ( pReviveMarker )
|
||
|
{
|
||
|
m_hReviveMarker = pReviveMarker; // Store last marker we touched
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Now make sure there isn't something other than team players in the way.
|
||
|
class CMedigunFilter : public CTraceFilterSimple
|
||
|
{
|
||
|
public:
|
||
|
CMedigunFilter( CBaseEntity *pShooter ) : CTraceFilterSimple( pShooter, COLLISION_GROUP_WEAPON )
|
||
|
{
|
||
|
m_pShooter = pShooter;
|
||
|
}
|
||
|
|
||
|
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
|
||
|
{
|
||
|
// If it hit an edict that isn't the target and is on our team, then the ray is blocked.
|
||
|
CBaseEntity *pEnt = static_cast<CBaseEntity*>(pHandleEntity);
|
||
|
|
||
|
// Ignore collisions with the shooter
|
||
|
if ( pEnt == m_pShooter )
|
||
|
return false;
|
||
|
|
||
|
if ( pEnt->GetTeam() == m_pShooter->GetTeam() )
|
||
|
return false;
|
||
|
|
||
|
return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
|
||
|
}
|
||
|
|
||
|
CBaseEntity *m_pShooter;
|
||
|
};
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::MaintainTargetInSlot()
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
CBaseEntity *pTarget = m_hHealingTarget;
|
||
|
Assert( pTarget );
|
||
|
|
||
|
// Make sure the guy didn't go out of range.
|
||
|
bool bLostTarget = true;
|
||
|
Vector vecSrc = pOwner->Weapon_ShootPosition( );
|
||
|
Vector vecTargetPoint = pTarget->WorldSpaceCenter();
|
||
|
Vector vecPoint;
|
||
|
|
||
|
// If it's brush built, use absmins/absmaxs
|
||
|
pTarget->CollisionProp()->CalcNearestPoint( vecSrc, &vecPoint );
|
||
|
|
||
|
float flDistance = (vecPoint - vecSrc).Length();
|
||
|
if ( flDistance < GetStickRange() )
|
||
|
{
|
||
|
if ( m_flNextTargetCheckTime > gpGlobals->curtime )
|
||
|
return;
|
||
|
|
||
|
m_flNextTargetCheckTime = gpGlobals->curtime + 1.0f;
|
||
|
|
||
|
CheckAchievementsOnHealTarget();
|
||
|
|
||
|
trace_t tr;
|
||
|
CMedigunFilter drainFilter( pOwner );
|
||
|
|
||
|
Vector vecAiming;
|
||
|
pOwner->EyeVectors( &vecAiming );
|
||
|
|
||
|
Vector vecEnd = vecSrc + vecAiming * GetTargetRange();
|
||
|
UTIL_TraceLine( vecSrc, vecEnd, (MASK_SHOT & ~CONTENTS_HITBOX), pOwner, DMG_GENERIC, &tr );
|
||
|
|
||
|
// Still visible?
|
||
|
if ( tr.m_pEnt == pTarget )
|
||
|
return;
|
||
|
|
||
|
UTIL_TraceLine( vecSrc, vecTargetPoint, MASK_SHOT, &drainFilter, &tr );
|
||
|
|
||
|
// Still visible?
|
||
|
if (( tr.fraction == 1.0f) || (tr.m_pEnt == pTarget))
|
||
|
return;
|
||
|
|
||
|
// If we failed, try the target's eye point as well
|
||
|
UTIL_TraceLine( vecSrc, pTarget->EyePosition(), MASK_SHOT, &drainFilter, &tr );
|
||
|
if (( tr.fraction == 1.0f) || (tr.m_pEnt == pTarget))
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// We've lost this guy
|
||
|
if ( bLostTarget )
|
||
|
{
|
||
|
RemoveHealingTarget();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::FindNewTargetForSlot()
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
Vector vecSrc = pOwner->Weapon_ShootPosition( );
|
||
|
if ( m_hHealingTarget )
|
||
|
{
|
||
|
RemoveHealingTarget();
|
||
|
}
|
||
|
|
||
|
// In Normal mode, we heal players under our crosshair
|
||
|
Vector vecAiming;
|
||
|
pOwner->EyeVectors( &vecAiming );
|
||
|
|
||
|
// Find a player in range of this player, and make sure they're healable.
|
||
|
Vector vecEnd = vecSrc + vecAiming * GetTargetRange();
|
||
|
trace_t tr;
|
||
|
|
||
|
UTIL_TraceLine( vecSrc, vecEnd, (MASK_SHOT & ~CONTENTS_HITBOX), pOwner, DMG_GENERIC, &tr );
|
||
|
if ( tr.fraction != 1.0 && tr.m_pEnt )
|
||
|
{
|
||
|
if ( !HealingTarget( tr.m_pEnt ) && AllowedToHealTarget( tr.m_pEnt ) )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_MEDIC_STARTEDHEALING );
|
||
|
if ( tr.m_pEnt->IsPlayer() )
|
||
|
{
|
||
|
CTFPlayer *pTarget = ToTFPlayer( tr.m_pEnt );
|
||
|
pTarget->SpeakConceptIfAllowed( MP_CONCEPT_HEALTARGET_STARTEDHEALING );
|
||
|
}
|
||
|
|
||
|
// Start the heal target thinking.
|
||
|
SetContextThink( &CWeaponMedigun::HealTargetThink, gpGlobals->curtime, s_pszMedigunHealTargetThink );
|
||
|
|
||
|
m_hLastHealingTarget = tr.m_pEnt;
|
||
|
#endif
|
||
|
|
||
|
m_hHealingTarget.Set( tr.m_pEnt );
|
||
|
m_flNextTargetCheckTime = gpGlobals->curtime + 1.0f;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool CWeaponMedigun::IsReleasingCharge( void ) const
|
||
|
{
|
||
|
return (m_bChargeRelease && !m_bHolstered);
|
||
|
}
|
||
|
|
||
|
|
||
|
int CWeaponMedigun::GetMedigunType( void ) const
|
||
|
{
|
||
|
int iMode = 0;
|
||
|
CALL_ATTRIB_HOOK_INT( iMode, set_weapon_mode );
|
||
|
return iMode;
|
||
|
}
|
||
|
|
||
|
|
||
|
float CWeaponMedigun::GetMinChargeAmount( void ) const
|
||
|
{
|
||
|
if( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
return 1.f / weapon_medigun_resist_num_chunks.GetInt();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return 1.f;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
medigun_charge_types CWeaponMedigun::GetChargeType( void ) const
|
||
|
{
|
||
|
int iTmp = MEDIGUN_CHARGE_INVULN;
|
||
|
CALL_ATTRIB_HOOK_INT( iTmp, set_charge_type );
|
||
|
|
||
|
if( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
// If this is a resist-medigun, then the charge type needs to be within the resist types
|
||
|
Assert( iTmp >= MEDIGUN_CHARGE_BULLET_RESIST && iTmp <= MEDIGUN_CHARGE_FIRE_RESIST );
|
||
|
Assert( m_nChargeResistType < MEDIGUN_NUM_RESISTS );
|
||
|
|
||
|
iTmp += m_nChargeResistType;
|
||
|
}
|
||
|
|
||
|
return (medigun_charge_types)iTmp;
|
||
|
}
|
||
|
|
||
|
void CWeaponMedigun::CycleResistType()
|
||
|
{
|
||
|
// Resist medigun only!
|
||
|
if( GetMedigunType() != MEDIGUN_RESIST )
|
||
|
return;
|
||
|
|
||
|
if( IsReleasingCharge() )
|
||
|
return;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
// When cycling resist we have to remove the current resist, then add the new resist.
|
||
|
CTFPlayer *pTFHealingTarget = ToTFPlayer( m_hHealingTarget );
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
|
||
|
ETFCond cond = g_MedigunResistConditions[ GetResistType() ].passiveCond;
|
||
|
// Remove from out healing target
|
||
|
if( pTFHealingTarget)
|
||
|
{
|
||
|
CBaseEntity* pProvider = pTFHealingTarget->m_Shared.GetConditionProvider( cond );
|
||
|
|
||
|
// Remove from our healing target if we're the provider
|
||
|
if( pProvider == pOwner || pProvider == NULL )
|
||
|
{
|
||
|
pTFHealingTarget->m_Shared.RemoveCond( cond );
|
||
|
}
|
||
|
}
|
||
|
// Remove from ourselves
|
||
|
if( pOwner )
|
||
|
{
|
||
|
// Remove from ourselves if we're the provider
|
||
|
CBaseEntity* pProvider = pOwner->m_Shared.GetConditionProvider( cond );
|
||
|
if( pProvider == pOwner || pProvider == NULL )
|
||
|
{
|
||
|
pOwner->m_Shared.RemoveCond( cond );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
m_nChargeResistType += 1;
|
||
|
m_nChargeResistType = m_nChargeResistType % MEDIGUN_NUM_RESISTS;
|
||
|
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
CTFPlayer *pTFOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
|
||
|
if( pTFOwner )
|
||
|
{
|
||
|
RecalcEffectOnTarget( pTFOwner );
|
||
|
}
|
||
|
|
||
|
|
||
|
if( pTFHealingTarget )
|
||
|
{
|
||
|
// Now add the new resist
|
||
|
RecalcEffectOnTarget( pTFHealingTarget );
|
||
|
pTFHealingTarget->m_Shared.AddCond( g_MedigunResistConditions[ GetResistType() ].passiveCond, PERMANENT_CONDITION, pTFOwner );
|
||
|
pTFOwner->m_Shared.AddCond( g_MedigunResistConditions[ GetResistType() ].passiveCond, PERMANENT_CONDITION, pTFOwner );
|
||
|
}
|
||
|
#else
|
||
|
// Updates our particles
|
||
|
ForceHealingTargetUpdate();
|
||
|
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
|
||
|
medigun_resist_types_t CWeaponMedigun::GetResistType() const
|
||
|
{
|
||
|
Assert( GetMedigunType() == MEDIGUN_RESIST );
|
||
|
|
||
|
int nCurrentActiveResist = ( GetChargeType() - MEDIGUN_CHARGE_BULLET_RESIST );
|
||
|
Assert( nCurrentActiveResist >= 0 && nCurrentActiveResist < MEDIGUN_NUM_RESISTS );
|
||
|
nCurrentActiveResist = nCurrentActiveResist % MEDIGUN_NUM_RESISTS;
|
||
|
|
||
|
return medigun_resist_types_t(nCurrentActiveResist);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::IsAllowedToTargetBuildings( void )
|
||
|
{
|
||
|
#ifdef STAGING_ONLY
|
||
|
if ( !TFGameRules() || !TFGameRules()->GameModeUsesUpgrades() )
|
||
|
return false;
|
||
|
|
||
|
// See if we have the upgrade to heal buildings
|
||
|
int iHealBuildings = 0;
|
||
|
CALL_ATTRIB_HOOK_INT( iHealBuildings, medic_machinery_beam );
|
||
|
|
||
|
return iHealBuildings ? true : false;
|
||
|
#else
|
||
|
return false;
|
||
|
#endif // STAGING_ONLY
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::IsAttachedToBuilding( void )
|
||
|
{
|
||
|
if ( !m_hHealingTarget )
|
||
|
return false;
|
||
|
|
||
|
return m_hHealingTarget->IsBaseObject();
|
||
|
}
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::HealTargetThink( void )
|
||
|
{
|
||
|
// Verify that we still have a valid heal target.
|
||
|
CBaseEntity *pTarget = m_hHealingTarget;
|
||
|
if ( !pTarget || !pTarget->IsAlive() )
|
||
|
{
|
||
|
SetContextThink( NULL, 0, s_pszMedigunHealTargetThink );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
float flTime = gpGlobals->curtime - pOwner->GetTimeBase();
|
||
|
if ( flTime > 5.0f || !AllowedToHealTarget(pTarget) )
|
||
|
{
|
||
|
RemoveHealingTarget( true );
|
||
|
}
|
||
|
|
||
|
// Make sure our heal target hasn't changed classes while being healed
|
||
|
CTFPlayer *pTFTarget = ToTFPlayer( pTarget );
|
||
|
if ( pTFTarget )
|
||
|
{
|
||
|
int nPrevClass = m_nHealTargetClass;
|
||
|
m_nHealTargetClass = pTFTarget->GetPlayerClass()->GetClassIndex();
|
||
|
if ( m_nHealTargetClass != nPrevClass )
|
||
|
{
|
||
|
pOwner->TeamFortress_SetSpeed();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( !pTarget->IsPlayer() )
|
||
|
{
|
||
|
#ifdef STAGING_ONLY
|
||
|
if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
|
||
|
{
|
||
|
if ( IsAttachedToBuilding() )
|
||
|
{
|
||
|
// Heal building
|
||
|
if ( m_hHealingTarget->GetHealth() < m_hHealingTarget->GetMaxHealth() )
|
||
|
{
|
||
|
CBaseEntity *pEntity = m_hHealingTarget;
|
||
|
CBaseObject *pObject = dynamic_cast<CBaseObject*>( pEntity );
|
||
|
if ( pObject )
|
||
|
{
|
||
|
pObject->SetHealth( m_hHealingTarget->GetHealth() + ( GetHealRate() / 10.f ) );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif // STAGING_ONLY
|
||
|
|
||
|
CTFReviveMarker *pReviveMarker = dynamic_cast< CTFReviveMarker* >( pTarget );
|
||
|
if ( pReviveMarker )
|
||
|
{
|
||
|
CTFPlayer *pDeadPlayer = pReviveMarker->GetOwner();
|
||
|
if ( pDeadPlayer )
|
||
|
{
|
||
|
pReviveMarker->SetReviver( pOwner );
|
||
|
|
||
|
// Instantly revive players when deploying uber
|
||
|
float flHealRate = GetHealRate();
|
||
|
float flReviveRate = m_bChargeRelease ? flHealRate / 2.f : flHealRate / 8.f;
|
||
|
pReviveMarker->AddMarkerHealth( flReviveRate );
|
||
|
|
||
|
// Set observer target to reviver so they know they're being revived
|
||
|
if ( pDeadPlayer->GetObserverMode() > OBS_MODE_FREEZECAM )
|
||
|
{
|
||
|
if ( pReviveMarker->GetReviver() && pDeadPlayer->GetObserverTarget() != pReviveMarker->GetReviver() )
|
||
|
{
|
||
|
pDeadPlayer->SetObserverTarget( pReviveMarker->GetReviver() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( !pReviveMarker->HasOwnerBeenPrompted() )
|
||
|
{
|
||
|
// This will give them a messagebox that has a Cancel button
|
||
|
pReviveMarker->PromptOwner();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
SetNextThink( gpGlobals->curtime + 0.2f, s_pszMedigunHealTargetThink );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::StartHealingTarget( CBaseEntity *pTarget )
|
||
|
{
|
||
|
CTFPlayer *pTFTarget = ToTFPlayer( pTarget );
|
||
|
if ( !pTFTarget )
|
||
|
return;
|
||
|
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
// Handle bonuses as additive, penalties as percentage...
|
||
|
float flOverhealBonus = tf_max_health_boost.GetFloat() - 1.0f;
|
||
|
float flMod = 1.0f;
|
||
|
CALL_ATTRIB_HOOK_FLOAT( flMod, mult_medigun_overheal_amount );
|
||
|
if ( flMod >= 1.0f )
|
||
|
{
|
||
|
flOverhealBonus += flMod;
|
||
|
}
|
||
|
else if ( flMod < 1.0f && flOverhealBonus > 0.0f )
|
||
|
{
|
||
|
flOverhealBonus *= flMod;
|
||
|
flOverhealBonus += 1.0f;
|
||
|
}
|
||
|
|
||
|
// Safety net
|
||
|
if ( flOverhealBonus <= 1.0f )
|
||
|
{
|
||
|
flOverhealBonus = 1.0f;
|
||
|
}
|
||
|
|
||
|
float flOverhealDecayMult = 1.0;
|
||
|
CALL_ATTRIB_HOOK_FLOAT( flOverhealDecayMult, mult_medigun_overheal_decay );
|
||
|
|
||
|
float flOverhealExpert = 0.f;
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pOwner, flOverhealExpert, overheal_expert );
|
||
|
flOverhealBonus = Max( flOverhealBonus, flOverhealBonus + ( flOverhealExpert / 4 ) );
|
||
|
flOverhealDecayMult = Max( flOverhealDecayMult, flOverhealDecayMult + ( flOverhealExpert / 2 ) );
|
||
|
|
||
|
pTFTarget->m_Shared.Heal( pOwner, GetHealRate(), flOverhealBonus, flOverhealDecayMult );
|
||
|
|
||
|
// If target is grappling, set ourselves as grappling them
|
||
|
if ( pTFTarget->GetGrapplingHookTarget() )
|
||
|
{
|
||
|
pOwner->SetGrapplingHookTarget( pTFTarget );
|
||
|
}
|
||
|
|
||
|
// Add on the small passive resist when we attach onto a target
|
||
|
if( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
pTFTarget->m_Shared.AddCond( g_MedigunResistConditions[ GetResistType() ].passiveCond, PERMANENT_CONDITION, pOwner );
|
||
|
pOwner->m_Shared.AddCond( g_MedigunResistConditions[ GetResistType() ].passiveCond, PERMANENT_CONDITION, pOwner );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: QuickFix uber heals the target and medic
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::StopHealingOwner( void )
|
||
|
{
|
||
|
if ( !m_bHealingSelf )
|
||
|
return;
|
||
|
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
pOwner->m_Shared.StopHealing( pOwner );
|
||
|
m_bHealingSelf = false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::AddCharge( float flPercentage )
|
||
|
{
|
||
|
m_flChargeLevel = MIN( m_flChargeLevel + flPercentage, 1.0 );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::SubtractCharge( float flPercentage )
|
||
|
{
|
||
|
float flSubtractAmount = Max( flPercentage, 0.0f );
|
||
|
SubtractChargeAndUpdateDeployState( flSubtractAmount, true );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::RecalcEffectOnTarget( CTFPlayer *pPlayer, bool bInstantRemove )
|
||
|
{
|
||
|
if ( !pPlayer )
|
||
|
return;
|
||
|
|
||
|
pPlayer->m_Shared.RecalculateChargeEffects( bInstantRemove );
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
const char *CWeaponMedigun::GetHealSound( void ) const
|
||
|
{
|
||
|
COMPILE_TIME_ASSERT( ARRAYSIZE(g_pszMedigunHealSounds) == MEDIGUN_NUM_CHARGE_TYPES );
|
||
|
return g_pszMedigunHealSounds[ GetMedigunType() ];
|
||
|
}
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
void CWeaponMedigun::UberchargeChunkDeployed()
|
||
|
{
|
||
|
m_nChargesReleased++;
|
||
|
if( m_nChargesReleased % weapon_medigun_resist_num_chunks.GetInt() == 0 )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
CTF_GameStats.Event_PlayerInvulnerable( pOwner );
|
||
|
EconEntity_OnOwnerKillEaterEvent( this, pOwner, ToTFPlayer( m_hHealingTarget ), kKillEaterEvent_UberActivated );
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::CreateMedigunShield( void )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
if ( m_hMedigunShield )
|
||
|
return;
|
||
|
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
#ifdef STAGING_ONLY
|
||
|
bool bHasPermanentShield = HasPermanentShield();
|
||
|
if ( !bHasPermanentShield )
|
||
|
#endif // STAGING_ONLY
|
||
|
{
|
||
|
// check if we can activate the shield
|
||
|
if ( ( pOwner->m_Shared.GetRageMeter() < 100.f ) && !pOwner->m_Shared.IsRageDraining() )
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_MEDIC_HEAL_SHIELD );
|
||
|
m_hMedigunShield = CTFMedigunShield::Create( pOwner );
|
||
|
if ( m_hMedigunShield )
|
||
|
{
|
||
|
pOwner->m_Shared.StartRageDrain();
|
||
|
|
||
|
#ifdef STAGING_ONLY
|
||
|
m_hMedigunShield->SetPermanentShield( bHasPermanentShield );
|
||
|
#endif // STAGING_ONLY
|
||
|
}
|
||
|
#endif // GAME_DLL
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::RemoveMedigunShield( void )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
if ( m_hMedigunShield )
|
||
|
{
|
||
|
m_hMedigunShield->RemoveShield();
|
||
|
m_hMedigunShield.Set( NULL );
|
||
|
}
|
||
|
#endif // GAME_DLL
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef STAGING_ONLY
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::HasPermanentShield() const
|
||
|
{
|
||
|
if ( !TFGameRules()->IsMannVsMachineMode() )
|
||
|
return false;
|
||
|
|
||
|
int iPermanentShield = 0;
|
||
|
CALL_ATTRIB_HOOK_INT( iPermanentShield, permanent_medic_shield );
|
||
|
return iPermanentShield != 0;
|
||
|
}
|
||
|
#endif // STAGING_ONLY
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Returns a pointer to a healable target
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::FindAndHealTargets( void )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return false;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
if ( !pOwner->IsBot() )
|
||
|
{
|
||
|
INetChannelInfo *pNetChanInfo = engine->GetPlayerNetInfo( pOwner->entindex() );
|
||
|
if ( !pNetChanInfo || pNetChanInfo->IsTimingOut() )
|
||
|
return false;
|
||
|
}
|
||
|
#endif // GAME_DLL
|
||
|
|
||
|
bool bFound = false;
|
||
|
|
||
|
// Maintaining beam to existing target?
|
||
|
CBaseEntity *pTarget = m_hHealingTarget;
|
||
|
if ( pTarget && pTarget->IsAlive() )
|
||
|
{
|
||
|
MaintainTargetInSlot();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
FindNewTargetForSlot();
|
||
|
}
|
||
|
|
||
|
CBaseEntity *pNewTarget = m_hHealingTarget;
|
||
|
if ( pNewTarget && pNewTarget->IsAlive() )
|
||
|
{
|
||
|
CTFPlayer *pTFPlayer = ToTFPlayer( pNewTarget );
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
// HACK: For now, just deal with players
|
||
|
if ( pTFPlayer )
|
||
|
{
|
||
|
if ( pTarget != pNewTarget )
|
||
|
{
|
||
|
StartHealingTarget( pNewTarget );
|
||
|
}
|
||
|
|
||
|
RecalcEffectOnTarget( pTFPlayer );
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
bFound = true;
|
||
|
|
||
|
// Charge up our power if we're not releasing it, and our target
|
||
|
// isn't receiving any benefit from our healing.
|
||
|
if ( !m_bChargeRelease )
|
||
|
{
|
||
|
float flChargeRate = weapon_medigun_charge_rate.GetFloat();
|
||
|
float flChargeAmount = gpGlobals->frametime / flChargeRate;
|
||
|
|
||
|
if ( pTFPlayer && weapon_medigun_charge_rate.GetFloat() )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
int iBoostMax = floor( pTFPlayer->m_Shared.GetMaxBuffedHealth() * 0.95);
|
||
|
float flChargeModifier = 1.f;
|
||
|
|
||
|
// Reduced charge for healing fully healed guys
|
||
|
if ( pNewTarget->GetHealth() >= iBoostMax && ( TFGameRules() && !(TFGameRules()->InSetup() && TFGameRules()->GetActiveRoundTimer() ) ) )
|
||
|
{
|
||
|
flChargeModifier *= 0.5;
|
||
|
}
|
||
|
|
||
|
int iTotalHealers = pTFPlayer->m_Shared.GetNumHealers();
|
||
|
if ( iTotalHealers > 1 )
|
||
|
{
|
||
|
flChargeModifier /= (float)iTotalHealers;
|
||
|
}
|
||
|
|
||
|
// The resist medigun has a uber charge rate
|
||
|
flChargeAmount *= flChargeModifier;
|
||
|
|
||
|
if ( pOwner->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
|
||
|
{
|
||
|
flChargeAmount *= 2.f;
|
||
|
}
|
||
|
else if ( pOwner->m_Shared.GetCarryingRuneType() == RUNE_KING || pOwner->m_Shared.InCond( TF_COND_KING_BUFFED ) )
|
||
|
{
|
||
|
flChargeAmount *= 1.5f;
|
||
|
}
|
||
|
|
||
|
if ( pNewTarget->GetHealth() >= pNewTarget->GetMaxHealth() && ( TFGameRules() && !(TFGameRules()->InSetup() && TFGameRules()->GetActiveRoundTimer() ) ) )
|
||
|
{
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pOwner, flChargeAmount, mult_medigun_overheal_uberchargerate );
|
||
|
}
|
||
|
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pOwner, flChargeAmount, mult_medigun_uberchargerate );
|
||
|
|
||
|
|
||
|
// Apply any bonus our target gives us.
|
||
|
if ( pTarget )
|
||
|
{
|
||
|
bool bInRespawnRoom =
|
||
|
PointInRespawnRoom( pTarget, WorldSpaceCenter() ) ||
|
||
|
PointInRespawnRoom( pOwner, WorldSpaceCenter() );
|
||
|
|
||
|
if ( !bInRespawnRoom )
|
||
|
{
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTarget, flChargeAmount, mult_uberchargerate_for_healer );
|
||
|
}
|
||
|
}
|
||
|
if ( TFGameRules() )
|
||
|
{
|
||
|
if ( TFGameRules()->IsQuickBuildTime() )
|
||
|
{
|
||
|
flChargeAmount *= 4.f;
|
||
|
}
|
||
|
else if ( TFGameRules()->InSetup() && TFGameRules()->GetActiveRoundTimer() )
|
||
|
{
|
||
|
flChargeAmount *= 3.f;
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
float flNewLevel = MIN( m_flChargeLevel + flChargeAmount, 1.0 );
|
||
|
|
||
|
float flMinChargeAmount = GetMinChargeAmount();
|
||
|
|
||
|
if ( flNewLevel >= flMinChargeAmount && m_flChargeLevel < flMinChargeAmount )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_MEDIC_CHARGEREADY );
|
||
|
pTFPlayer->SpeakConceptIfAllowed( MP_CONCEPT_HEALTARGET_CHARGEREADY );
|
||
|
#else
|
||
|
// send a message that we've got charge
|
||
|
// if you change this from being a client-side only event, you have to
|
||
|
// fix ACHIEVEMENT_TF_MEDIC_KILL_WHILE_CHARGED to check the medic userid.
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_chargeready" );
|
||
|
if ( event )
|
||
|
{
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
if ( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
// Play a sound when we tick over to a new charge level
|
||
|
int nChargeLevel = int(floor(flNewLevel/flMinChargeAmount));
|
||
|
float flNextChargeLevelAmount = nChargeLevel * flMinChargeAmount;
|
||
|
if( flNewLevel >= flNextChargeLevelAmount && m_flChargeLevel < flNextChargeLevelAmount )
|
||
|
{
|
||
|
const char* pzsSoundName = CFmtStr( "WeaponMedigun_Vaccinator.Charged_tier_0%d", nChargeLevel );
|
||
|
|
||
|
if ( nChargeLevel == 1 )
|
||
|
{
|
||
|
if ( m_pChargedSound != NULL )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pChargedSound );
|
||
|
m_pChargedSound = NULL;
|
||
|
}
|
||
|
|
||
|
CLocalPlayerFilter filter;
|
||
|
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
m_pChargedSound = controller.SoundCreate( filter, entindex(), pzsSoundName );
|
||
|
controller.Play( m_pChargedSound, 1.0, 100 );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pOwner->EmitSound( pzsSoundName );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
SetChargeLevel( flNewLevel );
|
||
|
}
|
||
|
else if ( IsAttachedToBuilding() )
|
||
|
{
|
||
|
m_flChargeLevel = MIN( m_flChargeLevel + flChargeAmount, 1.0 );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return bFound;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::ItemHolsterFrame( void )
|
||
|
{
|
||
|
BaseClass::ItemHolsterFrame();
|
||
|
|
||
|
DrainCharge();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::DrainCharge( void )
|
||
|
{
|
||
|
// If we're in charge release mode, drain our charge
|
||
|
if ( m_bChargeRelease )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
int flUberTime = weapon_medigun_chargerelease_rate.GetFloat();
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pOwner, flUberTime, add_uber_time );
|
||
|
|
||
|
float flChargeAmount = gpGlobals->frametime / flUberTime;
|
||
|
float flExtraPlayerCost = flChargeAmount * 0.5;
|
||
|
|
||
|
// Drain faster the more targets we're applying to. Extra targets count for 50% drain to still reward juggling somewhat.
|
||
|
for ( int i = m_DetachedTargets.Count()-1; i >= 0; i-- )
|
||
|
{
|
||
|
if ( m_DetachedTargets[i].hTarget == NULL || m_DetachedTargets[i].hTarget.Get() == m_hHealingTarget.Get() ||
|
||
|
!m_DetachedTargets[i].hTarget->IsAlive() || m_DetachedTargets[i].flTime < (gpGlobals->curtime - tf_invuln_time.GetFloat()) )
|
||
|
{
|
||
|
m_DetachedTargets.Remove(i);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
flChargeAmount += flExtraPlayerCost;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
SubtractChargeAndUpdateDeployState( flChargeAmount, false );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void CWeaponMedigun::SubtractChargeAndUpdateDeployState( float flSubtractAmount, bool bForceDrain )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
float flNewCharge = Max( m_flChargeLevel - flSubtractAmount, 0.0f );
|
||
|
|
||
|
if( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
if( flNewCharge <= m_flEndResistCharge )
|
||
|
{
|
||
|
// If the player is holding down ATTACK2 and they have a bar of Uber left,
|
||
|
// let them burn straight into the next bar
|
||
|
if( (m_flEndResistCharge > 0) && m_bAttack2Down )
|
||
|
{
|
||
|
float flChunkSize = GetMinChargeAmount();
|
||
|
int nCurrentChunk = floor(m_flChargeLevel / flChunkSize);
|
||
|
m_flEndResistCharge = flChunkSize * Max( 0, (nCurrentChunk - 1) );
|
||
|
#ifdef GAME_DLL
|
||
|
UberchargeChunkDeployed();
|
||
|
#endif
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
|
||
|
// Make sure we don't cross over too far if this is a natural drain
|
||
|
if( !bForceDrain )
|
||
|
{
|
||
|
flNewCharge = m_flEndResistCharge;
|
||
|
}
|
||
|
m_flEndResistCharge = 0.f;
|
||
|
// Stop deploying
|
||
|
m_bChargeRelease = false;
|
||
|
m_flReleaseStartedAt = 0;
|
||
|
m_DetachedTargets.Purge();
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
pOwner->ClearPunchVictims();
|
||
|
RecalcEffectOnTarget( pOwner );
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_flChargeLevel = flNewCharge;
|
||
|
|
||
|
if ( !m_flChargeLevel )
|
||
|
{
|
||
|
m_bChargeRelease = false;
|
||
|
m_flReleaseStartedAt = 0;
|
||
|
m_DetachedTargets.Purge();
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
pOwner->ClearPunchVictims();
|
||
|
RecalcEffectOnTarget( pOwner );
|
||
|
StopHealingOwner(); // QuickFix uber heals the target and medic
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Overloaded to handle the hold-down healing
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::ItemPostFrame( void )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
// If we're lowered, we're not allowed to fire
|
||
|
if ( CanAttack() == false )
|
||
|
{
|
||
|
RemoveHealingTarget( true );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
#if !defined( CLIENT_DLL )
|
||
|
if ( AppliesModifier() )
|
||
|
{
|
||
|
m_DamageModifier.SetModifier( weapon_medigun_damage_modifier.GetFloat() );
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// Try to start healing
|
||
|
m_bAttacking = false;
|
||
|
if ( pOwner->GetMedigunAutoHeal() )
|
||
|
{
|
||
|
if ( pOwner->m_nButtons & IN_ATTACK )
|
||
|
{
|
||
|
if ( m_bCanChangeTarget )
|
||
|
{
|
||
|
RemoveHealingTarget();
|
||
|
#if defined( CLIENT_DLL )
|
||
|
if (prediction->IsFirstTimePredicted() ) {
|
||
|
m_bPlayingSound = false;
|
||
|
StopHealSound();
|
||
|
}
|
||
|
#endif
|
||
|
// can't change again until we release the attack button
|
||
|
m_bCanChangeTarget = false;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_bCanChangeTarget = true;
|
||
|
}
|
||
|
|
||
|
if ( m_bHealing && ( m_iState != WEAPON_IS_ACTIVE || pOwner->IsTaunting() ) )
|
||
|
{
|
||
|
RemoveHealingTarget();
|
||
|
}
|
||
|
else if ( m_bHealing || ( pOwner->m_nButtons & IN_ATTACK ) )
|
||
|
{
|
||
|
PrimaryAttack();
|
||
|
m_bAttacking = true;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( /*m_bChargeRelease || */ pOwner->m_nButtons & IN_ATTACK )
|
||
|
{
|
||
|
PrimaryAttack();
|
||
|
m_bAttacking = true;
|
||
|
}
|
||
|
else if ( m_bHealing )
|
||
|
{
|
||
|
// Detach from the player if they release the attack button.
|
||
|
RemoveHealingTarget();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( pOwner->m_nButtons & IN_ATTACK2 )
|
||
|
{
|
||
|
SecondaryAttack();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_bAttack2Down = false;
|
||
|
}
|
||
|
|
||
|
if( (pOwner->m_nButtons & IN_ATTACK3) && !m_bAttack3Down )
|
||
|
{
|
||
|
CreateMedigunShield();
|
||
|
m_bAttack3Down = true;
|
||
|
}
|
||
|
else if( !(pOwner->m_nButtons & IN_ATTACK3) && m_bAttack3Down )
|
||
|
{
|
||
|
m_bAttack3Down = false;
|
||
|
}
|
||
|
|
||
|
if ( pOwner->m_nButtons & IN_RELOAD && !m_bReloadDown )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
CycleResistType();
|
||
|
#endif
|
||
|
m_bReloadDown = true;
|
||
|
}
|
||
|
else if ( !(pOwner->m_nButtons & IN_RELOAD) && m_bReloadDown )
|
||
|
{
|
||
|
m_bReloadDown = false;
|
||
|
}
|
||
|
|
||
|
WeaponIdle();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::Lower( void )
|
||
|
{
|
||
|
// Stop healing if we are
|
||
|
if ( m_bHealing )
|
||
|
{
|
||
|
RemoveHealingTarget( true );
|
||
|
m_bAttacking = false;
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
UpdateEffects();
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
return BaseClass::Lower();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::RemoveHealingTarget( bool bStopHealingSelf )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
|
||
|
// If this guy is already in our detached target list, update the time. Otherwise, add him.
|
||
|
if ( m_bChargeRelease )
|
||
|
{
|
||
|
int i = 0;
|
||
|
for ( i = 0; i < m_DetachedTargets.Count(); i++ )
|
||
|
{
|
||
|
if ( m_DetachedTargets[i].hTarget == m_hHealingTarget )
|
||
|
{
|
||
|
m_DetachedTargets[i].flTime = gpGlobals->curtime;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if ( i == m_DetachedTargets.Count() )
|
||
|
{
|
||
|
int iIdx = m_DetachedTargets.AddToTail();
|
||
|
m_DetachedTargets[iIdx].hTarget = m_hHealingTarget;
|
||
|
m_DetachedTargets[iIdx].flTime = gpGlobals->curtime;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
int nMedigunType = GetMedigunType();
|
||
|
|
||
|
if ( m_hHealingTarget )
|
||
|
{
|
||
|
// HACK: For now, just deal with players
|
||
|
if ( m_hHealingTarget->IsPlayer() )
|
||
|
{
|
||
|
CTFPlayer *pTFPlayer = ToTFPlayer( m_hHealingTarget );
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( pTFPlayer && pOwner )
|
||
|
{
|
||
|
pTFPlayer->m_Shared.StopHealing( pOwner );
|
||
|
|
||
|
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_MEDIC_STOPPEDHEALING, pTFPlayer->IsAlive() ? "healtarget:alive" : "healtarget:dead" );
|
||
|
pTFPlayer->SpeakConceptIfAllowed( MP_CONCEPT_HEALTARGET_STOPPEDHEALING );
|
||
|
|
||
|
// If we're grappled to this player, drop
|
||
|
if ( pOwner->GetGrapplingHookTarget() == pTFPlayer )
|
||
|
{
|
||
|
pOwner->SetGrapplingHookTarget( NULL );
|
||
|
}
|
||
|
|
||
|
// Remove our passive resist
|
||
|
if( nMedigunType == MEDIGUN_RESIST )
|
||
|
{
|
||
|
ETFCond cond = g_MedigunResistConditions[ GetResistType() ].passiveCond;
|
||
|
CBaseEntity* pProvider = pTFPlayer->m_Shared.GetConditionProvider( cond );
|
||
|
|
||
|
// Remove from our healing target if we're the provider
|
||
|
if( pProvider == pOwner || pProvider == NULL )
|
||
|
{
|
||
|
pTFPlayer->m_Shared.RemoveCond( cond );
|
||
|
}
|
||
|
|
||
|
// Remove from ourselves if we're the provider
|
||
|
pProvider = pOwner->m_Shared.GetConditionProvider( cond );
|
||
|
if( pProvider == pOwner || pProvider == NULL )
|
||
|
{
|
||
|
pOwner->m_Shared.RemoveCond( cond );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Stop thinking - we no longer have a heal target.
|
||
|
SetContextThink( NULL, 0, s_pszMedigunHealTargetThink );
|
||
|
#endif
|
||
|
|
||
|
m_hHealingTarget.Set( NULL );
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
// See if we have The QuickFix, which adjusts our move speed based on heal target
|
||
|
pOwner->TeamFortress_SetSpeed();
|
||
|
|
||
|
#endif
|
||
|
|
||
|
// Stop the welding animation
|
||
|
if ( m_bHealing )
|
||
|
{
|
||
|
SendWeaponAnim( ACT_MP_ATTACK_STAND_POSTFIRE );
|
||
|
pOwner->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_POST );
|
||
|
}
|
||
|
|
||
|
#ifndef CLIENT_DLL
|
||
|
m_DamageModifier.RemoveModifier();
|
||
|
#endif
|
||
|
m_bHealing = false;
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Attempt to heal any player within range of the medikit
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::PrimaryAttack( void )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
|
||
|
if ( !CanAttack() )
|
||
|
return;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
/*
|
||
|
// Start boosting ourself if we're not
|
||
|
if ( m_bChargeRelease && !m_bHealingSelf )
|
||
|
{
|
||
|
pOwner->m_Shared.Heal( pOwner, GetHealRate() * 2 );
|
||
|
m_bHealingSelf = true;
|
||
|
}
|
||
|
*/
|
||
|
#endif
|
||
|
|
||
|
#if !defined (CLIENT_DLL)
|
||
|
if ( tf_medigun_lagcomp.GetBool() )
|
||
|
lagcompensation->StartLagCompensation( pOwner, pOwner->GetCurrentCommand() );
|
||
|
#endif
|
||
|
|
||
|
if ( FindAndHealTargets() )
|
||
|
{
|
||
|
// Start the animation
|
||
|
if ( !m_bHealing )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
pOwner->SpeakWeaponFire();
|
||
|
#endif
|
||
|
|
||
|
SendWeaponAnim( ACT_MP_ATTACK_STAND_PREFIRE );
|
||
|
pOwner->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_PRE );
|
||
|
}
|
||
|
|
||
|
m_bHealing = true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
RemoveHealingTarget();
|
||
|
}
|
||
|
|
||
|
#if !defined (CLIENT_DLL)
|
||
|
if ( tf_medigun_lagcomp.GetBool() )
|
||
|
lagcompensation->FinishLagCompensation( pOwner );
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Burn charge level to generate invulnerability
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::SecondaryAttack( void )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
if ( !CanAttack() )
|
||
|
return;
|
||
|
|
||
|
CTFPlayer *pTFPlayerPatient = NULL;
|
||
|
if ( m_hHealingTarget && m_hHealingTarget->IsPlayer() )
|
||
|
{
|
||
|
pTFPlayerPatient = ToTFPlayer( m_hHealingTarget );
|
||
|
}
|
||
|
|
||
|
// STAGING_MEDIC
|
||
|
// Resist gun early outs if the patient and medic both have the condition (or medic with no patient has condition)
|
||
|
if ( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
ETFCond uberCond = g_MedigunResistConditions[GetResistType()].uberCond;
|
||
|
if ( pOwner->m_Shared.InCond( uberCond ) )
|
||
|
{
|
||
|
if ( !pTFPlayerPatient || pTFPlayerPatient->m_Shared.InCond( uberCond ) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_bAttack2Down = true;
|
||
|
|
||
|
// If using standard-uber-model-medigun, ensure they have a full charge and are not already in charge release mode
|
||
|
bool bDenyUse = GetMedigunType() != MEDIGUN_RESIST && (m_flChargeLevel < 1.0);
|
||
|
// If using the resist-medigun, they can shoot sooner
|
||
|
float flChunkSize = GetMinChargeAmount();
|
||
|
bDenyUse |= GetMedigunType() == MEDIGUN_RESIST && m_flChargeLevel < flChunkSize;
|
||
|
|
||
|
if ( bDenyUse || m_bChargeRelease )
|
||
|
{
|
||
|
#ifdef CLIENT_DLL
|
||
|
// Deny, flash
|
||
|
if ( !m_bChargeRelease && gpGlobals->curtime >= m_flDenySecondary )
|
||
|
{
|
||
|
m_flDenySecondary = gpGlobals->curtime + 0.5f;
|
||
|
pOwner->EmitSound( "Player.DenyWeaponSelection" );
|
||
|
}
|
||
|
#endif
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( !pOwner->m_Shared.CanRecieveMedigunChargeEffect( GetChargeType() ) )
|
||
|
{
|
||
|
if ( pOwner->m_afButtonPressed & IN_ATTACK2
|
||
|
#ifdef CLIENT_DLL
|
||
|
&& prediction->IsFirstTimePredicted()
|
||
|
#endif
|
||
|
)
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
CSingleUserRecipientFilter filter( pOwner );
|
||
|
TFGameRules()->SendHudNotification( filter, HUD_NOTIFY_NO_INVULN_WITH_FLAG );
|
||
|
#else
|
||
|
pOwner->EmitSound( "Player.DenyWeaponSelection" );
|
||
|
#endif
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Toggle super charge state
|
||
|
m_bChargeRelease = true;
|
||
|
m_flReleaseStartedAt = gpGlobals->curtime;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
if( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
// We dont want to give the user a point every time they deploy an uber with the resist medigun.
|
||
|
// Instead we give them a point for every 4 deploys
|
||
|
UberchargeChunkDeployed();
|
||
|
|
||
|
int nCurrentChunk = floor( m_flChargeLevel / flChunkSize );
|
||
|
Assert( nCurrentChunk >= 1 );
|
||
|
|
||
|
CPVSFilter filter( pOwner->WorldSpaceCenter() );
|
||
|
pOwner->EmitSound( filter, pOwner->entindex(), CFmtStr( "WeaponMedigun_Vaccinator.Charged_tier_0%d", nCurrentChunk ) );
|
||
|
pOwner->EmitSound( filter, pOwner->entindex(), g_MedigunEffects[MEDIGUN_CHARGE_BULLET_RESIST].pszChargeOnSound );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Award assist point
|
||
|
CTF_GameStats.Event_PlayerInvulnerable( pOwner );
|
||
|
// Award strange assist score
|
||
|
EconEntity_OnOwnerKillEaterEvent( this, pOwner, ToTFPlayer( m_hHealingTarget ), kKillEaterEvent_UberActivated );
|
||
|
}
|
||
|
|
||
|
// STAGING_MEDIC
|
||
|
if ( GetMedigunType() != MEDIGUN_RESIST )
|
||
|
{
|
||
|
RecalcEffectOnTarget( pOwner );
|
||
|
}
|
||
|
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_MEDIC_CHARGEDEPLOYED );
|
||
|
|
||
|
if ( pTFPlayerPatient )
|
||
|
{
|
||
|
// STAGING_MEDIC
|
||
|
if ( GetMedigunType() != MEDIGUN_RESIST )
|
||
|
{
|
||
|
RecalcEffectOnTarget( pTFPlayerPatient );
|
||
|
}
|
||
|
|
||
|
pTFPlayerPatient->SpeakConceptIfAllowed( MP_CONCEPT_HEALTARGET_CHARGEDEPLOYED );
|
||
|
}
|
||
|
|
||
|
IGameEvent * event = gameeventmanager->CreateEvent( "player_chargedeployed" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "userid", pOwner->GetUserID() );
|
||
|
if ( m_hHealingTarget && m_hHealingTarget->IsPlayer() )
|
||
|
{
|
||
|
event->SetInt( "targetid", ToTFPlayer(m_hHealingTarget)->GetUserID() );
|
||
|
}
|
||
|
gameeventmanager->FireEvent( event );
|
||
|
}
|
||
|
|
||
|
// Check for achievements
|
||
|
// Simultaneous uber charge with teammates.
|
||
|
CTeam *pTeam = pOwner->GetTeam();
|
||
|
if ( pTeam )
|
||
|
{
|
||
|
CUtlVector<CTFPlayer*> aChargingMedics;
|
||
|
aChargingMedics.AddToTail( pOwner );
|
||
|
for ( int i = 0; i < pTeam->GetNumPlayers(); i++ )
|
||
|
{
|
||
|
CTFPlayer *pTeamPlayer = ToTFPlayer( pTeam->GetPlayer(i) );
|
||
|
if ( pTeamPlayer && pTeamPlayer->IsPlayerClass( TF_CLASS_MEDIC ) && pTeamPlayer != pOwner )
|
||
|
{
|
||
|
CWeaponMedigun *pWeapon = dynamic_cast <CWeaponMedigun*>( pTeamPlayer->GetActiveWeapon() );
|
||
|
if ( pWeapon && pWeapon->IsReleasingCharge() )
|
||
|
{
|
||
|
aChargingMedics.AddToTail( pTeamPlayer );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( aChargingMedics.Count() >= 3 )
|
||
|
{
|
||
|
// Give the achievement to all the Medics
|
||
|
for ( int i = 0; i < aChargingMedics.Count(); i++ )
|
||
|
{
|
||
|
if ( aChargingMedics[i] )
|
||
|
{
|
||
|
aChargingMedics[i]->AwardAchievement( ACHIEVEMENT_TF_MEDIC_SIMUL_CHARGE );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// reset this count
|
||
|
pOwner->HandleAchievement_Medic_AssistHeavy( NULL );
|
||
|
|
||
|
// If using the QuickFix, heal the medic
|
||
|
if ( GetMedigunType() == MEDIGUN_QUICKFIX )
|
||
|
{
|
||
|
if ( IsReleasingCharge() && !m_bHealingSelf )
|
||
|
{
|
||
|
StartHealingTarget( pOwner );
|
||
|
m_bHealingSelf = true;
|
||
|
}
|
||
|
}
|
||
|
#endif // GAME_DLL
|
||
|
|
||
|
// STAGING_MEDIC
|
||
|
if ( GetMedigunType() == MEDIGUN_RESIST )
|
||
|
{
|
||
|
// Remove charge immediately and just give target and yourself the conditions
|
||
|
m_bChargeRelease = false;
|
||
|
#ifdef GAME_DLL
|
||
|
int iResistDuration = 3.0f;
|
||
|
pOwner->m_Shared.AddCond( g_MedigunResistConditions[GetResistType()].uberCond, iResistDuration, pOwner );
|
||
|
m_flChargeLevel -= flChunkSize;
|
||
|
if ( pTFPlayerPatient )
|
||
|
{
|
||
|
pTFPlayerPatient->m_Shared.AddCond( g_MedigunResistConditions[GetResistType()].uberCond, iResistDuration, pOwner );
|
||
|
}
|
||
|
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
|
||
|
{
|
||
|
CBaseEntity *pTarget = m_hHealingTarget;
|
||
|
CTFReviveMarker *pReviveMarker = dynamic_cast<CTFReviveMarker*>( pTarget );
|
||
|
if ( pReviveMarker )
|
||
|
{
|
||
|
CTFPlayer *pDeadPlayer = pReviveMarker->GetOwner();
|
||
|
if ( pDeadPlayer )
|
||
|
{
|
||
|
pReviveMarker->SetReviver( pOwner );
|
||
|
// fill almost to max, give a small time period so patient has time to see notifications from regular revive code
|
||
|
pReviveMarker->AddMarkerHealth( pReviveMarker->GetMaxHealth() * 0.9f );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Idle tests to see if we're facing a valid target for the medikit
|
||
|
// If so, move into the "heal-able" animation.
|
||
|
// Otherwise, move into the "not-heal-able" animation.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::WeaponIdle( void )
|
||
|
{
|
||
|
if ( HasWeaponIdleTimeElapsed() )
|
||
|
{
|
||
|
// Loop the welding animation
|
||
|
if ( m_bHealing )
|
||
|
{
|
||
|
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
return BaseClass::WeaponIdle();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#if defined( CLIENT_DLL )
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::StopHealSound( bool bStopHealingSound, bool bStopNoTargetSound )
|
||
|
{
|
||
|
if ( bStopHealingSound )
|
||
|
{
|
||
|
StopSound( GetHealSound() );
|
||
|
}
|
||
|
|
||
|
if ( bStopNoTargetSound )
|
||
|
{
|
||
|
StopSound( "WeaponMedigun.NoTarget" );
|
||
|
}
|
||
|
|
||
|
if ( m_pDisruptSound )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pDisruptSound );
|
||
|
m_pDisruptSound = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CWeaponMedigun::StopChargeEffect( bool bImmediately )
|
||
|
{
|
||
|
// Either these should both be NULL or neither NULL
|
||
|
Assert( ( m_pChargeEffect != NULL && m_pChargeEffectOwner != NULL ) || ( m_pChargeEffect == NULL && m_pChargeEffectOwner == NULL ) );
|
||
|
|
||
|
if ( m_pChargeEffect != NULL && m_pChargeEffectOwner != NULL )
|
||
|
{
|
||
|
if( bImmediately )
|
||
|
{
|
||
|
m_pChargeEffectOwner->ParticleProp()->StopEmissionAndDestroyImmediately( m_pChargeEffect );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_pChargeEffectOwner->ParticleProp()->StopEmission( m_pChargeEffect );
|
||
|
}
|
||
|
m_pChargeEffect = NULL;
|
||
|
m_pChargeEffectOwner = NULL;
|
||
|
}
|
||
|
|
||
|
if ( m_pChargedSound != NULL )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pChargedSound );
|
||
|
m_pChargedSound = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::ManageChargeEffect( void )
|
||
|
{
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
C_BaseEntity *pEffectOwner = this;
|
||
|
|
||
|
if ( pLocalPlayer == NULL )
|
||
|
return;
|
||
|
|
||
|
if ( pLocalPlayer == GetTFPlayerOwner() )
|
||
|
{
|
||
|
pEffectOwner = pLocalPlayer->GetRenderedWeaponModel();
|
||
|
if ( !pEffectOwner )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool bOwnerTaunting = false;
|
||
|
|
||
|
if ( GetTFPlayerOwner() && GetTFPlayerOwner()->m_Shared.InCond( TF_COND_TAUNTING ) == true )
|
||
|
{
|
||
|
bOwnerTaunting = true;
|
||
|
}
|
||
|
|
||
|
float flMinChargeToDeploy = GetMinChargeAmount();
|
||
|
|
||
|
if ( GetTFPlayerOwner() && bOwnerTaunting == false && m_bHolstered == false && ( m_flChargeLevel >= flMinChargeToDeploy || m_bChargeRelease == true ) )
|
||
|
{
|
||
|
// Did we switch from 1st to 3rd or 3rd to 1st? Taunting does this.
|
||
|
if( pEffectOwner != m_pChargeEffectOwner )
|
||
|
{
|
||
|
// Stop the current effect so we can make a new one
|
||
|
StopChargeEffect( m_bHolstered );
|
||
|
}
|
||
|
|
||
|
if ( m_pChargeEffect == NULL )
|
||
|
{
|
||
|
const char *pszEffectName = NULL;
|
||
|
|
||
|
switch( GetTFPlayerOwner()->GetTeamNumber() )
|
||
|
{
|
||
|
case TF_TEAM_BLUE:
|
||
|
pszEffectName = "medicgun_invulnstatus_fullcharge_blue";
|
||
|
break;
|
||
|
case TF_TEAM_RED:
|
||
|
pszEffectName = "medicgun_invulnstatus_fullcharge_red";
|
||
|
break;
|
||
|
default:
|
||
|
pszEffectName = "";
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
m_pChargeEffect = pEffectOwner->ParticleProp()->Create( pszEffectName, PATTACH_POINT_FOLLOW, "muzzle" );
|
||
|
m_pChargeEffectOwner = pEffectOwner;
|
||
|
}
|
||
|
|
||
|
if ( m_pChargedSound == NULL )
|
||
|
{
|
||
|
CLocalPlayerFilter filter;
|
||
|
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
m_pChargedSound = controller.SoundCreate( filter, entindex(), "WeaponMedigun.Charged" );
|
||
|
controller.Play( m_pChargedSound, 1.0, 100 );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
StopChargeEffect( m_bHolstered );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Input : updateType -
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::OnDataChanged( DataUpdateType_t updateType )
|
||
|
{
|
||
|
BaseClass::OnDataChanged( updateType );
|
||
|
|
||
|
if ( m_bUpdateHealingTargets )
|
||
|
{
|
||
|
UpdateEffects();
|
||
|
m_bUpdateHealingTargets = false;
|
||
|
}
|
||
|
|
||
|
if ( m_nOldChargeResistType != m_nChargeResistType )
|
||
|
{
|
||
|
m_nOldChargeResistType = m_nChargeResistType;
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
if( GetOwner() == pLocalPlayer && pLocalPlayer )
|
||
|
{
|
||
|
// Sound effect
|
||
|
pLocalPlayer->EmitSound( "WeaponMedigun_Vaccinator.Toggle" );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_bHealing )
|
||
|
{
|
||
|
CTFPlayer *pTarget = ToTFPlayer( m_hHealingTarget );
|
||
|
if ( !m_pDisruptSound && pTarget && pTarget->m_Shared.InCond( TF_COND_HEALING_DEBUFF ) )
|
||
|
{
|
||
|
CLocalPlayerFilter filter;
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
m_pDisruptSound = controller.SoundCreate( filter, entindex(), "WeaponMedigun.HealingDisrupt" );
|
||
|
controller.Play( m_pDisruptSound, 1.f, 100.f );
|
||
|
}
|
||
|
else if ( m_pDisruptSound )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pDisruptSound );
|
||
|
m_pDisruptSound = NULL;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
|
||
|
m_bPlayingSound = false;
|
||
|
StopHealSound( true, false );
|
||
|
|
||
|
// Are they holding the attack button but not healing anyone? Give feedback.
|
||
|
if ( IsActiveByLocalPlayer() && GetOwner() && GetOwner()->IsAlive() && m_bAttacking && GetOwner() == C_BasePlayer::GetLocalPlayer() && CanAttack() == true )
|
||
|
{
|
||
|
if ( gpGlobals->curtime >= m_flNextBuzzTime )
|
||
|
{
|
||
|
CLocalPlayerFilter filter;
|
||
|
EmitSound( filter, entindex(), "WeaponMedigun.NoTarget" );
|
||
|
m_flNextBuzzTime = gpGlobals->curtime + 0.5f; // only buzz every so often.
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
StopHealSound( false, true ); // Stop the "no target" sound.
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Think?
|
||
|
if ( m_bHealing || IsCarriedByLocalPlayer() )
|
||
|
{
|
||
|
ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
|
||
|
}
|
||
|
|
||
|
ManageChargeEffect();
|
||
|
|
||
|
// Find teammates that need healing
|
||
|
if ( IsCarriedByLocalPlayer() )
|
||
|
{
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
if ( !pLocalPlayer || !pLocalPlayer->IsPlayerClass( TF_CLASS_MEDIC ) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( pLocalPlayer == GetOwner() && hud_medicautocallers.GetBool() )
|
||
|
{
|
||
|
UpdateMedicAutoCallers();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::ClientThink()
|
||
|
{
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
if ( !pLocalPlayer )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// Don't show it while the player is dead. Ideally, we'd respond to m_bHealing in OnDataChanged,
|
||
|
// but it stops sending the weapon when it's holstered, and it gets holstered when the player dies.
|
||
|
CTFPlayer *pFiringPlayer = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pFiringPlayer || pFiringPlayer->IsPlayerDead() || pFiringPlayer->IsDormant() )
|
||
|
{
|
||
|
ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
|
||
|
m_bPlayingSound = false;
|
||
|
StopHealSound();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// If the local player is the guy getting healed, let him know
|
||
|
// who's healing him, and their charge level.
|
||
|
if( m_hHealingTarget != NULL )
|
||
|
{
|
||
|
if ( pLocalPlayer == m_hHealingTarget )
|
||
|
{
|
||
|
pLocalPlayer->SetHealer( pFiringPlayer, m_flChargeLevel );
|
||
|
}
|
||
|
|
||
|
// Setup whether we were last healed by the local player or by someone else (used by replay system)
|
||
|
// since GetHealer() gets cleared out every frame before player_death events get fired. See tf_replay.cpp.
|
||
|
C_BaseEntity *pHealingTargetEnt = m_hHealingTarget;
|
||
|
if ( pHealingTargetEnt && pHealingTargetEnt->IsPlayer() )
|
||
|
{
|
||
|
C_TFPlayer *pHealingTargetPlayer = ToTFPlayer( pHealingTargetEnt );
|
||
|
pHealingTargetPlayer->SetWasHealedByLocalPlayer( pFiringPlayer == pLocalPlayer );
|
||
|
}
|
||
|
|
||
|
if ( !m_bPlayingSound )
|
||
|
{
|
||
|
m_bPlayingSound = true;
|
||
|
CLocalPlayerFilter filter;
|
||
|
EmitSound( filter, entindex(), GetHealSound() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_bOldChargeRelease != m_bChargeRelease )
|
||
|
{
|
||
|
m_bOldChargeRelease = m_bChargeRelease;
|
||
|
ForceHealingTargetUpdate();
|
||
|
}
|
||
|
|
||
|
// If the rendered weapon has changed, we need to update our particles
|
||
|
if ( m_hHealingTargetEffect.pOwner && pFiringPlayer->GetRenderedWeaponModel() != m_hHealingTargetEffect.pOwner )
|
||
|
{
|
||
|
ForceHealingTargetUpdate();
|
||
|
}
|
||
|
|
||
|
if ( pFiringPlayer->m_Shared.IsEnteringOrExitingFullyInvisible() )
|
||
|
{
|
||
|
UpdateEffects();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::UpdateEffects( void )
|
||
|
{
|
||
|
CTFPlayer *pFiringPlayer = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pFiringPlayer )
|
||
|
return;
|
||
|
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
C_BaseEntity *pEffectOwner = this;
|
||
|
if ( pLocalPlayer == pFiringPlayer )
|
||
|
{
|
||
|
pEffectOwner = pLocalPlayer->GetRenderedWeaponModel();
|
||
|
}
|
||
|
|
||
|
// If we're still healing and our owner changed, then we did something
|
||
|
// like changed
|
||
|
bool bImmediate = pEffectOwner != m_hHealingTargetEffect.pOwner && m_bHealing;
|
||
|
|
||
|
// Remove all the effects
|
||
|
if ( m_hHealingTargetEffect.pOwner )
|
||
|
{
|
||
|
if ( m_hHealingTargetEffect.pEffect )
|
||
|
{
|
||
|
bImmediate ? m_hHealingTargetEffect.pOwner->ParticleProp()->StopEmissionAndDestroyImmediately( m_hHealingTargetEffect.pEffect )
|
||
|
: m_hHealingTargetEffect.pOwner->ParticleProp()->StopEmission( m_hHealingTargetEffect.pEffect );
|
||
|
}
|
||
|
if ( m_hHealingTargetEffect.pCustomEffect )
|
||
|
{
|
||
|
bImmediate ? m_hHealingTargetEffect.pOwner->ParticleProp()->StopEmissionAndDestroyImmediately( m_hHealingTargetEffect.pCustomEffect )
|
||
|
: m_hHealingTargetEffect.pOwner->ParticleProp()->StopEmission( m_hHealingTargetEffect.pCustomEffect );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_hHealingTargetEffect.pEffect )
|
||
|
{
|
||
|
m_hHealingTargetEffect.pEffect->StopEmission();
|
||
|
}
|
||
|
if ( m_hHealingTargetEffect.pCustomEffect )
|
||
|
{
|
||
|
m_hHealingTargetEffect.pCustomEffect->StopEmission();
|
||
|
}
|
||
|
}
|
||
|
m_hHealingTargetEffect.pOwner = NULL;
|
||
|
m_hHealingTargetEffect.pTarget = NULL;
|
||
|
m_hHealingTargetEffect.pEffect = NULL;
|
||
|
m_hHealingTargetEffect.pCustomEffect = NULL;
|
||
|
|
||
|
// Don't add targets if the medic is dead
|
||
|
if ( !pEffectOwner || pFiringPlayer->IsPlayerDead() || !pFiringPlayer->IsPlayerClass( TF_CLASS_MEDIC ) || pFiringPlayer->m_Shared.IsFullyInvisible() )
|
||
|
return;
|
||
|
|
||
|
// Add our targets
|
||
|
// Loops through the healing targets, and make sure we have an effect for each of them
|
||
|
|
||
|
if ( m_hHealingTarget )
|
||
|
{
|
||
|
if ( m_hHealingTargetEffect.pTarget == m_hHealingTarget )
|
||
|
return;
|
||
|
|
||
|
bool bReviveMarker = m_hReviveMarker && m_hReviveMarker == m_hHealingTarget; // Hack to avoid another dynamic_cast here
|
||
|
bool bHealTargetMarker = hud_medichealtargetmarker.GetBool() && !bReviveMarker;
|
||
|
|
||
|
const char *pszEffectName;
|
||
|
if ( IsAttachedToBuilding() )
|
||
|
{
|
||
|
pszEffectName = "medicgun_beam_machinery";
|
||
|
}
|
||
|
else if ( pFiringPlayer->GetTeamNumber() == TF_TEAM_RED )
|
||
|
{
|
||
|
if ( m_bChargeRelease )
|
||
|
{
|
||
|
pszEffectName = "medicgun_beam_red_invun";
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( bHealTargetMarker && pFiringPlayer == pLocalPlayer )
|
||
|
{
|
||
|
pszEffectName = "medicgun_beam_red_targeted";
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pszEffectName = "medicgun_beam_red";
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_bChargeRelease )
|
||
|
{
|
||
|
pszEffectName = "medicgun_beam_blue_invun";
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( bHealTargetMarker && pFiringPlayer == pLocalPlayer )
|
||
|
{
|
||
|
pszEffectName = "medicgun_beam_blue_targeted";
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pszEffectName = "medicgun_beam_blue";
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Attach differently if targeting a revive marker
|
||
|
float flVecHeightOffset = bReviveMarker ? 0.f : 50.f;
|
||
|
ParticleAttachment_t attachType = bReviveMarker ? PATTACH_POINT_FOLLOW : PATTACH_ABSORIGIN_FOLLOW;
|
||
|
const char *pszAttachName = bReviveMarker ? "healbeam" : NULL;
|
||
|
|
||
|
CNewParticleEffect *pEffect = pEffectOwner->ParticleProp()->Create( pszEffectName, PATTACH_POINT_FOLLOW, "muzzle" );
|
||
|
pEffectOwner->ParticleProp()->AddControlPoint( pEffect, 1, m_hHealingTarget, attachType, pszAttachName, Vector(0.f,0.f,flVecHeightOffset) );
|
||
|
|
||
|
m_hHealingTargetEffect.pTarget = m_hHealingTarget;
|
||
|
m_hHealingTargetEffect.pEffect = pEffect;
|
||
|
m_hHealingTargetEffect.pOwner = pEffectOwner;
|
||
|
|
||
|
// See if we have a custom particle effect that wants to add to the beam
|
||
|
CEconItemView *pItem = m_AttributeManager.GetItem();
|
||
|
int iSystems = pItem->GetStaticData()->GetNumAttachedParticles( GetTeamNumber() );
|
||
|
for ( int i = 0; i < iSystems; i++ )
|
||
|
{
|
||
|
attachedparticlesystem_t *pSystem = pItem->GetStaticData()->GetAttachedParticleData( GetTeamNumber(),i );
|
||
|
if ( pSystem->iCustomType == 1 )
|
||
|
{
|
||
|
pEffect = pEffectOwner->ParticleProp()->Create( pSystem->pszSystemName, PATTACH_POINT_FOLLOW, "muzzle" );
|
||
|
pEffectOwner->ParticleProp()->AddControlPoint( pEffect, 1, m_hHealingTarget, attachType, pszAttachName, Vector(0.f,0.f,flVecHeightOffset) );
|
||
|
m_hHealingTargetEffect.pCustomEffect = pEffect;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Look for teammates that need healing
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::UpdateMedicAutoCallers( void )
|
||
|
{
|
||
|
// Find teammates that need healing
|
||
|
if ( gpGlobals->curtime > m_flAutoCallerCheckTime )
|
||
|
{
|
||
|
if ( !g_TF_PR )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
|
||
|
for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
|
||
|
{
|
||
|
if ( g_TF_PR->GetTeam( playerIndex ) == GetLocalPlayerTeam() )
|
||
|
{
|
||
|
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
|
||
|
|
||
|
// Don't do this for the local player
|
||
|
if ( pPlayer == NULL || pPlayer == pLocalPlayer )
|
||
|
continue;
|
||
|
|
||
|
if( m_hHealingTarget != NULL )
|
||
|
{
|
||
|
// Don't do this for players the medic is healing
|
||
|
if ( pPlayer == m_hHealingTarget )
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
if ( pPlayer->IsAlive() )
|
||
|
{
|
||
|
int iHealth = float( pPlayer->GetHealth() ) / float( pPlayer->GetMaxHealth() ) * 100;
|
||
|
int iHealthThreshold = hud_medicautocallersthreshold.GetInt();
|
||
|
|
||
|
// If it's a healthy teammate....
|
||
|
if ( iHealth > iHealthThreshold )
|
||
|
{
|
||
|
// Make sure we don't have them in our list if previously hurt
|
||
|
if ( m_iAutoCallers.Find( playerIndex ) != m_iAutoCallers.InvalidIndex() )
|
||
|
{
|
||
|
m_iAutoCallers.FindAndRemove( playerIndex );
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// If it's a hurt teammate....
|
||
|
if ( iHealth <= iHealthThreshold )
|
||
|
{
|
||
|
|
||
|
// Make sure we're not already tracking this
|
||
|
if ( m_iAutoCallers.Find( playerIndex ) != m_iAutoCallers.InvalidIndex())
|
||
|
continue;
|
||
|
|
||
|
// Distance check
|
||
|
float flDistSq = pPlayer->GetAbsOrigin().DistToSqr( pLocalPlayer->GetAbsOrigin() );
|
||
|
if ( flDistSq >= 1000000 )
|
||
|
{
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
// Now add auto-caller
|
||
|
pPlayer->CreateSaveMeEffect( CALLER_TYPE_AUTO );
|
||
|
|
||
|
// And track the player so we don't re-add them
|
||
|
m_iAutoCallers.AddToTail( playerIndex );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Throttle this check
|
||
|
m_flAutoCallerCheckTime = gpGlobals->curtime + 0.25f;
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::CheckAchievementsOnHealTarget( void )
|
||
|
{
|
||
|
CTFPlayer *pTFPlayer = ToTFPlayer( m_hHealingTarget );
|
||
|
if ( !pTFPlayer )
|
||
|
return;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
|
||
|
// Check for "target under fire" achievement
|
||
|
if ( pTFPlayer->m_AchievementData.CountDamagersWithinTime(3.0) >= 4 )
|
||
|
{
|
||
|
if ( GetTFPlayerOwner() )
|
||
|
{
|
||
|
GetTFPlayerOwner()->AwardAchievement( ACHIEVEMENT_TF_MEDIC_HEAL_UNDER_FIRE );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Check for "Engineer repairing sentrygun" achievement
|
||
|
if ( pTFPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) )
|
||
|
{
|
||
|
// Has Engineer worked on his sentrygun recently?
|
||
|
CBaseObject *pSentry = pTFPlayer->GetObjectOfType( OBJ_SENTRYGUN );
|
||
|
if ( pSentry && pTFPlayer->m_AchievementData.IsTargetInHistory( pSentry, 4.0 ) )
|
||
|
{
|
||
|
if ( pSentry->m_AchievementData.CountDamagersWithinTime(3.0) > 0 )
|
||
|
{
|
||
|
CTFPlayer *pOwner = GetTFPlayerOwner();
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
// give to medic
|
||
|
pOwner->AwardAchievement( ACHIEVEMENT_TF_MEDIC_HEAL_ENGINEER );
|
||
|
|
||
|
// give to the engineer!
|
||
|
pTFPlayer->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_REPAIR_SENTRY_W_MEDIC );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#else
|
||
|
|
||
|
// check for ACHIEVEMENT_TF_MEDIC_HEAL_CALLERS
|
||
|
if ( pTFPlayer->m_flSaveMeExpireTime > gpGlobals->curtime )
|
||
|
{
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_healedmediccall" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "userid", pTFPlayer->GetUserID() );
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Our owner has become stunned.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CWeaponMedigun::OnControlStunned( void )
|
||
|
{
|
||
|
BaseClass::OnControlStunned();
|
||
|
|
||
|
// Interrupt auto healing.
|
||
|
RemoveHealingTarget( true );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CWeaponMedigun::EffectMeterShouldFlash( void )
|
||
|
{
|
||
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
||
|
if ( !pPlayer )
|
||
|
return false;
|
||
|
|
||
|
if ( pPlayer && ( pPlayer->m_Shared.GetRageMeter() >= 100.0f || pPlayer->m_Shared.IsRageDraining() ) )
|
||
|
return true;
|
||
|
else
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: UI Progress
|
||
|
//-----------------------------------------------------------------------------
|
||
|
float CWeaponMedigun::GetProgress( void )
|
||
|
{
|
||
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
||
|
if ( !pPlayer )
|
||
|
return 0.f;
|
||
|
|
||
|
return pPlayer->m_Shared.GetRageMeter() / 100.0f;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// entity_medigun_shield
|
||
|
//-----------------------------------------------------------------------------
|
||
|
#define MEDIGUNSHIELD_THINK_CONTEXT "CTFMedigunShield_ShieldThink"
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( entity_medigun_shield, CTFMedigunShield );
|
||
|
PRECACHE_WEAPON_REGISTER( entity_medigun_shield );
|
||
|
|
||
|
// Network
|
||
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFMedigunShield, DT_TFMedigunShield )
|
||
|
|
||
|
BEGIN_NETWORK_TABLE( CTFMedigunShield, DT_TFMedigunShield )
|
||
|
END_NETWORK_TABLE()
|
||
|
|
||
|
BEGIN_PREDICTION_DATA( CTFMedigunShield )
|
||
|
END_PREDICTION_DATA()
|
||
|
|
||
|
// Data
|
||
|
BEGIN_DATADESC( CTFMedigunShield )
|
||
|
#ifdef GAME_DLL
|
||
|
DEFINE_FUNCTION( ShieldTouch ),
|
||
|
DEFINE_THINKFUNC( ShieldThink ),
|
||
|
#endif // GAME_DLL
|
||
|
END_DATADESC()
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
static const float PROJECTILE_SHIELD_ALPHA_BASE = 150.f;
|
||
|
static const float PROJECTILE_SHIELD_ENERGY_REFILL_PULSE = 10.f;
|
||
|
static const float PROJECTILE_SHIELD_ENERGY_MAX = 1000.f;
|
||
|
#endif // GAME_DLL
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CTFMedigunShield::CTFMedigunShield()
|
||
|
{
|
||
|
m_nBlinkCount = 0;
|
||
|
#ifdef GAME_DLL
|
||
|
m_pTouchLoop = NULL;
|
||
|
|
||
|
#ifdef STAGING_ONLY
|
||
|
m_bPermanentShield = false;
|
||
|
#endif // STAGING_ONLY
|
||
|
|
||
|
#endif // GAME_DLL
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CTFMedigunShield::~CTFMedigunShield()
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
if ( m_pTouchLoop )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pTouchLoop );
|
||
|
m_pTouchLoop = NULL;
|
||
|
}
|
||
|
#endif // GAME_DLL
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::Spawn()
|
||
|
{
|
||
|
BaseClass::Spawn();
|
||
|
|
||
|
SetModel( "models/props_mvm/mvm_player_shield.mdl" );
|
||
|
SetSolid( SOLID_VPHYSICS );
|
||
|
SetSolidFlags( FSOLID_TRIGGER );
|
||
|
SetCollisionGroup( TFCOLLISION_GROUP_COMBATOBJECT );
|
||
|
SetBlocksLOS( false );
|
||
|
AddEffects( EF_NOSHADOW );
|
||
|
|
||
|
m_takedamage = DAMAGE_EVENTS_ONLY;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
m_flShieldEnergyLevel = PROJECTILE_SHIELD_ENERGY_MAX;
|
||
|
|
||
|
SetTouch( &CTFMedigunShield::ShieldTouch );
|
||
|
SetContextThink( &CTFMedigunShield::ShieldThink, gpGlobals->curtime, MEDIGUNSHIELD_THINK_CONTEXT );
|
||
|
#else
|
||
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
||
|
#endif // GAME_DLL
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::Precache()
|
||
|
{
|
||
|
PrecacheScriptSound( "WeaponMedi_Shield.Deploy" );
|
||
|
PrecacheScriptSound( "WeaponMedi_Shield.Protection" );
|
||
|
PrecacheScriptSound( "WeaponMedi_Shield.Retract" );
|
||
|
PrecacheScriptSound( "WeaponMedi_Shield.Burn" );
|
||
|
PrecacheScriptSound( "WeaponMedi_Shield.Burn_lp" );
|
||
|
|
||
|
PrecacheModel( "models/props_mvm/mvm_player_shield.mdl" );
|
||
|
PrecacheModel( "models/props_mvm/mvm_player_shield2.mdl" );
|
||
|
|
||
|
BaseClass::Precache();
|
||
|
}
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::ClientThink()
|
||
|
{
|
||
|
UpdateShieldPosition();
|
||
|
}
|
||
|
#endif // CLIENT_DLL
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::UpdateShieldPosition( void )
|
||
|
{
|
||
|
CBaseEntity *pOwner = GetOwnerEntity();
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
// Positioning logic
|
||
|
Vector vecForward;
|
||
|
AngleVectors( pOwner->EyeAngles(), &vecForward );
|
||
|
vecForward.z = 0.f;
|
||
|
Vector vecShieldOrigin = pOwner->GetAbsOrigin() + vecForward * 145.f;
|
||
|
SetAbsOrigin( vecShieldOrigin );
|
||
|
SetAbsAngles( QAngle( 0.f, pOwner->EyeAngles().y, 0.f ) ); // Ignore pitch
|
||
|
}
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CTFMedigunShield *CTFMedigunShield::Create( CTFPlayer *pOwner )
|
||
|
{
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
CTFMedigunShield *pShield = static_cast< CTFMedigunShield* >( CBaseEntity::Create( "entity_medigun_shield", pOwner->GetAbsOrigin() + Vector( 0, 0, 60 ), pOwner->GetAbsAngles() ) );
|
||
|
if ( pShield )
|
||
|
{
|
||
|
pShield->SetOwnerEntity( pOwner );
|
||
|
pShield->ChangeTeam( pOwner->GetTeamNumber() );
|
||
|
|
||
|
int nShieldLevel = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pOwner, nShieldLevel, generate_rage_on_heal );
|
||
|
if ( nShieldLevel > 1 )
|
||
|
{
|
||
|
pShield->SetModel( "models/props_mvm/mvm_player_shield2.mdl" );
|
||
|
}
|
||
|
|
||
|
pShield->m_nSkin = pShield->GetTeamNumber() == TF_TEAM_RED ? 0 : 1;
|
||
|
|
||
|
CPVSFilter filter( pOwner->WorldSpaceCenter() );
|
||
|
pOwner->EmitSound( filter, pOwner->entindex(), "WeaponMedi_Shield.Deploy" );
|
||
|
|
||
|
return pShield;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//------------------------------------------------------------------------------
|
||
|
// bool CTFMedigunShield::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace )
|
||
|
// {
|
||
|
// switch( GetTeamNumber() )
|
||
|
// {
|
||
|
// case TF_TEAM_RED:
|
||
|
// if ( ( mask & CONTENTS_REDTEAM ) )
|
||
|
// return false;
|
||
|
// break;
|
||
|
//
|
||
|
// case TF_TEAM_BLUE:
|
||
|
// if ( ( mask & CONTENTS_BLUETEAM ) )
|
||
|
// return false;
|
||
|
// break;
|
||
|
// }
|
||
|
//
|
||
|
// vcollide_t *pCollide = modelinfo->GetVCollide( GetModelIndex() );
|
||
|
//
|
||
|
// UTIL_ClearTrace( trace );
|
||
|
//
|
||
|
// physcollision->TraceBox( ray, pCollide->solids[0], GetAbsOrigin(), GetAbsAngles(), &trace );
|
||
|
//
|
||
|
// if ( trace.fraction >= 1 )
|
||
|
// return false;
|
||
|
//
|
||
|
// // return owner as trace hit
|
||
|
// trace.m_pEnt = this;
|
||
|
// return true;
|
||
|
// }
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CTFMedigunShield::ShouldCollide( int collisionGroup, int contentsMask ) const
|
||
|
{
|
||
|
if ( collisionGroup == COLLISION_GROUP_PROJECTILE ||
|
||
|
collisionGroup == TFCOLLISION_GROUP_ROCKETS ||
|
||
|
collisionGroup == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS )
|
||
|
{
|
||
|
switch( GetTeamNumber() )
|
||
|
{
|
||
|
case TF_TEAM_RED:
|
||
|
if ( ( contentsMask & CONTENTS_BLUETEAM ) )
|
||
|
return false;
|
||
|
break;
|
||
|
|
||
|
case TF_TEAM_BLUE:
|
||
|
if ( ( contentsMask & CONTENTS_REDTEAM ) )
|
||
|
return false;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return BaseClass::ShouldCollide( collisionGroup, contentsMask );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::StartTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
BaseClass::StartTouch( pOther );
|
||
|
|
||
|
CBaseEntity *pOwner = GetOwnerEntity();
|
||
|
if ( !pOwner )
|
||
|
return;
|
||
|
|
||
|
if ( !InSameTeam( pOther ) )
|
||
|
{
|
||
|
CPVSFilter filter( WorldSpaceCenter() );
|
||
|
pOwner->EmitSound( filter, entindex(), "WeaponMedi_Shield.Burn" );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::ShieldTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
if ( !pOther )
|
||
|
return;
|
||
|
|
||
|
if ( !InSameTeam( pOther ) )
|
||
|
{
|
||
|
// Drip pan for unknown projectiles
|
||
|
if ( !pOther->IsDeflectable() && pOther->GetCollisionGroup() == COLLISION_GROUP_PROJECTILE )
|
||
|
{
|
||
|
UTIL_Remove( pOther );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CTFPlayer *pTFOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( !pTFOwner )
|
||
|
return;
|
||
|
|
||
|
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && ( pTFOwner->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
|
||
|
return;
|
||
|
|
||
|
int nShieldLevel = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFOwner, nShieldLevel, generate_rage_on_heal );
|
||
|
|
||
|
// Damage it
|
||
|
float flDamage = ( nShieldLevel > 1 ) ? 2.f : 1.f;
|
||
|
CTakeDamageInfo info;
|
||
|
info.SetAttacker( pTFOwner );
|
||
|
info.SetInflictor( this );
|
||
|
info.SetWeapon( pTFOwner->GetActiveTFWeapon() );
|
||
|
info.SetDamage( flDamage );
|
||
|
info.SetDamageType( DMG_ENERGYBEAM );
|
||
|
info.SetDamageCustom( TF_DMG_CUSTOM_PLASMA );
|
||
|
info.SetDamagePosition( pOther->EyePosition() );
|
||
|
pOther->TakeDamage( info );
|
||
|
|
||
|
// Slow enemy players
|
||
|
if ( pOther->IsPlayer() )
|
||
|
{
|
||
|
CTFPlayer *pTFVictim = ToTFPlayer( pOther );
|
||
|
if ( !pTFVictim )
|
||
|
return;
|
||
|
|
||
|
float flStun = ( nShieldLevel > 1 ) ? 0.5f : 0.3f;
|
||
|
pTFVictim->m_Shared.StunPlayer( 0.5f, flStun, TF_STUN_MOVEMENT, pTFOwner );
|
||
|
}
|
||
|
|
||
|
// Sound
|
||
|
if ( !m_pTouchLoop )
|
||
|
{
|
||
|
CPVSFilter filter( GetAbsOrigin() );
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
m_pTouchLoop = controller.SoundCreate( filter, entindex(), "WeaponMedi_Shield.Burn_lp" );
|
||
|
controller.Play( m_pTouchLoop, 1.0, 100 );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::EndTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
BaseClass::EndTouch( pOther );
|
||
|
|
||
|
if ( m_pTouchLoop )
|
||
|
{
|
||
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pTouchLoop );
|
||
|
m_pTouchLoop = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::ShieldThink( void )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
#ifdef STAGING_ONLY
|
||
|
if ( !pOwner || ( !pOwner->m_Shared.IsRageDraining() && !m_bPermanentShield ) )
|
||
|
#else
|
||
|
if ( !pOwner || !pOwner->m_Shared.IsRageDraining() )
|
||
|
#endif
|
||
|
{
|
||
|
RemoveShield();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
UpdateShieldPosition();
|
||
|
|
||
|
// Regen shield
|
||
|
if ( m_flShieldEnergyLevel < PROJECTILE_SHIELD_ENERGY_MAX )
|
||
|
{
|
||
|
m_flShieldEnergyLevel += PROJECTILE_SHIELD_ENERGY_REFILL_PULSE;
|
||
|
m_flShieldEnergyLevel = Min( m_flShieldEnergyLevel, PROJECTILE_SHIELD_ENERGY_MAX );
|
||
|
}
|
||
|
|
||
|
// Visuals
|
||
|
SetRenderMode( kRenderTransAlpha );
|
||
|
int nShieldOpacity = PROJECTILE_SHIELD_ALPHA_BASE;
|
||
|
|
||
|
// Determine alpha
|
||
|
float flFadePoint = PROJECTILE_SHIELD_ENERGY_MAX / 2.f;
|
||
|
if ( m_flShieldEnergyLevel <= flFadePoint )
|
||
|
{
|
||
|
nShieldOpacity = (int)RemapValClamped( m_flShieldEnergyLevel, 0.f, flFadePoint, 255.f, PROJECTILE_SHIELD_ALPHA_BASE );
|
||
|
}
|
||
|
|
||
|
// Blink when we're about to expire
|
||
|
#ifdef STAGING_ONLY
|
||
|
if ( pOwner->m_Shared.GetRageMeter() <= 25.f && !m_bPermanentShield )
|
||
|
#else
|
||
|
if ( pOwner->m_Shared.GetRageMeter() <= 25.f )
|
||
|
#endif
|
||
|
{
|
||
|
++m_nBlinkCount;
|
||
|
|
||
|
if ( m_nBlinkCount & 0x2 )
|
||
|
{
|
||
|
SetRenderColorA( PROJECTILE_SHIELD_ALPHA_BASE - 100 );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetRenderColorA( nShieldOpacity );
|
||
|
}
|
||
|
|
||
|
// Play a retract sound
|
||
|
if ( m_nBlinkCount == 1 )
|
||
|
{
|
||
|
CPVSFilter filter( pOwner->WorldSpaceCenter() );
|
||
|
pOwner->EmitSound( filter, entindex(), "WeaponMedi_Shield.Retract" );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetRenderColorA( nShieldOpacity );
|
||
|
}
|
||
|
|
||
|
SetContextThink( &CTFMedigunShield::ShieldThink, gpGlobals->curtime + 0.1f, MEDIGUNSHIELD_THINK_CONTEXT );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::RemoveShield( void )
|
||
|
{
|
||
|
SetTouch( NULL );
|
||
|
AddEffects( EF_NODRAW );
|
||
|
|
||
|
UTIL_Remove( this );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFMedigunShield::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
|
||
|
{
|
||
|
if ( !InSameTeam( info.GetAttacker() ) )
|
||
|
{
|
||
|
CEffectData data;
|
||
|
data.m_vOrigin = ptr->endpos - (vecDir * 8);
|
||
|
data.m_vNormal = -vecDir;
|
||
|
data.m_flMagnitude = RemapValClamped( info.GetDamage(), 1.f, 50.f, 0.5f, 2.f );
|
||
|
|
||
|
CPVSFilter filter( GetAbsOrigin() );
|
||
|
te->DispatchEffect( filter, 0.f, data.m_vOrigin, "EnergyShieldImpact", data );
|
||
|
|
||
|
// g_pEffects->EnergySplash( ptr->endpos - (vecDir * 8), -vecDir, false );
|
||
|
}
|
||
|
|
||
|
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CTFMedigunShield::OnTakeDamage( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
if ( !InSameTeam( info.GetAttacker() ) )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
float flDamage = info.GetDamage();
|
||
|
m_flShieldEnergyLevel -= flDamage;
|
||
|
m_flShieldEnergyLevel = Max( m_flShieldEnergyLevel, 0.f );
|
||
|
|
||
|
// Add to blocked damage stat
|
||
|
CTF_GameStats.Event_PlayerBlockedDamage( pOwner, flDamage );
|
||
|
|
||
|
// CPVSFilter filter( pOwner->WorldSpaceCenter() );
|
||
|
// pOwner->EmitSound( filter, entindex(), "WeaponMedi_Shield.Protection" );
|
||
|
|
||
|
pOwner->PlayDamageResistSound( 100.f, RandomFloat( 0.85f, 1.f ) );
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "medigun_shield_blocked_damage" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "userid", pOwner->GetUserID() );
|
||
|
event->SetFloat( "damage", flDamage );
|
||
|
gameeventmanager->FireEvent( event );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
#endif // GAME_DLL
|
||
|
|
||
|
|