expvintl/source-engine-2018-hl2_src
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
source-engine-2018-hl2_src/game/server/episodic/vehicle_jeep_episodic.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1765 lines
54 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//
//
//=============================================================================
#include "cbase.h"
#include "vehicle_jeep_episodic.h"
#include "collisionutils.h"
#include "npc_alyx_episodic.h"
#include "particle_parse.h"
#include "particle_system.h"
#include "hl2_player.h"
#include "in_buttons.h"
#include "vphysics/friction.h"
#include "vphysicsupdateai.h"
#include "physics_npc_solver.h"
#include "Sprite.h"
#include "weapon_striderbuster.h"
#include "npc_strider.h"
#include "vguiscreen.h"
#include "hl2_vehicle_radar.h"
#include "props.h"
#include "ai_dynamiclink.h"
extern ConVar phys_upimpactforcescale;
ConVar jalopy_blocked_exit_max_speed( "jalopy_blocked_exit_max_speed", "50" );
#define JEEP_AMMOCRATE_HITGROUP 5
#define JEEP_AMMO_CRATE_CLOSE_DELAY 2.0f
// Bodygroups
#define JEEP_RADAR_BODYGROUP 1
#define JEEP_HOPPER_BODYGROUP 2
#define JEEP_CARBAR_BODYGROUP 3
#define RADAR_PANEL_MATERIAL "vgui/screens/radar"
#define RADAR_PANEL_WRITEZ "engine/writez"
static const char *s_szHazardSprite = "sprites/light_glow01.vmt";
enum
{
RADAR_MODE_NORMAL = 0,
RADAR_MODE_STICKY,
};
//=========================================================
//=========================================================
class CRadarTarget : public CPointEntity
{
DECLARE_CLASS( CRadarTarget, CPointEntity );
public:
void Spawn();
bool IsDisabled() { return m_bDisabled; }
int GetType() { return m_iType; }
int GetMode() { return m_iMode; }
void InputEnable( inputdata_t &inputdata );
void InputDisable( inputdata_t &inputdata );
int ObjectCaps();
private:
bool m_bDisabled;
int m_iType;
int m_iMode;
public:
float m_flRadius;
DECLARE_DATADESC();
};
LINK_ENTITY_TO_CLASS( info_radar_target, CRadarTarget );
BEGIN_DATADESC( CRadarTarget )
DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ),
DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "radius" ),
DEFINE_KEYFIELD( m_iType, FIELD_INTEGER, "type" ),
DEFINE_KEYFIELD( m_iMode, FIELD_INTEGER, "mode" ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable",InputDisable ),
END_DATADESC();
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CRadarTarget::Spawn()
{
BaseClass::Spawn();
AddEffects( EF_NODRAW );
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_NONE );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CRadarTarget::InputEnable( inputdata_t &inputdata )
{
m_bDisabled = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CRadarTarget::InputDisable( inputdata_t &inputdata )
{
m_bDisabled = true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CRadarTarget::ObjectCaps()
{
return BaseClass::ObjectCaps() | FCAP_ACROSS_TRANSITION;
}
//
// Trigger which detects entities placed in the cargo hold of the jalopy
//
class CVehicleCargoTrigger : public CBaseEntity
{
DECLARE_CLASS( CVehicleCargoTrigger, CBaseEntity );
public:
//
// Creates a trigger with the specified bounds
static CVehicleCargoTrigger *Create( const Vector &vecOrigin, const Vector &vecMins, const Vector &vecMaxs, CBaseEntity *pOwner )
{
CVehicleCargoTrigger *pTrigger = (CVehicleCargoTrigger *) CreateEntityByName( "trigger_vehicle_cargo" );
if ( pTrigger == NULL )
return NULL;
UTIL_SetOrigin( pTrigger, vecOrigin );
UTIL_SetSize( pTrigger, vecMins, vecMaxs );
pTrigger->SetOwnerEntity( pOwner );
pTrigger->SetParent( pOwner );
pTrigger->Spawn();
return pTrigger;
}
//
// Handles the trigger touching its intended quarry
void CargoTouch( CBaseEntity *pOther )
{
// Cannot be ignoring touches
if ( ( m_hIgnoreEntity == pOther ) || ( m_flIgnoreDuration >= gpGlobals->curtime ) )
return;
// Make sure this object is being held by the player
if ( pOther->VPhysicsGetObject() == NULL || (pOther->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD) == false )
return;
if ( StriderBuster_NumFlechettesAttached( pOther ) > 0 )
return;
AddCargo( pOther );
}
bool AddCargo( CBaseEntity *pOther )
{
// For now, only bother with strider busters
if ( (FClassnameIs( pOther, "weapon_striderbuster" ) == false) &&
(FClassnameIs( pOther, "npc_grenade_magna" ) == false)
)
return false;
// Must be a physics prop
CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>(pOther);
if ( pOther == NULL )
return false;
CPropJeepEpisodic *pJeep = dynamic_cast< CPropJeepEpisodic * >( GetOwnerEntity() );
if ( pJeep == NULL )
return false;
// Make the player release the item
Pickup_ForcePlayerToDropThisObject( pOther );
// Stop colliding with things
pOther->VPhysicsDestroyObject();
pOther->SetSolidFlags( FSOLID_NOT_SOLID );
pOther->SetMoveType( MOVETYPE_NONE );
// Parent the object to our owner
pOther->SetParent( GetOwnerEntity() );
// The car now owns the entity
pJeep->AddPropToCargoHold( pProp );
// Notify the buster that it's been added to the cargo hold.
StriderBuster_OnAddToCargoHold( pProp );
// Stop touching this item
Disable();
return true;
}
//
// Setup the entity
void Spawn( void )
{
BaseClass::Spawn();
SetSolid( SOLID_BBOX );
SetSolidFlags( FSOLID_TRIGGER | FSOLID_NOT_SOLID );
SetTouch( &CVehicleCargoTrigger::CargoTouch );
}
void Activate()
{
BaseClass::Activate();
SetSolidFlags( FSOLID_TRIGGER | FSOLID_NOT_SOLID ); // Fixes up old savegames
}
//
// When we've stopped touching this entity, we ignore it
void EndTouch( CBaseEntity *pOther )
{
if ( pOther == m_hIgnoreEntity )
{
m_hIgnoreEntity = NULL;
}
BaseClass::EndTouch( pOther );
}
//
// Disables the trigger for a set duration
void IgnoreTouches( CBaseEntity *pIgnoreEntity )
{
m_hIgnoreEntity = pIgnoreEntity;
m_flIgnoreDuration = gpGlobals->curtime + 0.5f;
}
void Disable( void )
{
SetTouch( NULL );
}
void Enable( void )
{
SetTouch( &CVehicleCargoTrigger::CargoTouch );
}
protected:
float m_flIgnoreDuration;
CHandle <CBaseEntity> m_hIgnoreEntity;
DECLARE_DATADESC();
};
LINK_ENTITY_TO_CLASS( trigger_vehicle_cargo, CVehicleCargoTrigger );
BEGIN_DATADESC( CVehicleCargoTrigger )
DEFINE_FIELD( m_flIgnoreDuration, FIELD_TIME ),
DEFINE_FIELD( m_hIgnoreEntity, FIELD_EHANDLE ),
DEFINE_ENTITYFUNC( CargoTouch ),
END_DATADESC();
//
// Transition reference point for the vehicle
//
class CInfoTargetVehicleTransition : public CPointEntity
{
public:
DECLARE_CLASS( CInfoTargetVehicleTransition, CPointEntity );
void Enable( void ) { m_bDisabled = false; }
void Disable( void ) { m_bDisabled = true; }
bool IsDisabled( void ) const { return m_bDisabled; }
private:
void InputEnable( inputdata_t &data ) { Enable(); }
void InputDisable( inputdata_t &data ) { Disable(); }
bool m_bDisabled;
DECLARE_DATADESC();
};
BEGIN_DATADESC( CInfoTargetVehicleTransition )
DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable",InputDisable ),
END_DATADESC();
LINK_ENTITY_TO_CLASS( info_target_vehicle_transition, CInfoTargetVehicleTransition );
//
// CPropJeepEpisodic
//
LINK_ENTITY_TO_CLASS( prop_vehicle_jeep, CPropJeepEpisodic );
BEGIN_DATADESC( CPropJeepEpisodic )
DEFINE_FIELD( m_bEntranceLocked, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bExitLocked, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hCargoProp, FIELD_EHANDLE ),
DEFINE_FIELD( m_hCargoTrigger, FIELD_EHANDLE ),
DEFINE_FIELD( m_bAddingCargo, FIELD_BOOLEAN ),
DEFINE_ARRAY( m_hWheelDust, FIELD_EHANDLE, NUM_WHEEL_EFFECTS ),
DEFINE_ARRAY( m_hWheelWater, FIELD_EHANDLE, NUM_WHEEL_EFFECTS ),
DEFINE_ARRAY( m_hHazardLights, FIELD_EHANDLE, NUM_HAZARD_LIGHTS ),
DEFINE_FIELD( m_flCargoStartTime, FIELD_TIME ),
DEFINE_FIELD( m_bBlink, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bRadarEnabled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bRadarDetectsEnemies, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hRadarScreen, FIELD_EHANDLE ),
DEFINE_FIELD( m_hLinkControllerFront, FIELD_EHANDLE ),
DEFINE_FIELD( m_hLinkControllerRear, FIELD_EHANDLE ),
DEFINE_KEYFIELD( m_bBusterHopperVisible, FIELD_BOOLEAN, "CargoVisible" ),
// m_flNextAvoidBroadcastTime
DEFINE_FIELD( m_flNextWaterSound, FIELD_TIME ),
DEFINE_FIELD( m_flNextRadarUpdateTime, FIELD_TIME ),
DEFINE_FIELD( m_iNumRadarContacts, FIELD_INTEGER ),
DEFINE_ARRAY( m_vecRadarContactPos, FIELD_POSITION_VECTOR, RADAR_MAX_CONTACTS ),
DEFINE_ARRAY( m_iRadarContactType, FIELD_INTEGER, RADAR_MAX_CONTACTS ),
DEFINE_THINKFUNC( HazardBlinkThink ),
DEFINE_OUTPUT( m_OnCompanionEnteredVehicle, "OnCompanionEnteredVehicle" ),
DEFINE_OUTPUT( m_OnCompanionExitedVehicle, "OnCompanionExitedVehicle" ),
DEFINE_OUTPUT( m_OnHostileEnteredVehicle, "OnHostileEnteredVehicle" ),
DEFINE_OUTPUT( m_OnHostileExitedVehicle, "OnHostileExitedVehicle" ),
DEFINE_INPUTFUNC( FIELD_VOID, "LockEntrance", InputLockEntrance ),
DEFINE_INPUTFUNC( FIELD_VOID, "UnlockEntrance", InputUnlockEntrance ),
DEFINE_INPUTFUNC( FIELD_VOID, "LockExit", InputLockExit ),
DEFINE_INPUTFUNC( FIELD_VOID, "UnlockExit", InputUnlockExit ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnableRadar", InputEnableRadar ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableRadar", InputDisableRadar ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnableRadarDetectEnemies", InputEnableRadarDetectEnemies ),
DEFINE_INPUTFUNC( FIELD_VOID, "AddBusterToCargo", InputAddBusterToCargo ),
DEFINE_INPUTFUNC( FIELD_VOID, "OutsideTransition", InputOutsideTransition ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisablePhysGun", InputDisablePhysGun ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnablePhysGun", InputEnablePhysGun ),
DEFINE_INPUTFUNC( FIELD_VOID, "CreateLinkController", InputCreateLinkController ),
DEFINE_INPUTFUNC( FIELD_VOID, "DestroyLinkController", InputDestroyLinkController ),
DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetCargoHopperVisibility", InputSetCargoVisibility ),
END_DATADESC();
IMPLEMENT_SERVERCLASS_ST(CPropJeepEpisodic, DT_CPropJeepEpisodic)
//CNetworkVar( int, m_iNumRadarContacts );
SendPropInt( SENDINFO(m_iNumRadarContacts), 8 ),
//CNetworkArray( Vector, m_vecRadarContactPos, RADAR_MAX_CONTACTS );
SendPropArray( SendPropVector( SENDINFO_ARRAY(m_vecRadarContactPos), -1, SPROP_COORD), m_vecRadarContactPos ),
//CNetworkArray( int, m_iRadarContactType, RADAR_MAX_CONTACTS );
SendPropArray( SendPropInt(SENDINFO_ARRAY(m_iRadarContactType), RADAR_CONTACT_TYPE_BITS ), m_iRadarContactType ),
END_SEND_TABLE()
//=============================================================================
// Episodic jeep
CPropJeepEpisodic::CPropJeepEpisodic( void ) :
m_bEntranceLocked( false ),
m_bExitLocked( false ),
m_bAddingCargo( false ),
m_flNextAvoidBroadcastTime( 0.0f )
{
m_bHasGun = false;
m_bUnableToFire = true;
m_bRadarDetectsEnemies = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::UpdateOnRemove( void )
{
BaseClass::UpdateOnRemove();
// Kill our wheel dust
for ( int i = 0; i < NUM_WHEEL_EFFECTS; i++ )
{
if ( m_hWheelDust[i] != NULL )
{
UTIL_Remove( m_hWheelDust[i] );
}
if ( m_hWheelWater[i] != NULL )
{
UTIL_Remove( m_hWheelWater[i] );
}
}
DestroyHazardLights();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::Precache( void )
{
PrecacheMaterial( RADAR_PANEL_MATERIAL );
PrecacheMaterial( RADAR_PANEL_WRITEZ );
PrecacheModel( s_szHazardSprite );
PrecacheScriptSound( "JNK_Radar_Ping_Friendly" );
PrecacheScriptSound( "Physics.WaterSplash" );
PrecacheParticleSystem( "WheelDust" );
PrecacheParticleSystem( "WheelSplash" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::EnterVehicle( CBaseCombatCharacter *pPassenger )
{
BaseClass::EnterVehicle( pPassenger );
// Turn our hazards off!
DestroyHazardLights();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::Spawn( void )
{
BaseClass::Spawn();
SetBlocksLOS( false );
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if ( pPlayer != NULL )
{
pPlayer->m_Local.m_iHideHUD |= HIDEHUD_VEHICLE_CROSSHAIR;
}
SetBodygroup( JEEP_HOPPER_BODYGROUP, m_bBusterHopperVisible ? 1 : 0);
CreateCargoTrigger();
// carbar bodygroup is always on
SetBodygroup( JEEP_CARBAR_BODYGROUP, 1 );
m_bRadarDetectsEnemies = false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::Activate()
{
m_iNumRadarContacts = 0; // Force first contact tone
BaseClass::Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::NPC_FinishedEnterVehicle( CAI_BaseNPC *pPassenger, bool bCompanion )
{
// FIXME: This will be moved to the NPCs entering and exiting
// Fire our outputs
if ( bCompanion )
{
m_OnCompanionEnteredVehicle.FireOutput( this, pPassenger );
}
else
{
m_OnHostileEnteredVehicle.FireOutput( this, pPassenger );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::NPC_FinishedExitVehicle( CAI_BaseNPC *pPassenger, bool bCompanion )
{
// FIXME: This will be moved to the NPCs entering and exiting
// Fire our outputs
if ( bCompanion )
{
m_OnCompanionExitedVehicle.FireOutput( this, pPassenger );
}
else
{
m_OnHostileExitedVehicle.FireOutput( this, pPassenger );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPassenger -
// bCompanion -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPropJeepEpisodic::NPC_CanEnterVehicle( CAI_BaseNPC *pPassenger, bool bCompanion )
{
// Must be unlocked
if ( bCompanion && m_bEntranceLocked )
return false;
return BaseClass::NPC_CanEnterVehicle( pPassenger, bCompanion );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPassenger -
// bCompanion -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPropJeepEpisodic::NPC_CanExitVehicle( CAI_BaseNPC *pPassenger, bool bCompanion )
{
// Must be unlocked
if ( bCompanion && m_bExitLocked )
return false;
return BaseClass::NPC_CanExitVehicle( pPassenger, bCompanion );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputLockEntrance( inputdata_t &data )
{
m_bEntranceLocked = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputUnlockEntrance( inputdata_t &data )
{
m_bEntranceLocked = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputLockExit( inputdata_t &data )
{
m_bExitLocked = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputUnlockExit( inputdata_t &data )
{
m_bExitLocked = false;
}
//-----------------------------------------------------------------------------
// Purpose: Turn on the Jalopy radar device
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputEnableRadar( inputdata_t &data )
{
if( m_bRadarEnabled )
return; // Already enabled
SetBodygroup( JEEP_RADAR_BODYGROUP, 1 );
SpawnRadarPanel();
}
//-----------------------------------------------------------------------------
// Purpose: Turn off the Jalopy radar device
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputDisableRadar( inputdata_t &data )
{
if( !m_bRadarEnabled )
return; // Already disabled
SetBodygroup( JEEP_RADAR_BODYGROUP, 0 );
DestroyRadarPanel();
}
//-----------------------------------------------------------------------------
// Purpose: Allow the Jalopy radar to detect Hunters and Striders
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputEnableRadarDetectEnemies( inputdata_t &data )
{
m_bRadarDetectsEnemies = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputAddBusterToCargo( inputdata_t &data )
{
if ( m_hCargoProp != NULL)
{
ReleasePropFromCargoHold();
m_hCargoProp = NULL;
}
CBaseEntity *pNewBomb = CreateEntityByName( "weapon_striderbuster" );
if ( pNewBomb )
{
DispatchSpawn( pNewBomb );
pNewBomb->Teleport( &m_hCargoTrigger->GetAbsOrigin(), NULL, NULL );
m_hCargoTrigger->AddCargo( pNewBomb );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPropJeepEpisodic::PassengerInTransition( void )
{
// FIXME: Big hack - we need a way to bridge this data better
// TODO: Get a list of passengers we can traverse instead
CNPC_Alyx *pAlyx = CNPC_Alyx::GetAlyx();
if ( pAlyx )
{
if ( pAlyx->GetPassengerState() == PASSENGER_STATE_ENTERING ||
pAlyx->GetPassengerState() == PASSENGER_STATE_EXITING )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Override velocity if our passenger is transitioning or we're upside-down
//-----------------------------------------------------------------------------
Vector CPropJeepEpisodic::PhysGunLaunchVelocity( const Vector &forward, float flMass )
{
// Disallow
if ( PassengerInTransition() )
return vec3_origin;
Vector vecPuntDir = BaseClass::PhysGunLaunchVelocity( forward, flMass );
vecPuntDir.z = 150.0f;
vecPuntDir *= 600.0f;
return vecPuntDir;
}
//-----------------------------------------------------------------------------
// Purpose: Rolls the vehicle when its trying to upright itself from a punt
//-----------------------------------------------------------------------------
AngularImpulse CPropJeepEpisodic::PhysGunLaunchAngularImpulse( void )
{
if ( IsOverturned() )
return AngularImpulse( 0, 300, 0 );
// Don't spin randomly, always spin reliably
return AngularImpulse( 0, 0, 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Get the upright strength based on what state we're in
//-----------------------------------------------------------------------------
float CPropJeepEpisodic::GetUprightStrength( void )
{
// Lesser if overturned
if ( IsOverturned() )
return 2.0f;
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::CreateCargoTrigger( void )
{
if ( m_hCargoTrigger != NULL )
return;
int nAttachment = LookupAttachment( "cargo" );
if ( nAttachment )
{
Vector vecAttachOrigin;
Vector vecForward, vecRight, vecUp;
GetAttachment( nAttachment, vecAttachOrigin, &vecForward, &vecRight, &vecUp );
// Approx size of the hold
Vector vecMins( -8.0, -6.0, 0 );
Vector vecMaxs( 8.0, 6.0, 4.0 );
// NDebugOverlay::BoxDirection( vecAttachOrigin, vecMins, vecMaxs, vecForward, 255, 0, 0, 64, 4.0f );
// Create a trigger that lives for a small amount of time
m_hCargoTrigger = CVehicleCargoTrigger::Create( vecAttachOrigin, vecMins, vecMaxs, this );
}
}
//-----------------------------------------------------------------------------
// Purpose: If the player uses the jeep while at the back, he gets ammo from the crate instead
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// Fall back and get in the vehicle instead, skip giving ammo
BaseClass::BaseClass::Use( pActivator, pCaller, useType, value );
}
#define MIN_WHEEL_DUST_SPEED 5
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::UpdateWheelDust( void )
{
// See if this wheel should emit dust
const vehicleparams_t *vehicleData = m_pServerVehicle->GetVehicleParams();
const vehicle_operatingparams_t *carState = m_pServerVehicle->GetVehicleOperatingParams();
bool bAllowDust = vehicleData->steering.dustCloud;
// Car must be active
bool bCarOn = m_VehiclePhysics.IsOn();
// Must be moving quickly enough or skidding along the ground
bool bCreateDust = ( bCarOn &&
bAllowDust &&
( m_VehiclePhysics.GetSpeed() >= MIN_WHEEL_DUST_SPEED || carState->skidSpeed > DEFAULT_SKID_THRESHOLD ) );
// Update our wheel dust
Vector vecPos;
for ( int i = 0; i < NUM_WHEEL_EFFECTS; i++ )
{
m_pServerVehicle->GetWheelContactPoint( i, vecPos );
// Make sure the effect is created
if ( m_hWheelDust[i] == NULL )
{
// Create the dust effect in place
m_hWheelDust[i] = (CParticleSystem *) CreateEntityByName( "info_particle_system" );
if ( m_hWheelDust[i] == NULL )
continue;
// Setup our basic parameters
m_hWheelDust[i]->KeyValue( "start_active", "0" );
m_hWheelDust[i]->KeyValue( "effect_name", "WheelDust" );
m_hWheelDust[i]->SetParent( this );
m_hWheelDust[i]->SetLocalOrigin( vec3_origin );
DispatchSpawn( m_hWheelDust[i] );
if ( gpGlobals->curtime > 0.5f )
m_hWheelDust[i]->Activate();
}
// Make sure the effect is created
if ( m_hWheelWater[i] == NULL )
{
// Create the dust effect in place
m_hWheelWater[i] = (CParticleSystem *) CreateEntityByName( "info_particle_system" );
if ( m_hWheelWater[i] == NULL )
continue;
// Setup our basic parameters
m_hWheelWater[i]->KeyValue( "start_active", "0" );
m_hWheelWater[i]->KeyValue( "effect_name", "WheelSplash" );
m_hWheelWater[i]->SetParent( this );
m_hWheelWater[i]->SetLocalOrigin( vec3_origin );
DispatchSpawn( m_hWheelWater[i] );
if ( gpGlobals->curtime > 0.5f )
m_hWheelWater[i]->Activate();
}
// Turn the dust on or off
if ( bCreateDust )
{
// Angle the dust out away from the wheels
Vector vecForward, vecRight, vecUp;
GetVectors( &vecForward, &vecRight, &vecUp );
const vehicle_controlparams_t *vehicleControls = m_pServerVehicle->GetVehicleControlParams();
float flWheelDir = ( i & 1 ) ? 1.0f : -1.0f;
QAngle vecAngles;
vecForward += vecRight * flWheelDir;
vecForward += vecRight * (vehicleControls->steering*0.5f) * flWheelDir;
vecForward += vecUp;
VectorAngles( vecForward, vecAngles );
// NDebugOverlay::Axis( vecPos, vecAngles, 8.0f, true, 0.1f );
if ( m_WaterData.m_bWheelInWater[i] )
{
m_hWheelDust[i]->StopParticleSystem();
// Set us up in the right position
m_hWheelWater[i]->StartParticleSystem();
m_hWheelWater[i]->SetAbsAngles( vecAngles );
m_hWheelWater[i]->SetAbsOrigin( vecPos + Vector( 0, 0, 8 ) );
if ( m_flNextWaterSound < gpGlobals->curtime )
{
m_flNextWaterSound = gpGlobals->curtime + random->RandomFloat( 0.25f, 1.0f );
EmitSound( "Physics.WaterSplash" );
}
}
else
{
m_hWheelWater[i]->StopParticleSystem();
// Set us up in the right position
m_hWheelDust[i]->StartParticleSystem();
m_hWheelDust[i]->SetAbsAngles( vecAngles );
m_hWheelDust[i]->SetAbsOrigin( vecPos + Vector( 0, 0, 8 ) );
}
}
else
{
// Stop emitting
m_hWheelDust[i]->StopParticleSystem();
m_hWheelWater[i]->StopParticleSystem();
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ConVar jalopy_radar_test_ent( "jalopy_radar_test_ent", "none" );
//-----------------------------------------------------------------------------
// Purpose: Search for things that the radar detects, and stick them in the
// UTILVector that gets sent to the client for radar display.
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::UpdateRadar( bool forceUpdate )
{
bool bDetectedDog = false;
if( !m_bRadarEnabled )
return;
if( !forceUpdate && gpGlobals->curtime < m_flNextRadarUpdateTime )
return;
// Count the targets on radar. If any more targets come on the radar, we beep.
int m_iNumOldRadarContacts = m_iNumRadarContacts;
m_flNextRadarUpdateTime = gpGlobals->curtime + RADAR_UPDATE_FREQUENCY;
m_iNumRadarContacts = 0;
CBaseEntity *pEnt = gEntList.FirstEnt();
string_t iszRadarTarget = FindPooledString( "info_radar_target" );
string_t iszStriderName = FindPooledString( "npc_strider" );
string_t iszHunterName = FindPooledString( "npc_hunter" );
string_t iszTestName = FindPooledString( jalopy_radar_test_ent.GetString() );
Vector vecJalopyOrigin = WorldSpaceCenter();
while( pEnt != NULL )
{
int type = RADAR_CONTACT_NONE;
if( pEnt->m_iClassname == iszRadarTarget )
{
CRadarTarget *pTarget = dynamic_cast<CRadarTarget*>(pEnt);
if( pTarget != NULL && !pTarget->IsDisabled() )
{
if( pTarget->m_flRadius < 0 || vecJalopyOrigin.DistToSqr(pTarget->GetAbsOrigin()) <= Square(pTarget->m_flRadius) )
{
// This item has been detected.
type = pTarget->GetType();
if( type == RADAR_CONTACT_DOG )
bDetectedDog = true;// used to prevent Alyx talking about the radar (see below)
if( pTarget->GetMode() == RADAR_MODE_STICKY )
{
// This beacon was just detected. Now change the radius to infinite
// so that it will never go off the radar due to distance.
pTarget->m_flRadius = -1;
}
}
}
}
else if ( m_bRadarDetectsEnemies )
{
if ( pEnt->m_iClassname == iszStriderName )
{
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider*>(pEnt);
if( !pStrider || !pStrider->CarriedByDropship() )
{
// Ignore striders which are carried by dropships.
type = RADAR_CONTACT_LARGE_ENEMY;
}
}
if ( pEnt->m_iClassname == iszHunterName )
{
type = RADAR_CONTACT_ENEMY;
}
}
if( type != RADAR_CONTACT_NONE )
{
Vector vecPos = pEnt->WorldSpaceCenter();
m_vecRadarContactPos.Set( m_iNumRadarContacts, vecPos );
m_iRadarContactType.Set( m_iNumRadarContacts, type );
m_iNumRadarContacts++;
if( m_iNumRadarContacts == RADAR_MAX_CONTACTS )
break;
}
pEnt = gEntList.NextEnt(pEnt);
}
if( m_iNumRadarContacts > m_iNumOldRadarContacts )
{
// Play a bleepy sound
if( !bDetectedDog )
{
EmitSound( "JNK_Radar_Ping_Friendly" );
}
//Notify Alyx so she can talk about the radar contact
CNPC_Alyx *pAlyx = CNPC_Alyx::GetAlyx();
if( !bDetectedDog && pAlyx != NULL && pAlyx->GetVehicle() )
{
pAlyx->SpeakIfAllowed( TLK_PASSENGER_NEW_RADAR_CONTACT );
}
}
if( bDetectedDog )
{
// Update the radar much more frequently when dog is around.
m_flNextRadarUpdateTime = gpGlobals->curtime + RADAR_UPDATE_FREQUENCY_FAST;
}
//Msg("Server detected %d objects\n", m_iNumRadarContacts );
CBasePlayer *pPlayer = AI_GetSinglePlayer();
CSingleUserRecipientFilter filter(pPlayer);
UserMessageBegin( filter, "UpdateJalopyRadar" );
WRITE_BYTE( 0 ); // end marker
MessageEnd(); // send message
}
ConVar jalopy_cargo_anim_time( "jalopy_cargo_anim_time", "1.0" );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::UpdateCargoEntry( void )
{
// Don't bother if we have no prop to move
if ( m_hCargoProp == NULL )
return;
// If we're past our animation point, then we're already done
if ( m_flCargoStartTime + jalopy_cargo_anim_time.GetFloat() < gpGlobals->curtime )
{
// Close the hold immediately if we're finished
if ( m_bAddingCargo )
{
m_flAmmoCrateCloseTime = gpGlobals->curtime;
m_bAddingCargo = false;
}
return;
}
// Get our target point
int nAttachment = LookupAttachment( "cargo" );
Vector vecTarget, vecOut;
QAngle vecAngles;
GetAttachmentLocal( nAttachment, vecTarget, vecAngles );
// Find where we are in the blend and bias it for a fast entry and slow ease-out
float flPerc = (jalopy_cargo_anim_time.GetFloat()) ? (( gpGlobals->curtime - m_flCargoStartTime ) / jalopy_cargo_anim_time.GetFloat()) : 1.0f;
flPerc = Bias( flPerc, 0.75f );
VectorLerp( m_hCargoProp->GetLocalOrigin(), vecTarget, flPerc, vecOut );
// Get our target orientation
CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>(m_hCargoProp.Get());
if ( pProp == NULL )
return;
// Slerp our quaternions to find where we are this frame
Quaternion qtTarget;
QAngle qa( 0, 90, 0 );
qa += pProp->PreferredCarryAngles();
AngleQuaternion( qa, qtTarget ); // FIXME: Find the real offset to make this sit properly
Quaternion qtCurrent;
AngleQuaternion( pProp->GetLocalAngles(), qtCurrent );
Quaternion qtOut;
QuaternionSlerp( qtCurrent, qtTarget, flPerc, qtOut );
// Put it back to angles
QuaternionAngles( qtOut, vecAngles );
// Finally, take these new position
m_hCargoProp->SetLocalOrigin( vecOut );
m_hCargoProp->SetLocalAngles( vecAngles );
// Push the closing out into the future to make sure we don't try and close at the same time
m_flAmmoCrateCloseTime += gpGlobals->frametime;
}
#define VEHICLE_AVOID_BROADCAST_RATE 0.5f
//-----------------------------------------------------------------------------
// Purpose: This function isn't really what we want
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::CreateAvoidanceZone( void )
{
if ( m_flNextAvoidBroadcastTime > gpGlobals->curtime )
return;
// Only do this when we're stopped
if ( m_VehiclePhysics.GetSpeed() > 5.0f )
return;
float flHullRadius = CollisionProp()->BoundingRadius2D();
Vector vecPos;
CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.33f, 0.25f ), &vecPos );
CSoundEnt::InsertSound( SOUND_MOVE_AWAY, vecPos, (flHullRadius*0.4f), VEHICLE_AVOID_BROADCAST_RATE, this );
// NDebugOverlay::Sphere( vecPos, vec3_angle, flHullRadius*0.4f, 255, 0, 0, 0, true, VEHICLE_AVOID_BROADCAST_RATE );
CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.66f, 0.25f ), &vecPos );
CSoundEnt::InsertSound( SOUND_MOVE_AWAY, vecPos, (flHullRadius*0.4f), VEHICLE_AVOID_BROADCAST_RATE, this );
// NDebugOverlay::Sphere( vecPos, vec3_angle, flHullRadius*0.4f, 255, 0, 0, 0, true, VEHICLE_AVOID_BROADCAST_RATE );
// Don't broadcast again until these are done
m_flNextAvoidBroadcastTime = gpGlobals->curtime + VEHICLE_AVOID_BROADCAST_RATE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::Think( void )
{
BaseClass::Think();
// If our passenger is transitioning, then don't let the player drive off
CNPC_Alyx *pAlyx = CNPC_Alyx::GetAlyx();
if ( pAlyx && pAlyx->GetPassengerState() == PASSENGER_STATE_EXITING )
{
m_throttleDisableTime = gpGlobals->curtime + 0.25f;
}
// Update our cargo entering our hold
UpdateCargoEntry();
// See if the wheel dust should be on or off
UpdateWheelDust();
// Update the radar, of course.
UpdateRadar();
if ( m_hCargoTrigger && !m_hCargoProp && !m_hCargoTrigger->m_pfnTouch )
{
m_hCargoTrigger->Enable();
}
CreateAvoidanceZone();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity -
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::AddPropToCargoHold( CPhysicsProp *pProp )
{
// The hold must be empty to add something to it
if ( m_hCargoProp != NULL )
{
Assert( 0 );
return;
}
// Take the prop as our cargo
m_hCargoProp = pProp;
m_flCargoStartTime = gpGlobals->curtime;
m_bAddingCargo = true;
}
//-----------------------------------------------------------------------------
// Purpose: Drops the cargo from the hold
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::ReleasePropFromCargoHold( void )
{
// Pull the object free!
m_hCargoProp->SetParent( NULL );
m_hCargoProp->CreateVPhysics();
if ( m_hCargoTrigger )
{
m_hCargoTrigger->Enable();
m_hCargoTrigger->IgnoreTouches( m_hCargoProp );
}
}
//-----------------------------------------------------------------------------
// Purpose: If the player is trying to pull the cargo out of the hold using the physcannon, let him
// Output : Returns the cargo to pick up, if all the conditions are met
//-----------------------------------------------------------------------------
CBaseEntity *CPropJeepEpisodic::OnFailedPhysGunPickup( Vector vPhysgunPos )
{
// Make sure we're available to open
if ( m_hCargoProp != NULL )
{
// Player's forward direction
Vector vecPlayerForward;
CBasePlayer *pPlayer = AI_GetSinglePlayer();
if ( pPlayer == NULL )
return NULL;
pPlayer->EyeVectors( &vecPlayerForward );
// Origin and facing of the cargo hold
Vector vecCargoOrigin;
Vector vecCargoForward;
GetAttachment( "cargo", vecCargoOrigin, &vecCargoForward );
// Direction from the cargo to the player's position
Vector vecPickupDir = ( vecCargoOrigin - vPhysgunPos );
float flDist = VectorNormalize( vecPickupDir );
// We need to make sure the player's position is within a cone near the opening and that they're also facing the right way
bool bInCargoRange = ( (flDist < (15.0f * 12.0f)) && DotProduct( vecCargoForward, vecPickupDir ) < 0.1f );
bool bFacingCargo = DotProduct( vecPlayerForward, vecPickupDir ) > 0.975f;
// If we're roughly pulling at the item, pick that up
if ( bInCargoRange && bFacingCargo )
{
// Save this for later
CBaseEntity *pCargo = m_hCargoProp;
// Drop the cargo
ReleasePropFromCargoHold();
// Forget the item but pass it back as the object to pick up
m_hCargoProp = NULL;
return pCargo;
}
}
return BaseClass::OnFailedPhysGunPickup( vPhysgunPos );
}
// adds a collision solver for any small props that are stuck under the vehicle
static void SolveBlockingProps( CPropJeepEpisodic *pVehicleEntity, IPhysicsObject *pVehiclePhysics )
{
CUtlVector<CBaseEntity *> solveList;
float vehicleMass = pVehiclePhysics->GetMass();
Vector vehicleUp;
pVehicleEntity->GetVectors( NULL, NULL, &vehicleUp );
IPhysicsFrictionSnapshot *pSnapshot = pVehiclePhysics->CreateFrictionSnapshot();
while ( pSnapshot->IsValid() )
{
IPhysicsObject *pOther = pSnapshot->GetObject(1);
float otherMass = pOther->GetMass();
CBaseEntity *pOtherEntity = static_cast<CBaseEntity *>(pOther->GetGameData());
Assert(pOtherEntity);
if ( pOtherEntity && pOtherEntity->GetMoveType() == MOVETYPE_VPHYSICS && pOther->IsMoveable() && (otherMass*4.0f) < vehicleMass )
{
Vector normal;
pSnapshot->GetSurfaceNormal(normal);
// this points down in the car's reference frame, then it's probably trapped under the car
if ( DotProduct(normal, vehicleUp) < -0.9f )
{
Vector point, pointLocal;
pSnapshot->GetContactPoint(point);
VectorITransform( point, pVehicleEntity->EntityToWorldTransform(), pointLocal );
Vector bottomPoint = physcollision->CollideGetExtent( pVehiclePhysics->GetCollide(), vec3_origin, vec3_angle, Vector(0,0,-1) );
// make sure it's under the bottom of the car
float bottomPlane = DotProduct(bottomPoint,vehicleUp)+8; // 8 inches above bottom
if ( DotProduct( pointLocal, vehicleUp ) <= bottomPlane )
{
//Msg("Solved %s\n", pOtherEntity->GetClassname());
if ( solveList.Find(pOtherEntity) < 0 )
{
solveList.AddToTail(pOtherEntity);
}
}
}
}
pSnapshot->NextFrictionData();
}
pVehiclePhysics->DestroyFrictionSnapshot( pSnapshot );
if ( solveList.Count() )
{
for ( int i = 0; i < solveList.Count(); i++ )
{
EntityPhysics_CreateSolver( pVehicleEntity, solveList[i], true, 4.0f );
}
pVehiclePhysics->RecheckContactPoints();
}
}
static void SimpleCollisionResponse( Vector velocityIn, const Vector &normal, float coefficientOfRestitution, Vector *pVelocityOut )
{
Vector Vn = DotProduct(velocityIn,normal) * normal;
Vector Vt = velocityIn - Vn;
*pVelocityOut = Vt - coefficientOfRestitution * Vn;
}
static void KillBlockingEnemyNPCs( CBasePlayer *pPlayer, CBaseEntity *pVehicleEntity, IPhysicsObject *pVehiclePhysics )
{
Vector velocity;
pVehiclePhysics->GetVelocity( &velocity, NULL );
float vehicleMass = pVehiclePhysics->GetMass();
// loop through the contacts and look for enemy NPCs that we're pushing on
CUtlVector<CAI_BaseNPC *> npcList;
CUtlVector<Vector> forceList;
CUtlVector<Vector> contactList;
IPhysicsFrictionSnapshot *pSnapshot = pVehiclePhysics->CreateFrictionSnapshot();
while ( pSnapshot->IsValid() )
{
IPhysicsObject *pOther = pSnapshot->GetObject(1);
float otherMass = pOther->GetMass();
CBaseEntity *pOtherEntity = static_cast<CBaseEntity *>(pOther->GetGameData());
CAI_BaseNPC *pNPC = pOtherEntity ? pOtherEntity->MyNPCPointer() : NULL;
// Is this an enemy NPC with a small enough mass?
if ( pNPC && pPlayer->IRelationType(pNPC) != D_LI && ((otherMass*2.0f) < vehicleMass) )
{
// accumulate the stress force for this NPC in the lsit
float force = pSnapshot->GetNormalForce();
Vector normal;
pSnapshot->GetSurfaceNormal(normal);
normal *= force;
int index = npcList.Find(pNPC);
if ( index < 0 )
{
vphysicsupdateai_t *pUpdate = NULL;
if ( pNPC->VPhysicsGetObject() && pNPC->VPhysicsGetObject()->GetShadowController() && pNPC->GetMoveType() == MOVETYPE_STEP )
{
if ( pNPC->HasDataObjectType(VPHYSICSUPDATEAI) )
{
pUpdate = static_cast<vphysicsupdateai_t *>(pNPC->GetDataObject(VPHYSICSUPDATEAI));
// kill this guy if I've been pushing him for more than half a second and I'm
// still pushing in his direction
if ( (gpGlobals->curtime - pUpdate->startUpdateTime) > 0.5f && DotProduct(velocity,normal) > 0)
{
index = npcList.AddToTail(pNPC);
forceList.AddToTail( normal );
Vector pos;
pSnapshot->GetContactPoint(pos);
contactList.AddToTail(pos);
}
}
else
{
pUpdate = static_cast<vphysicsupdateai_t *>(pNPC->CreateDataObject( VPHYSICSUPDATEAI ));
pUpdate->startUpdateTime = gpGlobals->curtime;
}
// update based on vphysics for the next second
// this allows the car to push the NPC
pUpdate->stopUpdateTime = gpGlobals->curtime + 1.0f;
float maxAngular;
pNPC->VPhysicsGetObject()->GetShadowController()->GetMaxSpeed( &pUpdate->savedShadowControllerMaxSpeed, &maxAngular );
pNPC->VPhysicsGetObject()->GetShadowController()->MaxSpeed( 1.0f, maxAngular );
}
}
else
{
forceList[index] += normal;
}
}
pSnapshot->NextFrictionData();
}
pVehiclePhysics->DestroyFrictionSnapshot( pSnapshot );
// now iterate the list and check each cumulative force against the threshold
if ( npcList.Count() )
{
for ( int i = npcList.Count(); --i >= 0; )
{
Vector damageForce;
npcList[i]->VPhysicsGetObject()->GetVelocity( &damageForce, NULL );
Vector vel;
pVehiclePhysics->GetVelocityAtPoint( contactList[i], &vel );
damageForce -= vel;
Vector normal = forceList[i];
VectorNormalize(normal);
SimpleCollisionResponse( damageForce, normal, 1.0, &damageForce );
damageForce += (normal * 300.0f);
damageForce *= npcList[i]->VPhysicsGetObject()->GetMass();
float len = damageForce.Length();
damageForce.z += len*phys_upimpactforcescale.GetFloat();
Vector vehicleForce = -damageForce;
CTakeDamageInfo dmgInfo( pVehicleEntity, pVehicleEntity, damageForce, contactList[i], 200.0f, DMG_CRUSH|DMG_VEHICLE );
npcList[i]->TakeDamage( dmgInfo );
pVehiclePhysics->ApplyForceOffset( vehicleForce, contactList[i] );
PhysCollisionSound( pVehicleEntity, npcList[i]->VPhysicsGetObject(), CHAN_BODY, pVehiclePhysics->GetMaterialIndex(), npcList[i]->VPhysicsGetObject()->GetMaterialIndex(), gpGlobals->frametime, 200.0f );
}
}
}
void CPropJeepEpisodic::DriveVehicle( float flFrameTime, CUserCmd *ucmd, int iButtonsDown, int iButtonsReleased )
{
/* The car headlight hurts perf, there's no timer to turn it off automatically,
and we haven't built any gameplay around it.
Furthermore, I don't think I've ever seen a playtester turn it on.
if ( ucmd->impulse == 100 )
{
if (HeadlightIsOn())
{
HeadlightTurnOff();
}
else
{
HeadlightTurnOn();
}
}*/
if ( ucmd->forwardmove != 0.0f )
{
//Msg("Push V: %.2f, %.2f, %.2f\n", ucmd->forwardmove, carState->engineRPM, carState->speed );
CBasePlayer *pPlayer = ToBasePlayer(GetDriver());
if ( pPlayer && VPhysicsGetObject() )
{
KillBlockingEnemyNPCs( pPlayer, this, VPhysicsGetObject() );
SolveBlockingProps( this, VPhysicsGetObject() );
}
}
BaseClass::DriveVehicle(flFrameTime, ucmd, iButtonsDown, iButtonsReleased);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::CreateHazardLights( void )
{
static const char *s_szAttach[NUM_HAZARD_LIGHTS] =
{
"rearlight_r",
"rearlight_l",
"headlight_r",
"headlight_l",
};
// Turn on the hazards!
for ( int i = 0; i < NUM_HAZARD_LIGHTS; i++ )
{
if ( m_hHazardLights[i] == NULL )
{
m_hHazardLights[i] = CSprite::SpriteCreate( s_szHazardSprite, GetLocalOrigin(), false );
if ( m_hHazardLights[i] )
{
m_hHazardLights[i]->SetTransparency( kRenderWorldGlow, 255, 220, 40, 255, kRenderFxNoDissipation );
m_hHazardLights[i]->SetAttachment( this, LookupAttachment( s_szAttach[i] ) );
m_hHazardLights[i]->SetGlowProxySize( 2.0f );
m_hHazardLights[i]->TurnOff();
if ( i < 2 )
{
// Rear lights are red
m_hHazardLights[i]->SetColor( 255, 0, 0 );
m_hHazardLights[i]->SetScale( 1.0f );
}
else
{
// Font lights are white
m_hHazardLights[i]->SetScale( 1.0f );
}
}
}
}
// We start off
m_bBlink = false;
// Setup our blink
SetContextThink( &CPropJeepEpisodic::HazardBlinkThink, gpGlobals->curtime + 0.1f, "HazardBlink" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::DestroyHazardLights( void )
{
for ( int i = 0; i < NUM_HAZARD_LIGHTS; i++ )
{
if ( m_hHazardLights[i] != NULL )
{
UTIL_Remove( m_hHazardLights[i] );
}
}
SetContextThink( NULL, gpGlobals->curtime, "HazardBlink" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nRole -
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::ExitVehicle( int nRole )
{
BaseClass::ExitVehicle( nRole );
CreateHazardLights();
}
void CPropJeepEpisodic::SetBusterHopperVisibility(bool visible)
{
// if we're there already do nothing
if (visible == m_bBusterHopperVisible)
return;
SetBodygroup( JEEP_HOPPER_BODYGROUP, visible ? 1 : 0);
m_bBusterHopperVisible = visible;
}
void CPropJeepEpisodic::InputSetCargoVisibility( inputdata_t &data )
{
bool visible = data.value.Bool();
SetBusterHopperVisibility( visible );
}
//-----------------------------------------------------------------------------
// THIS CODE LIFTED RIGHT OUT OF TF2, to defer the pain of making vgui-on-an-entity
// code available to all CBaseAnimating.
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::SpawnRadarPanel()
{
// FIXME: Deal with dynamically resizing control panels?
// If we're attached to an entity, spawn control panels on it instead of use
CBaseAnimating *pEntityToSpawnOn = this;
char *pOrgLL = "controlpanel0_ll";
char *pOrgUR = "controlpanel0_ur";
Assert( pEntityToSpawnOn );
// Lookup the attachment point...
int nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(pOrgLL);
if (nLLAttachmentIndex <= 0)
{
return;
}
int nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(pOrgUR);
if (nURAttachmentIndex <= 0)
{
return;
}
const char *pScreenName = "jalopy_radar_panel";
const char *pScreenClassname = "vgui_screen";
// Compute the screen size from the attachment points...
matrix3x4_t panelToWorld;
pEntityToSpawnOn->GetAttachment( nLLAttachmentIndex, panelToWorld );
matrix3x4_t worldToPanel;
MatrixInvert( panelToWorld, worldToPanel );
// Now get the lower right position + transform into panel space
Vector lr, lrlocal;
pEntityToSpawnOn->GetAttachment( nURAttachmentIndex, panelToWorld );
MatrixGetColumn( panelToWorld, 3, lr );
VectorTransform( lr, worldToPanel, lrlocal );
float flWidth = lrlocal.x;
float flHeight = lrlocal.y;
CVGuiScreen *pScreen = CreateVGuiScreen( pScreenClassname, pScreenName, pEntityToSpawnOn, this, nLLAttachmentIndex );
pScreen->SetActualSize( flWidth, flHeight );
pScreen->SetActive( true );
pScreen->SetOverlayMaterial( RADAR_PANEL_WRITEZ );
pScreen->SetTransparency( true );
m_hRadarScreen.Set( pScreen );
m_bRadarEnabled = true;
m_iNumRadarContacts = 0;
m_flNextRadarUpdateTime = gpGlobals->curtime - 1.0f;
}
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::DestroyRadarPanel()
{
Assert( m_hRadarScreen != NULL );
m_hRadarScreen->SUB_Remove();
m_bRadarEnabled = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::HazardBlinkThink( void )
{
if ( m_bBlink )
{
for ( int i = 0; i < NUM_HAZARD_LIGHTS; i++ )
{
if ( m_hHazardLights[i] )
{
m_hHazardLights[i]->SetBrightness( 0, 0.1f );
}
}
SetContextThink( &CPropJeepEpisodic::HazardBlinkThink, gpGlobals->curtime + 0.25f, "HazardBlink" );
}
else
{
for ( int i = 0; i < NUM_HAZARD_LIGHTS; i++ )
{
if ( m_hHazardLights[i] )
{
m_hHazardLights[i]->SetBrightness( 255, 0.1f );
m_hHazardLights[i]->TurnOn();
}
}
SetContextThink( &CPropJeepEpisodic::HazardBlinkThink, gpGlobals->curtime + 0.5f, "HazardBlink" );
}
m_bBlink = !m_bBlink;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::HandleWater( void )
{
// Only check the wheels and engine in water if we have a driver (player).
if ( !GetDriver() )
return;
// Update our internal state
CheckWater();
// Save of data from last think.
for ( int iWheel = 0; iWheel < JEEP_WHEEL_COUNT; ++iWheel )
{
m_WaterData.m_bWheelWasInWater[iWheel] = m_WaterData.m_bWheelInWater[iWheel];
}
}
//-----------------------------------------------------------------------------
// Purpose: Report our lock state
//-----------------------------------------------------------------------------
int CPropJeepEpisodic::DrawDebugTextOverlays( void )
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if ( m_debugOverlays & OVERLAY_TEXT_BIT )
{
EntityText( text_offset, CFmtStr("Entrance: %s", m_bEntranceLocked ? "Locked" : "Unlocked" ), 0 );
text_offset++;
EntityText( text_offset, CFmtStr("Exit: %s", m_bExitLocked ? "Locked" : "Unlocked" ), 0 );
text_offset++;
}
return text_offset;
}
#define TRANSITION_SEARCH_RADIUS (100*12)
//-----------------------------------------------------------------------------
// Purpose: Teleport the car to a destination that will cause it to transition if it's not going to otherwise
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputOutsideTransition( inputdata_t &inputdata )
{
// Teleport into the new map
CBasePlayer *pPlayer = AI_GetSinglePlayer();
Vector vecTeleportPos;
QAngle vecTeleportAngles;
// Get our bounds
Vector vecSurroundMins, vecSurroundMaxs;
CollisionProp()->WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs );
vecSurroundMins -= WorldSpaceCenter();
vecSurroundMaxs -= WorldSpaceCenter();
Vector vecBestPos;
QAngle vecBestAngles;
CInfoTargetVehicleTransition *pEntity = NULL;
bool bSucceeded = false;
// Find all entities of the correct name and try and sit where they're at
while ( ( pEntity = (CInfoTargetVehicleTransition *) gEntList.FindEntityByClassname( pEntity, "info_target_vehicle_transition" ) ) != NULL )
{
// Must be enabled
if ( pEntity->IsDisabled() )
continue;
// Must be within range
if ( ( pEntity->GetAbsOrigin() - pPlayer->GetAbsOrigin() ).LengthSqr() > Square( TRANSITION_SEARCH_RADIUS ) )
continue;
vecTeleportPos = pEntity->GetAbsOrigin();
vecTeleportAngles = pEntity->GetAbsAngles() + QAngle( 0, -90, 0 ); // Vehicle is always off by 90 degrees
// Rotate to face the destination angles
Vector vecMins;
Vector vecMaxs;
VectorRotate( vecSurroundMins, vecTeleportAngles, vecMins );
VectorRotate( vecSurroundMaxs, vecTeleportAngles, vecMaxs );
if ( vecMaxs.x < vecMins.x )
V_swap( vecMins.x, vecMaxs.x );
if ( vecMaxs.y < vecMins.y )
V_swap( vecMins.y, vecMaxs.y );
if ( vecMaxs.z < vecMins.z )
V_swap( vecMins.z, vecMaxs.z );
// Move up
vecTeleportPos.z += ( vecMaxs.z - vecMins.z );
trace_t tr;
UTIL_TraceHull( vecTeleportPos, vecTeleportPos - Vector( 0, 0, 128 ), vecMins, vecMaxs, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if ( tr.startsolid == false && tr.allsolid == false && tr.fraction < 1.0f )
{
// Store this off
vecBestPos = tr.endpos;
vecBestAngles = vecTeleportAngles;
bSucceeded = true;
// If this point isn't visible, then stop looking and use it
if ( pPlayer->FInViewCone( tr.endpos ) == false )
break;
}
}
// See if we're finished
if ( bSucceeded )
{
Teleport( &vecTeleportPos, &vecTeleportAngles, NULL );
return;
}
// TODO: We found no valid teleport points, so try to find them dynamically
Warning("No valid vehicle teleport points!\n");
}
//-----------------------------------------------------------------------------
// Purpose: Stop players punting the car around.
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputDisablePhysGun( inputdata_t &data )
{
AddEFlags( EFL_NO_PHYSCANNON_INTERACTION );
}
//-----------------------------------------------------------------------------
// Purpose: Return to normal
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputEnablePhysGun( inputdata_t &data )
{
RemoveEFlags( EFL_NO_PHYSCANNON_INTERACTION );
}
//-----------------------------------------------------------------------------
// Create and parent two radial node link controllers.
//-----------------------------------------------------------------------------
void CPropJeepEpisodic::InputCreateLinkController( inputdata_t &data )
{
Vector vecFront, vecRear;
Vector vecWFL, vecWFR; // Front wheels
Vector vecWRL, vecWRR; // Back wheels
GetAttachment( "wheel_fr", vecWFR );
GetAttachment( "wheel_fl", vecWFL );
GetAttachment( "wheel_rr", vecWRR );
GetAttachment( "wheel_rl", vecWRL );
vecFront = (vecWFL + vecWFR) * 0.5f;
vecRear = (vecWRL + vecWRR) * 0.5f;
float flRadius = ( (vecFront - vecRear).Length() ) * 0.6f;
CAI_RadialLinkController *pLinkController = (CAI_RadialLinkController *)CreateEntityByName( "info_radial_link_controller" );
if( pLinkController != NULL && m_hLinkControllerFront.Get() == NULL )
{
pLinkController->m_flRadius = flRadius;
pLinkController->Spawn();
pLinkController->SetAbsOrigin( vecFront );
pLinkController->SetOwnerEntity( this );
pLinkController->SetParent( this );
pLinkController->Activate();
m_hLinkControllerFront.Set( pLinkController );
//NDebugOverlay::Circle( vecFront, Vector(0,1,0), Vector(1,0,0), flRadius, 255, 255, 255, 128, false, 100 );
}
pLinkController = (CAI_RadialLinkController *)CreateEntityByName( "info_radial_link_controller" );
if( pLinkController != NULL && m_hLinkControllerRear.Get() == NULL )
{
pLinkController->m_flRadius = flRadius;
pLinkController->Spawn();
pLinkController->SetAbsOrigin( vecRear );
pLinkController->SetOwnerEntity( this );
pLinkController->SetParent( this );
pLinkController->Activate();
m_hLinkControllerRear.Set( pLinkController );
//NDebugOverlay::Circle( vecRear, Vector(0,1,0), Vector(1,0,0), flRadius, 255, 255, 255, 128, false, 100 );
}
}
void CPropJeepEpisodic::InputDestroyLinkController( inputdata_t &data )
{
if( m_hLinkControllerFront.Get() != NULL )
{
CAI_RadialLinkController *pLinkController = dynamic_cast<CAI_RadialLinkController*>(m_hLinkControllerFront.Get());
if( pLinkController != NULL )
{
pLinkController->ModifyNodeLinks(false);
UTIL_Remove( pLinkController );
m_hLinkControllerFront.Set(NULL);
}
}
if( m_hLinkControllerRear.Get() != NULL )
{
CAI_RadialLinkController *pLinkController = dynamic_cast<CAI_RadialLinkController*>(m_hLinkControllerRear.Get());
if( pLinkController != NULL )
{
pLinkController->ModifyNodeLinks(false);
UTIL_Remove( pLinkController );
m_hLinkControllerRear.Set(NULL);
}
}
}
bool CPropJeepEpisodic::AllowBlockedExit( CBaseCombatCharacter *pPassenger, int nRole )
{
// Wait until we've settled down before we resort to blocked exits.
// This keeps us from doing blocked exits in mid-jump, which can cause mayhem like
// sticking the player through player clips or into geometry.
return GetSmoothedVelocity().IsLengthLessThan( jalopy_blocked_exit_max_speed.GetFloat() );
}
Reference in New Issue View Git Blame Copy Permalink