620 lines
15 KiB
C++
620 lines
15 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
//
|
|
//=============================================================================
|
|
#include "cbase.h"
|
|
#include "tf_weapon_flaregun.h"
|
|
#include "tf_fx_shared.h"
|
|
#include "in_buttons.h"
|
|
|
|
// Client specific.
|
|
#ifdef CLIENT_DLL
|
|
#include "c_tf_player.h"
|
|
#include "soundenvelope.h"
|
|
// Server specific.
|
|
#else
|
|
#include "tf_gamestats.h"
|
|
#include "tf_player.h"
|
|
#endif
|
|
|
|
//=============================================================================
|
|
//
|
|
// Weapon Flare Gun tables.
|
|
//
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFFlareGun, DT_WeaponFlareGun )
|
|
|
|
BEGIN_NETWORK_TABLE( CTFFlareGun, DT_WeaponFlareGun )
|
|
#ifdef CLIENT_DLL
|
|
RecvPropFloat( RECVINFO( m_flChargeBeginTime ) ),
|
|
#else
|
|
SendPropFloat( SENDINFO( m_flChargeBeginTime ) ),
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_PREDICTION_DATA( CTFFlareGun )
|
|
END_PREDICTION_DATA()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_weapon_flaregun, CTFFlareGun );
|
|
PRECACHE_WEAPON_REGISTER( tf_weapon_flaregun );
|
|
|
|
// Server specific.
|
|
#ifndef CLIENT_DLL
|
|
BEGIN_DATADESC( CTFFlareGun )
|
|
END_DATADESC()
|
|
#endif
|
|
|
|
|
|
//============================
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFFlareGun_Revenge, DT_WeaponFlareGun_Revenge )
|
|
|
|
BEGIN_NETWORK_TABLE( CTFFlareGun_Revenge, DT_WeaponFlareGun_Revenge )
|
|
#ifdef CLIENT_DLL
|
|
RecvPropFloat( RECVINFO( m_fLastExtinguishTime ) ),
|
|
#else
|
|
SendPropFloat( SENDINFO( m_fLastExtinguishTime ) ),
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_PREDICTION_DATA( CTFFlareGun_Revenge )
|
|
END_PREDICTION_DATA()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_weapon_flaregun_revenge, CTFFlareGun_Revenge );
|
|
PRECACHE_WEAPON_REGISTER( tf_weapon_flaregun_revenge );
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// Weapon Flare Gun functions.
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CTFFlareGun::CTFFlareGun()
|
|
{
|
|
m_bEffectsThinking = false;
|
|
m_flLastDenySoundTime = 0.0f;
|
|
|
|
#ifdef CLIENT_DLL
|
|
m_bReadyToFire = false;
|
|
#endif
|
|
|
|
StopCharge();
|
|
}
|
|
|
|
CTFFlareGun::~CTFFlareGun()
|
|
{
|
|
DestroySounds();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFFlareGun::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
|
|
PrecacheParticleSystem( "stickybombtrail_blue" );
|
|
PrecacheParticleSystem( "stickybombtrail_red" );
|
|
PrecacheParticleSystem( "critical_grenade_blue" );
|
|
PrecacheParticleSystem( "critical_grenade_red" );
|
|
}
|
|
|
|
void CTFFlareGun::DestroySounds( void )
|
|
{
|
|
StopCharge();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFFlareGun::PrimaryAttack( void )
|
|
{
|
|
// Get the player owning the weapon.
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pOwner )
|
|
return;
|
|
|
|
if ( m_flChargeBeginTime > 0.0f )
|
|
return;
|
|
|
|
// Don't attack if we're underwater
|
|
if ( pOwner->GetWaterLevel() != WL_Eyes )
|
|
{
|
|
BaseClass::PrimaryAttack();
|
|
}
|
|
else
|
|
{
|
|
if ( gpGlobals->curtime > m_flLastDenySoundTime )
|
|
{
|
|
WeaponSound( SPECIAL2 );
|
|
m_flLastDenySoundTime = gpGlobals->curtime + 1.0f;
|
|
}
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
m_bReadyToFire = false;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Detonate flare
|
|
//-----------------------------------------------------------------------------
|
|
void CTFFlareGun::SecondaryAttack( void )
|
|
{
|
|
if ( GetFlareGunType() != FLAREGUN_DETONATE )
|
|
return;
|
|
|
|
if ( !CanAttack() )
|
|
return;
|
|
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
#ifdef GAME_DLL
|
|
if ( m_iFlareCount )
|
|
{
|
|
int iCount = m_Flares.Count();
|
|
for ( int i = 0; i < iCount; i++ )
|
|
{
|
|
CTFProjectile_Flare *pTemp = m_Flares[i];
|
|
if ( pTemp )
|
|
{
|
|
pTemp->Detonate();
|
|
}
|
|
}
|
|
}
|
|
#endif // GAME_DLL
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFFlareGun::AddFlare( CTFProjectile_Flare *pFlare )
|
|
{
|
|
FlareHandle hHandle;
|
|
hHandle = pFlare;
|
|
m_Flares.AddToTail( hHandle );
|
|
|
|
m_iFlareCount = m_Flares.Count();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFFlareGun::DeathNotice( CBaseEntity *pVictim )
|
|
{
|
|
Assert( dynamic_cast<CTFProjectile_Flare*>( pVictim ) );
|
|
|
|
FlareHandle hHandle;
|
|
hHandle = (CTFProjectile_Flare*)pVictim;
|
|
m_Flares.FindAndRemove( hHandle );
|
|
|
|
m_iFlareCount = m_Flares.Count();
|
|
}
|
|
#endif
|
|
|
|
bool CTFFlareGun::Holster( CBaseCombatWeapon *pSwitchingTo )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
m_bEffectsThinking = false;
|
|
StopCharge();
|
|
|
|
m_bReadyToFire = false;
|
|
#endif
|
|
|
|
return BaseClass::Holster( pSwitchingTo );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFFlareGun::Deploy( void )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
m_bEffectsThinking = true;
|
|
SetContextThink( &CTFFlareGun::ClientEffectsThink, gpGlobals->curtime + 0.25f, "EFFECTS_THINK" );
|
|
|
|
m_bReadyToFire = false;
|
|
#endif
|
|
|
|
return BaseClass::Deploy();
|
|
}
|
|
|
|
void CTFFlareGun::WeaponReset( void )
|
|
{
|
|
BaseClass::WeaponReset();
|
|
|
|
#if defined( CLIENT_DLL )
|
|
StopCharge();
|
|
#endif
|
|
}
|
|
|
|
void CTFFlareGun::ItemPostFrame( void )
|
|
{
|
|
BaseClass::ItemPostFrame();
|
|
|
|
if ( m_flChargeBeginTime > 0.0f )
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// If we're not holding down the attack button
|
|
if ( !(pPlayer->m_nButtons & IN_ATTACK2) )
|
|
{
|
|
StopCharge();
|
|
}
|
|
else
|
|
{
|
|
ChargePostFrame();
|
|
}
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( !m_bEffectsThinking )
|
|
{
|
|
m_bEffectsThinking = true;
|
|
SetContextThink( &CTFFlareGun::ClientEffectsThink, gpGlobals->curtime + 0.25f, "EFFECTS_THINK" );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
void CTFFlareGun::DispatchMuzzleFlash( const char* effectName, C_BaseEntity* pAttachEnt )
|
|
{
|
|
DispatchParticleEffect( effectName, PATTACH_POINT_FOLLOW, pAttachEnt, "muzzle", GetParticleColor( 1 ), GetParticleColor( 2 ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFFlareGun::ClientEffectsThink( void )
|
|
{
|
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
if ( !pPlayer->IsLocalPlayer() )
|
|
return;
|
|
|
|
if ( !pPlayer->GetViewModel() )
|
|
return;
|
|
|
|
if ( !m_bEffectsThinking )
|
|
return;
|
|
|
|
if ( !GetOwner() || GetOwner()->GetActiveWeapon() != this )
|
|
{
|
|
m_bEffectsThinking = false;
|
|
}
|
|
else
|
|
{
|
|
SetContextThink( &CTFFlareGun::ClientEffectsThink, gpGlobals->curtime + 0.25f, "EFFECTS_THINK" );
|
|
}
|
|
|
|
if ( GetFlareGunType() == FLAREGUN_GRORDBORT && m_flNextPrimaryAttack <= gpGlobals->curtime )
|
|
{
|
|
ParticleProp()->Init( this );
|
|
CNewParticleEffect* pEffect = ParticleProp()->Create( "drg_bison_idle", PATTACH_POINT_FOLLOW, "muzzle" );
|
|
if ( pEffect )
|
|
{
|
|
pEffect->SetControlPoint( CUSTOM_COLOR_CP1, GetParticleColor( 1 ) );
|
|
pEffect->SetControlPoint( CUSTOM_COLOR_CP2, GetParticleColor( 2 ) );
|
|
}
|
|
|
|
ParticleProp()->Create( "drg_manmelter_idle", PATTACH_POINT_FOLLOW, "muzzle" );
|
|
|
|
if ( !m_bReadyToFire )
|
|
{
|
|
m_bReadyToFire = true;
|
|
|
|
EmitSound( "Weapon_SniperRailgun.NonScoped" );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTFFlareGun::StartChargeEffects()
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pPlayer )
|
|
{
|
|
DispatchParticleEffect( GetChargeEffect(), PATTACH_POINT_FOLLOW, GetAppropriateWorldOrViewModel(), "muzzle", GetParticleColor( 1 ), GetParticleColor( 2 ) );
|
|
}
|
|
}
|
|
|
|
void CTFFlareGun::StopChargeEffects()
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pPlayer )
|
|
{
|
|
GetAppropriateWorldOrViewModel()->ParticleProp()->StopParticlesNamed( GetChargeEffect(), false );
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
void CTFFlareGun::StartCharge( void )
|
|
{
|
|
StartChargeStartTime();
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( !m_pChargeLoop )
|
|
{
|
|
CLocalPlayerFilter filter;
|
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
m_pChargeLoop = controller.SoundCreate( filter, entindex(), GetShootSound( WPN_DOUBLE ) );
|
|
controller.Play( m_pChargeLoop, 1.0, 100 );
|
|
}
|
|
|
|
StartChargeEffects();
|
|
#endif
|
|
}
|
|
|
|
void CTFFlareGun::StopCharge( void )
|
|
{
|
|
m_flChargeBeginTime = 0.0f;
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( m_pChargeLoop )
|
|
{
|
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pChargeLoop );
|
|
}
|
|
|
|
m_pChargeLoop = NULL;
|
|
|
|
StopChargeEffects();
|
|
#endif
|
|
}
|
|
|
|
|
|
CTFFlareGun_Revenge::CTFFlareGun_Revenge()
|
|
{
|
|
m_fLastExtinguishTime = 0.0f;
|
|
|
|
#ifdef CLIENT_DLL
|
|
m_nOldRevengeCrits = 0;
|
|
#endif
|
|
}
|
|
|
|
void CTFFlareGun_Revenge::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
|
|
PrecacheParticleSystem( "drg_manmelter_vacuum" );
|
|
PrecacheParticleSystem( "drg_manmelter_vacuum_flames" );
|
|
PrecacheParticleSystem( "drg_manmelter_muzzleflash" );
|
|
}
|
|
|
|
int CTFFlareGun_Revenge::GetCustomDamageType() const
|
|
{
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pOwner )
|
|
{
|
|
int iRevengeCrits = pOwner->m_Shared.GetRevengeCrits();
|
|
return iRevengeCrits > 0 ? TF_DMG_CUSTOM_SHOTGUN_REVENGE_CRIT : TF_DMG_CUSTOM_NONE;
|
|
}
|
|
return TF_DMG_CUSTOM_NONE;
|
|
}
|
|
|
|
bool CTFFlareGun_Revenge::Holster( CBaseCombatWeapon *pSwitchingTo )
|
|
{
|
|
#ifdef GAME_DLL
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pOwner && pOwner->m_Shared.GetRevengeCrits() )
|
|
{
|
|
pOwner->m_Shared.RemoveCond( TF_COND_CRITBOOSTED );
|
|
}
|
|
#endif
|
|
|
|
StopCharge();
|
|
|
|
return BaseClass::Holster( pSwitchingTo );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFFlareGun_Revenge::Deploy( void )
|
|
{
|
|
#ifdef GAME_DLL
|
|
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
|
|
if ( pOwner && pOwner->m_Shared.GetRevengeCrits() )
|
|
{
|
|
pOwner->m_Shared.AddCond( TF_COND_CRITBOOSTED );
|
|
}
|
|
#endif
|
|
|
|
StopCharge();
|
|
|
|
return BaseClass::Deploy();
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reset revenge crits when the flaregun is changed
|
|
//-----------------------------------------------------------------------------
|
|
void CTFFlareGun_Revenge::Detach( void )
|
|
{
|
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
|
if ( pPlayer )
|
|
{
|
|
pPlayer->m_Shared.SetRevengeCrits( 0 );
|
|
pPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED );
|
|
}
|
|
|
|
BaseClass::Detach();
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CTFFlareGun_Revenge::GetCount( void )
|
|
{
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pOwner )
|
|
{
|
|
return pOwner->m_Shared.GetRevengeCrits();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CTFFlareGun_Revenge::PrimaryAttack()
|
|
{
|
|
if ( !CanAttack() )
|
|
return;
|
|
|
|
BaseClass::PrimaryAttack();
|
|
|
|
// Lower the reveng crit count
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pOwner )
|
|
{
|
|
int iNewRevengeCrits = MAX( pOwner->m_Shared.GetRevengeCrits() - 1, 0 );
|
|
pOwner->m_Shared.SetRevengeCrits( iNewRevengeCrits );
|
|
}
|
|
}
|
|
|
|
void CTFFlareGun_Revenge::SecondaryAttack( void )
|
|
{
|
|
if ( m_flNextSecondaryAttack > gpGlobals->curtime )
|
|
{
|
|
return;
|
|
}
|
|
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pOwner )
|
|
return;
|
|
|
|
if ( GetChargeBeginTime() == 0.0f )
|
|
{
|
|
StartCharge();
|
|
|
|
#ifdef GAME_DLL
|
|
//SendWeaponAnim( ACT_VM_PULLBACK );
|
|
#endif
|
|
}
|
|
|
|
m_flNextSecondaryAttack = gpGlobals->curtime + 0.5f;
|
|
}
|
|
|
|
void CTFFlareGun_Revenge::ChargePostFrame( void )
|
|
{
|
|
BaseClass::ChargePostFrame();
|
|
|
|
if ( gpGlobals->curtime > m_fLastExtinguishTime + 0.5f )
|
|
{
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pOwner )
|
|
{
|
|
// Extinguish friends
|
|
Vector vecEye = pOwner->EyePosition();
|
|
Vector vecForward, vecRight, vecUp;
|
|
AngleVectors( pOwner->EyeAngles(), &vecForward, NULL, NULL );
|
|
|
|
const Vector vHull = Vector( 16.0f, 16.0f, 16.0f );
|
|
|
|
trace_t tr;
|
|
UTIL_TraceHull( vecEye, vecEye + vecForward * 256.0f, -vHull, vHull, MASK_SOLID, pOwner, COLLISION_GROUP_NONE, &tr );
|
|
|
|
CTFPlayer *pTarget = ToTFPlayer( tr.m_pEnt );
|
|
if ( pTarget )
|
|
{
|
|
#ifdef GAME_DLL
|
|
// Get the player that ignited them before we extinguish
|
|
CTFPlayer *pBurner = pTarget->m_Shared.GetOriginalBurnAttacker();
|
|
#endif
|
|
|
|
if ( ExtinguishPlayerInternal( pTarget, pOwner ) )
|
|
{
|
|
m_fLastExtinguishTime = gpGlobals->curtime;
|
|
|
|
#ifdef GAME_DLL
|
|
// Make sure the team isn't burning themselves to earn crits
|
|
if ( pBurner && pBurner->GetTeamNumber() != pOwner->GetTeamNumber() )
|
|
{
|
|
// Grant revenge crits
|
|
pOwner->m_Shared.SetRevengeCrits( pOwner->m_Shared.GetRevengeCrits() + 1 );
|
|
|
|
// Return health to the Pyro.
|
|
int iRestoreHealthOnExtinguish = 0;
|
|
CALL_ATTRIB_HOOK_INT( iRestoreHealthOnExtinguish, extinguish_restores_health );
|
|
if ( iRestoreHealthOnExtinguish > 0 && pOwner->TakeHealth( 20, DMG_GENERIC ) > 0 )
|
|
{
|
|
IGameEvent *healevent = gameeventmanager->CreateEvent( "player_healonhit" );
|
|
if ( healevent )
|
|
{
|
|
healevent->SetInt( "amount", iRestoreHealthOnExtinguish );
|
|
healevent->SetInt( "entindex", pOwner->entindex() );
|
|
item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
|
|
if ( GetAttributeContainer() && GetAttributeContainer()->GetItem() )
|
|
{
|
|
healingItemDef = GetAttributeContainer()->GetItem()->GetItemDefIndex();
|
|
}
|
|
healevent->SetInt( "weapon_def_index", healingItemDef );
|
|
|
|
gameeventmanager->FireEvent( healevent );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
extern void ExtinguishPlayer( CEconEntity *pExtinguisher, CTFPlayer *pOwner, CTFPlayer *pTarget, const char *pExtinguisherName );
|
|
#endif // GAME_DLL
|
|
|
|
bool CTFFlareGun_Revenge::ExtinguishPlayerInternal( CTFPlayer *pTarget, CTFPlayer *pOwner )
|
|
{
|
|
if ( pTarget->GetTeamNumber() == pOwner->GetTeamNumber() )
|
|
{
|
|
if ( pTarget->m_Shared.InCond( TF_COND_BURNING ) )
|
|
{
|
|
#ifdef GAME_DLL
|
|
ExtinguishPlayer( this, pOwner, pTarget, GetName() );
|
|
#endif // GAME_DLL
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
void CTFFlareGun_Revenge::OnDataChanged( DataUpdateType_t type )
|
|
{
|
|
BaseClass::OnDataChanged( type );
|
|
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pOwner )
|
|
{
|
|
if ( m_nOldRevengeCrits < pOwner->m_Shared.GetRevengeCrits() )
|
|
{
|
|
DoAbsorbEffect();
|
|
}
|
|
|
|
m_nOldRevengeCrits = pOwner->m_Shared.GetRevengeCrits();
|
|
}
|
|
}
|
|
|
|
void CTFFlareGun_Revenge::DoAbsorbEffect( void )
|
|
{
|
|
WeaponSound( SPECIAL1 );
|
|
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pPlayer )
|
|
{
|
|
DispatchParticleEffect( "drg_manmelter_vacuum_flames", PATTACH_POINT_FOLLOW, GetAppropriateWorldOrViewModel(), "muzzle", GetParticleColor( 1 ), GetParticleColor( 2 ) );
|
|
}
|
|
}
|
|
#endif
|