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.
1403 lines
39 KiB
1403 lines
39 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose: TF Pipebomb Grenade.
|
||
|
//
|
||
|
//=============================================================================//
|
||
|
#include "cbase.h"
|
||
|
#include "tf_weaponbase.h"
|
||
|
#include "tf_gamerules.h"
|
||
|
#include "npcevent.h"
|
||
|
#include "engine/IEngineSound.h"
|
||
|
#include "tf_weapon_grenade_pipebomb.h"
|
||
|
#include "tf_weapon_pipebomblauncher.h"
|
||
|
#include "tf_weapon_grenadelauncher.h"
|
||
|
|
||
|
// Client specific.
|
||
|
#ifdef CLIENT_DLL
|
||
|
#include "c_tf_player.h"
|
||
|
#include "IEffects.h"
|
||
|
#include "materialsystem/imaterialvar.h"
|
||
|
#include "functionproxy.h"
|
||
|
// Server specific.
|
||
|
#else
|
||
|
#include "tf_player.h"
|
||
|
#include "items.h"
|
||
|
#include "tf_weaponbase_grenadeproj.h"
|
||
|
#include "soundent.h"
|
||
|
#include "KeyValues.h"
|
||
|
#include "IEffects.h"
|
||
|
#include "props.h"
|
||
|
#include "func_respawnroom.h"
|
||
|
#include "tf_ammo_pack.h"
|
||
|
#include "takedamageinfo.h"
|
||
|
#include "tf_team.h"
|
||
|
#include "physics_collisionevent.h"
|
||
|
#ifdef TF_RAID_MODE
|
||
|
#include "player_vs_environment/boss_alpha/boss_alpha.h"
|
||
|
#endif // TF_RAID_MODE
|
||
|
#include "tf_weapon_medigun.h"
|
||
|
#endif
|
||
|
|
||
|
#define TF_WEAPON_PIPEBOMB_TIMER 3.0f //Seconds
|
||
|
|
||
|
#define TF_WEAPON_PIPEBOMB_GRAVITY 0.5f
|
||
|
#define TF_WEAPON_PIPEBOMB_FRICTION 0.8f
|
||
|
#define TF_WEAPON_PIPEBOMB_ELASTICITY 0.45f
|
||
|
|
||
|
#define TF_WEAPON_PIPEBOMB_TIMER_DMG_REDUCTION 0.6
|
||
|
|
||
|
extern ConVar tf_grenadelauncher_max_chargetime;
|
||
|
ConVar tf_grenadelauncher_chargescale( "tf_grenadelauncher_chargescale", "1.0", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
|
||
|
ConVar tf_grenadelauncher_livetime( "tf_grenadelauncher_livetime", "0.8", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
|
||
|
extern ConVar tf_sticky_radius_ramp_time;
|
||
|
extern ConVar tf_sticky_airdet_radius;
|
||
|
|
||
|
#ifndef CLIENT_DLL
|
||
|
|
||
|
ConVar tf_grenadelauncher_min_contact_speed( "tf_grenadelauncher_min_contact_speed", "100", FCVAR_DEVELOPMENTONLY );
|
||
|
extern ConVar tf_obj_gib_velocity_min;
|
||
|
extern ConVar tf_obj_gib_velocity_max;
|
||
|
extern ConVar tf_obj_gib_maxspeed;
|
||
|
#endif
|
||
|
|
||
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFGrenadePipebombProjectile, DT_TFProjectile_Pipebomb )
|
||
|
|
||
|
BEGIN_NETWORK_TABLE( CTFGrenadePipebombProjectile, DT_TFProjectile_Pipebomb )
|
||
|
#ifdef CLIENT_DLL
|
||
|
RecvPropInt( RECVINFO( m_bTouched ) ),
|
||
|
RecvPropInt( RECVINFO( m_iType ) ),
|
||
|
RecvPropEHandle( RECVINFO( m_hLauncher ) ),
|
||
|
RecvPropBool( RECVINFO( m_bDefensiveBomb ) ),
|
||
|
#else
|
||
|
SendPropBool( SENDINFO( m_bTouched ) ),
|
||
|
SendPropInt( SENDINFO( m_iType ), 3 ),
|
||
|
SendPropEHandle( SENDINFO( m_hLauncher ) ),
|
||
|
SendPropBool( SENDINFO( m_bDefensiveBomb ) ),
|
||
|
#endif
|
||
|
END_NETWORK_TABLE()
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
static string_t s_iszTrainName;
|
||
|
#endif
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Input : -
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CTFGrenadePipebombProjectile::CTFGrenadePipebombProjectile()
|
||
|
{
|
||
|
m_bTouched = false;
|
||
|
m_flChargeTime = 0.0f;
|
||
|
m_bDetonateOnPulse = false;
|
||
|
#ifdef GAME_DLL
|
||
|
s_iszTrainName = AllocPooledString( "models/props_vehicles/train_enginecar.mdl" );
|
||
|
m_flDeflectedTime = 0.0f;
|
||
|
m_bWallShatter = false;
|
||
|
m_bDefensiveBomb = false;
|
||
|
m_bSendPlayerDestroyedEvent = true;
|
||
|
m_bCanTakeDamage = true;
|
||
|
#else
|
||
|
pEffectTrail = NULL;
|
||
|
pEffectCrit = NULL;
|
||
|
m_iCachedDeflect = 0;
|
||
|
m_bHighlight = false;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Input : -
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CTFGrenadePipebombProjectile::~CTFGrenadePipebombProjectile()
|
||
|
{
|
||
|
#ifdef CLIENT_DLL
|
||
|
|
||
|
if ( pEffectTrail )
|
||
|
{
|
||
|
ParticleProp()->StopEmission( pEffectTrail );
|
||
|
}
|
||
|
if ( pEffectCrit )
|
||
|
{
|
||
|
ParticleProp()->StopEmission( pEffectCrit );
|
||
|
}
|
||
|
if ( m_pGlowEffect )
|
||
|
{
|
||
|
delete m_pGlowEffect;
|
||
|
m_pGlowEffect = NULL;
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CTFGrenadePipebombProjectile::GetWeaponID( void ) const
|
||
|
{
|
||
|
if ( m_iType == TF_GL_MODE_CANNONBALL )
|
||
|
{
|
||
|
return TF_WEAPON_CANNON;
|
||
|
}
|
||
|
|
||
|
return ( HasStickyEffects() ? TF_WEAPON_GRENADE_PIPEBOMB : TF_WEAPON_GRENADE_DEMOMAN );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CTFGrenadePipebombProjectile::GetDamageType( void )
|
||
|
{
|
||
|
int iDmgType = BaseClass::GetDamageType();
|
||
|
|
||
|
// If we're a pipebomb, we do distance based damage falloff for just the first few seconds of our life
|
||
|
if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
|
||
|
{
|
||
|
if ( gpGlobals->curtime - m_flCreationTime < 5.0 )
|
||
|
{
|
||
|
iDmgType |= DMG_USEDISTANCEMOD;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return iDmgType;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CTFGrenadePipebombProjectile::ShouldMiniCritOnReflect() const
|
||
|
{
|
||
|
return GetType() == TF_GL_MODE_REGULAR;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::UpdateOnRemove( void )
|
||
|
{
|
||
|
// Tell our launcher that we were removed
|
||
|
CTFPipebombLauncher *pLauncher = dynamic_cast<CTFPipebombLauncher*>( m_hLauncher.Get() );
|
||
|
|
||
|
if ( pLauncher )
|
||
|
{
|
||
|
pLauncher->DeathNotice( this );
|
||
|
}
|
||
|
|
||
|
BaseClass::UpdateOnRemove();
|
||
|
}
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
//=============================================================================
|
||
|
//
|
||
|
// TF Pipebomb Grenade Projectile functions (Client specific).
|
||
|
//
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Output : const char
|
||
|
//-----------------------------------------------------------------------------
|
||
|
const char *CTFGrenadePipebombProjectile::GetTrailParticleName( void )
|
||
|
{
|
||
|
int iTeamNumber = GetTeamNumber();
|
||
|
|
||
|
if ( GetDeflected() && m_iType != TF_GL_MODE_REMOTE_DETONATE )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetDeflectOwner() );
|
||
|
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
iTeamNumber = pOwner->GetTeamNumber();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( HasStickyEffects() )
|
||
|
{
|
||
|
if ( iTeamNumber == TF_TEAM_BLUE )
|
||
|
{
|
||
|
return "stickybombtrail_blue";
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return "stickybombtrail_red";
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( iTeamNumber == TF_TEAM_BLUE )
|
||
|
{
|
||
|
return "pipebombtrail_blue";
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return "pipebombtrail_red";
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Input : updateType -
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::OnDataChanged(DataUpdateType_t updateType)
|
||
|
{
|
||
|
BaseClass::OnDataChanged( updateType );
|
||
|
|
||
|
if ( updateType == DATA_UPDATE_CREATED )
|
||
|
{
|
||
|
m_flCreationTime = gpGlobals->curtime;
|
||
|
m_bPulsed = false;
|
||
|
|
||
|
CTFPipebombLauncher *pLauncher = dynamic_cast<CTFPipebombLauncher*>( m_hLauncher.Get() );
|
||
|
|
||
|
if ( pLauncher )
|
||
|
{
|
||
|
pLauncher->AddPipeBomb( this );
|
||
|
}
|
||
|
|
||
|
if ( m_bDefensiveBomb && C_BasePlayer::GetLocalPlayer() == GetThrower() )
|
||
|
{
|
||
|
if ( GetTeamNumber() == TF_TEAM_RED )
|
||
|
{
|
||
|
m_pGlowEffect = new CGlowObject( this, Vector( 150, 0, 0 ), 1.0, true );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_pGlowEffect = new CGlowObject( this, Vector( 0, 0, 150 ), 1.0, true );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
CreateTrailParticles();
|
||
|
}
|
||
|
else if ( m_bTouched )
|
||
|
{
|
||
|
//ParticleProp()->StopEmission();
|
||
|
}
|
||
|
|
||
|
if ( m_iCachedDeflect != GetDeflected() )
|
||
|
{
|
||
|
CreateTrailParticles();
|
||
|
}
|
||
|
|
||
|
m_iCachedDeflect = GetDeflected();
|
||
|
}
|
||
|
|
||
|
void CTFGrenadePipebombProjectile::CreateTrailParticles( void )
|
||
|
{
|
||
|
if ( pEffectTrail )
|
||
|
{
|
||
|
ParticleProp()->StopEmission( pEffectTrail );
|
||
|
}
|
||
|
|
||
|
if ( pEffectCrit )
|
||
|
{
|
||
|
ParticleProp()->StopEmission( pEffectCrit );
|
||
|
}
|
||
|
|
||
|
pEffectTrail = ParticleProp()->Create( GetTrailParticleName(), PATTACH_ABSORIGIN_FOLLOW );
|
||
|
|
||
|
int iTeamNumber = GetTeamNumber();
|
||
|
|
||
|
if ( GetDeflected() && m_iType != TF_GL_MODE_REMOTE_DETONATE )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetDeflectOwner() );
|
||
|
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
iTeamNumber = pOwner->GetTeamNumber();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_bCritical )
|
||
|
{
|
||
|
switch( iTeamNumber )
|
||
|
{
|
||
|
case TF_TEAM_BLUE:
|
||
|
|
||
|
if ( HasStickyEffects() )
|
||
|
{
|
||
|
pEffectCrit = ParticleProp()->Create( "critical_grenade_blue", PATTACH_ABSORIGIN_FOLLOW );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pEffectCrit = ParticleProp()->Create( "critical_pipe_blue", PATTACH_ABSORIGIN_FOLLOW );
|
||
|
}
|
||
|
break;
|
||
|
case TF_TEAM_RED:
|
||
|
|
||
|
if ( HasStickyEffects() )
|
||
|
{
|
||
|
pEffectCrit = ParticleProp()->Create( "critical_grenade_red", PATTACH_ABSORIGIN_FOLLOW );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pEffectCrit = ParticleProp()->Create( "critical_pipe_red", PATTACH_ABSORIGIN_FOLLOW );
|
||
|
}
|
||
|
break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
extern ConVar tf_grenadelauncher_livetime;
|
||
|
|
||
|
void CTFGrenadePipebombProjectile::Simulate( void )
|
||
|
{
|
||
|
BaseClass::Simulate();
|
||
|
|
||
|
if ( !HasStickyEffects() )
|
||
|
return;
|
||
|
|
||
|
if ( m_bPulsed == false )
|
||
|
{
|
||
|
if ( (gpGlobals->curtime - m_flCreationTime) >= GetLiveTime() )
|
||
|
{
|
||
|
if ( GetTeamNumber() == TF_TEAM_RED )
|
||
|
{
|
||
|
ParticleProp()->Create( "stickybomb_pulse_red", PATTACH_ABSORIGIN_FOLLOW );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
ParticleProp()->Create( "stickybomb_pulse_blue", PATTACH_ABSORIGIN_FOLLOW );
|
||
|
}
|
||
|
|
||
|
m_bPulsed = true;
|
||
|
|
||
|
if ( m_bDetonateOnPulse )
|
||
|
{
|
||
|
Detonate();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
// Purpose: Don't draw if we haven't yet gone past our original spawn point
|
||
|
// Input : flags -
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CTFGrenadePipebombProjectile::DrawModel( int flags )
|
||
|
{
|
||
|
if ( gpGlobals->curtime < ( m_flCreationTime + 0.1 ) )
|
||
|
return 0;
|
||
|
|
||
|
return BaseClass::DrawModel( flags );
|
||
|
}
|
||
|
|
||
|
#else
|
||
|
|
||
|
//=============================================================================
|
||
|
//
|
||
|
// TF Pipebomb Grenade Projectile functions (Server specific).
|
||
|
//
|
||
|
#define TF_WEAPON_PIPEGRENADE_MODEL "models/weapons/w_models/w_grenade_grenadelauncher.mdl"
|
||
|
#define TF_WEAPON_CANNONBALL_MODEL "models/weapons/w_models/w_cannonball.mdl"
|
||
|
#define TF_WEAPON_PIPEBOMB_MODEL "models/weapons/w_models/w_stickybomb.mdl"
|
||
|
#define TF_WEAPON_PIPEBOMB2_MODEL "models/weapons/w_models/w_stickybomb2.mdl"
|
||
|
#define TF_WEAPON_PIPEBOMBD_MODEL "models/weapons/w_models/w_stickybomb_d.mdl"
|
||
|
#define TF_WEAPON_PIPEBOMB_BOUNCE_SOUND "Weapon_Grenade_Pipebomb.Bounce"
|
||
|
#define TF_WEAPON_CANNON_IMPACT_SOUND "Weapon_LooseCannon.BallImpact"
|
||
|
#define TF_WEAPON_GRENADE_DETONATE_TIME 2.0f
|
||
|
#define TF_WEAPON_GRENADE_XBOX_DAMAGE 112
|
||
|
|
||
|
BEGIN_DATADESC( CTFGrenadePipebombProjectile )
|
||
|
END_DATADESC()
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( tf_projectile_pipe_remote, CTFGrenadePipebombProjectile );
|
||
|
PRECACHE_WEAPON_REGISTER( tf_projectile_pipe_remote );
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( tf_projectile_pipe, CTFGrenadePipebombProjectile );
|
||
|
PRECACHE_WEAPON_REGISTER( tf_projectile_pipe );
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
const char* CTFGrenadePipebombProjectile::GetPipebombClass( int iPipeBombType )
|
||
|
{
|
||
|
switch ( iPipeBombType )
|
||
|
{
|
||
|
case TF_GL_MODE_REGULAR:
|
||
|
return "tf_projectile_pipe";
|
||
|
case TF_GL_MODE_REMOTE_DETONATE:
|
||
|
case TF_GL_MODE_REMOTE_DETONATE_PRACTICE:
|
||
|
return "tf_projectile_pipe_remote";
|
||
|
default:
|
||
|
return "tf_projectile_pipe";
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CTFGrenadePipebombProjectile* CTFGrenadePipebombProjectile::Create( const Vector &position, const QAngle &angles,
|
||
|
const Vector &velocity, const AngularImpulse &angVelocity,
|
||
|
CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo,
|
||
|
int iPipeBombType, float flMultDmg )
|
||
|
{
|
||
|
// Translate a projectile type into a pipebomb type.
|
||
|
int iPipeBombDetonateType;
|
||
|
switch ( iPipeBombType )
|
||
|
{
|
||
|
case TF_PROJECTILE_PIPEBOMB_REMOTE:
|
||
|
{
|
||
|
iPipeBombDetonateType = TF_GL_MODE_REMOTE_DETONATE;
|
||
|
}
|
||
|
break;
|
||
|
case TF_PROJECTILE_PIPEBOMB_PRACTICE:
|
||
|
{
|
||
|
iPipeBombDetonateType = TF_GL_MODE_REMOTE_DETONATE_PRACTICE;
|
||
|
}
|
||
|
break;
|
||
|
case TF_PROJECTILE_CANNONBALL:
|
||
|
{
|
||
|
iPipeBombDetonateType = TF_GL_MODE_CANNONBALL;
|
||
|
}
|
||
|
break;
|
||
|
default:
|
||
|
iPipeBombDetonateType = TF_GL_MODE_REGULAR;
|
||
|
}
|
||
|
|
||
|
const char* pszBombClass = GetPipebombClass( iPipeBombDetonateType );
|
||
|
CTFGrenadePipebombProjectile *pGrenade = static_cast<CTFGrenadePipebombProjectile*>( CBaseEntity::CreateNoSpawn( pszBombClass, position, angles, pOwner ) );
|
||
|
if ( pGrenade )
|
||
|
{
|
||
|
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly
|
||
|
pGrenade->SetPipebombMode( iPipeBombDetonateType );
|
||
|
DispatchSpawn( pGrenade );
|
||
|
|
||
|
pGrenade->InitGrenade( velocity, angVelocity, pOwner, weaponInfo );
|
||
|
pGrenade->SetDamage( pGrenade->GetDamage() * flMultDmg );
|
||
|
pGrenade->SetFullDamage( pGrenade->GetDamage() );
|
||
|
|
||
|
if ( pGrenade->m_iType != TF_GL_MODE_REMOTE_DETONATE )
|
||
|
{
|
||
|
// Some hackery here. Reduce the damage, so that if we explode on timeout,
|
||
|
// we'll do less damage. If we explode on contact, we'll restore this to full damage.
|
||
|
pGrenade->SetDamage( pGrenade->GetDamage() * TF_WEAPON_PIPEBOMB_TIMER_DMG_REDUCTION );
|
||
|
}
|
||
|
|
||
|
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
|
||
|
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
pGrenade->SetTruceValidForEnt( pOwner->IsTruceValidForEnt() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return pGrenade;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::Spawn()
|
||
|
{
|
||
|
if ( HasStickyEffects() )
|
||
|
{
|
||
|
// Set this to max, so effectively they do not self-implode.
|
||
|
|
||
|
if ( m_iType == TF_GL_MODE_REMOTE_DETONATE_PRACTICE )
|
||
|
{
|
||
|
SetModel( TF_WEAPON_PIPEBOMB2_MODEL );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetModel( TF_WEAPON_PIPEBOMB_MODEL );
|
||
|
}
|
||
|
SetDetonateTimerLength( FLT_MAX );
|
||
|
SetContextThink( &CTFGrenadePipebombProjectile::PreArmThink, gpGlobals->curtime + 0.001f, "PRE_ARM_THINK" ); // Next frame.
|
||
|
SetTouch( &CTFGrenadePipebombProjectile::StickybombTouch );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_iType == TF_GL_MODE_CANNONBALL )
|
||
|
{
|
||
|
SetModel( TF_WEAPON_CANNONBALL_MODEL );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetModel( TF_WEAPON_PIPEGRENADE_MODEL );
|
||
|
}
|
||
|
SetDetonateTimerLength( TF_WEAPON_GRENADE_DETONATE_TIME );
|
||
|
SetTouch( &CTFGrenadePipebombProjectile::PipebombTouch );
|
||
|
}
|
||
|
|
||
|
SetCustomPipebombModel();
|
||
|
|
||
|
BaseClass::Spawn();
|
||
|
|
||
|
m_bTouched = false;
|
||
|
m_flCreationTime = gpGlobals->curtime;
|
||
|
|
||
|
// We want to get touch functions called so we can damage enemy players
|
||
|
AddSolidFlags( FSOLID_TRIGGER );
|
||
|
|
||
|
m_flMinSleepTime = 0;
|
||
|
AddFlag( FL_GRENADE );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::Precache()
|
||
|
{
|
||
|
int iModel = PrecacheModel( TF_WEAPON_PIPEBOMB_MODEL );
|
||
|
PrecacheGibsForModel( iModel );
|
||
|
|
||
|
iModel = PrecacheModel( TF_WEAPON_PIPEBOMB2_MODEL );
|
||
|
PrecacheGibsForModel( iModel );
|
||
|
|
||
|
iModel = PrecacheModel( TF_WEAPON_PIPEBOMBD_MODEL );
|
||
|
PrecacheGibsForModel( iModel );
|
||
|
|
||
|
iModel = PrecacheModel( TF_WEAPON_PIPEGRENADE_MODEL );
|
||
|
PrecacheGibsForModel( iModel );
|
||
|
|
||
|
iModel = PrecacheModel( TF_WEAPON_CANNONBALL_MODEL );
|
||
|
PrecacheGibsForModel( iModel );
|
||
|
|
||
|
// Must add All custom Models here
|
||
|
iModel = PrecacheModel( "models/workshop/weapons/c_models/c_kingmaker_sticky/w_kingmaker_stickybomb.mdl" );
|
||
|
iModel = PrecacheModel( "models/workshop/weapons/c_models/c_quadball/w_quadball_grenade.mdl" );
|
||
|
|
||
|
PrecacheParticleSystem( "stickybombtrail_blue" );
|
||
|
PrecacheParticleSystem( "stickybombtrail_red" );
|
||
|
|
||
|
PrecacheScriptSound( TF_WEAPON_PIPEBOMB_BOUNCE_SOUND );
|
||
|
PrecacheScriptSound( TF_WEAPON_CANNON_IMPACT_SOUND );
|
||
|
|
||
|
BaseClass::Precache();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::SetPipebombMode( int iPipebombMode /* = TF_GL_MODE_REGULAR */ )
|
||
|
{
|
||
|
m_iType.Set( iPipebombMode );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::BounceSound( void )
|
||
|
{
|
||
|
EmitSound( TF_WEAPON_PIPEBOMB_BOUNCE_SOUND );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::Detonate()
|
||
|
{
|
||
|
if ( gpGlobals->curtime > m_flDetonateTime )
|
||
|
{
|
||
|
if ( GetLauncher() )
|
||
|
{
|
||
|
float flFizzle = 0;
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(), flFizzle, stickybomb_fizzle_time );
|
||
|
if ( flFizzle )
|
||
|
{
|
||
|
Fizzle();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_bFizzle )
|
||
|
{
|
||
|
g_pEffects->Sparks( GetAbsOrigin(), 1, 2 );
|
||
|
Destroy( false );
|
||
|
|
||
|
if ( HasStickyEffects() )
|
||
|
{
|
||
|
CreatePipebombGibs();
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
BaseClass::Detonate();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CTFGrenadePipebombProjectile::DetonateStickies()
|
||
|
{
|
||
|
if ( !GetLauncher() )
|
||
|
return false;
|
||
|
|
||
|
bool bDetonateSticky = false;
|
||
|
|
||
|
Vector vecOrigin = GetAbsOrigin();
|
||
|
const int maxEntities = 64;
|
||
|
CBaseEntity *pObjects[ maxEntities ];
|
||
|
int count = UTIL_EntitiesInSphere( pObjects, maxEntities, vecOrigin, GetDamageRadius(), FL_GRENADE );
|
||
|
|
||
|
int iStickiesRemoved = 0;
|
||
|
|
||
|
trace_t tr;
|
||
|
for ( int i = 0; i < count; i++ )
|
||
|
{
|
||
|
if ( pObjects[i]->GetTeamNumber() == GetLauncher()->GetTeamNumber() )
|
||
|
continue;
|
||
|
|
||
|
CTFGrenadePipebombProjectile *pGrenade = dynamic_cast < CTFGrenadePipebombProjectile*> ( pObjects[i] );
|
||
|
if ( !pGrenade )
|
||
|
continue;
|
||
|
|
||
|
if ( pGrenade->m_iType != TF_GL_MODE_REMOTE_DETONATE )
|
||
|
continue;
|
||
|
|
||
|
if ( pGrenade->m_bFizzle )
|
||
|
continue;
|
||
|
|
||
|
UTIL_TraceLine( vecOrigin, pGrenade->GetAbsOrigin(), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
|
||
|
if ( tr.fraction < 1.0 )
|
||
|
continue; // No line of sight to the bomb.
|
||
|
|
||
|
pGrenade->Fizzle();
|
||
|
pGrenade->Detonate();
|
||
|
|
||
|
iStickiesRemoved++;
|
||
|
|
||
|
bDetonateSticky = true;
|
||
|
}
|
||
|
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetThrower() );
|
||
|
if ( iStickiesRemoved && pOwner )
|
||
|
{
|
||
|
pOwner->AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_DESTROY_X_STICKYBOMBS, iStickiesRemoved );
|
||
|
}
|
||
|
|
||
|
return bDetonateSticky;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::CreatePipebombGibs( void )
|
||
|
{
|
||
|
CPVSFilter filter( GetAbsOrigin() );
|
||
|
UserMessageBegin( filter, "CheapBreakModel" );
|
||
|
WRITE_SHORT( GetModelIndex() );
|
||
|
WRITE_VEC3COORD( GetAbsOrigin() );
|
||
|
MessageEnd();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::Fizzle( void )
|
||
|
{
|
||
|
m_bFizzle = true;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::StickybombTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
#ifdef GAME_DLL
|
||
|
#ifdef TF_RAID_MODE
|
||
|
if ( TFGameRules()->IsRaidMode() )
|
||
|
{
|
||
|
if ( dynamic_cast< CBossAlpha * >( pOther ) != NULL )
|
||
|
{
|
||
|
// stickies stick to the boss
|
||
|
m_bTouched = true;
|
||
|
VPhysicsGetObject()->EnableMotion( false );
|
||
|
|
||
|
SetParent( pOther );
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::PipebombTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
if ( pOther == GetThrower() )
|
||
|
return;
|
||
|
|
||
|
// Verify a correct "other."
|
||
|
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
|
||
|
return;
|
||
|
|
||
|
// Handle hitting skybox (disappear).
|
||
|
trace_t pTrace;
|
||
|
Vector velDir = GetAbsVelocity();
|
||
|
VectorNormalize( velDir );
|
||
|
Vector vOrigin = GetAbsOrigin();
|
||
|
Vector vecSpot = vOrigin - velDir * 32;
|
||
|
UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );
|
||
|
|
||
|
if ( pTrace.fraction < 1.0 && pTrace.surface.flags & SURF_SKY )
|
||
|
{
|
||
|
UTIL_Remove( this );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// PASSTIME always explode when it hits the ball
|
||
|
// fixme find a non-strcmp way to do this
|
||
|
if ( !V_strcmp( pOther->GetClassname(), "passtime_ball" ) )
|
||
|
{
|
||
|
Explode( &pTrace, GetDamageType() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
//If we already touched a surface then we're not exploding on contact anymore.
|
||
|
if ( m_bTouched == true )
|
||
|
return;
|
||
|
|
||
|
bool bExploded = false;
|
||
|
|
||
|
// Blow up if we hit an enemy we can damage
|
||
|
if ( pOther->GetTeamNumber() && pOther->GetTeamNumber() != GetTeamNumber() && pOther->m_takedamage != DAMAGE_NO )
|
||
|
{
|
||
|
// Check to see if this is a respawn room.
|
||
|
if ( !pOther->IsPlayer() )
|
||
|
{
|
||
|
CFuncRespawnRoom *pRespawnRoom = dynamic_cast<CFuncRespawnRoom*>( pOther );
|
||
|
if ( pRespawnRoom )
|
||
|
{
|
||
|
if ( !pRespawnRoom->PointIsWithin( vOrigin ) )
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_iType == TF_GL_MODE_CANNONBALL )
|
||
|
{
|
||
|
// Damage the player to push them back
|
||
|
CBaseEntity *pAttacker = GetThrower();
|
||
|
if ( pAttacker && ( pOther->IsPlayer() || pOther->IsBaseObject() ) )
|
||
|
{
|
||
|
// check if we already penetrate through this victim
|
||
|
if ( !m_penetratedEntities.HasElement( pOther ) )
|
||
|
{
|
||
|
// Impact damage scales with distance
|
||
|
float flDistanceSq = (pOther->GetAbsOrigin() - pAttacker->GetAbsOrigin()).LengthSqr();
|
||
|
float flImpactDamage = RemapValClamped( flDistanceSq, 512 * 512, 1024 * 1024, 50, 25 );
|
||
|
|
||
|
CTakeDamageInfo info( this, pAttacker, m_hLauncher, vec3_origin, vOrigin, flImpactDamage, GetDamageType(), TF_DMG_CUSTOM_CANNONBALL_PUSH );
|
||
|
pOther->TakeDamage( info );
|
||
|
|
||
|
CTFPlayer *pVictim = ToTFPlayer( pOther );
|
||
|
if ( pVictim )
|
||
|
{
|
||
|
// apply airblast - Apply stun if they are effectively grounded so we can knock them up
|
||
|
if ( !pVictim->m_Shared.InCond( TF_COND_KNOCKED_INTO_AIR ) )
|
||
|
{
|
||
|
pVictim->m_Shared.StunPlayer( 0.5, 1.f, TF_STUN_MOVEMENT, ToTFPlayer( pAttacker ) );
|
||
|
}
|
||
|
|
||
|
Vector vecToTarget = pVictim->WorldSpaceCenter() - pAttacker->WorldSpaceCenter();
|
||
|
VectorNormalize( vecToTarget );
|
||
|
vecToTarget *= 400;
|
||
|
vecToTarget.z += 350; // Mimic Flamethrower AirBlast
|
||
|
pVictim->ApplyAirBlastImpulse( vecToTarget );
|
||
|
}
|
||
|
|
||
|
m_penetratedEntities.AddToTail( pOther );
|
||
|
|
||
|
EmitSound( TF_WEAPON_CANNON_IMPACT_SOUND );
|
||
|
|
||
|
// Add this guy to our donk list. If this grenade explodes and hits anyone on our launcher's
|
||
|
// donk list, they get minicrit
|
||
|
CTFGrenadeLauncher* pLauncher = dynamic_cast<CTFGrenadeLauncher*>( GetLauncher() );
|
||
|
if( pLauncher )
|
||
|
{
|
||
|
pLauncher->AddDonkVictim( pOther );
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Save this entity as enemy, they will take 100% damage.
|
||
|
m_hEnemy = pOther;
|
||
|
|
||
|
// Restore damage. See comment in CTFGrenadePipebombProjectile::Create() above to understand this.
|
||
|
m_flDamage = m_flFullDamage;
|
||
|
Explode( &pTrace, GetDamageType() );
|
||
|
bExploded = true;
|
||
|
}
|
||
|
|
||
|
// Train hack!
|
||
|
if ( !bExploded && pOther->GetModelName() == s_iszTrainName && ( pOther->GetAbsVelocity().LengthSqr() > 1.0f ) )
|
||
|
{
|
||
|
Explode( &pTrace, GetDamageType() );
|
||
|
bExploded = true;
|
||
|
}
|
||
|
|
||
|
// Explode on contact with a Boss, too
|
||
|
if ( !bExploded && TFGameRules()->GetActiveBoss() && pOther == TFGameRules()->GetActiveBoss() )
|
||
|
{
|
||
|
Explode( &pTrace, GetDamageType() );
|
||
|
bExploded = true;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
extern bool PropDynamic_CollidesWithGrenades( CBaseEntity* pBaseEntity );
|
||
|
|
||
|
void CTFGrenadePipebombProjectile::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
|
||
|
{
|
||
|
BaseClass::VPhysicsCollision( index, pEvent );
|
||
|
|
||
|
int otherIndex = !index;
|
||
|
CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];
|
||
|
|
||
|
if ( !pHitEntity )
|
||
|
return;
|
||
|
|
||
|
if ( m_bWallShatter )
|
||
|
{
|
||
|
Fizzle();
|
||
|
Detonate();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( m_iType == TF_GL_MODE_REGULAR || m_iType == TF_GL_MODE_CANNONBALL )
|
||
|
{
|
||
|
if ( PropDynamic_CollidesWithGrenades( pHitEntity) )
|
||
|
{
|
||
|
if ( m_bTouched == false )
|
||
|
{
|
||
|
SetThink( &CTFGrenadePipebombProjectile::Detonate );
|
||
|
SetNextThink( gpGlobals->curtime );
|
||
|
}
|
||
|
}
|
||
|
// Blow up if we hit an enemy we can damage
|
||
|
else if ( pHitEntity->GetTeamNumber() && pHitEntity->GetTeamNumber() != GetTeamNumber() && pHitEntity->m_takedamage != DAMAGE_NO )
|
||
|
{
|
||
|
SetThink( &CTFGrenadePipebombProjectile::Detonate );
|
||
|
SetNextThink( gpGlobals->curtime );
|
||
|
}
|
||
|
|
||
|
if ( m_bTouched == false )
|
||
|
{
|
||
|
SetDamage( GetDamageScaleOnWorldContact() * GetDamage() );
|
||
|
|
||
|
int iNoBounce = 0;
|
||
|
if ( GetLauncher() )
|
||
|
{
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( GetLauncher(), iNoBounce, grenade_no_bounce )
|
||
|
if ( iNoBounce )
|
||
|
{
|
||
|
Vector velocity;
|
||
|
AngularImpulse angularVelocity;
|
||
|
VPhysicsGetObject()->GetVelocity( &velocity, &angularVelocity );
|
||
|
velocity *= 0.1f;
|
||
|
VPhysicsGetObject()->SetVelocity( &velocity, &angularVelocity );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_bTouched = true;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// Handle hitting skybox (disappear).
|
||
|
surfacedata_t *pprops = physprops->GetSurfaceData( pEvent->surfaceProps[otherIndex] );
|
||
|
if ( pprops->game.material == 'X' )
|
||
|
{
|
||
|
// uncomment to destroy grenade upon hitting sky brush
|
||
|
//SetThink( &CTFGrenadePipebombProjectile::SUB_Remove );
|
||
|
//SetNextThink( gpGlobals->curtime );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
bool bIsDynamicProp = ( NULL != dynamic_cast<CDynamicProp *>( pHitEntity ) );
|
||
|
|
||
|
// Temp: Don't stick to the saw blades in sawmill.
|
||
|
// We should make the saws their own entity type for networking.
|
||
|
if ( FStrEq( pHitEntity->m_iParent.ToCStr(), "sawmovelinear01" ) ||
|
||
|
FStrEq( pHitEntity->m_iParent.ToCStr(), "sawmovelinear02" ) ||
|
||
|
PropDynamic_CollidesWithGrenades( pHitEntity) )
|
||
|
{
|
||
|
bIsDynamicProp = false;
|
||
|
}
|
||
|
|
||
|
// Pipebombs stick to the world when they touch it
|
||
|
if ( pHitEntity && ( pHitEntity->IsWorld() || bIsDynamicProp ) && gpGlobals->curtime > m_flMinSleepTime )
|
||
|
{
|
||
|
m_bTouched = true;
|
||
|
|
||
|
g_PostSimulationQueue.QueueCall( VPhysicsGetObject(), &IPhysicsObject::EnableMotion, false );
|
||
|
|
||
|
// Save impact data for explosions.
|
||
|
m_bUseImpactNormal = true;
|
||
|
pEvent->pInternalData->GetSurfaceNormal( m_vecImpactNormal );
|
||
|
m_vecImpactNormal.Negate();
|
||
|
m_flTouchedTime = gpGlobals->curtime;
|
||
|
|
||
|
float flFizzle = 0;
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(), flFizzle, stickybomb_fizzle_time );
|
||
|
if ( flFizzle > 0 )
|
||
|
{
|
||
|
SetDetonateTimerLength( flFizzle );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
ConVar tf_grenade_forcefrom_bullet( "tf_grenade_forcefrom_bullet", "2.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
|
||
|
ConVar tf_grenade_forcefrom_buckshot( "tf_grenade_forcefrom_buckshot", "0.75", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
|
||
|
ConVar tf_grenade_forcefrom_blast( "tf_grenade_forcefrom_blast", "0.15", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
|
||
|
ConVar tf_grenade_force_sleeptime( "tf_grenade_force_sleeptime", "1.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY ); // How long after being shot will we re-stick to the world.
|
||
|
ConVar tf_pipebomb_force_to_move( "tf_pipebomb_force_to_move", "1500.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
|
||
|
ConVar tf_pipebomb_deflect_reset_time( "tf_pipebomb_deflect_reset_time", "10.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: If we are shot after being stuck to the world, move a bit
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CTFGrenadePipebombProjectile::OnTakeDamage( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
if ( !info.GetAttacker() )
|
||
|
{
|
||
|
Assert( !info.GetAttacker() );
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
bool bSameTeam = ( info.GetAttacker()->GetTeamNumber() == GetTeamNumber() );
|
||
|
if ( !bSameTeam && CanTakeDamage() )
|
||
|
{
|
||
|
if ( m_bTouched && HasStickyEffects() && ( info.GetDamageType() & (DMG_BULLET|DMG_BUCKSHOT|DMG_BLAST|DMG_SONIC|DMG_MELEE) ) )
|
||
|
{
|
||
|
Vector vecForce = info.GetDamageForce();
|
||
|
|
||
|
bool bBreakPipes = false;
|
||
|
|
||
|
if ( info.GetDamageType() & (DMG_BULLET|DMG_MELEE) )
|
||
|
{
|
||
|
vecForce *= tf_grenade_forcefrom_bullet.GetFloat();
|
||
|
bBreakPipes = true;
|
||
|
}
|
||
|
if ( info.GetDamageType() & DMG_SONIC )
|
||
|
{
|
||
|
vecForce *= tf_grenade_forcefrom_bullet.GetFloat();
|
||
|
}
|
||
|
else if ( info.GetDamageType() & DMG_BUCKSHOT )
|
||
|
{
|
||
|
vecForce *= tf_grenade_forcefrom_buckshot.GetFloat();
|
||
|
bBreakPipes = true;
|
||
|
}
|
||
|
else if ( info.GetDamageType() & DMG_BLAST )
|
||
|
{
|
||
|
vecForce *= tf_grenade_forcefrom_blast.GetFloat();
|
||
|
}
|
||
|
|
||
|
if ( bBreakPipes == true )
|
||
|
{
|
||
|
// we might get multiple calls for the same pipe when shooting it with a shotgun,
|
||
|
// so make sure it only sends the player_destroyed_pipebomb event once
|
||
|
if ( m_bSendPlayerDestroyedEvent )
|
||
|
{
|
||
|
if ( info.GetAttacker()->IsPlayer() )
|
||
|
{
|
||
|
CTFPlayer *pPlayer = ToTFPlayer( info.GetAttacker() );
|
||
|
if ( pPlayer )
|
||
|
{
|
||
|
IGameEvent * event = gameeventmanager->CreateEvent( "player_destroyed_pipebomb" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "userid", pPlayer->GetUserID() );
|
||
|
gameeventmanager->FireEvent( event );
|
||
|
}
|
||
|
|
||
|
if ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) )
|
||
|
{
|
||
|
// If we are near a building, award achievement progress.
|
||
|
CTFTeam *pTeam = pPlayer->GetTFTeam();
|
||
|
if ( pTeam )
|
||
|
{
|
||
|
for ( int i=0; i<pTeam->GetNumObjects(); i++ )
|
||
|
{
|
||
|
CBaseObject *pObject = pTeam->GetObject(i);
|
||
|
if ( pObject && pObject->GetAbsOrigin().DistTo( GetAbsOrigin() ) < 100 &&
|
||
|
pObject->ObjectType() != OBJ_ATTACHMENT_SAPPER )
|
||
|
{
|
||
|
pPlayer->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_DESTROY_STICKIES, 1 );
|
||
|
break; // Only one award per sticky.
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_bSendPlayerDestroyedEvent = false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Fizzle();
|
||
|
Detonate();
|
||
|
}
|
||
|
|
||
|
// If the force is sufficient, detach & move the pipebomb
|
||
|
float flForce = tf_pipebomb_force_to_move.GetFloat();
|
||
|
if ( vecForce.LengthSqr() > (flForce*flForce) )
|
||
|
{
|
||
|
if ( VPhysicsGetObject() )
|
||
|
{
|
||
|
VPhysicsGetObject()->EnableMotion( true );
|
||
|
}
|
||
|
|
||
|
CTakeDamageInfo newInfo = info;
|
||
|
newInfo.SetDamageForce( vecForce );
|
||
|
|
||
|
VPhysicsTakeDamage( newInfo );
|
||
|
|
||
|
// The pipebomb will re-stick to the ground after this time expires
|
||
|
m_flMinSleepTime = gpGlobals->curtime + tf_grenade_force_sleeptime.GetFloat();
|
||
|
m_bTouched = false;
|
||
|
|
||
|
// It has moved the data is no longer valid.
|
||
|
m_bUseImpactNormal = false;
|
||
|
m_vecImpactNormal.Init();
|
||
|
|
||
|
return 1;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
void CTFGrenadePipebombProjectile::IncrementDeflected( void )
|
||
|
{
|
||
|
BaseClass::IncrementDeflected();
|
||
|
|
||
|
if ( GetDeflected() && HasStickyEffects() )
|
||
|
{
|
||
|
m_flDeflectedTime = gpGlobals->curtime + tf_pipebomb_deflect_reset_time.GetFloat();
|
||
|
}
|
||
|
|
||
|
int iTeamNumber = GetTeamNumber();
|
||
|
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetDeflectOwner() );
|
||
|
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
iTeamNumber = pOwner->GetTeamNumber();
|
||
|
}
|
||
|
|
||
|
if ( !HasStickyEffects() )
|
||
|
{
|
||
|
m_nSkin = ( iTeamNumber == TF_TEAM_BLUE ) ? 1 : 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CTFGrenadePipebombProjectile::DetonateThink( void )
|
||
|
{
|
||
|
BaseClass::DetonateThink();
|
||
|
|
||
|
if ( m_flDeflectedTime <= gpGlobals->curtime && HasStickyEffects() )
|
||
|
{
|
||
|
ResetDeflected();
|
||
|
SetDeflectOwner( NULL );
|
||
|
}
|
||
|
|
||
|
// If we received our crit via a medic, make sure they still exist.
|
||
|
if ( m_CritMedics.Count() )
|
||
|
{
|
||
|
if ( TFGameRules() && ( TFGameRules()->InSetup() || TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS ) )
|
||
|
{
|
||
|
bool bRemove = true;
|
||
|
|
||
|
FOR_EACH_VEC( m_CritMedics, i )
|
||
|
{
|
||
|
if ( m_CritMedics[i] && m_CritMedics[i]->GetPlayerClass()->GetClassIndex() == TF_CLASS_MEDIC )
|
||
|
{
|
||
|
bRemove = false;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// No medic(s)
|
||
|
if ( bRemove )
|
||
|
{
|
||
|
Fizzle();
|
||
|
Detonate();
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Clear the vector when the game starts
|
||
|
m_CritMedics.RemoveAll();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CTFGrenadePipebombProjectile::PreArmThink( void )
|
||
|
{
|
||
|
SetContextThink( &CTFGrenadePipebombProjectile::ArmThink, gpGlobals->curtime + GetLiveTime(), "ARM_THINK" );
|
||
|
}
|
||
|
|
||
|
void CTFGrenadePipebombProjectile::ArmThink( void )
|
||
|
{
|
||
|
// When between waves in MvM, players sometimes switch to medic just so demos can place crit stickies,
|
||
|
// and then switch back. This code removes the sticky if the medic switches ( in DetonateThink() )
|
||
|
if ( IsCritical() && HasStickyEffects() && TFGameRules() && ( TFGameRules()->InSetup() || TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS ) )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetThrower() );
|
||
|
if ( pOwner && pOwner->m_Shared.InCond( TF_COND_CRITBOOSTED ) && !pOwner->m_Shared.InCond( TF_COND_CRITBOOSTED_USER_BUFF ) )
|
||
|
{
|
||
|
// Find the medic(s)
|
||
|
for ( int i = 0; i < pOwner->m_Shared.GetNumHealers(); i++ )
|
||
|
{
|
||
|
CTFPlayer *pMedic = ToTFPlayer( pOwner->m_Shared.GetHealerByIndex( i ) );
|
||
|
if ( !pMedic )
|
||
|
continue;
|
||
|
|
||
|
CWeaponMedigun *pMedigun = dynamic_cast <CWeaponMedigun*>( pMedic->GetActiveTFWeapon() );
|
||
|
if ( pMedigun && pMedigun->IsReleasingCharge() && pMedigun->GetChargeType() == MEDIGUN_CHARGE_CRITICALBOOST )
|
||
|
{
|
||
|
m_CritMedics.AddToTail( pMedic );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// We didn't find the medic. What provided TF_COND_CRITBOOSTED?
|
||
|
Assert( m_CritMedics.Count() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_bDetonateOnPulse )
|
||
|
{
|
||
|
Detonate();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
float CTFGrenadePipebombProjectile::GetLiveTime( void )
|
||
|
{
|
||
|
float flLiveTime = tf_grenadelauncher_livetime.GetFloat();
|
||
|
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(), flLiveTime, sticky_arm_time );
|
||
|
|
||
|
if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
|
||
|
{
|
||
|
CTFPlayer *pOwner = ToTFPlayer( GetThrower() );
|
||
|
|
||
|
if ( pOwner )
|
||
|
{
|
||
|
if ( pOwner->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
|
||
|
{
|
||
|
flLiveTime *= 0.5f;
|
||
|
}
|
||
|
else if ( pOwner->m_Shared.GetCarryingRuneType() == RUNE_KING || pOwner->m_Shared.InCond( TF_COND_KING_BUFFED ) )
|
||
|
{
|
||
|
flLiveTime *= 0.75f;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return flLiveTime;
|
||
|
}
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Grenade was deflected.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFGrenadePipebombProjectile::Deflected( CBaseEntity *pDeflectedBy, Vector& vecDir )
|
||
|
{
|
||
|
CTFPlayer *pTFDeflector = ToTFPlayer( pDeflectedBy );
|
||
|
if ( !pTFDeflector )
|
||
|
return;
|
||
|
|
||
|
CTFPlayer* pOldOwner = NULL;
|
||
|
if ( HasStickyEffects() )
|
||
|
{
|
||
|
CTakeDamageInfo info;
|
||
|
|
||
|
float flForceMultiplier = 1.0f;
|
||
|
ITFChargeUpWeapon *pWeapon = dynamic_cast<ITFChargeUpWeapon*>( pTFDeflector->GetActiveWeapon() );
|
||
|
if ( pWeapon )
|
||
|
{
|
||
|
flForceMultiplier = RemapValClamped( ( gpGlobals->curtime - pWeapon->GetChargeBeginTime() ),
|
||
|
0.0f,
|
||
|
pWeapon->GetChargeMaxTime(),
|
||
|
1.0f,
|
||
|
2.0f );
|
||
|
}
|
||
|
Vector vecForce = vecDir * flForceMultiplier * -CTFWeaponBase::DeflectionForce( WorldAlignSize(), 90, 12.0f );
|
||
|
|
||
|
pOldOwner = ToTFPlayer( GetThrower() );
|
||
|
info.SetAttacker( pDeflectedBy );
|
||
|
info.SetDamageForce( vecForce );
|
||
|
info.SetDamageType( DMG_SONIC );
|
||
|
info.SetWeapon( pTFDeflector->GetActiveTFWeapon() );
|
||
|
OnTakeDamage( info );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
ChangeTeam( pTFDeflector->GetTeamNumber() );
|
||
|
SetLauncher( pTFDeflector->GetActiveWeapon() );
|
||
|
pOldOwner = ToTFPlayer( GetThrower() );
|
||
|
SetThrower( pTFDeflector );
|
||
|
|
||
|
if ( pTFDeflector->m_Shared.IsCritBoosted() )
|
||
|
{
|
||
|
SetCritical( true );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( pOldOwner )
|
||
|
{
|
||
|
pOldOwner->SpeakConceptIfAllowed( MP_CONCEPT_DEFLECTED, "projectile:1,victim:1" );
|
||
|
}
|
||
|
|
||
|
CTFWeaponBase::SendObjectDeflectedEvent( pTFDeflector, pOldOwner, GetWeaponID(), this );
|
||
|
|
||
|
SetDeflectOwner( pTFDeflector );
|
||
|
IncrementDeflected();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
|
||
|
#ifdef CLIENT_DLL
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Highlight FX
|
||
|
//-----------------------------------------------------------------------------
|
||
|
class CProxyStickybombGlowColor : public CResultProxy
|
||
|
{
|
||
|
public:
|
||
|
void OnBind( void *pC_BaseEntity )
|
||
|
{
|
||
|
Assert( m_pResult );
|
||
|
|
||
|
if ( !pC_BaseEntity )
|
||
|
{
|
||
|
m_pResult->SetVecValue( 1, 1, 1 );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CTFGrenadePipebombProjectile *pGrenade = NULL;
|
||
|
C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
|
||
|
if ( !pEntity )
|
||
|
{
|
||
|
m_pResult->SetVecValue( 1, 1, 1 );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// default to [1 1 1]
|
||
|
Vector vResult = Vector( 1, 1, 1 );
|
||
|
|
||
|
pGrenade = dynamic_cast<CTFGrenadePipebombProjectile*>( pEntity );
|
||
|
if ( pGrenade )
|
||
|
{
|
||
|
if ( pGrenade->IsHighlighted() )
|
||
|
{
|
||
|
int iTeamNumber = pGrenade->GetTeamNumber();
|
||
|
if ( iTeamNumber == TF_TEAM_RED )
|
||
|
{
|
||
|
vResult = Vector ( 100.f, 0.f, 0.f );
|
||
|
if ( pGrenade->m_pGlowEffect )
|
||
|
{
|
||
|
pGrenade->m_pGlowEffect->SetColor( Vector( 250, 0, 0 ) );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
vResult = Vector ( 0.f, 0.f, 100.f );
|
||
|
if ( pGrenade->m_pGlowEffect )
|
||
|
{
|
||
|
pGrenade->m_pGlowEffect->SetColor( Vector( 0, 0, 250 ) );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
int iTeamNumber = pGrenade->GetTeamNumber();
|
||
|
if ( iTeamNumber == TF_TEAM_RED )
|
||
|
{
|
||
|
if ( pGrenade->m_pGlowEffect )
|
||
|
{
|
||
|
pGrenade->m_pGlowEffect->SetColor( Vector( 200, 100, 100 ) );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( pGrenade->m_pGlowEffect )
|
||
|
{
|
||
|
pGrenade->m_pGlowEffect->SetColor( Vector( 100, 100, 200 ) );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
m_pResult->SetVecValue( vResult.x, vResult.y, vResult.z );
|
||
|
}
|
||
|
};
|
||
|
EXPOSE_INTERFACE( CProxyStickybombGlowColor, IMaterialProxy, "StickybombGlowColor" IMATERIAL_PROXY_INTERFACE_VERSION );
|
||
|
#endif
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
#if GAME_DLL
|
||
|
int CTFGrenadePipebombProjectile::GetDamageCustom()
|
||
|
{
|
||
|
if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
|
||
|
{
|
||
|
if ( !m_bTouched )
|
||
|
{
|
||
|
return TF_DMG_CUSTOM_AIR_STICKY_BURST;
|
||
|
}
|
||
|
else if ( m_bDefensiveBomb )
|
||
|
{
|
||
|
return TF_DMG_CUSTOM_DEFENSIVE_STICKY;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return TF_DMG_CUSTOM_STANDARD_STICKY;
|
||
|
}
|
||
|
}
|
||
|
else if ( m_iType == TF_GL_MODE_REMOTE_DETONATE_PRACTICE )
|
||
|
{
|
||
|
return TF_DMG_CUSTOM_PRACTICE_STICKY;
|
||
|
}
|
||
|
|
||
|
return BaseClass::GetDamageCustom();
|
||
|
}
|
||
|
|
||
|
|
||
|
float CTFGrenadePipebombProjectile::GetDamageScaleOnWorldContact()
|
||
|
{
|
||
|
float flGrenadeDamageScaleOnWorldContact = 1.f;
|
||
|
if ( GetLauncher() )
|
||
|
{
|
||
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(),flGrenadeDamageScaleOnWorldContact, grenade_damage_reduction_on_world_contact );
|
||
|
}
|
||
|
return flGrenadeDamageScaleOnWorldContact;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
float CTFGrenadePipebombProjectile::GetDamageRadius()
|
||
|
{
|
||
|
float flRadiusMod = 1.0f;
|
||
|
|
||
|
#ifdef GAME_DLL
|
||
|
// winbomb prevention.
|
||
|
// Air Det
|
||
|
if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
|
||
|
{
|
||
|
if ( m_bTouched == false )
|
||
|
{
|
||
|
float flArmTime = tf_grenadelauncher_livetime.GetFloat();
|
||
|
flRadiusMod *= RemapValClamped( gpGlobals->curtime - m_flCreationTime, flArmTime, flArmTime + tf_sticky_radius_ramp_time.GetFloat(), tf_sticky_airdet_radius.GetFloat(), 1.0 );
|
||
|
}
|
||
|
}
|
||
|
#endif // GAME_DLL
|
||
|
return BaseClass::GetDamageRadius() * flRadiusMod;
|
||
|
}
|