1235 lines
38 KiB
C++
1235 lines
38 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
#include "tf_weapon_throwable.h"
|
|
#include "tf_gamerules.h"
|
|
#include "in_buttons.h"
|
|
#include "basetypes.h"
|
|
#include "tf_weaponbase_gun.h"
|
|
#include "effect_dispatch_data.h"
|
|
|
|
// Client specific.
|
|
#ifdef CLIENT_DLL
|
|
#include "c_tf_player.h"
|
|
// Server specific.
|
|
#else
|
|
#include "tf_player.h"
|
|
#include "tf_fx.h"
|
|
#include "te_effect_dispatch.h"
|
|
#include "bone_setup.h"
|
|
#include "tf_target_dummy.h"
|
|
#endif
|
|
|
|
|
|
// Base
|
|
// Launcher
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFThrowable, DT_TFWeaponThrowable )
|
|
BEGIN_NETWORK_TABLE( CTFThrowable, DT_TFWeaponThrowable )
|
|
#ifdef CLIENT_DLL
|
|
RecvPropFloat( RECVINFO( m_flChargeBeginTime ) ),
|
|
#else
|
|
SendPropFloat( SENDINFO( m_flChargeBeginTime ) ),
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_PREDICTION_DATA( CTFThrowable )
|
|
END_PREDICTION_DATA()
|
|
|
|
//LINK_ENTITY_TO_CLASS( tf_weapon_throwable, CTFThrowable );
|
|
//PRECACHE_WEAPON_REGISTER( tf_weapon_throwable );
|
|
|
|
#ifdef STAGING_ONLY
|
|
CREATE_SIMPLE_WEAPON_TABLE( TFThrowablePrimary, tf_weapon_throwable_primary )
|
|
CREATE_SIMPLE_WEAPON_TABLE( TFThrowableSecondary, tf_weapon_throwable_secondary )
|
|
CREATE_SIMPLE_WEAPON_TABLE( TFThrowableMelee, tf_weapon_throwable_melee )
|
|
CREATE_SIMPLE_WEAPON_TABLE( TFThrowableUtility, tf_weapon_throwable_utility )
|
|
#endif
|
|
|
|
// Projectile
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_Throwable, DT_TFProjectile_Throwable )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_Throwable, DT_TFProjectile_Throwable )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_throwable, CTFProjectile_Throwable );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_throwable );
|
|
|
|
// Projectile Repel
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_ThrowableRepel, DT_TFProjectile_ThrowableRepel )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_ThrowableRepel, DT_TFProjectile_ThrowableRepel )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_throwable_repel, CTFProjectile_ThrowableRepel );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_throwable_repel );
|
|
|
|
// Projectile Brick
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_ThrowableBrick, DT_TFProjectile_ThrowableBrick )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_ThrowableBrick, DT_TFProjectile_ThrowableBrick )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_throwable_brick, CTFProjectile_ThrowableBrick );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_throwable_brick );
|
|
|
|
// Projectile Bread Monster
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_ThrowableBreadMonster, DT_TFProjectile_ThrowableBreadMonster )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_ThrowableBreadMonster, DT_TFProjectile_ThrowableBreadMonster )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_throwable_breadmonster, CTFProjectile_ThrowableBreadMonster );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_throwable_breadmonster );
|
|
|
|
#ifdef STAGING_ONLY
|
|
// Projectile Target Dummy
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_ThrowableTargetDummy, DT_TFProjectile_ThrowableTargetDummy )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_ConcGrenade, DT_TFProjectile_ThrowableTargetDummy )
|
|
END_NETWORK_TABLE()
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_target_dummy, CTFProjectile_ThrowableTargetDummy );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_target_dummy );
|
|
|
|
// Projectile Concussion Grenade
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_ConcGrenade, DT_TFProjectile_ConcGrenade )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_ConcGrenade, DT_TFProjectile_ConcGrenade )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_grenade_concussion, CTFProjectile_ConcGrenade );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_grenade_concussion );
|
|
|
|
// Projectile Teleport Grenade
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_TeleportGrenade, DT_TFProjectile_TeleportGrenade )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_TeleportGrenade, DT_TFProjectile_TeleportGrenade )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_grenade_teleport, CTFProjectile_TeleportGrenade );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_grenade_teleport );
|
|
|
|
// Projectile Chain Grenade
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_GravityGrenade, DT_TFProjectile_GravityGrenade )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_GravityGrenade, DT_TFProjectile_GravityGrenade )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_grenade_gravity, CTFProjectile_GravityGrenade );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_grenade_gravity );
|
|
|
|
// Projectile Chain Grenade
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_ThrowingKnife, DT_TFProjectile_ThrowingKnife )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_ThrowingKnife, DT_TFProjectile_ThrowingKnife )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_throwing_knife, CTFProjectile_ThrowingKnife );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_throwing_knife );
|
|
|
|
// Projectile Smoke Grenade
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SmokeGrenade, DT_TFProjectile_SmokeGrenade )
|
|
BEGIN_NETWORK_TABLE( CTFProjectile_SmokeGrenade, DT_TFProjectile_SmokeGrenade )
|
|
END_NETWORK_TABLE()
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_projectile_grenade_smoke, CTFProjectile_SmokeGrenade );
|
|
PRECACHE_WEAPON_REGISTER( tf_projectile_grenade_smoke );
|
|
#endif // STAGING_ONLY
|
|
|
|
#define TF_GRENADE_TIMER "Weapon_Grenade.Timer"
|
|
#define TF_GRENADE_CHARGE "Weapon_LooseCannon.Charge"
|
|
|
|
//****************************************************************************
|
|
// Throwable Weapon
|
|
//****************************************************************************
|
|
CTFThrowable::CTFThrowable( void )
|
|
{
|
|
m_flChargeBeginTime = -1.0f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFThrowable::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
|
|
PrecacheModel( g_pszArrowModels[MODEL_BREAD_MONSTER] );
|
|
PrecacheModel( g_pszArrowModels[MODEL_THROWING_KNIFE] );
|
|
#ifdef STAGING_ONLY
|
|
PrecacheScriptSound( "Weapon_Grenade_Concussion.Explode" );
|
|
PrecacheScriptSound( "Weapon_Grenade_Teleport.Explode" );
|
|
PrecacheScriptSound( TF_GRENADE_TIMER );
|
|
#endif // STAGING_ONLY
|
|
PrecacheScriptSound( TF_GRENADE_CHARGE );
|
|
|
|
PrecacheScriptSound( "Weapon_bm_throwable.throw" );
|
|
PrecacheScriptSound( "Weapon_bm_throwable.smash" );
|
|
|
|
PrecacheParticleSystem( "grenade_smoke_cycle" );
|
|
PrecacheParticleSystem( "blood_bread_biting" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
float CTFThrowable::InternalGetEffectBarRechargeTime( void )
|
|
{
|
|
float flRechargeTime = 0;
|
|
CALL_ATTRIB_HOOK_FLOAT( flRechargeTime, throwable_recharge_time );
|
|
if ( flRechargeTime )
|
|
return flRechargeTime;
|
|
return 10.0f; // default
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
float CTFThrowable::GetDetonationTime()
|
|
{
|
|
float flDetonationTime = 0;
|
|
CALL_ATTRIB_HOOK_FLOAT( flDetonationTime, throwable_detonation_time );
|
|
if ( flDetonationTime )
|
|
return flDetonationTime;
|
|
return 5.0f; // default
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFThrowable::PrimaryAttack( void )
|
|
{
|
|
if ( !CanCharge() )
|
|
{
|
|
// Fire
|
|
BaseClass::PrimaryAttack();
|
|
return;
|
|
}
|
|
|
|
if ( m_flChargeBeginTime > 0 )
|
|
return;
|
|
|
|
// Do all the Checks and start a charged (primed) attack
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// Check for ammunition.
|
|
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) < 1 )
|
|
return;
|
|
|
|
// Are we capable of firing again?
|
|
if ( m_flNextPrimaryAttack > gpGlobals->curtime )
|
|
return;
|
|
|
|
if ( pPlayer->GetWaterLevel() == WL_Eyes )
|
|
return;
|
|
|
|
if ( !CanAttack() )
|
|
return;
|
|
|
|
if ( m_flChargeBeginTime <= 0 )
|
|
{
|
|
// Set the weapon mode.
|
|
m_iWeaponMode = TF_WEAPON_PRIMARY_MODE;
|
|
SendWeaponAnim( ACT_VM_PULLBACK ); // TODO : Anim!
|
|
#ifdef GAME_DLL
|
|
// save that we had the attack button down
|
|
m_flChargeBeginTime = gpGlobals->curtime;
|
|
#endif // GAME_LL
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( pPlayer == C_BasePlayer::GetLocalPlayer() )
|
|
{
|
|
int iCanBeCharged = 0;
|
|
CALL_ATTRIB_HOOK_INT( iCanBeCharged, is_throwable_chargeable );
|
|
if ( iCanBeCharged )
|
|
{
|
|
EmitSound( TF_GRENADE_CHARGE );
|
|
}
|
|
else
|
|
{
|
|
EmitSound( TF_GRENADE_TIMER );
|
|
}
|
|
}
|
|
#endif // CLIENT_DLL
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFThrowable::ItemPostFrame( void )
|
|
{
|
|
// Get the player owning the weapon.
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
if ( m_flChargeBeginTime > 0.f && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
|
|
{
|
|
bool bFiredWeapon = false;
|
|
// If we're not holding down the attack button, launch our grenade
|
|
if ( !( pPlayer->m_nButtons & IN_ATTACK ) )
|
|
{
|
|
FireProjectile( pPlayer );
|
|
bFiredWeapon = true;
|
|
}
|
|
// Misfire
|
|
else if ( m_flChargeBeginTime + GetDetonationTime() < gpGlobals->curtime )
|
|
{
|
|
CTFProjectile_Throwable * pThrowable = dynamic_cast<CTFProjectile_Throwable*>( FireProjectile( pPlayer ) );
|
|
if ( pThrowable )
|
|
{
|
|
#ifdef GAME_DLL
|
|
pThrowable->Misfire();
|
|
#endif // GAME_DLL
|
|
}
|
|
|
|
bFiredWeapon = true;
|
|
}
|
|
|
|
if ( bFiredWeapon )
|
|
{
|
|
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
|
|
pPlayer->SetAnimation( PLAYER_ATTACK1 );
|
|
#ifdef GAME_DLL
|
|
m_flChargeBeginTime = -1.0f; // reset
|
|
#endif // GAME_DLL
|
|
// Set next attack times.
|
|
float flFireDelay = m_pWeaponInfo->GetWeaponData( m_iWeaponMode ).m_flTimeFireDelay;
|
|
m_flNextPrimaryAttack = gpGlobals->curtime + flFireDelay;
|
|
SetWeaponIdleTime( gpGlobals->curtime + SequenceDuration() );
|
|
#ifdef CLIENT_DLL
|
|
int iCanBeCharged = 0;
|
|
CALL_ATTRIB_HOOK_INT( iCanBeCharged, is_throwable_chargeable );
|
|
if ( iCanBeCharged )
|
|
{
|
|
StopSound( TF_GRENADE_CHARGE );
|
|
}
|
|
#endif // CLIENT_DLL
|
|
}
|
|
}
|
|
BaseClass::ItemPostFrame();
|
|
}
|
|
|
|
// ITFChargeUpWeapon
|
|
//-----------------------------------------------------------------------------
|
|
// Primable is for timed explosions
|
|
// Charagable is for things like distance or power increases
|
|
// Can't really have both but can have neither
|
|
bool CTFThrowable::CanCharge()
|
|
{
|
|
int iCanBePrimed = 0;
|
|
CALL_ATTRIB_HOOK_INT( iCanBePrimed, is_throwable_primable );
|
|
|
|
int iCanBeCharged = 0;
|
|
CALL_ATTRIB_HOOK_INT( iCanBeCharged, is_throwable_chargeable );
|
|
|
|
return iCanBeCharged || iCanBePrimed ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
float CTFThrowable::GetChargeBeginTime( void )
|
|
{
|
|
float flDetonateTimeLength = GetDetonationTime();
|
|
// float flModDetonateTimeLength = 0;
|
|
|
|
int iCanBePrimed = 0;
|
|
CALL_ATTRIB_HOOK_INT( iCanBePrimed, is_throwable_primable );
|
|
|
|
// Use reverse logic for primable grenades (Counts down to boom)
|
|
// Full charge since we haven't fired
|
|
if ( iCanBePrimed )
|
|
{
|
|
if ( m_flChargeBeginTime < 0 )
|
|
{
|
|
return gpGlobals->curtime - flDetonateTimeLength;
|
|
}
|
|
return gpGlobals->curtime - Clamp( m_flChargeBeginTime + flDetonateTimeLength - gpGlobals->curtime, 0.f, flDetonateTimeLength );
|
|
}
|
|
|
|
return m_flChargeBeginTime;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
float CTFThrowable::GetChargeMaxTime( void )
|
|
{
|
|
return GetDetonationTime();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CTFThrowable::FireJar( CTFPlayer *pPlayer )
|
|
{
|
|
#ifdef GAME_DLL
|
|
return FireProjectileInternal();
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
//-----------------------------------------------------------------------------
|
|
void CTFThrowable::TossJarThink( void )
|
|
{
|
|
FireProjectileInternal();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
CTFProjectile_Throwable *CTFThrowable::FireProjectileInternal( void )
|
|
{
|
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
|
if ( !pPlayer )
|
|
return NULL;
|
|
|
|
CAttribute_String attrProjectileEntityName;
|
|
GetProjectileEntityName( &attrProjectileEntityName );
|
|
if ( !attrProjectileEntityName.has_value() )
|
|
return NULL;
|
|
|
|
Vector vecForward, vecRight, vecUp;
|
|
AngleVectors( pPlayer->EyeAngles(), &vecForward, &vecRight, &vecUp );
|
|
|
|
float fRight = 8.f;
|
|
if ( IsViewModelFlipped() )
|
|
{
|
|
fRight *= -1;
|
|
}
|
|
Vector vecSrc = pPlayer->Weapon_ShootPosition();
|
|
|
|
// Make spell toss position at the hand
|
|
vecSrc = vecSrc + ( vecUp * -9.0f ) + ( vecRight * 7.0f ) + ( vecForward * 3.0f );
|
|
|
|
trace_t trace;
|
|
Vector vecEye = pPlayer->EyePosition();
|
|
CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
|
|
UTIL_TraceHull( vecEye, vecSrc, -Vector( 8, 8, 8 ), Vector( 8, 8, 8 ), MASK_SOLID_BRUSHONLY, &traceFilter, &trace );
|
|
|
|
// If we started in solid, don't let them fire at all
|
|
if ( trace.startsolid )
|
|
return NULL;
|
|
|
|
CalcIsAttackCritical();
|
|
|
|
// Create the Grenade and Intialize it appropriately
|
|
CTFProjectile_Throwable *pGrenade = static_cast<CTFProjectile_Throwable*>( CBaseEntity::CreateNoSpawn( attrProjectileEntityName.value().c_str(), trace.endpos, pPlayer->EyeAngles(), pPlayer ) );
|
|
if ( pGrenade )
|
|
{
|
|
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
|
|
pGrenade->SetPipebombMode();
|
|
pGrenade->SetLauncher( this );
|
|
pGrenade->SetCritical( IsCurrentAttackACrit() );
|
|
|
|
DispatchSpawn( pGrenade );
|
|
|
|
// Calculate a charge percentage
|
|
// For now Charge just effects exit velocity
|
|
int iCanBeCharged = 0;
|
|
float flChargePercent = 0;
|
|
float flDetonateTime = GetDetonationTime();
|
|
CALL_ATTRIB_HOOK_INT( iCanBeCharged, is_throwable_chargeable );
|
|
if ( iCanBeCharged )
|
|
{
|
|
flChargePercent = RemapVal( gpGlobals->curtime, m_flChargeBeginTime, m_flChargeBeginTime + flDetonateTime, 0.0f, 1.0f );
|
|
}
|
|
|
|
Vector vecVelocity = pGrenade->GetVelocityVector( vecForward, vecRight, vecUp, flChargePercent );
|
|
AngularImpulse angVelocity = pGrenade->GetAngularImpulse();
|
|
|
|
pGrenade->InitGrenade( vecVelocity, angVelocity, pPlayer, GetTFWpnData() );
|
|
pGrenade->InitThrowable( flChargePercent );
|
|
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
|
|
|
|
if ( flDetonateTime > 0 )
|
|
{
|
|
// Check if this has been primed
|
|
int iCanBePrimed = 0;
|
|
CALL_ATTRIB_HOOK_INT( iCanBePrimed, is_throwable_primable );
|
|
if ( m_flChargeBeginTime > 0 && iCanBePrimed > 0 )
|
|
{
|
|
flDetonateTime = ( m_flChargeBeginTime + flDetonateTime - gpGlobals->curtime );
|
|
}
|
|
pGrenade->SetDetonateTimerLength( flDetonateTime );
|
|
}
|
|
pGrenade->m_flFullDamage = 0;
|
|
|
|
if ( pGrenade->GetThrowSoundEffect() )
|
|
{
|
|
pGrenade->EmitSound( pGrenade->GetThrowSoundEffect() );
|
|
}
|
|
}
|
|
|
|
StartEffectBarRegen();
|
|
|
|
return pGrenade;
|
|
}
|
|
#endif // GAME_DLL
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
// Throwable Projectile
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
#ifdef GAME_DLL
|
|
CTFProjectile_Throwable::CTFProjectile_Throwable( void )
|
|
{
|
|
m_flChargePercent = 0;
|
|
m_bHit = false;
|
|
}
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
// Get Initial Velocity
|
|
Vector CTFProjectile_Throwable::GetVelocityVector( const Vector &vecForward, const Vector &vecRight, const Vector &vecUp, float flCharge )
|
|
{
|
|
// Scale the projectile speed up to a maximum of 3000?
|
|
float flSpeed = RemapVal( flCharge, 0, 1.0f, GetProjectileSpeed(), GetProjectileMaxSpeed() );
|
|
|
|
return ( ( flSpeed * vecForward ) +
|
|
( ( random->RandomFloat( -10.0f, 10.0f ) + 200.0f ) * vecUp ) +
|
|
( random->RandomFloat( -10.0f, 10.0f ) * vecRight ) );
|
|
}
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
void CTFProjectile_Throwable::OnHit( CBaseEntity *pOther )
|
|
{
|
|
if ( m_bHit )
|
|
return;
|
|
|
|
if ( ExplodesOnHit() )
|
|
{
|
|
Explode();
|
|
}
|
|
|
|
m_bHit = true;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_Throwable::Explode()
|
|
{
|
|
trace_t tr;
|
|
Vector vecSpot;// trace starts here!
|
|
SetThink( NULL );
|
|
vecSpot = GetAbsOrigin() + Vector ( 0 , 0 , 8 );
|
|
UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -32 ), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, & tr);
|
|
Explode( &tr, GetDamageType() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_Throwable::Explode( trace_t *pTrace, int bitsDamageType )
|
|
{
|
|
if ( GetThrower() )
|
|
{
|
|
InitialExplodeEffects( NULL, pTrace );
|
|
|
|
// Particle
|
|
const char* pszExplodeEffect = GetExplodeEffectParticle();
|
|
if ( pszExplodeEffect && pszExplodeEffect[0] != '\0' )
|
|
{
|
|
CPVSFilter filter( GetAbsOrigin() );
|
|
TE_TFParticleEffect( filter, 0.0, pszExplodeEffect, GetAbsOrigin(), vec3_angle );
|
|
}
|
|
|
|
// Sounds
|
|
const char* pszSoundEffect = GetExplodeEffectSound();
|
|
if ( pszSoundEffect && pszSoundEffect[0] != '\0' )
|
|
{
|
|
EmitSound( pszSoundEffect );
|
|
}
|
|
}
|
|
|
|
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
|
|
SetTouch( NULL );
|
|
|
|
AddEffects( EF_NODRAW );
|
|
SetAbsVelocity( vec3_origin );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// THROWABLE REPEL
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ThrowableRepel::OnHit( CBaseEntity *pOther )
|
|
{
|
|
if ( m_bHit )
|
|
return;
|
|
|
|
CTFPlayer *pPlayer = dynamic_cast< CTFPlayer*>( pOther );
|
|
|
|
if ( pPlayer && !pPlayer->InSameTeam( GetThrower() ) )
|
|
{
|
|
CTraceFilterIgnoreTeammates tracefilter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
|
|
trace_t trace;
|
|
UTIL_TraceLine( GetAbsOrigin(), pPlayer->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &tracefilter, &trace );
|
|
|
|
// Apply AirBlast Force
|
|
Vector vecToTarget;
|
|
vecToTarget = pPlayer->GetAbsOrigin() - this->GetAbsOrigin();
|
|
vecToTarget.z = 0;
|
|
VectorNormalize( vecToTarget );
|
|
|
|
// Quick Fix Uber is immune
|
|
if ( pPlayer->m_Shared.InCond( TF_COND_MEGAHEAL ))
|
|
return;
|
|
|
|
float flForce = 300.0f * m_flChargePercent + 350.0f;
|
|
pPlayer->ApplyAirBlastImpulse( vecToTarget * flForce + Vector( 0, 0, flForce ) );
|
|
pPlayer->ApplyPunchImpulseX( RandomInt( -50, -30 ) );
|
|
|
|
// Apply Damage to Victim
|
|
CTakeDamageInfo info;
|
|
info.SetAttacker( GetThrower() );
|
|
info.SetInflictor( this );
|
|
info.SetWeapon( GetLauncher() );
|
|
info.SetDamage( GetDamage() );
|
|
info.SetDamageCustom( GetCustomDamageType() );
|
|
info.SetDamagePosition( this->GetAbsOrigin() );
|
|
info.SetDamageType( DMG_CLUB | DMG_PREVENT_PHYSICS_FORCE );
|
|
|
|
//Vector dir;
|
|
//AngleVectors( GetAbsAngles(), &dir );
|
|
|
|
pPlayer->DispatchTraceAttack( info, vecToTarget, &trace );
|
|
ApplyMultiDamage();
|
|
}
|
|
|
|
BaseClass::OnHit( pOther );
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// THROWABLE BRICK
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ThrowableBrick::OnHit( CBaseEntity *pOther )
|
|
{
|
|
if ( m_bHit )
|
|
return;
|
|
|
|
CTFPlayer *pPlayer = dynamic_cast< CTFPlayer*>( pOther );
|
|
|
|
if ( pPlayer && !pPlayer->InSameTeam( GetThrower() ) )
|
|
{
|
|
CTraceFilterIgnoreTeammates tracefilter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
|
|
trace_t trace;
|
|
UTIL_TraceLine( GetAbsOrigin(), pPlayer->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &tracefilter, &trace );
|
|
|
|
Vector vecToTarget;
|
|
vecToTarget = pPlayer->WorldSpaceCenter() - this->WorldSpaceCenter();
|
|
VectorNormalize( vecToTarget );
|
|
|
|
// Apply Damage to Victim
|
|
CTakeDamageInfo info;
|
|
info.SetAttacker( GetThrower() );
|
|
info.SetInflictor( this );
|
|
info.SetWeapon( GetLauncher() );
|
|
info.SetDamage( GetDamage() );
|
|
info.SetDamageCustom( GetCustomDamageType() );
|
|
info.SetDamagePosition( GetAbsOrigin() );
|
|
info.SetDamageType( DMG_CLUB );
|
|
|
|
pPlayer->DispatchTraceAttack( info, vecToTarget, &trace );
|
|
pPlayer->ApplyPunchImpulseX( RandomInt( 15, 20 ) );
|
|
ApplyMultiDamage();
|
|
}
|
|
|
|
BaseClass::OnHit( pOther );
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// THROWABLE BREADMONSTER
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ThrowableBreadMonster::OnHit( CBaseEntity *pOther )
|
|
{
|
|
if ( m_bHit )
|
|
return;
|
|
|
|
CTFPlayer *pVictim = dynamic_cast< CTFPlayer*>( pOther );
|
|
CTFPlayer *pOwner = dynamic_cast< CTFPlayer*>( GetThrower() );
|
|
|
|
if ( pVictim && pOwner && !pVictim->InSameTeam( pOwner ) )
|
|
{
|
|
m_bHit = true;
|
|
CTraceFilterIgnoreTeammates tracefilter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
|
|
trace_t trace;
|
|
Vector vEndPos = pVictim->WorldSpaceCenter();
|
|
vEndPos.z = WorldSpaceCenter().z + 1.0f;
|
|
UTIL_TraceLine( WorldSpaceCenter(), vEndPos, CONTENTS_HITBOX|CONTENTS_MONSTER|CONTENTS_SOLID, &tracefilter, &trace );
|
|
|
|
Vector vecToTarget;
|
|
vecToTarget = pVictim->WorldSpaceCenter() - this->WorldSpaceCenter();
|
|
VectorNormalize( vecToTarget );
|
|
|
|
// Apply Damage to Victim
|
|
CTakeDamageInfo info;
|
|
info.SetAttacker( GetThrower() );
|
|
info.SetInflictor( this );
|
|
info.SetWeapon( GetLauncher() );
|
|
info.SetDamage( GetDamage() );
|
|
info.SetDamageCustom( GetCustomDamageType() );
|
|
info.SetDamagePosition( GetAbsOrigin() );
|
|
|
|
int iDamageType = DMG_CLUB;
|
|
if ( IsCritical() )
|
|
{
|
|
iDamageType |= DMG_CRITICAL;
|
|
}
|
|
info.SetDamageType( iDamageType );
|
|
|
|
pVictim->DispatchTraceAttack( info, vecToTarget, &trace );
|
|
pVictim->ApplyPunchImpulseX( RandomInt( 15, 20 ) );
|
|
pVictim->m_Shared.MakeBleed( pOwner, dynamic_cast< CTFWeaponBase * >( GetLauncher() ), 5.0f, 1.0f );
|
|
ApplyMultiDamage();
|
|
|
|
// Bread Particle
|
|
CPVSFilter filter( vEndPos );
|
|
TE_TFParticleEffect( filter, 0.0, "blood_bread_biting", vEndPos, vec3_angle );
|
|
|
|
// Attach Breadmonster to Victim
|
|
CreateStickyAttachmentToTarget( pOwner, pVictim, &trace );
|
|
|
|
BaseClass::Explode();
|
|
return;
|
|
}
|
|
else // its a dud
|
|
{
|
|
BaseClass::Explode();
|
|
return;
|
|
}
|
|
BaseClass::OnHit( pOther );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ThrowableBreadMonster::Detonate()
|
|
{
|
|
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
|
|
SetTouch( NULL );
|
|
|
|
AddEffects( EF_NODRAW );
|
|
SetAbsVelocity( vec3_origin );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ThrowableBreadMonster::Explode( trace_t *pTrace, int bitsDamageType )
|
|
{
|
|
if ( !m_bHit )
|
|
{
|
|
// TODO, Spawn Debris / Flopping BreadInstead
|
|
trace_t tr;
|
|
Vector velDir = m_vCollisionVelocity;
|
|
VectorNormalize( velDir );
|
|
Vector vecSpot = GetAbsOrigin() - velDir * 32;
|
|
UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_DEBRIS, &tr );
|
|
if ( tr.fraction < 1.0 && tr.surface.flags & SURF_SKY )
|
|
{
|
|
// We hit the skybox, go away soon.
|
|
return;
|
|
}
|
|
|
|
// Create a breadmonster in the world
|
|
CEffectData data;
|
|
data.m_vOrigin = tr.endpos;
|
|
data.m_vNormal = velDir;
|
|
data.m_nEntIndex = 0;
|
|
data.m_nAttachmentIndex = 0;
|
|
data.m_nMaterial = 0;
|
|
data.m_fFlags = TF_PROJECTILE_BREAD_MONSTER;
|
|
data.m_nColor = ( GetTeamNumber() == TF_TEAM_BLUE ) ? 1 : 0;
|
|
|
|
DispatchEffect( "TFBoltImpact", data );
|
|
}
|
|
|
|
BaseClass::Explode( pTrace, bitsDamageType );
|
|
}
|
|
|
|
#endif // GAME_DLL
|
|
//
|
|
//#ifdef CLIENT_DLL
|
|
//
|
|
//static CUtlMap< const char*, CUtlString > s_TeamParticleMap;
|
|
//static bool s_TeamParticleMapInited = false;
|
|
//
|
|
////-----------------------------------------------------------------------------
|
|
//const char *CTFProjectile_Throwable::GetTrailParticleName( void )
|
|
//{
|
|
// // Check for Particles
|
|
// int iDynamicParticleEffect = 0;
|
|
// CALL_ATTRIB_HOOK_INT_ON_OTHER( GetLauncher(), iDynamicParticleEffect, set_attached_particle );
|
|
// if ( iDynamicParticleEffect > 0 )
|
|
// {
|
|
// // Init Map Once
|
|
// if ( !s_TeamParticleMapInited )
|
|
// {
|
|
// SetDefLessFunc( s_TeamParticleMap );
|
|
// s_TeamParticleMapInited = true;
|
|
// }
|
|
//
|
|
// attachedparticlesystem_t *pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( iDynamicParticleEffect );
|
|
// if ( pParticleSystem )
|
|
// {
|
|
// // TF Team Color Particles
|
|
// const char * pName = pParticleSystem->pszSystemName;
|
|
// if ( GetTeamNumber() == TF_TEAM_BLUE && V_stristr( pName, "_teamcolor_red" ))
|
|
// {
|
|
// int index = s_TeamParticleMap.Find( pName );
|
|
// if ( !s_TeamParticleMap.IsValidIndex( index ) )
|
|
// {
|
|
// char pBlue[256];
|
|
// V_StrSubst( pName, "_teamcolor_red", "_teamcolor_blue", pBlue, 256 );
|
|
// CUtlString pBlueString( pBlue );
|
|
// index = s_TeamParticleMap.Insert( pName, pBlueString );
|
|
// }
|
|
// return s_TeamParticleMap[index].String();
|
|
// }
|
|
// else if ( GetTeamNumber() == TF_TEAM_RED && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_blue" ))
|
|
// {
|
|
// // Guard against accidentally giving out the blue team color (support tool)
|
|
// int index = s_TeamParticleMap.Find( pName );
|
|
// if ( !s_TeamParticleMap.IsValidIndex( index ) )
|
|
// {
|
|
// char pRed[256];
|
|
// V_StrSubst( pName, "_teamcolor_blue", "_teamcolor_red", pRed, 256 );
|
|
// CUtlString pRedString( pRed );
|
|
// index = s_TeamParticleMap.Insert( pName, pRedString );
|
|
// }
|
|
// return s_TeamParticleMap[index].String();
|
|
// }
|
|
//
|
|
// return pName;
|
|
// }
|
|
// }
|
|
//
|
|
// if ( GetTeamNumber() == TF_TEAM_BLUE )
|
|
// {
|
|
// return "trail_basic_blue";
|
|
// }
|
|
// else
|
|
// {
|
|
// return "trail_basic_red";
|
|
// }
|
|
//}
|
|
//
|
|
//#endif // CLIENT_DLL
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
#ifdef STAGING_ONLY
|
|
#ifdef GAME_DLL
|
|
|
|
|
|
void CTFProjectile_ThrowableTargetDummy::Explode()
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetThrower() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
CTFTargetDummy::Create( GetAbsOrigin(), GetAbsAngles(), pPlayer );
|
|
BaseClass::Explode();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ConcGrenade::Detonate( )
|
|
{
|
|
Explode();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ConcGrenade::Misfire( )
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetThrower() );
|
|
if ( pPlayer )
|
|
{
|
|
SetAbsOrigin( pPlayer->GetAbsOrigin() );
|
|
}
|
|
|
|
Explode();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ConcGrenade::Explode( )
|
|
{
|
|
// Apply pushback
|
|
const float flMaxForce = 900.f;
|
|
const float flMaxSelfForce = 800.f;
|
|
const int nMaxEnts = MAX_PLAYERS;
|
|
CBaseEntity *pObjects[ nMaxEnts ];
|
|
int nCount = UTIL_EntitiesInSphere( pObjects, nMaxEnts, GetAbsOrigin(), GetDamageRadius(), FL_CLIENT );
|
|
CTFPlayer *pThrower = ToTFPlayer( GetThrower() );
|
|
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
if ( !pObjects[i] )
|
|
continue;
|
|
|
|
if ( !pObjects[i]->IsAlive() )
|
|
continue;
|
|
|
|
// Only affect the thrower from same team
|
|
if ( InSameTeam( pObjects[i] ) && pObjects[i] != pThrower )
|
|
continue;
|
|
|
|
if ( !FVisible( pObjects[i], MASK_OPAQUE ) )
|
|
continue;
|
|
|
|
if ( !pObjects[i]->IsPlayer() )
|
|
continue;
|
|
|
|
CTFPlayer *pTFPlayer = static_cast< CTFPlayer* >( pObjects[i] );
|
|
if ( !pTFPlayer )
|
|
continue;
|
|
|
|
// Conc does more force the further away you are from the blast radius
|
|
Vector vecPushDir = pTFPlayer->GetAbsOrigin() - GetAbsOrigin();
|
|
float flForce = RemapVal( vecPushDir.Length(), 0, GetDamageRadius(), 0, flMaxForce );
|
|
|
|
if ( flForce < 250.0f && pObjects[i] == pThrower ) // Hold case
|
|
{
|
|
AngularImpulse ang;
|
|
pTFPlayer->GetVelocity( &vecPushDir, &ang );
|
|
flForce = flMaxSelfForce;
|
|
}
|
|
VectorNormalize( vecPushDir );
|
|
vecPushDir.z *= 1.5f;
|
|
pTFPlayer->ApplyAirBlastImpulse( vecPushDir * flForce );
|
|
pTFPlayer->ApplyPunchImpulseX( RandomInt( -50, -30 ) );
|
|
|
|
// if ( pObjects[i] == pThrower )
|
|
// {
|
|
// // Apply 'Bonk' lines to make target more visible for 2 seconds
|
|
// pThrower->m_Shared.AddCond( TF_COND_SELF_CONC, 2 );
|
|
// }
|
|
}
|
|
|
|
BaseClass::Explode();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_TeleportGrenade::Spawn( void )
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
SetContextThink( &CTFProjectile_TeleportGrenade::RecordPosThink, gpGlobals->curtime + 0.05f, "RecordThink" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_TeleportGrenade::RecordPosThink( void )
|
|
{
|
|
m_vecTrailingPos.AddToTail( GetAbsOrigin() );
|
|
|
|
// Only retain 5 positions
|
|
if ( m_vecTrailingPos.Count() > 5 )
|
|
{
|
|
m_vecTrailingPos.Remove( 0 );
|
|
}
|
|
|
|
SetContextThink( &CTFProjectile_TeleportGrenade::RecordPosThink, gpGlobals->curtime + 0.05f, "RecordThink" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_TeleportGrenade::Explode( trace_t *pTrace, int bitsDamageType )
|
|
{
|
|
CTFPlayer *pThrower = ToTFPlayer( GetThrower() );
|
|
if ( !pThrower || !pThrower->IsAlive() )
|
|
return;
|
|
|
|
trace_t traceHull;
|
|
CTraceFilterIgnoreTeammates traceFilter( this, COLLISION_GROUP_PLAYER_MOVEMENT, GetTeamNumber() );
|
|
unsigned int nMask = pThrower->GetTeamNumber() == TF_TEAM_RED ? CONTENTS_BLUETEAM : CONTENTS_REDTEAM;
|
|
nMask |= MASK_PLAYERSOLID;
|
|
|
|
// Try a few spots
|
|
FOR_EACH_VEC_BACK( m_vecTrailingPos, i )
|
|
{
|
|
// Try positions starting with the current, and moving back in time a bit
|
|
Vector vecStart = m_vecTrailingPos[i];
|
|
UTIL_TraceHull( vecStart, vecStart, VEC_HULL_MIN, VEC_HULL_MAX, nMask, &traceFilter, &traceHull );
|
|
|
|
if ( !traceHull.DidHit() )
|
|
{
|
|
// Place a teleport effect where they came from
|
|
const Vector& vecOrigin = pThrower->GetAbsOrigin();
|
|
CPVSFilter pvsFilter( vecOrigin );
|
|
TE_TFParticleEffect( pvsFilter, 0.f, GetExplodeEffectParticle(), vecOrigin, vec3_angle );
|
|
|
|
// Move 'em!
|
|
pThrower->Teleport( &vecStart, &pThrower->GetAbsAngles(), NULL );
|
|
|
|
// Do a zoom effect
|
|
pThrower->SetFOV( pThrower, 0.f, 0.3f, 120.f );
|
|
|
|
// Screen flash
|
|
color32 fadeColor = { 255, 255, 255, 100 };
|
|
UTIL_ScreenFade( pThrower, fadeColor, 0.25f, 0.4f, FFADE_IN );
|
|
|
|
if ( TFGameRules() )
|
|
{
|
|
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_TELEPORT, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
|
|
}
|
|
}
|
|
}
|
|
|
|
BaseClass::Explode( pTrace, bitsDamageType );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_GravityGrenade::Spawn( void )
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
m_flStartTime = -1.f;
|
|
m_flNextPulseEffectTime = -1.f;
|
|
m_bHitWorld = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_GravityGrenade::TrapThink( void )
|
|
{
|
|
if ( gpGlobals->curtime > m_flStartTime + 5.f )
|
|
{
|
|
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
|
|
SetTouch( NULL );
|
|
|
|
AddEffects( EF_NODRAW );
|
|
SetAbsVelocity( vec3_origin );
|
|
return;
|
|
}
|
|
|
|
PulseTrap();
|
|
|
|
SetContextThink( &CTFProjectile_GravityGrenade::TrapThink, gpGlobals->curtime + 0.15f, "TrapThink" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_GravityGrenade::OnHitWorld( void )
|
|
{
|
|
if ( !m_bHitWorld )
|
|
{
|
|
SetDetonateTimerLength( FLT_MAX );
|
|
|
|
m_bHitWorld = true;
|
|
m_flStartTime = gpGlobals->curtime;
|
|
|
|
AddSolidFlags( FSOLID_TRIGGER );
|
|
SetTouch( NULL );
|
|
|
|
SetContextThink( &CTFProjectile_GravityGrenade::TrapThink, gpGlobals->curtime, "TrapThink" );
|
|
}
|
|
|
|
BaseClass::OnHitWorld();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_GravityGrenade::PulseTrap( void )
|
|
{
|
|
const int nMaxEnts = 32;
|
|
|
|
Vector vecPos = GetAbsOrigin();
|
|
CBaseEntity *pObjects[ nMaxEnts ];
|
|
int nCount = UTIL_EntitiesInSphere( pObjects, nMaxEnts, vecPos, GetDamageRadius(), FL_CLIENT );
|
|
|
|
// Iterate through sphere's contents
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
CBaseCombatCharacter *pEntity = pObjects[i]->MyCombatCharacterPointer();
|
|
if ( !pEntity )
|
|
continue;
|
|
|
|
if ( InSameTeam( pEntity ) )
|
|
continue;
|
|
|
|
if ( !FVisible( pEntity, MASK_OPAQUE ) )
|
|
continue;
|
|
|
|
// Draw player toward us
|
|
Vector vecSourcePos = pEntity->GetAbsOrigin();
|
|
Vector vecTargetPos = GetAbsOrigin();
|
|
Vector vecVelocity = ( vecTargetPos - vecSourcePos ) * 2.f;
|
|
vecVelocity.z += 50.f;
|
|
|
|
if ( pEntity->GetFlags() & FL_ONGROUND )
|
|
{
|
|
vecVelocity.z += 150.f;
|
|
pEntity->SetGroundEntity( NULL );
|
|
pEntity->SetGroundChangeTime( gpGlobals->curtime + 0.5f );
|
|
}
|
|
|
|
pEntity->Teleport( NULL, NULL, &vecVelocity );
|
|
}
|
|
|
|
// NDebugOverlay::Sphere( vecPos, GetDamageRadius(), 0, 255, 0, false, 0.35f );
|
|
|
|
PulseEffects();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_GravityGrenade::PulseEffects( void )
|
|
{
|
|
if ( gpGlobals->curtime < m_flNextPulseEffectTime )
|
|
return;
|
|
|
|
Vector vecOrigin = GetAbsOrigin();
|
|
CPVSFilter filter( vecOrigin );
|
|
TE_TFParticleEffect( filter, 0.f, "Explosion_ShockWave_01", vecOrigin, vec3_angle );
|
|
EmitSound( filter, entindex(), "Weapon_Upgrade.ExplosiveHeadshot" );
|
|
|
|
m_flNextPulseEffectTime = gpGlobals->curtime + 1.f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// THROWABLE KNIFE
|
|
//-----------------------------------------------------------------------------
|
|
Vector CTFProjectile_ThrowingKnife::GetVelocityVector( const Vector &vecForward, const Vector &vecRight, const Vector &vecUp, float flCharge )
|
|
{
|
|
// Scale the projectile speed up to a maximum of 3000?
|
|
float flSpeed = RemapVal( flCharge, 0, 1.0f, GetProjectileSpeed(), GetProjectileMaxSpeed() );
|
|
|
|
return ( ( flSpeed * vecForward ) +
|
|
( flSpeed * 0.1 * vecUp ) );
|
|
}
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
void CTFProjectile_ThrowingKnife::OnHit( CBaseEntity *pOther )
|
|
{
|
|
if ( m_bHit )
|
|
return;
|
|
|
|
CTFPlayer *pVictim = dynamic_cast< CTFPlayer*>( pOther );
|
|
CTFPlayer *pOwner = dynamic_cast< CTFPlayer*>( GetThrower() );
|
|
|
|
if ( pVictim && pOwner && !pVictim->InSameTeam( pOwner ) )
|
|
{
|
|
CTraceFilterIgnoreTeammates tracefilter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
|
|
trace_t trace;
|
|
UTIL_TraceLine( GetAbsOrigin(), pVictim->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &tracefilter, &trace );
|
|
|
|
Vector entForward;
|
|
AngleVectors( pVictim->EyeAngles(), &entForward );
|
|
Vector toEnt = pVictim->GetAbsOrigin() - this->GetAbsOrigin();
|
|
toEnt.z = 0;
|
|
entForward.z = 0;
|
|
toEnt.NormalizeInPlace();
|
|
entForward.NormalizeInPlace();
|
|
|
|
// Is from behind?
|
|
bool bIsFromBehind = DotProduct( toEnt, entForward ) > 0.7071f;
|
|
|
|
// Apply Damage to Victim
|
|
CTakeDamageInfo info;
|
|
info.SetAttacker( GetThrower() );
|
|
info.SetInflictor( this );
|
|
info.SetWeapon( GetLauncher() );
|
|
info.SetDamageCustom( GetCustomDamageType() );
|
|
info.SetDamagePosition( GetAbsOrigin() );
|
|
|
|
int iDamageType = DMG_CLUB;
|
|
if ( bIsFromBehind )
|
|
{
|
|
iDamageType |= DMG_CRITICAL;
|
|
}
|
|
info.SetDamageType( iDamageType );
|
|
info.SetDamage( bIsFromBehind ? GetBackHitDamage() : GetDamage() );
|
|
|
|
pVictim->DispatchTraceAttack( info, toEnt, &trace );
|
|
ApplyMultiDamage();
|
|
|
|
CreateStickyAttachmentToTarget( pOwner, pVictim, &trace );
|
|
|
|
Explode();
|
|
return;
|
|
}
|
|
else // its a dud, mark as hit and let it roll around
|
|
{
|
|
m_bHit = true;
|
|
}
|
|
BaseClass::OnHit( pOther );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_ThrowingKnife::Detonate()
|
|
{
|
|
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
|
|
SetTouch( NULL );
|
|
|
|
AddEffects( EF_NODRAW );
|
|
SetAbsVelocity( vec3_origin );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_SmokeGrenade::Spawn( void )
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
m_flStartTime = -1.f;
|
|
m_bHitWorld = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_SmokeGrenade::OnHitWorld( void )
|
|
{
|
|
if ( !m_bHitWorld )
|
|
{
|
|
SetDetonateTimerLength( FLT_MAX );
|
|
// VPhysicsGetObject()->EnableMotion( false );
|
|
|
|
m_bHitWorld = true;
|
|
m_flStartTime = gpGlobals->curtime;
|
|
|
|
const char *pszSoundEffect = GetExplodeEffectSound();
|
|
if ( pszSoundEffect && pszSoundEffect[0] != '\0' )
|
|
{
|
|
EmitSound( pszSoundEffect );
|
|
}
|
|
|
|
AddSolidFlags( FSOLID_TRIGGER );
|
|
SetTouch( NULL );
|
|
|
|
SetContextThink( &CTFProjectile_SmokeGrenade::SmokeThink, gpGlobals->curtime, "SmokeThink" );
|
|
}
|
|
|
|
BaseClass::OnHitWorld();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFProjectile_SmokeGrenade::SmokeThink( void )
|
|
{
|
|
if ( gpGlobals->curtime > m_flStartTime + 6.f )
|
|
{
|
|
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
|
|
|
|
AddEffects( EF_NODRAW );
|
|
SetAbsVelocity( vec3_origin );
|
|
return;
|
|
}
|
|
|
|
CPVSFilter filter( GetAbsOrigin() );
|
|
TE_TFParticleEffect( filter, 0.f, "grenade_smoke_cycle", GetAbsOrigin(), vec3_angle );
|
|
|
|
const int nMaxEnts = 32;
|
|
|
|
Vector vecPos = GetAbsOrigin();
|
|
CBaseEntity *pObjects[ nMaxEnts ];
|
|
int nCount = UTIL_EntitiesInSphere( pObjects, nMaxEnts, vecPos, GetDamageRadius(), FL_CLIENT );
|
|
|
|
// Iterate through sphere's contents
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
CBaseCombatCharacter *pEntity = pObjects[i]->MyCombatCharacterPointer();
|
|
if ( !pEntity )
|
|
continue;
|
|
|
|
if ( !InSameTeam( pEntity ) )
|
|
continue;
|
|
|
|
if ( !FVisible( pEntity, MASK_OPAQUE ) )
|
|
continue;
|
|
|
|
if ( !pEntity->IsPlayer() )
|
|
continue;
|
|
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( pEntity );
|
|
if ( !pTFPlayer )
|
|
continue;
|
|
|
|
pTFPlayer->m_Shared.AddCond( TF_COND_OBSCURED_SMOKE, 0.5f );
|
|
}
|
|
|
|
// NDebugOverlay::Sphere( vecPos, GetDamageRadius(), 0, 255, 0, false, 0.35f );
|
|
|
|
SetContextThink( &CTFProjectile_SmokeGrenade::SmokeThink, gpGlobals->curtime + 0.3f, "SmokeThink" );
|
|
}
|
|
#endif // GAME_DLL
|
|
#endif // STAGING_ONLY
|