//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Player for HL2. // //=============================================================================// #include "cbase.h" #include "hl2_player.h" #include "globalstate.h" #include "game.h" #include "gamerules.h" #include "trains.h" #include "basehlcombatweapon_shared.h" #include "vcollide_parse.h" #include "in_buttons.h" #include "ai_interactions.h" #include "ai_squad.h" #include "igamemovement.h" #include "ai_hull.h" #include "hl2_shareddefs.h" #include "info_camera_link.h" #include "point_camera.h" #include "engine/IEngineSound.h" #include "ndebugoverlay.h" #include "iservervehicle.h" #include "IVehicle.h" #include "globals.h" #include "collisionutils.h" #include "coordsize.h" #include "effect_color_tables.h" #include "vphysics/player_controller.h" #include "player_pickup.h" #include "weapon_physcannon.h" #include "script_intro.h" #include "effect_dispatch_data.h" #include "te_effect_dispatch.h" #include "ai_basenpc.h" #include "AI_Criteria.h" #include "npc_barnacle.h" #include "entitylist.h" #include "env_zoom.h" #include "hl2_gamerules.h" #include "prop_combine_ball.h" #include "datacache/imdlcache.h" #include "eventqueue.h" #include "gamestats.h" #include "filters.h" #include "tier0/icommandline.h" #ifdef HL2_EPISODIC #include "npc_alyx_episodic.h" #endif #ifdef PORTAL #include "portal_player.h" #endif // PORTAL // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" extern ConVar weapon_showproficiency; extern ConVar autoaim_max_dist; // Do not touch with without seeing me, please! (sjb) // For consistency's sake, enemy gunfire is traced against a scaled down // version of the player's hull, not the hitboxes for the player's model // because the player isn't aware of his model, and can't do anything about // preventing headshots and other such things. Also, game difficulty will // not change if the model changes. This is the value by which to scale // the X/Y of the player's hull to get the volume to trace bullets against. #define PLAYER_HULL_REDUCTION 0.70 // This switches between the single primary weapon, and multiple weapons with buckets approach (jdw) #define HL2_SINGLE_PRIMARY_WEAPON_MODE 0 #define TIME_IGNORE_FALL_DAMAGE 10.0 extern int gEvilImpulse101; ConVar sv_autojump( "sv_autojump", "0" ); ConVar hl2_walkspeed( "hl2_walkspeed", "150" ); ConVar hl2_normspeed( "hl2_normspeed", "190" ); ConVar hl2_sprintspeed( "hl2_sprintspeed", "320" ); ConVar hl2_darkness_flashlight_factor ( "hl2_darkness_flashlight_factor", "1" ); #ifdef HL2MP #define HL2_WALK_SPEED 150 #define HL2_NORM_SPEED 190 #define HL2_SPRINT_SPEED 320 #else #define HL2_WALK_SPEED hl2_walkspeed.GetFloat() #define HL2_NORM_SPEED hl2_normspeed.GetFloat() #define HL2_SPRINT_SPEED hl2_sprintspeed.GetFloat() #endif ConVar player_showpredictedposition( "player_showpredictedposition", "0" ); ConVar player_showpredictedposition_timestep( "player_showpredictedposition_timestep", "1.0" ); ConVar player_squad_transient_commands( "player_squad_transient_commands", "1", FCVAR_REPLICATED ); ConVar player_squad_double_tap_time( "player_squad_double_tap_time", "0.25" ); ConVar sv_infinite_aux_power( "sv_infinite_aux_power", "0", FCVAR_CHEAT ); ConVar autoaim_unlock_target( "autoaim_unlock_target", "0.8666" ); ConVar sv_stickysprint("sv_stickysprint", "0", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX); #define FLASH_DRAIN_TIME 1.1111 // 100 units / 90 secs #define FLASH_CHARGE_TIME 50.0f // 100 units / 2 secs //============================================================================================== // CAPPED PLAYER PHYSICS DAMAGE TABLE //============================================================================================== static impactentry_t cappedPlayerLinearTable[] = { { 150*150, 5 }, { 250*250, 10 }, { 450*450, 20 }, { 550*550, 30 }, //{ 700*700, 100 }, //{ 1000*1000, 500 }, }; static impactentry_t cappedPlayerAngularTable[] = { { 100*100, 10 }, { 150*150, 20 }, { 200*200, 30 }, //{ 300*300, 500 }, }; static impactdamagetable_t gCappedPlayerImpactDamageTable = { cappedPlayerLinearTable, cappedPlayerAngularTable, ARRAYSIZE(cappedPlayerLinearTable), ARRAYSIZE(cappedPlayerAngularTable), 24*24.0f, // minimum linear speed 360*360.0f, // minimum angular speed 2.0f, // can't take damage from anything under 2kg 5.0f, // anything less than 5kg is "small" 5.0f, // never take more than 5 pts of damage from anything under 5kg 36*36.0f, // <5kg objects must go faster than 36 in/s to do damage 0.0f, // large mass in kg (no large mass effects) 1.0f, // large mass scale 2.0f, // large mass falling scale 320.0f, // min velocity for player speed to cause damage }; // Flashlight utility bool g_bCacheLegacyFlashlightStatus = true; bool g_bUseLegacyFlashlight; bool Flashlight_UseLegacyVersion( void ) { // If this is the first run through, cache off what the answer should be (cannot change during a session) if ( g_bCacheLegacyFlashlightStatus ) { char modDir[MAX_PATH]; if ( UTIL_GetModDir( modDir, sizeof(modDir) ) == false ) return false; g_bUseLegacyFlashlight = ( !Q_strcmp( modDir, "hl2" ) || !Q_strcmp( modDir, "episodic" ) || !Q_strcmp( modDir, "lostcoast" ) || !Q_strcmp( modDir, "hl1" )); g_bCacheLegacyFlashlightStatus = false; } // Return the results return g_bUseLegacyFlashlight; } //----------------------------------------------------------------------------- // Purpose: Used to relay outputs/inputs from the player to the world and viceversa //----------------------------------------------------------------------------- class CLogicPlayerProxy : public CLogicalEntity { DECLARE_CLASS( CLogicPlayerProxy, CLogicalEntity ); private: DECLARE_DATADESC(); public: COutputEvent m_OnFlashlightOn; COutputEvent m_OnFlashlightOff; COutputEvent m_PlayerHasAmmo; COutputEvent m_PlayerHasNoAmmo; COutputEvent m_PlayerDied; COutputEvent m_PlayerMissedAR2AltFire; // Player fired a combine ball which did not dissolve any enemies. COutputInt m_RequestedPlayerHealth; void InputRequestPlayerHealth( inputdata_t &inputdata ); void InputSetFlashlightSlowDrain( inputdata_t &inputdata ); void InputSetFlashlightNormalDrain( inputdata_t &inputdata ); void InputSetPlayerHealth( inputdata_t &inputdata ); void InputRequestAmmoState( inputdata_t &inputdata ); void InputLowerWeapon( inputdata_t &inputdata ); void InputEnableCappedPhysicsDamage( inputdata_t &inputdata ); void InputDisableCappedPhysicsDamage( inputdata_t &inputdata ); void InputSetLocatorTargetEntity( inputdata_t &inputdata ); #ifdef PORTAL void InputSuppressCrosshair( inputdata_t &inputdata ); #endif // PORTAL2 void Activate ( void ); bool PassesDamageFilter( const CTakeDamageInfo &info ); EHANDLE m_hPlayer; }; //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ void CC_ToggleZoom( void ) { CBasePlayer* pPlayer = UTIL_GetCommandClient(); if( pPlayer ) { CHL2_Player *pHL2Player = dynamic_cast(pPlayer); if( pHL2Player && pHL2Player->IsSuitEquipped() ) { pHL2Player->ToggleZoom(); } } } static ConCommand toggle_zoom("toggle_zoom", CC_ToggleZoom, "Toggles zoom display" ); // ConVar cl_forwardspeed( "cl_forwardspeed", "400", FCVAR_CHEAT ); // Links us to the client's version ConVar xc_crouch_range( "xc_crouch_range", "0.85", FCVAR_ARCHIVE, "Percentarge [1..0] of joystick range to allow ducking within" ); // Only 1/2 of the range is used ConVar xc_use_crouch_limiter( "xc_use_crouch_limiter", "0", FCVAR_ARCHIVE, "Use the crouch limiting logic on the controller" ); //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ void CC_ToggleDuck( void ) { CBasePlayer* pPlayer = UTIL_GetCommandClient(); if ( pPlayer == NULL ) return; // Cannot be frozen if ( pPlayer->GetFlags() & FL_FROZEN ) return; static bool bChecked = false; static ConVar *pCVcl_forwardspeed = NULL; if ( !bChecked ) { bChecked = true; pCVcl_forwardspeed = ( ConVar * )cvar->FindVar( "cl_forwardspeed" ); } // If we're not ducked, do extra checking if ( xc_use_crouch_limiter.GetBool() ) { if ( pPlayer->GetToggledDuckState() == false ) { float flForwardSpeed = 400.0f; if ( pCVcl_forwardspeed ) { flForwardSpeed = pCVcl_forwardspeed->GetFloat(); } flForwardSpeed = MAX( 1.0f, flForwardSpeed ); // Make sure we're not in the blindspot on the crouch detection float flStickDistPerc = ( pPlayer->GetStickDist() / flForwardSpeed ); // Speed is the magnitude if ( flStickDistPerc > xc_crouch_range.GetFloat() ) return; } } // Toggle the duck pPlayer->ToggleDuck(); } static ConCommand toggle_duck("toggle_duck", CC_ToggleDuck, "Toggles duck" ); #ifndef HL2MP #ifndef PORTAL LINK_ENTITY_TO_CLASS( player, CHL2_Player ); #endif #endif PRECACHE_REGISTER(player); CBaseEntity *FindEntityForward( CBasePlayer *pMe, bool fHull ); BEGIN_SIMPLE_DATADESC( LadderMove_t ) DEFINE_FIELD( m_bForceLadderMove, FIELD_BOOLEAN ), DEFINE_FIELD( m_bForceMount, FIELD_BOOLEAN ), DEFINE_FIELD( m_flStartTime, FIELD_TIME ), DEFINE_FIELD( m_flArrivalTime, FIELD_TIME ), DEFINE_FIELD( m_vecGoalPosition, FIELD_POSITION_VECTOR ), DEFINE_FIELD( m_vecStartPosition, FIELD_POSITION_VECTOR ), DEFINE_FIELD( m_hForceLadder, FIELD_EHANDLE ), DEFINE_FIELD( m_hReservedSpot, FIELD_EHANDLE ), END_DATADESC() // Global Savedata for HL2 player BEGIN_DATADESC( CHL2_Player ) DEFINE_FIELD( m_nControlClass, FIELD_INTEGER ), DEFINE_EMBEDDED( m_HL2Local ), DEFINE_FIELD( m_bSprintEnabled, FIELD_BOOLEAN ), DEFINE_FIELD( m_flTimeAllSuitDevicesOff, FIELD_TIME ), DEFINE_FIELD( m_fIsSprinting, FIELD_BOOLEAN ), DEFINE_FIELD( m_fIsWalking, FIELD_BOOLEAN ), /* // These are initialized every time the player calls Activate() DEFINE_FIELD( m_bIsAutoSprinting, FIELD_BOOLEAN ), DEFINE_FIELD( m_fAutoSprintMinTime, FIELD_TIME ), */ // Field is used within a single tick, no need to save restore // DEFINE_FIELD( m_bPlayUseDenySound, FIELD_BOOLEAN ), // m_pPlayerAISquad reacquired on load DEFINE_AUTO_ARRAY( m_vecMissPositions, FIELD_POSITION_VECTOR ), DEFINE_FIELD( m_nNumMissPositions, FIELD_INTEGER ), // m_pPlayerAISquad DEFINE_EMBEDDED( m_CommanderUpdateTimer ), // m_RealTimeLastSquadCommand DEFINE_FIELD( m_QueuedCommand, FIELD_INTEGER ), DEFINE_FIELD( m_flTimeIgnoreFallDamage, FIELD_TIME ), DEFINE_FIELD( m_bIgnoreFallDamageResetAfterImpact, FIELD_BOOLEAN ), // Suit power fields DEFINE_FIELD( m_flSuitPowerLoad, FIELD_FLOAT ), DEFINE_FIELD( m_flIdleTime, FIELD_TIME ), DEFINE_FIELD( m_flMoveTime, FIELD_TIME ), DEFINE_FIELD( m_flLastDamageTime, FIELD_TIME ), DEFINE_FIELD( m_flTargetFindTime, FIELD_TIME ), DEFINE_FIELD( m_flAdmireGlovesAnimTime, FIELD_TIME ), DEFINE_FIELD( m_flNextFlashlightCheckTime, FIELD_TIME ), DEFINE_FIELD( m_flFlashlightPowerDrainScale, FIELD_FLOAT ), DEFINE_FIELD( m_bFlashlightDisabled, FIELD_BOOLEAN ), DEFINE_FIELD( m_bUseCappedPhysicsDamageTable, FIELD_BOOLEAN ), DEFINE_FIELD( m_hLockedAutoAimEntity, FIELD_EHANDLE ), DEFINE_EMBEDDED( m_LowerWeaponTimer ), DEFINE_EMBEDDED( m_AutoaimTimer ), DEFINE_INPUTFUNC( FIELD_FLOAT, "IgnoreFallDamage", InputIgnoreFallDamage ), DEFINE_INPUTFUNC( FIELD_FLOAT, "IgnoreFallDamageWithoutReset", InputIgnoreFallDamageWithoutReset ), DEFINE_INPUTFUNC( FIELD_VOID, "OnSquadMemberKilled", OnSquadMemberKilled ), DEFINE_INPUTFUNC( FIELD_VOID, "DisableFlashlight", InputDisableFlashlight ), DEFINE_INPUTFUNC( FIELD_VOID, "EnableFlashlight", InputEnableFlashlight ), DEFINE_INPUTFUNC( FIELD_VOID, "ForceDropPhysObjects", InputForceDropPhysObjects ), DEFINE_SOUNDPATCH( m_sndLeeches ), DEFINE_SOUNDPATCH( m_sndWaterSplashes ), DEFINE_FIELD( m_flArmorReductionTime, FIELD_TIME ), DEFINE_FIELD( m_iArmorReductionFrom, FIELD_INTEGER ), DEFINE_FIELD( m_flTimeUseSuspended, FIELD_TIME ), DEFINE_FIELD( m_hLocatorTargetEntity, FIELD_EHANDLE ), DEFINE_FIELD( m_flTimeNextLadderHint, FIELD_TIME ), //DEFINE_FIELD( m_hPlayerProxy, FIELD_EHANDLE ), //Shut up class check! END_DATADESC() CHL2_Player::CHL2_Player() { m_nNumMissPositions = 0; m_pPlayerAISquad = 0; m_bSprintEnabled = true; m_flArmorReductionTime = 0.0f; m_iArmorReductionFrom = 0; } // // SUIT POWER DEVICES // #define SUITPOWER_CHARGE_RATE 12.5 // 100 units in 8 seconds #ifdef HL2MP CSuitPowerDevice SuitDeviceSprint( bits_SUIT_DEVICE_SPRINT, 25.0f ); // 100 units in 4 seconds #else CSuitPowerDevice SuitDeviceSprint( bits_SUIT_DEVICE_SPRINT, 12.5f ); // 100 units in 8 seconds #endif #ifdef HL2_EPISODIC CSuitPowerDevice SuitDeviceFlashlight( bits_SUIT_DEVICE_FLASHLIGHT, 1.111 ); // 100 units in 90 second #else CSuitPowerDevice SuitDeviceFlashlight( bits_SUIT_DEVICE_FLASHLIGHT, 2.222 ); // 100 units in 45 second #endif CSuitPowerDevice SuitDeviceBreather( bits_SUIT_DEVICE_BREATHER, 6.7f ); // 100 units in 15 seconds (plus three padded seconds) IMPLEMENT_SERVERCLASS_ST(CHL2_Player, DT_HL2_Player) SendPropDataTable(SENDINFO_DT(m_HL2Local), &REFERENCE_SEND_TABLE(DT_HL2Local), SendProxy_SendLocalDataTable), SendPropBool( SENDINFO(m_fIsSprinting) ), END_SEND_TABLE() void CHL2_Player::Precache( void ) { BaseClass::Precache(); PrecacheScriptSound( "HL2Player.SprintNoPower" ); PrecacheScriptSound( "HL2Player.SprintStart" ); PrecacheScriptSound( "HL2Player.UseDeny" ); PrecacheScriptSound( "HL2Player.FlashLightOn" ); PrecacheScriptSound( "HL2Player.FlashLightOff" ); PrecacheScriptSound( "HL2Player.PickupWeapon" ); PrecacheScriptSound( "HL2Player.TrainUse" ); PrecacheScriptSound( "HL2Player.Use" ); PrecacheScriptSound( "HL2Player.BurnPain" ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHL2_Player::CheckSuitZoom( void ) { //#ifndef _XBOX //Adrian - No zooming without a suit! if ( IsSuitEquipped() ) { if ( m_afButtonReleased & IN_ZOOM ) { StopZooming(); } else if ( m_afButtonPressed & IN_ZOOM ) { StartZooming(); } } //#endif//_XBOX } void CHL2_Player::EquipSuit( bool bPlayEffects ) { MDLCACHE_CRITICAL_SECTION(); BaseClass::EquipSuit(); m_HL2Local.m_bDisplayReticle = true; if ( bPlayEffects == true ) { StartAdmireGlovesAnimation(); } } void CHL2_Player::RemoveSuit( void ) { BaseClass::RemoveSuit(); m_HL2Local.m_bDisplayReticle = false; } void CHL2_Player::HandleSpeedChanges( void ) { int buttonsChanged = m_afButtonPressed | m_afButtonReleased; bool bCanSprint = CanSprint(); bool bIsSprinting = IsSprinting(); bool bWantSprint = ( bCanSprint && IsSuitEquipped() && (m_nButtons & IN_SPEED) ); if ( bIsSprinting != bWantSprint && (buttonsChanged & IN_SPEED) ) { // If someone wants to sprint, make sure they've pressed the button to do so. We want to prevent the // case where a player can hold down the sprint key and burn tiny bursts of sprint as the suit recharges // We want a full debounce of the key to resume sprinting after the suit is completely drained if ( bWantSprint ) { if ( sv_stickysprint.GetBool() ) { StartAutoSprint(); } else { StartSprinting(); } } else { if ( !sv_stickysprint.GetBool() ) { StopSprinting(); } // Reset key, so it will be activated post whatever is suppressing it. m_nButtons &= ~IN_SPEED; } } bool bIsWalking = IsWalking(); // have suit, pressing button, not sprinting or ducking bool bWantWalking; if( IsSuitEquipped() ) { bWantWalking = (m_nButtons & IN_WALK) && !IsSprinting() && !(m_nButtons & IN_DUCK); } else { bWantWalking = true; } if( bIsWalking != bWantWalking ) { if ( bWantWalking ) { StartWalking(); } else { StopWalking(); } } } //----------------------------------------------------------------------------- // This happens when we powerdown from the mega physcannon to the regular one //----------------------------------------------------------------------------- void CHL2_Player::HandleArmorReduction( void ) { if ( m_flArmorReductionTime < gpGlobals->curtime ) return; if ( ArmorValue() <= 0 ) return; float flPercent = 1.0f - (( m_flArmorReductionTime - gpGlobals->curtime ) / ARMOR_DECAY_TIME ); int iArmor = Lerp( flPercent, m_iArmorReductionFrom, 0 ); SetArmorValue( iArmor ); } //----------------------------------------------------------------------------- // Purpose: Allow pre-frame adjustments on the player //----------------------------------------------------------------------------- void CHL2_Player::PreThink(void) { if ( player_showpredictedposition.GetBool() ) { Vector predPos; UTIL_PredictedPosition( this, player_showpredictedposition_timestep.GetFloat(), &predPos ); NDebugOverlay::Box( predPos, NAI_Hull::Mins( GetHullType() ), NAI_Hull::Maxs( GetHullType() ), 0, 255, 0, 0, 0.01f ); NDebugOverlay::Line( GetAbsOrigin(), predPos, 0, 255, 0, 0, 0.01f ); } #ifdef HL2_EPISODIC if( m_hLocatorTargetEntity != NULL ) { // Keep track of the entity here, the client will pick up the rest of the work m_HL2Local.m_vecLocatorOrigin = m_hLocatorTargetEntity->WorldSpaceCenter(); } else { m_HL2Local.m_vecLocatorOrigin = vec3_invalid; // This tells the client we have no locator target. } #endif//HL2_EPISODIC // Riding a vehicle? if ( IsInAVehicle() ) { VPROF( "CHL2_Player::PreThink-Vehicle" ); // make sure we update the client, check for timed damage and update suit even if we are in a vehicle UpdateClientData(); CheckTimeBasedDamage(); // Allow the suit to recharge when in the vehicle. SuitPower_Update(); CheckSuitUpdate(); CheckSuitZoom(); WaterMove(); return; } // This is an experiment of mine- autojumping! // only affects you if sv_autojump is nonzero. if( (GetFlags() & FL_ONGROUND) && sv_autojump.GetFloat() != 0 ) { VPROF( "CHL2_Player::PreThink-Autojump" ); // check autojump Vector vecCheckDir; vecCheckDir = GetAbsVelocity(); float flVelocity = VectorNormalize( vecCheckDir ); if( flVelocity > 200 ) { // Going fast enough to autojump vecCheckDir = WorldSpaceCenter() + vecCheckDir * 34 - Vector( 0, 0, 16 ); trace_t tr; UTIL_TraceHull( WorldSpaceCenter() - Vector( 0, 0, 16 ), vecCheckDir, NAI_Hull::Mins(HULL_TINY_CENTERED),NAI_Hull::Maxs(HULL_TINY_CENTERED), MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER, &tr ); //NDebugOverlay::Line( tr.startpos, tr.endpos, 0,255,0, true, 10 ); if( tr.fraction == 1.0 && !tr.startsolid ) { // Now trace down! UTIL_TraceLine( vecCheckDir, vecCheckDir - Vector( 0, 0, 64 ), MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &tr ); //NDebugOverlay::Line( tr.startpos, tr.endpos, 0,255,0, true, 10 ); if( tr.fraction == 1.0 && !tr.startsolid ) { // !!!HACKHACK // I KNOW, I KNOW, this is definitely not the right way to do this, // but I'm prototyping! (sjb) Vector vecNewVelocity = GetAbsVelocity(); vecNewVelocity.z += 250; SetAbsVelocity( vecNewVelocity ); } } } } VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-Speed" ); HandleSpeedChanges(); #ifdef HL2_EPISODIC HandleArmorReduction(); #endif if( sv_stickysprint.GetBool() && m_bIsAutoSprinting ) { // If we're ducked and not in the air if( IsDucked() && GetGroundEntity() != NULL ) { StopSprinting(); } // Stop sprinting if the player lets off the stick for a moment. else if( GetStickDist() == 0.0f ) { if( gpGlobals->curtime > m_fAutoSprintMinTime ) { StopSprinting(); } } else { // Stop sprinting one half second after the player stops inputting with the move stick. m_fAutoSprintMinTime = gpGlobals->curtime + 0.5f; } } else if ( IsSprinting() ) { // Disable sprint while ducked unless we're in the air (jumping) if ( IsDucked() && ( GetGroundEntity() != NULL ) ) { StopSprinting(); } } VPROF_SCOPE_END(); if ( g_fGameOver || IsPlayerLockedInPlace() ) return; // finale VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-ItemPreFrame" ); ItemPreFrame( ); VPROF_SCOPE_END(); VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-WaterMove" ); WaterMove(); VPROF_SCOPE_END(); if ( g_pGameRules && g_pGameRules->FAllowFlashlight() ) m_Local.m_iHideHUD &= ~HIDEHUD_FLASHLIGHT; else m_Local.m_iHideHUD |= HIDEHUD_FLASHLIGHT; VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-CommanderUpdate" ); CommanderUpdate(); VPROF_SCOPE_END(); // Operate suit accessories and manage power consumption/charge VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-SuitPower_Update" ); SuitPower_Update(); VPROF_SCOPE_END(); // checks if new client data (for HUD and view control) needs to be sent to the client VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-UpdateClientData" ); UpdateClientData(); VPROF_SCOPE_END(); VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-CheckTimeBasedDamage" ); CheckTimeBasedDamage(); VPROF_SCOPE_END(); VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-CheckSuitUpdate" ); CheckSuitUpdate(); VPROF_SCOPE_END(); VPROF_SCOPE_BEGIN( "CHL2_Player::PreThink-CheckSuitZoom" ); CheckSuitZoom(); VPROF_SCOPE_END(); if (m_lifeState >= LIFE_DYING) { PlayerDeathThink(); return; } #ifdef HL2_EPISODIC CheckFlashlight(); #endif // HL2_EPISODIC // So the correct flags get sent to client asap. // if ( m_afPhysicsFlags & PFLAG_DIROVERRIDE ) AddFlag( FL_ONTRAIN ); else RemoveFlag( FL_ONTRAIN ); // Train speed control if ( m_afPhysicsFlags & PFLAG_DIROVERRIDE ) { CBaseEntity *pTrain = GetGroundEntity(); float vel; if ( pTrain ) { if ( !(pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) ) pTrain = NULL; } if ( !pTrain ) { if ( GetActiveWeapon() && (GetActiveWeapon()->ObjectCaps() & FCAP_DIRECTIONAL_USE) ) { m_iTrain = TRAIN_ACTIVE | TRAIN_NEW; if ( m_nButtons & IN_FORWARD ) { m_iTrain |= TRAIN_FAST; } else if ( m_nButtons & IN_BACK ) { m_iTrain |= TRAIN_BACK; } else { m_iTrain |= TRAIN_NEUTRAL; } return; } else { trace_t trainTrace; // Maybe this is on the other side of a level transition UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector(0,0,-38), MASK_PLAYERSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &trainTrace ); if ( trainTrace.fraction != 1.0 && trainTrace.m_pEnt ) pTrain = trainTrace.m_pEnt; if ( !pTrain || !(pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) || !pTrain->OnControls(this) ) { // Warning( "In train mode with no train!\n" ); m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE; m_iTrain = TRAIN_NEW|TRAIN_OFF; return; } } } else if ( !( GetFlags() & FL_ONGROUND ) || pTrain->HasSpawnFlags( SF_TRACKTRAIN_NOCONTROL ) || (m_nButtons & (IN_MOVELEFT|IN_MOVERIGHT) ) ) { // Turn off the train if you jump, strafe, or the train controls go dead m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE; m_iTrain = TRAIN_NEW|TRAIN_OFF; return; } SetAbsVelocity( vec3_origin ); vel = 0; if ( m_afButtonPressed & IN_FORWARD ) { vel = 1; pTrain->Use( this, this, USE_SET, (float)vel ); } else if ( m_afButtonPressed & IN_BACK ) { vel = -1; pTrain->Use( this, this, USE_SET, (float)vel ); } if (vel) { m_iTrain = TrainSpeed(pTrain->m_flSpeed, ((CFuncTrackTrain*)pTrain)->GetMaxSpeed()); m_iTrain |= TRAIN_ACTIVE|TRAIN_NEW; } } else if (m_iTrain & TRAIN_ACTIVE) { m_iTrain = TRAIN_NEW; // turn off train } // // If we're not on the ground, we're falling. Update our falling velocity. // if ( !( GetFlags() & FL_ONGROUND ) ) { m_Local.m_flFallVelocity = -GetAbsVelocity().z; } if ( m_afPhysicsFlags & PFLAG_ONBARNACLE ) { bool bOnBarnacle = false; CNPC_Barnacle *pBarnacle = NULL; do { // FIXME: Not a good or fast solution, but maybe it will catch the bug! pBarnacle = (CNPC_Barnacle*)gEntList.FindEntityByClassname( pBarnacle, "npc_barnacle" ); if ( pBarnacle ) { if ( pBarnacle->GetEnemy() == this ) { bOnBarnacle = true; } } } while ( pBarnacle ); if ( !bOnBarnacle ) { Warning( "Attached to barnacle?\n" ); Assert( 0 ); m_afPhysicsFlags &= ~PFLAG_ONBARNACLE; } else { SetAbsVelocity( vec3_origin ); } } // StudioFrameAdvance( );//!!!HACKHACK!!! Can't be hit by traceline when not animating? // Update weapon's ready status UpdateWeaponPosture(); // Disallow shooting while zooming if ( IsX360() ) { if ( IsZooming() ) { if( GetActiveWeapon() && !GetActiveWeapon()->IsWeaponZoomed() ) { // If not zoomed because of the weapon itself, do not attack. m_nButtons &= ~(IN_ATTACK|IN_ATTACK2); } } } else { if ( m_nButtons & IN_ZOOM ) { //FIXME: Held weapons like the grenade get sad when this happens #ifdef HL2_EPISODIC // Episodic allows players to zoom while using a func_tank CBaseCombatWeapon* pWep = GetActiveWeapon(); if ( !m_hUseEntity || ( pWep && pWep->IsWeaponVisible() ) ) #endif m_nButtons &= ~(IN_ATTACK|IN_ATTACK2); } } } void CHL2_Player::PostThink( void ) { BaseClass::PostThink(); if ( !g_fGameOver && !IsPlayerLockedInPlace() && IsAlive() ) { HandleAdmireGlovesAnimation(); } } void CHL2_Player::StartAdmireGlovesAnimation( void ) { MDLCACHE_CRITICAL_SECTION(); CBaseViewModel *vm = GetViewModel( 0 ); if ( vm && !GetActiveWeapon() ) { vm->SetWeaponModel( "models/weapons/v_hands.mdl", NULL ); ShowViewModel( true ); int idealSequence = vm->SelectWeightedSequence( ACT_VM_IDLE ); if ( idealSequence >= 0 ) { vm->SendViewModelMatchingSequence( idealSequence ); m_flAdmireGlovesAnimTime = gpGlobals->curtime + vm->SequenceDuration( idealSequence ); } } } void CHL2_Player::HandleAdmireGlovesAnimation( void ) { CBaseViewModel *pVM = GetViewModel(); if ( pVM && pVM->GetOwningWeapon() == NULL ) { if ( m_flAdmireGlovesAnimTime != 0.0 ) { if ( m_flAdmireGlovesAnimTime > gpGlobals->curtime ) { pVM->m_flPlaybackRate = 1.0f; pVM->StudioFrameAdvance( ); } else if ( m_flAdmireGlovesAnimTime < gpGlobals->curtime ) { m_flAdmireGlovesAnimTime = 0.0f; pVM->SetWeaponModel( NULL, NULL ); } } } else m_flAdmireGlovesAnimTime = 0.0f; } #define HL2PLAYER_RELOADGAME_ATTACK_DELAY 1.0f void CHL2_Player::Activate( void ) { BaseClass::Activate(); InitSprinting(); #ifdef HL2_EPISODIC // Delay attacks by 1 second after loading a game. if ( GetActiveWeapon() ) { float flRemaining = GetActiveWeapon()->m_flNextPrimaryAttack - gpGlobals->curtime; if ( flRemaining < HL2PLAYER_RELOADGAME_ATTACK_DELAY ) { GetActiveWeapon()->m_flNextPrimaryAttack = gpGlobals->curtime + HL2PLAYER_RELOADGAME_ATTACK_DELAY; } flRemaining = GetActiveWeapon()->m_flNextSecondaryAttack - gpGlobals->curtime; if ( flRemaining < HL2PLAYER_RELOADGAME_ATTACK_DELAY ) { GetActiveWeapon()->m_flNextSecondaryAttack = gpGlobals->curtime + HL2PLAYER_RELOADGAME_ATTACK_DELAY; } } #endif GetPlayerProxy(); } //------------------------------------------------------------------------------ // Purpose : // Input : // Output : //------------------------------------------------------------------------------ Class_T CHL2_Player::Classify ( void ) { // If player controlling another entity? If so, return this class if (m_nControlClass != CLASS_NONE) { return m_nControlClass; } else { if(IsInAVehicle()) { IServerVehicle *pVehicle = GetVehicle(); return pVehicle->ClassifyPassenger( this, CLASS_PLAYER ); } else { return CLASS_PLAYER; } } } //----------------------------------------------------------------------------- // Purpose: This is a generic function (to be implemented by sub-classes) to // handle specific interactions between different types of characters // (For example the barnacle grabbing an NPC) // Input : Constant for the type of interaction // Output : true - if sub-class has a response for the interaction // false - if sub-class has no response //----------------------------------------------------------------------------- bool CHL2_Player::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter* sourceEnt) { if ( interactionType == g_interactionBarnacleVictimDangle ) return false; if (interactionType == g_interactionBarnacleVictimReleased) { m_afPhysicsFlags &= ~PFLAG_ONBARNACLE; SetMoveType( MOVETYPE_WALK ); return true; } else if (interactionType == g_interactionBarnacleVictimGrab) { #ifdef HL2_EPISODIC CNPC_Alyx *pAlyx = CNPC_Alyx::GetAlyx(); if ( pAlyx ) { // Make Alyx totally hate this barnacle so that she saves the player. int priority; priority = pAlyx->IRelationPriority(sourceEnt); pAlyx->AddEntityRelationship( sourceEnt, D_HT, priority + 5 ); } #endif//HL2_EPISODIC m_afPhysicsFlags |= PFLAG_ONBARNACLE; ClearUseEntity(); return true; } return false; } void CHL2_Player::PlayerRunCommand(CUserCmd *ucmd, IMoveHelper *moveHelper) { // Handle FL_FROZEN. if ( m_afPhysicsFlags & PFLAG_ONBARNACLE ) { ucmd->forwardmove = 0; ucmd->sidemove = 0; ucmd->upmove = 0; ucmd->buttons &= ~IN_USE; } // Can't use stuff while dead if ( IsDead() ) { ucmd->buttons &= ~IN_USE; } //Update our movement information if ( ( ucmd->forwardmove != 0 ) || ( ucmd->sidemove != 0 ) || ( ucmd->upmove != 0 ) ) { m_flIdleTime -= TICK_INTERVAL * 2.0f; if ( m_flIdleTime < 0.0f ) { m_flIdleTime = 0.0f; } m_flMoveTime += TICK_INTERVAL; if ( m_flMoveTime > 4.0f ) { m_flMoveTime = 4.0f; } } else { m_flIdleTime += TICK_INTERVAL; if ( m_flIdleTime > 4.0f ) { m_flIdleTime = 4.0f; } m_flMoveTime -= TICK_INTERVAL * 2.0f; if ( m_flMoveTime < 0.0f ) { m_flMoveTime = 0.0f; } } //Msg("Player time: [ACTIVE: %f]\t[IDLE: %f]\n", m_flMoveTime, m_flIdleTime ); BaseClass::PlayerRunCommand( ucmd, moveHelper ); } //----------------------------------------------------------------------------- // Purpose: Sets HL2 specific defaults. //----------------------------------------------------------------------------- void CHL2_Player::Spawn(void) { #ifndef HL2MP #ifndef PORTAL SetModel( "models/player.mdl" ); #endif #endif BaseClass::Spawn(); // // Our player movement speed is set once here. This will override the cl_xxxx // cvars unless they are set to be lower than this. // //m_flMaxspeed = 320; if ( !IsSuitEquipped() ) StartWalking(); SuitPower_SetCharge( 100 ); m_Local.m_iHideHUD |= HIDEHUD_CHAT; m_pPlayerAISquad = g_AI_SquadManager.FindCreateSquad(AllocPooledString(PLAYER_SQUADNAME)); InitSprinting(); // Setup our flashlight values #ifdef HL2_EPISODIC m_HL2Local.m_flFlashBattery = 100.0f; #endif GetPlayerProxy(); SetFlashlightPowerDrainScale( 1.0f ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::UpdateLocatorPosition( const Vector &vecPosition ) { #ifdef HL2_EPISODIC m_HL2Local.m_vecLocatorOrigin = vecPosition; #endif//HL2_EPISODIC } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::InitSprinting( void ) { StopSprinting(); } //----------------------------------------------------------------------------- // Purpose: Returns whether or not we are allowed to sprint now. //----------------------------------------------------------------------------- bool CHL2_Player::CanSprint() { return ( m_bSprintEnabled && // Only if sprint is enabled !IsWalking() && // Not if we're walking !( m_Local.m_bDucked && !m_Local.m_bDucking ) && // Nor if we're ducking (GetWaterLevel() != 3) && // Certainly not underwater (GlobalEntity_GetState("suit_no_sprint") != GLOBAL_ON) ); // Out of the question without the sprint module } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::StartAutoSprint() { if( IsSprinting() ) { StopSprinting(); } else { StartSprinting(); m_bIsAutoSprinting = true; m_fAutoSprintMinTime = gpGlobals->curtime + 1.5f; } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::StartSprinting( void ) { if( m_HL2Local.m_flSuitPower < 10 ) { // Don't sprint unless there's a reasonable // amount of suit power. // debounce the button for sound playing if ( m_afButtonPressed & IN_SPEED ) { CPASAttenuationFilter filter( this ); filter.UsePredictionRules(); EmitSound( filter, entindex(), "HL2Player.SprintNoPower" ); } return; } if( !SuitPower_AddDevice( SuitDeviceSprint ) ) return; CPASAttenuationFilter filter( this ); filter.UsePredictionRules(); EmitSound( filter, entindex(), "HL2Player.SprintStart" ); SetMaxSpeed( HL2_SPRINT_SPEED ); m_fIsSprinting = true; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::StopSprinting( void ) { if ( m_HL2Local.m_bitsActiveDevices & SuitDeviceSprint.GetDeviceID() ) { SuitPower_RemoveDevice( SuitDeviceSprint ); } if( IsSuitEquipped() ) { SetMaxSpeed( HL2_NORM_SPEED ); } else { SetMaxSpeed( HL2_WALK_SPEED ); } m_fIsSprinting = false; if ( sv_stickysprint.GetBool() ) { m_bIsAutoSprinting = false; m_fAutoSprintMinTime = 0.0f; } } //----------------------------------------------------------------------------- // Purpose: Called to disable and enable sprint due to temporary circumstances: // - Carrying a heavy object with the physcannon //----------------------------------------------------------------------------- void CHL2_Player::EnableSprint( bool bEnable ) { if ( !bEnable && IsSprinting() ) { StopSprinting(); } m_bSprintEnabled = bEnable; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::StartWalking( void ) { SetMaxSpeed( HL2_WALK_SPEED ); m_fIsWalking = true; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::StopWalking( void ) { SetMaxSpeed( HL2_NORM_SPEED ); m_fIsWalking = false; } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CHL2_Player::CanZoom( CBaseEntity *pRequester ) { if ( IsZooming() ) return false; //Check our weapon return true; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::ToggleZoom(void) { if( IsZooming() ) { StopZooming(); } else { StartZooming(); } } //----------------------------------------------------------------------------- // Purpose: +zoom suit zoom //----------------------------------------------------------------------------- void CHL2_Player::StartZooming( void ) { int iFOV = 25; if ( SetFOV( this, iFOV, 0.4f ) ) { m_HL2Local.m_bZooming = true; } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHL2_Player::StopZooming( void ) { int iFOV = GetZoomOwnerDesiredFOV( m_hZoomOwner ); if ( SetFOV( this, iFOV, 0.2f ) ) { m_HL2Local.m_bZooming = false; } } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CHL2_Player::IsZooming( void ) { if ( m_hZoomOwner != NULL ) return true; return false; } class CPhysicsPlayerCallback : public IPhysicsPlayerControllerEvent { public: int ShouldMoveTo( IPhysicsObject *pObject, const Vector &position ) { CHL2_Player *pPlayer = (CHL2_Player *)pObject->GetGameData(); if ( pPlayer ) { if ( pPlayer->TouchedPhysics() ) { return 0; } } return 1; } }; static CPhysicsPlayerCallback playerCallback; //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHL2_Player::InitVCollision( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity ) { BaseClass::InitVCollision( vecAbsOrigin, vecAbsVelocity ); // Setup the HL2 specific callback. IPhysicsPlayerController *pPlayerController = GetPhysicsController(); if ( pPlayerController ) { pPlayerController->SetEventHandler( &playerCallback ); } } CHL2_Player::~CHL2_Player( void ) { } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CHL2_Player::CommanderFindGoal( commandgoal_t *pGoal ) { CAI_BaseNPC *pAllyNpc; trace_t tr; Vector vecTarget; Vector forward; EyeVectors( &forward ); //--------------------------------- // MASK_SHOT on purpose! So that you don't hit the invisible hulls of the NPCs. CTraceFilterSkipTwoEntities filter( this, PhysCannonGetHeldEntity( GetActiveWeapon() ), COLLISION_GROUP_INTERACTIVE_DEBRIS ); UTIL_TraceLine( EyePosition(), EyePosition() + forward * MAX_COORD_RANGE, MASK_SHOT, &filter, &tr ); if( !tr.DidHitWorld() ) { CUtlVector Allies; AISquadIter_t iter; for ( pAllyNpc = m_pPlayerAISquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = m_pPlayerAISquad->GetNextMember(&iter) ) { if ( pAllyNpc->IsCommandable() ) Allies.AddToTail( pAllyNpc ); } for( int i = 0 ; i < Allies.Count() ; i++ ) { if( Allies[ i ]->IsValidCommandTarget( tr.m_pEnt ) ) { pGoal->m_pGoalEntity = tr.m_pEnt; return true; } } } if( tr.fraction == 1.0 || (tr.surface.flags & SURF_SKY) ) { // Move commands invalid against skybox. pGoal->m_vecGoalLocation = tr.endpos; return false; } if ( tr.m_pEnt->IsNPC() && ((CAI_BaseNPC *)(tr.m_pEnt))->IsCommandable() ) { pGoal->m_vecGoalLocation = tr.m_pEnt->GetAbsOrigin(); } else { vecTarget = tr.endpos; Vector mins( -16, -16, 0 ); Vector maxs( 16, 16, 0 ); // Back up from whatever we hit so that there's enough space at the // target location for a bounding box. // Now trace down. //UTIL_TraceLine( vecTarget, vecTarget - Vector( 0, 0, 8192 ), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr ); UTIL_TraceHull( vecTarget + tr.plane.normal * 24, vecTarget - Vector( 0, 0, 8192 ), mins, maxs, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); if ( !tr.startsolid ) pGoal->m_vecGoalLocation = tr.endpos; else pGoal->m_vecGoalLocation = vecTarget; } pAllyNpc = GetSquadCommandRepresentative(); if ( !pAllyNpc ) return false; vecTarget = pGoal->m_vecGoalLocation; if ( !pAllyNpc->FindNearestValidGoalPos( vecTarget, &pGoal->m_vecGoalLocation ) ) return false; return ( ( vecTarget - pGoal->m_vecGoalLocation ).LengthSqr() < Square( 15*12 ) ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- CAI_BaseNPC *CHL2_Player::GetSquadCommandRepresentative() { if ( m_pPlayerAISquad != NULL ) { CAI_BaseNPC *pAllyNpc = m_pPlayerAISquad->GetFirstMember(); if ( pAllyNpc ) { return pAllyNpc->GetSquadCommandRepresentative(); } } return NULL; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- int CHL2_Player::GetNumSquadCommandables() { AISquadIter_t iter; int c = 0; for ( CAI_BaseNPC *pAllyNpc = m_pPlayerAISquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = m_pPlayerAISquad->GetNextMember(&iter) ) { if ( pAllyNpc->IsCommandable() ) c++; } return c; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- int CHL2_Player::GetNumSquadCommandableMedics() { AISquadIter_t iter; int c = 0; for ( CAI_BaseNPC *pAllyNpc = m_pPlayerAISquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = m_pPlayerAISquad->GetNextMember(&iter) ) { if ( pAllyNpc->IsCommandable() && pAllyNpc->IsMedic() ) c++; } return c; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::CommanderUpdate() { CAI_BaseNPC *pCommandRepresentative = GetSquadCommandRepresentative(); bool bFollowMode = false; if ( pCommandRepresentative ) { bFollowMode = ( pCommandRepresentative->GetCommandGoal() == vec3_invalid ); // set the variables for network transmission (to show on the hud) m_HL2Local.m_iSquadMemberCount = GetNumSquadCommandables(); m_HL2Local.m_iSquadMedicCount = GetNumSquadCommandableMedics(); m_HL2Local.m_fSquadInFollowMode = bFollowMode; // debugging code for displaying extra squad indicators /* char *pszMoving = ""; AISquadIter_t iter; for ( CAI_BaseNPC *pAllyNpc = m_pPlayerAISquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = m_pPlayerAISquad->GetNextMember(&iter) ) { if ( pAllyNpc->IsCommandMoving() ) { pszMoving = "<-"; break; } } NDebugOverlay::ScreenText( 0.932, 0.919, CFmtStr( "%d|%c%s", GetNumSquadCommandables(), ( bFollowMode ) ? 'F' : 'S', pszMoving ), 255, 128, 0, 128, 0 ); */ } else { m_HL2Local.m_iSquadMemberCount = 0; m_HL2Local.m_iSquadMedicCount = 0; m_HL2Local.m_fSquadInFollowMode = true; } if ( m_QueuedCommand != CC_NONE && ( m_QueuedCommand == CC_FOLLOW || gpGlobals->realtime - m_RealTimeLastSquadCommand >= player_squad_double_tap_time.GetFloat() ) ) { CommanderExecute( m_QueuedCommand ); m_QueuedCommand = CC_NONE; } else if ( !bFollowMode && pCommandRepresentative && m_CommanderUpdateTimer.Expired() && player_squad_transient_commands.GetBool() ) { m_CommanderUpdateTimer.Set(2.5); if ( pCommandRepresentative->ShouldAutoSummon() ) CommanderExecute( CC_FOLLOW ); } } //----------------------------------------------------------------------------- // Purpose: // // bHandled - indicates whether to continue delivering this order to // all allies. Allows us to stop delivering certain types of orders once we find // a suitable candidate. (like picking up a single weapon. We don't wish for // all allies to respond and try to pick up one weapon). //----------------------------------------------------------------------------- bool CHL2_Player::CommanderExecuteOne( CAI_BaseNPC *pNpc, const commandgoal_t &goal, CAI_BaseNPC **Allies, int numAllies ) { if ( goal.m_pGoalEntity ) { return pNpc->TargetOrder( goal.m_pGoalEntity, Allies, numAllies ); } else if ( pNpc->IsInPlayerSquad() ) { pNpc->MoveOrder( goal.m_vecGoalLocation, Allies, numAllies ); } return true; } //--------------------------------------------------------- //--------------------------------------------------------- void CHL2_Player::CommanderExecute( CommanderCommand_t command ) { CAI_BaseNPC *pPlayerSquadLeader = GetSquadCommandRepresentative(); if ( !pPlayerSquadLeader ) { EmitSound( "HL2Player.UseDeny" ); return; } int i; CUtlVector Allies; commandgoal_t goal; if ( command == CC_TOGGLE ) { if ( pPlayerSquadLeader->GetCommandGoal() != vec3_invalid ) command = CC_FOLLOW; else command = CC_SEND; } else { if ( command == CC_FOLLOW && pPlayerSquadLeader->GetCommandGoal() == vec3_invalid ) return; } if ( command == CC_FOLLOW ) { goal.m_pGoalEntity = this; goal.m_vecGoalLocation = vec3_invalid; } else { goal.m_pGoalEntity = NULL; goal.m_vecGoalLocation = vec3_invalid; // Find a goal for ourselves. if( !CommanderFindGoal( &goal ) ) { EmitSound( "HL2Player.UseDeny" ); return; // just keep following } } #ifdef _DEBUG if( goal.m_pGoalEntity == NULL && goal.m_vecGoalLocation == vec3_invalid ) { DevMsg( 1, "**ERROR: Someone sent an invalid goal to CommanderExecute!\n" ); } #endif // _DEBUG AISquadIter_t iter; for ( CAI_BaseNPC *pAllyNpc = m_pPlayerAISquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = m_pPlayerAISquad->GetNextMember(&iter) ) { if ( pAllyNpc->IsCommandable() ) Allies.AddToTail( pAllyNpc ); } //--------------------------------- // If the trace hits an NPC, send all ally NPCs a "target" order. Always // goes to targeted one first #ifdef DBGFLAG_ASSERT int nAIs = g_AI_Manager.NumAIs(); #endif CAI_BaseNPC * pTargetNpc = (goal.m_pGoalEntity) ? goal.m_pGoalEntity->MyNPCPointer() : NULL; bool bHandled = false; if( pTargetNpc ) { bHandled = !CommanderExecuteOne( pTargetNpc, goal, Allies.Base(), Allies.Count() ); } for ( i = 0; !bHandled && i < Allies.Count(); i++ ) { if ( Allies[i] != pTargetNpc && Allies[i]->IsPlayerAlly() ) { bHandled = !CommanderExecuteOne( Allies[i], goal, Allies.Base(), Allies.Count() ); } Assert( nAIs == g_AI_Manager.NumAIs() ); // not coded to support mutating set of NPCs } } //----------------------------------------------------------------------------- // Enter/exit commander mode, manage ally selection. //----------------------------------------------------------------------------- void CHL2_Player::CommanderMode() { float commandInterval = gpGlobals->realtime - m_RealTimeLastSquadCommand; m_RealTimeLastSquadCommand = gpGlobals->realtime; if ( commandInterval < player_squad_double_tap_time.GetFloat() ) { m_QueuedCommand = CC_FOLLOW; } else { m_QueuedCommand = (player_squad_transient_commands.GetBool()) ? CC_SEND : CC_TOGGLE; } } //----------------------------------------------------------------------------- // Purpose: // Input : iImpulse - //----------------------------------------------------------------------------- void CHL2_Player::CheatImpulseCommands( int iImpulse ) { switch( iImpulse ) { case 50: { CommanderMode(); break; } case 51: { // Cheat to create a dynamic resupply item Vector vecForward; AngleVectors( EyeAngles(), &vecForward ); CBaseEntity *pItem = (CBaseEntity *)CreateEntityByName( "item_dynamic_resupply" ); if ( pItem ) { Vector vecOrigin = GetAbsOrigin() + vecForward * 256 + Vector(0,0,64); QAngle vecAngles( 0, GetAbsAngles().y - 90, 0 ); pItem->SetAbsOrigin( vecOrigin ); pItem->SetAbsAngles( vecAngles ); pItem->KeyValue( "targetname", "resupply" ); pItem->Spawn(); pItem->Activate(); } break; } case 52: { // Rangefinder trace_t tr; UTIL_TraceLine( EyePosition(), EyePosition() + EyeDirection3D() * MAX_COORD_RANGE, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr ); if( tr.fraction != 1.0 ) { float flDist = (tr.startpos - tr.endpos).Length(); float flDist2D = (tr.startpos - tr.endpos).Length2D(); DevMsg( 1,"\nStartPos: %.4f %.4f %.4f --- EndPos: %.4f %.4f %.4f\n", tr.startpos.x,tr.startpos.y,tr.startpos.z,tr.endpos.x,tr.endpos.y,tr.endpos.z ); DevMsg( 1,"3D Distance: %.4f units (%.2f feet) --- 2D Distance: %.4f units (%.2f feet)\n", flDist, flDist / 12.0, flDist2D, flDist2D / 12.0 ); } break; } default: BaseClass::CheatImpulseCommands( iImpulse ); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHL2_Player::SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize ) { BaseClass::SetupVisibility( pViewEntity, pvs, pvssize ); int area = pViewEntity ? pViewEntity->NetworkProp()->AreaNum() : NetworkProp()->AreaNum(); PointCameraSetupVisibility( this, area, pvs, pvssize ); // If the intro script is playing, we want to get it's visibility points if ( g_hIntroScript ) { Vector vecOrigin; CBaseEntity *pCamera; if ( g_hIntroScript->GetIncludedPVSOrigin( &vecOrigin, &pCamera ) ) { // If it's a point camera, turn it on CPointCamera *pPointCamera = dynamic_cast< CPointCamera* >(pCamera); if ( pPointCamera ) { pPointCamera->SetActive( true ); } engine->AddOriginToPVS( vecOrigin ); } } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::SuitPower_Update( void ) { if( SuitPower_ShouldRecharge() ) { SuitPower_Charge( SUITPOWER_CHARGE_RATE * gpGlobals->frametime ); } else if( m_HL2Local.m_bitsActiveDevices ) { float flPowerLoad = m_flSuitPowerLoad; //Since stickysprint quickly shuts off sprint if it isn't being used, this isn't an issue. if ( !sv_stickysprint.GetBool() ) { if( SuitPower_IsDeviceActive(SuitDeviceSprint) ) { if( !fabs(GetAbsVelocity().x) && !fabs(GetAbsVelocity().y) ) { // If player's not moving, don't drain sprint juice. flPowerLoad -= SuitDeviceSprint.GetDeviceDrainRate(); } } } if( SuitPower_IsDeviceActive(SuitDeviceFlashlight) ) { float factor; factor = 1.0f / m_flFlashlightPowerDrainScale; flPowerLoad -= ( SuitDeviceFlashlight.GetDeviceDrainRate() * (1.0f - factor) ); } if( !SuitPower_Drain( flPowerLoad * gpGlobals->frametime ) ) { // TURN OFF ALL DEVICES!! if( IsSprinting() ) { StopSprinting(); } if ( Flashlight_UseLegacyVersion() ) { if( FlashlightIsOn() ) { #ifndef HL2MP FlashlightTurnOff(); #endif } } } if ( Flashlight_UseLegacyVersion() ) { // turn off flashlight a little bit after it hits below one aux power notch (5%) if( m_HL2Local.m_flSuitPower < 4.8f && FlashlightIsOn() ) { #ifndef HL2MP FlashlightTurnOff(); #endif } } } } //----------------------------------------------------------------------------- // Charge battery fully, turn off all devices. //----------------------------------------------------------------------------- void CHL2_Player::SuitPower_Initialize( void ) { m_HL2Local.m_bitsActiveDevices = 0x00000000; m_HL2Local.m_flSuitPower = 100.0; m_flSuitPowerLoad = 0.0; } //----------------------------------------------------------------------------- // Purpose: Interface to drain power from the suit's power supply. // Input: Amount of charge to remove (expressed as percentage of full charge) // Output: Returns TRUE if successful, FALSE if not enough power available. //----------------------------------------------------------------------------- bool CHL2_Player::SuitPower_Drain( float flPower ) { // Suitpower cheat on? if ( sv_infinite_aux_power.GetBool() ) return true; m_HL2Local.m_flSuitPower -= flPower; if( m_HL2Local.m_flSuitPower < 0.0 ) { // Power is depleted! // Clamp and fail m_HL2Local.m_flSuitPower = 0.0; return false; } return true; } //----------------------------------------------------------------------------- // Purpose: Interface to add power to the suit's power supply // Input: Amount of charge to add //----------------------------------------------------------------------------- void CHL2_Player::SuitPower_Charge( float flPower ) { m_HL2Local.m_flSuitPower += flPower; if( m_HL2Local.m_flSuitPower > 100.0 ) { // Full charge, clamp. m_HL2Local.m_flSuitPower = 100.0; } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CHL2_Player::SuitPower_IsDeviceActive( const CSuitPowerDevice &device ) { return (m_HL2Local.m_bitsActiveDevices & device.GetDeviceID()) != 0; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CHL2_Player::SuitPower_AddDevice( const CSuitPowerDevice &device ) { // Make sure this device is NOT active!! if( m_HL2Local.m_bitsActiveDevices & device.GetDeviceID() ) return false; if( !IsSuitEquipped() ) return false; m_HL2Local.m_bitsActiveDevices |= device.GetDeviceID(); m_flSuitPowerLoad += device.GetDeviceDrainRate(); return true; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CHL2_Player::SuitPower_RemoveDevice( const CSuitPowerDevice &device ) { // Make sure this device is active!! if( ! (m_HL2Local.m_bitsActiveDevices & device.GetDeviceID()) ) return false; if( !IsSuitEquipped() ) return false; // Take a little bit of suit power when you disable a device. If the device is shutting off // because the battery is drained, no harm done, the battery charge cannot go below 0. // This code in combination with the delay before the suit can start recharging are a defense // against exploits where the player could rapidly tap sprint and never run out of power. SuitPower_Drain( device.GetDeviceDrainRate() * 0.1f ); m_HL2Local.m_bitsActiveDevices &= ~device.GetDeviceID(); m_flSuitPowerLoad -= device.GetDeviceDrainRate(); if( m_HL2Local.m_bitsActiveDevices == 0x00000000 ) { // With this device turned off, we can set this timer which tells us when the // suit power system entered a no-load state. m_flTimeAllSuitDevicesOff = gpGlobals->curtime; } return true; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- #define SUITPOWER_BEGIN_RECHARGE_DELAY 0.5f bool CHL2_Player::SuitPower_ShouldRecharge( void ) { // Make sure all devices are off. if( m_HL2Local.m_bitsActiveDevices != 0x00000000 ) return false; // Is the system fully charged? if( m_HL2Local.m_flSuitPower >= 100.0f ) return false; // Has the system been in a no-load state for long enough // to begin recharging? if( gpGlobals->curtime < m_flTimeAllSuitDevicesOff + SUITPOWER_BEGIN_RECHARGE_DELAY ) return false; return true; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- ConVar sk_battery( "sk_battery","0" ); bool CHL2_Player::ApplyBattery( float powerMultiplier ) { const float MAX_NORMAL_BATTERY = 100; if ((ArmorValue() < MAX_NORMAL_BATTERY) && IsSuitEquipped()) { int pct; char szcharge[64]; IncrementArmorValue( sk_battery.GetFloat() * powerMultiplier, MAX_NORMAL_BATTERY ); CPASAttenuationFilter filter( this, "ItemBattery.Touch" ); EmitSound( filter, entindex(), "ItemBattery.Touch" ); CSingleUserRecipientFilter user( this ); user.MakeReliable(); UserMessageBegin( user, "ItemPickup" ); WRITE_STRING( "item_battery" ); MessageEnd(); // Suit reports new power level // For some reason this wasn't working in release build -- round it. pct = (int)( (float)(ArmorValue() * 100.0) * (1.0/MAX_NORMAL_BATTERY) + 0.5); pct = (pct / 5); if (pct > 0) pct--; Q_snprintf( szcharge,sizeof(szcharge),"!HEV_%1dP", pct ); //UTIL_EmitSoundSuit(edict(), szcharge); //SetSuitUpdate(szcharge, FALSE, SUIT_NEXT_IN_30SEC); return true; } return false; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- int CHL2_Player::FlashlightIsOn( void ) { return IsEffectActive( EF_DIMLIGHT ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::FlashlightTurnOn( void ) { if( m_bFlashlightDisabled ) return; if ( Flashlight_UseLegacyVersion() ) { if( !SuitPower_AddDevice( SuitDeviceFlashlight ) ) return; } #ifdef HL2_DLL if( !IsSuitEquipped() ) return; #endif AddEffects( EF_DIMLIGHT ); EmitSound( "HL2Player.FlashLightOn" ); variant_t flashlighton; flashlighton.SetFloat( m_HL2Local.m_flSuitPower / 100.0f ); FirePlayerProxyOutput( "OnFlashlightOn", flashlighton, this, this ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::FlashlightTurnOff( void ) { if ( Flashlight_UseLegacyVersion() ) { if( !SuitPower_RemoveDevice( SuitDeviceFlashlight ) ) return; } RemoveEffects( EF_DIMLIGHT ); EmitSound( "HL2Player.FlashLightOff" ); variant_t flashlightoff; flashlightoff.SetFloat( m_HL2Local.m_flSuitPower / 100.0f ); FirePlayerProxyOutput( "OnFlashlightOff", flashlightoff, this, this ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- #define FLASHLIGHT_RANGE Square(600) bool CHL2_Player::IsIlluminatedByFlashlight( CBaseEntity *pEntity, float *flReturnDot ) { if( !FlashlightIsOn() ) return false; if( pEntity->Classify() == CLASS_BARNACLE && pEntity->GetEnemy() == this ) { // As long as my flashlight is on, the barnacle that's pulling me in is considered illuminated. // This is because players often shine their flashlights at Alyx when they are in a barnacle's // grasp, and wonder why Alyx isn't helping. Alyx isn't helping because the light isn't pointed // at the barnacle. This will allow Alyx to see the barnacle no matter which way the light is pointed. return true; } // Within 50 feet? float flDistSqr = GetAbsOrigin().DistToSqr(pEntity->GetAbsOrigin()); if( flDistSqr > FLASHLIGHT_RANGE ) return false; // Within 45 degrees? Vector vecSpot = pEntity->WorldSpaceCenter(); Vector los; // If the eyeposition is too close, move it back. Solves problems // caused by the player being too close the target. if ( flDistSqr < (128 * 128) ) { Vector vecForward; EyeVectors( &vecForward ); Vector vecMovedEyePos = EyePosition() - (vecForward * 128); los = ( vecSpot - vecMovedEyePos ); } else { los = ( vecSpot - EyePosition() ); } VectorNormalize( los ); Vector facingDir = EyeDirection3D( ); float flDot = DotProduct( los, facingDir ); if ( flReturnDot ) { *flReturnDot = flDot; } if ( flDot < 0.92387f ) return false; if( !FVisible(pEntity) ) return false; return true; } //----------------------------------------------------------------------------- // Purpose: Let NPCs know when the flashlight is trained on them //----------------------------------------------------------------------------- void CHL2_Player::CheckFlashlight( void ) { if ( !FlashlightIsOn() ) return; if ( m_flNextFlashlightCheckTime > gpGlobals->curtime ) return; m_flNextFlashlightCheckTime = gpGlobals->curtime + FLASHLIGHT_NPC_CHECK_INTERVAL; // Loop through NPCs looking for illuminated ones for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ ) { CAI_BaseNPC *pNPC = g_AI_Manager.AccessAIs()[i]; float flDot; if ( IsIlluminatedByFlashlight( pNPC, &flDot ) ) { pNPC->PlayerHasIlluminatedNPC( this, flDot ); } } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::SetPlayerUnderwater( bool state ) { if ( state ) { SuitPower_AddDevice( SuitDeviceBreather ); } else { SuitPower_RemoveDevice( SuitDeviceBreather ); } BaseClass::SetPlayerUnderwater( state ); } //----------------------------------------------------------------------------- bool CHL2_Player::PassesDamageFilter( const CTakeDamageInfo &info ) { CBaseEntity *pAttacker = info.GetAttacker(); if( pAttacker && pAttacker->MyNPCPointer() && pAttacker->MyNPCPointer()->IsPlayerAlly() ) { return false; } if( m_hPlayerProxy && !m_hPlayerProxy->PassesDamageFilter( info ) ) { return false; } return BaseClass::PassesDamageFilter( info ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHL2_Player::SetFlashlightEnabled( bool bState ) { m_bFlashlightDisabled = !bState; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::InputDisableFlashlight( inputdata_t &inputdata ) { if( FlashlightIsOn() ) FlashlightTurnOff(); SetFlashlightEnabled( false ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::InputEnableFlashlight( inputdata_t &inputdata ) { SetFlashlightEnabled( true ); } //----------------------------------------------------------------------------- // Purpose: Prevent the player from taking fall damage for [n] seconds, but // reset back to taking fall damage after the first impact (so players will be // hurt if they bounce off what they hit). This is the original behavior. //----------------------------------------------------------------------------- void CHL2_Player::InputIgnoreFallDamage( inputdata_t &inputdata ) { float timeToIgnore = inputdata.value.Float(); if ( timeToIgnore <= 0.0 ) timeToIgnore = TIME_IGNORE_FALL_DAMAGE; m_flTimeIgnoreFallDamage = gpGlobals->curtime + timeToIgnore; m_bIgnoreFallDamageResetAfterImpact = true; } //----------------------------------------------------------------------------- // Purpose: Absolutely prevent the player from taking fall damage for [n] seconds. //----------------------------------------------------------------------------- void CHL2_Player::InputIgnoreFallDamageWithoutReset( inputdata_t &inputdata ) { float timeToIgnore = inputdata.value.Float(); if ( timeToIgnore <= 0.0 ) timeToIgnore = TIME_IGNORE_FALL_DAMAGE; m_flTimeIgnoreFallDamage = gpGlobals->curtime + timeToIgnore; m_bIgnoreFallDamageResetAfterImpact = false; } //----------------------------------------------------------------------------- // Purpose: Notification of a player's npc ally in the players squad being killed //----------------------------------------------------------------------------- void CHL2_Player::OnSquadMemberKilled( inputdata_t &data ) { // send a message to the client, to notify the hud of the loss CSingleUserRecipientFilter user( this ); user.MakeReliable(); UserMessageBegin( user, "SquadMemberDied" ); MessageEnd(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHL2_Player::NotifyFriendsOfDamage( CBaseEntity *pAttackerEntity ) { CAI_BaseNPC *pAttacker = pAttackerEntity->MyNPCPointer(); if ( pAttacker ) { const Vector &origin = GetAbsOrigin(); for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ ) { const float NEAR_Z = 12*12; const float NEAR_XY_SQ = Square( 50*12 ); CAI_BaseNPC *pNpc = g_AI_Manager.AccessAIs()[i]; if ( pNpc->IsPlayerAlly() ) { const Vector &originNpc = pNpc->GetAbsOrigin(); if ( fabsf( originNpc.z - origin.z ) < NEAR_Z ) { if ( (originNpc.AsVector2D() - origin.AsVector2D()).LengthSqr() < NEAR_XY_SQ ) { pNpc->OnFriendDamaged( this, pAttacker ); } } } } } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- ConVar test_massive_dmg("test_massive_dmg", "30" ); ConVar test_massive_dmg_clip("test_massive_dmg_clip", "0.5" ); int CHL2_Player::OnTakeDamage( const CTakeDamageInfo &info ) { if ( GlobalEntity_GetState( "gordon_invulnerable" ) == GLOBAL_ON ) return 0; // ignore fall damage if instructed to do so by input if ( ( info.GetDamageType() & DMG_FALL ) && m_flTimeIgnoreFallDamage > gpGlobals->curtime ) { // usually, we will reset the input flag after the first impact. However there is another input that // prevents this behavior. if ( m_bIgnoreFallDamageResetAfterImpact ) { m_flTimeIgnoreFallDamage = 0; } return 0; } if( info.GetDamageType() & DMG_BLAST_SURFACE ) { if( GetWaterLevel() > 2 ) { // Don't take blast damage from anything above the surface. if( info.GetInflictor()->GetWaterLevel() == 0 ) { return 0; } } } if ( info.GetDamage() > 0.0f ) { m_flLastDamageTime = gpGlobals->curtime; if ( info.GetAttacker() ) NotifyFriendsOfDamage( info.GetAttacker() ); } // Modify the amount of damage the player takes, based on skill. CTakeDamageInfo playerDamage = info; // Should we run this damage through the skill level adjustment? bool bAdjustForSkillLevel = true; if( info.GetDamageType() == DMG_GENERIC && info.GetAttacker() == this && info.GetInflictor() == this ) { // Only do a skill level adjustment if the player isn't his own attacker AND inflictor. // This prevents damage from SetHealth() inputs from being adjusted for skill level. bAdjustForSkillLevel = false; } if ( GetVehicleEntity() != NULL && GlobalEntity_GetState("gordon_protect_driver") == GLOBAL_ON ) { if( playerDamage.GetDamage() > test_massive_dmg.GetFloat() && playerDamage.GetInflictor() == GetVehicleEntity() && (playerDamage.GetDamageType() & DMG_CRUSH) ) { playerDamage.ScaleDamage( test_massive_dmg_clip.GetFloat() / playerDamage.GetDamage() ); } } if( bAdjustForSkillLevel ) { playerDamage.AdjustPlayerDamageTakenForSkillLevel(); } gamestats->Event_PlayerDamage( this, info ); return BaseClass::OnTakeDamage( playerDamage ); } //----------------------------------------------------------------------------- // Purpose: // Input : &info - //----------------------------------------------------------------------------- int CHL2_Player::OnTakeDamage_Alive( const CTakeDamageInfo &info ) { // Drown if( info.GetDamageType() & DMG_DROWN ) { if( m_idrowndmg == m_idrownrestored ) { EmitSound( "Player.DrownStart" ); } else { EmitSound( "Player.DrownContinue" ); } } // Burnt if ( info.GetDamageType() & DMG_BURN ) { EmitSound( "HL2Player.BurnPain" ); } if( (info.GetDamageType() & DMG_SLASH) && hl2_episodic.GetBool() ) { if( m_afPhysicsFlags & PFLAG_USING ) { // Stop the player using a rotating button for a short time if hit by a creature's melee attack. // This is for the antlion burrow-corking training in EP1 (sjb). SuspendUse( 0.5f ); } } // Call the base class implementation return BaseClass::OnTakeDamage_Alive( info ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::OnDamagedByExplosion( const CTakeDamageInfo &info ) { if ( info.GetInflictor() && info.GetInflictor()->ClassMatches( "mortarshell" ) ) { // No ear ringing for mortar UTIL_ScreenShake( info.GetInflictor()->GetAbsOrigin(), 4.0, 1.0, 0.5, 1000, SHAKE_START, false ); return; } BaseClass::OnDamagedByExplosion( info ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CHL2_Player::ShouldShootMissTarget( CBaseCombatCharacter *pAttacker ) { if( gpGlobals->curtime > m_flTargetFindTime ) { // Put this off into the future again. m_flTargetFindTime = gpGlobals->curtime + random->RandomFloat( 3, 5 ); return true; } return false; } //----------------------------------------------------------------------------- // Purpose: Notifies Alyx that player has put a combine ball into a socket so she can comment on it. // Input : pCombineBall - ball the was socketed //----------------------------------------------------------------------------- void CHL2_Player::CombineBallSocketed( CPropCombineBall *pCombineBall ) { #ifdef HL2_EPISODIC CNPC_Alyx *pAlyx = CNPC_Alyx::GetAlyx(); if ( pAlyx ) { pAlyx->CombineBallSocketed( pCombineBall->NumBounces() ); } #endif } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::Event_KilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info ) { BaseClass::Event_KilledOther( pVictim, info ); #ifdef HL2_EPISODIC CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs(); for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ ) { if ( ppAIs[i] && ppAIs[i]->IRelationType(this) == D_LI ) { ppAIs[i]->OnPlayerKilledOther( pVictim, info ); } } #endif } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::Event_Killed( const CTakeDamageInfo &info ) { BaseClass::Event_Killed( info ); FirePlayerProxyOutput( "PlayerDied", variant_t(), this, this ); NotifyScriptsOfDeath(); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::NotifyScriptsOfDeath( void ) { CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, "scripted_sequence" ); while( pEnt ) { variant_t emptyVariant; pEnt->AcceptInput( "ScriptPlayerDeath", NULL, NULL, emptyVariant, 0 ); pEnt = gEntList.FindEntityByClassname( pEnt, "scripted_sequence" ); } pEnt = gEntList.FindEntityByClassname( NULL, "logic_choreographed_scene" ); while( pEnt ) { variant_t emptyVariant; pEnt->AcceptInput( "ScriptPlayerDeath", NULL, NULL, emptyVariant, 0 ); pEnt = gEntList.FindEntityByClassname( pEnt, "logic_choreographed_scene" ); } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CHL2_Player::GetAutoaimVector( autoaim_params_t ¶ms ) { BaseClass::GetAutoaimVector( params ); if ( IsX360() ) { if( IsInAVehicle() ) { if( m_hLockedAutoAimEntity && m_hLockedAutoAimEntity->IsAlive() && ShouldKeepLockedAutoaimTarget(m_hLockedAutoAimEntity) ) { if( params.m_hAutoAimEntity && params.m_hAutoAimEntity != m_hLockedAutoAimEntity ) { // Autoaim has picked a new target. Switch. m_hLockedAutoAimEntity = params.m_hAutoAimEntity; } // Ignore autoaim and just keep aiming at this target. params.m_hAutoAimEntity = m_hLockedAutoAimEntity; Vector vecTarget = m_hLockedAutoAimEntity->BodyTarget( EyePosition(), false ); Vector vecDir = vecTarget - EyePosition(); VectorNormalize( vecDir ); params.m_vecAutoAimDir = vecDir; params.m_vecAutoAimPoint = vecTarget; return; } else { m_hLockedAutoAimEntity = NULL; } } // If the player manually gets his crosshair onto a target, make that target sticky if( params.m_fScale != AUTOAIM_SCALE_DIRECT_ONLY ) { // Only affect this for 'real' queries //if( params.m_hAutoAimEntity && params.m_bOnTargetNatural ) if( params.m_hAutoAimEntity ) { // Turn on sticky. m_HL2Local.m_bStickyAutoAim = true; if( IsInAVehicle() ) { m_hLockedAutoAimEntity = params.m_hAutoAimEntity; } } else if( !params.m_hAutoAimEntity ) { // Turn off sticky only if there's no target at all. m_HL2Local.m_bStickyAutoAim = false; m_hLockedAutoAimEntity = NULL; } } } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CHL2_Player::ShouldKeepLockedAutoaimTarget( EHANDLE hLockedTarget ) { Vector vecLooking; Vector vecToTarget; vecToTarget = hLockedTarget->WorldSpaceCenter() - EyePosition(); float flDist = vecToTarget.Length2D(); VectorNormalize( vecToTarget ); if( flDist > autoaim_max_dist.GetFloat() ) return false; float flDot; vecLooking = EyeDirection3D(); flDot = DotProduct( vecLooking, vecToTarget ); if( flDot < autoaim_unlock_target.GetFloat() ) return false; return true; } //----------------------------------------------------------------------------- // Purpose: // Input : iCount - // iAmmoIndex - // bSuppressSound - // Output : int //----------------------------------------------------------------------------- int CHL2_Player::GiveAmmo( int nCount, int nAmmoIndex, bool bSuppressSound) { // Don't try to give the player invalid ammo indices. if (nAmmoIndex < 0) return 0; bool bCheckAutoSwitch = false; if (!HasAnyAmmoOfType(nAmmoIndex)) { bCheckAutoSwitch = true; } int nAdd = BaseClass::GiveAmmo(nCount, nAmmoIndex, bSuppressSound); if ( nCount > 0 && nAdd == 0 ) { // we've been denied the pickup, display a hud icon to show that CSingleUserRecipientFilter user( this ); user.MakeReliable(); UserMessageBegin( user, "AmmoDenied" ); WRITE_SHORT( nAmmoIndex ); MessageEnd(); } // // If I was dry on ammo for my best weapon and justed picked up ammo for it, // autoswitch to my best weapon now. // if (bCheckAutoSwitch) { CBaseCombatWeapon *pWeapon = g_pGameRules->GetNextBestWeapon(this, GetActiveWeapon()); if ( pWeapon && pWeapon->GetPrimaryAmmoType() == nAmmoIndex ) { SwitchToNextBestWeapon(GetActiveWeapon()); } } return nAdd; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CHL2_Player::Weapon_CanUse( CBaseCombatWeapon *pWeapon ) { #ifndef HL2MP if ( pWeapon->ClassMatches( "weapon_stunstick" ) ) { if ( ApplyBattery( 0.5 ) ) UTIL_Remove( pWeapon ); return false; } #endif return BaseClass::Weapon_CanUse( pWeapon ); } //----------------------------------------------------------------------------- // Purpose: // Input : *pWeapon - //----------------------------------------------------------------------------- void CHL2_Player::Weapon_Equip( CBaseCombatWeapon *pWeapon ) { #if HL2_SINGLE_PRIMARY_WEAPON_MODE if ( pWeapon->GetSlot() == WEAPON_PRIMARY_SLOT ) { Weapon_DropSlot( WEAPON_PRIMARY_SLOT ); } #endif if( GetActiveWeapon() == NULL ) { m_HL2Local.m_bWeaponLowered = false; } BaseClass::Weapon_Equip( pWeapon ); } //----------------------------------------------------------------------------- // Purpose: Player reacts to bumping a weapon. // Input : pWeapon - the weapon that the player bumped into. // Output : Returns true if player picked up the weapon //----------------------------------------------------------------------------- bool CHL2_Player::BumpWeapon( CBaseCombatWeapon *pWeapon ) { #if HL2_SINGLE_PRIMARY_WEAPON_MODE CBaseCombatCharacter *pOwner = pWeapon->GetOwner(); // Can I have this weapon type? if ( pOwner || !Weapon_CanUse( pWeapon ) || !g_pGameRules->CanHavePlayerItem( this, pWeapon ) ) { if ( gEvilImpulse101 ) { UTIL_Remove( pWeapon ); } return false; } // ---------------------------------------- // If I already have it just take the ammo // ---------------------------------------- if (Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType())) { //Only remove the weapon if we attained ammo from it if ( Weapon_EquipAmmoOnly( pWeapon ) == false ) return false; // Only remove me if I have no ammo left // Can't just check HasAnyAmmo because if I don't use clips, I want to be removed, if ( pWeapon->UsesClipsForAmmo1() && pWeapon->HasPrimaryAmmo() ) return false; UTIL_Remove( pWeapon ); return false; } // ------------------------- // Otherwise take the weapon // ------------------------- else { //Make sure we're not trying to take a new weapon type we already have if ( Weapon_SlotOccupied( pWeapon ) ) { CBaseCombatWeapon *pActiveWeapon = Weapon_GetSlot( WEAPON_PRIMARY_SLOT ); if ( pActiveWeapon != NULL && pActiveWeapon->HasAnyAmmo() == false && Weapon_CanSwitchTo( pWeapon ) ) { Weapon_Equip( pWeapon ); return true; } //Attempt to take ammo if this is the gun we're holding already if ( Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType() ) ) { Weapon_EquipAmmoOnly( pWeapon ); } return false; } pWeapon->CheckRespawn(); pWeapon->AddSolidFlags( FSOLID_NOT_SOLID ); pWeapon->AddEffects( EF_NODRAW ); Weapon_Equip( pWeapon ); EmitSound( "HL2Player.PickupWeapon" ); return true; } #else return BaseClass::BumpWeapon( pWeapon ); #endif } //----------------------------------------------------------------------------- // Purpose: // Input : *cmd - // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CHL2_Player::ClientCommand( const CCommand &args ) { #if HL2_SINGLE_PRIMARY_WEAPON_MODE //Drop primary weapon if ( !Q_stricmp( args[0], "DropPrimary" ) ) { Weapon_DropSlot( WEAPON_PRIMARY_SLOT ); return true; } #endif if ( !Q_stricmp( args[0], "emit" ) ) { CSingleUserRecipientFilter filter( this ); if ( args.ArgC() > 1 ) { EmitSound( filter, entindex(), args[ 1 ] ); } else { EmitSound( filter, entindex(), "Test.Sound" ); } return true; } return BaseClass::ClientCommand( args ); } //----------------------------------------------------------------------------- // Purpose: // Output : void CBasePlayer::PlayerUse //----------------------------------------------------------------------------- void CHL2_Player::PlayerUse ( void ) { // Was use pressed or released? if ( ! ((m_nButtons | m_afButtonPressed | m_afButtonReleased) & IN_USE) ) return; if ( m_afButtonPressed & IN_USE ) { // Currently using a latched entity? if ( ClearUseEntity() ) { return; } else { if ( m_afPhysicsFlags & PFLAG_DIROVERRIDE ) { m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE; m_iTrain = TRAIN_NEW|TRAIN_OFF; return; } else { // Start controlling the train! CBaseEntity *pTrain = GetGroundEntity(); if ( pTrain && !(m_nButtons & IN_JUMP) && (GetFlags() & FL_ONGROUND) && (pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) && pTrain->OnControls(this) ) { m_afPhysicsFlags |= PFLAG_DIROVERRIDE; m_iTrain = TrainSpeed(pTrain->m_flSpeed, ((CFuncTrackTrain*)pTrain)->GetMaxSpeed()); m_iTrain |= TRAIN_NEW; EmitSound( "HL2Player.TrainUse" ); return; } } } // Tracker 3926: We can't +USE something if we're climbing a ladder if ( GetMoveType() == MOVETYPE_LADDER ) { return; } } if( m_flTimeUseSuspended > gpGlobals->curtime ) { // Something has temporarily stopped us being able to USE things. // Obviously, this should be used very carefully.(sjb) return; } CBaseEntity *pUseEntity = FindUseEntity(); bool usedSomething = false; // Found an object if ( pUseEntity ) { //!!!UNDONE: traceline here to prevent +USEing buttons through walls int caps = pUseEntity->ObjectCaps(); variant_t emptyVariant; if ( m_afButtonPressed & IN_USE ) { // Robin: Don't play sounds for NPCs, because NPCs will allow respond with speech. if ( !pUseEntity->MyNPCPointer() ) { EmitSound( "HL2Player.Use" ); } } if ( ( (m_nButtons & IN_USE) && (caps & FCAP_CONTINUOUS_USE) ) || ( (m_afButtonPressed & IN_USE) && (caps & (FCAP_IMPULSE_USE|FCAP_ONOFF_USE)) ) ) { if ( caps & FCAP_CONTINUOUS_USE ) m_afPhysicsFlags |= PFLAG_USING; pUseEntity->AcceptInput( "Use", this, this, emptyVariant, USE_TOGGLE ); usedSomething = true; } // UNDONE: Send different USE codes for ON/OFF. Cache last ONOFF_USE object to send 'off' if you turn away else if ( (m_afButtonReleased & IN_USE) && (pUseEntity->ObjectCaps() & FCAP_ONOFF_USE) ) // BUGBUG This is an "off" use { pUseEntity->AcceptInput( "Use", this, this, emptyVariant, USE_TOGGLE ); usedSomething = true; } #if HL2_SINGLE_PRIMARY_WEAPON_MODE //Check for weapon pick-up if ( m_afButtonPressed & IN_USE ) { CBaseCombatWeapon *pWeapon = dynamic_cast(pUseEntity); if ( ( pWeapon != NULL ) && ( Weapon_CanSwitchTo( pWeapon ) ) ) { //Try to take ammo or swap the weapon if ( Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType() ) ) { Weapon_EquipAmmoOnly( pWeapon ); } else { Weapon_DropSlot( pWeapon->GetSlot() ); Weapon_Equip( pWeapon ); } usedSomething = true; } } #endif } else if ( m_afButtonPressed & IN_USE ) { // Signal that we want to play the deny sound, unless the user is +USEing on a ladder! // The sound is emitted in ItemPostFrame, since that occurs after GameMovement::ProcessMove which // lets the ladder code unset this flag. m_bPlayUseDenySound = true; } // Debounce the use key if ( usedSomething && pUseEntity ) { m_Local.m_nOldButtons |= IN_USE; m_afButtonPressed &= ~IN_USE; } } ConVar sv_show_crosshair_target( "sv_show_crosshair_target", "0" ); //----------------------------------------------------------------------------- // Purpose: Updates the posture of the weapon from lowered to ready //----------------------------------------------------------------------------- void CHL2_Player::UpdateWeaponPosture( void ) { CBaseCombatWeapon *pWeapon = dynamic_cast(GetActiveWeapon()); if ( pWeapon && m_LowerWeaponTimer.Expired() && pWeapon->CanLower() ) { m_LowerWeaponTimer.Set( .3 ); VPROF( "CHL2_Player::UpdateWeaponPosture-CheckLower" ); Vector vecAim = BaseClass::GetAutoaimVector( AUTOAIM_SCALE_DIRECT_ONLY ); const float CHECK_FRIENDLY_RANGE = 50 * 12; trace_t tr; UTIL_TraceLine( EyePosition(), EyePosition() + vecAim * CHECK_FRIENDLY_RANGE, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr ); CBaseEntity *aimTarget = tr.m_pEnt; //If we're over something if ( aimTarget && !tr.DidHitWorld() ) { if ( !aimTarget->IsNPC() || aimTarget->MyNPCPointer()->GetState() != NPC_STATE_COMBAT ) { Disposition_t dis = IRelationType( aimTarget ); //Debug info for seeing what an object "cons" as if ( sv_show_crosshair_target.GetBool() ) { int text_offset = BaseClass::DrawDebugTextOverlays(); char tempstr[255]; switch ( dis ) { case D_LI: Q_snprintf( tempstr, sizeof(tempstr), "Disposition: Like" ); break; case D_HT: Q_snprintf( tempstr, sizeof(tempstr), "Disposition: Hate" ); break; case D_FR: Q_snprintf( tempstr, sizeof(tempstr), "Disposition: Fear" ); break; case D_NU: Q_snprintf( tempstr, sizeof(tempstr), "Disposition: Neutral" ); break; default: case D_ER: Q_snprintf( tempstr, sizeof(tempstr), "Disposition: !!!ERROR!!!" ); break; } //Draw the text NDebugOverlay::EntityText( aimTarget->entindex(), text_offset, tempstr, 0 ); } //See if we hates it if ( dis == D_LI ) { //We're over a friendly, drop our weapon if ( Weapon_Lower() == false ) { //FIXME: We couldn't lower our weapon! } return; } } } if ( Weapon_Ready() == false ) { //FIXME: We couldn't raise our weapon! } } if( g_pGameRules->GetAutoAimMode() != AUTOAIM_NONE ) { if( !pWeapon ) { // This tells the client to draw no crosshair m_HL2Local.m_bWeaponLowered = true; return; } else { if( !pWeapon->CanLower() && m_HL2Local.m_bWeaponLowered ) m_HL2Local.m_bWeaponLowered = false; } if( !m_AutoaimTimer.Expired() ) return; m_AutoaimTimer.Set( .1 ); VPROF( "hl2_x360_aiming" ); // Call the autoaim code to update the local player data, which allows the client to update. autoaim_params_t params; params.m_vecAutoAimPoint.Init(); params.m_vecAutoAimDir.Init(); params.m_fScale = AUTOAIM_SCALE_DEFAULT; params.m_fMaxDist = autoaim_max_dist.GetFloat(); GetAutoaimVector( params ); m_HL2Local.m_hAutoAimTarget.Set( params.m_hAutoAimEntity ); m_HL2Local.m_vecAutoAimPoint.Set( params.m_vecAutoAimPoint ); m_HL2Local.m_bAutoAimTarget = ( params.m_bAutoAimAssisting || params.m_bOnTargetNatural ); return; } else { // Make sure there's no residual autoaim target if the user changes the xbox_aiming convar on the fly. m_HL2Local.m_hAutoAimTarget.Set(NULL); } } //----------------------------------------------------------------------------- // Purpose: Lowers the weapon posture (for hovering over friendlies) // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CHL2_Player::Weapon_Lower( void ) { VPROF( "CHL2_Player::Weapon_Lower" ); // Already lowered? if ( m_HL2Local.m_bWeaponLowered ) return true; m_HL2Local.m_bWeaponLowered = true; CBaseCombatWeapon *pWeapon = dynamic_cast(GetActiveWeapon()); if ( pWeapon == NULL ) return false; return pWeapon->Lower(); } //----------------------------------------------------------------------------- // Purpose: Returns the weapon posture to normal // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CHL2_Player::Weapon_Ready( void ) { VPROF( "CHL2_Player::Weapon_Ready" ); // Already ready? if ( m_HL2Local.m_bWeaponLowered == false ) return true; m_HL2Local.m_bWeaponLowered = false; CBaseCombatWeapon *pWeapon = dynamic_cast(GetActiveWeapon()); if ( pWeapon == NULL ) return false; return pWeapon->Ready(); } //----------------------------------------------------------------------------- // Purpose: Returns whether or not we can switch to the given weapon. // Input : pWeapon - //----------------------------------------------------------------------------- bool CHL2_Player::Weapon_CanSwitchTo( CBaseCombatWeapon *pWeapon ) { CBasePlayer *pPlayer = (CBasePlayer *)this; #if !defined( CLIENT_DLL ) IServerVehicle *pVehicle = pPlayer->GetVehicle(); #else IClientVehicle *pVehicle = pPlayer->GetVehicle(); #endif if (pVehicle && !pPlayer->UsingStandardWeaponsInVehicle()) return false; if ( !pWeapon->HasAnyAmmo() && !GetAmmoCount( pWeapon->m_iPrimaryAmmoType ) ) return false; if ( !pWeapon->CanDeploy() ) return false; if ( GetActiveWeapon() ) { if ( PhysCannonGetHeldEntity( GetActiveWeapon() ) == pWeapon && Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType()) ) { return true; } if ( !GetActiveWeapon()->CanHolster() ) return false; } return true; } void CHL2_Player::PickupObject( CBaseEntity *pObject, bool bLimitMassAndSize ) { // can't pick up what you're standing on if ( GetGroundEntity() == pObject ) return; if ( bLimitMassAndSize == true ) { if ( CBasePlayer::CanPickupObject( pObject, 35, 128 ) == false ) return; } // Can't be picked up if NPCs are on me if ( pObject->HasNPCsOnIt() ) return; PlayerPickupObject( this, pObject ); } //----------------------------------------------------------------------------- // Purpose: // Output : CBaseEntity //----------------------------------------------------------------------------- bool CHL2_Player::IsHoldingEntity( CBaseEntity *pEnt ) { return PlayerPickupControllerIsHoldingEntity( m_hUseEntity, pEnt ); } float CHL2_Player::GetHeldObjectMass( IPhysicsObject *pHeldObject ) { float mass = PlayerPickupGetHeldObjectMass( m_hUseEntity, pHeldObject ); if ( mass == 0.0f ) { mass = PhysCannonGetHeldObjectMass( GetActiveWeapon(), pHeldObject ); } return mass; } //----------------------------------------------------------------------------- // Purpose: Force the player to drop any physics objects he's carrying //----------------------------------------------------------------------------- void CHL2_Player::ForceDropOfCarriedPhysObjects( CBaseEntity *pOnlyIfHoldingThis ) { if ( PhysIsInCallback() ) { variant_t value; g_EventQueue.AddEvent( this, "ForceDropPhysObjects", value, 0.01f, pOnlyIfHoldingThis, this ); return; } #ifdef HL2_EPISODIC if ( hl2_episodic.GetBool() ) { CBaseEntity *pHeldEntity = PhysCannonGetHeldEntity( GetActiveWeapon() ); if( pHeldEntity && pHeldEntity->ClassMatches( "grenade_helicopter" ) ) { return; } } #endif // Drop any objects being handheld. ClearUseEntity(); // Then force the physcannon to drop anything it's holding, if it's our active weapon PhysCannonForceDrop( GetActiveWeapon(), NULL ); } void CHL2_Player::InputForceDropPhysObjects( inputdata_t &data ) { ForceDropOfCarriedPhysObjects( data.pActivator ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CHL2_Player::UpdateClientData( void ) { if (m_DmgTake || m_DmgSave || m_bitsHUDDamage != m_bitsDamageType) { // Comes from inside me if not set Vector damageOrigin = GetLocalOrigin(); // send "damage" message // causes screen to flash, and pain compass to show direction of damage damageOrigin = m_DmgOrigin; // only send down damage type that have hud art int iShowHudDamage = g_pGameRules->Damage_GetShowOnHud(); int visibleDamageBits = m_bitsDamageType & iShowHudDamage; m_DmgTake = clamp( m_DmgTake, 0, 255 ); m_DmgSave = clamp( m_DmgSave, 0, 255 ); // If we're poisoned, but it wasn't this frame, don't send the indicator // Without this check, any damage that occured to the player while they were // recovering from a poison bite would register as poisonous as well and flash // the whole screen! -- jdw if ( visibleDamageBits & DMG_POISON ) { float flLastPoisonedDelta = gpGlobals->curtime - m_tbdPrev; if ( flLastPoisonedDelta > 0.1f ) { visibleDamageBits &= ~DMG_POISON; } } CSingleUserRecipientFilter user( this ); user.MakeReliable(); UserMessageBegin( user, "Damage" ); WRITE_BYTE( m_DmgSave ); WRITE_BYTE( m_DmgTake ); WRITE_LONG( visibleDamageBits ); WRITE_FLOAT( damageOrigin.x ); //BUG: Should be fixed point (to hud) not floats WRITE_FLOAT( damageOrigin.y ); //BUG: However, the HUD does _not_ implement bitfield messages (yet) WRITE_FLOAT( damageOrigin.z ); //BUG: We use WRITE_VEC3COORD for everything else MessageEnd(); m_DmgTake = 0; m_DmgSave = 0; m_bitsHUDDamage = m_bitsDamageType; // Clear off non-time-based damage indicators int iTimeBasedDamage = g_pGameRules->Damage_GetTimeBased(); m_bitsDamageType &= iTimeBasedDamage; } // Update Flashlight #ifdef HL2_EPISODIC if ( Flashlight_UseLegacyVersion() == false ) { if ( FlashlightIsOn() && sv_infinite_aux_power.GetBool() == false ) { m_HL2Local.m_flFlashBattery -= FLASH_DRAIN_TIME * gpGlobals->frametime; if ( m_HL2Local.m_flFlashBattery < 0.0f ) { FlashlightTurnOff(); m_HL2Local.m_flFlashBattery = 0.0f; } } else { m_HL2Local.m_flFlashBattery += FLASH_CHARGE_TIME * gpGlobals->frametime; if ( m_HL2Local.m_flFlashBattery > 100.0f ) { m_HL2Local.m_flFlashBattery = 100.0f; } } } else { m_HL2Local.m_flFlashBattery = -1.0f; } #endif // HL2_EPISODIC BaseClass::UpdateClientData(); } //--------------------------------------------------------- //--------------------------------------------------------- void CHL2_Player::OnRestore() { BaseClass::OnRestore(); m_pPlayerAISquad = g_AI_SquadManager.FindCreateSquad(AllocPooledString(PLAYER_SQUADNAME)); } //--------------------------------------------------------- //--------------------------------------------------------- Vector CHL2_Player::EyeDirection2D( void ) { Vector vecReturn = EyeDirection3D(); vecReturn.z = 0; vecReturn.AsVector2D().NormalizeInPlace(); return vecReturn; } //--------------------------------------------------------- //--------------------------------------------------------- Vector CHL2_Player::EyeDirection3D( void ) { Vector vecForward; // Return the vehicle angles if we request them if ( GetVehicle() != NULL ) { CacheVehicleView(); EyeVectors( &vecForward ); return vecForward; } AngleVectors( EyeAngles(), &vecForward ); return vecForward; } //--------------------------------------------------------- //--------------------------------------------------------- bool CHL2_Player::Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex ) { MDLCACHE_CRITICAL_SECTION(); // Recalculate proficiency! SetCurrentWeaponProficiency( CalcWeaponProficiency( pWeapon ) ); // Come out of suit zoom mode if ( IsZooming() ) { StopZooming(); } return BaseClass::Weapon_Switch( pWeapon, viewmodelindex ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- WeaponProficiency_t CHL2_Player::CalcWeaponProficiency( CBaseCombatWeapon *pWeapon ) { WeaponProficiency_t proficiency; proficiency = WEAPON_PROFICIENCY_PERFECT; if( weapon_showproficiency.GetBool() != 0 ) { Msg("Player switched to %s, proficiency is %s\n", pWeapon->GetClassname(), GetWeaponProficiencyName( proficiency ) ); } return proficiency; } //----------------------------------------------------------------------------- // Purpose: override how single player rays hit the player //----------------------------------------------------------------------------- bool LineCircleIntersection( const Vector2D ¢er, const float radius, const Vector2D &vLinePt, const Vector2D &vLineDir, float *fIntersection1, float *fIntersection2) { // Line = P + Vt // Sphere = r (assume we've translated to origin) // (P + Vt)^2 = r^2 // VVt^2 + 2PVt + (PP - r^2) // Solve as quadratic: (-b +/- sqrt(b^2 - 4ac)) / 2a // If (b^2 - 4ac) is < 0 there is no solution. // If (b^2 - 4ac) is = 0 there is one solution (a case this function doesn't support). // If (b^2 - 4ac) is > 0 there are two solutions. Vector2D P; float a, b, c, sqr, insideSqr; // Translate circle to origin. P[0] = vLinePt[0] - center[0]; P[1] = vLinePt[1] - center[1]; a = vLineDir.Dot(vLineDir); b = 2.0f * P.Dot(vLineDir); c = P.Dot(P) - (radius * radius); insideSqr = b*b - 4*a*c; if(insideSqr <= 0.000001f) return false; // Ok, two solutions. sqr = (float)FastSqrt(insideSqr); float denom = 1.0 / (2.0f * a); *fIntersection1 = (-b - sqr) * denom; *fIntersection2 = (-b + sqr) * denom; return true; } static void Collision_ClearTrace( const Vector &vecRayStart, const Vector &vecRayDelta, CBaseTrace *pTrace ) { pTrace->startpos = vecRayStart; pTrace->endpos = vecRayStart; pTrace->endpos += vecRayDelta; pTrace->startsolid = false; pTrace->allsolid = false; pTrace->fraction = 1.0f; pTrace->contents = 0; } bool IntersectRayWithAACylinder( const Ray_t &ray, const Vector ¢er, float radius, float height, CBaseTrace *pTrace ) { Assert( ray.m_IsRay ); Collision_ClearTrace( ray.m_Start, ray.m_Delta, pTrace ); // First intersect the ray with the top + bottom planes float halfHeight = height * 0.5; // Handle parallel case Vector vStart = ray.m_Start - center; Vector vEnd = vStart + ray.m_Delta; float flEnterFrac, flLeaveFrac; if (FloatMakePositive(ray.m_Delta.z) < 1e-8) { if ( (vStart.z < -halfHeight) || (vStart.z > halfHeight) ) { return false; // no hit } flEnterFrac = 0.0f; flLeaveFrac = 1.0f; } else { // Clip the ray to the top and bottom of box flEnterFrac = IntersectRayWithAAPlane( vStart, vEnd, 2, 1, halfHeight); flLeaveFrac = IntersectRayWithAAPlane( vStart, vEnd, 2, 1, -halfHeight); if ( flLeaveFrac < flEnterFrac ) { float temp = flLeaveFrac; flLeaveFrac = flEnterFrac; flEnterFrac = temp; } if ( flLeaveFrac < 0 || flEnterFrac > 1) { return false; } } // Intersect with circle float flCircleEnterFrac, flCircleLeaveFrac; if ( !LineCircleIntersection( vec3_origin.AsVector2D(), radius, vStart.AsVector2D(), ray.m_Delta.AsVector2D(), &flCircleEnterFrac, &flCircleLeaveFrac ) ) { return false; // no hit } Assert( flCircleEnterFrac <= flCircleLeaveFrac ); if ( flCircleLeaveFrac < 0 || flCircleEnterFrac > 1) { return false; } if ( flEnterFrac < flCircleEnterFrac ) flEnterFrac = flCircleEnterFrac; if ( flLeaveFrac > flCircleLeaveFrac ) flLeaveFrac = flCircleLeaveFrac; if ( flLeaveFrac < flEnterFrac ) return false; VectorMA( ray.m_Start, flEnterFrac , ray.m_Delta, pTrace->endpos ); pTrace->fraction = flEnterFrac; pTrace->contents = CONTENTS_SOLID; // Calculate the point on our center line where we're nearest the intersection point Vector collisionCenter; CalcClosestPointOnLineSegment( pTrace->endpos, center + Vector( 0, 0, halfHeight ), center - Vector( 0, 0, halfHeight ), collisionCenter ); // Our normal is the direction from that center point to the intersection point pTrace->plane.normal = pTrace->endpos - collisionCenter; VectorNormalize( pTrace->plane.normal ); return true; } bool CHL2_Player::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ) { if( g_pGameRules->IsMultiplayer() ) { return BaseClass::TestHitboxes( ray, fContentsMask, tr ); } else { Assert( ray.m_IsRay ); Vector mins, maxs; mins = WorldAlignMins(); maxs = WorldAlignMaxs(); if ( IntersectRayWithAACylinder( ray, WorldSpaceCenter(), maxs.x * PLAYER_HULL_REDUCTION, maxs.z - mins.z, &tr ) ) { tr.hitbox = 0; CStudioHdr *pStudioHdr = GetModelPtr( ); if (!pStudioHdr) return false; mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( m_nHitboxSet ); if ( !set || !set->numhitboxes ) return false; mstudiobbox_t *pbox = set->pHitbox( tr.hitbox ); mstudiobone_t *pBone = pStudioHdr->pBone(pbox->bone); tr.surface.name = "**studio**"; tr.surface.flags = SURF_HITBOX; tr.surface.surfaceProps = physprops->GetSurfaceIndex( pBone->pszSurfaceProp() ); } return true; } } //--------------------------------------------------------- // Show the player's scaled down bbox that we use for // bullet impacts. //--------------------------------------------------------- void CHL2_Player::DrawDebugGeometryOverlays(void) { BaseClass::DrawDebugGeometryOverlays(); if (m_debugOverlays & OVERLAY_BBOX_BIT) { Vector mins, maxs; mins = WorldAlignMins(); maxs = WorldAlignMaxs(); mins.x *= PLAYER_HULL_REDUCTION; mins.y *= PLAYER_HULL_REDUCTION; maxs.x *= PLAYER_HULL_REDUCTION; maxs.y *= PLAYER_HULL_REDUCTION; NDebugOverlay::Box( GetAbsOrigin(), mins, maxs, 255, 0, 0, 100, 0 ); } } //----------------------------------------------------------------------------- // Purpose: Helper to remove from ladder //----------------------------------------------------------------------------- void CHL2_Player::ExitLadder() { if ( MOVETYPE_LADDER != GetMoveType() ) return; SetMoveType( MOVETYPE_WALK ); SetMoveCollide( MOVECOLLIDE_DEFAULT ); // Remove from ladder m_HL2Local.m_hLadder.Set( NULL ); } surfacedata_t *CHL2_Player::GetLadderSurface( const Vector &origin ) { extern const char *FuncLadder_GetSurfaceprops(CBaseEntity *pLadderEntity); CBaseEntity *pLadder = m_HL2Local.m_hLadder.Get(); if ( pLadder ) { const char *pSurfaceprops = FuncLadder_GetSurfaceprops(pLadder); // get ladder material from func_ladder return physprops->GetSurfaceData( physprops->GetSurfaceIndex( pSurfaceprops ) ); } return BaseClass::GetLadderSurface(origin); } //----------------------------------------------------------------------------- // Purpose: Queues up a use deny sound, played in ItemPostFrame. //----------------------------------------------------------------------------- void CHL2_Player::PlayUseDenySound() { m_bPlayUseDenySound = true; } void CHL2_Player::ItemPostFrame() { BaseClass::ItemPostFrame(); if ( m_bPlayUseDenySound ) { m_bPlayUseDenySound = false; EmitSound( "HL2Player.UseDeny" ); } } void CHL2_Player::StartWaterDeathSounds( void ) { CPASAttenuationFilter filter( this ); if ( m_sndLeeches == NULL ) { m_sndLeeches = (CSoundEnvelopeController::GetController()).SoundCreate( filter, entindex(), CHAN_STATIC, "coast.leech_bites_loop" , ATTN_NORM ); } if ( m_sndLeeches ) { (CSoundEnvelopeController::GetController()).Play( m_sndLeeches, 1.0f, 100 ); } if ( m_sndWaterSplashes == NULL ) { m_sndWaterSplashes = (CSoundEnvelopeController::GetController()).SoundCreate( filter, entindex(), CHAN_STATIC, "coast.leech_water_churn_loop" , ATTN_NORM ); } if ( m_sndWaterSplashes ) { (CSoundEnvelopeController::GetController()).Play( m_sndWaterSplashes, 1.0f, 100 ); } } void CHL2_Player::StopWaterDeathSounds( void ) { if ( m_sndLeeches ) { (CSoundEnvelopeController::GetController()).SoundFadeOut( m_sndLeeches, 0.5f, true ); m_sndLeeches = NULL; } if ( m_sndWaterSplashes ) { (CSoundEnvelopeController::GetController()).SoundFadeOut( m_sndWaterSplashes, 0.5f, true ); m_sndWaterSplashes = NULL; } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CHL2_Player::MissedAR2AltFire() { if( GetPlayerProxy() != NULL ) { GetPlayerProxy()->m_PlayerMissedAR2AltFire.FireOutput( this, this ); } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CHL2_Player::DisplayLadderHudHint() { #if !defined( CLIENT_DLL ) if( gpGlobals->curtime > m_flTimeNextLadderHint ) { m_flTimeNextLadderHint = gpGlobals->curtime + 60.0f; CFmtStr hint; hint.sprintf( "#Valve_Hint_Ladder" ); UTIL_HudHintText( this, hint.Access() ); } #endif//CLIENT_DLL } //----------------------------------------------------------------------------- // Shuts down sounds //----------------------------------------------------------------------------- void CHL2_Player::StopLoopingSounds( void ) { if ( m_sndLeeches != NULL ) { (CSoundEnvelopeController::GetController()).SoundDestroy( m_sndLeeches ); m_sndLeeches = NULL; } if ( m_sndWaterSplashes != NULL ) { (CSoundEnvelopeController::GetController()).SoundDestroy( m_sndWaterSplashes ); m_sndWaterSplashes = NULL; } BaseClass::StopLoopingSounds(); } //----------------------------------------------------------------------------- void CHL2_Player::ModifyOrAppendPlayerCriteria( AI_CriteriaSet& set ) { BaseClass::ModifyOrAppendPlayerCriteria( set ); if ( GlobalEntity_GetIndex( "gordon_precriminal" ) == -1 ) { set.AppendCriteria( "gordon_precriminal", "0" ); } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- const impactdamagetable_t &CHL2_Player::GetPhysicsImpactDamageTable() { if ( m_bUseCappedPhysicsDamageTable ) return gCappedPlayerImpactDamageTable; return BaseClass::GetPhysicsImpactDamageTable(); } //----------------------------------------------------------------------------- // Purpose: Makes a splash when the player transitions between water states //----------------------------------------------------------------------------- void CHL2_Player::Splash( void ) { CEffectData data; data.m_fFlags = 0; data.m_vOrigin = GetAbsOrigin(); data.m_vNormal = Vector(0,0,1); data.m_vAngles = QAngle( 0, 0, 0 ); if ( GetWaterType() & CONTENTS_SLIME ) { data.m_fFlags |= FX_WATER_IN_SLIME; } float flSpeed = GetAbsVelocity().Length(); if ( flSpeed < 300 ) { data.m_flScale = random->RandomFloat( 10, 12 ); DispatchEffect( "waterripple", data ); } else { data.m_flScale = random->RandomFloat( 6, 8 ); DispatchEffect( "watersplash", data ); } } CLogicPlayerProxy *CHL2_Player::GetPlayerProxy( void ) { CLogicPlayerProxy *pProxy = dynamic_cast< CLogicPlayerProxy* > ( m_hPlayerProxy.Get() ); if ( pProxy == NULL ) { pProxy = (CLogicPlayerProxy*)gEntList.FindEntityByClassname(NULL, "logic_playerproxy" ); if ( pProxy == NULL ) return NULL; pProxy->m_hPlayer = this; m_hPlayerProxy = pProxy; } return pProxy; } void CHL2_Player::FirePlayerProxyOutput( const char *pszOutputName, variant_t variant, CBaseEntity *pActivator, CBaseEntity *pCaller ) { if ( GetPlayerProxy() == NULL ) return; GetPlayerProxy()->FireNamedOutput( pszOutputName, variant, pActivator, pCaller ); } LINK_ENTITY_TO_CLASS( logic_playerproxy, CLogicPlayerProxy); BEGIN_DATADESC( CLogicPlayerProxy ) DEFINE_OUTPUT( m_OnFlashlightOn, "OnFlashlightOn" ), DEFINE_OUTPUT( m_OnFlashlightOff, "OnFlashlightOff" ), DEFINE_OUTPUT( m_RequestedPlayerHealth, "PlayerHealth" ), DEFINE_OUTPUT( m_PlayerHasAmmo, "PlayerHasAmmo" ), DEFINE_OUTPUT( m_PlayerHasNoAmmo, "PlayerHasNoAmmo" ), DEFINE_OUTPUT( m_PlayerDied, "PlayerDied" ), DEFINE_OUTPUT( m_PlayerMissedAR2AltFire, "PlayerMissedAR2AltFire" ), DEFINE_INPUTFUNC( FIELD_VOID, "RequestPlayerHealth", InputRequestPlayerHealth ), DEFINE_INPUTFUNC( FIELD_VOID, "SetFlashlightSlowDrain", InputSetFlashlightSlowDrain ), DEFINE_INPUTFUNC( FIELD_VOID, "SetFlashlightNormalDrain", InputSetFlashlightNormalDrain ), DEFINE_INPUTFUNC( FIELD_INTEGER, "SetPlayerHealth", InputSetPlayerHealth ), DEFINE_INPUTFUNC( FIELD_VOID, "RequestAmmoState", InputRequestAmmoState ), DEFINE_INPUTFUNC( FIELD_VOID, "LowerWeapon", InputLowerWeapon ), DEFINE_INPUTFUNC( FIELD_VOID, "EnableCappedPhysicsDamage", InputEnableCappedPhysicsDamage ), DEFINE_INPUTFUNC( FIELD_VOID, "DisableCappedPhysicsDamage", InputDisableCappedPhysicsDamage ), DEFINE_INPUTFUNC( FIELD_STRING, "SetLocatorTargetEntity", InputSetLocatorTargetEntity ), #ifdef PORTAL DEFINE_INPUTFUNC( FIELD_VOID, "SuppressCrosshair", InputSuppressCrosshair ), #endif // PORTAL DEFINE_FIELD( m_hPlayer, FIELD_EHANDLE ), END_DATADESC() void CLogicPlayerProxy::Activate( void ) { BaseClass::Activate(); if ( m_hPlayer == NULL ) { m_hPlayer = AI_GetSinglePlayer(); } } bool CLogicPlayerProxy::PassesDamageFilter( const CTakeDamageInfo &info ) { if (m_hDamageFilter) { CBaseFilter *pFilter = (CBaseFilter *)(m_hDamageFilter.Get()); return pFilter->PassesDamageFilter(info); } return true; } void CLogicPlayerProxy::InputSetPlayerHealth( inputdata_t &inputdata ) { if ( m_hPlayer == NULL ) return; m_hPlayer->SetHealth( inputdata.value.Int() ); } void CLogicPlayerProxy::InputRequestPlayerHealth( inputdata_t &inputdata ) { if ( m_hPlayer == NULL ) return; m_RequestedPlayerHealth.Set( m_hPlayer->GetHealth(), inputdata.pActivator, inputdata.pCaller ); } void CLogicPlayerProxy::InputSetFlashlightSlowDrain( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CHL2_Player *pPlayer = dynamic_cast(m_hPlayer.Get()); if( pPlayer ) pPlayer->SetFlashlightPowerDrainScale( hl2_darkness_flashlight_factor.GetFloat() ); } void CLogicPlayerProxy::InputSetFlashlightNormalDrain( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CHL2_Player *pPlayer = dynamic_cast(m_hPlayer.Get()); if( pPlayer ) pPlayer->SetFlashlightPowerDrainScale( 1.0f ); } void CLogicPlayerProxy::InputRequestAmmoState( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CHL2_Player *pPlayer = dynamic_cast(m_hPlayer.Get()); for ( int i = 0 ; i < pPlayer->WeaponCount(); ++i ) { CBaseCombatWeapon* pCheck = pPlayer->GetWeapon( i ); if ( pCheck ) { if ( pCheck->HasAnyAmmo() && (pCheck->UsesPrimaryAmmo() || pCheck->UsesSecondaryAmmo())) { m_PlayerHasAmmo.FireOutput( this, this, 0 ); return; } } } m_PlayerHasNoAmmo.FireOutput( this, this, 0 ); } void CLogicPlayerProxy::InputLowerWeapon( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CHL2_Player *pPlayer = dynamic_cast(m_hPlayer.Get()); pPlayer->Weapon_Lower(); } void CLogicPlayerProxy::InputEnableCappedPhysicsDamage( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CHL2_Player *pPlayer = dynamic_cast(m_hPlayer.Get()); pPlayer->EnableCappedPhysicsDamage(); } void CLogicPlayerProxy::InputDisableCappedPhysicsDamage( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CHL2_Player *pPlayer = dynamic_cast(m_hPlayer.Get()); pPlayer->DisableCappedPhysicsDamage(); } void CLogicPlayerProxy::InputSetLocatorTargetEntity( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CBaseEntity *pTarget = NULL; // assume no target string_t iszTarget = MAKE_STRING( inputdata.value.String() ); if( iszTarget != NULL_STRING ) { pTarget = gEntList.FindEntityByName( NULL, iszTarget ); } CHL2_Player *pPlayer = dynamic_cast(m_hPlayer.Get()); pPlayer->SetLocatorTargetEntity(pTarget); } #ifdef PORTAL void CLogicPlayerProxy::InputSuppressCrosshair( inputdata_t &inputdata ) { if( m_hPlayer == NULL ) return; CPortal_Player *pPlayer = ToPortalPlayer(m_hPlayer.Get()); pPlayer->SuppressCrosshair( true ); } #endif // PORTAL