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.
88 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 2d17c2b52f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2d17c2b52f'
${ noResults }
source-engine/game/server/tf2/tf_basefourwheelvehicle.cpp

762 lines
24 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: A moving vehicle that is used as a battering ram
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_basefourwheelvehicle.h"
#include "engine/IEngineSound.h"
#include "soundenvelope.h"
#include "vcollide_parse.h"
#include "in_buttons.h"
#include "tf_movedata.h"
#define BASEFOURWHEELEDVEHICLE_THINK_CONTEXT "BaseFourWheeledThink"
#define BASEFOURWHEELEDVEHICLE_DEPLOYTHINK_CONTEXT "BaseFourWheeledDeployThink"
// HACK HAC
#define BASEFOURWHEELEDVEHICLE_STOPTHERODEO_CONTEXT "BaseFourWheeledVehicleStopTheRodeoMadnessThink"
ConVar road_feel( "road_feel", "0.1", FCVAR_NOTIFY | FCVAR_REPLICATED );
extern ConVar tf_fastbuild;
BEGIN_DATADESC( CBaseTFFourWheelVehicle )
DEFINE_EMBEDDED( m_VehiclePhysics ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "Throttle", InputThrottle ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "Steer", InputSteering ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "Action", InputAction ),
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOn", InputTurnOn ),
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOff", InputTurnOff ),
END_DATADESC()
// Used for debugging to make vehicle deploying go really fast.
ConVar tf_fastdeploy( "tf_fastdeploy", "0", FCVAR_CHEAT );
IMPLEMENT_SERVERCLASS_ST(CBaseTFFourWheelVehicle, DT_BaseTFFourWheelVehicle)
SendPropFloat( SENDINFO( m_flDeployFinishTime ), 0, SPROP_NOSCALE ),
SendPropInt( SENDINFO( m_eDeployMode ), NUM_VEHICLE_DEPLOYMODE_BITS, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bBoostUpgrade ), 1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nBoostTimeLeft ), 8, SPROP_UNSIGNED ),
END_SEND_TABLE()
ConVar fourwheelvehicle_hit_damage( "fourwheelvehicle_hit_damage","40", FCVAR_NONE, "Four-wheel vehicle hit damage" );
ConVar fourwheelvehicle_hit_damage_boostmod( "fourwheelvehicle_hit_damage_boostmod", "1.5", FCVAR_NONE, "Four-wheel vehicle boosted hit damage modifier" );
ConVar fourwheelvehicle_hit_mindamagevel( "fourwheelvehicle_hit_mindamagevel","100", FCVAR_NONE, "Four-wheel vehciel hit velocity for min damage" );
ConVar fourwheelvehicle_hit_maxdamagevel( "fourwheelvehicle_hit_maxdamagevel","230", FCVAR_NONE, "Four-wheel vehicle hit velocity for max damage" );
ConVar fourwheelvehicle_impact_time( "fourwheelvehicle_impact_time", "1.0", FCVAR_NONE, "Four-wheel vehicle impact wait time." );
ConVar fourwheelvehicle_hit_damage_player( "fourwheelvehicle_hit_damage_player", "30.0f", FCVAR_NONE, "Four-wheel vehicle hit player damage." );
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
#pragma warning( disable: 4355 )
CBaseTFFourWheelVehicle::CBaseTFFourWheelVehicle() : m_VehiclePhysics(this)
{
m_flDeployFinishTime = -1;
}
#pragma warning( default: 4355 )
//-----------------------------------------------------------------------------
// Destructor
//-----------------------------------------------------------------------------
CBaseTFFourWheelVehicle::~CBaseTFFourWheelVehicle ()
{
}
//-----------------------------------------------------------------------------
// Purpose: Put a vehicle in a deploy state. Turn off the engine and run a
// deploy animation.
//-----------------------------------------------------------------------------
bool CBaseTFFourWheelVehicle::Deploy( void )
{
// Make sure we're allowed to deploy here
if ( !IsReadyToDrive() )
return false;
// Check to see if we are already in a deploy mode.
if ( m_eDeployMode != VEHICLE_MODE_NORMAL )
return false;
// Disable the vehicle's motion.
DisableMotion();
// Save pre-deploy activity.
m_PreDeployActivity = GetActivity();
// Set the deploying activity - ACT_DEPLOY
SetActivity( ACT_DEPLOY );
// Get the deployment time.
float flDeployTime = SequenceDuration();
if ( tf_fastdeploy.GetBool() )
flDeployTime = 1;
m_flDeployFinishTime = gpGlobals->curtime + flDeployTime;
SetContextThink( BaseFourWheeledVehicleDeployThink, gpGlobals->curtime + flDeployTime,
BASEFOURWHEELEDVEHICLE_DEPLOYTHINK_CONTEXT );
// Set the deploy mode.
m_eDeployMode = VEHICLE_MODE_DEPLOYING;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Release a vehicle from a deployed state. Run a de-coupling
// animation and turn on the vehicle.
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::UnDeploy( void )
{
// Make sure we are deployed.
if ( !IsDeployed() )
return;
// Enable motion and turn on the vehicle.
EnableMotion();
// Set the undeploying activity - ACT_UNDEPLOY
SetActivity( ACT_UNDEPLOY );
// Get the undeployment time.
float flUnDeployTime = SequenceDuration();
if ( tf_fastdeploy.GetBool() )
flUnDeployTime = 1;
m_flDeployFinishTime = gpGlobals->curtime + flUnDeployTime;
SetContextThink( BaseFourWheeledVehicleDeployThink, gpGlobals->curtime + flUnDeployTime,
BASEFOURWHEELEDVEHICLE_DEPLOYTHINK_CONTEXT );
// Set the deploy mode.
m_eDeployMode = VEHICLE_MODE_UNDEPLOYING;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::CancelDeploy( void )
{
// Check for the deploying state.
if ( !IsDeploying() )
return;
// Re-enable the motion.
EnableMotion();
// Reset the activity to the previous activity.
SetActivity( m_PreDeployActivity );
// Reset the deploy mode.
m_eDeployMode = VEHICLE_MODE_NORMAL;
m_flDeployFinishTime = -1;
// Turn off the context think.
SetContextThink( NULL, 0, BASEFOURWHEELEDVEHICLE_DEPLOYTHINK_CONTEXT );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::BaseFourWheeledVehicleDeployThink( void )
{
// Called from deploy.
if ( IsDeploying() )
{
OnFinishedDeploy();
m_flDeployFinishTime = -1;
}
// Called from undeploy.
else if ( IsUndeploying() )
{
OnFinishedUnDeploy();
m_flDeployFinishTime = -1;
}
// Turn off the context think.
SetContextThink( NULL, 0, BASEFOURWHEELEDVEHICLE_DEPLOYTHINK_CONTEXT );
}
void CBaseTFFourWheelVehicle::BaseFourWheeledVehicleStopTheRodeoMadnessThink( void )
{
// HACK HACK: See note above at FinishBuilding call
// This resets the handbrake, so the newly placed object doesn't roll down any hills.
m_VehiclePhysics.ResetControls();
// Turn off the context think.
SetContextThink( NULL, 0, BASEFOURWHEELEDVEHICLE_STOPTHERODEO_CONTEXT );
// Start our base think
SetContextThink( BaseFourWheeledVehicleThink, gpGlobals->curtime + 0.1, BASEFOURWHEELEDVEHICLE_THINK_CONTEXT );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::OnFinishedDeploy( void )
{
SetActivity( ACT_DEPLOY_IDLE );
m_eDeployMode = VEHICLE_MODE_DEPLOYED;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::OnFinishedUnDeploy( void )
{
m_eDeployMode = VEHICLE_MODE_NORMAL;
}
//-----------------------------------------------------------------------------
// Purpose: Allow the vehicle to move.
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::EnableMotion( void )
{
// Enable vehicle chasis motion.
IPhysicsObject *pVehicleObject = VPhysicsGetObject();
if ( pVehicleObject )
{
pVehicleObject->EnableMotion( true );
}
// Enable motion on the tires.
m_VehiclePhysics.EnableMotion();
}
//-----------------------------------------------------------------------------
// Purpose: Dis-allow the vehicle to move.
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::DisableMotion( void )
{
// Disable vehicle chasis motion.
IPhysicsObject *pVehicleObject = VPhysicsGetObject();
if ( pVehicleObject )
{
pVehicleObject->EnableMotion( false );
}
// Disable motion on the tires.
m_VehiclePhysics.DisableMotion();
}
//-----------------------------------------------------------------------------
// Precache
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::Precache()
{
BaseClass::Precache();
PrecacheScriptSound( "BaseTFFourWheelVehicle.EMP" );
PrecacheScriptSound( "BaseTFFourWheelVehicle.RamSound" );
}
//-----------------------------------------------------------------------------
// Spawn
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::Spawn( )
{
SetModel( STRING( GetModelName() ) );
// CFourWheelServerVehicle *pServerVehicle = dynamic_cast<CFourWheelServerVehicle*>(GetServerVehicle());
// m_VehiclePhysics.SetOuter( this, pServerVehicle );
m_VehiclePhysics.Spawn();
BaseClass::Spawn();
// The base class spawn sets a default collision group, so this needs to
// be called post.
SetCollisionGroup( COLLISION_GROUP_VEHICLE );
m_eDeployMode = VEHICLE_MODE_NORMAL;
SetBoostUpgrade( false );
m_flNextHitTime = 0.0f;
}
//-----------------------------------------------------------------------------
// Teleport
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity )
{
// We basically just have to make sure the wheels are in the right place
// after teleportation occurs
matrix3x4_t startMatrixInv;
MatrixInvert( EntityToWorldTransform(), startMatrixInv );
BaseClass::Teleport( newPosition, newAngles, newVelocity );
// Teleport the vehicle physics from the starting position to the ending one
matrix3x4_t relativeTransform;
ConcatTransforms( EntityToWorldTransform(), startMatrixInv, relativeTransform );
m_VehiclePhysics.Teleport( relativeTransform );
}
//-----------------------------------------------------------------------------
// Debugging methods
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::DrawDebugGeometryOverlays()
{
if (m_debugOverlays & OVERLAY_BBOX_BIT)
{
m_VehiclePhysics.DrawDebugGeometryOverlays();
}
BaseClass::DrawDebugGeometryOverlays();
}
int CBaseTFFourWheelVehicle::DrawDebugTextOverlays()
{
int nOffset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
nOffset = m_VehiclePhysics.DrawDebugTextOverlays( nOffset );
}
return nOffset;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFFourWheelVehicle::StartBuilding( CBaseEntity *pPlayer )
{
if (!BaseClass::StartBuilding(pPlayer))
return false;
// Until we're finished building, turn off vphysics-based motion
SetSolid( SOLID_VPHYSICS );
VPhysicsInitStatic();
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::FinishedBuilding( void )
{
BaseClass::FinishedBuilding();
char pScriptName[128];
Q_snprintf( pScriptName, sizeof( pScriptName ), "scripts/vehicles/%s.txt", GetClassname() );
m_VehiclePhysics.Initialize( pScriptName, true );
// HACK HACK: This is a hack to avoid physics spazzing out on a newly created vehicle with the handbrake
// set. We create and activate it, but then release the handbrake for a single Think function call and
// then zero out the controls right then. This seems to stabilize something in the physics simulator.
m_VehiclePhysics.ReleaseHandbrake();
SetContextThink( BaseFourWheeledVehicleStopTheRodeoMadnessThink, gpGlobals->curtime, BASEFOURWHEELEDVEHICLE_STOPTHERODEO_CONTEXT );
ResetDeteriorationTime();
}
//-----------------------------------------------------------------------------
// Input methods
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::InputThrottle( inputdata_t &inputdata )
{
m_VehiclePhysics.SetThrottle( inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::InputSteering( inputdata_t &inputdata )
{
m_VehiclePhysics.SetSteering( inputdata.value.Float(), 2*gpGlobals->frametime );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::InputAction( inputdata_t &inputdata )
{
m_VehiclePhysics.SetAction( inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::InputTurnOn( inputdata_t &inputdata )
{
if (!m_VehiclePhysics.IsOn())
{
SetContextThink( BaseFourWheeledVehicleThink, gpGlobals->curtime + 0.1, BASEFOURWHEELEDVEHICLE_THINK_CONTEXT );
m_VehiclePhysics.TurnOn( );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::InputTurnOff( inputdata_t &inputdata )
{
if ( m_VehiclePhysics.IsOn() )
{
m_VehiclePhysics.TurnOff( );
}
}
//-----------------------------------------------------------------------------
// Input methods
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::BaseFourWheeledVehicleThink()
{
if (m_VehiclePhysics.Think())
{
SetNextThink( gpGlobals->curtime, BASEFOURWHEELEDVEHICLE_THINK_CONTEXT );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::VPhysicsUpdate( IPhysicsObject *pPhysics )
{
// must be a wheel
if (!m_VehiclePhysics.VPhysicsUpdate(pPhysics))
return;
BaseClass::VPhysicsUpdate( pPhysics );
}
//-----------------------------------------------------------------------------
// Methods related to getting in and out of the vehicle
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::SetPassenger( int nRole, CBasePlayer *pEnt )
{
if ( nRole == VEHICLE_ROLE_DRIVER )
{
if (pEnt)
{
PlayerControlInit( ToBasePlayer(pEnt) );
}
else
{
PlayerControlShutdown( );
}
}
BaseClass::SetPassenger( nRole, pEnt );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::PlayerControlInit( CBasePlayer *pPlayer )
{
// Blat out the view offset
m_savedViewOffset = pPlayer->GetViewOffset();
pPlayer->SetViewOffset( vec3_origin );
m_playerOn.FireOutput( pPlayer, this, 0 );
InputTurnOn( inputdata_t() );
// Release the handbrake.
if ( !IsDeployed() )
{
m_VehiclePhysics.ReleaseHandbrake();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::ResetUseKey( CBasePlayer *pPlayer )
{
pPlayer->m_afButtonPressed &= ~IN_USE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::PlayerControlShutdown()
{
CBasePlayer *pPlayer = GetDriverPlayer();
if ( !pPlayer )
return;
ResetUseKey( pPlayer );
pPlayer->SetViewOffset( m_savedViewOffset );
m_playerOff.FireOutput( pPlayer, this, 0 );
// clear out the fire buttons
m_attackaxis.Set( 0, pPlayer, this );
m_attack2axis.Set( 0, pPlayer, this );
InputTurnOff( inputdata_t() );
}
//-----------------------------------------------------------------------------
// Purpose: Powerup has just started
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::PowerupStart( int iPowerup, float flAmount, CBaseEntity *pAttacker, CDamageModifier *pDamageModifier )
{
switch( iPowerup )
{
case POWERUP_EMP:
m_VehiclePhysics.SetMaxThrottle( 0.1 );
break;
default:
break;
}
BaseClass::PowerupStart( iPowerup, flAmount, pAttacker, pDamageModifier );
}
//-----------------------------------------------------------------------------
// Purpose: Powerup has just started
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::PowerupEnd( int iPowerup )
{
switch ( iPowerup )
{
case POWERUP_EMP:
m_VehiclePhysics.SetMaxThrottle( 1.0 );
break;
default:
break;
}
BaseClass::PowerupEnd( iPowerup );
}
//-----------------------------------------------------------------------------
// Methods related to actually driving the vehicle
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::DriveVehicle( CBasePlayer *pPlayer, CUserCmd *ucmd )
{
// Lose control when the player dies
if ( pPlayer->IsAlive() == false )
return;
// Only the driver gets to drive.
int nRole = GetPassengerRole( pPlayer );
if ( nRole != VEHICLE_ROLE_DRIVER )
return;
// No driving in the mothership, kids
if ( !tf_fastbuild.GetInt() && !IsReadyToDrive() )
{
m_VehiclePhysics.SetHandbrake( true );
m_VehiclePhysics.SetThrottle( 0 );
m_VehiclePhysics.SetSteering( 0, 0 );
m_attackaxis.Set( 0, pPlayer, this );
m_attack2axis.Set( 0, pPlayer, this );
return;
}
// Update the boost time.
m_nBoostTimeLeft = m_VehiclePhysics.BoostTimeLeft();
// If the vehicle's emped, it can't drive
if ( HasPowerup( POWERUP_EMP ) )
{
// Play sounds if they're trying to drive
if ( ucmd->buttons & (IN_MOVELEFT | IN_MOVERIGHT | IN_FORWARD | IN_BACK) )
{
if ( m_flNextEmpSound < gpGlobals->curtime )
{
EmitSound( "BaseTFFourWheelVehicle.EMP" );
m_flNextEmpSound = gpGlobals->curtime + 2.0;
}
}
}
ResetDeteriorationTime();
m_VehiclePhysics.UpdateDriverControls( ucmd, TICK_INTERVAL );
float attack = 0, attack2 = 0;
if ( pPlayer->m_afButtonPressed & IN_ATTACK )
{
m_pressedAttack.FireOutput( pPlayer, this, 0 );
}
if ( pPlayer->m_afButtonPressed & IN_ATTACK2 )
{
m_pressedAttack2.FireOutput( pPlayer, this, 0 );
}
if ( ucmd->buttons & IN_ATTACK )
{
attack = 1;
}
if ( ucmd->buttons & IN_ATTACK2 )
{
attack2 = 1;
}
m_attackaxis.Set( attack, pPlayer, this );
m_attack2axis.Set( attack2, pPlayer, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::SetupMove( CBasePlayer *pPlayer, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
{
BaseClass::SetupMove( pPlayer, ucmd, pHelper, move );
if ( IsDeployed() )
return;
DriveVehicle( pPlayer, ucmd );
m_nMovementRole = GetPassengerRole( pPlayer );
Assert( m_nMovementRole >= 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::SetBoostUpgrade( bool bBoostUpgrade )
{
m_bBoostUpgrade = bBoostUpgrade;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFFourWheelVehicle::IsBoostable( void )
{
return m_bBoostUpgrade;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::StartBoost( void )
{
if ( IsBoostable() )
{
m_VehiclePhysics.SetBoost( 1.0f );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFFourWheelVehicle::IsBoosting( void )
{
return m_VehiclePhysics.IsBoosting();
}
//-----------------------------------------------------------------------------
// Purpose: Vehicle damage!
//-----------------------------------------------------------------------------
void CBaseTFFourWheelVehicle::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
BaseClass::VPhysicsCollision( index, pEvent );
int otherIndex = !index;
CBaseEntity *pEntity = pEvent->pEntities[otherIndex];
// We only damage objects...
// And only if we're travelling fast enough...
Assert( pEntity );
if ( !pEntity->IsSolid() )
return;
// Ignore shields..
if ( pEntity->GetCollisionGroup() == TFCOLLISION_GROUP_SHIELD )
return;
// Ignore anything that's not an object
if ( pEntity->Classify() != CLASS_MILITARY && !pEntity->IsPlayer() )
return;
// Ignore teammates
if ( InSameTeam( pEntity ))
return;
// Ignore invulnerable stuff
if ( pEntity->m_takedamage == DAMAGE_NO )
return;
// See if we can damage again? (Time-based)
if ( m_flNextHitTime > gpGlobals->curtime )
return;
// Do damage based on velocity.
Vector vecVelocity = pEvent->preVelocity[index];
CTakeDamageInfo info;
info.SetInflictor( this );
info.SetAttacker( GetDriverPlayer() );
info.SetDamageType( DMG_CLUB );
float flMaxDamage = fourwheelvehicle_hit_damage.GetFloat();
float flMaxDamageVel = fourwheelvehicle_hit_maxdamagevel.GetFloat();
float flMinDamageVel = fourwheelvehicle_hit_mindamagevel.GetFloat();
float flVel = vecVelocity.Length();
if ( flVel < flMinDamageVel )
return;
EmitSound( "BaseTFFourWheelVehicle.RamSound" );
float flDamageFactor = flMaxDamage;
// Special damage for players.
if ( pEntity->IsPlayer() )
{
flDamageFactor = fourwheelvehicle_hit_damage_player.GetFloat();
if ( IsBoosting() )
{
flDamageFactor *= 4.0f;
}
// Knock the player up into the air
float flForceScale = (flVel*0.5) * 75 * 4;
Vector vecForce = vecVelocity;
VectorNormalize( vecForce );
vecForce.z += 0.7;
vecForce *= flForceScale;
info.SetDamageForce( vecForce );
}
// Damage to objects.
else
{
if ( IsBoosting() )
{
flDamageFactor *= fourwheelvehicle_hit_damage_boostmod.GetFloat();
}
if ( ( flMaxDamageVel > flMinDamageVel ) && ( flVel < flMaxDamageVel ) )
{
// Use less damage when we're not moving fast enough
float flVelocityFactor = ( flVel - flMinDamageVel ) / ( flMaxDamageVel - flMinDamageVel );
flVelocityFactor *= flVelocityFactor;
flDamageFactor *= flVelocityFactor;
}
}
info.SetDamage( flDamageFactor );
Vector damagePos;
pEvent->pInternalData->GetContactPoint( damagePos );
Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();
info.SetDamageForce( damageForce );
info.SetDamagePosition( damagePos );
PhysCallbackDamage( pEntity, info, *pEvent, index );
// Set next time hit time
m_flNextHitTime = gpGlobals->curtime + fourwheelvehicle_impact_time.GetFloat();
}