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.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/shared/tf/tf_weapon_bat.cpp

1294 lines
36 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "tf_weapon_bat.h"
#include "decals.h"
// Client specific.
#ifdef CLIENT_DLL
#include "c_basedoor.h"
#include "c_tf_player.h"
#include "IEffects.h"
#include "bone_setup.h"
#include "c_tf_gamestats.h"
// Server specific.
#else
#include "doors.h"
#include "tf_player.h"
#include "tf_ammo_pack.h"
#include "tf_gamestats.h"
#include "ilagcompensationmanager.h"
#include "collisionutils.h"
#include "particle_parse.h"
#include "tf_projectile_base.h"
#include "tf_gamerules.h"
#endif
const float DEFAULT_ORNAMENT_EXPLODE_RADIUS = 50.0f;
const float DEFAULT_ORNAMENT_EXPLODE_DAMAGE_MULT = 0.9f;
//=============================================================================
//
// Weapon Bat tables.
//
// TFBat --
IMPLEMENT_NETWORKCLASS_ALIASED( TFBat, DT_TFWeaponBat )
BEGIN_NETWORK_TABLE( CTFBat, DT_TFWeaponBat )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFBat )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_bat, CTFBat );
PRECACHE_WEAPON_REGISTER( tf_weapon_bat );
// -- TFBat
// TFBat_Fish --
IMPLEMENT_NETWORKCLASS_ALIASED( TFBat_Fish, DT_TFWeaponBat_Fish )
BEGIN_NETWORK_TABLE( CTFBat_Fish, DT_TFWeaponBat_Fish )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFBat_Fish )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_bat_fish, CTFBat_Fish );
PRECACHE_WEAPON_REGISTER( tf_weapon_bat_fish );
// -- TFBat_Fish
// TFBat_Wood --
IMPLEMENT_NETWORKCLASS_ALIASED( TFBat_Wood, DT_TFWeaponBat_Wood )
BEGIN_NETWORK_TABLE( CTFBat_Wood, DT_TFWeaponBat_Wood )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFBat_Wood )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_bat_wood, CTFBat_Wood );
PRECACHE_WEAPON_REGISTER( tf_weapon_bat_wood );
// -- TFBat_Wood
// CTFBat_Giftwrap --
IMPLEMENT_NETWORKCLASS_ALIASED( TFBat_Giftwrap, DT_TFWeaponBat_Giftwrap )
BEGIN_NETWORK_TABLE( CTFBat_Giftwrap, DT_TFWeaponBat_Giftwrap )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFBat_Giftwrap )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_bat_giftwrap, CTFBat_Giftwrap );
PRECACHE_WEAPON_REGISTER( tf_weapon_bat_giftwrap );
// -- CTFBat_Giftwrap
// TFStunBall --
IMPLEMENT_NETWORKCLASS_ALIASED( TFStunBall, DT_TFProjectile_StunBall )
BEGIN_NETWORK_TABLE( CTFStunBall, DT_TFProjectile_StunBall )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_stun_ball, CTFStunBall );
PRECACHE_WEAPON_REGISTER( tf_projectile_stun_ball );
#define TF_WEAPON_STUNBALL_VM_MODEL "models/weapons/v_models/v_baseball.mdl"
#define TF_WEAPON_STUNBALL_MODEL "models/weapons/w_models/w_baseball.mdl"
#if defined( GAME_DLL )
ConVar tf_scout_stunball_base_duration( "tf_scout_stunball_base_duration", "6.0", FCVAR_DEVELOPMENTONLY );
ConVar tf_scout_stunball_base_speed( "tf_scout_stunball_base_speed", "3000", FCVAR_DEVELOPMENTONLY );
ConVar sv_proj_stunball_damage( "sv_proj_stunball_damage", "15", FCVAR_DEVELOPMENTONLY );
#endif
// -- TFStunBall
// CTFBall_Ornament --
IMPLEMENT_NETWORKCLASS_ALIASED( TFBall_Ornament, DT_TFProjectileBall_Ornament )
BEGIN_NETWORK_TABLE( CTFBall_Ornament, DT_TFProjectileBall_Ornament )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_ball_ornament, CTFBall_Ornament );
PRECACHE_WEAPON_REGISTER( tf_projectile_ball_ornament );
#define TF_WEAPON_BALL_ORNAMENT_VM_MODEL "models/weapons/c_models/c_xms_festive_ornament.mdl"
#define TF_WEAPON_BALL_ORNAMENT_MODEL "models/weapons/c_models/c_xms_festive_ornament.mdl"
#if defined( GAME_DLL )
//ConVar tf_scout_stunball_base_duration( "tf_scout_stunball_base_duration", "6.0", FCVAR_DEVELOPMENTONLY );
#endif
// -- CTFBall_Ornament
static string_t s_iszTrainName;
//=============================================================================
#define STUNBALL_TRAIL_ALPHA 128
//=============================================================================
//
// CTFBat
//
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFBat::CTFBat()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat::Smack( void )
{
BaseClass::Smack();
#ifdef GAME_DLL
if ( BatDeflects() )
{
#ifdef TF_RAID_MODE
if ( TFGameRules()->IsRaidMode() )
{
}
else
#endif // TF_RAID_MODE
{
DeflectProjectiles();
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat::PlayDeflectionSound( bool bPlayer )
{
WeaponSound( MELEE_HIT_WORLD );
}
//=============================================================================
//
// CTFBat_Wood
//
CTFBat_Wood::CTFBat_Wood()
{
m_iEnemyBallID = 0;
#ifdef CLIENT_DLL
m_hStunBallVM = NULL;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ConVar tf_scout_bat_launch_delay( "tf_scout_bat_launch_delay", "0.1", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::LaunchBallThink( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
LaunchBall();
#ifdef GAME_DLL
pPlayer->SpeakWeaponFire( MP_CONCEPT_BAT_BALL );
CTF_GameStats.Event_PlayerFiredWeapon( pPlayer, IsCurrentAttackACrit() );
#endif
#ifdef CLIENT_DLL
C_CTF_GameStats.Event_PlayerFiredWeapon( pPlayer, IsCurrentAttackACrit() );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::SecondaryAttackAnim( CTFPlayer *pPlayer )
{
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_SECONDARY );
}
// SERVER ONLY --
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Calculate the ball's initial position, angle, and velocity.
//-----------------------------------------------------------------------------
void CTFBat_Wood::GetBallDynamics( Vector& vecLoc, QAngle& vecAngles, Vector& vecVelocity, AngularImpulse& angImpulse, CTFPlayer* pPlayer )
{
Vector vecForward, vecUp;
AngleVectors( pPlayer->EyeAngles(), &vecForward, NULL, &vecUp );
vecLoc = pPlayer->GetAbsOrigin() + pPlayer->GetModelScale() * ( Vector( 0, 0, 50 ) + vecForward * 32.f );
vecAngles = pPlayer->GetAbsAngles();
// Calculate the initial impulse on the item.
vecVelocity = Vector( 0.0f, 0.0f, 0.0f );
vecVelocity += vecForward * 10;
vecVelocity += vecUp * 1;
VectorNormalize( vecVelocity );
vecVelocity *= tf_scout_stunball_base_speed.GetInt();
angImpulse = AngularImpulse( 0, random->RandomFloat( 0, 100 ), 0 );
}
// -- SERVER ONLY
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::SecondaryAttack( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( !CanAttack() )
return;
if ( m_flNextPrimaryAttack > gpGlobals->curtime )
return;
// Do we have any balls? If so, use them.
int iBallCount = pPlayer->GetAmmoCount( TF_AMMO_GRENADES1 );
if ( (iBallCount > 0) && CanCreateBall( pPlayer ) )
{
SecondaryAttackAnim( pPlayer );
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
SetContextThink( &CTFBat_Wood::LaunchBallThink, gpGlobals->curtime + tf_scout_bat_launch_delay.GetFloat(), "LAUNCH_BALL_THINK" );
m_flNextPrimaryAttack = gpGlobals->curtime + 0.25;
#ifdef GAME_DLL
if ( pPlayer->m_Shared.IsStealthed() )
{
pPlayer->RemoveInvisibility();
}
#endif // GAME_DLL
}
}
//-----------------------------------------------------------------------------
// Purpose: Client Only. Show the stunball view model if necessary.
//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL
void CTFBat_Wood::SetWeaponVisible( bool visible )
{
BaseClass::SetWeaponVisible( visible );
if ( !m_hStunBallVM )
return;
if ( visible )
{
m_hStunBallVM->RemoveEffects( EF_NODRAW );
}
else
{
m_hStunBallVM->AddEffects( EF_NODRAW );
}
}
#endif
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged( updateType );
bool bLocalPlayerAmmo = true;
if ( GetPlayerOwner() == C_BasePlayer::GetLocalPlayer() )
{
bLocalPlayerAmmo = GetPlayerOwner()->GetAmmoCount( TF_AMMO_GRENADES1 ) > 0;
}
if ( IsCarrierAlive() && ( WeaponState() == WEAPON_IS_ACTIVE ) && bLocalPlayerAmmo == true )
{
AddBallChild();
}
else
{
RemoveBallChild();
}
}
//-----------------------------------------------------------------------------
// Purpose: Client Only. Show the stunball view model if necessary.
//-----------------------------------------------------------------------------
void CTFBat_Wood::AddBallChild( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( !pPlayer->IsLocalPlayer() )
return;
if ( !pPlayer->GetViewModel() )
return;
if ( m_hStunBallVM )
return;
CTFViewModel* pBall = new class CTFViewModel();
if ( pBall != NULL )
{
pBall->InitializeAsClientEntity( GetBallViewModelName(), RENDER_GROUP_OPAQUE_ENTITY );
pBall->SetAbsOrigin( pPlayer->GetViewModel()->GetAbsOrigin() );
pBall->SetModel( GetBallViewModelName() );
pBall->m_nSkin = ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) ? 1 : 0;
CStudioHdr *pStudioHdr = pPlayer->GetViewModel()->GetModelPtr();
if ( pStudioHdr )
{
int iAttachment = Studio_FindAttachment( pStudioHdr, "weapon_bone_L" ) + 1;
pBall->SetParent( pPlayer->GetViewModel(), iAttachment );
}
pBall->AddEffects( EF_BONEMERGE );
pBall->SetMoveType( MOVETYPE_NONE );
pBall->AddSolidFlags( FSOLID_NOT_SOLID );
m_hStunBallVM.Set( pBall );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::Drop( const Vector &vecVelocity )
{
BaseClass::Drop( vecVelocity );
RemoveBallChild();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::WeaponReset( void )
{
RemoveBallChild();
BaseClass::WeaponReset();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::UpdateOnRemove( void )
{
RemoveBallChild();
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::RemoveBallChild()
{
if ( m_hStunBallVM )
{
m_hStunBallVM->Remove();
m_hStunBallVM = NULL;
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Determines if there is space to create a ball.
//-----------------------------------------------------------------------------
bool CTFBat_Wood::CanCreateBall( CTFPlayer* pPlayer )
{
int iWeaponMod = 0;
CALL_ATTRIB_HOOK_INT( iWeaponMod, set_weapon_mode );
if ( iWeaponMod == 0 )
return false;
if ( pPlayer->GetWaterLevel() == WL_Eyes )
return false;
Vector vecForward, vecUp;
AngleVectors( pPlayer->EyeAngles(), &vecForward, NULL, &vecUp );
Vector vecBallStart = pPlayer->GetAbsOrigin() + Vector( 0, 0, 50 );
Vector vecBallEnd = vecBallStart + vecForward * 32.f;
// Trace out and see if we hit a wall.
trace_t trace;
CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
UTIL_TraceHull( vecBallStart, vecBallEnd, -Vector(8,8,8), Vector(8,8,8), MASK_SOLID_BRUSHONLY, &traceFilter, &trace );
if ( trace.DidHitWorld() || trace.startsolid )
return false;
else
{
if ( trace.m_pEnt )
{
// Don't let the player bat through doors.
CBaseDoor *pDoor = dynamic_cast<CBaseDoor*>( trace.m_pEnt );
if ( pDoor )
return false;
}
return true;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Wood::LaunchBall( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
#if GAME_DLL
// Make a ball.
CBaseEntity* pBall = CreateBall();
if ( !pBall )
return;
if ( IsCurrentAttackACrit() )
{
WeaponSound( BURST );
}
WeaponSound( SPECIAL2 );
pPlayer->RemoveAmmo( 1, TF_AMMO_GRENADES1 );
#endif
StartEffectBarRegen();
}
// SERVER ONLY --
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: The wooden bat creates a baseball that stuns whomever it hits.
//-----------------------------------------------------------------------------
CBaseEntity* CTFBat_Wood::CreateBall( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return NULL;
// Do another check here, as the player may have moved to an invalid position
// since the first check (0.1 seconds ago). This fixes the ball sometimes
// going through thin geometry, such as windows and spawn blockers.
if ( !CanCreateBall( pPlayer ) )
return NULL;
// Determine the ball's initial location, angles, and velocity.
Vector vecLocation, vecVelocity;
QAngle vecAngles;
AngularImpulse angImpulse;
GetBallDynamics( vecLocation, vecAngles, vecVelocity, angImpulse, pPlayer );
// Create a stun ball.
CTFStunBall* pBall = CTFStunBall::Create( vecLocation, vecAngles, pPlayer );
Assert( pBall );
if ( !pBall )
return NULL;
CalcIsAttackCritical();
pBall->m_iOriginalOwnerID = m_iEnemyBallID;
m_iEnemyBallID = 0;
pBall->SetCritical( IsCurrentAttackACrit() );
pBall->InitGrenade( vecVelocity, angImpulse, pPlayer, GetTFWpnData() );
pBall->SetLauncher( this );
pBall->SetOwnerEntity( pPlayer );
pBall->SetInitialSpeed( tf_scout_stunball_base_speed.GetInt() );
return pBall;
}
// -- SERVER ONLY
#endif
//-----------------------------------------------------------------------------
// Purpose: Play pickup anim when we grab a new ball.
//-----------------------------------------------------------------------------
void CTFBat_Wood::PickedUpBall( void )
{
if ( WeaponState() == WEAPON_IS_ACTIVE )
{
SendWeaponAnim( ACT_VM_PULLBACK_SPECIAL );
}
}
//-----------------------------------------------------------------------------
// Purpose: Play animation appropriate to ball status.
//-----------------------------------------------------------------------------
bool CTFBat_Wood::SendWeaponAnim( int iActivity )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return BaseClass::SendWeaponAnim( iActivity );
if ( pPlayer->GetAmmoCount( TF_AMMO_GRENADES1 ) > 0 )
{
switch ( iActivity )
{
case ACT_VM_DRAW:
iActivity = ACT_VM_DRAW_SPECIAL;
break;
case ACT_VM_HOLSTER:
iActivity = ACT_VM_HOLSTER_SPECIAL;
break;
case ACT_VM_IDLE:
iActivity = ACT_VM_IDLE_SPECIAL;
break;
case ACT_VM_PULLBACK:
iActivity = ACT_VM_PULLBACK_SPECIAL;
break;
case ACT_VM_PRIMARYATTACK:
iActivity = ACT_VM_PRIMARYATTACK_SPECIAL;
break;
case ACT_VM_SECONDARYATTACK:
iActivity = ACT_VM_PRIMARYATTACK_SPECIAL;
break;
case ACT_VM_HITCENTER:
iActivity = ACT_VM_HITCENTER_SPECIAL;
break;
case ACT_VM_SWINGHARD:
iActivity = ACT_VM_SWINGHARD_SPECIAL;
break;
case ACT_VM_IDLE_TO_LOWERED:
iActivity = ACT_VM_IDLE_TO_LOWERED_SPECIAL;
break;
case ACT_VM_IDLE_LOWERED:
iActivity = ACT_VM_IDLE_LOWERED_SPECIAL;
break;
case ACT_VM_LOWERED_TO_IDLE:
iActivity = ACT_VM_LOWERED_TO_IDLE_SPECIAL;
break;
default:
break;
}
}
return BaseClass::SendWeaponAnim( iActivity );
}
//=============================================================================
//
// CTFStunBall
//
// SERVER ONLY --
#ifdef GAME_DLL
CTFStunBall::CTFStunBall()
{
s_iszTrainName = AllocPooledString( "models/props_vehicles/train_enginecar.mdl" );
m_iOriginalOwnerID = 0;
m_pBallTrail = NULL;
m_flBallTrailLife = 1.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Static entity factory.
//-----------------------------------------------------------------------------
CTFStunBall* CTFStunBall::Create( const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner )
{
CTFStunBall* pBall = static_cast<CTFStunBall*>( CBaseAnimating::CreateNoSpawn( "tf_projectile_stun_ball", vecOrigin, vecAngles, pOwner ) );
if ( pBall )
{
DispatchSpawn( pBall );
}
return pBall;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStunBall::Precache( void )
{
PrecacheModel( GetBallModelName() );
PrecacheModel( GetBallViewModelName() );
PrecacheModel( "effects/baseballtrail_red.vmt" );
PrecacheModel( "effects/baseballtrail_blu.vmt" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
const char *CTFStunBall::GetBallModelName( void ) const
{
return TF_WEAPON_STUNBALL_MODEL;
}
//-----------------------------------------------------------------------------
const char *CTFStunBall::GetBallViewModelName( void ) const
{
return TF_WEAPON_STUNBALL_VM_MODEL;
}
//-----------------------------------------------------------------------------
// Purpose: Sets up initial properties.
//-----------------------------------------------------------------------------
void CTFStunBall::Spawn( void )
{
BaseClass::Spawn();
SetModel( GetBallModelName() );
VPhysicsDestroyObject();
VPhysicsInitNormal( SOLID_BBOX, 0, false );
AddSolidFlags( FSOLID_TRIGGER );
AddFlag( FL_GRENADE );
SetCollisionGroup( COLLISION_GROUP_PROJECTILE );
m_takedamage = DAMAGE_NO;
SetContextThink( &CBaseEntity::SUB_Remove, gpGlobals->curtime + 15, "DieContext" );
// Draw the trail for the Baseball on spawn
if ( !m_pBallTrail )
{
const char *pTrailTeamName = ( GetTeamNumber() == TF_TEAM_RED ) ? "effects/baseballtrail_red.vmt" : "effects/baseballtrail_blu.vmt";
CSpriteTrail *pTempTrail = NULL;
pTempTrail = CSpriteTrail::SpriteTrailCreate( pTrailTeamName, GetAbsOrigin(), true );
pTempTrail->FollowEntity( this );
pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, STUNBALL_TRAIL_ALPHA, kRenderFxNone );
pTempTrail->SetStartWidth( 9 );
pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
pTempTrail->SetLifeTime( 0.4 );
pTempTrail->TurnOn();
pTempTrail->SetAttachment( this, 0 );
m_pBallTrail = pTempTrail;
SetContextThink( &CTFStunBall::RemoveBallTrail, gpGlobals->curtime + 3, "FadeBallTrail");
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStunBall::Explode( trace_t *pTrace, int bitsDamageType )
{
if ( !IsAllowedToExplode() )
return;
BaseClass::Explode( pTrace, bitsDamageType );
}
//-----------------------------------------------------------------------------
// Purpose: Stun the person we smashed into.
//-----------------------------------------------------------------------------
#define FLIGHT_TIME_TO_MAX_STUN 1.f
void CTFStunBall::ApplyBallImpactEffectOnVictim( CBaseEntity *pOther )
{
if ( !pOther || !pOther->IsPlayer() )
return;
CTFPlayer* pPlayer = ToTFPlayer( pOther );
if ( !pPlayer )
return;
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return;
if ( m_bTouched )
return;
// Can't stun an invul player.
if ( pPlayer->m_Shared.IsInvulnerable() || pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
return;
// We have a more intense stun based on our travel time.
float flLifeTime = MIN( gpGlobals->curtime - m_flCreationTime, FLIGHT_TIME_TO_MAX_STUN );
float flLifeTimeRatio = flLifeTime / FLIGHT_TIME_TO_MAX_STUN;
if ( flLifeTimeRatio > 0.1f )
{
float flStun = 0.5f;
float flStunDuration = tf_scout_stunball_base_duration.GetFloat() * flLifeTimeRatio;
if ( IsCritical() )
flStunDuration += 2.0; // Extra two seconds of effect time if we're a critical hit.
int iStunFlags = TF_STUN_LOSER_STATE | TF_STUN_MOVEMENT;
if ( flLifeTimeRatio >= 1.f )
{
flStunDuration += 1.0;
iStunFlags = TF_STUN_CONTROLS;
iStunFlags |= TF_STUN_SPECIAL_SOUND;
CTF_GameStats.Event_PlayerStunBall( pOwner, true );
}
else
{
CTF_GameStats.Event_PlayerStunBall( pOwner, false );
}
// Adjust stun amount and flags if we're hitting a boss or scaled enemy
if ( TFGameRules() && TFGameRules()->GameModeUsesMiniBosses() && ( pPlayer->IsMiniBoss() || pPlayer->GetModelScale() > 1.0f ) )
{
// If max range, freeze them in place - otherwise adjust it based on distance
flStun = flLifeTimeRatio >= 1.f ? 1.f : RemapValClamped( flLifeTimeRatio, 0.1f, 0.99f, 0.5f, 0.75 );
iStunFlags = flLifeTimeRatio >= 1.f ? ( TF_STUN_SPECIAL_SOUND | TF_STUN_MOVEMENT ) : TF_STUN_MOVEMENT;
}
if ( pPlayer->GetWaterLevel() != WL_Eyes )
{
pPlayer->m_Shared.StunPlayer( flStunDuration, flStun, iStunFlags, pOwner );
if ( pPlayer->GetUserID() == m_iOriginalOwnerID )
{
// Holy crap! We just stunned a scout with their own ball.
// Give the player an achievement for this.
if ( pOwner->IsPlayerClass( TF_CLASS_SCOUT ) )
{
pOwner->AwardAchievement( ACHIEVEMENT_TF_SCOUT_STUN_SCOUT_WITH_THEIR_BALL );
}
}
}
}
// Give 'em a love tap.
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
trace_t *pNewTrace = const_cast<trace_t*>( pTrace );
CBaseEntity *pInflictor = GetLauncher();
CTakeDamageInfo info;
info.SetAttacker( GetOwnerEntity() );
info.SetInflictor( pInflictor );
info.SetWeapon( pInflictor );
info.SetDamage( GetDamage() );
info.SetDamageCustom( TF_DMG_CUSTOM_BASEBALL );
info.SetDamageForce( GetDamageForce() );
info.SetDamagePosition( GetAbsOrigin() );
int iDamageType = GetDamageType();
if ( IsCritical() )
iDamageType |= DMG_CRITICAL;
info.SetDamageType( iDamageType );
// Hurt 'em.
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pPlayer->DispatchTraceAttack( info, dir, pNewTrace );
ApplyMultiDamage();
// Make this ball fade faster now that it's hit something.
SetContextThink( &CBaseEntity::SUB_Remove, gpGlobals->curtime + 4, "DieContext" );
m_bTouched = true;
}
float CTFStunBall::GetDamage( void )
{
return sv_proj_stunball_damage.GetFloat();
}
Vector CTFStunBall::GetDamageForce( void )
{
Vector vecVelocity = GetAbsVelocity();
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->GetVelocity( &vecVelocity, NULL );
VectorNormalize( vecVelocity );
}
return (vecVelocity * GetDamage());
}
//-----------------------------------------------------------------------------
// Purpose: We hit something.
//-----------------------------------------------------------------------------
void CTFStunBall::PipebombTouch( CBaseEntity *pOther )
{
CTFPlayer* pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return;
if ( !pOther || !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
{
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_BALL_MISSED );
return;
}
// Go away if we're hit by a moving train.
if ( pOther->GetModelName() == s_iszTrainName && ( pOther->GetAbsVelocity().LengthSqr() > 1.0f ) )
{
UTIL_Remove( this );
return;
}
// Go away if we hit the skybox.
trace_t pTrace;
Vector velDir = GetAbsVelocity();
VectorNormalize( velDir );
Vector vecSpot = GetAbsOrigin() - velDir * 32;
UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );
if ( pTrace.fraction < 1.0 && pTrace.surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
// Ignore things that aren't players.
if ( !pOther->IsPlayer() )
return;
// If we hit a scout, pickup as ammo
if ( m_bTouched )
{
CTFPlayer* pPlayer = ToTFPlayer( pOther );
if ( pPlayer && pPlayer->IsPlayerClass( TF_CLASS_SCOUT ) &&
(pPlayer->GetAmmoCount( TF_AMMO_GRENADES1 ) < pPlayer->GetMaxAmmo( TF_AMMO_GRENADES1 )) )
{
pPlayer->GiveAmmo( 1, TF_AMMO_GRENADES1 );
RemoveBallTrail();
UTIL_Remove( this );
CTFBat_Wood *pBat = (CTFBat_Wood *) pPlayer->Weapon_OwnsThisID( TF_WEAPON_BAT_WOOD );
if ( pBat )
{
// If this ball came from an enemy scout, remember who they were...
if ( pPlayer->GetTeamNumber() != GetTeamNumber() )
{
if ( pOwner )
{
pBat->m_iEnemyBallID = pOwner->GetUserID();
}
}
// If we have the bat up, we need to play the correct anim.
pBat->PickedUpBall();
}
// Say something.
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_GRAB_BALL, (pOther->GetTeamNumber() == GetTeamNumber()) ? "my_team:1" : "my_team:0" );
}
return;
}
if ( pOther == GetThrower() )
return;
if ( !InSameTeam( pOther ) && pOther->m_takedamage != DAMAGE_NO )
{
ApplyBallImpactEffectOnVictim( pOther );
}
}
//-----------------------------------------------------------------------------
// Purpose: We hit something.
//-----------------------------------------------------------------------------
void CTFStunBall::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
CTFPlayer* pOwner = ToTFPlayer( GetOwnerEntity() );
bool bWasTouched = m_bTouched;
BaseClass::VPhysicsCollision( index, pEvent );
if ( pOwner && !bWasTouched && m_bTouched )
{
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_BALL_MISSED );
}
}
//-----------------------------------------------------------------------------
// Purpose: Fade and kill the trail
//-----------------------------------------------------------------------------
void CTFStunBall::RemoveBallTrail( void )
{
if (!m_pBallTrail)
return;
if (m_pBallTrail)
{
if (m_flBallTrailLife <= 0)
{
UTIL_Remove( m_pBallTrail);
m_flBallTrailLife = 1.0f;
}
else
{
float fAlpha = STUNBALL_TRAIL_ALPHA * m_flBallTrailLife;
CSpriteTrail *pTempTrail = dynamic_cast< CSpriteTrail*>( m_pBallTrail.Get() );
if ( pTempTrail )
{
pTempTrail->SetBrightness( int(fAlpha) );
}
m_flBallTrailLife = m_flBallTrailLife - 0.1f;
SetContextThink( &CTFStunBall::RemoveBallTrail, gpGlobals->curtime + 0.05, "FadeBallTrail");
}
}
}
// -- SERVER ONLY
#endif
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFStunBall::GetTrailParticleName( void )
{
int iTeamNumber = GetTeamNumber();
if ( GetDeflected() )
{
CTFPlayer *pOwner = ToTFPlayer( GetDeflectOwner() );
if ( pOwner )
{
iTeamNumber = pOwner->GetTeamNumber();
}
}
if ( iTeamNumber == TF_TEAM_BLUE )
{
return "stunballtrail_blue";
}
else
{
return "stunballtrail_red";
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStunBall::CreateTrailParticles( void )
{
if ( pEffectTrail )
{
ParticleProp()->StopEmission( pEffectTrail );
}
if ( pEffectCrit )
{
ParticleProp()->StopEmission( pEffectCrit );
}
pEffectTrail = ParticleProp()->Create( GetTrailParticleName(), PATTACH_ABSORIGIN_FOLLOW );
int iTeamNumber = GetTeamNumber();
if ( GetDeflected() )
{
CTFPlayer *pOwner = ToTFPlayer( GetDeflectOwner() );
if ( pOwner )
{
iTeamNumber = pOwner->GetTeamNumber();
}
}
if ( m_bCritical )
{
if ( iTeamNumber == TF_TEAM_BLUE )
{
pEffectCrit = ParticleProp()->Create( "stunballtrail_blue_crit", PATTACH_ABSORIGIN_FOLLOW );
}
else
{
pEffectCrit = ParticleProp()->Create( "stunballtrail_red_crit", PATTACH_ABSORIGIN_FOLLOW );
}
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBat_Giftwrap::Spawn( void )
{
BaseClass::Spawn();
m_nSkin = ( GetTeamNumber() == TF_TEAM_BLUE ) ? 1 : 0;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseEntity *CTFBat_Giftwrap::CreateBall( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return NULL;
// Do another check here, as the player may have moved to an invalid position
// since the first check (0.1 seconds ago). This fixes the ball sometimes
// going through thin geometry, such as windows and spawn blockers.
if ( !CanCreateBall( pPlayer ) )
return NULL;
// Determine the ball's initial location, angles, and velocity.
Vector vecLocation, vecVelocity;
QAngle vecAngles;
AngularImpulse angImpulse;
GetBallDynamics( vecLocation, vecAngles, vecVelocity, angImpulse, pPlayer );
// Create the ornament ball.
CTFBall_Ornament *pBall = CTFBall_Ornament::Create( vecLocation, vecAngles, pPlayer );
Assert( pBall );
if ( !pBall )
return NULL;
CalcIsAttackCritical();
pBall->m_iOriginalOwnerID = m_iEnemyBallID;
m_iEnemyBallID = 0;
pBall->SetCritical( IsCurrentAttackACrit() );
pBall->InitGrenade( vecVelocity, angImpulse, pPlayer, GetTFWpnData() );
pBall->SetLauncher( this );
pBall->SetOwnerEntity( pPlayer );
pBall->SetInitialSpeed( tf_scout_stunball_base_speed.GetInt() );
pBall->m_nSkin = ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) ? 1 : 0;
return pBall;
}
//-----------------------------------------------------------------------------
void CTFBall_Ornament::Precache( void )
{
PrecacheScriptSound( "BallBuster.OrnamentImpactRange" );
PrecacheScriptSound( "BallBuster.OrnamentImpact" );
PrecacheScriptSound( "BallBuster.HitBall" );
PrecacheScriptSound( "BallBuster.HitFlesh" );
PrecacheScriptSound( "BallBuster.HitWorld" );
PrecacheScriptSound( "BallBuster.DrawCatch" );
PrecacheScriptSound( "BallBuster.Ornament_DrawCatch" );
PrecacheScriptSound( "BallBuster.Ball_HitWorld" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
CTFBall_Ornament *CTFBall_Ornament::Create( const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner )
{
CTFBall_Ornament* pBall = static_cast< CTFBall_Ornament * >( CBaseAnimating::CreateNoSpawn( "tf_projectile_ball_ornament", vecOrigin, vecAngles, pOwner ) );
if ( pBall )
{
DispatchSpawn( pBall );
}
return pBall;
}
//-----------------------------------------------------------------------------
const char *CTFBall_Ornament::GetBallModelName( void ) const
{
return TF_WEAPON_BALL_ORNAMENT_MODEL;
}
//-----------------------------------------------------------------------------
const char *CTFBall_Ornament::GetBallViewModelName( void ) const
{
return TF_WEAPON_BALL_ORNAMENT_VM_MODEL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFBall_Ornament::ApplyBallImpactEffectOnVictim( CBaseEntity *pOther )
{
if ( !pOther || !pOther->IsPlayer() )
return;
CTFPlayer* pPlayer = ToTFPlayer( pOther );
if ( !pPlayer )
return;
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return;
if ( m_bTouched )
return;
// Can't bleed an invul player.
if ( pPlayer->m_Shared.IsInvulnerable() || pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
return;
bool bIsCriticalHit = IsCritical();
float flBleedTime = 5.0f;
bool bIsLongRangeHit = false;
// long distance hit is always a crit
float flLifeTime = gpGlobals->curtime - m_flCreationTime;
if ( flLifeTime >= FLIGHT_TIME_TO_MAX_STUN )
{
bIsCriticalHit = true;
bIsLongRangeHit = true;
}
// just do the bleed effect directly since the bleed
// attribute comes from the inflictor, which is the bat.
pPlayer->m_Shared.MakeBleed( pOwner, (CTFBat_Giftwrap *)GetLauncher(), flBleedTime );
// Apply particle effect to victim (the remaining effects happen inside Explode)
DispatchParticleEffect( "xms_ornament_glitter", PATTACH_POINT_FOLLOW, pPlayer, "head" );
// Give 'em a love tap.
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
trace_t *pNewTrace = const_cast<trace_t*>( pTrace );
CBaseEntity *pInflictor = GetLauncher();
CTakeDamageInfo info;
info.SetAttacker( GetOwnerEntity() );
info.SetInflictor( pInflictor );
info.SetWeapon( pInflictor );
info.SetDamage( GetDamage() );
info.SetDamageCustom( TF_DMG_CUSTOM_BASEBALL );
info.SetDamageForce( GetDamageForce() );
info.SetDamagePosition( GetAbsOrigin() );
int iDamageType = GetDamageType();
if ( bIsCriticalHit )
iDamageType |= DMG_CRITICAL;
info.SetDamageType( iDamageType );
// Hurt 'em.
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pPlayer->DispatchTraceAttack( info, dir, pNewTrace );
ApplyMultiDamage();
// the ball shatters
UTIL_Remove( this );
m_bTouched = true;
}
void CTFBall_Ornament::PipebombTouch( CBaseEntity *pOther )
{
CTFPlayer* pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return;
// Go away if we're hit by a moving train.
if ( pOther->GetModelName() == s_iszTrainName && ( pOther->GetAbsVelocity().LengthSqr() > 1.0f ) )
{
UTIL_Remove( this );
return;
}
// Go away if we hit the skybox.
trace_t pTrace;
Vector velDir = GetAbsVelocity();
VectorNormalize( velDir );
Vector vecSpot = GetAbsOrigin() - velDir * 32;
UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );
if ( pTrace.fraction < 1.0 && pTrace.surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
if ( pOther == GetThrower() )
return;
// Explode (does radius damage, triggers particles and sound effects).
Explode( &pTrace, DMG_BLAST|DMG_PREVENT_PHYSICS_FORCE );
if ( !InSameTeam( pOther ) && pOther->m_takedamage != DAMAGE_NO )
{
ApplyBallImpactEffectOnVictim( pOther );
}
}
void CTFBall_Ornament::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
BaseClass::VPhysicsCollision( index, pEvent );
int otherIndex = !index;
CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];
if ( !pHitEntity )
return;
// Break if we hit the world.
if ( pHitEntity->IsWorld() )
{
// Explode immediately next frame. (Can't explode in the collision callback.)
m_vCollisionVelocity = pEvent->preVelocity[index];
SetContextThink( &CTFBall_Ornament::VPhysicsCollisionThink, gpGlobals->curtime, "OrnamentCollisionThink" );
}
}
void CTFBall_Ornament::VPhysicsCollisionThink( void )
{
trace_t pTrace;
Vector velDir = m_vCollisionVelocity;
VectorNormalize( velDir );
Vector vecSpot = GetAbsOrigin() - velDir * 16;
UTIL_TraceLine( vecSpot, vecSpot + velDir * 32, MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );
Explode( &pTrace, DMG_BLAST|DMG_PREVENT_PHYSICS_FORCE );
}
void CTFBall_Ornament::Explode( trace_t *pTrace, int bitsDamageType )
{
// Create smashed glass particles when we explode
CTFPlayer* pOwner = ToTFPlayer( GetOwnerEntity() );
if ( pOwner && pOwner->GetTeamNumber() == TF_TEAM_RED )
{
DispatchParticleEffect( "xms_ornament_smash_red", GetAbsOrigin(), GetAbsAngles() );
}
else
{
DispatchParticleEffect( "xms_ornament_smash_blue", GetAbsOrigin(), GetAbsAngles() );
}
Vector vecOrigin = GetAbsOrigin();
// sound effects
EmitSound_t params;
params.m_flSoundTime = 0;
params.m_pflSoundDuration = 0;
params.m_pSoundName = "BallBuster.OrnamentImpact";
CPASFilter filter( vecOrigin );
filter.RemoveRecipient( pOwner );
EmitSound( filter, entindex(), params );
CSingleUserRecipientFilter attackerFilter( pOwner );
EmitSound( attackerFilter, pOwner->entindex(), params );
// Explosion damage is some fraction of our base damage
float flExplodeDamage = GetDamage() * DEFAULT_ORNAMENT_EXPLODE_DAMAGE_MULT;
// Do radius damage
Vector vecBlastForce(0.0f, 0.0f, 0.0f);
CTakeDamageInfo info( this, GetThrower(), m_hLauncher, vecBlastForce, GetAbsOrigin(), flExplodeDamage, bitsDamageType, TF_DMG_CUSTOM_BASEBALL, &vecOrigin );
CTFRadiusDamageInfo radiusinfo( &info, vecOrigin, DEFAULT_ORNAMENT_EXPLODE_RADIUS, nullptr, 0.0f, 0.0f );
TFGameRules()->RadiusDamage( radiusinfo );
UTIL_Remove( this );
}
#endif