BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/client/dod/c_dod_player.cpp

2781 lines
75 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "cbase.h"
#include "c_dod_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"
#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 "fx_dod_blood.h"
#include "effect_dispatch_data.h" //for water ripple / splash effect
#include "c_te_effect_dispatch.h" //ditto
#include "dod_gamerules.h"
#include <igameevents.h>
#include "physpropclientside.h"
#include "obstacle_pushaway.h"
#include "prediction.h"
#include "viewangleanim.h"
#include "soundenvelope.h"
#include "weapon_dodbipodgun.h"
#include "c_dod_basegrenade.h"
#include "dod_weapon_parse.h"
#include "view_scene.h"
#include "dod_headiconmanager.h"
#include "c_world.h"
#include "c_dod_bombtarget.h"
#include "toolframework/itoolframework.h"
#include "toolframework_client.h"
#include "c_team.h"
#include "collisionutils.h"
#include "weapon_dodsniper.h"
// NVNT - haptics system for spectating and grenades
#include "haptics/haptic_utils.h"
// NVNT - for grenade effects
#include "weapon_dodbasegrenade.h"
// NVNT - for planting bomb effect
#include "weapon_dodbasebomb.h"
#if defined( CDODPlayer )
#undef CDODPlayer
#endif
#include "iviewrender_beams.h" // flashlight beam
#include "materialsystem/imesh.h" //for materials->FindMaterial
#include "iviewrender.h" //for view->
ConVar cl_ragdoll_physics_enable( "cl_ragdoll_physics_enable", "1", 0, "Enable/disable ragdoll physics." );
ConVar cl_autoreload( "cl_autoreload", "1", FCVAR_USERINFO | FCVAR_ARCHIVE, "Set to 1 to auto reload your weapon when it is empty" );
ConVar cl_autorezoom( "cl_autorezoom", "1", FCVAR_USERINFO | FCVAR_ARCHIVE, "When set to 1, sniper rifles and bazooka weapons will automatically raise after each shot" );
#include "tier0/memdbgon.h"
//======================================================
//
// Cold Breath Emitter - for DOD players.
//
class ColdBreathEmitter : public CSimpleEmitter
{
public:
ColdBreathEmitter( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}
static ColdBreathEmitter *Create( const char *pDebugName )
{
return new ColdBreathEmitter( pDebugName );
}
void UpdateVelocity( SimpleParticle *pParticle, float timeDelta )
{
// Float up when lifetime is half gone.
pParticle->m_vecVelocity[2] -= ( 8.0f * timeDelta );
// FIXME: optimize this....
pParticle->m_vecVelocity *= ExponentialDecay( 0.9, 0.03, timeDelta );
}
virtual float UpdateRoll( SimpleParticle *pParticle, float timeDelta )
{
pParticle->m_flRoll += pParticle->m_flRollDelta * timeDelta;
pParticle->m_flRollDelta += pParticle->m_flRollDelta * ( timeDelta * -2.0f );
//Cap the minimum roll
if ( fabs( pParticle->m_flRollDelta ) < 0.5f )
{
pParticle->m_flRollDelta = ( pParticle->m_flRollDelta > 0.0f ) ? 0.5f : -0.5f;
}
return pParticle->m_flRoll;
}
private:
ColdBreathEmitter( const ColdBreathEmitter & );
};
void RecvProxy_StunTime( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
C_DODPlayer *pPlayerData = (C_DODPlayer *) pStruct;
if( pPlayerData != C_BasePlayer::GetLocalPlayer() )
return;
if ( (pPlayerData->m_flStunDuration != pData->m_Value.m_Float) && pData->m_Value.m_Float > 0 )
{
pPlayerData->m_flStunAlpha = 1;
}
pPlayerData->m_flStunDuration = pData->m_Value.m_Float;
pPlayerData->m_flStunEffectTime = gpGlobals->curtime + pPlayerData->m_flStunDuration;
}
// -------------------------------------------------------------------------------- //
// 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_DODPlayer *pPlayer = dynamic_cast< C_DODPlayer* >( 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()
void RecvProxy_CapAreaIndex( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
CDODPlayerShared *pShared = ( CDODPlayerShared *)pStruct;
int iCapAreaIndex = pData->m_Value.m_Int;
if ( iCapAreaIndex != pShared->GetCPIndex() )
{
pShared->SetCPIndex( iCapAreaIndex );
}
}
// ------------------------------------------------------------------------------------------ //
// Data tables.
// ------------------------------------------------------------------------------------------ //
// CDODPlayerShared Data Tables
//=============================
// specific to the local player ( ideally should not be in CDODPlayerShared! )
BEGIN_RECV_TABLE_NOBASE( CDODPlayerShared, DT_DODSharedLocalPlayerExclusive )
RecvPropInt( RECVINFO( m_iPlayerClass ) ),
RecvPropInt( RECVINFO( m_iDesiredPlayerClass ) ),
RecvPropFloat( RECVINFO( m_flDeployedYawLimitLeft ) ),
RecvPropFloat( RECVINFO( m_flDeployedYawLimitRight ) ),
RecvPropInt( RECVINFO( m_iCPIndex ), 0, RecvProxy_CapAreaIndex ),
RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominated ), RecvPropBool( RECVINFO( m_bPlayerDominated[0] ) ) ),
RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominatingMe ), RecvPropBool( RECVINFO( m_bPlayerDominatingMe[0] ) ) ),
END_RECV_TABLE()
// main table
BEGIN_RECV_TABLE_NOBASE( CDODPlayerShared, DT_DODPlayerShared )
RecvPropFloat( RECVINFO( m_flStamina ) ),
RecvPropTime( RECVINFO( m_flSlowedUntilTime ) ),
RecvPropBool( RECVINFO( m_bProne ) ),
RecvPropBool( RECVINFO( m_bIsSprinting ) ),
RecvPropTime( RECVINFO( m_flGoProneTime ) ),
RecvPropTime( RECVINFO( m_flUnProneTime ) ),
RecvPropTime( RECVINFO( m_flDeployChangeTime ) ),
RecvPropFloat( RECVINFO( m_flDeployedHeight ) ),
RecvPropBool( RECVINFO( m_bPlanting ) ),
RecvPropBool( RECVINFO( m_bDefusing ) ),
RecvPropDataTable( "dodsharedlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_DODSharedLocalPlayerExclusive) ),
END_RECV_TABLE()
// C_DODPlayer Data Tables
//=========================
// specific to the local player
BEGIN_RECV_TABLE_NOBASE( C_DODPlayer, DT_DODLocalPlayerExclusive )
RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
RecvPropFloat( RECVINFO( m_flStunDuration ), 0, RecvProxy_StunTime ),
RecvPropFloat( RECVINFO( m_flStunMaxAlpha)),
RecvPropInt( RECVINFO( m_iProgressBarDuration ) ),
RecvPropFloat( RECVINFO( m_flProgressBarStartTime ) ),
END_RECV_TABLE()
// all players except the local player
BEGIN_RECV_TABLE_NOBASE( C_DODPlayer, DT_DODNonLocalPlayerExclusive )
RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
END_RECV_TABLE()
// main table
IMPLEMENT_CLIENTCLASS_DT( C_DODPlayer, DT_DODPlayer, CDODPlayer )
RecvPropDataTable( RECVINFO_DT( m_Shared ), 0, &REFERENCE_RECV_TABLE( DT_DODPlayerShared ) ),
RecvPropDataTable( "dodlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_DODLocalPlayerExclusive) ),
RecvPropDataTable( "dodnonlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_DODNonLocalPlayerExclusive) ),
RecvPropFloat( RECVINFO( m_angEyeAngles[0] ) ),
RecvPropFloat( RECVINFO( m_angEyeAngles[1] ) ),
RecvPropEHandle( RECVINFO( m_hRagdoll ) ),
RecvPropBool( RECVINFO( m_bSpawnInterpCounter ) ),
RecvPropInt( RECVINFO( m_iAchievementAwardsMask ) ),
END_RECV_TABLE()
// ------------------------------------------------------------------------------------------ //
// Prediction tables.
// ------------------------------------------------------------------------------------------ //
BEGIN_PREDICTION_DATA_NO_BASE( CDODPlayerShared )
DEFINE_PRED_FIELD( m_bProne, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flStamina, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bIsSprinting, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flGoProneTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flUnProneTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flDeployChangeTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flDeployedHeight, FIELD_FLOAT, FTYPEDESC_INSENDTABLE )
END_PREDICTION_DATA()
BEGIN_PREDICTION_DATA( C_DODPlayer )
DEFINE_PRED_TYPEDESCRIPTION( m_Shared, CDODPlayerShared ),
DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
DEFINE_PRED_FIELD( m_nSequence, FIELD_INTEGER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
END_PREDICTION_DATA()
// ----------------------------------------------------------------------------- //
// Client ragdoll entity.
// ----------------------------------------------------------------------------- //
ConVar cl_low_violence( "cl_low_violence", "0" );
ConVar cl_ragdoll_fade_time( "cl_ragdoll_fade_time", "15", FCVAR_CLIENTDLL );
ConVar cl_ragdoll_pronecheck_distance( "cl_ragdoll_pronecheck_distance", "64", FCVAR_GAMEDLL );
class C_DODRagdoll : public C_BaseAnimatingOverlay
{
public:
DECLARE_CLASS( C_DODRagdoll, C_BaseAnimatingOverlay );
DECLARE_CLIENTCLASS();
C_DODRagdoll();
~C_DODRagdoll();
virtual void OnDataChanged( DataUpdateType_t type );
int GetPlayerEntIndex() const;
IRagdoll* GetIRagdoll() const;
void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName );
void ClientThink( void );
void StartFadeOut( float fDelay );
bool IsRagdollVisible();
private:
C_DODRagdoll( const C_DODRagdoll & ) {}
void Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity );
void CreateLowViolenceRagdoll();
void CreateDODRagdoll();
private:
EHANDLE m_hPlayer;
CNetworkVector( m_vecRagdollVelocity );
CNetworkVector( m_vecRagdollOrigin );
float m_fDeathTime;
bool m_bFadingOut;
};
IMPLEMENT_CLIENTCLASS_DT_NOBASE( C_DODRagdoll, DT_DODRagdoll, CDODRagdoll )
RecvPropVector( RECVINFO(m_vecRagdollOrigin) ),
RecvPropEHandle( RECVINFO( m_hPlayer ) ),
RecvPropInt( RECVINFO( m_nModelIndex ) ),
RecvPropInt( RECVINFO(m_nForceBone) ),
RecvPropVector( RECVINFO(m_vecForce) ),
RecvPropVector( RECVINFO( m_vecRagdollVelocity ) )
END_RECV_TABLE()
C_DODRagdoll::C_DODRagdoll()
{
m_fDeathTime = -1;
m_bFadingOut = false;
}
C_DODRagdoll::~C_DODRagdoll()
{
PhysCleanupFrictionSounds( this );
}
void C_DODRagdoll::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_DODRagdoll::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 strength
// 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 strength
// apply force where we hit it
pPhysicsObject->ApplyForceOffset( dir, hitpos );
// Blood spray!
FX_DOD_BloodSpray( hitpos, dir, 10 );
}
m_pRagdoll->ResetRagdollSleepAfterTime();
}
void C_DODRagdoll::CreateLowViolenceRagdoll()
{
// 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 )
{
CreateDODRagdoll();
}
else
{
int iDeathAnim = RandomInt( iMinDeathAnim, iMaxDeathAnim );
char str[512];
Q_snprintf( str, sizeof( str ), "death%d", iDeathAnim );
SetSequence( LookupSequence( str ) );
ForceClientSideAnimationOn();
SetNetworkOrigin( m_vecRagdollOrigin );
SetAbsOrigin( m_vecRagdollOrigin );
SetAbsVelocity( m_vecRagdollVelocity );
C_DODPlayer *pPlayer = dynamic_cast< C_DODPlayer* >( m_hPlayer.Get() );
if ( pPlayer && !pPlayer->IsDormant() )
{
// move my current model instance to the ragdoll's so decals are preserved.
pPlayer->SnatchModelInstance( this );
SetAbsAngles( pPlayer->GetRenderAngles() );
SetNetworkAngles( pPlayer->GetRenderAngles() );
}
Interp_Reset( GetVarMapping() );
}
}
void C_DODRagdoll::CreateDODRagdoll()
{
// 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_DODPlayer *pPlayer = dynamic_cast< C_DODPlayer* >( m_hPlayer.Get() );
#ifdef _DEBUG
DevMsg( 2, "CreateDODRagdoll %d %d\n", gpGlobals->framecount, pPlayer ? pPlayer->entindex() : 0 );
#endif
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.
if ( !pPlayer->IsLocalPlayer() && pPlayer->dod_IsInterpolationEnabled() )
{
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( "RagdollSpawn" ); // hax, find a neutral standing pose
if ( iSeq == -1 )
{
Assert( false ); // missing look_idle?
iSeq = 0;
}
SetSequence( iSeq ); // look_idle, basic pose
SetCycle( 0.0 );
Interp_Reset( varMap );
}
m_nBody = pPlayer->GetBody();
}
else
{
// overwrite network origin so later interpolation will
// use this position
SetNetworkOrigin( m_vecRagdollOrigin );
SetAbsOrigin( m_vecRagdollOrigin );
SetAbsVelocity( m_vecRagdollVelocity );
Interp_Reset( GetVarMapping() );
}
SetModelIndex( m_nModelIndex );
// 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;
if ( pPlayer && pPlayer == C_BasePlayer::GetLocalPlayer() )
{
pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
}
else
{
GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
}
InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt );
}
else
{
ClientLeafSystem()->SetRenderGroup( GetRenderHandle(), RENDER_GROUP_TRANSLUCENT_ENTITY );
}
// Fade out the ragdoll in a while
StartFadeOut( cl_ragdoll_fade_time.GetFloat() );
SetNextClientThink( gpGlobals->curtime + 5.0f );
}
void C_DODRagdoll::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_CREATED )
{
if ( cl_low_violence.GetInt() )
{
CreateLowViolenceRagdoll();
}
else
{
CreateDODRagdoll();
}
}
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_DODRagdoll::GetIRagdoll() const
{
return m_pRagdoll;
}
bool C_DODRagdoll::IsRagdollVisible()
{
Vector vMins = Vector(-1,-1,-1); //WorldAlignMins();
Vector vMaxs = Vector(1,1,1); //WorldAlignMaxs();
Vector origin = GetAbsOrigin();
if( !engine->IsBoxInViewCluster( vMins + origin, vMaxs + origin) )
{
return false;
}
else if( engine->CullBox( vMins + origin, vMaxs + origin ) )
{
return false;
}
return true;
}
void C_DODRagdoll::ClientThink( void )
{
SetNextClientThink( CLIENT_THINK_ALWAYS );
if ( m_bFadingOut == true )
{
int iAlpha = GetRenderColor().a;
int iFadeSpeed = 600.0f;
iAlpha = MAX( iAlpha - ( iFadeSpeed * gpGlobals->frametime ), 0 );
SetRenderMode( kRenderTransAlpha );
SetRenderColorA( iAlpha );
if ( iAlpha == 0 )
{
//Release();
AddEffects( EF_NODRAW );
}
return;
}
for( int iClient = 1; iClient <= gpGlobals->maxClients; ++iClient )
{
C_DODPlayer *pEnt = static_cast< C_DODPlayer *> ( UTIL_PlayerByIndex( iClient ) );
if(!pEnt || !pEnt->IsPlayer())
continue;
if ( m_hPlayer == NULL )
continue;
if ( pEnt->entindex() == m_hPlayer->entindex() )
continue;
if ( pEnt->GetHealth() <= 0 )
continue;
if ( pEnt->m_Shared.IsProne() == false )
continue;
Vector vTargetOrigin = pEnt->GetAbsOrigin();
Vector vMyOrigin = GetAbsOrigin();
Vector vDir = vTargetOrigin - vMyOrigin;
if ( vDir.Length() > cl_ragdoll_pronecheck_distance.GetInt() )
continue;
SetNextClientThink( CLIENT_THINK_ALWAYS );
m_bFadingOut = true;
return;
}
// if the player is looking at us, delay the fade
if ( IsRagdollVisible() )
{
StartFadeOut( 5.0 );
return;
}
if ( m_fDeathTime > gpGlobals->curtime )
return;
//Release(); // Die
AddEffects( EF_NODRAW );
}
void C_DODRagdoll::StartFadeOut( float fDelay )
{
m_fDeathTime = gpGlobals->curtime + fDelay;
SetNextClientThink( CLIENT_THINK_ALWAYS );
}
// ------------------------------------------------------------------------------------------ //
// C_DODPlayer implementation.
// ------------------------------------------------------------------------------------------ //
C_DODPlayer::C_DODPlayer() :
m_iv_angEyeAngles( "C_DODPlayer::m_iv_angEyeAngles" )
{
m_PlayerAnimState = CreatePlayerAnimState( this );
m_Shared.Init( this );
m_flPitchRecoilAccumulator = 0.0;
m_flYawRecoilAccumulator = 0.0;
m_flRecoilTimeRemaining = 0.0;
m_iProgressBarDuration = 0;
m_flProgressBarStartTime = 0.0f;
AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR );
m_flProneViewOffset = 0.0;
m_bProneSwayingRight = true;
m_iIDEntIndex = 0;
m_Hints.Init( this, NUM_HINTS, g_pszHintMessages );
m_pFlashlightBeam = NULL;
m_fNextThinkPushAway = 0.0f;
// Cold breath.
m_bColdBreathOn = false;
m_flColdBreathTimeStart = 0.0f;
m_flColdBreathTimeEnd = 0.0f;
m_hColdBreathEmitter = NULL;
m_hColdBreathMaterial = INVALID_MATERIAL_HANDLE;
m_flHideHeadIconUntilTime = 0.0f;
m_iAchievementAwardsMask = 0;
m_pHeadIconMaterial = NULL;
}
C_DODPlayer::~C_DODPlayer()
{
m_PlayerAnimState->Release();
ReleaseFlashlight();
// Kill the stamina sound!
if ( m_pStaminaSound )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pStaminaSound );
m_pStaminaSound = NULL;
}
// Cold breath.
DestroyColdBreathEmitter();
}
C_DODPlayer* C_DODPlayer::GetLocalDODPlayer()
{
return ToDODPlayer( C_BasePlayer::GetLocalPlayer() );
}
IRagdoll* C_DODPlayer::GetRepresentativeRagdoll() const
{
if ( m_hRagdoll.Get() )
{
C_DODRagdoll *pRagdoll = (C_DODRagdoll*)m_hRagdoll.Get();
return pRagdoll->GetIRagdoll();
}
else
{
return NULL;
}
}
const QAngle& C_DODPlayer::GetRenderAngles()
{
if ( IsRagdoll() )
{
return vec3_angle;
}
else
{
return m_PlayerAnimState->GetRenderAngles();
}
}
void C_DODPlayer::UpdateClientSideAnimation()
{
// 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_DODPlayer::GetLocalDODPlayer() )
m_PlayerAnimState->Update( EyeAngles()[YAW], m_angEyeAngles[PITCH] );
else
m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
BaseClass::UpdateClientSideAnimation();
}
ConVar dod_playachievementsound( "dod_playachievementsound", "1", FCVAR_ARCHIVE );
void C_DODPlayer::OnAchievementAchieved( int iAchievement )
{
// don't draw the head icon for a length of time after showing the particle effect
m_flHideHeadIconUntilTime = gpGlobals->curtime + 2.5;
if ( dod_playachievementsound.GetBool() )
{
EmitSound( "Achievement.Earned" );
}
BaseClass::OnAchievementAchieved( iAchievement );
}
int C_DODPlayer::DrawModel( int flags )
{
int nRetval = BaseClass::DrawModel( flags );
if ( nRetval != 0 )
{
// register to draw the head icon, unless we're hiding it due to the "achieved" particle effect
if ( gpGlobals->curtime > m_flHideHeadIconUntilTime )
{
HeadIconManager()->PlayerDrawn( this );
}
}
return nRetval;
}
void C_DODPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
{
m_PlayerAnimState->DoAnimationEvent( event, nData );
}
DODPlayerState C_DODPlayer::State_Get() const
{
return m_iPlayerState;
}
bool C_DODPlayer::CanShowClassMenu( void )
{
return ( GetTeamNumber() == TEAM_ALLIES || GetTeamNumber() == TEAM_AXIS );
}
void C_DODPlayer::DoRecoil( int iWpnID, float flWpnRecoil )
{
float flPitchRecoil = flWpnRecoil;
float flYawRecoil = flPitchRecoil / 4;
if( iWpnID == WEAPON_BAR )
flYawRecoil = MIN( flYawRecoil, 1.3 );
if ( m_Shared.IsInMGDeploy() )
{
flPitchRecoil = 0.0;
flYawRecoil = 0.0;
}
else if ( m_Shared.IsProne() &&
iWpnID != WEAPON_30CAL &&
iWpnID != WEAPON_MG42 ) //minor hackage
{
flPitchRecoil = flPitchRecoil / 4;
flYawRecoil = flYawRecoil / 4;
}
else if ( m_Shared.IsDucking() )
{
flPitchRecoil = flPitchRecoil / 2;
flYawRecoil = flYawRecoil / 2;
}
SetRecoilAmount( flPitchRecoil, flYawRecoil );
}
//Set the amount of pitch and yaw recoil we want to do over the next RECOIL_DURATION seconds
void C_DODPlayer::SetRecoilAmount( float flPitchRecoil, float flYawRecoil )
{
//Slam the values, abandon previous recoils
m_flPitchRecoilAccumulator = flPitchRecoil;
flYawRecoil = flYawRecoil * random->RandomFloat( 0.8, 1.1 );
if( random->RandomInt( 0,1 ) <= 0 )
m_flYawRecoilAccumulator = flYawRecoil;
else
m_flYawRecoilAccumulator = -flYawRecoil;
m_flRecoilTimeRemaining = RECOIL_DURATION;
}
//Get the amount of recoil we should do this frame
void C_DODPlayer::GetRecoilToAddThisFrame( float &flPitchRecoil, float &flYawRecoil )
{
if( m_flRecoilTimeRemaining <= 0 )
{
flPitchRecoil = 0.0;
flYawRecoil = 0.0;
return;
}
float flRemaining = MIN( m_flRecoilTimeRemaining, gpGlobals->frametime );
float flRecoilProportion = ( flRemaining / RECOIL_DURATION );
flPitchRecoil = m_flPitchRecoilAccumulator * flRecoilProportion;
flYawRecoil = m_flYawRecoilAccumulator * flRecoilProportion;
m_flRecoilTimeRemaining -= gpGlobals->frametime;
}
//-----------------------------------------------------------------------------
// Purpose: Input handling
//-----------------------------------------------------------------------------
bool C_DODPlayer::CreateMove( float flInputSampleTime, CUserCmd *pCmd )
{
// Lock view if deployed
if( m_Shared.IsInMGDeploy() )
{
m_Shared.ClampDeployedAngles( &pCmd->viewangles );
}
//if we're prone and moving, do some sway
if( m_Shared.IsProne() && IsAlive() )
{
float flSpeed = GetAbsVelocity().Length();
float flSwayAmount = PRONE_SWAY_AMOUNT * gpGlobals->frametime;
if( flSpeed > 10 )
{
if (m_flProneViewOffset >= PRONE_MAX_SWAY)
{
m_bProneSwayingRight = false;
}
else if (m_flProneViewOffset <= -PRONE_MAX_SWAY)
{
m_bProneSwayingRight = true;
}
if (m_bProneSwayingRight)
{
pCmd->viewangles[YAW] += flSwayAmount;
m_flProneViewOffset += flSwayAmount;
}
else
{
pCmd->viewangles[YAW] -= flSwayAmount;
m_flProneViewOffset -= flSwayAmount;
}
}
else
{
// Return to 0 prone sway offset gradually
//Quick Checks to make sure it isn't bigger or smaller than our sway amount
if ( (m_flProneViewOffset < 0.0 && m_flProneViewOffset > -flSwayAmount) ||
(m_flProneViewOffset > 0.0 && m_flProneViewOffset < flSwayAmount) )
{
m_flProneViewOffset = 0.0;
}
if (m_flProneViewOffset > 0.0)
{
pCmd->viewangles[YAW] -= flSwayAmount;
m_flProneViewOffset -= flSwayAmount;
}
else if (m_flProneViewOffset < 0.0)
{
pCmd->viewangles[YAW] += flSwayAmount;
m_flProneViewOffset += flSwayAmount;
}
}
}
bool bResult = BaseClass::CreateMove( flInputSampleTime, pCmd );
AvoidPlayers( pCmd );
return bResult;
}
// How fast to avoid collisions with center of other object, in units per second
#define AVOID_SPEED 1000.0f
ConVar cl_avoidspeed( "cl_avoidspeed", "1000.0f", FCVAR_CLIENTDLL );
extern ConVar cl_forwardspeed;
extern ConVar cl_backspeed;
extern ConVar cl_sidespeed;
bool C_DODPlayer::ShouldDraw( void )
{
if( IsDormant() )
return false;
// 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();
}
//-----------------------------------------------------------------------------
// Deal with visibility
//-----------------------------------------------------------------------------
void C_DODPlayer::GetToolRecordingState( KeyValues *msg )
{
#ifndef _XBOX
BaseClass::GetToolRecordingState( msg );
BaseEntityRecordingState_t *pBaseEntityState = (BaseEntityRecordingState_t*)msg->GetPtr( "baseentity" );
if ( IsLocalPlayer() )
{
pBaseEntityState->m_bVisible = !IsDormant() && IsAlive() && ( GetTeamNumber() != TEAM_SPECTATOR ) &&
( GetRenderMode() != kRenderNone ) && (GetObserverMode() != OBS_MODE_DEATHCAM) && !IsEffectActive(EF_NODRAW);
}
#endif
}
CWeaponDODBase* C_DODPlayer::GetActiveDODWeapon() const
{
C_BaseCombatWeapon *pWpn = GetActiveWeapon();
if ( !pWpn )
return NULL;
return dynamic_cast< CWeaponDODBase* >( pWpn );
}
C_BaseAnimating * C_DODPlayer::BecomeRagdollOnClient()
{
return NULL;
}
void C_DODPlayer::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
{
if( event == 7002 )
{
if( this == C_BasePlayer::GetLocalPlayer() )
return;
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
if ( !pWeapon )
return;
int iAttachment = 2;
Vector vecOrigin;
QAngle angAngles;
if( pWeapon->GetAttachment( iAttachment, vecOrigin, angAngles ) )
{
int shellType = atoi(options);
CEffectData data;
data.m_nHitBox = shellType;
data.m_vOrigin = vecOrigin;
data.m_vAngles = angAngles;
DispatchEffect( "DOD_EjectBrass", data );
}
}
else
BaseClass::FireEvent( origin, angles, event, options );
/*
// MATTTODO: water footstep effects
if( event == 7001 )
{
bool bInWater = ( enginetrace->GetPointContents(origin) & CONTENTS_WATER );
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 );
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 );
}
}
*/
}
// NVNT gate for spectating.
static bool inSpectating_Haptics = false;
// NVNT check grenade things ( -- this is here to avoid modificaions to the grenade class -- )
static bool s_holdingGrenade = false;
static bool s_grenadePinPulled = false;
static bool s_grenadeArmed = false;
static bool s_bombPlanting = false;
void C_DODPlayer::ClientThink()
{
BaseClass::ClientThink();
if ( gpGlobals->curtime >= m_fNextThinkPushAway )
{
PerformObstaclePushaway( this );
m_fNextThinkPushAway = gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL;
}
if ( IsLocalPlayer() )
{
UpdateIDTarget();
StaminaSoundThink();
// Recoil
QAngle viewangles;
engine->GetViewAngles( viewangles );
float flYawRecoil;
float flPitchRecoil;
GetRecoilToAddThisFrame( flPitchRecoil, flYawRecoil );
// Recoil
if( flPitchRecoil > 0 )
{
//add the recoil pitch
viewangles[PITCH] -= flPitchRecoil;
viewangles[YAW] += flYawRecoil;
}
// Sniper sway
if( m_Shared.IsSniperZoomed() && GetFOV() <= 20 )
{
//multiply by frametime to balance for framerate changes
float x = gpGlobals->frametime * cos( gpGlobals->curtime );
float y = gpGlobals->frametime * 2 * cos( 2 * gpGlobals->curtime );
float scale;
if( m_Shared.IsDucking() ) //duck
scale = ZOOM_SWAY_DUCKING;
else if( m_Shared.IsProne() )
scale = ZOOM_SWAY_PRONE;
else //standing
scale = ZOOM_SWAY_STANDING;
if( GetAbsVelocity().Length() > 10 )
scale += ZOOM_SWAY_MOVING_PENALTY;
viewangles[PITCH] += y * scale;
viewangles[YAW] += x * scale;
}
engine->SetViewAngles( viewangles );
// NVNT check spectator nav.
if( ( ( GetTeamNumber() == TEAM_SPECTATOR ) || ( !this->IsAlive() ) ) ) {
if(!inSpectating_Haptics)
{
if ( haptics )
haptics->SetNavigationClass("spectate");
inSpectating_Haptics = true;
}
}else{
if(inSpectating_Haptics) {
if ( haptics )
haptics->SetNavigationClass("on_foot");
inSpectating_Haptics = false;
}
}
// NVNT check grenade things ( -- this is here to avoid modificaions to the grenade class -- )
C_WeaponDODBaseGrenade *heldGrenade = dynamic_cast<C_WeaponDODBaseGrenade*>(GetActiveDODWeapon());
if(heldGrenade)
{
if(!s_holdingGrenade)
{
s_holdingGrenade = true;
}
bool pinPulled = heldGrenade->m_bPinPulled;
if(pinPulled != s_grenadePinPulled) {
if(pinPulled)
{
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "PinPulled");
}else {
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "PinReplaced");
}
s_grenadePinPulled = pinPulled;
}
bool grenadeArmed = heldGrenade->m_bArmed;
if(grenadeArmed != s_grenadeArmed) {
if(grenadeArmed)
{
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "Armed");
}else {
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "Unarmed");
}
s_grenadeArmed = grenadeArmed;
}
}else{
if( s_holdingGrenade )
{
if(s_grenadeArmed && s_grenadePinPulled) {
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", "Grenades", "Thrown");
}
s_holdingGrenade = false;
s_grenadeArmed = false;
s_grenadePinPulled = false;
}
C_DODBaseBombWeapon *heldBomb = dynamic_cast<C_DODBaseBombWeapon*>(GetActiveDODWeapon());
if(heldBomb) {
bool isPlanting = heldBomb->IsPlanting();
if(isPlanting!=s_bombPlanting) {
if(isPlanting) {
if(!s_bombPlanting) {
s_bombPlanting = true;
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", heldBomb->GetClassname(), "Plant");
}
}else{
if(s_bombPlanting) {
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", heldBomb->GetClassname(), "StopPlant");
}
}
}
}else if(s_bombPlanting) {
s_bombPlanting = false;
if ( haptics )
haptics->ProcessHapticEvent(3, "Weapons", "Bomb", "Complete");
}
}
}
else
{
// Cold breath.
UpdateColdBreath();
}
}
// Start or stop the stamina breathing sound if necessary
void C_DODPlayer::StaminaSoundThink( void )
{
if ( m_bPlayingLowStaminaSound )
{
if ( !IsAlive() || m_Shared.GetStamina() >= LOW_STAMINA_THRESHOLD )
{
// stop the sprint sound
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundFadeOut( m_pStaminaSound, 1.0, true );
// SoundFadeOut will destroy this sound, so we will have to create another one
// if we go below the threshold again soon
m_pStaminaSound = NULL;
m_bPlayingLowStaminaSound = false;
}
}
else
{
if ( IsAlive() && m_Shared.GetStamina() < LOW_STAMINA_THRESHOLD )
{
// we are alive and have low stamina
CLocalPlayerFilter filter;
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
if ( !m_pStaminaSound )
m_pStaminaSound = controller.SoundCreate( filter, entindex(), "Player.Sprint" );
controller.Play( m_pStaminaSound, 0.0, 100 );
controller.SoundChangeVolume( m_pStaminaSound, 1.0, 2.0 );
m_bPlayingLowStaminaSound = true;
}
}
}
void C_DODPlayer::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_CREATED )
{
SetNextClientThink( CLIENT_THINK_ALWAYS );
}
UpdateVisibility();
}
void C_DODPlayer::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 );
if( m_bSpawnInterpCounter != m_bSpawnInterpCounterCache )
{
if ( IsLocalPlayer() )
{
LocalPlayerRespawn();
}
m_bSpawnInterpCounterCache = m_bSpawnInterpCounter.m_Value;
}
}
// Called every time the player respawns
void C_DODPlayer::LocalPlayerRespawn( void )
{
MoveToLastReceivedPosition( true );
ResetLatched();
ResetToneMapping(1.0);
m_Shared.m_bForceProneChange = true;
m_flLastRespawnTime = gpGlobals->curtime;
}
class C_FadingPhysPropClientside : public C_PhysPropClientside
{
public:
DECLARE_CLASS( C_FadingPhysPropClientside, C_PhysPropClientside );
// if we wake, extend fade time
virtual void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
{
// If we haven't started fading
if( GetRenderColor().a >= 255 )
{
// delay the fade
StartFadeOut( 10.0 );
// register the impact
BaseClass::ImpactTrace( pTrace, iDamageType, pCustomImpactName );
}
}
};
void C_DODPlayer::PopHelmet( Vector vecDir, Vector vecForceOrigin, int iModel )
{
if ( IsDormant() )
return; // We can't see them anyway, just bail
C_FadingPhysPropClientside *pEntity = new C_FadingPhysPropClientside();
if ( !pEntity )
return;
const model_t *model = modelinfo->GetModel( iModel );
if ( !model )
{
DevMsg("CTempEnts::PhysicsProp: model index %i not found\n", iModel );
return;
}
Vector vecHead;
QAngle angHeadAngles;
{
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false );
int iAttachment = LookupAttachment( "head" );
GetAttachment( iAttachment, vecHead, angHeadAngles ); //attachment 1 is the head attachment
}
pEntity->SetModelName( modelinfo->GetModelName(model) );
pEntity->SetAbsOrigin( vecHead );
pEntity->SetAbsAngles( angHeadAngles );
pEntity->SetPhysicsMode( PHYSICS_MULTIPLAYER_CLIENTSIDE );
if ( !pEntity->Initialize() )
{
pEntity->Release();
return;
}
IPhysicsObject *pPhysicsObject = pEntity->VPhysicsGetObject();
if( pPhysicsObject )
{
#ifdef DEBUG
if( vecForceOrigin == vec3_origin )
{
vecForceOrigin = GetAbsOrigin();
}
#endif
Vector vecForce = vecDir;
Vector vecOffset = vecForceOrigin - pEntity->GetAbsOrigin();
pPhysicsObject->ApplyForceOffset( vecForce, vecOffset );
}
else
{
// failed to create a physics object
pEntity->Release();
return;
}
pEntity->StartFadeOut( 10.0 );
}
void C_DODPlayer::ReceiveMessage( int classID, bf_read &msg )
{
if ( classID != GetClientClass()->m_ClassID )
{
// message is for subclass
BaseClass::ReceiveMessage( classID, msg );
return;
}
int messageType = msg.ReadByte();
switch( messageType )
{
case DOD_PLAYER_POP_HELMET:
{
Vector vecDir, vecForceOffset;
msg.ReadBitVec3Coord( vecDir );
msg.ReadBitVec3Coord( vecForceOffset );
int model = msg.ReadShort();
PopHelmet( vecDir, vecForceOffset, model );
}
break;
case DOD_PLAYER_REMOVE_DECALS:
{
RemoveAllDecals();
}
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Update this client's target entity
//-----------------------------------------------------------------------------
void C_DODPlayer::UpdateIDTarget()
{
Assert( IsLocalPlayer() );
// Clear old target and find a new one
m_iIDEntIndex = 0;
// don't show IDs in chase spec mode
if ( GetObserverMode() == OBS_MODE_CHASE ||
GetObserverMode() == OBS_MODE_DEATHCAM )
return;
trace_t tr;
Vector vecStart, vecEnd;
VectorMA( MainViewOrigin(), 1500, MainViewForward(), vecEnd );
VectorMA( MainViewOrigin(), 10, MainViewForward(), vecStart );
UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
C_BaseEntity *pEntity = NULL;
if ( !tr.startsolid && tr.DidHitNonWorldEntity() )
{
pEntity = tr.m_pEnt;
if ( pEntity && (pEntity != this) )
{
m_iIDEntIndex = pEntity->entindex();
}
}
// if we haven't done the weapon hint, and this entity is a weapon,
// show the weapon hint
if ( m_Hints.HasPlayedHint( HINT_PICK_UP_WEAPON ) == false && pEntity )
{
Vector vecDist = vecStart - tr.endpos;
// if m_iIDEntIndex is a CWeaponDODBase, show pick up hint
CWeaponDODBase *pWpn = dynamic_cast<CWeaponDODBase *>( pEntity );
if ( pWpn && vecDist.Length() < 100 )
{
HintMessage( HINT_PICK_UP_WEAPON );
}
}
}
bool C_DODPlayer::ShouldAutoReload( void )
{
return cl_autoreload.GetBool();
}
bool C_DODPlayer::ShouldAutoRezoom( void )
{
return cl_autorezoom.GetBool();
}
void C_DODPlayer::CheckGrenadeHint( Vector vecGrenadeOrigin )
{
if ( m_Hints.HasPlayedHint( HINT_PICK_UP_GRENADE ) == false )
{
// if its within 500 units
float flDist = ( vecGrenadeOrigin - GetAbsOrigin() ).Length2D();
if ( flDist < 500 )
{
m_Hints.HintMessage( HINT_PICK_UP_GRENADE );
}
}
}
void C_DODPlayer::CheckBombTargetPlantHint( void )
{
if ( m_Hints.HasPlayedHint( HINT_BOMB_TARGET ) == false )
{
m_Hints.HintMessage( HINT_BOMB_TARGET );
}
}
void C_DODPlayer::CheckBombTargetDefuseHint( void )
{
if ( m_Hints.HasPlayedHint( HINT_DEFUSE_BOMB ) == false )
{
m_Hints.HintMessage( HINT_DEFUSE_BOMB );
}
}
void C_DODPlayer::LowerWeapon( void )
{
m_bWeaponLowered = true;
}
void C_DODPlayer::RaiseWeapon( void )
{
m_bWeaponLowered = false;
}
bool C_DODPlayer::IsWeaponLowered( void )
{
if ( GetMoveType() == MOVETYPE_LADDER )
return true;
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
if ( !pWeapon )
return false;
// Lower when underwater ( except if its melee )
if ( GetWaterLevel() > 2 && pWeapon->GetDODWpnData().m_WeaponType != WPN_TYPE_MELEE )
return true;
if ( m_Shared.IsProne() && GetAbsVelocity().LengthSqr() > 1 )
return true;
if ( m_Shared.IsGoingProne() || m_Shared.IsGettingUpFromProne() )
return true;
if ( m_Shared.IsJumping() )
return true;
if ( m_Shared.IsDefusing() )
return true;
// Lower losing team's weapons in bonus round
int state = DODGameRules()->State_Get();
if ( state == STATE_ALLIES_WIN && GetTeamNumber() == TEAM_AXIS )
return true;
if ( state == STATE_AXIS_WIN && GetTeamNumber() == TEAM_ALLIES )
return true;
if ( m_Shared.IsBazookaDeployed() )
return false;
Vector vel = GetAbsVelocity();
if ( vel.Length2D() < 50 )
return false;
if ( m_nButtons & IN_SPEED && ( m_nButtons & IN_FORWARD ) &&
m_Shared.GetStamina() >= 5 &&
!m_Shared.IsDucking() )
return true;
return m_bWeaponLowered;
}
// Shadows
ConVar cl_blobbyshadows( "cl_blobbyshadows", "0", FCVAR_CLIENTDLL );
ShadowType_t C_DODPlayer::ShadowCastType( void )
{
if ( !IsVisible() )
return SHADOWS_NONE;
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
// if we're first person spectating this player
if ( pLocalPlayer &&
pLocalPlayer->GetObserverTarget() == this &&
pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
return SHADOWS_NONE;
}
if( cl_blobbyshadows.GetBool() )
return SHADOWS_SIMPLE;
return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
}
float g_flFattenAmt = 4;
void C_DODPlayer::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_DODPlayer::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 );
}
bool C_DODPlayer::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 );
}
}
ConVar cl_muzzleflash_dlight_3rd( "cl_muzzleflash_dlight_3rd", "1" );
void C_DODPlayer::ProcessMuzzleFlashEvent()
{
CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
bool bInToolRecordingMode = ToolsEnabled() && clienttools->IsInRecordingMode();
// Reenable when the weapons have muzzle flash attachments in the right spot.
if ( this == pLocalPlayer && !bInToolRecordingMode )
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;
}
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
if ( !pWeapon )
return;
int nModelIndex = pWeapon->GetModelIndex();
int nWorldModelIndex = pWeapon->GetWorldModelIndex();
if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
{
pWeapon->SetModelIndex( nWorldModelIndex );
}
Vector vecOrigin;
QAngle angAngles;
//MATTTODO - use string names of the weapon
const static int iMuzzleFlashAttachment = 1;
const static int iEjectBrassAttachment = 2;
// If we have an attachment, then stick a light on it.
if ( cl_muzzleflash_dlight_3rd.GetBool() && pWeapon->GetAttachment( iMuzzleFlashAttachment, vecOrigin, angAngles ) )
{
// Muzzleflash light
dlight_t *el = effects->CL_AllocDlight( LIGHT_INDEX_MUZZLEFLASH );
el->origin = vecOrigin;
el->radius = 70;
if ( pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_SNIPER )
el->radius = 150;
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;
if ( bInToolRecordingMode )
{
Color clr( el->color.r, el->color.g, el->color.b );
KeyValues *msg = new KeyValues( "TempEntity" );
msg->SetInt( "te", TE_DYNAMIC_LIGHT );
msg->SetString( "name", "TE_DynamicLight" );
msg->SetFloat( "time", gpGlobals->curtime );
msg->SetFloat( "duration", el->die );
msg->SetFloat( "originx", el->origin.x );
msg->SetFloat( "originy", el->origin.y );
msg->SetFloat( "originz", el->origin.z );
msg->SetFloat( "radius", el->radius );
msg->SetFloat( "decay", el->decay );
msg->SetColor( "color", clr );
msg->SetInt( "exponent", el->color.exponent );
msg->SetInt( "lightindex", LIGHT_INDEX_MUZZLEFLASH );
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
msg->deleteThis();
}
}
const char *pszMuzzleFlashEffect = NULL;
switch( pWeapon->GetDODWpnData().m_iMuzzleFlashType )
{
case DOD_MUZZLEFLASH_PISTOL:
pszMuzzleFlashEffect = "muzzle_pistols";
break;
case DOD_MUZZLEFLASH_AUTO:
pszMuzzleFlashEffect = "muzzle_fullyautomatic";
break;
case DOD_MUZZLEFLASH_RIFLE:
pszMuzzleFlashEffect = "muzzle_rifles";
break;
case DOD_MUZZLEFLASH_ROCKET:
pszMuzzleFlashEffect = "muzzle_rockets";
break;
case DOD_MUZZLEFLASH_MG42:
pszMuzzleFlashEffect = "muzzle_mg42";
break;
default:
break;
}
if ( pszMuzzleFlashEffect )
{
DispatchParticleEffect( pszMuzzleFlashEffect, PATTACH_POINT_FOLLOW, pWeapon, 1 );
}
if( pWeapon->ShouldAutoEjectBrass() )
{
// shell eject
if( pWeapon->GetAttachment( iEjectBrassAttachment, vecOrigin, angAngles ) )
{
int shellType = pWeapon->GetEjectBrassShellType();
CEffectData data;
data.m_nHitBox = shellType;
data.m_vOrigin = vecOrigin;
data.m_vAngles = angAngles;
DispatchEffect( "DOD_EjectBrass", data );
}
}
if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
{
pWeapon->SetModelIndex( nModelIndex );
}
}
void C_DODPlayer::NotifyShouldTransmit( ShouldTransmitState_t state )
{
// Remove all effects if we go out of the PVS.
if ( state == SHOULDTRANSMIT_END )
{
if( m_pFlashlightBeam != NULL )
{
ReleaseFlashlight();
}
}
BaseClass::NotifyShouldTransmit( state );
}
void C_DODPlayer::Simulate( void )
{
if( this != C_BasePlayer::GetLocalPlayer() )
{
if ( IsEffectActive( EF_DIMLIGHT ) )
{
QAngle eyeAngles = m_angEyeAngles;
Vector vForward;
AngleVectors( eyeAngles, &vForward );
int iAttachment = LookupAttachment( "anim_attachment_RH" );
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_DODPlayer::ReleaseFlashlight( void )
{
if( m_pFlashlightBeam )
{
m_pFlashlightBeam->flags = 0;
m_pFlashlightBeam->die = gpGlobals->curtime - 1;
m_pFlashlightBeam = NULL;
}
}
bool C_DODPlayer::SetFOV( CBaseEntity *pRequester, int FOV, float zoomRate /* = 0.0f */ )
{
/*
if( FOV < 30 )
{
// fade in
ScreenFade_t sf;
memset( &sf, 0, sizeof( sf ) );
sf.a = 255;
sf.r = 0;
sf.g = 0;
sf.b = 0;
sf.duration = (unsigned short)((float)(1<<SCREENFADE_FRACBITS) * 2.5f );
sf.fadeFlags = FFADE_IN;
vieweffects->Fade( sf );
}
else
{
//cancel the fade if its active
ScreenFade_t sf;
memset( &sf, 0, sizeof( sf ) );
sf.fadeFlags = FFADE_IN | FFADE_PURGE;
vieweffects->Fade( sf );
}
*/
return true;
}
void C_DODPlayer::CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
{
if( GetObserverMode() == OBS_MODE_DEATHCAM )
{
CalcDODDeathCamView( eyeOrigin, eyeAngles, fov );
}
else
BaseClass::CalcObserverView( eyeOrigin, eyeAngles, fov );
}
static Vector WALL_MIN(-WALL_OFFSET,-WALL_OFFSET,-WALL_OFFSET);
static Vector WALL_MAX(WALL_OFFSET,WALL_OFFSET,WALL_OFFSET);
void C_DODPlayer::CalcDODDeathCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
CBaseEntity * killer = GetObserverTarget();
//float interpolation = ( gpGlobals->curtime - m_flDeathTime ) / DEATH_ANIMATION_TIME;
// Interpolate very quickly to the killer and follow
float interpolation = ( gpGlobals->curtime - m_flDeathTime ) / 0.2f;
interpolation = clamp( interpolation, 0.0f, 1.0f );
m_flObserverChaseDistance += gpGlobals->frametime*48.0f;
m_flObserverChaseDistance = clamp( m_flObserverChaseDistance, CHASE_CAM_DISTANCE_MIN, CHASE_CAM_DISTANCE_MAX );
QAngle aForward = eyeAngles = EyeAngles();
Vector origin = EyePosition();
IRagdoll *pRagdoll = GetRepresentativeRagdoll();
if ( pRagdoll )
{
origin = pRagdoll->GetRagdollOrigin();
origin.z += VEC_DEAD_VIEWHEIGHT_SCALED( this ).z; // look over ragdoll, not through
}
if ( killer && (killer != this) )
{
Vector vecKiller = killer->GetAbsOrigin();
C_DODPlayer *player = ToDODPlayer( killer );
if ( player && player->IsAlive() )
{
if ( player->m_Shared.IsProne() )
{
VectorAdd( vecKiller, VEC_PRONE_VIEW_SCALED( this ), vecKiller );
}
else if( player->GetFlags() & FL_DUCKING )
{
VectorAdd( vecKiller, VEC_DUCK_VIEW_SCALED( this ), vecKiller );
}
else
{
VectorAdd( vecKiller, VEC_VIEW_SCALED( this ), vecKiller );
}
}
Vector vecToKiller = vecKiller - origin;
QAngle aKiller;
VectorAngles( vecToKiller, aKiller );
InterpolateAngles( aForward, aKiller, eyeAngles, interpolation );
}
Vector vForward; AngleVectors( eyeAngles, &vForward );
VectorNormalize( vForward );
VectorMA( origin, -m_flObserverChaseDistance, vForward, eyeOrigin );
trace_t trace; // clip against world
C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
UTIL_TraceHull( origin, eyeOrigin, WALL_MIN, WALL_MAX, MASK_SOLID, this, COLLISION_GROUP_NONE, &trace );
C_BaseEntity::PopEnableAbsRecomputations();
if (trace.fraction < 1.0)
{
eyeOrigin = trace.endpos;
m_flObserverChaseDistance = VectorLength(origin - eyeOrigin);
}
fov = GetFOV();
}
void C_DODPlayer::CalcChaseCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
C_BaseEntity *target = GetObserverTarget();
if ( !target )
{
// just copy a save in-map position
VectorCopy( EyePosition(), eyeOrigin );
VectorCopy( EyeAngles(), eyeAngles );
return;
};
Vector forward, viewpoint;
// GetRenderOrigin() returns ragdoll pos if player is ragdolled
Vector origin = target->GetRenderOrigin();
C_DODPlayer *player = ToDODPlayer( target );
if ( player && player->IsAlive() )
{
if ( player->m_Shared.IsProne() )
{
VectorAdd( origin, VEC_PRONE_VIEW_SCALED( this ), origin );
}
else if( player->GetFlags() & FL_DUCKING )
{
VectorAdd( origin, VEC_DUCK_VIEW_SCALED( this ), origin );
}
else
{
VectorAdd( origin, VEC_VIEW_SCALED( this ), origin );
}
}
else
{
// assume it's the players ragdoll
VectorAdd( origin, VEC_DEAD_VIEWHEIGHT_SCALED( this ), origin );
}
QAngle viewangles;
if ( IsLocalPlayer() )
{
engine->GetViewAngles( viewangles );
}
else
{
viewangles = EyeAngles();
}
m_flObserverChaseDistance += gpGlobals->frametime*48.0f;
m_flObserverChaseDistance = clamp( m_flObserverChaseDistance, CHASE_CAM_DISTANCE_MIN, CHASE_CAM_DISTANCE_MAX );
AngleVectors( viewangles, &forward );
VectorNormalize( forward );
VectorMA(origin, -m_flObserverChaseDistance, forward, viewpoint );
trace_t trace;
C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
UTIL_TraceHull( origin, viewpoint, WALL_MIN, WALL_MAX, MASK_SOLID, target, COLLISION_GROUP_NONE, &trace );
C_BaseEntity::PopEnableAbsRecomputations();
if (trace.fraction < 1.0)
{
viewpoint = trace.endpos;
m_flObserverChaseDistance = VectorLength(origin - eyeOrigin);
}
VectorCopy( viewangles, eyeAngles );
VectorCopy( viewpoint, eyeOrigin );
fov = GetFOV();
}
extern ConVar spec_freeze_traveltime;
extern ConVar spec_freeze_time;
extern ConVar cl_dod_freezecam;
//-----------------------------------------------------------------------------
// Purpose: Calculate the view for the player while he's in freeze frame observer mode
//-----------------------------------------------------------------------------
void C_DODPlayer::CalcFreezeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
{
C_BaseEntity *pTarget = GetObserverTarget();
if ( !pTarget || !cl_dod_freezecam.GetBool() )
{
CalcDeathCamView( eyeOrigin, eyeAngles, fov );
return;
}
// Zoom towards our target
float flCurTime = (gpGlobals->curtime - m_flFreezeFrameStartTime);
float flBlendPerc = clamp( flCurTime / spec_freeze_traveltime.GetFloat(), 0, 1 );
flBlendPerc = SimpleSpline( flBlendPerc );
// Find the position we would like to be lookin at
Vector vecCamDesired = pTarget->GetObserverCamOrigin(); // Returns ragdoll origin if they're ragdolled
VectorAdd( vecCamDesired, GetChaseCamViewOffset( pTarget ), vecCamDesired );
Vector vecCamTarget = vecCamDesired;
if ( !pTarget->IsAlive() )
{
vecCamTarget.z += pTarget->GetBaseAnimating() ? VEC_DEAD_VIEWHEIGHT_SCALED( pTarget->GetBaseAnimating() ).z : VEC_DEAD_VIEWHEIGHT.z; // look over ragdoll, not through
}
// Figure out a view position in front of the target
Vector vecEyeOnPlane = eyeOrigin;
vecEyeOnPlane.z = vecCamTarget.z;
Vector vecTargetPos = vecCamTarget;
Vector vecToTarget = vecTargetPos - vecEyeOnPlane;
VectorNormalize( vecToTarget );
// Stop a few units away from the target, and shift up to be at the same height
vecTargetPos = vecCamTarget - (vecToTarget * m_flFreezeFrameDistance);
float flEyePosZ = pTarget->EyePosition().z;
vecTargetPos.z = flEyePosZ + m_flFreezeZOffset;
// 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_TraceLine( vecCamTarget, vecTargetPos, 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.
vecTargetPos = trace.endpos;
vecCamTarget = vecCamDesired;
// To stop all close in views looking up at character's chins, move the view up.
vecTargetPos.z += fabs(vecCamTarget.z - vecTargetPos.z) * 0.85;
C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
UTIL_TraceLine( vecCamTarget, vecTargetPos, MASK_SOLID, pTarget, COLLISION_GROUP_NONE, &trace );
C_BaseEntity::PopEnableAbsRecomputations();
vecTargetPos = trace.endpos;
}
// Look directly at the target
vecToTarget = vecCamTarget - vecTargetPos;
VectorNormalize( vecToTarget );
VectorAngles( vecToTarget, eyeAngles );
VectorLerp( m_vecFreezeFrameStart, vecTargetPos, flBlendPerc, eyeOrigin );
if ( flCurTime >= 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() );
}
}
const Vector& C_DODPlayer::GetRenderOrigin( void )
{
if ( !IsAlive() && m_hRagdoll.Get() )
return m_hRagdoll.Get()->GetRenderOrigin();
return BaseClass::GetRenderOrigin();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Vector C_DODPlayer::GetChaseCamViewOffset( CBaseEntity *target )
{
C_DODPlayer *pPlayer = ToDODPlayer( target );
if ( pPlayer && pPlayer->IsAlive() )
{
if ( pPlayer->m_Shared.IsProne() )
{
return VEC_PRONE_VIEW;
}
}
return BaseClass::GetChaseCamViewOffset( target );
}
const QAngle& C_DODPlayer::EyeAngles()
{
if ( IsLocalPlayer() && g_nKillCamMode == OBS_MODE_NONE )
{
return BaseClass::EyeAngles();
}
else
{
return m_angEyeAngles;
}
}
// Cold breath defines.
#define COLDBREATH_EMIT_MIN 2.0f
#define COLDBREATH_EMIT_MAX 3.0f
#define COLDBREATH_EMIT_SCALE 0.35f
#define COLDBREATH_PARTICLE_LIFE_MIN 0.25f
#define COLDBREATH_PARTICLE_LIFE_MAX 1.0f
#define COLDBREATH_PARTICLE_LIFE_SCALE 0.75
#define COLDBREATH_PARTICLE_SIZE_MIN 1.0f
#define COLDBREATH_PARTICLE_SIZE_MAX 4.0f
#define COLDBREATH_PARTICLE_SIZE_SCALE 1.1f
#define COLDBREATH_PARTICLE_COUNT 1
#define COLDBREATH_DURATION_MIN 0.0f
#define COLDBREATH_DURATION_MAX 1.0f
#define COLDBREATH_ALPHA_MIN 0.0f
#define COLDBREATH_ALPHA_MAX 0.3f
#define COLDBREATH_ENDSCALE_MIN 0.1f
#define COLDBREATH_ENDSCALE_MAX 0.4f
static ConVar cl_coldbreath_forcestamina( "cl_coldbreath_forcestamina", "0", FCVAR_CHEAT );
static ConVar cl_coldbreath_enable( "cl_coldbreath_enable", "1" );
//-----------------------------------------------------------------------------
// Purpose: Create the emitter of cold breath particles
//-----------------------------------------------------------------------------
bool C_DODPlayer::CreateColdBreathEmitter( void )
{
// Check to see if we are in a cold breath scenario.
if ( !GetClientWorldEntity()->m_bColdWorld )
return false;
// Set cold breath to true.
m_bColdBreathOn = true;
// Create a cold breath emitter if one doesn't already exist.
if ( !m_hColdBreathEmitter )
{
m_hColdBreathEmitter = ColdBreathEmitter::Create( "ColdBreath" );
if ( !m_hColdBreathEmitter )
return false;
// Get the particle material.
m_hColdBreathMaterial = m_hColdBreathEmitter->GetPMaterial( "sprites/frostbreath" );
Assert( m_hColdBreathMaterial != INVALID_MATERIAL_HANDLE );
// Cache off the head attachment for setting up cold breath.
m_iHeadAttach = LookupAttachment( "head" );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Destroy the cold breath emitter
//-----------------------------------------------------------------------------
void C_DODPlayer::DestroyColdBreathEmitter( void )
{
#if 0
if ( m_hColdBreathEmitter.IsValid() )
{
UTIL_Remove( m_hColdBreathEmitter );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_DODPlayer::UpdateColdBreath( void )
{
if ( !cl_coldbreath_enable.GetBool() )
return;
// Check to see if the cold breath emitter has been created.
if ( !m_hColdBreathEmitter.IsValid() )
{
if ( !CreateColdBreathEmitter() )
return;
}
// Cold breath updates.
if ( !m_bColdBreathOn )
return;
// Don't emit breath if we are dead.
if ( !IsAlive() || IsDormant() )
return;
// Check player speed, do emit cold breath when moving quickly.
float flSpeed = GetAbsVelocity().Length();
if ( flSpeed > 60.0f )
return;
if ( m_flColdBreathTimeStart < gpGlobals->curtime )
{
// Spawn cold breath particles.
EmitColdBreathParticles();
// Update the timer.
if ( m_flColdBreathTimeEnd < gpGlobals->curtime )
{
// Check stamina and modify the time accordingly.
if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
{
m_flColdBreathTimeStart = gpGlobals->curtime + RandomFloat( COLDBREATH_EMIT_MIN * COLDBREATH_EMIT_SCALE, COLDBREATH_EMIT_MAX * COLDBREATH_EMIT_SCALE );
float flDuration = RandomFloat( COLDBREATH_DURATION_MIN, COLDBREATH_DURATION_MAX );
m_flColdBreathTimeEnd = m_flColdBreathTimeStart + flDuration;
}
else
{
m_flColdBreathTimeStart = gpGlobals->curtime + RandomFloat( COLDBREATH_EMIT_MIN, COLDBREATH_EMIT_MAX );
float flDuration = RandomFloat( COLDBREATH_DURATION_MIN, COLDBREATH_DURATION_MAX );
m_flColdBreathTimeEnd = m_flColdBreathTimeStart + flDuration;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_DODPlayer::CalculateIKLocks( float currentTime )
{
if (!m_pIk)
return;
int targetCount = m_pIk->m_target.Count();
if ( targetCount == 0 )
return;
// In TF, we might be attaching a player's view to a walking model that's using IK. If we are, it can
// get in here during the view setup code, and it's not normally supposed to be able to access the spatial
// partition that early in the rendering loop. So we allow access right here for that special case.
SpatialPartitionListMask_t curSuppressed = partition->GetSuppressedLists();
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false );
CBaseEntity::PushEnableAbsRecomputations( false );
for (int i = 0; i < targetCount; i++)
{
trace_t trace;
CIKTarget *pTarget = &m_pIk->m_target[i];
if (!pTarget->IsActive())
continue;
switch( pTarget->type)
{
case IK_GROUND:
{
pTarget->SetPos( Vector( pTarget->est.pos.x, pTarget->est.pos.y, GetRenderOrigin().z ));
pTarget->SetAngles( GetRenderAngles() );
}
break;
case IK_ATTACHMENT:
{
C_BaseEntity *pEntity = NULL;
float flDist = pTarget->est.radius;
// FIXME: make entity finding sticky!
// FIXME: what should the radius check be?
for ( CEntitySphereQuery sphere( pTarget->est.pos, 64 ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
{
C_BaseAnimating *pAnim = pEntity->GetBaseAnimating( );
if (!pAnim)
continue;
int iAttachment = pAnim->LookupAttachment( pTarget->offset.pAttachmentName );
if (iAttachment <= 0)
continue;
Vector origin;
QAngle angles;
pAnim->GetAttachment( iAttachment, origin, angles );
// debugoverlay->AddBoxOverlay( origin, Vector( -1, -1, -1 ), Vector( 1, 1, 1 ), QAngle( 0, 0, 0 ), 255, 0, 0, 0, 0 );
float d = (pTarget->est.pos - origin).Length();
if ( d >= flDist)
continue;
flDist = d;
pTarget->SetPos( origin );
pTarget->SetAngles( angles );
// debugoverlay->AddBoxOverlay( pTarget->est.pos, Vector( -pTarget->est.radius, -pTarget->est.radius, -pTarget->est.radius ), Vector( pTarget->est.radius, pTarget->est.radius, pTarget->est.radius), QAngle( 0, 0, 0 ), 0, 255, 0, 0, 0 );
}
if (flDist >= pTarget->est.radius)
{
// debugoverlay->AddBoxOverlay( pTarget->est.pos, Vector( -pTarget->est.radius, -pTarget->est.radius, -pTarget->est.radius ), Vector( pTarget->est.radius, pTarget->est.radius, pTarget->est.radius), QAngle( 0, 0, 0 ), 0, 0, 255, 0, 0 );
// no solution, disable ik rule
pTarget->IKFailed( );
}
}
break;
}
}
CBaseEntity::PopEnableAbsRecomputations();
partition->SuppressLists( curSuppressed, true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_DODPlayer::EmitColdBreathParticles( void )
{
// Get the position to emit from - look into caching this off we are doing redundant work in the case
// of allies (see dod_headiconmanager.cpp).
Vector vecOrigin;
QAngle vecAngle;
GetAttachment( m_iHeadAttach, vecOrigin, vecAngle );
Vector vecForward, vecRight, vecUp;
AngleVectors( vecAngle, &vecUp, &vecForward, &vecRight );
vecOrigin += ( vecForward * 8.0f );
SimpleParticle *pParticle = static_cast<SimpleParticle*>( m_hColdBreathEmitter->AddParticle( sizeof( SimpleParticle ),m_hColdBreathMaterial, vecOrigin ) );
if ( pParticle )
{
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = RandomFloat( COLDBREATH_PARTICLE_LIFE_MIN, COLDBREATH_PARTICLE_LIFE_MAX );
if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
{
pParticle->m_flDieTime *= COLDBREATH_PARTICLE_LIFE_SCALE;
}
// Add just a little movement.
if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
{
pParticle->m_vecVelocity = ( vecForward * RandomFloat( 10.0f, 30.0f ) ) + ( vecRight * RandomFloat( -2.0f, 2.0f ) ) +
( vecUp * RandomFloat( 0.0f, 0.5f ) );
}
else
{
pParticle->m_vecVelocity = ( vecForward * RandomFloat( 10.0f, 20.0f ) ) + ( vecRight * RandomFloat( -2.0f, 2.0f ) ) +
( vecUp * RandomFloat( 0.0f, 1.5f ) );
}
pParticle->m_uchColor[0] = 200;
pParticle->m_uchColor[1] = 200;
pParticle->m_uchColor[2] = 210;
float flParticleSize = RandomFloat( COLDBREATH_PARTICLE_SIZE_MIN, COLDBREATH_PARTICLE_SIZE_MAX );
float flParticleScale = RandomFloat( COLDBREATH_ENDSCALE_MIN, COLDBREATH_ENDSCALE_MAX );
if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
{
pParticle->m_uchEndSize = flParticleSize * COLDBREATH_PARTICLE_SIZE_SCALE;
flParticleScale *= COLDBREATH_PARTICLE_SIZE_SCALE;
}
else
{
pParticle->m_uchEndSize = flParticleSize;
}
pParticle->m_uchStartSize = ( flParticleSize * flParticleScale );
float flAlpha = RandomFloat( COLDBREATH_ALPHA_MIN, COLDBREATH_ALPHA_MAX );
pParticle->m_uchStartAlpha = flAlpha * 255;
pParticle->m_uchEndAlpha = 0;
pParticle->m_flRoll = RandomInt( 0, 360 );
pParticle->m_flRollDelta = RandomFloat( 0.0f, 1.25f );
}
}
void C_DODPlayer::ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
{
m_Shared.ComputeWorldSpaceSurroundingBox( pVecWorldMins, pVecWorldMaxs );
}
//-----------------------------------------------------------------------------
// Purpose: Try to steer away from any players and objects we might interpenetrate
//-----------------------------------------------------------------------------
#define DOD_AVOID_MAX_RADIUS_SQR 5184.0f // Based on player extents and max buildable extents.
#define DOD_OO_AVOID_MAX_RADIUS_SQR 0.00019f
#define DOD_MAX_SEPARATION_FORCE 256
extern ConVar cl_forwardspeed;
extern ConVar cl_backspeed;
extern ConVar cl_sidespeed;
void C_DODPlayer::AvoidPlayers( CUserCmd *pCmd )
{
// Don't test if the player is dead.
if ( IsAlive() == false )
return;
C_Team *pTeam = ( C_Team * )GetTeam();
if ( !pTeam )
return;
// Up vector.
static Vector vecUp( 0.0f, 0.0f, 1.0f );
Vector vecDODPlayerCenter = GetAbsOrigin();
Vector vecDODPlayerMin = GetPlayerMins();
Vector vecDODPlayerMax = GetPlayerMaxs();
float flZHeight = vecDODPlayerMax.z - vecDODPlayerMin.z;
vecDODPlayerCenter.z += 0.5f * flZHeight;
VectorAdd( vecDODPlayerMin, vecDODPlayerCenter, vecDODPlayerMin );
VectorAdd( vecDODPlayerMax, vecDODPlayerCenter, vecDODPlayerMax );
// Find an intersecting player or object.
int nAvoidPlayerCount = 0;
C_DODPlayer *pAvoidPlayerList[MAX_PLAYERS];
C_DODPlayer *pIntersectPlayer = NULL;
float flAvoidRadius = 0.0f;
Vector vecAvoidCenter, vecAvoidMin, vecAvoidMax;
for ( int i = 0; i < pTeam->GetNumPlayers(); ++i )
{
C_DODPlayer *pAvoidPlayer = static_cast< C_DODPlayer * >( pTeam->GetPlayer( i ) );
if ( pAvoidPlayer == NULL )
continue;
// Is the avoid player me?
if ( pAvoidPlayer == this )
continue;
// Save as list to check against for objects.
pAvoidPlayerList[nAvoidPlayerCount] = pAvoidPlayer;
++nAvoidPlayerCount;
// Check to see if the avoid player is dormant.
if ( pAvoidPlayer->IsDormant() )
continue;
// Is the avoid player solid?
if ( pAvoidPlayer->IsSolidFlagSet( FSOLID_NOT_SOLID ) )
continue;
Vector t1, t2;
vecAvoidCenter = pAvoidPlayer->GetAbsOrigin();
vecAvoidMin = pAvoidPlayer->GetPlayerMins();
vecAvoidMax = pAvoidPlayer->GetPlayerMaxs();
flZHeight = vecAvoidMax.z - vecAvoidMin.z;
vecAvoidCenter.z += 0.5f * flZHeight;
VectorAdd( vecAvoidMin, vecAvoidCenter, vecAvoidMin );
VectorAdd( vecAvoidMax, vecAvoidCenter, vecAvoidMax );
if ( IsBoxIntersectingBox( vecDODPlayerMin, vecDODPlayerMax, vecAvoidMin, vecAvoidMax ) )
{
// Need to avoid this player.
if ( !pIntersectPlayer )
{
pIntersectPlayer = pAvoidPlayer;
break;
}
}
}
// Anything to avoid?
if ( !pIntersectPlayer )
{
return;
}
// Calculate the push strength and direction.
Vector vecDelta;
// Avoid a player - they have precedence.
if ( pIntersectPlayer )
{
VectorSubtract( pIntersectPlayer->WorldSpaceCenter(), vecDODPlayerCenter, vecDelta );
Vector vRad = pIntersectPlayer->WorldAlignMaxs() - pIntersectPlayer->WorldAlignMins();
vRad.z = 0;
flAvoidRadius = vRad.Length();
}
float flPushStrength = RemapValClamped( vecDelta.Length(), flAvoidRadius, 0, 0, DOD_MAX_SEPARATION_FORCE ); //flPushScale;
//Msg( "PushScale = %f\n", flPushStrength );
// Check to see if we have enough push strength to make a difference.
if ( flPushStrength < 0.01f )
return;
Vector vecPush;
if ( GetAbsVelocity().Length2DSqr() > 0.1f )
{
Vector vecVelocity = GetAbsVelocity();
vecVelocity.z = 0.0f;
CrossProduct( vecUp, vecVelocity, vecPush );
VectorNormalize( vecPush );
}
else
{
// We are not moving, but we're still intersecting.
QAngle angView = pCmd->viewangles;
angView.x = 0.0f;
AngleVectors( angView, NULL, &vecPush, NULL );
}
// Move away from the other player/object.
Vector vecSeparationVelocity;
if ( vecDelta.Dot( vecPush ) < 0 )
{
vecSeparationVelocity = vecPush * flPushStrength;
}
else
{
vecSeparationVelocity = vecPush * -flPushStrength;
}
// Don't allow the max push speed to be greater than the max player speed.
float flMaxPlayerSpeed = MaxSpeed();
float flCropFraction = 1.33333333f;
if ( ( GetFlags() & FL_DUCKING ) && ( GetGroundEntity() != NULL ) )
{
flMaxPlayerSpeed *= flCropFraction;
}
float flMaxPlayerSpeedSqr = flMaxPlayerSpeed * flMaxPlayerSpeed;
if ( vecSeparationVelocity.LengthSqr() > flMaxPlayerSpeedSqr )
{
vecSeparationVelocity.NormalizeInPlace();
VectorScale( vecSeparationVelocity, flMaxPlayerSpeed, vecSeparationVelocity );
}
QAngle vAngles = pCmd->viewangles;
vAngles.x = 0;
Vector currentdir;
Vector rightdir;
AngleVectors( vAngles, &currentdir, &rightdir, NULL );
Vector vDirection = vecSeparationVelocity;
VectorNormalize( vDirection );
float fwd = currentdir.Dot( vDirection );
float rt = rightdir.Dot( vDirection );
float forward = fwd * flPushStrength;
float side = rt * flPushStrength;
//Msg( "fwd: %f - rt: %f - forward: %f - side: %f\n", fwd, rt, forward, side );
pCmd->forwardmove += forward;
pCmd->sidemove += side;
// Clamp the move to within legal limits, preserving direction. This is a little
// complicated because we have different limits for forward, back, and side
//Msg( "PRECLAMP: forwardmove=%f, sidemove=%f\n", pCmd->forwardmove, pCmd->sidemove );
float flForwardScale = 1.0f;
if ( pCmd->forwardmove > fabs( cl_forwardspeed.GetFloat() ) )
{
flForwardScale = fabs( cl_forwardspeed.GetFloat() ) / pCmd->forwardmove;
}
else if ( pCmd->forwardmove < -fabs( cl_backspeed.GetFloat() ) )
{
flForwardScale = fabs( cl_backspeed.GetFloat() ) / fabs( pCmd->forwardmove );
}
float flSideScale = 1.0f;
if ( fabs( pCmd->sidemove ) > fabs( cl_sidespeed.GetFloat() ) )
{
flSideScale = fabs( cl_sidespeed.GetFloat() ) / fabs( pCmd->sidemove );
}
float flScale = MIN( flForwardScale, flSideScale );
pCmd->forwardmove *= flScale;
pCmd->sidemove *= flScale;
//Msg( "Pforwardmove=%f, sidemove=%f\n", pCmd->forwardmove, pCmd->sidemove );
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether this player is the nemesis of the local player
//-----------------------------------------------------------------------------
bool C_DODPlayer::IsNemesisOfLocalPlayer()
{
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pLocalPlayer )
{
// return whether this player is dominating the local player
return m_Shared.IsPlayerDominated( pLocalPlayer->entindex() );
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether we should show the nemesis icon for this player
//-----------------------------------------------------------------------------
bool C_DODPlayer::ShouldShowNemesisIcon()
{
/*
// we should show the nemesis effect on this player if he is the nemesis of the local player,
// and is not dead, cloaked or disguised
if ( IsNemesisOfLocalPlayer() && g_DODPR && g_PR->IsConnected( entindex() ) )
{
if ( IsAlive() )
return true;
}
*/
return false;
}
int C_DODPlayer::GetActiveAchievementAward( void )
{
int iAward = ACHIEVEMENT_AWARDS_NONE;
int iClassBit = m_Shared.PlayerClass() + 1;
if ( m_iAchievementAwardsMask & (1<<ACHIEVEMENT_AWARDS_ALL_PACK_1) )
{
iAward = ACHIEVEMENT_AWARDS_ALL_PACK_1;
}
else if ( m_iAchievementAwardsMask & ( 1<<iClassBit ) )
{
iAward = iClassBit;
}
return iAward;
}
IMaterial *C_DODPlayer::GetHeadIconMaterial( void )
{
const char *pszMaterial = "";
int iAchievementAward = GetActiveAchievementAward();
if ( iAchievementAward >= 0 && iAchievementAward < NUM_ACHIEVEMENT_AWARDS )
{
switch ( GetTeamNumber() )
{
case TEAM_ALLIES:
pszMaterial = g_pszAchievementAwardMaterials_Allies[iAchievementAward];
break;
case TEAM_AXIS:
pszMaterial = g_pszAchievementAwardMaterials_Axis[iAchievementAward];
break;
default:
break;
}
}
IMaterial *pMaterial = NULL;
if ( pszMaterial )
{
pMaterial = materials->FindMaterial( pszMaterial, TEXTURE_GROUP_VGUI );
}
// clear the old one if its different
if ( m_pHeadIconMaterial != pMaterial )
{
if ( m_pHeadIconMaterial )
{
m_pHeadIconMaterial->DecrementReferenceCount();
}
m_pHeadIconMaterial = pMaterial;
m_pHeadIconMaterial->IncrementReferenceCount();
}
return m_pHeadIconMaterial;
}
Reference in New Issue View Git Blame Copy Permalink