573 lines
17 KiB
C++
573 lines
17 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
// copied from portal2 code; original code came with client-predicted counterpart,
|
|
// but implementing predictable triggers in tf2 wasn't trivial so this is just the
|
|
// server component. it works but causes prediction errors.
|
|
#include "cbase.h"
|
|
|
|
#include "movevars_shared.h"
|
|
|
|
#if defined( GAME_DLL )
|
|
#include "trigger_catapult.h"
|
|
#include "tf_player.h"
|
|
#include "vcollide_parse.h"
|
|
#include "props.h"
|
|
#else
|
|
#include "c_trigger_catapult.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
ConVar catapult_physics_drag_boost( "catapult_physics_drag_boost", "2.1", FCVAR_REPLICATED );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: calculates the launch vector between the entity that touched the
|
|
// catapult trigger and the catapult target
|
|
//-----------------------------------------------------------------------------
|
|
Vector CTriggerCatapult::CalculateLaunchVector( CBaseEntity *pVictim, CBaseEntity *pTarget )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
if( !GetPredictable() || !pVictim->GetPredictable() )
|
|
return vec3_origin;
|
|
#endif
|
|
|
|
// Find where we're going
|
|
Vector vecSourcePos = pVictim->GetAbsOrigin();
|
|
Vector vecTargetPos = pTarget->GetAbsOrigin();
|
|
|
|
// If victim is player, adjust target position so player's center will hit the target
|
|
if ( pVictim->IsPlayer() )
|
|
{
|
|
vecTargetPos.z -= 32.0f;
|
|
}
|
|
|
|
float flSpeed = (pVictim->IsPlayer()) ? (float)m_flPlayerVelocity : (float)m_flPhysicsVelocity; // u/sec
|
|
float flGravity = GetCurrentGravity();
|
|
|
|
Vector vecVelocity = (vecTargetPos - vecSourcePos);
|
|
|
|
// throw at a constant time
|
|
float time = vecVelocity.Length( ) / flSpeed;
|
|
vecVelocity = vecVelocity * (1.f / time); // CatapultLaunchVelocityMultiplier
|
|
|
|
// adjust upward toss to compensate for gravity loss
|
|
vecVelocity.z += flGravity * time * 0.5;
|
|
|
|
return vecVelocity;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: calculates the launch vector between the entity that touched the
|
|
// catapult trigger and the catapult target
|
|
//-----------------------------------------------------------------------------
|
|
Vector CTriggerCatapult::CalculateLaunchVectorPreserve( Vector vecInitialVelocity, CBaseEntity *pVictim, CBaseEntity *pTarget, bool bForcePlayer )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
if( !GetPredictable() || !pVictim->GetPredictable() )
|
|
return vec3_origin;
|
|
#endif
|
|
|
|
// Find where we're going
|
|
Vector vecSourcePos = pVictim->GetAbsOrigin();
|
|
Vector vecTargetPos = pTarget->GetAbsOrigin();
|
|
|
|
// If victim is player, adjust target position so player's center will hit the target
|
|
if ( pVictim->IsPlayer() || bForcePlayer )
|
|
{
|
|
vecTargetPos.z -= 32.0f;
|
|
}
|
|
|
|
Vector vecDiff = (vecTargetPos - vecSourcePos);
|
|
|
|
float flHeight = vecDiff.z;
|
|
float flDist = vecDiff.Length2D();
|
|
float flVelocity = (pVictim->IsPlayer() || bForcePlayer ) ? (float)m_flPlayerVelocity : (float)m_flPhysicsVelocity;
|
|
float flGravity = -1.0f*GetCurrentGravity();
|
|
|
|
|
|
if( flDist == 0.f )
|
|
{
|
|
DevWarning( "Bad location input for catapult!\n" );
|
|
return CalculateLaunchVector(pVictim, pTarget);
|
|
}
|
|
|
|
float flRadical = flVelocity*flVelocity*flVelocity*flVelocity - flGravity*(flGravity*flDist*flDist - 2.f*flHeight*flVelocity*flVelocity);
|
|
|
|
if( flRadical <= 0.f )
|
|
{
|
|
DevWarning( "Catapult can't hit target! Add more speed!\n" );
|
|
return CalculateLaunchVector(pVictim, pTarget);
|
|
}
|
|
|
|
flRadical = ( sqrt( flRadical ) );
|
|
|
|
float flTestAngle1 = flVelocity*flVelocity;
|
|
float flTestAngle2 = flTestAngle1;
|
|
|
|
flTestAngle1 = -atan( (flTestAngle1 + flRadical) / (flGravity*flDist) );
|
|
flTestAngle2 = -atan( (flTestAngle2 - flRadical) / (flGravity*flDist) );
|
|
|
|
Vector vecTestVelocity1 = vecDiff;
|
|
vecTestVelocity1.z = 0;
|
|
vecTestVelocity1.NormalizeInPlace();
|
|
|
|
Vector vecTestVelocity2 = vecTestVelocity1;
|
|
|
|
vecTestVelocity1 *= flVelocity*cos( flTestAngle1 );
|
|
vecTestVelocity1.z = flVelocity*sin( flTestAngle1 );
|
|
|
|
vecTestVelocity2 *= flVelocity*cos( flTestAngle2 );
|
|
vecTestVelocity2.z = flVelocity*sin( flTestAngle2 );
|
|
|
|
vecInitialVelocity.NormalizeInPlace();
|
|
|
|
if( m_ExactVelocityChoice == 1 )
|
|
{
|
|
return vecTestVelocity1;
|
|
}
|
|
else if( m_ExactVelocityChoice == 2 )
|
|
{
|
|
return vecTestVelocity2;
|
|
}
|
|
|
|
if( vecInitialVelocity.Dot( vecTestVelocity1 ) > vecInitialVelocity.Dot( vecTestVelocity2 ) )
|
|
{
|
|
return vecTestVelocity1;
|
|
}
|
|
return vecTestVelocity2;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTriggerCatapult::LaunchByTarget( CBaseEntity *pVictim, CBaseEntity *pTarget )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
if( !GetPredictable() || !pVictim->GetPredictable() )
|
|
return;
|
|
#endif
|
|
|
|
Vector vecVictim;
|
|
if ( pVictim->VPhysicsGetObject() )
|
|
{
|
|
pVictim->VPhysicsGetObject()->GetVelocity( &vecVictim, NULL );
|
|
}
|
|
else
|
|
{
|
|
vecVictim = pVictim->GetAbsVelocity();
|
|
}
|
|
// get the launch vector
|
|
Vector vecVelocity = m_bUseExactVelocity ?
|
|
CalculateLaunchVectorPreserve( vecVictim, pVictim, pTarget ):
|
|
CalculateLaunchVector( pVictim, pTarget );
|
|
|
|
|
|
// Handle a player
|
|
if ( pVictim->IsPlayer() )
|
|
{
|
|
// Send us flying
|
|
if ( pVictim->GetFlags() & FL_ONGROUND )
|
|
{
|
|
pVictim->SetGroundEntity( NULL );
|
|
pVictim->SetGroundChangeTime( gpGlobals->curtime + 0.5f );
|
|
}
|
|
|
|
CTFPlayer *pPlayer = ToTFPlayer( pVictim );
|
|
if ( pPlayer )
|
|
{
|
|
float flSupressionTimeInSeconds = 0.25f;
|
|
if ( m_flAirControlSupressionTime > 0 )
|
|
{
|
|
// If set in the map, use this override time
|
|
flSupressionTimeInSeconds = m_flAirControlSupressionTime;
|
|
}
|
|
//pPlayer->SetAirControlSupressionTime( flSupressionTimeInSeconds * 1000.0f ); // fix units, this method expects milliseconds
|
|
pVictim->Teleport( NULL, NULL, &vecVelocity );
|
|
OnLaunchedVictim( pVictim );
|
|
|
|
#if defined( GAME_DLL ) && !defined( _GAMECONSOLE ) && !defined( NO_STEAM )
|
|
//g_PortalGameStats.Event_Catapult_LaunchByTarget( pPlayer, vecVelocity );
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( pVictim->GetMoveType() == MOVETYPE_VPHYSICS )
|
|
{
|
|
// Launch!
|
|
IPhysicsObject *pPhysObject = pVictim->VPhysicsGetObject();
|
|
if ( pPhysObject )
|
|
{
|
|
AngularImpulse angImpulse = m_bApplyAngularImpulse ? RandomAngularImpulse( -150.0f, 150.0f ) : vec3_origin;
|
|
pPhysObject->SetVelocityInstantaneous( &vecVelocity, &angImpulse );
|
|
|
|
// UNDONE: don't mess with physics properties
|
|
|
|
#if defined( GAME_DLL )
|
|
CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>(pVictim);
|
|
if ( pProp != NULL )
|
|
{
|
|
//HACK!
|
|
pProp->OnPhysGunDrop( UTIL_GetLocalPlayer(), LAUNCHED_BY_CANNON );
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
OnLaunchedVictim( pVictim );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTriggerCatapult::LaunchByDirection( CBaseEntity *pVictim )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
if( !GetPredictable() || !pVictim->GetPredictable() )
|
|
return;
|
|
#endif
|
|
|
|
Vector vecForward;
|
|
AngleVectors( m_vecLaunchAngles, &vecForward, NULL, NULL );
|
|
|
|
// Handle a player
|
|
if ( pVictim->IsPlayer() )
|
|
{
|
|
// Simply push us forward
|
|
Vector vecPush = vecForward * m_flPlayerVelocity;
|
|
|
|
// Hack on top of magic
|
|
if( CloseEnough( vecPush[0], 0.f ) && CloseEnough( vecPush[1],0.f ) )
|
|
{
|
|
vecPush[2] = m_flPlayerVelocity * 1.5f; // FIXME: Magic!
|
|
}
|
|
|
|
// Send us flying
|
|
if ( pVictim->GetFlags() & FL_ONGROUND )
|
|
{
|
|
pVictim->SetGroundEntity( NULL );
|
|
pVictim->SetGroundChangeTime( gpGlobals->curtime + 0.5f );
|
|
}
|
|
|
|
pVictim->SetAbsVelocity( vecPush );
|
|
OnLaunchedVictim( pVictim );
|
|
|
|
// Do air control suppression
|
|
if( m_bDirectionSuppressAirControl )
|
|
{
|
|
float flSupressionTimeInSeconds = 0.25f;
|
|
if ( m_flAirControlSupressionTime > 0 )
|
|
{
|
|
// If set in the map, use this override time
|
|
flSupressionTimeInSeconds = m_flAirControlSupressionTime;
|
|
}
|
|
|
|
//CTFPlayer* pTFPlayer = static_cast<CTFPlayer*>(pVictim);
|
|
//pTFPlayer->SetAirControlSupressionTime( flSupressionTimeInSeconds * 1000.0f ); // fix units, this method expects milliseconds
|
|
}
|
|
|
|
#if defined( GAME_DLL ) && !defined( _GAMECONSOLE ) && !defined( NO_STEAM )
|
|
//g_PortalGameStats.Event_Catapult_LaunchByDirection( ToPortalPlayer(pVictim), vecPush );
|
|
#endif
|
|
}
|
|
#if defined( GAME_DLL )
|
|
else
|
|
{
|
|
if ( pVictim->GetMoveType() == MOVETYPE_VPHYSICS )
|
|
{
|
|
// Launch!
|
|
IPhysicsObject *pPhysObject = pVictim->VPhysicsGetObject();
|
|
if ( pPhysObject )
|
|
{
|
|
Vector vecVelocity = vecForward * m_flPhysicsVelocity;
|
|
vecVelocity[2] = m_flPhysicsVelocity;
|
|
|
|
AngularImpulse angImpulse = RandomAngularImpulse( -50.0f, 50.0f );
|
|
|
|
pPhysObject->SetVelocityInstantaneous( &vecVelocity, &angImpulse );
|
|
|
|
// Force this!
|
|
float flNull = 0.0f;
|
|
pPhysObject->SetDragCoefficient( &flNull, &flNull );
|
|
pPhysObject->SetDamping( &flNull, &flNull );
|
|
|
|
CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>(pVictim);
|
|
if ( pProp != NULL )
|
|
{
|
|
//HACK!
|
|
pProp->OnPhysGunDrop( UTIL_GetLocalPlayer(), LAUNCHED_BY_CANNON );
|
|
}
|
|
}
|
|
}
|
|
OnLaunchedVictim( pVictim );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTriggerCatapult::OnLaunchedVictim( CBaseEntity *pVictim )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
if( !GetPredictable() || !pVictim->GetPredictable() )
|
|
return;
|
|
#endif
|
|
|
|
#if defined( GAME_DLL )
|
|
m_OnCatapulted.FireOutput( pVictim, this );
|
|
#endif
|
|
|
|
if ( pVictim->IsPlayer() )
|
|
{
|
|
CTFPlayer *pPlayer = static_cast< CTFPlayer* >( pVictim );
|
|
int nRefireIndex = pPlayer->entindex();
|
|
#if defined( GAME_DLL )
|
|
m_flRefireDelay[ nRefireIndex ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#else
|
|
m_flRefireDelay[ nRefireIndex ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#if defined( GAME_DLL )
|
|
m_flRefireDelay[ 0 ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#else
|
|
m_flRefireDelay[ 0 ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTriggerCatapult::StartTouch( CBaseEntity *pOther )
|
|
{
|
|
if ( pOther == NULL )
|
|
return;
|
|
|
|
#if defined( CLIENT_DLL )
|
|
if( !GetPredictable() || !pOther->GetPredictable() )
|
|
return;
|
|
#endif
|
|
|
|
//Warning( "CTriggerCatapult::StartTouch( %i %s %f )\n", entindex(), gpGlobals->IsClient() ? "client" : "server", gpGlobals->curtime );
|
|
|
|
|
|
#if defined( GAME_DLL )
|
|
if ( PassesTriggerFilters( pOther ) == false )
|
|
#else
|
|
if( !(pOther->IsPlayer() && m_bPlayersPassTriggerFilters) )
|
|
#endif
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Don't refire too quickly
|
|
int nRefireIndex = pOther->IsPlayer() ? static_cast< CBasePlayer* >( pOther )->entindex() : 0;
|
|
if ( nRefireIndex >= MAX_PLAYERS + 1 )
|
|
{
|
|
Warning( "CTriggerCatapult::StartTouch Trying to store a refire index for an entity( %d ) outside the expected range ( < %d ).\n", nRefireIndex, MAX_PLAYERS + 1 );
|
|
nRefireIndex = 0;
|
|
}
|
|
|
|
if ( m_flRefireDelay[ nRefireIndex ] > gpGlobals->curtime )
|
|
{
|
|
// but also don't forget to try again
|
|
if ( m_hAbortedLaunchees.Find( pOther ) == -1 )
|
|
{
|
|
m_hAbortedLaunchees.AddToTail( pOther );
|
|
}
|
|
SetThink( &CTriggerCatapult::LaunchThink );
|
|
SetNextThink( gpGlobals->curtime + 0.05f );
|
|
return;
|
|
}
|
|
|
|
#if defined( GAME_DLL )
|
|
// Don't touch things the player is holding
|
|
if ( pOther->VPhysicsGetObject() && (pOther->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD) )
|
|
{
|
|
if ( m_hAbortedLaunchees.Find( pOther ) == -1 )
|
|
{
|
|
m_hAbortedLaunchees.AddToTail( pOther );
|
|
}
|
|
SetThink( &CTriggerCatapult::LaunchThink );
|
|
SetNextThink( gpGlobals->curtime + 0.05f );
|
|
return;
|
|
}
|
|
else if ( pOther->IsPlayer() )
|
|
{
|
|
// Always keep players in this list in case the were trapped under another player in the previous launch
|
|
if ( m_hAbortedLaunchees.Find( pOther ) == -1 )
|
|
{
|
|
m_hAbortedLaunchees.AddToTail( pOther );
|
|
}
|
|
SetThink( &CTriggerCatapult::LaunchThink );
|
|
SetNextThink( gpGlobals->curtime + 0.05f );
|
|
}
|
|
#endif
|
|
|
|
// Get the target
|
|
CBaseEntity *pLaunchTarget = m_hLaunchTarget;
|
|
|
|
// See if we're attempting to hit a target
|
|
if ( pLaunchTarget )
|
|
{
|
|
// See if we are using the threshold check
|
|
if ( m_bUseThresholdCheck )
|
|
{
|
|
// Get the velocity of the physics objects / players touching the catapult
|
|
Vector vecVictim;
|
|
if ( pOther->IsPlayer() )
|
|
{
|
|
vecVictim = pOther->GetAbsVelocity();
|
|
}
|
|
else if( pOther->VPhysicsGetObject() )
|
|
{
|
|
pOther->VPhysicsGetObject()->GetVelocity( &vecVictim, NULL );
|
|
}
|
|
else
|
|
{
|
|
// DevMsg("Catapult fail!! Object is not a player and has no physics object! BUG THIS\n");
|
|
vecVictim = vec3_origin;
|
|
}
|
|
|
|
float flVictimSpeed = vecVictim.Length();
|
|
|
|
// get the speed needed to hit the target
|
|
Vector vecVelocity;
|
|
if( m_bUseExactVelocity )
|
|
{
|
|
vecVelocity = CalculateLaunchVectorPreserve( vecVictim, pOther, pLaunchTarget );
|
|
}
|
|
else
|
|
{
|
|
vecVelocity = CalculateLaunchVector( pOther, pLaunchTarget );
|
|
}
|
|
float flLaunchSpeed = vecVelocity.Length();
|
|
|
|
// is the victim facing the target?
|
|
Vector vecDirection = ( pLaunchTarget->GetAbsOrigin() - pOther->GetAbsOrigin() );
|
|
Vector necNormalizedVictim = vecVictim;
|
|
Vector vecNormalizedDirection = vecDirection;
|
|
|
|
necNormalizedVictim.NormalizeInPlace();
|
|
vecNormalizedDirection.NormalizeInPlace();
|
|
|
|
float flDot = DotProduct( necNormalizedVictim, vecNormalizedDirection );
|
|
if ( flDot >= m_flEntryAngleTolerance )
|
|
{
|
|
// Is the victim speed within tolerance to launch them?
|
|
if ( ( ( flLaunchSpeed - (flLaunchSpeed * m_flLowerThreshold ) ) < flVictimSpeed ) && ( ( flLaunchSpeed + (flLaunchSpeed * m_flUpperThreshold ) ) > flVictimSpeed ) )
|
|
{
|
|
if( m_bOnlyVelocityCheck )
|
|
{
|
|
OnLaunchedVictim( pOther );
|
|
}
|
|
else
|
|
{
|
|
// Launch!
|
|
LaunchByTarget( pOther, pLaunchTarget );
|
|
// DevMsg( 1, "Catapult \"%s\" is adjusting velocity of \"%s\" so it will hit the target. (Object Velocity: %.1f -- Object needed to be between %.1f and %.1f \n", STRING(GetEntityName()), pOther->GetClassname(), flVictimSpeed, flLaunchSpeed - (flLaunchSpeed * m_flLowerThreshold ), flLaunchSpeed + (flLaunchSpeed * m_flUpperThreshold ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// DevMsg( 1, "Catapult \"%s\" ignoring object \"%s\" because its velocity is outside of the threshold. (Object Velocity: %.1f -- Object needed to be between %.1f and %.1f \n", STRING(GetEntityName()), pOther->GetClassname(), flVictimSpeed, flLaunchSpeed - (flLaunchSpeed * m_flLowerThreshold ), flLaunchSpeed + (flLaunchSpeed * m_flUpperThreshold ) );
|
|
// since we attempted a fling set the refire delay
|
|
#if defined( GAME_DLL )
|
|
m_flRefireDelay[ nRefireIndex ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#else
|
|
m_flRefireDelay[ nRefireIndex ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we're facing the wrong way. set the refire delay.
|
|
#if defined( GAME_DLL )
|
|
m_flRefireDelay[ nRefireIndex ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#else
|
|
m_flRefireDelay[ nRefireIndex ] = gpGlobals->curtime + 0.5f; // HACK!
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LaunchByTarget( pOther, pLaunchTarget );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
if( m_hLaunchTarget.IsValid() )
|
|
{
|
|
Warning( "Catapult launch target not networked to client! This will make prediction fail! Fix this in the map.\n"
|
|
"Catapult launch target not networked to client! This will make prediction fail! Fix this in the map.\n"
|
|
"Catapult launch target not networked to client! This will make prediction fail! Fix this in the map.\n"
|
|
"Catapult launch target not networked to client! This will make prediction fail! Fix this in the map.\n"
|
|
"Catapult launch target not networked to client! This will make prediction fail! Fix this in the map.\n" );
|
|
}
|
|
#endif
|
|
|
|
bool bShouldLaunch = true;
|
|
|
|
if( m_bUseThresholdCheck )
|
|
{
|
|
// Get the velocity of the physics objects / players touching the catapult
|
|
Vector vecVictim;
|
|
if ( pOther->IsPlayer() )
|
|
{
|
|
vecVictim = pOther->GetAbsVelocity();
|
|
}
|
|
else if( pOther->VPhysicsGetObject() )
|
|
{
|
|
pOther->VPhysicsGetObject()->GetVelocity( &vecVictim, NULL );
|
|
}
|
|
else
|
|
{
|
|
// DevMsg("Catapult fail!! Object is not a player and has no physics object! BUG THIS\n");
|
|
vecVictim = vec3_origin;
|
|
}
|
|
|
|
Vector vecForward;
|
|
AngleVectors( m_vecLaunchAngles, &vecForward, NULL, NULL );
|
|
|
|
float flDot = DotProduct( vecForward, vecVictim );
|
|
float flLower = m_flPlayerVelocity - (m_flPlayerVelocity * m_flLowerThreshold);
|
|
float flUpper = m_flPlayerVelocity + (m_flPlayerVelocity * m_flUpperThreshold);
|
|
if( flDot < flLower || flDot > flUpper )
|
|
{
|
|
bShouldLaunch = false;
|
|
}
|
|
}
|
|
|
|
if( bShouldLaunch )
|
|
{
|
|
#if defined( CLIENT_DLL )
|
|
CEG_PROTECT_VIRTUAL_FUNCTION ( CTriggerCatapult_StartTouch );
|
|
#endif
|
|
if( m_bOnlyVelocityCheck )
|
|
{
|
|
OnLaunchedVictim( pOther );
|
|
}
|
|
else
|
|
{
|
|
LaunchByDirection( pOther );
|
|
}
|
|
}
|
|
}
|
|
}
|