2748 lines
83 KiB
C++
2748 lines
83 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "vcollide_parse.h"
|
|
#include "vehicle_base.h"
|
|
#include "npc_vehicledriver.h"
|
|
#include "in_buttons.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "soundenvelope.h"
|
|
#include "SoundEmitterSystem/isoundemittersystembase.h"
|
|
#include "saverestore_utlvector.h"
|
|
#include "KeyValues.h"
|
|
#include "studio.h"
|
|
#include "bone_setup.h"
|
|
#include "collisionutils.h"
|
|
#include "animation.h"
|
|
#include "env_player_surface_trigger.h"
|
|
#include "rumble_shared.h"
|
|
|
|
#ifdef HL2_DLL
|
|
#include "hl2_player.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
ConVar g_debug_vehiclesound( "g_debug_vehiclesound", "0", FCVAR_CHEAT );
|
|
ConVar g_debug_vehicleexit( "g_debug_vehicleexit", "0", FCVAR_CHEAT );
|
|
|
|
ConVar sv_vehicle_autoaim_scale("sv_vehicle_autoaim_scale", "8");
|
|
|
|
bool ShouldVehicleIgnoreEntity( CBaseEntity *pVehicle, CBaseEntity *pCollide );
|
|
|
|
#define HITBOX_SET 2
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Save/load
|
|
//-----------------------------------------------------------------------------
|
|
BEGIN_DATADESC_NO_BASE( vehicle_gear_t )
|
|
|
|
DEFINE_FIELD( flMinSpeed, FIELD_FLOAT ),
|
|
DEFINE_FIELD( flMaxSpeed, FIELD_FLOAT ),
|
|
DEFINE_FIELD( flSpeedApproachFactor,FIELD_FLOAT ),
|
|
|
|
END_DATADESC()
|
|
|
|
BEGIN_DATADESC_NO_BASE( vehicle_crashsound_t )
|
|
DEFINE_FIELD( flMinSpeed, FIELD_FLOAT ),
|
|
DEFINE_FIELD( flMinDeltaSpeed, FIELD_FLOAT ),
|
|
DEFINE_FIELD( iszCrashSound, FIELD_STRING ),
|
|
DEFINE_FIELD( gearLimit, FIELD_INTEGER ),
|
|
END_DATADESC()
|
|
|
|
BEGIN_DATADESC_NO_BASE( vehiclesounds_t )
|
|
|
|
DEFINE_AUTO_ARRAY( iszSound, FIELD_STRING ),
|
|
DEFINE_UTLVECTOR( pGears, FIELD_EMBEDDED ),
|
|
DEFINE_UTLVECTOR( crashSounds, FIELD_EMBEDDED ),
|
|
DEFINE_AUTO_ARRAY( iszStateSounds, FIELD_STRING ),
|
|
DEFINE_AUTO_ARRAY( minStateTime, FIELD_FLOAT ),
|
|
|
|
END_DATADESC()
|
|
|
|
BEGIN_SIMPLE_DATADESC( CPassengerInfo )
|
|
DEFINE_FIELD( m_hPassenger, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_strRoleName, FIELD_STRING ),
|
|
DEFINE_FIELD( m_strSeatName, FIELD_STRING ),
|
|
// NOT SAVED
|
|
// DEFINE_FIELD( m_nRole, FIELD_INTEGER ),
|
|
// DEFINE_FIELD( m_nSeat, FIELD_INTEGER ),
|
|
END_DATADESC()
|
|
|
|
BEGIN_SIMPLE_DATADESC( CBaseServerVehicle )
|
|
|
|
// These are reset every time by the constructor of the owning class
|
|
// DEFINE_FIELD( m_pVehicle, FIELD_CLASSPTR ),
|
|
// DEFINE_FIELD( m_pDrivableVehicle; ??? ),
|
|
|
|
// Controls
|
|
DEFINE_FIELD( m_nNPCButtons, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_nPrevNPCButtons, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_flTurnDegrees, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_flVehicleVolume, FIELD_FLOAT ),
|
|
|
|
// We're going to reparse this data from file in Precache
|
|
DEFINE_EMBEDDED( m_vehicleSounds ),
|
|
|
|
DEFINE_FIELD( m_iSoundGear, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_flSpeedPercentage, FIELD_FLOAT ),
|
|
DEFINE_SOUNDPATCH( m_pStateSound ),
|
|
DEFINE_SOUNDPATCH( m_pStateSoundFade ),
|
|
DEFINE_FIELD( m_soundState, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_soundStateStartTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_lastSpeed, FIELD_FLOAT ),
|
|
|
|
// NOT SAVED
|
|
// DEFINE_FIELD( m_EntryAnimations, CUtlVector ),
|
|
// DEFINE_FIELD( m_ExitAnimations, CUtlVector ),
|
|
// DEFINE_FIELD( m_bParsedAnimations, FIELD_BOOLEAN ),
|
|
// DEFINE_UTLVECTOR( m_PassengerRoles, FIELD_EMBEDDED ),
|
|
|
|
DEFINE_FIELD( m_iCurrentExitAnim, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_vecCurrentExitEndPoint, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_chPreviousTextureType, FIELD_CHARACTER ),
|
|
|
|
DEFINE_FIELD( m_savedViewOffset, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_hExitBlocker, FIELD_EHANDLE ),
|
|
|
|
DEFINE_UTLVECTOR( m_PassengerInfo, FIELD_EMBEDDED ),
|
|
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Base class for drivable vehicle handling. Contain it in your
|
|
// drivable vehicle.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseServerVehicle::CBaseServerVehicle( void )
|
|
{
|
|
m_pVehicle = NULL;
|
|
m_pDrivableVehicle = NULL;
|
|
m_nNPCButtons = 0;
|
|
m_nPrevNPCButtons = 0;
|
|
m_flTurnDegrees = 0;
|
|
|
|
m_bParsedAnimations = false;
|
|
m_iCurrentExitAnim = 0;
|
|
m_vecCurrentExitEndPoint = vec3_origin;
|
|
|
|
m_flVehicleVolume = 0.5;
|
|
m_iSoundGear = 0;
|
|
m_pStateSound = NULL;
|
|
m_pStateSoundFade = NULL;
|
|
m_soundState = SS_NONE;
|
|
m_flSpeedPercentage = 0;
|
|
m_bUseLegacyExitChecks = false;
|
|
|
|
m_vehicleSounds.Init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBaseServerVehicle::~CBaseServerVehicle( void )
|
|
{
|
|
SoundShutdown(0);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::Precache( void )
|
|
{
|
|
int i;
|
|
// Precache our other sounds
|
|
for ( i = 0; i < VS_NUM_SOUNDS; i++ )
|
|
{
|
|
if ( m_vehicleSounds.iszSound[i] != NULL_STRING )
|
|
{
|
|
CBaseEntity::PrecacheScriptSound( STRING(m_vehicleSounds.iszSound[i]) );
|
|
}
|
|
}
|
|
for ( i = 0; i < m_vehicleSounds.crashSounds.Count(); i++ )
|
|
{
|
|
if ( m_vehicleSounds.crashSounds[i].iszCrashSound != NULL_STRING )
|
|
{
|
|
CBaseEntity::PrecacheScriptSound( STRING(m_vehicleSounds.crashSounds[i].iszCrashSound) );
|
|
}
|
|
}
|
|
|
|
for ( i = 0; i < SS_NUM_STATES; i++ )
|
|
{
|
|
if ( m_vehicleSounds.iszStateSounds[i] != NULL_STRING )
|
|
{
|
|
CBaseEntity::PrecacheScriptSound( STRING(m_vehicleSounds.iszStateSounds[i]) );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parses the vehicle's script for the vehicle sounds
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::Initialize( const char *pScriptName )
|
|
{
|
|
// Attempt to parse our vehicle script
|
|
if ( PhysFindOrAddVehicleScript( pScriptName, NULL, &m_vehicleSounds ) == false )
|
|
return false;
|
|
|
|
Precache();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::SetVehicle( CBaseEntity *pVehicle )
|
|
{
|
|
m_pVehicle = pVehicle;
|
|
m_pDrivableVehicle = dynamic_cast<IDrivableVehicle*>(m_pVehicle);
|
|
Assert( m_pDrivableVehicle );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
IDrivableVehicle *CBaseServerVehicle::GetDrivableVehicle( void )
|
|
{
|
|
Assert( m_pDrivableVehicle );
|
|
return m_pDrivableVehicle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the driver. Unlike GetPassenger(VEHICLE_ROLE_DRIVER), it will return
|
|
// the NPC driver if it has one.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CBaseServerVehicle::GetDriver( void )
|
|
{
|
|
return GetPassenger( VEHICLE_ROLE_DRIVER );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBaseCombatCharacter *CBaseServerVehicle::GetPassenger( int nRole )
|
|
{
|
|
Assert( nRole == VEHICLE_ROLE_DRIVER );
|
|
CBaseEntity *pDriver = GetDrivableVehicle()->GetDriver();
|
|
|
|
if ( pDriver == NULL )
|
|
return NULL;
|
|
|
|
return pDriver->MyCombatCharacterPointer();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::GetPassengerRole( CBaseCombatCharacter *pPassenger )
|
|
{
|
|
if ( pPassenger == GetDrivableVehicle()->GetDriver() )
|
|
return VEHICLE_ROLE_DRIVER;
|
|
|
|
return VEHICLE_ROLE_NONE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a passenger to the vehicle
|
|
// Input : nSeat - seat to sit in
|
|
// *pPassenger - character to enter
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::NPC_AddPassenger( CBaseCombatCharacter *pPassenger, string_t strRoleName, int nSeat )
|
|
{
|
|
// Players cannot yet use this code! - jdw
|
|
Assert( pPassenger != NULL && pPassenger->IsPlayer() == false );
|
|
if ( pPassenger == NULL || pPassenger->IsPlayer() )
|
|
return false;
|
|
|
|
// Find our role
|
|
int nRole = FindRoleIndexByName( strRoleName );
|
|
if ( nRole == -1 )
|
|
return false;
|
|
|
|
// Cannot evict a passenger already in this position
|
|
CBaseCombatCharacter *pCurrentPassenger = NPC_GetPassengerInSeat( nRole, nSeat );
|
|
if ( pCurrentPassenger == pPassenger )
|
|
return true;
|
|
|
|
// If we weren't the same passenger, we need to be empty
|
|
if ( pCurrentPassenger != NULL )
|
|
return false;
|
|
|
|
// Find the seat
|
|
for ( int i = 0; i < m_PassengerInfo.Count(); i++ )
|
|
{
|
|
if ( m_PassengerInfo[i].GetSeat() == nSeat && m_PassengerInfo[i].GetRole() == nRole )
|
|
{
|
|
m_PassengerInfo[i].m_hPassenger = pPassenger;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Removes a passenger from the vehicle
|
|
// Input : *pPassenger - Passenger to remove
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::NPC_RemovePassenger( CBaseCombatCharacter *pPassenger )
|
|
{
|
|
// Players cannot yet use this code! - jdw
|
|
Assert( pPassenger != NULL && pPassenger->IsPlayer() == false );
|
|
if ( pPassenger == NULL || pPassenger->IsPlayer() )
|
|
return false;
|
|
|
|
// Find the seat
|
|
for ( int i = 0; i < m_PassengerInfo.Count(); i++ )
|
|
{
|
|
if ( m_PassengerInfo[i].m_hPassenger == pPassenger )
|
|
{
|
|
m_PassengerInfo[i].m_hPassenger = NULL;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the attachment point index for the passenger's seat
|
|
// Input : *pPassenger - Passenger in the seat
|
|
// Output : int - Attachment point index for the vehicle
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::NPC_GetPassengerSeatAttachment( CBaseCombatCharacter *pPassenger )
|
|
{
|
|
// Get the role and seat the the supplied passenger
|
|
for ( int i = 0; i < m_PassengerInfo.Count(); i++ )
|
|
{
|
|
// If this is the passenger, get the attachment it'll be at
|
|
if ( m_PassengerInfo[i].m_hPassenger == pPassenger )
|
|
{
|
|
// The seat is the attachment point
|
|
int nSeat = m_PassengerInfo[i].GetSeat();
|
|
int nRole = m_PassengerInfo[i].GetRole();
|
|
|
|
return m_PassengerRoles[nRole].m_PassengerSeats[nSeat].GetAttachmentID();
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the worldspace position and angles of the specified seat
|
|
// Input : *pPassenger - Passenger's seat to use
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::NPC_GetPassengerSeatPosition( CBaseCombatCharacter *pPassenger, Vector *vecResultPos, QAngle *vecResultAngles )
|
|
{
|
|
// Get our attachment point
|
|
int nSeatAttachment = NPC_GetPassengerSeatAttachment( pPassenger );
|
|
if ( nSeatAttachment == -1 )
|
|
return false;
|
|
|
|
// Figure out which entrypoint hitbox the player is in
|
|
CBaseAnimating *pAnimating = dynamic_cast< CBaseAnimating * >( m_pVehicle );
|
|
if ( pAnimating == NULL )
|
|
return false;
|
|
|
|
Vector vecPos;
|
|
QAngle vecAngles;
|
|
pAnimating->GetAttachment( nSeatAttachment, vecPos, vecAngles );
|
|
|
|
if ( vecResultPos != NULL )
|
|
{
|
|
*vecResultPos = vecPos;
|
|
}
|
|
|
|
if ( vecResultAngles != NULL )
|
|
{
|
|
*vecResultAngles = vecAngles;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the localspace position and angles of the specified seat
|
|
// Input : *pPassenger - Passenger's seat to use
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::NPC_GetPassengerSeatPositionLocal( CBaseCombatCharacter *pPassenger, Vector *vecResultPos, QAngle *vecResultAngles )
|
|
{
|
|
// Get our attachment point
|
|
int nSeatAttachment = NPC_GetPassengerSeatAttachment( pPassenger );
|
|
if ( nSeatAttachment == -1 )
|
|
return false;
|
|
|
|
// Figure out which entrypoint hitbox the player is in
|
|
CBaseAnimating *pAnimating = m_pVehicle->GetBaseAnimating();
|
|
if ( pAnimating == NULL )
|
|
return false;
|
|
|
|
Vector vecPos;
|
|
QAngle vecAngles;
|
|
pAnimating->InvalidateBoneCache(); // NOTE: We're moving with velocity, so we're almost always out of date
|
|
pAnimating->GetAttachmentLocal( nSeatAttachment, vecPos, vecAngles );
|
|
|
|
if ( vecResultPos != NULL )
|
|
{
|
|
*vecResultPos = vecPos;
|
|
}
|
|
|
|
if ( vecResultAngles != NULL )
|
|
{
|
|
*vecResultAngles = vecAngles;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieves a list of animations used to enter/exit the seat occupied by the passenger
|
|
// Input : *pPassenger - Passenger who's seat anims to retrieve
|
|
// nType - which set of animations to retrieve
|
|
//-----------------------------------------------------------------------------
|
|
const PassengerSeatAnims_t *CBaseServerVehicle::NPC_GetPassengerSeatAnims( CBaseCombatCharacter *pPassenger, PassengerSeatAnimType_t nType )
|
|
{
|
|
// Get the role and seat the the supplied passenger
|
|
for ( int i = 0; i < m_PassengerInfo.Count(); i++ )
|
|
{
|
|
if ( m_PassengerInfo[i].m_hPassenger == pPassenger )
|
|
{
|
|
int nSeat = m_PassengerInfo[i].GetSeat();
|
|
int nRole = m_PassengerInfo[i].GetRole();
|
|
switch( nType )
|
|
{
|
|
case PASSENGER_SEAT_ENTRY:
|
|
return &m_PassengerRoles[nRole].m_PassengerSeats[nSeat].m_EntryTransitions;
|
|
break;
|
|
|
|
case PASSENGER_SEAT_EXIT:
|
|
return &m_PassengerRoles[nRole].m_PassengerSeats[nSeat].m_ExitTransitions;
|
|
break;
|
|
|
|
default:
|
|
return NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get and set the current driver. Use PassengerRole_t enum in shareddefs.h for adding passengers
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::SetPassenger( int nRole, CBaseCombatCharacter *pPassenger )
|
|
{
|
|
// Baseclass only handles vehicles with a single passenger
|
|
Assert( nRole == VEHICLE_ROLE_DRIVER );
|
|
|
|
if ( pPassenger != NULL && pPassenger->IsPlayer() == false )
|
|
{
|
|
// Use NPC_AddPassenger() for NPCs at the moment, these will all be collapsed into one system -- jdw
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
|
|
// Getting in? or out?
|
|
if ( pPassenger != NULL )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( pPassenger );
|
|
if ( pPlayer != NULL )
|
|
{
|
|
m_savedViewOffset = pPlayer->GetViewOffset();
|
|
pPlayer->SetViewOffset( vec3_origin );
|
|
pPlayer->ShowCrosshair( false );
|
|
|
|
GetDrivableVehicle()->EnterVehicle( pPassenger );
|
|
|
|
#ifdef HL2_DLL
|
|
// Stop the player sprint and flashlight.
|
|
CHL2_Player *pHL2Player = dynamic_cast<CHL2_Player*>( pPlayer );
|
|
if ( pHL2Player )
|
|
{
|
|
if ( pHL2Player->IsSprinting() )
|
|
{
|
|
pHL2Player->StopSprinting();
|
|
}
|
|
|
|
if ( pHL2Player->FlashlightIsOn() )
|
|
{
|
|
pHL2Player->FlashlightTurnOff();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetDriver() );
|
|
if ( pPlayer )
|
|
{
|
|
// Restore the exiting player's view offset
|
|
pPlayer->SetViewOffset( m_savedViewOffset );
|
|
pPlayer->ShowCrosshair( true );
|
|
}
|
|
|
|
GetDrivableVehicle()->ExitVehicle( nRole );
|
|
GetDrivableVehicle()->SetVehicleEntryAnim( false );
|
|
UTIL_Remove( m_hExitBlocker );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get a position in *world space* inside the vehicle for the player to start at
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::GetPassengerSeatPoint( int nRole, Vector *pPoint, QAngle *pAngles )
|
|
{
|
|
Assert( nRole == VEHICLE_ROLE_DRIVER );
|
|
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
|
|
if ( pAnimating )
|
|
{
|
|
char pAttachmentName[32];
|
|
Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_feet_passenger%d", nRole );
|
|
int nFeetAttachmentIndex = pAnimating->LookupAttachment(pAttachmentName);
|
|
int nIdleSequence = pAnimating->SelectWeightedSequence( ACT_IDLE );
|
|
if ( nFeetAttachmentIndex > 0 && nIdleSequence != -1 )
|
|
{
|
|
// FIXME: This really wants to be a faster query than this implementation!
|
|
Vector vecOrigin;
|
|
QAngle vecAngles;
|
|
if ( GetLocalAttachmentAtTime( nIdleSequence, nFeetAttachmentIndex, 0.0f, &vecOrigin, &vecAngles ) )
|
|
{
|
|
UTIL_ParentToWorldSpace( pAnimating, vecOrigin, vecAngles );
|
|
if ( pPoint )
|
|
{
|
|
*pPoint = vecOrigin;
|
|
}
|
|
|
|
if ( pAngles )
|
|
{
|
|
*pAngles = vecAngles;
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Couldn't find the attachment point, so just use the origin
|
|
if ( pPoint )
|
|
{
|
|
*pPoint = m_pVehicle->GetAbsOrigin();
|
|
}
|
|
|
|
if ( pAngles )
|
|
{
|
|
*pAngles = m_pVehicle->GetAbsAngles();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
// Check Exit Point for leaving vehicle.
|
|
//
|
|
// Input: yaw/roll from vehicle angle to check for exit
|
|
// distance from origin to drop player (allows for different shaped vehicles
|
|
// Output: returns true if valid location, pEndPoint
|
|
// updated with actual exit point
|
|
//---------------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::CheckExitPoint( float yaw, int distance, Vector *pEndPoint )
|
|
{
|
|
QAngle vehicleAngles = m_pVehicle->GetLocalAngles();
|
|
Vector vecStart = m_pVehicle->GetAbsOrigin();
|
|
Vector vecDir;
|
|
|
|
vecStart.z += 12; // always 12" from ground
|
|
vehicleAngles[YAW] += yaw;
|
|
AngleVectors( vehicleAngles, NULL, &vecDir, NULL );
|
|
// Vehicles are oriented along the Y axis
|
|
vecDir *= -1;
|
|
*pEndPoint = vecStart + vecDir * distance;
|
|
|
|
trace_t tr;
|
|
UTIL_TraceHull( vecStart, *pEndPoint, VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, m_pVehicle, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction < 1.0 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Where does this passenger exit the vehicle?
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::GetPassengerExitPoint( int nRole, Vector *pExitPoint, QAngle *pAngles )
|
|
{
|
|
Assert( nRole == VEHICLE_ROLE_DRIVER );
|
|
|
|
// First, see if we've got an attachment point
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
|
|
if ( pAnimating )
|
|
{
|
|
Vector vehicleExitOrigin;
|
|
QAngle vehicleExitAngles;
|
|
if ( pAnimating->GetAttachment( "vehicle_driver_exit", vehicleExitOrigin, vehicleExitAngles ) )
|
|
{
|
|
// Make sure it's clear
|
|
trace_t tr;
|
|
UTIL_TraceHull( vehicleExitOrigin + Vector(0, 0, 12), vehicleExitOrigin, VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, m_pVehicle, COLLISION_GROUP_NONE, &tr );
|
|
if ( !tr.startsolid )
|
|
{
|
|
*pAngles = vehicleExitAngles;
|
|
*pExitPoint = tr.endpos;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// left side
|
|
if( CheckExitPoint( 90, 90, pExitPoint ) ) // angle from car, distance from origin, actual exit point
|
|
return true;
|
|
|
|
// right side
|
|
if( CheckExitPoint( -90, 90, pExitPoint ) )
|
|
return true;
|
|
|
|
// front
|
|
if( CheckExitPoint( 0, 100, pExitPoint ) )
|
|
return true;
|
|
|
|
// back
|
|
if( CheckExitPoint( 180, 170, pExitPoint ) )
|
|
return true;
|
|
|
|
// All else failed, try popping them out the top.
|
|
Vector vecWorldMins, vecWorldMaxs;
|
|
m_pVehicle->CollisionProp()->WorldSpaceAABB( &vecWorldMins, &vecWorldMaxs );
|
|
pExitPoint->x = (vecWorldMins.x + vecWorldMaxs.x) * 0.5f;
|
|
pExitPoint->y = (vecWorldMins.y + vecWorldMaxs.y) * 0.5f;
|
|
pExitPoint->z = vecWorldMaxs.z + 50.0f;
|
|
|
|
// Make sure it's clear
|
|
trace_t tr;
|
|
UTIL_TraceHull( m_pVehicle->CollisionProp()->WorldSpaceCenter(), *pExitPoint, VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, m_pVehicle, COLLISION_GROUP_NONE, &tr );
|
|
if ( !tr.startsolid )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// No clear exit point available!
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::ParseExitAnim( KeyValues *pkvExitList, bool bEscapeExit )
|
|
{
|
|
// Look through the entry animations list
|
|
KeyValues *pkvExitAnim = pkvExitList->GetFirstSubKey();
|
|
while ( pkvExitAnim )
|
|
{
|
|
// Add 'em to our list
|
|
int iIndex = m_ExitAnimations.AddToTail();
|
|
Q_strncpy( m_ExitAnimations[iIndex].szAnimName, pkvExitAnim->GetName(), sizeof(m_ExitAnimations[iIndex].szAnimName) );
|
|
m_ExitAnimations[iIndex].bEscapeExit = bEscapeExit;
|
|
if ( !Q_strncmp( pkvExitAnim->GetString(), "upsidedown", 10 ) )
|
|
{
|
|
m_ExitAnimations[iIndex].bUpright = false;
|
|
}
|
|
else
|
|
{
|
|
m_ExitAnimations[iIndex].bUpright = true;
|
|
}
|
|
|
|
pkvExitAnim = pkvExitAnim->GetNextKey();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse the transition information
|
|
// Input : *pTransitionKeyValues - key values to parse
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::ParseNPCSeatTransition( KeyValues *pTransitionKeyValues, CPassengerSeatTransition *pTransition )
|
|
{
|
|
// Store it
|
|
const char *lpszAnimName = pTransitionKeyValues->GetString( "animation" );
|
|
pTransition->m_strAnimationName = AllocPooledString( lpszAnimName );
|
|
pTransition->m_nPriority = pTransitionKeyValues->GetInt( "priority" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sorting function for vehicle seat animation priorities
|
|
//-----------------------------------------------------------------------------
|
|
typedef CPassengerSeatTransition SortSeatPriorityType;
|
|
int __cdecl SeatPrioritySort( const SortSeatPriorityType *s1, const SortSeatPriorityType *s2 )
|
|
{
|
|
return ( s1->GetPriority() > s2->GetPriority() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse one set of entry/exit data
|
|
// Input : *pSetKeyValues - Key values for this set
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::ParseNPCPassengerSeat( KeyValues *pSetKeyValues, CPassengerSeat *pSeat )
|
|
{
|
|
CBaseAnimating *pAnimating = (CBaseAnimating *) m_pVehicle;
|
|
|
|
// Get our attachment name
|
|
const char *lpszAttachmentName = pSetKeyValues->GetString( "target_attachment" );
|
|
int nAttachmentID = pAnimating->LookupAttachment( lpszAttachmentName );
|
|
pSeat->m_nAttachmentID = nAttachmentID;
|
|
pSeat->m_strSeatName = AllocPooledString( lpszAttachmentName );
|
|
|
|
KeyValues *pKey = pSetKeyValues->GetFirstSubKey();
|
|
while ( pKey != NULL )
|
|
{
|
|
const char *lpszName = pKey->GetName();
|
|
|
|
if ( Q_stricmp( lpszName, "entry" ) == 0 )
|
|
{
|
|
int nIndex = pSeat->m_EntryTransitions.AddToTail();
|
|
Assert( pSeat->m_EntryTransitions.IsValidIndex( nIndex ) );
|
|
|
|
ParseNPCSeatTransition( pKey, &pSeat->m_EntryTransitions[nIndex] );
|
|
}
|
|
else if ( Q_stricmp( lpszName, "exit" ) == 0 )
|
|
{
|
|
int nIndex = pSeat->m_ExitTransitions.AddToTail();
|
|
Assert( pSeat->m_ExitTransitions.IsValidIndex( nIndex ) );
|
|
|
|
ParseNPCSeatTransition( pKey, &pSeat->m_ExitTransitions[nIndex] );
|
|
}
|
|
|
|
// Advance
|
|
pKey = pKey->GetNextKey();
|
|
}
|
|
|
|
// Sort the seats based on their priority
|
|
pSeat->m_EntryTransitions.Sort( SeatPrioritySort );
|
|
pSeat->m_ExitTransitions.Sort( SeatPrioritySort );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find a passenger role (by name), or create a new one of that names
|
|
// Input : strName - name of the role
|
|
// : *nIndex - the index into the CUtlBuffer where this role resides
|
|
// Output : CPassengerRole * - Role found or created
|
|
//-----------------------------------------------------------------------------
|
|
CPassengerRole *CBaseServerVehicle::FindOrCreatePassengerRole( string_t strName, int *nIndex )
|
|
{
|
|
// Try to find an already created container of the same name
|
|
for ( int i = 0; i < m_PassengerRoles.Count(); i++ )
|
|
{
|
|
// If we match, return it
|
|
if ( FStrEq( STRING( m_PassengerRoles[i].m_strName ), STRING( strName ) ) )
|
|
{
|
|
// Supply the index, if requested
|
|
if ( nIndex != NULL )
|
|
{
|
|
*nIndex = i;
|
|
}
|
|
|
|
return &m_PassengerRoles[i];
|
|
}
|
|
}
|
|
|
|
// Create a new container
|
|
int nNewIndex = m_PassengerRoles.AddToTail();
|
|
Assert( m_PassengerRoles.IsValidIndex( nNewIndex ) );
|
|
|
|
m_PassengerRoles[nNewIndex].m_strName = strName;
|
|
|
|
// Supply the index, if requested
|
|
if ( nIndex != NULL )
|
|
{
|
|
*nIndex = nNewIndex;
|
|
}
|
|
|
|
return &m_PassengerRoles[nNewIndex];
|
|
}
|
|
|
|
ConVar g_debug_npc_vehicle_roles( "g_debug_npc_vehicle_roles", "0" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse NPC entry and exit anim data
|
|
// Input : *pModelKeyValues - Key values from the vehicle model
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::ParseNPCRoles( KeyValues *pkvPassengerList )
|
|
{
|
|
// Get the definition section
|
|
if ( pkvPassengerList == NULL )
|
|
return;
|
|
|
|
// Get our animating class
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
|
|
Assert( pAnimating != NULL );
|
|
if ( pAnimating == NULL )
|
|
return;
|
|
|
|
// For attachment polling
|
|
CStudioHdr *pStudioHdr = pAnimating->GetModelPtr();
|
|
Assert( pStudioHdr != NULL );
|
|
if ( pStudioHdr == NULL )
|
|
return;
|
|
|
|
// Parse all subkeys
|
|
int nRoleIndex;
|
|
KeyValues *pkvPassengerKey = pkvPassengerList->GetFirstSubKey();
|
|
while ( pkvPassengerKey != NULL )
|
|
{
|
|
string_t strRoleName = AllocPooledString( pkvPassengerKey->GetName() );
|
|
|
|
// Find or create the container
|
|
CPassengerRole *pRole = FindOrCreatePassengerRole( strRoleName, &nRoleIndex );
|
|
if ( pRole == NULL )
|
|
continue;
|
|
|
|
// Add a new role
|
|
int nSeatIndex = pRole->m_PassengerSeats.AddToTail();
|
|
Assert( pRole->m_PassengerSeats.IsValidIndex( nSeatIndex ) );
|
|
|
|
// Parse the information
|
|
ParseNPCPassengerSeat( pkvPassengerKey, &pRole->m_PassengerSeats[nSeatIndex] );
|
|
|
|
// Add a matching entry into our passenger manifest
|
|
int nPassengerIndex = m_PassengerInfo.AddToTail();
|
|
m_PassengerInfo[nPassengerIndex].m_hPassenger = NULL;
|
|
m_PassengerInfo[nPassengerIndex].m_nSeat = nSeatIndex;
|
|
m_PassengerInfo[nPassengerIndex].m_nRole = nRoleIndex;
|
|
|
|
// The following are used for index fix-ups after save game restoration
|
|
m_PassengerInfo[nPassengerIndex].m_strRoleName = strRoleName;
|
|
m_PassengerInfo[nPassengerIndex].m_strSeatName = pRole->m_PassengerSeats[nSeatIndex].m_strSeatName;
|
|
|
|
// Advance to the next key
|
|
pkvPassengerKey = pkvPassengerKey->GetNextKey();
|
|
}
|
|
|
|
// ======================================================================================================
|
|
// Debug print
|
|
|
|
if ( g_debug_npc_vehicle_roles.GetBool() )
|
|
{
|
|
Msg("Passenger Roles Parsed:\t%d\n\n", m_PassengerRoles.Count() );
|
|
for ( int i = 0; i < m_PassengerRoles.Count(); i++ )
|
|
{
|
|
Msg("\tPassenger Role:\t%s (%d seats)\n", STRING(m_PassengerRoles[i].m_strName), m_PassengerRoles[i].m_PassengerSeats.Count() );
|
|
|
|
// Iterate through all information sets under this name
|
|
for ( int j = 0; j < m_PassengerRoles[i].m_PassengerSeats.Count(); j++ )
|
|
{
|
|
Msg("\t\tAttachment: %d\n", m_PassengerRoles[i].m_PassengerSeats[j].m_nAttachmentID );
|
|
|
|
// Entries
|
|
Msg("\t\tEntries:\t%d\n", m_PassengerRoles[i].m_PassengerSeats[j].m_EntryTransitions.Count() );
|
|
Msg("\t\t=====================\n" );
|
|
|
|
for ( int nEntry = 0; nEntry < m_PassengerRoles[i].m_PassengerSeats[j].m_EntryTransitions.Count(); nEntry++ )
|
|
{
|
|
Msg("\t\t\tAnimation:\t%s\t(Priority %d)\n", STRING(m_PassengerRoles[i].m_PassengerSeats[j].m_EntryTransitions[nEntry].m_strAnimationName),
|
|
m_PassengerRoles[i].m_PassengerSeats[j].m_EntryTransitions[nEntry].m_nPriority );
|
|
}
|
|
|
|
Msg("\n");
|
|
|
|
// Exits
|
|
Msg("\t\tExits:\t%d\n", m_PassengerRoles[i].m_PassengerSeats[j].m_ExitTransitions.Count() );
|
|
Msg("\t\t=====================\n" );
|
|
|
|
for ( int nExits = 0; nExits < m_PassengerRoles[i].m_PassengerSeats[j].m_ExitTransitions.Count(); nExits++ )
|
|
{
|
|
Msg("\t\t\tAnimation:\t%s\t(Priority %d)\n", STRING(m_PassengerRoles[i].m_PassengerSeats[j].m_ExitTransitions[nExits].m_strAnimationName),
|
|
m_PassengerRoles[i].m_PassengerSeats[j].m_ExitTransitions[nExits].m_nPriority );
|
|
}
|
|
}
|
|
|
|
Msg("\n");
|
|
}
|
|
}
|
|
|
|
// ======================================================================================================
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get an attachment point at a specified time in its cycle (note: not exactly a speedy query, use sparingly!)
|
|
// Input : nSequence - sequence to test
|
|
// nAttachmentIndex - attachment to test
|
|
// flCyclePoint - 0.0 - 1.0
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::GetLocalAttachmentAtTime( int nQuerySequence, int nAttachmentIndex, float flCyclePoint, Vector *vecOriginOut, QAngle *vecAnglesOut )
|
|
{
|
|
CBaseAnimating *pAnimating = m_pVehicle->GetBaseAnimating();
|
|
if ( pAnimating == NULL )
|
|
return false;
|
|
|
|
// TODO: It's annoying to stomp and restore this off each time when we're just going to stomp it again later, but the function
|
|
// should really leave the car in an acceptable state to run this query -- jdw
|
|
|
|
// Store this off for restoration later
|
|
int nOldSequence = pAnimating->GetSequence();
|
|
float flOldCycle = pAnimating->GetCycle();
|
|
|
|
// Setup the model for the query
|
|
pAnimating->SetSequence( nQuerySequence );
|
|
pAnimating->SetCycle( flCyclePoint );
|
|
pAnimating->InvalidateBoneCache();
|
|
|
|
// Query for the point
|
|
Vector vecOrigin;
|
|
QAngle vecAngles;
|
|
pAnimating->GetAttachmentLocal( nAttachmentIndex, vecOrigin, vecAngles );
|
|
|
|
if ( vecOriginOut != NULL )
|
|
{
|
|
*vecOriginOut = vecOrigin;
|
|
}
|
|
|
|
if ( vecAnglesOut != NULL )
|
|
{
|
|
*vecAnglesOut = vecAngles;
|
|
}
|
|
|
|
// Restore the model after the query
|
|
pAnimating->SetSequence( nOldSequence );
|
|
pAnimating->SetCycle( flOldCycle );
|
|
pAnimating->InvalidateBoneCache();
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get an attachment point at a specified time in its cycle (note: not exactly a speedy query, use sparingly!)
|
|
// Input : lpszAnimName - name of the sequence to test
|
|
// nAttachmentIndex - attachment to test
|
|
// flCyclePoint - 0.0 - 1.0
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::GetLocalAttachmentAtTime( const char *lpszAnimName, int nAttachmentIndex, float flCyclePoint, Vector *vecOriginOut, QAngle *vecAnglesOut )
|
|
{
|
|
CBaseAnimating *pAnimating = m_pVehicle->GetBaseAnimating();
|
|
if ( pAnimating == NULL )
|
|
return false;
|
|
|
|
int nQuerySequence = pAnimating->LookupSequence( lpszAnimName );
|
|
if ( nQuerySequence < 0 )
|
|
return false;
|
|
|
|
return GetLocalAttachmentAtTime( nQuerySequence, nAttachmentIndex, flCyclePoint, vecOriginOut, vecAnglesOut );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::CacheEntryExitPoints( void )
|
|
{
|
|
CBaseAnimating *pAnimating = m_pVehicle->GetBaseAnimating();
|
|
if ( pAnimating == NULL )
|
|
return;
|
|
|
|
int nAttachment = pAnimating->LookupAttachment( "vehicle_driver_eyes" );
|
|
|
|
// For each exit animation, determine where the end point is and cache it
|
|
for ( int i = 0; i < m_ExitAnimations.Count(); i++ )
|
|
{
|
|
if ( GetLocalAttachmentAtTime( m_ExitAnimations[i].szAnimName, nAttachment, 1.0f, &m_ExitAnimations[i].vecExitPointLocal, &m_ExitAnimations[i].vecExitAnglesLocal ) == false )
|
|
{
|
|
Warning("Exit animation %s failed to cache target points properly!\n", m_ExitAnimations[i].szAnimName );
|
|
}
|
|
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
Vector vecExitPoint = m_ExitAnimations[i].vecExitPointLocal;
|
|
QAngle vecExitAngles = m_ExitAnimations[i].vecExitAnglesLocal;
|
|
UTIL_ParentToWorldSpace( pAnimating, vecExitPoint, vecExitAngles );
|
|
|
|
NDebugOverlay::Box( vecExitPoint, -Vector(8,8,8), Vector(8,8,8), 0, 255, 0, 0, 20.0f );
|
|
NDebugOverlay::Axis( vecExitPoint, vecExitAngles, 8.0f, true, 20.0f );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::ParseEntryExitAnims( void )
|
|
{
|
|
// Try and find the right animation to play in the model's keyvalues
|
|
KeyValues *modelKeyValues = new KeyValues("");
|
|
if ( modelKeyValues->LoadFromBuffer( modelinfo->GetModelName( m_pVehicle->GetModel() ), modelinfo->GetModelKeyValueText( m_pVehicle->GetModel() ) ) )
|
|
{
|
|
// Do we have an entry section?
|
|
KeyValues *pkvEntryList = modelKeyValues->FindKey("vehicle_entry");
|
|
if ( pkvEntryList )
|
|
{
|
|
// Look through the entry animations list
|
|
KeyValues *pkvEntryAnim = pkvEntryList->GetFirstSubKey();
|
|
while ( pkvEntryAnim )
|
|
{
|
|
// Add 'em to our list
|
|
int iIndex = m_EntryAnimations.AddToTail();
|
|
Q_strncpy( m_EntryAnimations[iIndex].szAnimName, pkvEntryAnim->GetName(), sizeof(m_EntryAnimations[iIndex].szAnimName) );
|
|
m_EntryAnimations[iIndex].iHitboxGroup = pkvEntryAnim->GetInt();
|
|
|
|
pkvEntryAnim = pkvEntryAnim->GetNextKey();
|
|
}
|
|
}
|
|
|
|
// Do we have an exit section?
|
|
KeyValues *pkvExitList = modelKeyValues->FindKey("vehicle_exit");
|
|
if ( pkvExitList )
|
|
{
|
|
ParseExitAnim( pkvExitList, false );
|
|
}
|
|
|
|
// Do we have an exit section?
|
|
pkvExitList = modelKeyValues->FindKey("vehicle_escape_exit");
|
|
if ( pkvExitList )
|
|
{
|
|
ParseExitAnim( pkvExitList, true );
|
|
}
|
|
|
|
// Parse the NPC vehicle roles as well
|
|
KeyValues *pkvPassengerList = modelKeyValues->FindKey( "vehicle_npc_passengers" );
|
|
if ( pkvPassengerList )
|
|
{
|
|
ParseNPCRoles( pkvPassengerList );
|
|
}
|
|
}
|
|
|
|
modelKeyValues->deleteThis();
|
|
|
|
// Determine the entry and exit points for the
|
|
CacheEntryExitPoints();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::HandlePassengerEntry( CBaseCombatCharacter *pPassenger, bool bAllowEntryOutsideZone )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( pPassenger );
|
|
if ( pPlayer != NULL )
|
|
{
|
|
// Find out which hitbox the player's eyepoint is within
|
|
int iEntryAnim = GetEntryAnimForPoint( pPlayer->EyePosition() );
|
|
|
|
// Get this interface for animation queries
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
|
|
if ( !pAnimating )
|
|
return;
|
|
|
|
// Are we in an entrypoint zone?
|
|
if ( iEntryAnim == ACTIVITY_NOT_AVAILABLE )
|
|
{
|
|
// Normal get in refuses to allow entry
|
|
if ( !bAllowEntryOutsideZone )
|
|
return;
|
|
|
|
// We failed to find a valid entry anim, but we've got to get back in because the player's
|
|
// got stuck exiting the vehicle. For now, just use the first get in anim
|
|
// UNDONE: We need a better solution for this.
|
|
iEntryAnim = pAnimating->LookupSequence( m_EntryAnimations[0].szAnimName );
|
|
}
|
|
|
|
// Check to see if this vehicle can be controlled or if it's locked
|
|
if ( GetDrivableVehicle()->CanEnterVehicle( pPlayer ) )
|
|
{
|
|
// Make sure the passenger can get in as well
|
|
if ( pPlayer->CanEnterVehicle( this, VEHICLE_ROLE_DRIVER ) )
|
|
{
|
|
// Setup the "enter" vehicle sequence and skip the animation if it isn't present.
|
|
pAnimating->SetCycle( 0 );
|
|
pAnimating->m_flAnimTime = gpGlobals->curtime;
|
|
pAnimating->ResetSequence( iEntryAnim );
|
|
pAnimating->ResetClientsideFrame();
|
|
pAnimating->InvalidateBoneCache(); // This is necessary because we need to query attachment points this frame for blending!
|
|
GetDrivableVehicle()->SetVehicleEntryAnim( true );
|
|
|
|
pPlayer->GetInVehicle( this, VEHICLE_ROLE_DRIVER );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// NPCs handle transitioning themselves, they should NOT call this function
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::HandlePassengerExit( CBaseCombatCharacter *pPassenger )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( pPassenger );
|
|
if ( pPlayer != NULL )
|
|
{
|
|
// Clear hud hints
|
|
UTIL_HudHintText( pPlayer, "" );
|
|
|
|
vbs_sound_update_t params;
|
|
InitSoundParams(params);
|
|
params.bExitVehicle = true;
|
|
SoundState_Update( params );
|
|
|
|
// Find the right exit anim to use based on available exit points.
|
|
Vector vecExitPoint;
|
|
bool bAllPointsBlocked;
|
|
int iSequence = GetExitAnimToUse( vecExitPoint, bAllPointsBlocked );
|
|
|
|
// If all exit points were blocked and this vehicle doesn't allow exiting in
|
|
// these cases, bail.
|
|
Vector vecNewPos = pPlayer->GetAbsOrigin();
|
|
QAngle angNewAngles = pPlayer->GetAbsAngles();
|
|
|
|
int nRole = GetPassengerRole( pPlayer );
|
|
if ( ( bAllPointsBlocked ) || ( iSequence == ACTIVITY_NOT_AVAILABLE ) )
|
|
{
|
|
// Animation-driven exit points are all blocked, or we have none. Fall back to the more simple static exit points.
|
|
if ( !GetPassengerExitPoint( nRole, &vecNewPos, &angNewAngles ) && !GetDrivableVehicle()->AllowBlockedExit( pPlayer, nRole ) )
|
|
return false;
|
|
|
|
// At this point, the player has exited the vehicle but did so without playing an animation. We need to give the vehicle a
|
|
// chance to do any post-animation clean-up it may need to perform.
|
|
HandleEntryExitFinish( false, true );
|
|
}
|
|
|
|
// Now we either have an exit sequence to play, a valid static exit position, or we don't care
|
|
// whether we're blocked or not. We're getting out, one way or another.
|
|
GetDrivableVehicle()->PreExitVehicle( pPlayer, nRole );
|
|
|
|
if ( iSequence > ACTIVITY_NOT_AVAILABLE )
|
|
{
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
|
|
if ( pAnimating )
|
|
{
|
|
pAnimating->SetCycle( 0 );
|
|
pAnimating->m_flAnimTime = gpGlobals->curtime;
|
|
pAnimating->ResetSequence( iSequence );
|
|
pAnimating->ResetClientsideFrame();
|
|
GetDrivableVehicle()->SetVehicleExitAnim( true, vecExitPoint );
|
|
|
|
// Re-deploy our weapon
|
|
if ( pPlayer && pPlayer->IsAlive() )
|
|
{
|
|
if ( pPlayer->GetActiveWeapon() )
|
|
{
|
|
pPlayer->GetActiveWeapon()->Deploy();
|
|
pPlayer->ShowCrosshair( true );
|
|
}
|
|
}
|
|
|
|
// To prevent anything moving into the volume the player's going to occupy at the end of the exit
|
|
// NOTE: Set the player as the blocker's owner so the player is allowed to intersect it
|
|
Vector vecExitFeetPoint = vecExitPoint - VEC_VIEW;
|
|
m_hExitBlocker = CEntityBlocker::Create( vecExitFeetPoint, VEC_HULL_MIN, VEC_HULL_MAX, pPlayer, true );
|
|
|
|
// We may as well stand where we're going to get out at and stop being parented
|
|
pPlayer->SetAbsOrigin( vecExitFeetPoint );
|
|
pPlayer->SetParent( NULL );
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Couldn't find an animation, so exit immediately
|
|
pPlayer->LeaveVehicle( vecNewPos, angNewAngles );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// NPCs handle transitioning themselves, they should NOT call this function
|
|
Assert( 0 );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::GetEntryAnimForPoint( const Vector &vecEyePoint )
|
|
{
|
|
// Parse the vehicle animations the first time they get in the vehicle
|
|
if ( !m_bParsedAnimations )
|
|
{
|
|
// Load the entry/exit animations from the vehicle
|
|
ParseEntryExitAnims();
|
|
m_bParsedAnimations = true;
|
|
}
|
|
|
|
// No entry anims? Vehicles with no entry anims are always enterable.
|
|
if ( !m_EntryAnimations.Count() )
|
|
return 0;
|
|
|
|
// Figure out which entrypoint hitbox the player is in
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
|
|
if ( !pAnimating )
|
|
return 0;
|
|
|
|
CStudioHdr *pStudioHdr = pAnimating->GetModelPtr();
|
|
if (!pStudioHdr)
|
|
return 0;
|
|
int iHitboxSet = FindHitboxSetByName( pStudioHdr, "entryboxes" );
|
|
mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( iHitboxSet );
|
|
if ( !set || !set->numhitboxes )
|
|
return 0;
|
|
|
|
// Loop through the hitboxes and find out which one we're in
|
|
for ( int i = 0; i < set->numhitboxes; i++ )
|
|
{
|
|
mstudiobbox_t *pbox = set->pHitbox( i );
|
|
|
|
Vector vecPosition;
|
|
QAngle vecAngles;
|
|
pAnimating->GetBonePosition( pbox->bone, vecPosition, vecAngles );
|
|
|
|
// Build a rotation matrix from orientation
|
|
matrix3x4_t fRotateMatrix;
|
|
AngleMatrix( vecAngles, vecPosition, fRotateMatrix);
|
|
|
|
Vector localEyePoint;
|
|
VectorITransform( vecEyePoint, fRotateMatrix, localEyePoint );
|
|
if ( IsPointInBox( localEyePoint, pbox->bbmin, pbox->bbmax ) )
|
|
{
|
|
// Find the entry animation for this hitbox
|
|
int iCount = m_EntryAnimations.Count();
|
|
for ( int entry = 0; entry < iCount; entry++ )
|
|
{
|
|
if ( m_EntryAnimations[entry].iHitboxGroup == pbox->group )
|
|
{
|
|
// Get the sequence for the animation
|
|
return pAnimating->LookupSequence( m_EntryAnimations[entry].szAnimName );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fail
|
|
return ACTIVITY_NOT_AVAILABLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find an exit animation that'll get the player to a valid position
|
|
// Input : vecEyeExitEndpoint - Returns with the final eye position after exiting.
|
|
// bAllPointsBlocked - Returns whether all exit points were found to be blocked.
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::GetExitAnimToUse( Vector &vecEyeExitEndpoint, bool &bAllPointsBlocked )
|
|
{
|
|
bAllPointsBlocked = false;
|
|
|
|
// Parse the vehicle animations the first time they get in the vehicle
|
|
if ( !m_bParsedAnimations )
|
|
{
|
|
// Load the entry/exit animations from the vehicle
|
|
ParseEntryExitAnims();
|
|
m_bParsedAnimations = true;
|
|
}
|
|
|
|
// No exit anims?
|
|
if ( !m_ExitAnimations.Count() )
|
|
return ACTIVITY_NOT_AVAILABLE;
|
|
|
|
// Figure out which entrypoint hitbox the player is in
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
|
|
if ( !pAnimating )
|
|
return ACTIVITY_NOT_AVAILABLE;
|
|
|
|
CStudioHdr *pStudioHdr = pAnimating->GetModelPtr();
|
|
if (!pStudioHdr)
|
|
return ACTIVITY_NOT_AVAILABLE;
|
|
|
|
bool bUpright = IsVehicleUpright();
|
|
|
|
// Loop through the exit animations and find one that ends in a clear position
|
|
// Also attempt to choose the animation which brings you closest to your view direction.
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetDriver() );
|
|
if ( pPlayer == NULL )
|
|
return ACTIVITY_NOT_AVAILABLE;
|
|
|
|
int nRole = GetPassengerRole( pPlayer );
|
|
|
|
int nBestExitAnim = -1;
|
|
bool bBestExitIsEscapePoint = true;
|
|
Vector vecViewDirection, vecViewOrigin, vecBestExitPoint( 0, 0, 0 );
|
|
vecViewOrigin = pPlayer->EyePosition();
|
|
pPlayer->EyeVectors( &vecViewDirection );
|
|
vecViewDirection.z = 0.0f;
|
|
VectorNormalize( vecViewDirection );
|
|
|
|
float flMaxCosAngleDelta = -2.0f;
|
|
|
|
int iCount = m_ExitAnimations.Count();
|
|
for ( int i = 0; i < iCount; i++ )
|
|
{
|
|
if ( m_ExitAnimations[i].bUpright != bUpright )
|
|
continue;
|
|
|
|
// Don't use an escape point if we found a non-escape point already
|
|
if ( !bBestExitIsEscapePoint && m_ExitAnimations[i].bEscapeExit )
|
|
continue;
|
|
|
|
Vector vehicleExitOrigin;
|
|
QAngle vehicleExitAngles;
|
|
|
|
// NOTE: HL2 and Ep1 used a method that relied on the animators to place attachment points in the model which marked where
|
|
// the player would exit to. This was rendered unnecessary in Ep2, but the choreo vehicles of these older products
|
|
// did not have proper exit animations and relied on the exact queries that were happening before. For choreo vehicles,
|
|
// we now just allow them to perform those older queries to keep those products happy. - jdw
|
|
|
|
// Get the position we think we're going to end up at
|
|
if ( m_bUseLegacyExitChecks )
|
|
{
|
|
pAnimating->GetAttachment( m_ExitAnimations[i].szAnimName, vehicleExitOrigin, vehicleExitAngles );
|
|
}
|
|
else
|
|
{
|
|
vehicleExitOrigin = m_ExitAnimations[i].vecExitPointLocal;
|
|
vehicleExitAngles = m_ExitAnimations[i].vecExitAnglesLocal;
|
|
UTIL_ParentToWorldSpace( pAnimating, vehicleExitOrigin, vehicleExitAngles );
|
|
}
|
|
|
|
// Don't bother checking points which are farther from our view direction.
|
|
Vector vecDelta;
|
|
VectorSubtract( vehicleExitOrigin, vecViewOrigin, vecDelta );
|
|
vecDelta.z = 0.0f;
|
|
VectorNormalize( vecDelta );
|
|
float flCosAngleDelta = DotProduct( vecDelta, vecViewDirection );
|
|
|
|
// But always check non-escape exits if our current best exit is an escape exit.
|
|
if ( !bBestExitIsEscapePoint || m_ExitAnimations[i].bEscapeExit )
|
|
{
|
|
if ( flCosAngleDelta < flMaxCosAngleDelta )
|
|
continue;
|
|
}
|
|
|
|
// The attachment points are where the driver's eyes will end up, so we subtract the view offset
|
|
// to get the actual exit position.
|
|
vehicleExitOrigin -= VEC_VIEW;
|
|
|
|
Vector vecMove(0,0,64);
|
|
Vector vecStart = vehicleExitOrigin + vecMove;
|
|
Vector vecEnd = vehicleExitOrigin - vecMove;
|
|
|
|
// Starting at the exit point, trace a flat plane down until we hit ground
|
|
// NOTE: The hull has no vertical span because we want to test the lateral constraints against the ground, not height (yet)
|
|
trace_t tr;
|
|
UTIL_TraceHull( vecStart, vecEnd, VEC_HULL_MIN, Vector( VEC_HULL_MAX.x, VEC_HULL_MAX.y, VEC_HULL_MIN.z ), MASK_PLAYERSOLID, NULL, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
NDebugOverlay::SweptBox( vecStart, vecEnd, VEC_HULL_MIN, Vector( VEC_HULL_MAX.x, VEC_HULL_MAX.y, VEC_HULL_MIN.y ), vec3_angle, 255, 255, 255, 8.0f, 20.0f );
|
|
}
|
|
|
|
if ( tr.fraction < 1.0f )
|
|
{
|
|
// If we hit the ground, try to now "stand up" at that point to see if we'll fit
|
|
UTIL_TraceHull( tr.endpos, tr.endpos, VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, NULL, COLLISION_GROUP_NONE, &tr );
|
|
|
|
// See if we're unable to stand at this space
|
|
if ( tr.startsolid )
|
|
{
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
NDebugOverlay::Box( tr.endpos, VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 8.0f, 20.0f );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
NDebugOverlay::Box( tr.endpos, VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 8.0f, 20.0f );
|
|
}
|
|
}
|
|
else if ( tr.allsolid || ( ( tr.fraction == 1.0 ) && !GetDrivableVehicle()->AllowMidairExit( pPlayer, nRole ) ) )
|
|
{
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
NDebugOverlay::Box( tr.endpos, VEC_HULL_MIN, VEC_HULL_MAX, 255,0,0, 64, 10 );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Calculate the exit endpoint & viewpoint
|
|
Vector vecExitEndPoint = tr.endpos;
|
|
|
|
// Make sure we can trace to the center of the exit point
|
|
UTIL_TraceLine( vecViewOrigin, vecExitEndPoint, MASK_PLAYERSOLID, pAnimating, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction != 1.0 )
|
|
{
|
|
#ifdef HL2_EPISODIC
|
|
if ( ShouldVehicleIgnoreEntity( GetVehicleEnt(), tr.m_pEnt ) == false )
|
|
#endif //HL2_EPISODIC
|
|
{
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
NDebugOverlay::Line( vecViewOrigin, vecExitEndPoint, 255,0,0, true, 10 );
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
bBestExitIsEscapePoint = m_ExitAnimations[i].bEscapeExit;
|
|
vecBestExitPoint = vecExitEndPoint;
|
|
nBestExitAnim = i;
|
|
flMaxCosAngleDelta = flCosAngleDelta;
|
|
}
|
|
|
|
if ( nBestExitAnim >= 0 )
|
|
{
|
|
m_vecCurrentExitEndPoint = vecBestExitPoint;
|
|
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
NDebugOverlay::Cross3D( m_vecCurrentExitEndPoint, 16, 0, 255, 0, true, 10 );
|
|
NDebugOverlay::Box( m_vecCurrentExitEndPoint, VEC_HULL_MIN, VEC_HULL_MAX, 255,255,255, 8, 10 );
|
|
}
|
|
|
|
vecEyeExitEndpoint = vecBestExitPoint + VEC_VIEW;
|
|
m_iCurrentExitAnim = nBestExitAnim;
|
|
return pAnimating->LookupSequence( m_ExitAnimations[m_iCurrentExitAnim].szAnimName );
|
|
}
|
|
|
|
// Fail, all exit points were blocked.
|
|
bAllPointsBlocked = true;
|
|
return ACTIVITY_NOT_AVAILABLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::HandleEntryExitFinish( bool bExitAnimOn, bool bResetAnim )
|
|
{
|
|
// Parse the vehicle animations. This is needed because they may have
|
|
// saved, and loaded during exit anim, which would clear the exit anim.
|
|
if ( !m_bParsedAnimations )
|
|
{
|
|
// Load the entry/exit animations from the vehicle
|
|
ParseEntryExitAnims();
|
|
m_bParsedAnimations = true;
|
|
}
|
|
|
|
// Figure out which entrypoint hitbox the player is in
|
|
CBaseAnimating *pAnimating = m_pVehicle->GetBaseAnimating();
|
|
if ( !pAnimating )
|
|
return;
|
|
|
|
// Did the entry anim just finish?
|
|
if ( bExitAnimOn )
|
|
{
|
|
// The exit animation just finished
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetDriver() );
|
|
if ( pPlayer != NULL )
|
|
{
|
|
Vector vecEyes;
|
|
QAngle vecEyeAng;
|
|
if ( m_iCurrentExitAnim >= 0 && m_iCurrentExitAnim < m_ExitAnimations.Count() )
|
|
{
|
|
// Convert our offset points to worldspace ones
|
|
vecEyes = m_ExitAnimations[m_iCurrentExitAnim].vecExitPointLocal;
|
|
vecEyeAng = m_ExitAnimations[m_iCurrentExitAnim].vecExitAnglesLocal;
|
|
UTIL_ParentToWorldSpace( pAnimating, vecEyes, vecEyeAng );
|
|
|
|
// Use the endpoint we figured out when we exited
|
|
vecEyes = m_vecCurrentExitEndPoint;
|
|
}
|
|
else
|
|
{
|
|
pAnimating->GetAttachment( "vehicle_driver_eyes", vecEyes, vecEyeAng );
|
|
}
|
|
|
|
if ( g_debug_vehicleexit.GetBool() )
|
|
{
|
|
NDebugOverlay::Box( vecEyes, -Vector(2,2,2), Vector(2,2,2), 255,0,0, 64, 10.0 );
|
|
}
|
|
|
|
// If the end point isn't clear, get back in the vehicle
|
|
/*
|
|
trace_t tr;
|
|
UTIL_TraceHull( vecEyes, vecEyes, VEC_HULL_MIN, VEC_HULL_MAX, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.startsolid && tr.fraction < 1.0 )
|
|
{
|
|
pPlayer->LeaveVehicle( vecEyes, vecEyeAng );
|
|
m_pVehicle->Use( pPlayer, pPlayer, USE_TOGGLE, 1 );
|
|
return;
|
|
}
|
|
*/
|
|
|
|
pPlayer->LeaveVehicle( vecEyes, vecEyeAng );
|
|
}
|
|
}
|
|
|
|
// Only reset the animation if we're told to
|
|
if ( bResetAnim )
|
|
{
|
|
// Start the vehicle idling again
|
|
int iSequence = pAnimating->SelectWeightedSequence( ACT_IDLE );
|
|
if ( iSequence > ACTIVITY_NOT_AVAILABLE )
|
|
{
|
|
pAnimating->SetCycle( 0 );
|
|
pAnimating->m_flAnimTime = gpGlobals->curtime;
|
|
pAnimating->ResetSequence( iSequence );
|
|
pAnimating->ResetClientsideFrame();
|
|
}
|
|
}
|
|
|
|
GetDrivableVehicle()->SetVehicleEntryAnim( false );
|
|
GetDrivableVehicle()->SetVehicleExitAnim( false, vec3_origin );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Where does the passenger see from?
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::GetVehicleViewPosition( int nRole, Vector *pAbsOrigin, QAngle *pAbsAngles, float *pFOV /*= NULL*/ )
|
|
{
|
|
Assert( nRole == VEHICLE_ROLE_DRIVER );
|
|
CBaseCombatCharacter *pPassenger = GetPassenger( VEHICLE_ROLE_DRIVER );
|
|
Assert( pPassenger );
|
|
|
|
CBasePlayer *pPlayer = ToBasePlayer( pPassenger );
|
|
if ( pPlayer != NULL )
|
|
{
|
|
// Call through the player to resolve the actual position (if available)
|
|
if ( pAbsOrigin != NULL )
|
|
{
|
|
*pAbsOrigin = pPlayer->EyePosition();
|
|
}
|
|
|
|
if ( pAbsAngles != NULL )
|
|
{
|
|
*pAbsAngles = pPlayer->EyeAngles();
|
|
}
|
|
|
|
if ( pFOV )
|
|
{
|
|
*pFOV = pPlayer->GetFOV();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// NPCs are not supported
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
|
|
{
|
|
GetDrivableVehicle()->SetupMove( player, ucmd, pHelper, move );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData )
|
|
{
|
|
GetDrivableVehicle()->ProcessMovement( pPlayer, pMoveData );
|
|
|
|
trace_t tr;
|
|
UTIL_TraceLine( pPlayer->GetAbsOrigin(), pPlayer->GetAbsOrigin() - Vector( 0, 0, 256 ), MASK_PLAYERSOLID, GetVehicleEnt(), COLLISION_GROUP_NONE, &tr );
|
|
|
|
// If our gamematerial has changed, tell any player surface triggers that are watching
|
|
IPhysicsSurfaceProps *physprops = MoveHelper()->GetSurfaceProps();
|
|
const surfacedata_t *pSurfaceProp = physprops->GetSurfaceData( tr.surface.surfaceProps );
|
|
char cCurrGameMaterial = pSurfaceProp->game.material;
|
|
|
|
// Changed?
|
|
if ( m_chPreviousTextureType != cCurrGameMaterial )
|
|
{
|
|
CEnvPlayerSurfaceTrigger::SetPlayerSurface( pPlayer, cCurrGameMaterial );
|
|
}
|
|
|
|
m_chPreviousTextureType = cCurrGameMaterial;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move )
|
|
{
|
|
GetDrivableVehicle()->FinishMove( player, ucmd, move );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::ItemPostFrame( CBasePlayer *player )
|
|
{
|
|
Assert( player == GetDriver() );
|
|
|
|
GetDrivableVehicle()->ItemPostFrame( player );
|
|
|
|
if ( player->m_afButtonPressed & IN_USE )
|
|
{
|
|
if ( GetDrivableVehicle()->CanExitVehicle(player) )
|
|
{
|
|
if ( !HandlePassengerExit( player ) && ( player != NULL ) )
|
|
{
|
|
player->PlayUseDenySound();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_ThrottleForward( void )
|
|
{
|
|
m_nNPCButtons |= IN_FORWARD;
|
|
m_nNPCButtons &= ~IN_BACK;
|
|
m_nNPCButtons &= ~IN_JUMP;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_ThrottleReverse( void )
|
|
{
|
|
m_nNPCButtons |= IN_BACK;
|
|
m_nNPCButtons &= ~IN_FORWARD;
|
|
m_nNPCButtons &= ~IN_JUMP;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_ThrottleCenter( void )
|
|
{
|
|
m_nNPCButtons &= ~IN_FORWARD;
|
|
m_nNPCButtons &= ~IN_BACK;
|
|
m_nNPCButtons &= ~IN_JUMP;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_Brake( void )
|
|
{
|
|
m_nNPCButtons &= ~IN_FORWARD;
|
|
m_nNPCButtons &= ~IN_BACK;
|
|
m_nNPCButtons |= IN_JUMP;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_TurnLeft( float flDegrees )
|
|
{
|
|
m_nNPCButtons |= IN_MOVELEFT;
|
|
m_nNPCButtons &= ~IN_MOVERIGHT;
|
|
m_flTurnDegrees = -flDegrees;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_TurnRight( float flDegrees )
|
|
{
|
|
m_nNPCButtons |= IN_MOVERIGHT;
|
|
m_nNPCButtons &= ~IN_MOVELEFT;
|
|
m_flTurnDegrees = flDegrees;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_TurnCenter( void )
|
|
{
|
|
m_nNPCButtons &= ~IN_MOVERIGHT;
|
|
m_nNPCButtons &= ~IN_MOVELEFT;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_PrimaryFire( void )
|
|
{
|
|
m_nNPCButtons |= IN_ATTACK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::NPC_SecondaryFire( void )
|
|
{
|
|
m_nNPCButtons |= IN_ATTACK2;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::Weapon_PrimaryRanges( float *flMinRange, float *flMaxRange )
|
|
{
|
|
*flMinRange = 64;
|
|
*flMaxRange = 1024;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::Weapon_SecondaryRanges( float *flMinRange, float *flMaxRange )
|
|
{
|
|
*flMinRange = 64;
|
|
*flMaxRange = 1024;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the time at which this vehicle's primary weapon can fire again
|
|
//-----------------------------------------------------------------------------
|
|
float CBaseServerVehicle::Weapon_PrimaryCanFireAt( void )
|
|
{
|
|
return gpGlobals->curtime;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the time at which this vehicle's secondary weapon can fire again
|
|
//-----------------------------------------------------------------------------
|
|
float CBaseServerVehicle::Weapon_SecondaryCanFireAt( void )
|
|
{
|
|
return gpGlobals->curtime;
|
|
}
|
|
|
|
const char *pSoundStateNames[] =
|
|
{
|
|
"SS_NONE",
|
|
"SS_SHUTDOWN",
|
|
"SS_SHUTDOWN_WATER",
|
|
"SS_START_WATER",
|
|
"SS_START_IDLE",
|
|
"SS_IDLE",
|
|
"SS_GEAR_0",
|
|
"SS_GEAR_1",
|
|
"SS_GEAR_2",
|
|
"SS_GEAR_3",
|
|
"SS_GEAR_4",
|
|
"SS_SLOWDOWN",
|
|
"SS_SLOWDOWN_HIGHSPEED",
|
|
"SS_GEAR_0_RESUME",
|
|
"SS_GEAR_1_RESUME",
|
|
"SS_GEAR_2_RESUME",
|
|
"SS_GEAR_3_RESUME",
|
|
"SS_GEAR_4_RESUME",
|
|
"SS_TURBO",
|
|
"SS_REVERSE",
|
|
};
|
|
|
|
|
|
static int SoundStateIndexFromName( const char *pName )
|
|
{
|
|
for ( int i = 0; i < SS_NUM_STATES; i++ )
|
|
{
|
|
Assert( i < ARRAYSIZE(pSoundStateNames) );
|
|
if ( !strcmpi( pSoundStateNames[i], pName ) )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static const char *SoundStateNameFromIndex( int index )
|
|
{
|
|
index = clamp(index, 0, SS_NUM_STATES-1 );
|
|
return pSoundStateNames[index];
|
|
}
|
|
|
|
void CBaseServerVehicle::PlaySound( const char *pSound )
|
|
{
|
|
if ( !pSound || !pSound[0] )
|
|
return;
|
|
|
|
if ( g_debug_vehiclesound.GetInt() )
|
|
{
|
|
Msg("Playing non-looping vehicle sound: %s\n", pSound );
|
|
}
|
|
m_pVehicle->EmitSound( pSound );
|
|
}
|
|
|
|
void CBaseServerVehicle::StopLoopingSound( float fadeTime )
|
|
{
|
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
if ( m_pStateSoundFade )
|
|
{
|
|
controller.SoundDestroy( m_pStateSoundFade );
|
|
m_pStateSoundFade = NULL;
|
|
}
|
|
if ( m_pStateSound )
|
|
{
|
|
m_pStateSoundFade = m_pStateSound;
|
|
m_pStateSound = NULL;
|
|
controller.SoundFadeOut( m_pStateSoundFade, fadeTime, false );
|
|
}
|
|
}
|
|
|
|
void CBaseServerVehicle::PlayLoopingSound( const char *pSoundName )
|
|
{
|
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
|
|
CPASAttenuationFilter filter( m_pVehicle );
|
|
CSoundPatch *pNewSound = NULL;
|
|
if ( pSoundName && pSoundName[0] )
|
|
{
|
|
pNewSound = controller.SoundCreate( filter, m_pVehicle->entindex(), CHAN_STATIC, pSoundName, ATTN_NORM );
|
|
}
|
|
|
|
if ( m_pStateSound && pNewSound && controller.SoundGetName( pNewSound ) == controller.SoundGetName( m_pStateSound ) )
|
|
{
|
|
// if the sound is the same, don't play this, just re-use the old one
|
|
controller.SoundDestroy( pNewSound );
|
|
pNewSound = m_pStateSound;
|
|
controller.SoundChangeVolume( pNewSound, 1.0f, 0.0f );
|
|
m_pStateSound = NULL;
|
|
}
|
|
else if ( g_debug_vehiclesound.GetInt() )
|
|
{
|
|
const char *pStopSound = m_pStateSound ? controller.SoundGetName( m_pStateSound ).ToCStr() : "NULL";
|
|
const char *pStartSound = pNewSound ? controller.SoundGetName( pNewSound ).ToCStr() : "NULL";
|
|
Msg("Stop %s, start %s\n", pStopSound, pStartSound );
|
|
}
|
|
|
|
StopLoopingSound();
|
|
m_pStateSound = pNewSound;
|
|
if ( m_pStateSound )
|
|
{
|
|
controller.Play( m_pStateSound, 1.0f, 100 );
|
|
}
|
|
}
|
|
|
|
static sound_states MapGearToState( vbs_sound_update_t ¶ms, int gear )
|
|
{
|
|
switch( gear )
|
|
{
|
|
case 0: return params.bReverse ? SS_REVERSE : SS_GEAR_0;
|
|
case 1: return SS_GEAR_1;
|
|
case 2: return SS_GEAR_2;
|
|
case 3: return SS_GEAR_3;
|
|
default:case 4: return SS_GEAR_4;
|
|
}
|
|
}
|
|
|
|
static sound_states MapGearToMidState( vbs_sound_update_t ¶ms, int gear )
|
|
{
|
|
switch( gear )
|
|
{
|
|
case 0: return params.bReverse ? SS_REVERSE : SS_GEAR_0_RESUME;
|
|
case 1: return SS_GEAR_1_RESUME;
|
|
case 2: return SS_GEAR_2_RESUME;
|
|
case 3: return SS_GEAR_3_RESUME;
|
|
default:case 4: return SS_GEAR_4_RESUME;
|
|
}
|
|
}
|
|
|
|
bool CBaseServerVehicle::PlayCrashSound( float speed )
|
|
{
|
|
int i;
|
|
float delta = 0;
|
|
float absSpeed = fabs(speed);
|
|
float absLastSpeed = fabs(m_lastSpeed);
|
|
if ( absLastSpeed > absSpeed )
|
|
{
|
|
delta = fabs(m_lastSpeed - speed);
|
|
}
|
|
|
|
float rumble = delta / 8.0f;
|
|
|
|
if( rumble > 60.0f )
|
|
rumble = 60.0f;
|
|
|
|
if( rumble > 5.0f )
|
|
{
|
|
if ( GetDriver() )
|
|
{
|
|
UTIL_ScreenShake( GetDriver()->GetAbsOrigin(), rumble, 150.0f, 1.0f, 240.0f, SHAKE_START_RUMBLEONLY, true );
|
|
}
|
|
}
|
|
|
|
for ( i = 0; i < m_vehicleSounds.crashSounds.Count(); i++ )
|
|
{
|
|
const vehicle_crashsound_t &crash = m_vehicleSounds.crashSounds[i];
|
|
if ( !crash.gearLimit )
|
|
continue;
|
|
|
|
if ( m_iSoundGear <= crash.gearLimit )
|
|
{
|
|
if ( delta > crash.flMinDeltaSpeed && absLastSpeed > crash.flMinSpeed )
|
|
{
|
|
PlaySound( crash.iszCrashSound.ToCStr() );
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( i = m_vehicleSounds.crashSounds.Count()-1; i >= 0; --i )
|
|
{
|
|
const vehicle_crashsound_t &crash = m_vehicleSounds.crashSounds[i];
|
|
if ( delta > crash.flMinDeltaSpeed && absLastSpeed > crash.flMinSpeed )
|
|
{
|
|
PlaySound( crash.iszCrashSound.ToCStr() );
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool CBaseServerVehicle::CheckCrash( vbs_sound_update_t ¶ms )
|
|
{
|
|
if ( params.bVehicleInWater )
|
|
return false;
|
|
|
|
bool bCrashed = PlayCrashSound( params.flWorldSpaceSpeed );
|
|
if ( bCrashed )
|
|
{
|
|
if ( g_debug_vehiclesound.GetInt() )
|
|
{
|
|
Msg("Crashed!: speed %.2f, lastSpeed %.2f\n", params.flWorldSpaceSpeed, m_lastSpeed );
|
|
}
|
|
}
|
|
m_lastSpeed = params.flWorldSpaceSpeed;
|
|
return bCrashed;
|
|
}
|
|
|
|
|
|
sound_states CBaseServerVehicle::SoundState_ChooseState( vbs_sound_update_t ¶ms )
|
|
{
|
|
float timeInState = gpGlobals->curtime - m_soundStateStartTime;
|
|
bool bInStateForMinTime = timeInState > m_vehicleSounds.minStateTime[m_soundState] ? true : false;
|
|
|
|
sound_states stateOut = m_soundState;
|
|
|
|
// exit overrides everything else
|
|
if ( params.bExitVehicle )
|
|
{
|
|
switch ( m_soundState )
|
|
{
|
|
case SS_NONE:
|
|
case SS_SHUTDOWN:
|
|
case SS_SHUTDOWN_WATER:
|
|
return m_soundState;
|
|
}
|
|
return SS_SHUTDOWN;
|
|
}
|
|
|
|
// check global state in states that don't mask them
|
|
switch( m_soundState )
|
|
{
|
|
// global states masked for these states.
|
|
case SS_NONE:
|
|
case SS_START_IDLE:
|
|
case SS_SHUTDOWN:
|
|
break;
|
|
case SS_START_WATER:
|
|
case SS_SHUTDOWN_WATER:
|
|
if ( !params.bVehicleInWater )
|
|
return SS_START_IDLE;
|
|
break;
|
|
|
|
case SS_TURBO:
|
|
if ( params.bVehicleInWater )
|
|
return SS_SHUTDOWN_WATER;
|
|
if ( CheckCrash(params) )
|
|
return SS_IDLE;
|
|
break;
|
|
|
|
case SS_IDLE:
|
|
if ( params.bVehicleInWater )
|
|
return SS_SHUTDOWN_WATER;
|
|
break;
|
|
|
|
case SS_REVERSE:
|
|
case SS_GEAR_0:
|
|
case SS_GEAR_1:
|
|
case SS_GEAR_2:
|
|
case SS_GEAR_3:
|
|
case SS_GEAR_4:
|
|
case SS_SLOWDOWN:
|
|
case SS_SLOWDOWN_HIGHSPEED:
|
|
case SS_GEAR_0_RESUME:
|
|
case SS_GEAR_1_RESUME:
|
|
case SS_GEAR_2_RESUME:
|
|
case SS_GEAR_3_RESUME:
|
|
case SS_GEAR_4_RESUME:
|
|
if ( params.bVehicleInWater )
|
|
{
|
|
return SS_SHUTDOWN_WATER;
|
|
}
|
|
if ( params.bTurbo )
|
|
{
|
|
return SS_TURBO;
|
|
}
|
|
if ( CheckCrash(params) )
|
|
return SS_IDLE;
|
|
break;
|
|
}
|
|
|
|
switch( m_soundState )
|
|
{
|
|
case SS_START_IDLE:
|
|
if ( bInStateForMinTime || params.bThrottleDown )
|
|
return SS_IDLE;
|
|
break;
|
|
case SS_IDLE:
|
|
if ( bInStateForMinTime && params.bThrottleDown )
|
|
{
|
|
if ( params.bTurbo )
|
|
return SS_TURBO;
|
|
return params.bReverse ? SS_REVERSE : SS_GEAR_0;
|
|
}
|
|
break;
|
|
|
|
case SS_GEAR_0_RESUME:
|
|
case SS_GEAR_0:
|
|
if ( (bInStateForMinTime && !params.bThrottleDown) || params.bReverse )
|
|
{
|
|
return SS_IDLE;
|
|
}
|
|
if ( m_iSoundGear > 0 )
|
|
{
|
|
return SS_GEAR_1;
|
|
}
|
|
break;
|
|
case SS_GEAR_1_RESUME:
|
|
case SS_GEAR_1:
|
|
if ( bInStateForMinTime )
|
|
{
|
|
if ( !params.bThrottleDown )
|
|
return SS_SLOWDOWN;
|
|
}
|
|
if ( m_iSoundGear != 1 )
|
|
return MapGearToState( params, m_iSoundGear);
|
|
break;
|
|
|
|
case SS_GEAR_2_RESUME:
|
|
case SS_GEAR_2:
|
|
if ( bInStateForMinTime )
|
|
{
|
|
if ( !params.bThrottleDown )
|
|
return SS_SLOWDOWN;
|
|
else if ( m_iSoundGear != 2 )
|
|
return MapGearToState(params, m_iSoundGear);
|
|
}
|
|
break;
|
|
|
|
case SS_GEAR_3_RESUME:
|
|
case SS_GEAR_3:
|
|
if ( bInStateForMinTime )
|
|
{
|
|
if ( !params.bThrottleDown )
|
|
return SS_SLOWDOWN;
|
|
else if ( m_iSoundGear != 3 )
|
|
return MapGearToState(params, m_iSoundGear);
|
|
}
|
|
break;
|
|
|
|
case SS_GEAR_4_RESUME:
|
|
case SS_GEAR_4:
|
|
if ( bInStateForMinTime && !params.bThrottleDown )
|
|
{
|
|
return SS_SLOWDOWN;
|
|
}
|
|
if ( m_iSoundGear != 4 )
|
|
{
|
|
return MapGearToMidState(params, m_iSoundGear);
|
|
}
|
|
break;
|
|
case SS_REVERSE:
|
|
if ( bInStateForMinTime && !params.bReverse )
|
|
{
|
|
return SS_SLOWDOWN;
|
|
}
|
|
break;
|
|
|
|
case SS_SLOWDOWN_HIGHSPEED:
|
|
case SS_SLOWDOWN:
|
|
if ( params.bThrottleDown )
|
|
{
|
|
// map gears
|
|
return MapGearToMidState(params, m_iSoundGear);
|
|
}
|
|
if ( m_iSoundGear == 0 )
|
|
{
|
|
return SS_IDLE;
|
|
}
|
|
break;
|
|
|
|
case SS_NONE:
|
|
stateOut = params.bVehicleInWater ? SS_START_WATER : SS_START_IDLE;
|
|
break;
|
|
case SS_TURBO:
|
|
if ( bInStateForMinTime && !params.bTurbo )
|
|
{
|
|
return MapGearToMidState(params, m_iSoundGear);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return stateOut;
|
|
}
|
|
|
|
const char *CBaseServerVehicle::StateSoundName( sound_states state )
|
|
{
|
|
return m_vehicleSounds.iszStateSounds[state].ToCStr();
|
|
}
|
|
|
|
void CBaseServerVehicle::SoundState_OnNewState( sound_states lastState )
|
|
{
|
|
if ( g_debug_vehiclesound.GetInt() )
|
|
{
|
|
int index = m_soundState;
|
|
Msg("Switched to state: %d (%s)\n", m_soundState, SoundStateNameFromIndex(index) );
|
|
}
|
|
|
|
switch ( m_soundState )
|
|
{
|
|
case SS_SHUTDOWN:
|
|
case SS_SHUTDOWN_WATER:
|
|
case SS_START_WATER:
|
|
StopLoopingSound();
|
|
PlaySound( StateSoundName(m_soundState) );
|
|
break;
|
|
case SS_IDLE:
|
|
m_lastSpeed = -1;
|
|
PlayLoopingSound( StateSoundName(m_soundState) );
|
|
break;
|
|
case SS_START_IDLE:
|
|
case SS_REVERSE:
|
|
case SS_GEAR_0:
|
|
case SS_GEAR_0_RESUME:
|
|
case SS_GEAR_1:
|
|
case SS_GEAR_1_RESUME:
|
|
case SS_GEAR_2:
|
|
case SS_GEAR_2_RESUME:
|
|
case SS_GEAR_3:
|
|
case SS_GEAR_3_RESUME:
|
|
case SS_GEAR_4:
|
|
case SS_GEAR_4_RESUME:
|
|
case SS_TURBO:
|
|
PlayLoopingSound( StateSoundName(m_soundState) );
|
|
break;
|
|
|
|
case SS_SLOWDOWN_HIGHSPEED:
|
|
case SS_SLOWDOWN:
|
|
if ( m_iSoundGear < 2 )
|
|
{
|
|
PlayLoopingSound( StateSoundName( SS_SLOWDOWN ) );
|
|
}
|
|
else
|
|
{
|
|
PlayLoopingSound( StateSoundName( SS_SLOWDOWN_HIGHSPEED ) );
|
|
}
|
|
break;
|
|
|
|
default:break;
|
|
}
|
|
|
|
m_soundStateStartTime = gpGlobals->curtime;
|
|
}
|
|
|
|
|
|
void CBaseServerVehicle::SoundState_Update( vbs_sound_update_t ¶ms )
|
|
{
|
|
sound_states newState = SoundState_ChooseState( params );
|
|
if ( newState != m_soundState )
|
|
{
|
|
sound_states lastState = m_soundState;
|
|
m_soundState = newState;
|
|
SoundState_OnNewState( lastState );
|
|
}
|
|
|
|
switch( m_soundState )
|
|
{
|
|
case SS_SHUTDOWN:
|
|
case SS_SHUTDOWN_WATER:
|
|
case SS_START_WATER:
|
|
case SS_START_IDLE:
|
|
case SS_IDLE:
|
|
case SS_REVERSE:
|
|
case SS_GEAR_0:
|
|
case SS_GEAR_4:
|
|
case SS_SLOWDOWN_HIGHSPEED:
|
|
case SS_SLOWDOWN:
|
|
case SS_GEAR_0_RESUME:
|
|
case SS_GEAR_4_RESUME:
|
|
break;
|
|
default:break;
|
|
}
|
|
}
|
|
|
|
void CBaseServerVehicle::InitSoundParams( vbs_sound_update_t ¶ms )
|
|
{
|
|
params.Defaults();
|
|
params.bVehicleInWater = IsVehicleBodyInWater();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Vehicle Sound Start
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::SoundStart()
|
|
{
|
|
StartEngineRumble();
|
|
|
|
m_soundState = SS_NONE;
|
|
vbs_sound_update_t params;
|
|
InitSoundParams(params);
|
|
|
|
SoundState_Update( params );
|
|
}
|
|
|
|
// vehicle is starting up disabled, but in some cases you still want to play a sound
|
|
// HACK: handle those here.
|
|
void CBaseServerVehicle::SoundStartDisabled()
|
|
{
|
|
m_soundState = SS_NONE;
|
|
vbs_sound_update_t params;
|
|
InitSoundParams(params);
|
|
sound_states newState = SoundState_ChooseState( params );
|
|
|
|
switch( newState )
|
|
{
|
|
case SS_START_WATER:
|
|
PlaySound( StateSoundName(newState) );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::SoundShutdown( float flFadeTime )
|
|
{
|
|
StopEngineRumble();
|
|
|
|
// Stop any looping sounds that may be running, as the following stop sound may not exist
|
|
// and thus leave a looping sound playing after the user gets out.
|
|
for ( int i = 0; i < NUM_SOUNDS_TO_STOP_ON_EXIT; i++ )
|
|
{
|
|
StopSound( g_iSoundsToStopOnExit[i] );
|
|
}
|
|
|
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
if ( m_pStateSoundFade )
|
|
{
|
|
controller.SoundFadeOut( m_pStateSoundFade, flFadeTime, true );
|
|
m_pStateSoundFade = NULL;
|
|
}
|
|
if ( m_pStateSound )
|
|
{
|
|
controller.SoundFadeOut( m_pStateSound, flFadeTime, true );
|
|
m_pStateSound = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::SoundUpdate( vbs_sound_update_t ¶ms )
|
|
{
|
|
if ( g_debug_vehiclesound.GetInt() > 1 )
|
|
{
|
|
Msg("Throttle: %s, Reverse: %s\n", params.bThrottleDown?"on":"off", params.bReverse?"on":"off" );
|
|
}
|
|
|
|
float flCurrentSpeed = params.flCurrentSpeedFraction;
|
|
if ( g_debug_vehiclesound.GetInt() > 1 )
|
|
{
|
|
Msg("CurrentSpeed: %.3f ", flCurrentSpeed );
|
|
}
|
|
|
|
// Figure out our speed for the purposes of sound playing.
|
|
// We slow the transition down a little to make the gear changes slower.
|
|
if ( m_vehicleSounds.pGears.Count() > 0 )
|
|
{
|
|
if ( flCurrentSpeed > m_flSpeedPercentage )
|
|
{
|
|
// don't accelerate when the throttle isn't down
|
|
if ( !params.bThrottleDown )
|
|
{
|
|
flCurrentSpeed = m_flSpeedPercentage;
|
|
}
|
|
flCurrentSpeed = Approach( flCurrentSpeed, m_flSpeedPercentage, params.flFrameTime * m_vehicleSounds.pGears[m_iSoundGear].flSpeedApproachFactor );
|
|
}
|
|
}
|
|
m_flSpeedPercentage = clamp( flCurrentSpeed, 0.0f, 1.0f );
|
|
|
|
if ( g_debug_vehiclesound.GetInt() > 1 )
|
|
{
|
|
Msg("Sound Speed: %.3f\n", m_flSpeedPercentage );
|
|
}
|
|
|
|
// Only do gear changes when the throttle's down
|
|
RecalculateSoundGear( params );
|
|
|
|
SoundState_Update( params );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Play a non-gear based vehicle sound
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::PlaySound( vehiclesound iSound )
|
|
{
|
|
if ( m_vehicleSounds.iszSound[iSound] != NULL_STRING )
|
|
{
|
|
CPASAttenuationFilter filter( m_pVehicle );
|
|
|
|
EmitSound_t ep;
|
|
ep.m_nChannel = CHAN_VOICE;
|
|
ep.m_pSoundName = STRING(m_vehicleSounds.iszSound[iSound]);
|
|
ep.m_flVolume = m_flVehicleVolume;
|
|
ep.m_SoundLevel = SNDLVL_NORM;
|
|
|
|
CBaseEntity::EmitSound( filter, m_pVehicle->entindex(), ep );
|
|
if ( g_debug_vehiclesound.GetInt() )
|
|
{
|
|
Msg("Playing vehicle sound: %s\n", ep.m_pSoundName );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Stop a non-gear based vehicle sound
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::StopSound( vehiclesound iSound )
|
|
{
|
|
if ( m_vehicleSounds.iszSound[iSound] != NULL_STRING )
|
|
{
|
|
CBaseEntity::StopSound( m_pVehicle->entindex(), CHAN_VOICE, STRING(m_vehicleSounds.iszSound[iSound]) );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Calculate the gear we should be in based upon the vehicle's current speed
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::RecalculateSoundGear( vbs_sound_update_t ¶ms )
|
|
{
|
|
int iNumGears = m_vehicleSounds.pGears.Count();
|
|
for ( int i = (iNumGears-1); i >= 0; i-- )
|
|
{
|
|
if ( m_flSpeedPercentage > m_vehicleSounds.pGears[i].flMinSpeed )
|
|
{
|
|
m_iSoundGear = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we're going in reverse, we want to stay in first gear
|
|
if ( params.bReverse )
|
|
{
|
|
m_iSoundGear = 0;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CBaseServerVehicle::StartEngineRumble()
|
|
{
|
|
return;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CBaseServerVehicle::StopEngineRumble()
|
|
{
|
|
return;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the passenger in the given seat of the vehicle
|
|
// Input : nSeatID - seat ID to check
|
|
// Output : CBaseCombatCharacter - character in the seat
|
|
//-----------------------------------------------------------------------------
|
|
CBaseCombatCharacter *CBaseServerVehicle::NPC_GetPassengerInSeat( int nRoleID, int nSeatID )
|
|
{
|
|
// Search all passengers in the vehicle
|
|
for ( int i = 0; i < m_PassengerInfo.Count(); i++ )
|
|
{
|
|
// If the seat ID matches, return the entity in that seat
|
|
if ( m_PassengerInfo[i].GetSeat() == nSeatID && m_PassengerInfo[i].GetRole() == nRoleID )
|
|
return m_PassengerInfo[i].m_hPassenger;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the first available seat (ranked by priority)
|
|
// Input : nRoleID - Role index
|
|
// Output : int - Seat by index
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::NPC_GetAvailableSeat_Any( CBaseCombatCharacter *pPassenger, int nRoleID )
|
|
{
|
|
// Look through all available seats
|
|
for ( int i = 0; i < m_PassengerRoles[nRoleID].m_PassengerSeats.Count(); i++ )
|
|
{
|
|
// See if anyone is already in this seat
|
|
CBaseCombatCharacter *pCurrentPassenger = NPC_GetPassengerInSeat( nRoleID, i );
|
|
if ( pCurrentPassenger != NULL && pCurrentPassenger != pPassenger )
|
|
continue;
|
|
|
|
// This seat is open
|
|
return i;
|
|
}
|
|
|
|
// Nothing found
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the seat with the nearest entry point to the querier
|
|
// Input : *pPassenger - Terget to be nearest to
|
|
// nRoleID - Role index
|
|
// Output : int - Seat by index
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::NPC_GetAvailableSeat_Nearest( CBaseCombatCharacter *pPassenger, int nRoleID )
|
|
{
|
|
// Not yet implemented
|
|
Assert( 0 );
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get a seat in the vehicle based on our role and criteria
|
|
// Input : *pPassenger - Entity attempting to find a seat
|
|
// strRoleName - Role the seat must serve
|
|
// nQueryType - Method for choosing the best seat (if multiple)
|
|
// Output : int - Seat by unique ID
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::NPC_GetAvailableSeat( CBaseCombatCharacter *pPassenger, string_t strRoleName, VehicleSeatQuery_e nQueryType )
|
|
{
|
|
// Parse the vehicle animations the first time they get in the vehicle
|
|
if ( m_bParsedAnimations == false )
|
|
{
|
|
// Load the entry/exit animations from the vehicle
|
|
ParseEntryExitAnims();
|
|
m_bParsedAnimations = true;
|
|
}
|
|
|
|
// Get the role index
|
|
int nRole = FindRoleIndexByName( strRoleName );
|
|
if ( m_PassengerRoles.IsValidIndex( nRole ) == false )
|
|
return -1;
|
|
|
|
switch( nQueryType )
|
|
{
|
|
case VEHICLE_SEAT_ANY:
|
|
return NPC_GetAvailableSeat_Any( pPassenger, nRole );
|
|
break;
|
|
|
|
case VEHICLE_SEAT_NEAREST:
|
|
return NPC_GetAvailableSeat_Nearest( pPassenger, nRole );
|
|
break;
|
|
|
|
default:
|
|
Assert( 0 );
|
|
break;
|
|
};
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determine if there's an available seat of a given role name
|
|
// Input : strRoleName - name of the role
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::NPC_HasAvailableSeat( string_t strRoleName )
|
|
{
|
|
return ( NPC_GetAvailableSeat( NULL, strRoleName, VEHICLE_SEAT_ANY ) != -1 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find a role index by name
|
|
// Input : strRoleName - name of the role
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::FindRoleIndexByName( string_t strRoleName )
|
|
{
|
|
// Search through all our known roles
|
|
for ( int i = 0; i < m_PassengerRoles.Count(); i++ )
|
|
{
|
|
// Return the index if the name matches
|
|
if ( FStrEq( STRING( m_PassengerRoles[i].GetName() ), STRING( strRoleName ) ) )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find a seat index by its name
|
|
// Input : strSeatName - name of the seat
|
|
//-----------------------------------------------------------------------------
|
|
int CBaseServerVehicle::FindSeatIndexByName( int nRoleIndex, string_t strSeatName )
|
|
{
|
|
// Role must be valid
|
|
if ( m_PassengerRoles.IsValidIndex( nRoleIndex ) == false )
|
|
return -1;
|
|
|
|
// Used for attachment polling
|
|
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(GetVehicleEnt());
|
|
if ( pAnimating == NULL )
|
|
return -1;
|
|
|
|
// Get the index of the named attachment in the model
|
|
int nAttachmentID = pAnimating->LookupAttachment( STRING( strSeatName ) );
|
|
|
|
// Look through the roles for this seat attachment ID
|
|
for ( int i = 0; i < m_PassengerRoles[nRoleIndex].m_PassengerSeats.Count(); i++ )
|
|
{
|
|
// Return that index if found
|
|
if ( m_PassengerRoles[nRoleIndex].m_PassengerSeats[i].GetAttachmentID() == nAttachmentID )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called after loading a saved game
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseServerVehicle::RestorePassengerInfo( void )
|
|
{
|
|
// If there is passenger information, then we have passengers in the vehicle
|
|
if ( m_PassengerInfo.Count() != 0 && m_bParsedAnimations == false )
|
|
{
|
|
// Load the entry/exit animations from the vehicle
|
|
ParseEntryExitAnims();
|
|
m_bParsedAnimations = true;
|
|
}
|
|
|
|
// FIXME: If a passenger cannot fix-up its indices, it must be removed from the vehicle!
|
|
|
|
// Fix-up every passenger with updated indices
|
|
for ( int i = 0; i < m_PassengerInfo.Count(); i++ )
|
|
{
|
|
// Fix up the role first
|
|
int nRoleIndex = FindRoleIndexByName( m_PassengerInfo[i].m_strRoleName );
|
|
if ( m_PassengerRoles.IsValidIndex( nRoleIndex ) )
|
|
{
|
|
// New role index
|
|
m_PassengerInfo[i].m_nRole = nRoleIndex;
|
|
|
|
// Then fix up the seat via attachment name
|
|
int nSeatIndex = FindSeatIndexByName( nRoleIndex, m_PassengerInfo[i].m_strSeatName );
|
|
if ( m_PassengerRoles[nRoleIndex].m_PassengerSeats.IsValidIndex( nSeatIndex ) )
|
|
{
|
|
// New seat index
|
|
m_PassengerInfo[i].m_nSeat = nSeatIndex;
|
|
}
|
|
else
|
|
{
|
|
// The seat attachment was not found. This most likely means that the seat attachment name has changed
|
|
// in the target vehicle and the NPC passenger is now stranded!
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The role was not found. This most likely means that the role names have changed
|
|
// in the target vehicle and the NPC passenger is now stranded!
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBaseServerVehicle::ReloadScript()
|
|
{
|
|
if ( m_pDrivableVehicle )
|
|
{
|
|
string_t script = m_pDrivableVehicle->GetVehicleScriptName();
|
|
IPhysicsVehicleController *pController = GetVehicleController();
|
|
vehicleparams_t *pVehicleParams = pController ? &(pController->GetVehicleParamsForChange()) : NULL;
|
|
PhysFindOrAddVehicleScript( script.ToCStr(), pVehicleParams, &m_vehicleSounds );
|
|
if ( pController )
|
|
{
|
|
pController->VehicleDataReload();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Passes this call down into the server vehicle where the tests are done
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseServerVehicle::PassengerShouldReceiveDamage( CTakeDamageInfo &info )
|
|
{
|
|
if ( GetDrivableVehicle() )
|
|
return GetDrivableVehicle()->PassengerShouldReceiveDamage( info );
|
|
|
|
return true;
|
|
}
|
|
|
|
//===========================================================================================================
|
|
// Vehicle Sounds
|
|
//===========================================================================================================
|
|
|
|
// These are sounds that are to be automatically stopped whenever the vehicle's driver leaves it
|
|
vehiclesound g_iSoundsToStopOnExit[] =
|
|
{
|
|
VS_ENGINE2_START,
|
|
VS_ENGINE2_STOP,
|
|
};
|
|
|
|
const char *vehiclesound_parsenames[VS_NUM_SOUNDS] =
|
|
{
|
|
"skid_lowfriction",
|
|
"skid_normalfriction",
|
|
"skid_highfriction",
|
|
"engine2_start",
|
|
"engine2_stop",
|
|
"misc1",
|
|
"misc2",
|
|
"misc3",
|
|
"misc4",
|
|
};
|
|
|
|
CVehicleSoundsParser::CVehicleSoundsParser( void )
|
|
{
|
|
// UNDONE: Revisit this pattern - move sub-block processing ideas into the parser architecture
|
|
m_iCurrentGear = -1;
|
|
m_iCurrentState = -1;
|
|
m_iCurrentCrashSound = -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CVehicleSoundsParser::ParseKeyValue( void *pData, const char *pKey, const char *pValue )
|
|
{
|
|
vehiclesounds_t *pSounds = (vehiclesounds_t *)pData;
|
|
// New gear?
|
|
if ( !strcmpi( pKey, "gear" ) )
|
|
{
|
|
// Create, initialize, and add a new gear to our list
|
|
int iNewGear = pSounds->pGears.AddToTail();
|
|
pSounds->pGears[iNewGear].flMaxSpeed = 0;
|
|
pSounds->pGears[iNewGear].flSpeedApproachFactor = 1.0;
|
|
|
|
// Set our min speed to the previous gear's max
|
|
if ( iNewGear == 0 )
|
|
{
|
|
// First gear, so our minspeed is 0
|
|
pSounds->pGears[iNewGear].flMinSpeed = 0;
|
|
}
|
|
else
|
|
{
|
|
pSounds->pGears[iNewGear].flMinSpeed = pSounds->pGears[iNewGear-1].flMaxSpeed;
|
|
}
|
|
|
|
// Remember which gear we're reading data from
|
|
m_iCurrentGear = iNewGear;
|
|
}
|
|
else if ( !strcmpi( pKey, "state" ) )
|
|
{
|
|
m_iCurrentState = 0;
|
|
}
|
|
else if ( !strcmpi( pKey, "crashsound" ) )
|
|
{
|
|
m_iCurrentCrashSound = pSounds->crashSounds.AddToTail();
|
|
pSounds->crashSounds[m_iCurrentCrashSound].flMinSpeed = 0;
|
|
pSounds->crashSounds[m_iCurrentCrashSound].flMinDeltaSpeed = 0;
|
|
pSounds->crashSounds[m_iCurrentCrashSound].iszCrashSound = NULL_STRING;
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
|
|
// Are we currently in a gear block?
|
|
if ( m_iCurrentGear >= 0 )
|
|
{
|
|
Assert( m_iCurrentGear < pSounds->pGears.Count() );
|
|
|
|
// Check gear keys
|
|
if ( !strcmpi( pKey, "max_speed" ) )
|
|
{
|
|
pSounds->pGears[m_iCurrentGear].flMaxSpeed = atof(pValue);
|
|
return;
|
|
}
|
|
if ( !strcmpi( pKey, "speed_approach_factor" ) )
|
|
{
|
|
pSounds->pGears[m_iCurrentGear].flSpeedApproachFactor = atof(pValue);
|
|
return;
|
|
}
|
|
}
|
|
// We're done reading a gear, so stop checking them.
|
|
m_iCurrentGear = -1;
|
|
|
|
if ( m_iCurrentState >= 0 )
|
|
{
|
|
if ( !strcmpi( pKey, "name" ) )
|
|
{
|
|
m_iCurrentState = SoundStateIndexFromName( pValue );
|
|
pSounds->iszStateSounds[m_iCurrentState] = NULL_STRING;
|
|
pSounds->minStateTime[m_iCurrentState] = 0.0f;
|
|
return;
|
|
}
|
|
else if ( !strcmpi( pKey, "sound" ) )
|
|
{
|
|
pSounds->iszStateSounds[m_iCurrentState] = AllocPooledString(pValue);
|
|
return;
|
|
}
|
|
else if ( !strcmpi( pKey, "min_time" ) )
|
|
{
|
|
pSounds->minStateTime[m_iCurrentState] = atof(pValue);
|
|
return;
|
|
}
|
|
}
|
|
//
|
|
m_iCurrentState = -1;
|
|
|
|
if ( m_iCurrentCrashSound >= 0 )
|
|
{
|
|
if ( !strcmpi( pKey, "min_speed" ) )
|
|
{
|
|
pSounds->crashSounds[m_iCurrentCrashSound].flMinSpeed = atof(pValue);
|
|
return;
|
|
}
|
|
else if ( !strcmpi( pKey, "sound" ) )
|
|
{
|
|
pSounds->crashSounds[m_iCurrentCrashSound].iszCrashSound = AllocPooledString(pValue);
|
|
return;
|
|
}
|
|
else if ( !strcmpi( pKey, "min_speed_change" ) )
|
|
{
|
|
pSounds->crashSounds[m_iCurrentCrashSound].flMinDeltaSpeed = atof(pValue);
|
|
return;
|
|
}
|
|
else if ( !strcmpi( pKey, "gear_limit" ) )
|
|
{
|
|
pSounds->crashSounds[m_iCurrentCrashSound].gearLimit = atoi(pValue);
|
|
return;
|
|
}
|
|
}
|
|
m_iCurrentCrashSound = -1;
|
|
|
|
for ( i = 0; i < VS_NUM_SOUNDS; i++ )
|
|
{
|
|
if ( !strcmpi( pKey, vehiclesound_parsenames[i] ) )
|
|
{
|
|
pSounds->iszSound[i] = AllocPooledString(pValue);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CVehicleSoundsParser::SetDefaults( void *pData )
|
|
{
|
|
vehiclesounds_t *pSounds = (vehiclesounds_t *)pData;
|
|
pSounds->Init();
|
|
}
|
|
|