d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/client/dod/c_dod_player.cpp

2780 lines
75 KiB
Raw 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;
}