sqwarmed/sdk_src/game/server/vehicle_baseserver.cpp

2748 lines
86 KiB
C++
Raw Normal View History

2024-08-29 19:18:30 -04:00
//========= Copyright <20> 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 &params, 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 &params, 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 &params )
{
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 &params )
{
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 &params )
{
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 &params )
{
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 &params )
{
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 &params )
{
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();
}