//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "c_cs_player.h"
#include "c_user_message_register.h"
#include "view.h"
#include "iclientvehicle.h"
#include "ivieweffects.h"
#include "input.h"
#include "IEffects.h"
#include "fx.h"
#include "c_basetempentity.h"
#include "hud_macros.h" //HOOK_COMMAND
#include "engine/ivdebugoverlay.h"
#include "smoke_fog_overlay.h"
#include "bone_setup.h"
#include "in_buttons.h"
#include "r_efx.h"
#include "dlight.h"
#include "shake.h"
#include "cl_animevent.h"
#include "c_physicsprop.h"
#include "props_shared.h"
#include "obstacle_pushaway.h"
#include "death_pose.h"
#include "effect_dispatch_data.h" //for water ripple / splash effect
#include "c_te_effect_dispatch.h" //ditto
#include "c_te_legacytempents.h"
#include "cs_gamerules.h"
#include "fx_cs_blood.h"
#include "c_cs_playerresource.h"
#include "c_team.h"
#include "history_resource.h"
#include "ragdoll_shared.h"
#include "collisionutils.h"
// NVNT - haptics system for spectating
#include "haptics/haptic_utils.h"
#include "steam/steam_api.h"
#include "cs_blackmarket.h" // for vest/helmet prices
#if defined( CCSPlayer )
#undef CCSPlayer
#endif
#include "materialsystem/imesh.h" //for materials->FindMaterial
#include "iviewrender.h" //for view->
#include "iviewrender_beams.h" // flashlight beam
//=============================================================================
// HPE_BEGIN:
// [menglish] Adding and externing variables needed for the freezecam
//=============================================================================
static Vector WALL_MIN(-WALL_OFFSET,-WALL_OFFSET,-WALL_OFFSET);
static Vector WALL_MAX(WALL_OFFSET,WALL_OFFSET,WALL_OFFSET);
extern ConVar spec_freeze_time;
extern ConVar spec_freeze_traveltime;
extern ConVar spec_freeze_distance_min;
extern ConVar spec_freeze_distance_max;
//=============================================================================
// HPE_END
//=============================================================================
ConVar cl_left_hand_ik( "cl_left_hand_ik", "0", 0, "Attach player's left hand to rifle with IK." );
ConVar cl_ragdoll_physics_enable( "cl_ragdoll_physics_enable", "1", 0, "Enable/disable ragdoll physics." );
ConVar cl_minmodels( "cl_minmodels", "0", 0, "Uses one player model for each team." );
ConVar cl_min_ct( "cl_min_ct", "1", 0, "Controls which CT model is used when cl_minmodels is set.", true, 1, true, 4 );
ConVar cl_min_t( "cl_min_t", "1", 0, "Controls which Terrorist model is used when cl_minmodels is set.", true, 1, true, 4 );
const float CycleLatchTolerance = 0.15; // amount we can diverge from the server's cycle before we're corrected
extern ConVar mp_playerid_delay;
extern ConVar mp_playerid_hold;
extern ConVar sv_allowminmodels;
class CAddonInfo
{
public:
const char *m_pAttachmentName;
const char *m_pWeaponClassName; // The addon uses the w_ model from this weapon.
const char *m_pModelName; //If this is present, will use this model instead of looking up the weapon
const char *m_pHolsterName;
};
// These must follow the ADDON_ ordering.
CAddonInfo g_AddonInfo[] =
{
{ "grenade0", "weapon_flashbang", 0, 0 },
{ "grenade1", "weapon_flashbang", 0, 0 },
{ "grenade2", "weapon_hegrenade", 0, 0 },
{ "grenade3", "weapon_smokegrenade", 0, 0 },
{ "c4", "weapon_c4", 0, 0 },
{ "defusekit", 0, "models/weapons/w_defuser.mdl", 0 },
{ "primary", 0, 0, 0 }, // Primary addon model is looked up based on m_iPrimaryAddon
{ "pistol", 0, 0, 0 }, // Pistol addon model is looked up based on m_iSecondaryAddon
{ "eholster", 0, "models/weapons/w_eq_eholster_elite.mdl", "models/weapons/w_eq_eholster.mdl" },
};
// -------------------------------------------------------------------------------- //
// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
// -------------------------------------------------------------------------------- //
class C_TEPlayerAnimEvent : public C_BaseTempEntity
{
public:
DECLARE_CLASS( C_TEPlayerAnimEvent, C_BaseTempEntity );
DECLARE_CLIENTCLASS();
virtual void PostDataUpdate( DataUpdateType_t updateType )
{
// Create the effect.
C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( m_hPlayer.Get() );
if ( pPlayer && !pPlayer->IsDormant() )
{
pPlayer->DoAnimationEvent( (PlayerAnimEvent_t)m_iEvent.Get(), m_nData );
}
}
public:
CNetworkHandle( CBasePlayer, m_hPlayer );
CNetworkVar( int, m_iEvent );
CNetworkVar( int, m_nData );
};
IMPLEMENT_CLIENTCLASS_EVENT( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent, CTEPlayerAnimEvent );
BEGIN_RECV_TABLE_NOBASE( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent )
RecvPropEHandle( RECVINFO( m_hPlayer ) ),
RecvPropInt( RECVINFO( m_iEvent ) ),
RecvPropInt( RECVINFO( m_nData ) )
END_RECV_TABLE()
BEGIN_PREDICTION_DATA( C_CSPlayer )
#ifdef CS_SHIELD_ENABLED
DEFINE_PRED_FIELD( m_bShieldDrawn, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
#endif
DEFINE_PRED_FIELD_TOL( m_flStamina, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.1f ),
DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
DEFINE_PRED_FIELD( m_iShotsFired, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_iDirection, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bResumeZoom, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_iLastZoom, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
END_PREDICTION_DATA()
vgui::IImage* GetDefaultAvatarImage( C_BasePlayer *pPlayer )
{
vgui::IImage* result = NULL;
switch ( pPlayer ? pPlayer->GetTeamNumber() : TEAM_MAXCOUNT )
{
case TEAM_TERRORIST:
result = vgui::scheme()->GetImage( CSTRIKE_DEFAULT_T_AVATAR, true );
break;
case TEAM_CT:
result = vgui::scheme()->GetImage( CSTRIKE_DEFAULT_CT_AVATAR, true );
break;
default:
result = vgui::scheme()->GetImage( CSTRIKE_DEFAULT_AVATAR, true );
break;
}
return result;
}
// ----------------------------------------------------------------------------- //
// Client ragdoll entity.
// ----------------------------------------------------------------------------- //
float g_flDieTranslucentTime = 0.6;
class C_CSRagdoll : public C_BaseAnimatingOverlay
{
public:
DECLARE_CLASS( C_CSRagdoll, C_BaseAnimatingOverlay );
DECLARE_CLIENTCLASS();
C_CSRagdoll();
~C_CSRagdoll();
virtual void OnDataChanged( DataUpdateType_t type );
int GetPlayerEntIndex() const;
IRagdoll* GetIRagdoll() const;
void GetRagdollInitBoneArrays( matrix3x4_t *pDeltaBones0, matrix3x4_t *pDeltaBones1, matrix3x4_t *pCurrentBones, float boneDt ) OVERRIDE;
void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName );
virtual void ComputeFxBlend();
virtual bool IsTransparent();
bool IsInitialized() { return m_bInitialized; }
// fading ragdolls don't cast shadows
virtual ShadowType_t ShadowCastType()
{
if ( m_flRagdollSinkStart == -1 )
return BaseClass::ShadowCastType();
return SHADOWS_NONE;
}
virtual void ValidateModelIndex( void );
private:
C_CSRagdoll( const C_CSRagdoll & ) {}
void Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity );
void CreateLowViolenceRagdoll( void );
void CreateCSRagdoll( void );
private:
EHANDLE m_hPlayer;
CNetworkVector( m_vecRagdollVelocity );
CNetworkVector( m_vecRagdollOrigin );
CNetworkVar(int, m_iDeathPose );
CNetworkVar(int, m_iDeathFrame );
float m_flRagdollSinkStart;
bool m_bInitialized;
bool m_bCreatedWhilePlaybackSkipping;
};
IMPLEMENT_CLIENTCLASS_DT_NOBASE( C_CSRagdoll, DT_CSRagdoll, CCSRagdoll )
RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
RecvPropVector( RECVINFO(m_vecRagdollOrigin) ),
RecvPropEHandle( RECVINFO( m_hPlayer ) ),
RecvPropInt( RECVINFO( m_nModelIndex ) ),
RecvPropInt( RECVINFO(m_nForceBone) ),
RecvPropVector( RECVINFO(m_vecForce) ),
RecvPropVector( RECVINFO( m_vecRagdollVelocity ) ),
RecvPropInt( RECVINFO(m_iDeathPose) ),
RecvPropInt( RECVINFO(m_iDeathFrame) ),
RecvPropInt(RECVINFO(m_iTeamNum)),
RecvPropInt( RECVINFO(m_bClientSideAnimation)),
END_RECV_TABLE()
C_CSRagdoll::C_CSRagdoll()
{
m_flRagdollSinkStart = -1;
m_bInitialized = false;
m_bCreatedWhilePlaybackSkipping = engine->IsSkippingPlayback();
}
C_CSRagdoll::~C_CSRagdoll()
{
PhysCleanupFrictionSounds( this );
}
void C_CSRagdoll::GetRagdollInitBoneArrays( matrix3x4_t *pDeltaBones0, matrix3x4_t *pDeltaBones1, matrix3x4_t *pCurrentBones, float boneDt )
{
// otherwise use the death pose to set up the ragdoll
ForceSetupBonesAtTime( pDeltaBones0, gpGlobals->curtime - boneDt );
GetRagdollCurSequenceWithDeathPose( this, pDeltaBones1, gpGlobals->curtime, m_iDeathPose, m_iDeathFrame );
SetupBones( pCurrentBones, MAXSTUDIOBONES, BONE_USED_BY_ANYTHING, gpGlobals->curtime );
}
void C_CSRagdoll::Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity )
{
if ( !pSourceEntity )
return;
VarMapping_t *pSrc = pSourceEntity->GetVarMapping();
VarMapping_t *pDest = GetVarMapping();
// Find all the VarMapEntry_t's that represent the same variable.
for ( int i = 0; i < pDest->m_Entries.Count(); i++ )
{
VarMapEntry_t *pDestEntry = &pDest->m_Entries[i];
for ( int j=0; j < pSrc->m_Entries.Count(); j++ )
{
VarMapEntry_t *pSrcEntry = &pSrc->m_Entries[j];
if ( !Q_strcmp( pSrcEntry->watcher->GetDebugName(),
pDestEntry->watcher->GetDebugName() ) )
{
pDestEntry->watcher->Copy( pSrcEntry->watcher );
break;
}
}
}
}
void C_CSRagdoll::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
{
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if( !pPhysicsObject )
return;
Vector dir = pTrace->endpos - pTrace->startpos;
if ( iDamageType == DMG_BLAST )
{
dir *= 4000; // adjust impact strenght
// apply force at object mass center
pPhysicsObject->ApplyForceCenter( dir );
}
else
{
Vector hitpos;
VectorMA( pTrace->startpos, pTrace->fraction, dir, hitpos );
VectorNormalize( dir );
dir *= 4000; // adjust impact strenght
// apply force where we hit it
pPhysicsObject->ApplyForceOffset( dir, hitpos );
// Blood spray!
FX_CS_BloodSpray( hitpos, dir, 10 );
}
m_pRagdoll->ResetRagdollSleepAfterTime();
}
void C_CSRagdoll::ValidateModelIndex( void )
{
if ( sv_allowminmodels.GetBool() && cl_minmodels.GetBool() )
{
if ( GetTeamNumber() == TEAM_CT )
{
int index = cl_min_ct.GetInt() - 1;
if ( index >= 0 && index < CTPlayerModels.Count() )
{
m_nModelIndex = modelinfo->GetModelIndex(CTPlayerModels[index]);
}
}
else if ( GetTeamNumber() == TEAM_TERRORIST )
{
int index = cl_min_t.GetInt() - 1;
if ( index >= 0 && index < TerroristPlayerModels.Count() )
{
m_nModelIndex = modelinfo->GetModelIndex(TerroristPlayerModels[index]);
}
}
}
BaseClass::ValidateModelIndex();
}
void C_CSRagdoll::CreateLowViolenceRagdoll( void )
{
// Just play a death animation.
// Find a death anim to play.
int iMinDeathAnim = 9999, iMaxDeathAnim = -9999;
for ( int iAnim=1; iAnim < 100; iAnim++ )
{
char str[512];
Q_snprintf( str, sizeof( str ), "death%d", iAnim );
if ( LookupSequence( str ) == -1 )
break;
iMinDeathAnim = MIN( iMinDeathAnim, iAnim );
iMaxDeathAnim = MAX( iMaxDeathAnim, iAnim );
}
if ( iMinDeathAnim == 9999 )
{
CreateCSRagdoll();
return;
}
SetNetworkOrigin( m_vecRagdollOrigin );
SetAbsOrigin( m_vecRagdollOrigin );
SetAbsVelocity( m_vecRagdollVelocity );
C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( m_hPlayer.Get() );
if ( pPlayer )
{
if ( !pPlayer->IsDormant() )
{
// move my current model instance to the ragdoll's so decals are preserved.
pPlayer->SnatchModelInstance( this );
}
SetAbsAngles( pPlayer->GetRenderAngles() );
SetNetworkAngles( pPlayer->GetRenderAngles() );
}
int iDeathAnim = RandomInt( iMinDeathAnim, iMaxDeathAnim );
char str[512];
Q_snprintf( str, sizeof( str ), "death%d", iDeathAnim );
SetSequence( LookupSequence( str ) );
ForceClientSideAnimationOn();
Interp_Reset( GetVarMapping() );
}
void C_CSRagdoll::CreateCSRagdoll()
{
// First, initialize all our data. If we have the player's entity on our client,
// then we can make ourselves start out exactly where the player is.
C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( m_hPlayer.Get() );
// mark this to prevent model changes from overwriting the death sequence with the server sequence
SetReceivedSequence();
if ( pPlayer && !pPlayer->IsDormant() )
{
// move my current model instance to the ragdoll's so decals are preserved.
pPlayer->SnatchModelInstance( this );
VarMapping_t *varMap = GetVarMapping();
// Copy all the interpolated vars from the player entity.
// The entity uses the interpolated history to get bone velocity.
bool bRemotePlayer = (pPlayer != C_BasePlayer::GetLocalPlayer());
if ( bRemotePlayer )
{
Interp_Copy( pPlayer );
SetAbsAngles( pPlayer->GetRenderAngles() );
GetRotationInterpolator().Reset();
m_flAnimTime = pPlayer->m_flAnimTime;
SetSequence( pPlayer->GetSequence() );
m_flPlaybackRate = pPlayer->GetPlaybackRate();
}
else
{
// This is the local player, so set them in a default
// pose and slam their velocity, angles and origin
SetAbsOrigin( m_vecRagdollOrigin );
SetAbsAngles( pPlayer->GetRenderAngles() );
SetAbsVelocity( m_vecRagdollVelocity );
int iSeq = LookupSequence( "walk_lower" );
if ( iSeq == -1 )
{
Assert( false ); // missing walk_lower?
iSeq = 0;
}
SetSequence( iSeq ); // walk_lower, basic pose
SetCycle( 0.0 );
// go ahead and set these on the player in case the code below decides to set up bones using
// that entity instead of this one. The local player may not have valid animation
pPlayer->SetSequence( iSeq ); // walk_lower, basic pose
pPlayer->SetCycle( 0.0 );
Interp_Reset( varMap );
}
}
else
{
// overwrite network origin so later interpolation will
// use this position
SetNetworkOrigin( m_vecRagdollOrigin );
SetAbsOrigin( m_vecRagdollOrigin );
SetAbsVelocity( m_vecRagdollVelocity );
Interp_Reset( GetVarMapping() );
}
// Turn it into a ragdoll.
if ( cl_ragdoll_physics_enable.GetInt() )
{
// Make us a ragdoll..
m_nRenderFX = kRenderFxRagdoll;
matrix3x4_t boneDelta0[MAXSTUDIOBONES];
matrix3x4_t boneDelta1[MAXSTUDIOBONES];
matrix3x4_t currentBones[MAXSTUDIOBONES];
const float boneDt = 0.05f;
//=============================================================================
// [pfreese], [tj]
// There are visual problems with the attempted blending of the
// death pose animations in C_CSRagdoll::GetRagdollInitBoneArrays. The version
// in C_BasePlayer::GetRagdollInitBoneArrays doesn't attempt to blend death
// poses, so if the player is relevant, use that one regardless of whether the
// player is the local one or not.
//=============================================================================
if ( pPlayer && !pPlayer->IsDormant() )
{
pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
}
else
{
GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
}
InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt );
m_flRagdollSinkStart = -1;
}
else
{
m_flRagdollSinkStart = gpGlobals->curtime;
DestroyShadow();
ClientLeafSystem()->SetRenderGroup( GetRenderHandle(), RENDER_GROUP_TRANSLUCENT_ENTITY );
}
m_bInitialized = true;
}
void C_CSRagdoll::ComputeFxBlend( void )
{
if ( m_flRagdollSinkStart == -1 )
{
BaseClass::ComputeFxBlend();
}
else
{
float elapsed = gpGlobals->curtime - m_flRagdollSinkStart;
float flVal = RemapVal( elapsed, 0, g_flDieTranslucentTime, 255, 0 );
flVal = clamp( flVal, 0, 255 );
m_nRenderFXBlend = (int)flVal;
#ifdef _DEBUG
m_nFXComputeFrame = gpGlobals->framecount;
#endif
}
}
bool C_CSRagdoll::IsTransparent( void )
{
if ( m_flRagdollSinkStart == -1 )
{
return BaseClass::IsTransparent();
}
else
{
return true;
}
}
void C_CSRagdoll::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_CREATED )
{
// Prevent replays from creating ragdolls on the first frame of playback after skipping through playback.
// If a player died (leaving a ragdoll) previous to the first frame of replay playback,
// their ragdoll wasn't yet initialized because OnDataChanged events are queued but not processed
// until the first render.
if ( engine->IsPlayingDemo() && m_bCreatedWhilePlaybackSkipping )
{
Release();
return;
}
if ( g_RagdollLVManager.IsLowViolence() )
{
CreateLowViolenceRagdoll();
}
else
{
CreateCSRagdoll();
}
}
else
{
if ( !cl_ragdoll_physics_enable.GetInt() )
{
// Don't let it set us back to a ragdoll with data from the server.
m_nRenderFX = kRenderFxNone;
}
}
}
IRagdoll* C_CSRagdoll::GetIRagdoll() const
{
return m_pRagdoll;
}
//-----------------------------------------------------------------------------
// Purpose: Called when the player toggles nightvision
// Input : *pData - the int value of the nightvision state
// *pStruct - the player
// *pOut -
//-----------------------------------------------------------------------------
void RecvProxy_NightVision( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
C_CSPlayer *pPlayerData = (C_CSPlayer *) pStruct;
bool bNightVisionOn = ( pData->m_Value.m_Int > 0 );
if ( pPlayerData->m_bNightVisionOn != bNightVisionOn )
{
if ( bNightVisionOn )
pPlayerData->m_flNightVisionAlpha = 1;
}
pPlayerData->m_bNightVisionOn = bNightVisionOn;
}
void RecvProxy_FlashTime( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
C_CSPlayer *pPlayerData = (C_CSPlayer *) pStruct;
if( pPlayerData != C_BasePlayer::GetLocalPlayer() )
return;
if ( (pPlayerData->m_flFlashDuration != pData->m_Value.m_Float) && pData->m_Value.m_Float > 0 )
{
pPlayerData->m_flFlashAlpha = 1;
}
pPlayerData->m_flFlashDuration = pData->m_Value.m_Float;
pPlayerData->m_flFlashBangTime = gpGlobals->curtime + pPlayerData->m_flFlashDuration;
}
void RecvProxy_HasDefuser( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
C_CSPlayer *pPlayerData = (C_CSPlayer *)pStruct;
if (pPlayerData == NULL)
{
return;
}
bool drawIcon = false;
if (pData->m_Value.m_Int == 0)
{
pPlayerData->RemoveDefuser();
}
else
{
if (pPlayerData->HasDefuser() == false)
{
drawIcon = true;
}
pPlayerData->GiveDefuser();
}
if (pPlayerData->IsLocalPlayer() && drawIcon)
{
// add to pickup history
CHudHistoryResource *pHudHR = GET_HUDELEMENT( CHudHistoryResource );
if ( pHudHR )
{
pHudHR->AddToHistory(HISTSLOT_ITEM, "defuser_pickup");
}
}
}
void C_CSPlayer::RecvProxy_CycleLatch( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
// This receive proxy looks to see if the server's value is close enough to what we think it should
// be. We've been running the same code; this is an error correction for changes we didn't simulate
// while they were out of PVS.
C_CSPlayer *pPlayer = (C_CSPlayer *)pStruct;
if( pPlayer->IsLocalPlayer() )
return; // Don't need to fixup ourselves.
float incomingCycle = (float)(pData->m_Value.m_Int) / 16; // Came in as 4 bit fixed point
float currentCycle = pPlayer->GetCycle();
bool closeEnough = fabs(currentCycle - incomingCycle) < CycleLatchTolerance;
if( fabs(currentCycle - incomingCycle) > (1 - CycleLatchTolerance) )
{
closeEnough = true;// Handle wrapping around 1->0
}
if( !closeEnough )
{
// Server disagrees too greatly. Correct our value.
if ( pPlayer && pPlayer->GetTeam() )
{
DevMsg( 2, "%s %s(%d): Cycle latch wants to correct %.2f in to %.2f.\n",
pPlayer->GetTeam()->Get_Name(), pPlayer->GetPlayerName(), pPlayer->entindex(), currentCycle, incomingCycle );
}
pPlayer->SetServerIntendedCycle( incomingCycle );
}
}
void __MsgFunc_ReloadEffect( bf_read &msg )
{
int iPlayer = msg.ReadShort();
C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( C_BaseEntity::Instance( iPlayer ) );
if ( pPlayer )
pPlayer->PlayReloadEffect();
}
USER_MESSAGE_REGISTER( ReloadEffect );
BEGIN_RECV_TABLE_NOBASE( C_CSPlayer, DT_CSLocalPlayerExclusive )
RecvPropFloat( RECVINFO(m_flStamina) ),
RecvPropInt( RECVINFO( m_iDirection ) ),
RecvPropInt( RECVINFO( m_iShotsFired ) ),
RecvPropFloat( RECVINFO( m_flVelocityModifier ) ),
RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
//=============================================================================
// HPE_BEGIN:
// [tj]Set up the receive table for per-client domination data
//=============================================================================
RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominated ), RecvPropBool( RECVINFO( m_bPlayerDominated[0] ) ) ),
RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominatingMe ), RecvPropBool( RECVINFO( m_bPlayerDominatingMe[0] ) ) )
//=============================================================================
// HPE_END
//=============================================================================
END_RECV_TABLE()
BEGIN_RECV_TABLE_NOBASE( C_CSPlayer, DT_CSNonLocalPlayerExclusive )
RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
END_RECV_TABLE()
IMPLEMENT_CLIENTCLASS_DT( C_CSPlayer, DT_CSPlayer, CCSPlayer )
RecvPropDataTable( "cslocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_CSLocalPlayerExclusive) ),
RecvPropDataTable( "csnonlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_CSNonLocalPlayerExclusive) ),
RecvPropInt( RECVINFO( m_iAddonBits ) ),
RecvPropInt( RECVINFO( m_iPrimaryAddon ) ),
RecvPropInt( RECVINFO( m_iSecondaryAddon ) ),
RecvPropInt( RECVINFO( m_iThrowGrenadeCounter ) ),
RecvPropInt( RECVINFO( m_iPlayerState ) ),
RecvPropInt( RECVINFO( m_iAccount ) ),
RecvPropInt( RECVINFO( m_bInBombZone ) ),
RecvPropInt( RECVINFO( m_bInBuyZone ) ),
RecvPropInt( RECVINFO( m_iClass ) ),
RecvPropInt( RECVINFO( m_ArmorValue ) ),
RecvPropFloat( RECVINFO( m_angEyeAngles[0] ) ),
RecvPropFloat( RECVINFO( m_angEyeAngles[1] ) ),
RecvPropFloat( RECVINFO( m_flStamina ) ),
RecvPropInt( RECVINFO( m_bHasDefuser ), 0, RecvProxy_HasDefuser ),
RecvPropInt( RECVINFO( m_bNightVisionOn), 0, RecvProxy_NightVision ),
RecvPropBool( RECVINFO( m_bHasNightVision ) ),
//=============================================================================
// HPE_BEGIN:
// [dwenger] Added for fun-fact support
//=============================================================================
//RecvPropBool( RECVINFO( m_bPickedUpDefuser ) ),
//RecvPropBool( RECVINFO( m_bDefusedWithPickedUpKit ) ),
//=============================================================================
// HPE_END
//=============================================================================
RecvPropBool( RECVINFO( m_bInHostageRescueZone ) ),
RecvPropInt( RECVINFO( m_ArmorValue ) ),
RecvPropBool( RECVINFO( m_bIsDefusing ) ),
RecvPropBool( RECVINFO( m_bResumeZoom ) ),
RecvPropInt( RECVINFO( m_iLastZoom ) ),
#ifdef CS_SHIELD_ENABLED
RecvPropBool( RECVINFO( m_bHasShield ) ),
RecvPropBool( RECVINFO( m_bShieldDrawn ) ),
#endif
RecvPropInt( RECVINFO( m_bHasHelmet ) ),
RecvPropVector( RECVINFO( m_vecRagdollVelocity ) ),
RecvPropFloat( RECVINFO( m_flFlashDuration ), 0, RecvProxy_FlashTime ),
RecvPropFloat( RECVINFO( m_flFlashMaxAlpha)),
RecvPropInt( RECVINFO( m_iProgressBarDuration ) ),
RecvPropFloat( RECVINFO( m_flProgressBarStartTime ) ),
RecvPropEHandle( RECVINFO( m_hRagdoll ) ),
RecvPropInt( RECVINFO( m_cycleLatch ), 0, &C_CSPlayer::RecvProxy_CycleLatch ),
END_RECV_TABLE()
C_CSPlayer::C_CSPlayer() :
m_iv_angEyeAngles( "C_CSPlayer::m_iv_angEyeAngles" )
{
m_PlayerAnimState = CreatePlayerAnimState( this, this, LEGANIM_9WAY, true );
m_angEyeAngles.Init();
AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR );
m_iLastAddonBits = m_iAddonBits = 0;
m_iLastPrimaryAddon = m_iLastSecondaryAddon = WEAPON_NONE;
m_iProgressBarDuration = 0;
m_flProgressBarStartTime = 0.0f;
m_ArmorValue = 0;
m_bHasHelmet = false;
m_iIDEntIndex = 0;
m_delayTargetIDTimer.Reset();
m_iOldIDEntIndex = 0;
m_holdTargetIDTimer.Reset();
m_iDirection = 0;
m_Activity = ACT_IDLE;
m_pFlashlightBeam = NULL;
m_fNextThinkPushAway = 0.0f;
m_serverIntendedCycle = -1.0f;
view->SetScreenOverlayMaterial( NULL );
m_bPlayingFreezeCamSound = false;
}
C_CSPlayer::~C_CSPlayer()
{
RemoveAddonModels();
ReleaseFlashlight();
m_PlayerAnimState->Release();
}
bool C_CSPlayer::HasDefuser() const
{
return m_bHasDefuser;
}
void C_CSPlayer::GiveDefuser()
{
m_bHasDefuser = true;
}
void C_CSPlayer::RemoveDefuser()
{
m_bHasDefuser = false;
}
bool C_CSPlayer::HasNightVision() const
{
return m_bHasNightVision;
}
bool C_CSPlayer::IsVIP() const
{
C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
if ( !pCSPR )
return false;
return pCSPR->IsVIP( entindex() );
}
C_CSPlayer* C_CSPlayer::GetLocalCSPlayer()
{
return (C_CSPlayer*)C_BasePlayer::GetLocalPlayer();
}
CSPlayerState C_CSPlayer::State_Get() const
{
return m_iPlayerState;
}
float C_CSPlayer::GetMinFOV() const
{
// Min FOV for AWP.
return 10;
}
int C_CSPlayer::GetAccount() const
{
return m_iAccount;
}
int C_CSPlayer::PlayerClass() const
{
return m_iClass;
}
bool C_CSPlayer::IsInBuyZone()
{
return m_bInBuyZone;
}
bool C_CSPlayer::CanShowTeamMenu() const
{
return true;
}
int C_CSPlayer::ArmorValue() const
{
return m_ArmorValue;
}
bool C_CSPlayer::HasHelmet() const
{
return m_bHasHelmet;
}
int C_CSPlayer::GetCurrentAssaultSuitPrice()
{
// WARNING: This price logic also exists in CCSPlayer::AttemptToBuyAssaultSuit
// and must be kept in sync if changes are made.
int fullArmor = ArmorValue() >= 100 ? 1 : 0;
if ( fullArmor && !HasHelmet() )
{
return HELMET_PRICE;
}
else if ( !fullArmor && HasHelmet() )
{
return KEVLAR_PRICE;
}
else
{
// NOTE: This applies to the case where you already have both
// as well as the case where you have neither. In the case
// where you have both, the item should still have a price
// and become disabled when you have little or no money left.
return ASSAULTSUIT_PRICE;
}
}
const QAngle& C_CSPlayer::GetRenderAngles()
{
if ( IsRagdoll() )
{
return vec3_angle;
}
else
{
return m_PlayerAnimState->GetRenderAngles();
}
}
float g_flFattenAmt = 4;
void C_CSPlayer::GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType )
{
if ( shadowType == SHADOWS_SIMPLE )
{
// Don't let the render bounds change when we're using blobby shadows, or else the shadow
// will pop and stretch.
mins = CollisionProp()->OBBMins();
maxs = CollisionProp()->OBBMaxs();
}
else
{
GetRenderBounds( mins, maxs );
// We do this because the normal bbox calculations don't take pose params into account, and
// the rotation of the guy's upper torso can place his gun a ways out of his bbox, and
// the shadow will get cut off as he rotates.
//
// Thus, we give it some padding here.
mins -= Vector( g_flFattenAmt, g_flFattenAmt, 0 );
maxs += Vector( g_flFattenAmt, g_flFattenAmt, 0 );
}
}
void C_CSPlayer::GetRenderBounds( Vector& theMins, Vector& theMaxs )
{
// TODO POSTSHIP - this hack/fix goes hand-in-hand with a fix in CalcSequenceBoundingBoxes in utils/studiomdl/simplify.cpp.
// When we enable the fix in CalcSequenceBoundingBoxes, we can get rid of this.
//
// What we're doing right here is making sure it only uses the bbox for our lower-body sequences since,
// with the current animations and the bug in CalcSequenceBoundingBoxes, are WAY bigger than they need to be.
C_BaseAnimating::GetRenderBounds( theMins, theMaxs );
// If we're ducking, we should reduce the render height by the difference in standing and ducking heights.
// This prevents shadows from drawing above ducking players etc.
if ( GetFlags() & FL_DUCKING )
{
theMaxs.z -= 18.5f;
}
}
bool C_CSPlayer::GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const
{
if ( shadowType == SHADOWS_SIMPLE )
{
// Blobby shadows should sit directly underneath us.
pDirection->Init( 0, 0, -1 );
return true;
}
else
{
return BaseClass::GetShadowCastDirection( pDirection, shadowType );
}
}
void C_CSPlayer::VPhysicsUpdate( IPhysicsObject *pPhysics )
{
BaseClass::VPhysicsUpdate( pPhysics );
}
int C_CSPlayer::GetIDTarget() const
{
if ( !m_delayTargetIDTimer.IsElapsed() )
return 0;
if ( m_iIDEntIndex )
{
return m_iIDEntIndex;
}
if ( m_iOldIDEntIndex && !m_holdTargetIDTimer.IsElapsed() )
{
return m_iOldIDEntIndex;
}
return 0;
}
void InitializeAddonModelFromWeapon( CWeaponCSBase *weapon, C_BreakableProp *addon )
{
if ( !weapon )
{
return;
}
const CCSWeaponInfo& weaponInfo = weapon->GetCSWpnData();
if ( weaponInfo.m_szAddonModel[0] == 0 )
{
addon->InitializeAsClientEntity( weaponInfo.szWorldModel, RENDER_GROUP_OPAQUE_ENTITY );
}
else
{
addon->InitializeAsClientEntity( weaponInfo.m_szAddonModel, RENDER_GROUP_OPAQUE_ENTITY );
}
}
void C_CSPlayer::CreateAddonModel( int i )
{
COMPILE_TIME_ASSERT( (sizeof( g_AddonInfo ) / sizeof( g_AddonInfo[0] )) == NUM_ADDON_BITS );
// Create the model entity.
CAddonInfo *pAddonInfo = &g_AddonInfo[i];
int iAttachment = LookupAttachment( pAddonInfo->m_pAttachmentName );
if ( iAttachment <= 0 )
return;
C_BreakableProp *pEnt = new C_BreakableProp;
int addonType = (1<<i);
if ( addonType == ADDON_PISTOL || addonType == ADDON_PRIMARY )
{
CCSWeaponInfo *weaponInfo = GetWeaponInfo( (CSWeaponID)((addonType == ADDON_PRIMARY) ? m_iPrimaryAddon.Get() : m_iSecondaryAddon.Get()) );
if ( !weaponInfo )
{
Warning( "C_CSPlayer::CreateAddonModel: Unable to get weapon info.\n" );
pEnt->Release();
return;
}
if ( weaponInfo->m_szAddonModel[0] == 0 )
{
pEnt->InitializeAsClientEntity( weaponInfo->szWorldModel, RENDER_GROUP_OPAQUE_ENTITY );
}
else
{
pEnt->InitializeAsClientEntity( weaponInfo->m_szAddonModel, RENDER_GROUP_OPAQUE_ENTITY );
}
}
else if( pAddonInfo->m_pModelName )
{
if ( addonType == ADDON_PISTOL2 && !(m_iAddonBits & ADDON_PISTOL ) )
{
pEnt->InitializeAsClientEntity( pAddonInfo->m_pHolsterName, RENDER_GROUP_OPAQUE_ENTITY );
}
else
{
pEnt->InitializeAsClientEntity( pAddonInfo->m_pModelName, RENDER_GROUP_OPAQUE_ENTITY );
}
}
else
{
WEAPON_FILE_INFO_HANDLE hWpnInfo = LookupWeaponInfoSlot( pAddonInfo->m_pWeaponClassName );
if ( hWpnInfo == GetInvalidWeaponInfoHandle() )
{
Assert( false );
return;
}
CCSWeaponInfo *pWeaponInfo = dynamic_cast< CCSWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
if ( pWeaponInfo )
{
if ( pWeaponInfo->m_szAddonModel[0] == 0 )
pEnt->InitializeAsClientEntity( pWeaponInfo->szWorldModel, RENDER_GROUP_OPAQUE_ENTITY );
else
pEnt->InitializeAsClientEntity( pWeaponInfo->m_szAddonModel, RENDER_GROUP_OPAQUE_ENTITY );
}
else
{
pEnt->Release();
Warning( "C_CSPlayer::CreateAddonModel: Unable to get weapon info for %s.\n", pAddonInfo->m_pWeaponClassName );
return;
}
}
if ( Q_strcmp( pAddonInfo->m_pAttachmentName, "c4" ) )
{
// fade out all attached models except C4
pEnt->SetFadeMinMax( 400, 500 );
}
// Create the addon.
CAddonModel *pAddon = &m_AddonModels[m_AddonModels.AddToTail()];
pAddon->m_hEnt = pEnt;
pAddon->m_iAddon = i;
pAddon->m_iAttachmentPoint = iAttachment;
pEnt->SetParent( this, pAddon->m_iAttachmentPoint );
pEnt->SetLocalOrigin( Vector( 0, 0, 0 ) );
pEnt->SetLocalAngles( QAngle( 0, 0, 0 ) );
if ( IsLocalPlayer() )
{
pEnt->SetSolid( SOLID_NONE );
pEnt->RemoveEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );
}
}
void C_CSPlayer::UpdateAddonModels()
{
int iCurAddonBits = m_iAddonBits;
// Don't put addon models on the local player unless in third person.
if ( IsLocalPlayer() && !C_BasePlayer::ShouldDrawLocalPlayer() )
iCurAddonBits = 0;
// If the local player is observing this entity in first-person mode, get rid of its addons.
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pPlayer->GetObserverTarget() == this )
iCurAddonBits = 0;
// Any changes to the attachments we should have?
if ( m_iLastAddonBits == iCurAddonBits &&
m_iLastPrimaryAddon == m_iPrimaryAddon &&
m_iLastSecondaryAddon == m_iSecondaryAddon )
{
return;
}
bool rebuildPistol2Addon = false;
if ( m_iSecondaryAddon == WEAPON_ELITE && ((m_iLastAddonBits ^ iCurAddonBits) & ADDON_PISTOL) != 0 )
{
rebuildPistol2Addon = true;
}
m_iLastAddonBits = iCurAddonBits;
m_iLastPrimaryAddon = m_iPrimaryAddon;
m_iLastSecondaryAddon = m_iSecondaryAddon;
// Get rid of any old models.
int i,iNext;
for ( i=m_AddonModels.Head(); i != m_AddonModels.InvalidIndex(); i = iNext )
{
iNext = m_AddonModels.Next( i );
CAddonModel *pModel = &m_AddonModels[i];
int addonBit = 1<<pModel->m_iAddon;
if ( !( iCurAddonBits & addonBit ) || (rebuildPistol2Addon && addonBit == ADDON_PISTOL2) )
{
if ( pModel->m_hEnt.Get() )
pModel->m_hEnt->Release();
m_AddonModels.Remove( i );
}
}
// Figure out which models we have now.
int curModelBits = 0;
FOR_EACH_LL( m_AddonModels, j )
{
curModelBits |= (1<<m_AddonModels[j].m_iAddon);
}
// Add any new models.
for ( i=0; i < NUM_ADDON_BITS; i++ )
{
if ( (iCurAddonBits & (1<<i)) && !( curModelBits & (1<<i) ) )
{
// Ok, we're supposed to have this one.
CreateAddonModel( i );
}
}
}
void C_CSPlayer::RemoveAddonModels()
{
m_iAddonBits = 0;
UpdateAddonModels();
}
void C_CSPlayer::NotifyShouldTransmit( ShouldTransmitState_t state )
{
// Remove all addon models if we go out of the PVS.
if ( state == SHOULDTRANSMIT_END )
{
RemoveAddonModels();
if( m_pFlashlightBeam != NULL )
{
ReleaseFlashlight();
}
}
BaseClass::NotifyShouldTransmit( state );
}
void C_CSPlayer::UpdateSoundEvents()
{
int iNext;
for ( int i=m_SoundEvents.Head(); i != m_SoundEvents.InvalidIndex(); i = iNext )
{
iNext = m_SoundEvents.Next( i );
CCSSoundEvent *pEvent = &m_SoundEvents[i];
if ( gpGlobals->curtime >= pEvent->m_flEventTime )
{
CLocalPlayerFilter filter;
EmitSound( filter, GetSoundSourceIndex(), STRING( pEvent->m_SoundName ) );
m_SoundEvents.Remove( i );
}
}
}
//-----------------------------------------------------------------------------
void C_CSPlayer::UpdateMinModels( void )
{
int modelIndex = m_nModelIndex;
// cl_minmodels convar dependent on sv_allowminmodels convar
if ( !IsVIP() && sv_allowminmodels.GetBool() && cl_minmodels.GetBool() && !IsLocalPlayer() )
{
if ( GetTeamNumber() == TEAM_CT )
{
int index = cl_min_ct.GetInt() - 1;
if ( index >= 0 && index < CTPlayerModels.Count() )
{
modelIndex = modelinfo->GetModelIndex( CTPlayerModels[index] );
}
}
else if ( GetTeamNumber() == TEAM_TERRORIST )
{
int index = cl_min_t.GetInt() - 1;
if ( index >= 0 && index < TerroristPlayerModels.Count() )
{
modelIndex = modelinfo->GetModelIndex( TerroristPlayerModels[index] );
}
}
}
SetModelByIndex( modelIndex );
}
// NVNT gate for spectating.
static bool inSpectating_Haptics = false;
//-----------------------------------------------------------------------------
void C_CSPlayer::ClientThink()
{
BaseClass::ClientThink();
UpdateSoundEvents();
UpdateAddonModels();
UpdateIDTarget();
if ( gpGlobals->curtime >= m_fNextThinkPushAway )
{
PerformObstaclePushaway( this );
m_fNextThinkPushAway = gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL;
}
// NVNT - check for spectating forces
if ( IsLocalPlayer() )
{
if ( GetTeamNumber() == TEAM_SPECTATOR || !this->IsAlive() || GetLocalOrInEyeCSPlayer() != this )
{
if (!inSpectating_Haptics)
{
if ( haptics )
haptics->SetNavigationClass("spectate");
inSpectating_Haptics = true;
}
}
else
{
if (inSpectating_Haptics)
{
if ( haptics )
haptics->SetNavigationClass("on_foot");
inSpectating_Haptics = false;
}
}
if ( m_iObserverMode == OBS_MODE_FREEZECAM )
{
//=============================================================================
// HPE_BEGIN:
// [Forrest] Added sv_disablefreezecam check
//=============================================================================
static ConVarRef sv_disablefreezecam( "sv_disablefreezecam" );
if ( !m_bPlayingFreezeCamSound && !cl_disablefreezecam.GetBool() && !sv_disablefreezecam.GetBool() )
//=============================================================================
// HPE_END
//=============================================================================
{
// Play sound
m_bPlayingFreezeCamSound = true;
CLocalPlayerFilter filter;
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = "UI/freeze_cam.wav";
ep.m_flVolume = VOL_NORM;
ep.m_SoundLevel = SNDLVL_NORM;
ep.m_bEmitCloseCaption = false;
EmitSound( filter, GetSoundSourceIndex(), ep );
}
}
else
{
m_bPlayingFreezeCamSound = false;
}
}
}
void C_CSPlayer::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_CREATED )
{
SetNextClientThink( CLIENT_THINK_ALWAYS );
if ( IsLocalPlayer() )
{
if ( CSGameRules() && CSGameRules()->IsBlackMarket() )
{
CSGameRules()->m_pPrices = NULL;
CSGameRules()->m_StringTableBlackMarket = NULL;
CSGameRules()->GetBlackMarketPriceList();
CSGameRules()->SetBlackMarketPrices( false );
}
}
}
UpdateVisibility();
}
void C_CSPlayer::ValidateModelIndex( void )
{
UpdateMinModels();
}
void C_CSPlayer::PostDataUpdate( DataUpdateType_t updateType )
{
// C_BaseEntity assumes we're networking the entity's angles, so pretend that it
// networked the same value we already have.
SetNetworkAngles( GetLocalAngles() );
BaseClass::PostDataUpdate( updateType );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_CSPlayer::Interpolate( float currentTime )
{
if ( !BaseClass::Interpolate( currentTime ) )
return false;
if ( CSGameRules()->IsFreezePeriod() )
{
// don't interpolate players position during freeze period
SetAbsOrigin( GetNetworkOrigin() );
}
return true;
}
int C_CSPlayer::GetMaxHealth() const
{
return 100;
}
//-----------------------------------------------------------------------------
// Purpose: Return the local player, or the player being spectated in-eye
//-----------------------------------------------------------------------------
C_CSPlayer* GetLocalOrInEyeCSPlayer( void )
{
C_CSPlayer *player = C_CSPlayer::GetLocalCSPlayer();
if( player && player->GetObserverMode() == OBS_MODE_IN_EYE )
{
C_BaseEntity *target = player->GetObserverTarget();
if( target && target->IsPlayer() )
{
return ToCSPlayer( target );
}
}
return player;
}
#define MAX_FLASHBANG_OPACITY 75.0f
//-----------------------------------------------------------------------------
// Purpose: Update this client's targetid entity
//-----------------------------------------------------------------------------
void C_CSPlayer::UpdateIDTarget()
{
if ( !IsLocalPlayer() )
return;
// Clear old target and find a new one
m_iIDEntIndex = 0;
// don't show IDs if mp_playerid == 2
if ( mp_playerid.GetInt() == 2 )
return;
// don't show IDs if mp_fadetoblack is on
if ( mp_fadetoblack.GetBool() && !IsAlive() )
return;
// don't show IDs in chase spec mode
if ( GetObserverMode() == OBS_MODE_CHASE ||
GetObserverMode() == OBS_MODE_DEATHCAM )
return;
//Check how much of a screen fade we have.
//if it's more than 75 then we can't see what's going on so we don't display the id.
byte color[4];
bool blend;
vieweffects->GetFadeParams( &color[0], &color[1], &color[2], &color[3], &blend );
if ( color[3] > MAX_FLASHBANG_OPACITY && ( IsAlive() || GetObserverMode() == OBS_MODE_IN_EYE ) )
return;
trace_t tr;
Vector vecStart, vecEnd;
VectorMA( MainViewOrigin(), 2500, MainViewForward(), vecEnd );
VectorMA( MainViewOrigin(), 10, MainViewForward(), vecStart );
UTIL_TraceLine( vecStart, vecEnd, MASK_VISIBLE_AND_NPCS, GetLocalOrInEyeCSPlayer(), COLLISION_GROUP_NONE, &tr );
if ( !tr.startsolid && !tr.DidHitNonWorldEntity() )
{
CTraceFilterSimple filter( GetLocalOrInEyeCSPlayer(), COLLISION_GROUP_NONE );
// Check for player hitboxes extending outside their collision bounds
const float rayExtension = 40.0f;
UTIL_ClipTraceToPlayers(vecStart, vecEnd + MainViewForward() * rayExtension, MASK_SOLID|CONTENTS_HITBOX, &filter, &tr );
}
if ( !tr.startsolid && tr.DidHitNonWorldEntity() )
{
C_BaseEntity *pEntity = tr.m_pEnt;
if ( pEntity && (pEntity != this) )
{
if ( mp_playerid.GetInt() == 1 ) // only show team names
{
if ( pEntity->GetTeamNumber() != GetTeamNumber() )
{
return;
}
}
//Adrian: If there's a smoke cloud in my way, don't display the name
//We check this AFTER we found a player, just so we don't go thru this for nothing.
for ( int i = 0; i < m_SmokeGrenades.Count(); i++ )
{
C_BaseParticleEntity *pSmokeGrenade = (C_BaseParticleEntity*)m_SmokeGrenades.Element( i );
if ( pSmokeGrenade )
{
float flHit1, flHit2;
float flRadius = ( SMOKEGRENADE_PARTICLERADIUS * NUM_PARTICLES_PER_DIMENSION + 1 ) * 0.5f;
Vector vPos = pSmokeGrenade->GetAbsOrigin();
/*debugoverlay->AddBoxOverlay( pSmokeGrenade->GetAbsOrigin(), Vector( flRadius, flRadius, flRadius ),
Vector( -flRadius, -flRadius, -flRadius ), QAngle( 0, 0, 0 ), 255, 0, 0, 255, 0.2 );*/
if ( IntersectInfiniteRayWithSphere( MainViewOrigin(), MainViewForward(), vPos, flRadius, &flHit1, &flHit2 ) )
{
return;
}
}
}
if ( !GetIDTarget() && ( !m_iOldIDEntIndex || m_holdTargetIDTimer.IsElapsed() ) )
{
// track when we first mouse over the target
m_delayTargetIDTimer.Start( mp_playerid_delay.GetFloat() );
}
m_iIDEntIndex = pEntity->entindex();
m_iOldIDEntIndex = m_iIDEntIndex;
m_holdTargetIDTimer.Start( mp_playerid_hold.GetFloat() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handling
//-----------------------------------------------------------------------------
bool C_CSPlayer::CreateMove( float flInputSampleTime, CUserCmd *pCmd )
{
// Bleh... we will wind up needing to access bones for attachments in here.
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, true );
return BaseClass::CreateMove( flInputSampleTime, pCmd );
}
//-----------------------------------------------------------------------------
// Purpose: Flash this entity on the radar
//-----------------------------------------------------------------------------
bool C_CSPlayer::IsInHostageRescueZone()
{
return m_bInHostageRescueZone;
}
CWeaponCSBase* C_CSPlayer::GetActiveCSWeapon() const
{
return dynamic_cast< CWeaponCSBase* >( GetActiveWeapon() );
}
CWeaponCSBase* C_CSPlayer::GetCSWeapon( CSWeaponID id ) const
{
for (int i=0;i<MAX_WEAPONS;i++)
{
CBaseCombatWeapon *weapon = GetWeapon( i );
if ( weapon )
{
CWeaponCSBase *csWeapon = dynamic_cast< CWeaponCSBase * >( weapon );
if ( csWeapon )
{
if ( id == csWeapon->GetWeaponID() )
{
return csWeapon;
}
}
}
}
return NULL;
}
//REMOVEME
/*
void C_CSPlayer::SetFireAnimation( PLAYER_ANIM playerAnim )
{
Activity idealActivity = ACT_WALK;
// Figure out stuff about the current state.
float speed = GetAbsVelocity().Length2D();
bool isMoving = ( speed != 0.0f ) ? true : false;
bool isDucked = ( GetFlags() & FL_DUCKING ) ? true : false;
bool isStillJumping = false; //!( GetFlags() & FL_ONGROUND );
bool isRunning = false;
if ( speed > ARBITRARY_RUN_SPEED )
{
isRunning = true;
}
// Now figure out what to do based on the current state and the new state.
switch ( playerAnim )
{
default:
case PLAYER_RELOAD:
case PLAYER_ATTACK1:
case PLAYER_IDLE:
case PLAYER_WALK:
// Are we still jumping?
// If so, keep playing the jump animation.
if ( !isStillJumping )
{
idealActivity = ACT_WALK;
if ( isDucked )
{
idealActivity = !isMoving ? ACT_CROUCHIDLE : ACT_RUN_CROUCH;
}
else
{
if ( isRunning )
{
idealActivity = ACT_RUN;
}
else
{
idealActivity = isMoving ? ACT_WALK : ACT_IDLE;
}
}
// Allow body yaw to override for standing and turning in place
idealActivity = m_PlayerAnimState.BodyYawTranslateActivity( idealActivity );
}
break;
case PLAYER_JUMP:
idealActivity = ACT_HOP;
break;
case PLAYER_DIE:
// Uses Ragdoll now???
idealActivity = ACT_DIESIMPLE;
break;
// FIXME: Use overlays for reload, start/leave aiming, attacking
case PLAYER_START_AIMING:
case PLAYER_LEAVE_AIMING:
idealActivity = ACT_WALK;
break;
}
CWeaponCSBase *pWeapon = GetActiveCSWeapon();
if ( pWeapon )
{
Activity aWeaponActivity = idealActivity;
if ( playerAnim == PLAYER_ATTACK1 )
{
switch ( idealActivity )
{
case ACT_WALK:
default:
aWeaponActivity = ACT_PLAYER_WALK_FIRE;
break;
case ACT_RUN:
aWeaponActivity = ACT_PLAYER_RUN_FIRE;
break;
case ACT_IDLE:
aWeaponActivity = ACT_PLAYER_IDLE_FIRE;
break;
case ACT_CROUCHIDLE:
aWeaponActivity = ACT_PLAYER_CROUCH_FIRE;
break;
case ACT_RUN_CROUCH:
aWeaponActivity = ACT_PLAYER_CROUCH_WALK_FIRE;
break;
}
}
m_PlayerAnimState.SetWeaponLayerSequence( pWeapon->GetCSWpnData().m_szAnimExtension, aWeaponActivity );
}
}
*/
ShadowType_t C_CSPlayer::ShadowCastType( void )
{
if ( !IsVisible() )
return SHADOWS_NONE;
return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether or not we can switch to the given weapon.
// Input : pWeapon -
//-----------------------------------------------------------------------------
bool C_CSPlayer::Weapon_CanSwitchTo( CBaseCombatWeapon *pWeapon )
{
if ( !pWeapon->CanDeploy() )
return false;
if ( GetActiveWeapon() )
{
if ( !GetActiveWeapon()->CanHolster() )
return false;
}
return true;
}
void C_CSPlayer::UpdateClientSideAnimation()
{
// We do this in a different order than the base class.
// We need our cycle to be valid for when we call the playeranimstate update code,
// or else it'll synchronize the upper body anims with the wrong cycle.
if ( GetSequence() != -1 )
{
// move frame forward
FrameAdvance( 0.0f ); // 0 means to use the time we last advanced instead of a constant
}
// Update the animation data. It does the local check here so this works when using
// a third-person camera (and we don't have valid player angles).
if ( this == C_CSPlayer::GetLocalCSPlayer() )
m_PlayerAnimState->Update( EyeAngles()[YAW], m_angEyeAngles[PITCH] );
else
m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
if ( GetSequence() != -1 )
{
// latch old values
OnLatchInterpolatedVariables( LATCH_ANIMATION_VAR );
}
}
float g_flMuzzleFlashScale=1;
void C_CSPlayer::ProcessMuzzleFlashEvent()
{
CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
// Reenable when the weapons have muzzle flash attachments in the right spot.
if ( this == pLocalPlayer )
return; // don't show own world muzzle flashs in for localplayer
if ( pLocalPlayer && pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
// also don't show in 1st person spec mode
if ( pLocalPlayer->GetObserverTarget() == this )
return;
}
CWeaponCSBase *pWeapon = GetActiveCSWeapon();
if ( !pWeapon )
return;
bool hasMuzzleFlash = (pWeapon->GetMuzzleFlashStyle() != CS_MUZZLEFLASH_NONE);
Vector vector;
QAngle angles;
int iAttachment = LookupAttachment( "muzzle_flash" );
if ( iAttachment >= 0 )
{
bool bFoundAttachment = GetAttachment( iAttachment, vector, angles );
// If we have an attachment, then stick a light on it.
if ( bFoundAttachment )
{
if ( hasMuzzleFlash )
{
dlight_t *el = effects->CL_AllocDlight( LIGHT_INDEX_MUZZLEFLASH + index );
el->origin = vector;
el->radius = 70;
el->decay = el->radius / 0.05f;
el->die = gpGlobals->curtime + 0.05f;
el->color.r = 255;
el->color.g = 192;
el->color.b = 64;
el->color.exponent = 5;
}
int shellType = GetShellForAmmoType( pWeapon->GetCSWpnData().szAmmo1 );
QAngle playerAngle = EyeAngles();
Vector vForward, vRight, vUp;
AngleVectors( playerAngle, &vForward, &vRight, &vUp );
QAngle angVelocity;
Vector vVel = vRight * 100 + vUp * 20;
VectorAngles( vVel, angVelocity );
if ( pWeapon->GetMaxClip1() > 0 )
{
tempents->CSEjectBrass( vector, angVelocity, 120, shellType, this );
}
}
}
if ( hasMuzzleFlash )
{
iAttachment = pWeapon->GetMuzzleAttachment();
if ( iAttachment > 0 )
{
float flScale = pWeapon->GetCSWpnData().m_flMuzzleScale;
flScale *= 0.75;
FX_MuzzleEffectAttached( flScale, pWeapon->GetRefEHandle(), iAttachment, NULL, false );
}
}
}
const QAngle& C_CSPlayer::EyeAngles()
{
if ( IsLocalPlayer() && !g_nKillCamMode )
{
return BaseClass::EyeAngles();
}
else
{
return m_angEyeAngles;
}
}
bool C_CSPlayer::ShouldDraw( void )
{
// If we're dead, our ragdoll will be drawn for us instead.
if ( !IsAlive() )
return false;
if( GetTeamNumber() == TEAM_SPECTATOR )
return false;
if( IsLocalPlayer() )
{
if ( IsRagdoll() )
return true;
}
return BaseClass::ShouldDraw();
}
bool FindWeaponAttachmentBone( C_BaseCombatWeapon *pWeapon, int &iWeaponBone )
{
if ( !pWeapon )
return false;
CStudioHdr *pHdr = pWeapon->GetModelPtr();
if ( !pHdr )
return false;
for ( iWeaponBone=0; iWeaponBone < pHdr->numbones(); iWeaponBone++ )
{
if ( stricmp( pHdr->pBone( iWeaponBone )->pszName(), "L_Hand_Attach" ) == 0 )
break;
}
return iWeaponBone != pHdr->numbones();
}
bool FindMyAttachmentBone( C_BaseAnimating *pModel, int &iBone, CStudioHdr *pHdr )
{
if ( !pHdr )
return false;
for ( iBone=0; iBone < pHdr->numbones(); iBone++ )
{
if ( stricmp( pHdr->pBone( iBone )->pszName(), "Valvebiped.Bip01_L_Hand" ) == 0 )
break;
}
return iBone != pHdr->numbones();
}
inline bool IsBoneChildOf( CStudioHdr *pHdr, int iBone, int iParent )
{
if ( iBone == iParent )
return false;
while ( iBone != -1 )
{
if ( iBone == iParent )
return true;
iBone = pHdr->pBone( iBone )->parent;
}
return false;
}
void ApplyDifferenceTransformToChildren(
C_BaseAnimating *pModel,
const matrix3x4_t &mSource,
const matrix3x4_t &mDest,
int iParentBone )
{
CStudioHdr *pHdr = pModel->GetModelPtr();
if ( !pHdr )
return;
// Build a matrix to go from mOriginalHand to mHand.
// ( mDest * Inverse( mSource ) ) * mSource = mDest
matrix3x4_t mSourceInverse, mToDest;
MatrixInvert( mSource, mSourceInverse );
ConcatTransforms( mDest, mSourceInverse, mToDest );
// Now multiply iMyBone and all its children by mToWeaponBone.
for ( int i=0; i < pHdr->numbones(); i++ )
{
if ( IsBoneChildOf( pHdr, i, iParentBone ) )
{
matrix3x4_t &mCur = pModel->GetBoneForWrite( i );
matrix3x4_t mNew;
ConcatTransforms( mToDest, mCur, mNew );
mCur = mNew;
}
}
}
void GetCorrectionMatrices(
const matrix3x4_t &mShoulder,
const matrix3x4_t &mElbow,
const matrix3x4_t &mHand,
matrix3x4_t &mShoulderCorrection,
matrix3x4_t &mElbowCorrection
)
{
extern void Studio_AlignIKMatrix( matrix3x4_t &mMat, const Vector &vAlignTo );
// Get the positions of each node so we can get the direction vectors.
Vector vShoulder, vElbow, vHand;
MatrixPosition( mShoulder, vShoulder );
MatrixPosition( mElbow, vElbow );
MatrixPosition( mHand, vHand );
// Get rid of the translation.
matrix3x4_t mOriginalShoulder = mShoulder;
matrix3x4_t mOriginalElbow = mElbow;
MatrixSetColumn( Vector( 0, 0, 0 ), 3, mOriginalShoulder );
MatrixSetColumn( Vector( 0, 0, 0 ), 3, mOriginalElbow );
// Let the IK code align them like it would if we did IK on the joint.
matrix3x4_t mAlignedShoulder = mOriginalShoulder;
matrix3x4_t mAlignedElbow = mOriginalElbow;
Studio_AlignIKMatrix( mAlignedShoulder, vElbow-vShoulder );
Studio_AlignIKMatrix( mAlignedElbow, vHand-vElbow );
// Figure out the transformation from the aligned bones to the original ones.
matrix3x4_t mInvAlignedShoulder, mInvAlignedElbow;
MatrixInvert( mAlignedShoulder, mInvAlignedShoulder );
MatrixInvert( mAlignedElbow, mInvAlignedElbow );
ConcatTransforms( mInvAlignedShoulder, mOriginalShoulder, mShoulderCorrection );
ConcatTransforms( mInvAlignedElbow, mOriginalElbow, mElbowCorrection );
}
void C_CSPlayer::BuildTransformations( CStudioHdr *pHdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed )
{
// First, setup our model's transformations like normal.
BaseClass::BuildTransformations( pHdr, pos, q, cameraTransform, boneMask, boneComputed );
if ( IsLocalPlayer() && !C_BasePlayer::ShouldDrawLocalPlayer() )
return;
if ( !cl_left_hand_ik.GetInt() )
return;
// If our current weapon has a bone named L_Hand_Attach, then we attach the player's
// left hand (Valvebiped.Bip01_L_Hand) to it.
C_BaseCombatWeapon *pWeapon = GetActiveWeapon();
if ( !pWeapon )
return;
// Have the weapon setup its bones.
pWeapon->SetupBones( NULL, 0, BONE_USED_BY_ANYTHING, gpGlobals->curtime );
int iWeaponBone = 0;
if ( FindWeaponAttachmentBone( pWeapon, iWeaponBone ) )
{
int iMyBone = 0;
if ( FindMyAttachmentBone( this, iMyBone, pHdr ) )
{
int iHand = iMyBone;
int iElbow = pHdr->pBone( iHand )->parent;
int iShoulder = pHdr->pBone( iElbow )->parent;
matrix3x4_t *pBones = &GetBoneForWrite( 0 );
// Store off the original hand position.
matrix3x4_t mSource = pBones[iHand];
// Figure out the rotation offset from the current shoulder and elbow bone rotations
// and what the IK code's alignment code is going to produce, because we'll have to
// re-apply that offset after the IK runs.
matrix3x4_t mShoulderCorrection, mElbowCorrection;
GetCorrectionMatrices( pBones[iShoulder], pBones[iElbow], pBones[iHand], mShoulderCorrection, mElbowCorrection );
// Do the IK solution.
Vector vHandTarget;
MatrixPosition( pWeapon->GetBone( iWeaponBone ), vHandTarget );
Studio_SolveIK( iShoulder, iElbow, iHand, vHandTarget, pBones );
// Now reapply the rotation correction.
matrix3x4_t mTempShoulder = pBones[iShoulder];
matrix3x4_t mTempElbow = pBones[iElbow];
ConcatTransforms( mTempShoulder, mShoulderCorrection, pBones[iShoulder] );
ConcatTransforms( mTempElbow, mElbowCorrection, pBones[iElbow] );
// Now apply the transformation on the hand to the fingers.
matrix3x4_t &mDest = GetBoneForWrite( iHand );
ApplyDifferenceTransformToChildren( this, mSource, mDest, iHand );
}
}
}
C_BaseAnimating * C_CSPlayer::BecomeRagdollOnClient()
{
return NULL;
}
IRagdoll* C_CSPlayer::GetRepresentativeRagdoll() const
{
if ( m_hRagdoll.Get() )
{
C_CSRagdoll *pRagdoll = (C_CSRagdoll*)m_hRagdoll.Get();
return pRagdoll->GetIRagdoll();
}
else
{
return NULL;
}
}
void C_CSPlayer::PlayReloadEffect()
{
// Only play the effect for other players.
if ( this == C_CSPlayer::GetLocalCSPlayer() )
{
Assert( false ); // We shouldn't have been sent this message.
return;
}
// Get the view model for our current gun.
CWeaponCSBase *pWeapon = GetActiveCSWeapon();
if ( !pWeapon )
return;
// The weapon needs two models, world and view, but can only cache one. Synthesize the other.
const CCSWeaponInfo &info = pWeapon->GetCSWpnData();
const model_t *pModel = modelinfo->GetModel( modelinfo->GetModelIndex( info.szViewModel ) );
if ( !pModel )
return;
CStudioHdr studioHdr( modelinfo->GetStudiomodel( pModel ), mdlcache );
if ( !studioHdr.IsValid() )
return;
// Find the reload animation.
for ( int iSeq=0; iSeq < studioHdr.GetNumSeq(); iSeq++ )
{
mstudioseqdesc_t *pSeq = &studioHdr.pSeqdesc( iSeq );
if ( pSeq->activity == ACT_VM_RELOAD )
{
float poseParameters[MAXSTUDIOPOSEPARAM];
memset( poseParameters, 0, sizeof( poseParameters ) );
float cyclesPerSecond = Studio_CPS( &studioHdr, *pSeq, iSeq, poseParameters );
// Now read out all the sound events with their timing
for ( int iEvent=0; iEvent < pSeq->numevents; iEvent++ )
{
mstudioevent_t *pEvent = pSeq->pEvent( iEvent );
if ( pEvent->event == CL_EVENT_SOUND )
{
CCSSoundEvent event;
event.m_SoundName = pEvent->options;
event.m_flEventTime = gpGlobals->curtime + pEvent->cycle / cyclesPerSecond;
m_SoundEvents.AddToTail( event );
}
}
break;
}
}
}
void C_CSPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
{
if ( event == PLAYERANIMEVENT_THROW_GRENADE )
{
// Let the server handle this event. It will update m_iThrowGrenadeCounter and the client will
// pick up the event in CCSPlayerAnimState.
}
else
{
m_PlayerAnimState->DoAnimationEvent( event, nData );
}
}
void C_CSPlayer::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
{
if( event == 7001 )
{
bool bInWater = ( enginetrace->GetPointContents(origin) & CONTENTS_WATER );
//Msg( "run event ( %d )\n", bInWater ? 1 : 0 );
if( bInWater )
{
//run splash
CEffectData data;
//trace up from foot position to the water surface
trace_t tr;
Vector vecTrace(0,0,1024);
UTIL_TraceLine( origin, origin + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.fractionleftsolid )
{
data.m_vOrigin = origin + (vecTrace * tr.fractionleftsolid);
}
else
{
data.m_vOrigin = origin;
}
data.m_vNormal = Vector( 0,0,1 );
data.m_flScale = random->RandomFloat( 4.0f, 5.0f );
DispatchEffect( "watersplash", data );
}
}
else if( event == 7002 )
{
bool bInWater = ( enginetrace->GetPointContents(origin) & CONTENTS_WATER );
//Msg( "walk event ( %d )\n", bInWater ? 1 : 0 );
if( bInWater )
{
//walk ripple
CEffectData data;
//trace up from foot position to the water surface
trace_t tr;
Vector vecTrace(0,0,1024);
UTIL_TraceLine( origin, origin + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.fractionleftsolid )
{
data.m_vOrigin = origin + (vecTrace * tr.fractionleftsolid);
}
else
{
data.m_vOrigin = origin;
}
data.m_vNormal = Vector( 0,0,1 );
data.m_flScale = random->RandomFloat( 4.0f, 7.0f );
DispatchEffect( "waterripple", data );
}
}
else
BaseClass::FireEvent( origin, angles, event, options );
}
void C_CSPlayer::SetActivity( Activity eActivity )
{
m_Activity = eActivity;
}
Activity C_CSPlayer::GetActivity() const
{
return m_Activity;
}
const Vector& C_CSPlayer::GetRenderOrigin( void )
{
if ( m_hRagdoll.Get() )
{
C_CSRagdoll *pRagdoll = (C_CSRagdoll*)m_hRagdoll.Get();
if ( pRagdoll->IsInitialized() )
return pRagdoll->GetRenderOrigin();
}
return BaseClass::GetRenderOrigin();
}
void C_CSPlayer::Simulate( void )
{
if( this != C_BasePlayer::GetLocalPlayer() )
{
if ( IsEffectActive( EF_DIMLIGHT ) )
{
QAngle eyeAngles = EyeAngles();
Vector vForward;
AngleVectors( eyeAngles, &vForward );
int iAttachment = LookupAttachment( "muzzle_flash" );
if ( iAttachment < 0 )
return;
Vector vecOrigin;
QAngle dummy;
GetAttachment( iAttachment, vecOrigin, dummy );
trace_t tr;
UTIL_TraceLine( vecOrigin, vecOrigin + (vForward * 200), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
if( !m_pFlashlightBeam )
{
BeamInfo_t beamInfo;
beamInfo.m_nType = TE_BEAMPOINTS;
beamInfo.m_vecStart = tr.startpos;
beamInfo.m_vecEnd = tr.endpos;
beamInfo.m_pszModelName = "sprites/glow01.vmt";
beamInfo.m_pszHaloName = "sprites/glow01.vmt";
beamInfo.m_flHaloScale = 3.0;
beamInfo.m_flWidth = 8.0f;
beamInfo.m_flEndWidth = 35.0f;
beamInfo.m_flFadeLength = 300.0f;
beamInfo.m_flAmplitude = 0;
beamInfo.m_flBrightness = 60.0;
beamInfo.m_flSpeed = 0.0f;
beamInfo.m_nStartFrame = 0.0;
beamInfo.m_flFrameRate = 0.0;
beamInfo.m_flRed = 255.0;
beamInfo.m_flGreen = 255.0;
beamInfo.m_flBlue = 255.0;
beamInfo.m_nSegments = 8;
beamInfo.m_bRenderable = true;
beamInfo.m_flLife = 0.5;
beamInfo.m_nFlags = FBEAM_FOREVER | FBEAM_ONLYNOISEONCE | FBEAM_NOTILE | FBEAM_HALOBEAM;
m_pFlashlightBeam = beams->CreateBeamPoints( beamInfo );
}
if( m_pFlashlightBeam )
{
BeamInfo_t beamInfo;
beamInfo.m_vecStart = tr.startpos;
beamInfo.m_vecEnd = tr.endpos;
beamInfo.m_flRed = 255.0;
beamInfo.m_flGreen = 255.0;
beamInfo.m_flBlue = 255.0;
beams->UpdateBeamInfo( m_pFlashlightBeam, beamInfo );
dlight_t *el = effects->CL_AllocDlight( 0 );
el->origin = tr.endpos;
el->radius = 50;
el->color.r = 200;
el->color.g = 200;
el->color.b = 200;
el->die = gpGlobals->curtime + 0.1;
}
}
else if ( m_pFlashlightBeam )
{
ReleaseFlashlight();
}
}
BaseClass::Simulate();
}
void C_CSPlayer::ReleaseFlashlight( void )
{
if( m_pFlashlightBeam )
{
m_pFlashlightBeam->flags = 0;
m_pFlashlightBeam->die = gpGlobals->curtime - 1;
m_pFlashlightBeam = NULL;
}
}
bool C_CSPlayer::HasC4( void )
{
if( this == C_CSPlayer::GetLocalPlayer() )
{
return Weapon_OwnsThisType( "weapon_c4" );
}
else
{
C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
return pCSPR->HasC4( entindex() );
}
}
void C_CSPlayer::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
{
static ConVar *violence_hblood = cvar->FindVar( "violence_hblood" );
if ( violence_hblood && !violence_hblood->GetBool() )
return;
BaseClass::ImpactTrace( pTrace, iDamageType, pCustomImpactName );
}
//-----------------------------------------------------------------------------
void C_CSPlayer::CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
{
/**
* TODO: Fix this!
// CS:S standing eyeheight is above the collision volume, so we need to pull it
// down when we go into close quarters.
float maxEyeHeightAboveBounds = VEC_VIEW_SCALED( this ).z - VEC_HULL_MAX_SCALED( this ).z;
if ( GetObserverMode() == OBS_MODE_IN_EYE &&
maxEyeHeightAboveBounds > 0.0f &&
GetObserverTarget() &&
GetObserverTarget()->IsPlayer() )
{
const float eyeClearance = 12.0f; // eye pos must be this far below the ceiling
C_CSPlayer *target = ToCSPlayer( GetObserverTarget() );
Vector offset = eyeOrigin - GetAbsOrigin();
Vector vHullMin = VEC_HULL_MIN_SCALED( this );
vHullMin.z = 0.0f;
Vector vHullMax = VEC_HULL_MAX_SCALED( this );
Vector start = GetAbsOrigin();
start.z += vHullMax.z;
Vector end = start;
end.z += eyeClearance + VEC_VIEW_SCALED( this ).z - vHullMax_SCALED( this ).z;
vHullMax.z = 0.0f;
Vector fudge( 1, 1, 0 );
vHullMin += fudge;
vHullMax -= fudge;
trace_t trace;
Ray_t ray;
ray.Init( start, end, vHullMin, vHullMax );
UTIL_TraceRay( ray, MASK_PLAYERSOLID, target, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( trace.fraction < 1.0f )
{
float est = start.z + trace.fraction * (end.z - start.z) - GetAbsOrigin().z - eyeClearance;
if ( ( target->GetFlags() & FL_DUCKING ) == 0 && !target->GetFallVelocity() && !target->IsDucked() )
{
offset.z = est;
}
else
{
offset.z = MIN( est, offset.z );
}
eyeOrigin.z = GetAbsOrigin().z + offset.z;
}
}
*/
BaseClass::CalcObserverView( eyeOrigin, eyeAngles, fov );
}
//=============================================================================
// HPE_BEGIN:
//=============================================================================
// [tj] checks if this player has another given player on their Steam friends list.
bool C_CSPlayer::HasPlayerAsFriend(C_CSPlayer* player)
{
if (!steamapicontext || !steamapicontext->SteamFriends() || !steamapicontext->SteamUtils() || !player)
{
return false;
}
player_info_t pi;
if ( !engine->GetPlayerInfo( player->entindex(), &pi ) )
{
return false;
}
if ( !pi.friendsID )
{
return false;
}
// check and see if they're on the local player's friends list
CSteamID steamID( pi.friendsID, 1, steamapicontext->SteamUtils()->GetConnectedUniverse(), k_EAccountTypeIndividual );
return steamapicontext->SteamFriends()->HasFriend( steamID, k_EFriendFlagImmediate);
}
// [menglish] Returns whether this player is dominating or is being dominated by the specified player
bool C_CSPlayer::IsPlayerDominated( int iPlayerIndex )
{
return m_bPlayerDominated.Get( iPlayerIndex );
}
bool C_CSPlayer::IsPlayerDominatingMe( int iPlayerIndex )
{
return m_bPlayerDominatingMe.Get( iPlayerIndex );
}
// helper interpolation functions
namespace Interpolators
{
inline float Linear( float t ) { return t; }
inline float SmoothStep( float t )
{
t = 3 * t * t - 2.0f * t * t * t;
return t;
}
inline float SmoothStep2( float t )
{
return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
}
inline float SmoothStepStart( float t )
{
t = 0.5f * t;
t = 3 * t * t - 2.0f * t * t * t;
t = t* 2.0f;
return t;
}
inline float SmoothStepEnd( float t )
{
t = 0.5f * t + 0.5f;
t = 3 * t * t - 2.0f * t * t * t;
t = (t - 0.5f) * 2.0f;
return t;
}
}
//-----------------------------------------------------------------------------
// Purpose: Calculate the view for the player while he's in freeze frame observer mode
//-----------------------------------------------------------------------------
void C_CSPlayer::CalcFreezeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
{
C_BaseEntity *pTarget = GetObserverTarget();
//=============================================================================
// HPE_BEGIN:
// [Forrest] Added sv_disablefreezecam check
//=============================================================================
static ConVarRef sv_disablefreezecam( "sv_disablefreezecam" );
if ( !pTarget || cl_disablefreezecam.GetBool() || sv_disablefreezecam.GetBool() )
//=============================================================================
// HPE_END
//=============================================================================
{
return CalcDeathCamView( eyeOrigin, eyeAngles, fov );
}
// pick a zoom camera target
Vector vLookAt = pTarget->GetObserverCamOrigin(); // Returns ragdoll origin if they're ragdolled
vLookAt += GetChaseCamViewOffset( pTarget );
// look over ragdoll, not through
if ( !pTarget->IsAlive() )
vLookAt.z += pTarget->GetBaseAnimating() ? VEC_DEAD_VIEWHEIGHT_SCALED( pTarget->GetBaseAnimating() ).z : VEC_DEAD_VIEWHEIGHT.z;
// Figure out a view position in front of the target
Vector vEyeOnPlane = eyeOrigin;
vEyeOnPlane.z = vLookAt.z;
Vector vToTarget = vLookAt - vEyeOnPlane;
VectorNormalize( vToTarget );
// goal position of camera is pulled away from target by m_flFreezeFrameDistance
Vector vTargetPos = vLookAt - (vToTarget * m_flFreezeFrameDistance);
// Now trace out from the target, so that we're put in front of any walls
trace_t trace;
C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
UTIL_TraceHull( vLookAt, vTargetPos, WALL_MIN, WALL_MAX, MASK_SOLID, pTarget, COLLISION_GROUP_NONE, &trace );
C_BaseEntity::PopEnableAbsRecomputations();
if ( trace.fraction < 1.0 )
{
// The camera's going to be really close to the target. So we don't end up
// looking at someone's chest, aim close freezecams at the target's eyes.
vTargetPos = trace.endpos;
// To stop all close in views looking up at character's chins, move the view up.
vTargetPos.z += fabs(vLookAt.z - vTargetPos.z) * 0.85;
C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
UTIL_TraceHull( vLookAt, vTargetPos, WALL_MIN, WALL_MAX, MASK_SOLID, pTarget, COLLISION_GROUP_NONE, &trace );
C_BaseEntity::PopEnableAbsRecomputations();
vTargetPos = trace.endpos;
}
// Look directly at the target
vToTarget = vLookAt - vTargetPos;
VectorNormalize( vToTarget );
VectorAngles( vToTarget, eyeAngles );
float fCurTime = gpGlobals->curtime - m_flFreezeFrameStartTime;
float fInterpolant = clamp( fCurTime / spec_freeze_traveltime.GetFloat(), 0.0f, 1.0f );
fInterpolant = Interpolators::SmoothStepEnd( fInterpolant );
// move the eye toward our killer
VectorLerp( m_vecFreezeFrameStart, vTargetPos, fInterpolant, eyeOrigin );
if ( fCurTime >= spec_freeze_traveltime.GetFloat() && !m_bSentFreezeFrame )
{
IGameEvent *pEvent = gameeventmanager->CreateEvent( "freezecam_started" );
if ( pEvent )
{
gameeventmanager->FireEventClientSide( pEvent );
}
m_bSentFreezeFrame = true;
view->FreezeFrame( spec_freeze_time.GetFloat() );
}
}
float C_CSPlayer::GetDeathCamInterpolationTime()
{
static ConVarRef sv_disablefreezecam( "sv_disablefreezecam" );
if ( cl_disablefreezecam.GetBool() || sv_disablefreezecam.GetBool() || !GetObserverTarget() )
return spec_freeze_time.GetFloat();
else
return CS_DEATH_ANIMATION_TIME;
}
//=============================================================================
// HPE_END
//=============================================================================