mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 22:27:05 +00:00
763 lines
24 KiB
C++
763 lines
24 KiB
C++
//========= 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();
|
|
}
|