2554 lines
68 KiB
C++
2554 lines
68 KiB
C++
//========= 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;
|
|
bool 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 );
|
|
}
|
|
|
|
bool 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 );
|
|
return 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
|
|
//=============================================================================
|
|
|