d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
47 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: cbffd53f8b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'cbffd53f8b'
${ noResults }
source-engine/game/server/tf/tf_projectile_arrow.cpp

1573 lines
48 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// TF Arrow
//
//=============================================================================
#include "cbase.h"
#include "tf_projectile_arrow.h"
#include "soundent.h"
#include "tf_fx.h"
#include "props.h"
#include "baseobject_shared.h"
#include "SpriteTrail.h"
#include "IEffects.h"
#include "te_effect_dispatch.h"
#include "collisionutils.h"
#include "bone_setup.h"
#include "decals.h"
#include "tf_player.h"
#include "tf_gamestats.h"
#include "tf_pumpkin_bomb.h"
#include "tf_weapon_shovel.h"
#include "player_vs_environment/tf_tank_boss.h"
#include "halloween/halloween_base_boss.h"
#include "halloween/merasmus/merasmus_trick_or_treat_prop.h"
#include "tf_logic_robot_destruction.h"
#include "tf_gamerules.h"
#include "bot/tf_bot.h"
#include "tf_weapon_medigun.h"
#include "soundenvelope.h"
//=============================================================================
//
// TF Arrow Projectile functions (Server specific).
//
#define ARROW_MODEL_GIB1 "models/weapons/w_models/w_arrow_gib1.mdl"
#define ARROW_MODEL_GIB2 "models/weapons/w_models/w_arrow_gib2.mdl"
#define ARROW_GRAVITY 0.3f
#define ARROW_THINK_CONTEXT "CTFProjectile_ArrowThink"
#define CLAW_TRAIL_RED "effects/repair_claw_trail_red.vmt"
#define CLAW_TRAIL_BLU "effects/repair_claw_trail_blue.vmt"
#define CLAW_GIB1 "models/weapons/w_models/w_repair_claw_gib1.mdl"
#define CLAW_GIB2 "models/weapons/w_models/w_repair_claw_gib2.mdl"
#define CLAW_REPAIR_EFFECT_BLU "repair_claw_heal_blue"
#define CLAW_REPAIR_EFFECT_RED "repair_claw_heal_red"
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_projectile_arrow, CTFProjectile_Arrow );
PRECACHE_WEAPON_REGISTER( tf_projectile_arrow );
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_Arrow, DT_TFProjectile_Arrow )
BEGIN_NETWORK_TABLE( CTFProjectile_Arrow, DT_TFProjectile_Arrow )
SendPropBool( SENDINFO( m_bArrowAlight ) ),
SendPropBool( SENDINFO( m_bCritical ) ),
SendPropInt( SENDINFO( m_iProjectileType ) ),
END_NETWORK_TABLE()
BEGIN_DATADESC( CTFProjectile_Arrow )
DEFINE_THINKFUNC( ImpactThink ),
END_DATADESC()
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_projectile_healing_bolt, CTFProjectile_HealingBolt );
PRECACHE_WEAPON_REGISTER( tf_projectile_healing_bolt );
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_HealingBolt, DT_TFProjectile_HealingBolt )
BEGIN_NETWORK_TABLE( CTFProjectile_HealingBolt, DT_TFProjectile_HealingBolt )
END_NETWORK_TABLE()
BEGIN_DATADESC( CTFProjectile_HealingBolt )
END_DATADESC()
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_projectile_grapplinghook, CTFProjectile_GrapplingHook );
PRECACHE_WEAPON_REGISTER( tf_projectile_grapplinghook );
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_GrapplingHook, DT_TFProjectile_GrapplingHook )
BEGIN_NETWORK_TABLE( CTFProjectile_GrapplingHook, DT_TFProjectile_GrapplingHook )
END_NETWORK_TABLE()
BEGIN_DATADESC( CTFProjectile_GrapplingHook )
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose: Helper to set a grappling hook target on all healers of this player
//-----------------------------------------------------------------------------
static void SetMedicsGrapplingHookTarget( CTFPlayer *pTFPlayer, CBaseEntity *pGrappleTarget )
{
int i;
int iNumHealers = pTFPlayer->m_Shared.GetNumHealers();
for ( i = 0 ; i < iNumHealers ; i++ )
{
CTFPlayer *pMedic = ToTFPlayer( pTFPlayer->m_Shared.GetHealerByIndex( i ) );
// Only want medics who are directly healing us with their medigun, not e.g. AoE healers.
if ( pMedic && ToTFPlayer ( pMedic->MedicGetHealTarget() ) == pTFPlayer )
{
pMedic->SetGrapplingHookTarget( pGrappleTarget );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Arrow::CTFProjectile_Arrow()
{
m_flImpactTime = 0.0f;
m_flTrailLife = 0.f;
m_pTrail = NULL;
m_bStruckEnemy = false;
m_bArrowAlight = false;
m_iDeflected = 0;
m_bCritical = false;
m_flInitTime = 0;
m_bPenetrate = false;
m_iProjectileType = TF_PROJECTILE_ARROW;
m_iWeaponId = TF_WEAPON_COMPOUND_BOW;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Arrow::~CTFProjectile_Arrow()
{
m_HitEntities.Purge();
}
static const char* GetArrowEntityName( ProjectileType_t projectileType )
{
switch ( projectileType )
{
case TF_PROJECTILE_HEALING_BOLT:
case TF_PROJECTILE_FESTIVE_HEALING_BOLT:
#ifdef STAGING_ONLY
case TF_PROJECTILE_MILK_BOLT:
#endif
return "tf_projectile_healing_bolt";
case TF_PROJECTILE_GRAPPLINGHOOK:
return "tf_projectile_grapplinghook";
default:
return "tf_projectile_arrow";
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Arrow *CTFProjectile_Arrow::Create( const Vector &vecOrigin, const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
const char* pszArrowEntityName = GetArrowEntityName( projectileType );
CTFProjectile_Arrow *pArrow = static_cast<CTFProjectile_Arrow*>( CBaseEntity::Create( pszArrowEntityName, vecOrigin, vecAngles, pOwner ) );
if ( pArrow )
{
pArrow->InitArrow( vecAngles, fSpeed, fGravity, projectileType, pOwner, pScorer );
}
return pArrow;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::InitArrow( const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
// Initialize the owner.
SetOwnerEntity( pOwner );
// Set team.
ChangeTeam( pOwner->GetTeamNumber() );
// must override projectile type before Spawn for proper model
m_iProjectileType = projectileType;
// Spawn.
Spawn();
SetGravity( fGravity );
SetCritical( true );
// Setup the initial velocity.
Vector vecForward, vecRight, vecUp;
AngleVectors( vecAngles, &vecForward, &vecRight, &vecUp );
Vector vecVelocity = vecForward * fSpeed;
SetAbsVelocity( vecVelocity );
SetupInitialTransmittedGrenadeVelocity( vecVelocity );
// Setup the initial angles.
QAngle angles;
VectorAngles( vecVelocity, angles );
SetAbsAngles( angles );
// Save the scoring player.
SetScorer( pScorer );
// Create a trail.
CreateTrail();
// Add ourselves to the hit entities list so we dont shoot ourselves
m_HitEntities.AddToTail( pOwner->entindex() );
m_flInitTime = gpGlobals->curtime;
#ifdef STAGING_ONLY
if ( m_iProjectileType == TF_PROJECTILE_SNIPERBULLET )
{
CTFPlayer* pTFOwner = ToTFPlayer( pOwner );
m_bFiredWhileZoomed = ( pTFOwner && pTFOwner->m_Shared.InCond( TF_COND_ZOOMED ) );
}
else
#endif // STAGING_ONLY
{
m_bFiredWhileZoomed = false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::Spawn()
{
if ( m_iProjectileType == TF_PROJECTILE_BUILDING_REPAIR_BOLT )
{
SetModel( g_pszArrowModels[MODEL_ARROW_BUILDING_REPAIR] );
m_iWeaponId = TF_WEAPON_SHOTGUN_BUILDING_RESCUE;
}
else if ( m_iProjectileType == TF_PROJECTILE_FESTIVE_ARROW )
{
SetModel( g_pszArrowModels[MODEL_FESTIVE_ARROW_REGULAR] );
}
else if ( m_iProjectileType == TF_PROJECTILE_HEALING_BOLT
#ifdef STAGING_ONLY
|| m_iProjectileType == TF_PROJECTILE_MILK_BOLT
#endif
) {
SetModel( g_pszArrowModels[MODEL_SYRINGE] );
SetModelScale( 3.0f );
}
else if ( m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT )
{
SetModel( g_pszArrowModels[MODEL_FESTIVE_HEALING_BOLT] );
SetModelScale( 3.0f );
}
#ifdef STAGING_ONLY
else if ( m_iProjectileType == TF_PROJECTILE_SNIPERBULLET )
{
SetModel( g_pszArrowModels[MODEL_SYRINGE] );
//SetModelScale( 3.0f );
}
#endif // STAGING_ONLY
else if ( m_iProjectileType == TF_PROJECTILE_GRAPPLINGHOOK )
{
SetModel( g_pszArrowModels[MODEL_GRAPPLINGHOOK] );
}
else
{
SetModel( g_pszArrowModels[MODEL_ARROW_REGULAR] );
}
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
UTIL_SetSize( this, Vector( -1.0f, -1.0f, -1.0f ), Vector( 1.0f, 1.0f, 1.0f ) );
SetSolid( SOLID_BBOX );
SetCollisionGroup( TFCOLLISION_GROUP_ROCKETS );
AddEffects( EF_NOSHADOW );
AddFlag( FL_GRENADE );
SetTouch( &CTFProjectile_Arrow::ArrowTouch );
// Set team.
m_nSkin = GetArrowSkin();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::Precache()
{
int arrow_model = PrecacheModel( g_pszArrowModels[MODEL_ARROW_REGULAR] );
int claw_model = PrecacheModel( g_pszArrowModels[MODEL_ARROW_BUILDING_REPAIR] );
int festive_arrow_model = PrecacheModel( g_pszArrowModels[MODEL_FESTIVE_ARROW_REGULAR] );
PrecacheModel( g_pszArrowModels[MODEL_FESTIVE_HEALING_BOLT] );
PrecacheGibsForModel( arrow_model );
PrecacheGibsForModel( claw_model );
PrecacheGibsForModel( festive_arrow_model );
//PrecacheGibsForModel( festive_healing_arrow_model );
PrecacheModel( "effects/arrowtrail_red.vmt" );
PrecacheModel( "effects/arrowtrail_blu.vmt" );
PrecacheModel( "effects/healingtrail_red.vmt" );
PrecacheModel( "effects/healingtrail_blu.vmt" );
PrecacheModel( CLAW_TRAIL_RED );
PrecacheModel( CLAW_TRAIL_BLU );
PrecacheParticleSystem( CLAW_REPAIR_EFFECT_BLU );
PrecacheParticleSystem( CLAW_REPAIR_EFFECT_RED );
PrecacheScriptSound( "Weapon_Arrow.ImpactFlesh" );
PrecacheScriptSound( "Weapon_Arrow.ImpactMetal" );
PrecacheScriptSound( "Weapon_Arrow.ImpactWood" );
PrecacheScriptSound( "Weapon_Arrow.ImpactConcrete" );
PrecacheScriptSound( "Weapon_Arrow.Nearmiss" );
PrecacheScriptSound( "Weapon_Arrow.ImpactFleshCrossbowHeal" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::SetScorer( CBaseEntity *pScorer )
{
m_Scorer = pScorer;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBasePlayer *CTFProjectile_Arrow::GetScorer( void )
{
return dynamic_cast<CBasePlayer *>( m_Scorer.Get() );
}
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::CanHeadshot()
{
CBaseEntity *pOwner = GetScorer();
if ( pOwner == NULL )
return false;
if ( m_iProjectileType == TF_PROJECTILE_BUILDING_REPAIR_BOLT
|| m_iProjectileType == TF_PROJECTILE_HEALING_BOLT
|| m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT
#ifdef STAGING_ONLY
|| m_iProjectileType == TF_PROJECTILE_MILK_BOLT
#endif
) {
return false;
}
#ifdef STAGING_ONLY
if ( m_iProjectileType == TF_PROJECTILE_SNIPERBULLET )
{
return m_bFiredWhileZoomed;
}
#endif // STAGING_ONLY
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Healing bolt damage.
//-----------------------------------------------------------------------------
float CTFProjectile_Arrow::GetDamage()
{
if ( m_iProjectileType == TF_PROJECTILE_HEALING_BOLT
|| m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT
#ifdef STAGING_ONLY
|| m_iProjectileType == TF_PROJECTILE_MILK_BOLT
#endif
) {
float lifeTimeScale = RemapValClamped( gpGlobals->curtime - m_flInitTime, 0.0f, 0.6f, 0.5f, 1.0f );
return m_flDamage * lifeTimeScale;
}
return BaseClass::GetDamage();
}
//-----------------------------------------------------------------------------
// Purpose: Moves the arrow to a particular bbox.
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::PositionArrowOnBone( mstudiobbox_t *pBox, CBaseAnimating *pOtherAnim )
{
CStudioHdr *pStudioHdr = pOtherAnim->GetModelPtr();
if ( !pStudioHdr )
return false;
mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( pOtherAnim->GetHitboxSet() );
if ( !set )
return false;
if ( !set->numhitboxes ) // Target must have hit boxes.
return false;
if ( pBox->bone < 0 || pBox->bone >= pStudioHdr->numbones() ) // Bone index must be valid.
return false;
CBoneCache *pCache = pOtherAnim->GetBoneCache();
if ( !pCache )
return false;
matrix3x4_t *bone_matrix = pCache->GetCachedBone( pBox->bone );
if ( !bone_matrix )
return false;
Vector vecBoxAbsMins, vecBoxAbsMaxs;
TransformAABB( *bone_matrix, pBox->bbmin, pBox->bbmax, vecBoxAbsMins, vecBoxAbsMaxs );
// Adjust the arrow so it isn't exactly in the center of the box.
Vector position;
Vector vecDelta = vecBoxAbsMaxs - vecBoxAbsMins;
float frand = (float) rand() / VALVE_RAND_MAX;
position.x = vecBoxAbsMins.x + vecDelta.x*0.6f - vecDelta.x*frand*0.2f;
frand = (float) rand() / VALVE_RAND_MAX;
position.y = vecBoxAbsMins.y + vecDelta.y*0.6f - vecDelta.y*frand*0.2f;
frand = (float) rand() / VALVE_RAND_MAX;
position.z = vecBoxAbsMins.z + vecDelta.z*0.6f - vecDelta.z*frand*0.2f;
SetAbsOrigin( position );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: This was written after PositionArrowOnBone, but the two might be mergable?
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::GetBoneAttachmentInfo( mstudiobbox_t *pBox, CBaseAnimating *pOtherAnim, Vector &bonePosition, QAngle &boneAngles, int &boneIndexAttached, int &physicsBoneIndex )
{
// Find a bone to stick to.
matrix3x4_t arrowWorldSpace;
MatrixCopy( EntityToWorldTransform(), arrowWorldSpace );
// Get the bone info so we can follow the bone.
boneIndexAttached = pBox->bone;
physicsBoneIndex = pOtherAnim->GetPhysicsBone( boneIndexAttached );
matrix3x4_t boneToWorld;
pOtherAnim->GetBoneTransform( boneIndexAttached, boneToWorld );
Vector attachedBonePos;
QAngle attachedBoneAngles;
pOtherAnim->GetBonePosition( boneIndexAttached, attachedBonePos, attachedBoneAngles );
// Transform my current position/orientation into the hit bone's space.
matrix3x4_t worldToBone, localMatrix;
MatrixInvert( boneToWorld, worldToBone );
ConcatTransforms( worldToBone, arrowWorldSpace, localMatrix );
MatrixAngles( localMatrix, boneAngles, bonePosition );
}
//-----------------------------------------------------------------------------
int CTFProjectile_Arrow::GetProjectileType ( void ) const
{
return m_iProjectileType;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::StrikeTarget( mstudiobbox_t *pBox, CBaseEntity *pOther )
{
if ( !pOther )
return false;
// Different path for arrows that heal friendly buildings.
if ( pOther->IsBaseObject() )
{
if ( OnArrowImpactObject( pOther ) )
{
return false;
}
}
// Block and break on invulnerable players
CTFPlayer *pTFPlayerOther = ToTFPlayer( pOther );
if ( pTFPlayerOther && pTFPlayerOther->m_Shared.IsInvulnerable() )
return false;
CBaseAnimating *pOtherAnim = dynamic_cast< CBaseAnimating* >(pOther);
if ( !pOtherAnim )
return false;
bool bBreakArrow = IsBreakable() && ( ( dynamic_cast< CTFTankBoss* >( pOther ) != NULL ) || ( dynamic_cast< CHalloweenBaseBoss* >( pOther ) != NULL ) );
// Position the arrow so its on the bone, within a reasonable region defined by the bbox.
if ( !m_bPenetrate && !bBreakArrow )
{
if ( !PositionArrowOnBone( pBox, pOtherAnim ) )
{
return false;
}
}
//
const Vector &vecOrigin = GetAbsOrigin();
Vector vecVelocity = GetAbsVelocity();
int nDamageCustom = 0;
bool bApplyEffect = true;
int nDamageType = GetDamageType();
// Are we a headshot?
bool bHeadshot = false;
if ( pBox->group == HITGROUP_HEAD && CanHeadshot() )
{
bHeadshot = true;
}
// Damage the entity we struck.
CBaseEntity *pAttacker = GetScorer();
if ( !pAttacker )
{
// likely not launched by a player
pAttacker = GetOwnerEntity();
}
if ( pAttacker )
{
// Check if we have the penetrate attribute. We don't want
// to strike the same target multiple times.
if ( m_bPenetrate )
{
// Don't strike the same target again
if ( m_HitEntities.Find( pOther->entindex() ) != m_HitEntities.InvalidIndex() )
{
bApplyEffect = false;
}
else
{
m_HitEntities.AddToTail( pOther->entindex() );
}
}
if ( !InSameTeam( pOther ) )
{
IScorer *pScorerInterface = dynamic_cast<IScorer*>( pAttacker );
if ( pScorerInterface )
{
pAttacker = pScorerInterface->GetScorer();
}
if ( m_bArrowAlight )
{
nDamageType |= DMG_IGNITE;
nDamageCustom = TF_DMG_CUSTOM_FLYINGBURN;
}
if ( bHeadshot )
{
nDamageType |= DMG_CRITICAL;
nDamageCustom = TF_DMG_CUSTOM_HEADSHOT;
}
if ( m_bCritical )
{
nDamageType |= DMG_CRITICAL;
}
#ifdef GAME_DLL
if ( TFGameRules()->IsPVEModeControlled( pAttacker ) )
{
// scenario bots cant crit (unless they always do)
CTFBot *bot = ToTFBot( pAttacker );
if ( !bot || !bot->HasAttribute( CTFBot::ALWAYS_CRIT ) )
{
nDamageType &= ~DMG_CRITICAL;
}
}
#endif
// Damage
if ( bApplyEffect )
{
// Apply Milk First so we can get health from this
if ( m_bApplyMilkOnHit && pOther->IsPlayer() )
{
CTFPlayer *pVictim = ToTFPlayer( pOther );
if ( pVictim && pVictim->m_Shared.CanBeDebuffed() && pVictim->CanGetWet() )
{
// duration is based on damage
float flDuration = RemapValClamped( GetDamage(), 25.0f, 75.0f, 6.0f, 10.0f );
pVictim->m_Shared.AddCond( TF_COND_MAD_MILK, flDuration, pAttacker );
pVictim->m_Shared.SetPeeAttacker( ToTFPlayer( pAttacker ) );
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_JARATE_HIT );
}
}
CTakeDamageInfo info( this, pAttacker, m_hLauncher, vecVelocity, vecOrigin, GetDamage(), nDamageType, nDamageCustom );
pOther->TakeDamage( info );
// Play an impact sound.
ImpactSound( "Weapon_Arrow.ImpactFlesh", true );
}
}
else if ( pOther->IsPlayer() ) // Hit a team-mate.
{
// Heal
if ( bApplyEffect )
{
ImpactTeamPlayer( dynamic_cast<CTFPlayer*>( pOther ) );
}
}
}
if ( !m_bPenetrate && !bBreakArrow )
{
OnArrowImpact( pBox, pOther, pAttacker );
}
// Perform a blood mesh decal trace.
trace_t tr;
Vector start = vecOrigin - vecVelocity * gpGlobals->frametime;
Vector end = vecOrigin + vecVelocity * gpGlobals->frametime;
CTraceFilterCollisionArrows filter( this, GetOwnerEntity() );
UTIL_TraceLine( start, end, CONTENTS_HITBOX|CONTENTS_MONSTER|CONTENTS_SOLID, &filter, &tr );
UTIL_ImpactTrace( &tr, 0 );
// Break it?
if ( bBreakArrow )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::OnArrowImpact( mstudiobbox_t *pBox, CBaseEntity *pOther, CBaseEntity *pAttacker )
{
CBaseAnimating *pOtherAnim = dynamic_cast< CBaseAnimating* >(pOther);
if ( !pOtherAnim )
return;
const Vector &vecOrigin = GetAbsOrigin();
Vector vecVelocity = GetAbsVelocity();
Vector bonePosition = vec3_origin;
QAngle boneAngles = QAngle(0,0,0);
int boneIndexAttached = -1;
int physicsBoneIndex = -1;
GetBoneAttachmentInfo( pBox, pOtherAnim, bonePosition, boneAngles, boneIndexAttached, physicsBoneIndex );
bool bSendImpactMessage = true;
// Did we kill the target?
if ( !pOther->IsAlive() && pOther->IsPlayer() )
{
CTFPlayer *pTFPlayerOther = dynamic_cast<CTFPlayer*>(pOther);
if ( pTFPlayerOther && pTFPlayerOther->m_hRagdoll )
{
VectorNormalize( vecVelocity );
if ( CheckRagdollPinned( vecOrigin, vecVelocity, boneIndexAttached, physicsBoneIndex, pTFPlayerOther->m_hRagdoll, pBox->group, pTFPlayerOther->entindex() ) )
{
pTFPlayerOther->StopRagdollDeathAnim();
bSendImpactMessage = false;
}
}
}
// Notify relevant clients of an arrow impact.
if ( bSendImpactMessage )
{
IGameEvent * event = gameeventmanager->CreateEvent( "arrow_impact" );
if ( event )
{
event->SetInt( "attachedEntity", pOther->entindex() );
event->SetInt( "shooter", pAttacker ? pAttacker->entindex() : 0 );
event->SetInt( "attachedEntity", pOther->entindex() );
event->SetInt( "boneIndexAttached", boneIndexAttached );
event->SetFloat( "bonePositionX", bonePosition.x );
event->SetFloat( "bonePositionY", bonePosition.y );
event->SetFloat( "bonePositionZ", bonePosition.z );
event->SetFloat( "boneAnglesX", boneAngles.x );
event->SetFloat( "boneAnglesY", boneAngles.y );
event->SetFloat( "boneAnglesZ", boneAngles.z );
event->SetInt( "projectileType", GetProjectileType() );
gameeventmanager->FireEvent( event );
}
}
FadeOut( 3.0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::OnArrowImpactObject( CBaseEntity *pOther )
{
if ( InSameTeam( pOther ) )
{
BuildingHealingArrow( pOther );
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::ImpactThink( void )
{
}
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::BuildingHealingArrow( CBaseEntity *pOther )
{
// This arrow impacted a building
// If its a building on our team, heal it
if ( !pOther->IsBaseObject() )
return;
CBaseEntity *pAttacker = GetScorer();
if ( pAttacker == NULL )
return;
// if not on our team, forget about it
if ( GetTeamNumber() != pOther->GetTeamNumber() )
return;
int iArrowsHealBuildings = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iArrowsHealBuildings, arrow_heals_buildings );
if ( iArrowsHealBuildings == 0 )
return;
CBaseObject *pBuilding = dynamic_cast< CBaseObject * >( pOther );
if ( !pBuilding || !pBuilding->CanBeRepaired() || pBuilding->HasSapper() || pBuilding->IsPlasmaDisabled() || pBuilding->IsBuilding() || pBuilding->IsPlacing() )
return;
// if building is sheilded, reduce health gain
if ( pBuilding->GetShieldLevel() == SHIELD_NORMAL )
{
iArrowsHealBuildings *= SHIELD_NORMAL_VALUE;
}
float flNewHealth = MIN( pBuilding->GetMaxHealth(), (int)pBuilding->GetHealth() + iArrowsHealBuildings );
int iHealthAdded = (int)(flNewHealth - pBuilding->GetHealth());
if ( iHealthAdded > 0 )
{
pBuilding->SetHealth( flNewHealth );
IGameEvent * event = gameeventmanager->CreateEvent( "building_healed" );
if ( event )
{
// HLTV event priority, not transmitted
event->SetInt( "priority", 1 );
// Healed by another player.
event->SetInt( "building", pBuilding->entindex() );
event->SetInt( "healer", pAttacker->entindex() );
event->SetInt( "amount", iHealthAdded );
gameeventmanager->FireEvent( event );
}
const char *pParticleName = GetTeamNumber() == TF_TEAM_BLUE ? CLAW_REPAIR_EFFECT_BLU : CLAW_REPAIR_EFFECT_RED;
CPVSFilter filter( GetAbsOrigin() );
TE_TFParticleEffect( filter, 0.0, pParticleName, GetAbsOrigin(), vec3_angle );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFProjectile_Arrow::GetArrowSkin() const
{
int nTeam = GetTeamNumber();
if ( GetOwnerEntity() && GetOwnerEntity()->IsPlayer() )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( pOwner && pOwner->IsPlayerClass( TF_CLASS_SPY ) && pOwner->m_Shared.InCond( TF_COND_DISGUISED ) )
{
nTeam = pOwner->m_Shared.GetDisguiseTeam();
}
}
return ( nTeam == TF_TEAM_BLUE ) ? 1 : 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::OnArrowMissAllPlayers()
{
CTFPlayer* pOwner = ToTFPlayer( GetOwnerEntity() );
if( pOwner && pOwner->IsPlayerClass( TF_CLASS_SNIPER ) )
{
EconEntity_OnOwnerKillEaterEventNoPartner( assert_cast<CEconEntity *>( m_hLauncher.Get() ), pOwner, kKillEaterEvent_NEGATIVE_SniperShotsMissed );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::ArrowTouch( CBaseEntity *pOther )
{
// Safety net hack:
// We routinely introduce new entity types, and arrows
// are repeat-offenders at not getting along with them.
// If enough time goes by, just remove the arrow.
float flAliveTime = gpGlobals->curtime - m_flInitTime;
if ( flAliveTime >= 10.f )
{
Warning( "Arrow alive for %f3.2\n seconds", flAliveTime );
UTIL_Remove( this );
}
if ( m_bStruckEnemy || (GetMoveType() == MOVETYPE_NONE) )
return;
if ( !pOther )
return;
bool bShield = pOther->IsCombatItem() && !InSameTeam( pOther );
CTFPumpkinBomb *pPumpkinBomb = dynamic_cast< CTFPumpkinBomb * >( pOther );
if ( pOther->IsSolidFlagSet( FSOLID_TRIGGER | FSOLID_VOLUME_CONTENTS ) && !pPumpkinBomb && !bShield )
return;
// test against combat characters, which include players, engineer buildings, and NPCs
CBaseCombatCharacter *pOtherCombatCharacter = dynamic_cast< CBaseCombatCharacter * >( pOther );
if ( !pOtherCombatCharacter )
{
// It might be a track train with boss parented
pOtherCombatCharacter = dynamic_cast< CBaseCombatCharacter * >( pOther->FirstMoveChild() );
if ( pOtherCombatCharacter )
{
pOther = pOtherCombatCharacter;
}
}
CTFMerasmusTrickOrTreatProp *pMerasmusProp = dynamic_cast< CTFMerasmusTrickOrTreatProp* >( pOther );
CTFRobotDestruction_Robot *pRobot = dynamic_cast< CTFRobotDestruction_Robot* >( pOther );
if ( pOther->IsWorld() || ( !pOtherCombatCharacter && !pPumpkinBomb && !pMerasmusProp && !bShield && !pRobot ) )
{
// Check to see if we struck the skybox.
CheckSkyboxImpact( pOther );
// If we've only got 1 entity in the hit list (the attacker by default) and we've not been deflected
// then we can consider this arrow to have completely missed all players.
if( m_HitEntities.Count() == 1 && GetDeflected() == 0 )
{
OnArrowMissAllPlayers();
}
return;
}
CBaseAnimating *pAnimOther = dynamic_cast<CBaseAnimating*>(pOther);
CStudioHdr *pStudioHdr = NULL;
mstudiohitboxset_t *set = NULL;
if ( pAnimOther )
{
pStudioHdr = pAnimOther->GetModelPtr();
if ( pStudioHdr )
{
set = pStudioHdr->pHitboxSet( pAnimOther->GetHitboxSet() );
}
}
if ( !pAnimOther || !pStudioHdr || !set )
{
// Whatever we hit doesn't have hitboxes. Ignore it.
UTIL_Remove( this );
return;
}
// We struck the collision box of a player or a buildable object.
// Trace forward to see if we struck a hitbox.
CTraceFilterCollisionArrows filter( this, GetOwnerEntity() );
Vector start = GetAbsOrigin();
Vector vel = GetAbsVelocity();
trace_t tr;
UTIL_TraceLine( start, start + vel * gpGlobals->frametime, CONTENTS_HITBOX|CONTENTS_MONSTER|CONTENTS_SOLID, &filter, &tr );
// If we hit a hitbox, stop tracing.
mstudiobbox_t *closest_box = NULL;
if ( tr.m_pEnt && tr.m_pEnt->GetTeamNumber() != GetTeamNumber() )
{
// This means the arrow was true and was flying directly at a hitbox on the target.
// We'll attach to that hitbox.
closest_box = set->pHitbox( tr.hitbox );
}
if ( !closest_box )
{
// Locate the hitbox closest to our point of impact on the collision box.
Vector position, start, forward;
QAngle angles;
float closest_dist = 99999;
// Intense, but extremely accurate:
AngleVectors( GetAbsAngles(), &forward );
start = GetAbsOrigin() + forward*16;
for ( int i = 0; i < set->numhitboxes; i++ )
{
mstudiobbox_t *pbox = set->pHitbox( i );
pAnimOther->GetBonePosition( pbox->bone, position, angles );
Ray_t ray;
ray.Init( start, position );
trace_t tr;
IntersectRayWithBox( ray, position+pbox->bbmin, position+pbox->bbmax, 0.f, &tr );
float dist = tr.endpos.DistTo( start );
if ( dist < closest_dist )
{
closest_dist = dist;
closest_box = pbox;
}
}
}
if ( closest_box )
{
// See if we're supposed to stick in the target.
bool bStrike = StrikeTarget( closest_box, pOther );
if ( bStrike && !m_bPenetrate)
{
// If we're here, it means StrikeTarget() called FadeOut( 3.0 )
SetAbsOrigin( start );
}
if ( !bStrike || bShield )
{
BreakArrow();
}
// Slightly confusing. If we're here, the arrow stopped at the
// target and will fade or break. Setting this prevents the
// touch code from re-running during the delay.
if ( !m_bPenetrate )
{
m_bStruckEnemy = true;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::CheckSkyboxImpact( CBaseEntity *pOther )
{
trace_t tr;
Vector velDir = GetAbsVelocity();
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.
FadeOut( 3.f );
return;
}
if ( !pOther->IsWorld() )
{
BreakArrow();
}
else
{
CEffectData data;
data.m_vOrigin = tr.endpos;
data.m_vNormal = velDir;
data.m_nEntIndex = 0;/*tr.fraction != 1.0f;*/
data.m_nAttachmentIndex = 0;
data.m_nMaterial = 0;
data.m_fFlags = GetProjectileType();
data.m_nColor = GetArrowSkin();
DispatchEffect( "TFBoltImpact", data );
FadeOut( 3.f );
// Play an impact sound.
const char* pszSoundName = "Weapon_Arrow.ImpactMetal";
surfacedata_t *psurf = physprops->GetSurfaceData( tr.surface.surfaceProps );
if ( psurf )
{
switch ( psurf->game.material )
{
case CHAR_TEX_GRATE:
case CHAR_TEX_METAL:
pszSoundName = "Weapon_Arrow.ImpactMetal";
break;
case CHAR_TEX_CONCRETE:
pszSoundName = "Weapon_Arrow.ImpactConcrete";
break;
case CHAR_TEX_WOOD:
pszSoundName = "Weapon_Arrow.ImpactWood";
break;
}
}
ImpactSound( pszSoundName );
}
}
//-----------------------------------------------------------------------------
// Purpose: Plays an impact sound. Louder for the attacker.
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::ImpactSound( const char *pszSoundName, bool bLoudForAttacker )
{
CTFPlayer *pAttacker = ToTFPlayer( GetScorer() );
if ( !pAttacker )
return;
if ( bLoudForAttacker )
{
float soundlen = 0;
EmitSound_t params;
params.m_flSoundTime = 0;
params.m_pSoundName = pszSoundName;
params.m_pflSoundDuration = &soundlen;
CPASFilter filter( GetAbsOrigin() );
filter.RemoveRecipient( ToTFPlayer(pAttacker) );
EmitSound( filter, entindex(), params );
CSingleUserRecipientFilter attackerFilter( ToTFPlayer(pAttacker) );
EmitSound( attackerFilter, pAttacker->entindex(), params );
}
else
{
EmitSound( pszSoundName );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::BreakArrow()
{
FadeOut( 3.f );
CPVSFilter filter( GetAbsOrigin() );
UserMessageBegin( filter, "BreakModel" );
WRITE_SHORT( GetModelIndex() );
WRITE_VEC3COORD( GetAbsOrigin() );
WRITE_ANGLES( GetAbsAngles() );
WRITE_SHORT( m_nSkin );
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::CheckRagdollPinned( const Vector &start, const Vector &vel, int boneIndexAttached, int physicsBoneIndex, CBaseEntity *pOther, int iHitGroup, int iVictim )
{
// Pin to the wall.
trace_t tr;
UTIL_TraceLine( start, start + vel * 125, MASK_BLOCKLOS, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0f && tr.DidHitWorld() )
{
CEffectData data;
data.m_vOrigin = tr.endpos;
data.m_vNormal = vel;
data.m_nEntIndex = pOther->entindex();
data.m_nAttachmentIndex = boneIndexAttached;
data.m_nMaterial = physicsBoneIndex;
data.m_nDamageType = iHitGroup;
data.m_nSurfaceProp = iVictim;
data.m_fFlags = GetProjectileType();
data.m_nColor = GetArrowSkin();
if ( GetScorer() )
{
data.m_nHitBox = GetScorer()->entindex();
}
DispatchEffect( "TFBoltImpact", data );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::FadeOut( int iTime )
{
SetMoveType( MOVETYPE_NONE );
SetAbsVelocity( vec3_origin );
AddSolidFlags( FSOLID_NOT_SOLID );
AddEffects( EF_NODRAW );
// Start remove timer.
SetContextThink( &CTFProjectile_Arrow::RemoveThink, gpGlobals->curtime + iTime, "ARROW_REMOVE_THINK" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::RemoveThink( void )
{
UTIL_Remove( this );
}
//-----------------------------------------------------------------------------
const char *CTFProjectile_Arrow::GetTrailParticleName( void )
{
if ( m_iProjectileType == TF_PROJECTILE_BUILDING_REPAIR_BOLT )
{
return ( GetTeamNumber() == TF_TEAM_RED ) ? CLAW_TRAIL_RED : CLAW_TRAIL_BLU;
}
else if ( m_iProjectileType == TF_PROJECTILE_HEALING_BOLT || m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT )
{
return ( GetTeamNumber() == TF_TEAM_RED ) ? "effects/healingtrail_red.vmt" : "effects/healingtrail_blu.vmt";
}
return ( GetTeamNumber() == TF_TEAM_RED ) ? "effects/arrowtrail_red.vmt" : "effects/arrowtrail_blu.vmt";
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::CreateTrail( void )
{
if ( IsDormant() )
return;
if ( !m_pTrail )
{
int width = 3;
switch ( m_iProjectileType )
{
case TF_PROJECTILE_BUILDING_REPAIR_BOLT:
width = 5;
break;
case TF_PROJECTILE_HEALING_BOLT:
case TF_PROJECTILE_FESTIVE_HEALING_BOLT:
case TF_PROJECTILE_GRAPPLINGHOOK:
#ifdef STAGING_ONLY
case TF_PROJECTILE_SNIPERBULLET:
#endif // STAGING_ONLY
return; // do not create arrow trail for healing bolt, use particle instead (client only)
}
const char *pTrailTeamName = GetTrailParticleName();
CSpriteTrail *pTempTrail = NULL;
pTempTrail = CSpriteTrail::SpriteTrailCreate( pTrailTeamName, GetAbsOrigin(), true );
pTempTrail->FollowEntity( this );
pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 255, kRenderFxNone );
pTempTrail->SetStartWidth( width );
pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
pTempTrail->SetLifeTime( 0.3 );
pTempTrail->TurnOn();
pTempTrail->SetAttachment( this, 0 );
m_pTrail = pTempTrail;
SetContextThink( &CTFProjectile_Arrow::RemoveTrail, gpGlobals->curtime + 3, "FadeTrail");
}
}
//-----------------------------------------------------------------------------
// Purpose: Fade and kill the trail
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::RemoveTrail( void )
{
if ( !m_pTrail )
return;
if ( m_pTrail )
{
if ( m_flTrailLife <= 0 )
{
UTIL_Remove( m_pTrail );
m_flTrailLife = 1.0f;
}
else
{
float fAlpha = 128 * m_flTrailLife;
CSpriteTrail *pTempTrail = dynamic_cast< CSpriteTrail*>( m_pTrail.Get() );
if ( pTempTrail )
{
pTempTrail->SetBrightness( int(fAlpha) );
}
m_flTrailLife = m_flTrailLife - 0.1f;
SetContextThink( &CTFProjectile_Arrow::RemoveTrail, gpGlobals->curtime + 0.05, "FadeTrail");
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::AdjustDamageDirection( const CTakeDamageInfo &info, Vector &dir, CBaseEntity *pEnt )
{
if ( pEnt )
{
dir = info.GetDamagePosition() - info.GetDamageForce() - pEnt->WorldSpaceCenter();
}
}
//-----------------------------------------------------------------------------
// Purpose: Arrow was deflected.
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::IncrementDeflected( void )
{
m_iDeflected++;
// Change trail color.
if ( m_pTrail )
{
UTIL_Remove( m_pTrail );
m_pTrail = NULL;
m_flTrailLife = 1.0f;
}
CreateTrail();
}
//-----------------------------------------------------------------------------
// Purpose: Arrow was deflected.
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::Deflected( CBaseEntity *pDeflectedBy, Vector &vecDir )
{
CTFPlayer *pTFDeflector = ToTFPlayer( pDeflectedBy );
if ( !pTFDeflector )
return;
ChangeTeam( pTFDeflector->GetTeamNumber() );
SetLauncher( pTFDeflector->GetActiveWeapon() );
CTFPlayer* pOldOwner = ToTFPlayer( GetOwnerEntity() );
SetOwnerEntity( pTFDeflector );
if ( pOldOwner )
{
pOldOwner->SpeakConceptIfAllowed( MP_CONCEPT_DEFLECTED, "projectile:1,victim:1" );
}
if ( pTFDeflector->m_Shared.IsCritBoosted() )
{
SetCritical( true );
}
CTFWeaponBase::SendObjectDeflectedEvent( pTFDeflector, pOldOwner, GetWeaponID(), this );
IncrementDeflected();
SetScorer( pTFDeflector );
// Purge our hit list so we can hit everyone again
m_HitEntities.Purge();
// Add ourselves so we dont hit ourselves
m_HitEntities.AddToTail( pTFDeflector->entindex() );
}
//-----------------------------------------------------------------------------
// Purpose: Setup function.
//-----------------------------------------------------------------------------
void CTFProjectile_HealingBolt::InitArrow( const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
BaseClass::InitArrow( vecAngles, fSpeed, fGravity, projectileType, pOwner, pScorer );
//SetNextThink( gpGlobals->curtime );
}
//-----------------------------------------------------------------------------
// Purpose: Healing bolt heal.
//-----------------------------------------------------------------------------
void CTFProjectile_HealingBolt::ImpactTeamPlayer( CTFPlayer *pOther )
{
if ( !pOther )
return;
#ifdef STAGING_ONLY
// Milk Arrows only heal teammates on special shot
if ( GetProjectileType() == TF_PROJECTILE_MILK_BOLT && !m_bApplyMilkOnHit )
return;
#endif
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return;
// Don't heal players using a weapon that blocks healing
CTFWeaponBase *pWeapon = pOther->GetActiveTFWeapon();
if ( pWeapon )
{
int iBlockHealing = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iBlockHealing, weapon_blocks_healing );
if ( iBlockHealing )
return;
}
float flHealth = GetDamage() * 2.0f;
#ifdef STAGING_ONLY
// Milk Arrows give a resist bubble on hitting a teammate
if ( GetProjectileType() == TF_PROJECTILE_MILK_BOLT )
{
// use damage to scale time
float flResistDuration = RemapValClamped( flHealth, 0, 150, 1, 3 );
pOther->m_Shared.AddCond( TF_COND_MEDIGUN_UBER_BULLET_RESIST, flResistDuration, pOwner );
pOther->m_Shared.AddCond( TF_COND_MEDIGUN_UBER_BLAST_RESIST, flResistDuration, pOwner );
pOther->m_Shared.AddCond( TF_COND_MEDIGUN_UBER_FIRE_RESIST, flResistDuration, pOwner );
}
#endif
// Scale this if needed
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pOther, flHealth, mult_healing_from_medics );
int iActualHealed = pOther->TakeHealth( flHealth, DMG_GENERIC );
if ( iActualHealed <= 0 )
return;
// Play an impact sound.
ImpactSound( "Weapon_Arrow.ImpactFleshCrossbowHeal" );
CTF_GameStats.Event_PlayerHealedOther( pOwner, flHealth );
IGameEvent * event = gameeventmanager->CreateEvent( "player_healed" );
if ( event )
{
// HLTV event priority, not transmitted
event->SetInt( "priority", 1 );
// Healed by another player.
event->SetInt( "patient", pOther->GetUserID() );
event->SetInt( "healer", pOwner->GetUserID() );
event->SetInt( "amount", flHealth );
gameeventmanager->FireEvent( event );
}
event = gameeventmanager->CreateEvent( "player_healonhit" );
if ( event )
{
event->SetInt( "amount", flHealth );
event->SetInt( "entindex", pOther->entindex() );
item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
if ( pWeapon && pWeapon->GetAttributeContainer() && pWeapon->GetAttributeContainer()->GetItem() )
{
healingItemDef = pWeapon->GetAttributeContainer()->GetItem()->GetItemDefIndex();
}
event->SetInt( "weapon_def_index", healingItemDef );
gameeventmanager->FireEvent( event );
}
event = gameeventmanager->CreateEvent( "crossbow_heal" );
if ( event )
{
event->SetInt( "healer", pOwner->GetUserID() );
event->SetInt( "target", pOther->GetUserID() );
event->SetInt( "amount", flHealth );
gameeventmanager->FireEvent( event );
}
// Give a litte bit of uber based on actual healing
// Give them a little bit of Uber
CWeaponMedigun *pMedigun = static_cast<CWeaponMedigun *>( pOwner->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
if ( pMedigun )
{
// On Mediguns, per frame, the amount of uber added is based on
// Default heal rate is 24per second, we scale based on that and frametime
pMedigun->AddCharge( ( iActualHealed / 24.0f ) * gpGlobals->frametime );
}
pOther->m_Shared.AddCond( TF_COND_HEALTH_OVERHEALED, 1.2f );
EconEntity_OnOwnerKillEaterEvent_Batched( dynamic_cast<CEconEntity *>( GetLauncher() ), pOwner, pOther, kKillEaterEvent_AllyHealingDone, flHealth );
}
CTFProjectile_GrapplingHook::CTFProjectile_GrapplingHook()
: m_pImpactFleshSoundLoop( NULL )
{
}
//-----------------------------------------------------------------------------
// Purpose: Spawn
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::Spawn()
{
BaseClass::Spawn();
SetMoveType( MOVETYPE_FLY, MOVECOLLIDE_FLY_CUSTOM );
}
void CTFProjectile_GrapplingHook::Precache()
{
BaseClass::Precache();
PrecacheModel( "models/weapons/c_models/c_grapple_proj/c_grapple_proj.mdl" );
PrecacheScriptSound( "WeaponGrapplingHook.ImpactFlesh" );
PrecacheScriptSound( "WeaponGrapplingHook.ImpactDefault" );
PrecacheScriptSound( "WeaponGrapplingHook.ImpactFleshLoop" );
}
//-----------------------------------------------------------------------------
// Purpose: Spawn
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::UpdateOnRemove()
{
// clear hook target
CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pTFPlayer )
{
// Clear any healers grappling with us
SetMedicsGrapplingHookTarget( pTFPlayer, NULL );
pTFPlayer->SetGrapplingHookTarget( NULL );
pTFPlayer->m_Shared.RemoveCond( TF_COND_GRAPPLINGHOOK );
}
StopImpactFleshSoundLoop();
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose: Setup function.
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::InitArrow( const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
BaseClass::InitArrow( vecAngles, fSpeed, fGravity, projectileType, pOwner, pScorer );
CTFPlayer *pTFPlayer = ToTFPlayer( pOwner );
if ( pTFPlayer )
{
pTFPlayer->m_Shared.AddCond( TF_COND_GRAPPLINGHOOK );
}
}
//-----------------------------------------------------------------------------
// Purpose: OnArrowImpact
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::OnArrowImpact( mstudiobbox_t *pBox, CBaseEntity *pOther, CBaseEntity *pAttacker )
{
HookTarget( pOther );
}
//-----------------------------------------------------------------------------
// Purpose: OnArrowImpactObject
//-----------------------------------------------------------------------------
bool CTFProjectile_GrapplingHook::OnArrowImpactObject( CBaseEntity *pOther )
{
HookTarget( pOther );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: CheckSkyboxImpact
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::CheckSkyboxImpact( CBaseEntity *pOther )
{
trace_t tr;
Vector velDir = GetAbsVelocity();
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.
FadeOut( 1.f );
return;
}
if ( !pOther->IsWorld() )
{
HookTarget( pOther );
}
else
{
HookTarget( pOther );
// rotate the hook model to be perpendicular to the world surface
Vector vUp;
AngleVectors( GetAbsAngles(), NULL, NULL, &vUp );
QAngle qNewAngles;
VectorAngles( -tr.plane.normal, vUp, qNewAngles );
SetAbsAngles( qNewAngles );
SetAbsOrigin( GetAbsOrigin() + 3.f * tr.plane.normal );
}
}
//-----------------------------------------------------------------------------
// Purpose: HookTarget
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::HookTarget( CBaseEntity *pOther )
{
if ( !GetOwnerEntity() || !pOther )
return;
CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
if ( !pTFPlayer || pTFPlayer->GetGrapplingHookTarget() )
return;
CBaseEntity *pTarget = pOther->IsWorld() ? this : pOther;
const char *pszSoundName = NULL;
if ( pTarget->IsPlayer() )
{
pszSoundName = "WeaponGrapplingHook.ImpactFlesh";
}
else
{
pszSoundName = "WeaponGrapplingHook.ImpactDefault";
}
ImpactSound( pszSoundName );
pTFPlayer->SetGrapplingHookTarget( pTarget, true );
// Grapple any medics to us
SetMedicsGrapplingHookTarget( pTFPlayer, pTFPlayer );
// Stop moving!
if ( pOther->IsPlayer() )
{
FollowEntity( pOther, false );
StartImpactFleshSoundLoop();
}
else
SetMoveType( MOVETYPE_NONE );
SetContextThink( &CTFProjectile_GrapplingHook::HookLatchedThink, gpGlobals->curtime + 0.1f, "HookLatchedThink" );
}
//-----------------------------------------------------------------------------
// Purpose: HookLatchedThink
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::HookLatchedThink()
{
// if owner is dead, remove the hook
CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
if ( !pTFPlayer || !pTFPlayer->IsAlive() )
{
UTIL_Remove( this );
return;
}
// if the target nolonger exist or target player is dead, remove the hook
CBaseEntity *pHookTarget = pTFPlayer->GetGrapplingHookTarget();
if ( !pHookTarget || ( pHookTarget->IsPlayer() && !pHookTarget->IsAlive() ) )
{
UTIL_Remove( this );
return;
}
SetContextThink( &CTFProjectile_GrapplingHook::HookLatchedThink, gpGlobals->curtime + 0.1f, "HookLatchedThink" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::StartImpactFleshSoundLoop()
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
CPASAttenuationFilter filter( this );
m_pImpactFleshSoundLoop = controller.SoundCreate( filter, entindex(), "WeaponGrapplingHook.ImpactFleshLoop" );
controller.Play( m_pImpactFleshSoundLoop, 1.0, 100 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::StopImpactFleshSoundLoop()
{
if ( m_pImpactFleshSoundLoop )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundDestroy( m_pImpactFleshSoundLoop );
m_pImpactFleshSoundLoop = NULL;
}
}