mirror of
https://github.com/alliedmodders/hl2sdk.git
synced 2025-12-12 00:28:22 +00:00
726 lines
22 KiB
C++
726 lines
22 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 );
|
|
|
|
|
|
// 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 );
|
|
|
|
|
|
#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] );
|
|
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() ) )
|
|
{
|
|
if ( pPlayer->m_Shared.IsImmuneToPushback() )
|
|
return;
|
|
|
|
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 );
|
|
|
|
float flForce = 300.0f * m_flChargePercent + 350.0f;
|
|
pPlayer->ApplyGenericPushbackImpulse( vecToTarget * flForce + Vector( 0, 0, flForce ), ToTFPlayer( GetThrower() ) );
|
|
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
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------
|