You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2747 lines
83 KiB
2747 lines
83 KiB
//========= Copyright © 1996-2005, 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, |
|
}; |
|
|
|
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(); |
|
} |
|
|
|
|