1397 lines
32 KiB
C++
1397 lines
32 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "dod_gamerules.h"
|
|
#include "takedamageinfo.h"
|
|
#include "dod_shareddefs.h"
|
|
#include "effect_dispatch_data.h"
|
|
|
|
#include "weapon_dodbase.h"
|
|
#include "weapon_dodbipodgun.h"
|
|
#include "weapon_dodbaserpg.h"
|
|
#include "weapon_dodsniper.h"
|
|
|
|
#include "movevars_shared.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "SoundEmitterSystem/isoundemittersystembase.h"
|
|
#include "engine/ivdebugoverlay.h"
|
|
#include "obstacle_pushaway.h"
|
|
#include "props_shared.h"
|
|
|
|
#include "decals.h"
|
|
#include "util_shared.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
#include "c_dod_player.h"
|
|
#include "prediction.h"
|
|
#include "clientmode_dod.h"
|
|
#include "vgui_controls/AnimationController.h"
|
|
|
|
#define CRecipientFilter C_RecipientFilter
|
|
|
|
#else
|
|
|
|
#include "dod_player.h"
|
|
|
|
#endif
|
|
|
|
ConVar dod_bonusround( "dod_bonusround", "1", FCVAR_REPLICATED, "If true, the winners of the round can attack in the intermission." );
|
|
ConVar sv_showimpacts("sv_showimpacts", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "Shows client (red) and server (blue) bullet impact point" );
|
|
|
|
void DispatchEffect( const char *pName, const CEffectData &data );
|
|
|
|
bool CDODPlayer::CanMove( void ) const
|
|
{
|
|
bool bValidMoveState = (State_Get() == STATE_ACTIVE || State_Get() == STATE_OBSERVER_MODE);
|
|
|
|
if ( !bValidMoveState )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// BUG! This is not called on the client at respawn, only first spawn!
|
|
void CDODPlayer::SharedSpawn()
|
|
{
|
|
BaseClass::SharedSpawn();
|
|
|
|
// Reset the animation state or we will animate to standing
|
|
// when we spawn
|
|
|
|
m_Shared.SetJumping( false );
|
|
|
|
m_flMinNextStepSoundTime = gpGlobals->curtime;
|
|
|
|
m_bPlayingProneMoveSound = false;
|
|
}
|
|
|
|
float GetDensityFromMaterial( surfacedata_t *pSurfaceData )
|
|
{
|
|
float flMaterialMod = 1.0f;
|
|
|
|
Assert( pSurfaceData );
|
|
|
|
// material mod is how many points of damage it costs to go through
|
|
// 1 unit of the material
|
|
|
|
switch( pSurfaceData->game.material )
|
|
{
|
|
//super soft
|
|
// case CHAR_TEX_LEAVES:
|
|
// flMaterialMod = 1.2f;
|
|
// break;
|
|
|
|
case CHAR_TEX_FLESH:
|
|
flMaterialMod = 1.35f;
|
|
break;
|
|
|
|
//soft
|
|
// case CHAR_TEX_STUCCO:
|
|
// case CHAR_TEX_SNOW:
|
|
case CHAR_TEX_GLASS:
|
|
case CHAR_TEX_WOOD:
|
|
case CHAR_TEX_TILE:
|
|
flMaterialMod = 1.8f;
|
|
break;
|
|
|
|
//hard
|
|
// case CHAR_TEX_SKY:
|
|
// case CHAR_TEX_ROCK:
|
|
// case CHAR_TEX_SAND:
|
|
case CHAR_TEX_CONCRETE:
|
|
case CHAR_TEX_DIRT: // "sand"
|
|
flMaterialMod = 6.6f;
|
|
break;
|
|
|
|
//really hard
|
|
// case CHAR_TEX_HEAVYMETAL:
|
|
case CHAR_TEX_GRATE:
|
|
case CHAR_TEX_METAL:
|
|
flMaterialMod = 13.5f;
|
|
break;
|
|
|
|
case 'X': // invisible collision material
|
|
flMaterialMod = 0.1f;
|
|
break;
|
|
|
|
//medium
|
|
// case CHAR_TEX_BRICK:
|
|
// case CHAR_TEX_GRAVEL:
|
|
// case CHAR_TEX_GRASS:
|
|
default:
|
|
|
|
#ifndef CLIENT_DLL
|
|
AssertMsg( 0, UTIL_VarArgs( "Material has unknown materialmod - '%c' \n", pSurfaceData->game.material ) );
|
|
#endif
|
|
|
|
flMaterialMod = 5.0f;
|
|
break;
|
|
}
|
|
|
|
Assert( flMaterialMod > 0 );
|
|
|
|
return flMaterialMod;
|
|
}
|
|
|
|
static bool TraceToExit( const Vector &start,
|
|
const Vector &dir,
|
|
Vector &end,
|
|
const float flStepSize,
|
|
const float flMaxDistance )
|
|
{
|
|
float flDistance = 0;
|
|
Vector last = start;
|
|
|
|
while ( flDistance < flMaxDistance )
|
|
{
|
|
flDistance += flStepSize;
|
|
|
|
// no point in tracing past the max distance.
|
|
// if this check fails, we save ourselves a traceline later
|
|
if ( flDistance > flMaxDistance )
|
|
{
|
|
flDistance = flMaxDistance;
|
|
}
|
|
|
|
end = start + flDistance * dir;
|
|
|
|
// point contents fails to return proper contents inside a func_detail brush, eg the dod_flash
|
|
// stairs
|
|
|
|
//int contents = UTIL_PointContents( end );
|
|
|
|
trace_t tr;
|
|
UTIL_TraceLine( end, end, MASK_SOLID | CONTENTS_HITBOX, NULL, &tr );
|
|
|
|
//if ( (UTIL_PointContents ( end ) & MASK_SOLID) == 0 )
|
|
|
|
if ( !tr.startsolid )
|
|
{
|
|
// found first free point
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#include "ammodef.h"
|
|
|
|
#define NEW_HITBOX_GROUP_CODE 1
|
|
#undef ARM_PENETRATION
|
|
|
|
#ifndef CLIENT_DLL
|
|
#include "ndebugoverlay.h"
|
|
#endif
|
|
void CDODPlayer::FireBullets( const FireBulletsInfo_t &info )
|
|
{
|
|
trace_t tr;
|
|
trace_t reverseTr; //Used to find exit points
|
|
static int iMaxPenetrations = 6;
|
|
int iPenetrations = 0;
|
|
float flDamage = info.m_flDamage; //Remaining damage in the bullet
|
|
Vector vecSrc = info.m_vecSrc;
|
|
Vector vecEnd = vecSrc + info.m_vecDirShooting * info.m_flDistance;
|
|
|
|
static int iTraceMask = ( ( MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX | CONTENTS_PRONE_HELPER ) & ~CONTENTS_GRATE );
|
|
|
|
CBaseEntity *pLastHitEntity = this; // start with us so we don't trace ourselves
|
|
|
|
int iDamageType = GetAmmoDef()->DamageType( info.m_iAmmoType );
|
|
int iCollisionGroup = COLLISION_GROUP_NONE;
|
|
|
|
#ifdef GAME_DLL
|
|
int iNumHeadshots = 0;
|
|
#endif
|
|
|
|
while ( flDamage > 0 && iPenetrations < iMaxPenetrations )
|
|
{
|
|
//DevMsg( 2, "penetration: %d, starting dmg: %.1f\n", iPenetrations, flDamage );
|
|
|
|
CBaseEntity *pPreviousHit = pLastHitEntity;
|
|
|
|
// skip the shooter always
|
|
CTraceFilterSkipTwoEntities ignoreShooterAndPrevious( this, pPreviousHit, iCollisionGroup );
|
|
UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &ignoreShooterAndPrevious, &tr );
|
|
|
|
const float rayExtension = 40.0f;
|
|
UTIL_ClipTraceToPlayers( vecSrc, vecEnd + info.m_vecDirShooting * rayExtension, iTraceMask, &ignoreShooterAndPrevious, &tr );
|
|
|
|
if ( tr.fraction == 1.0f )
|
|
break; // we didn't hit anything, stop tracing shoot
|
|
|
|
// New hitbox code that uses hitbox groups instead of trying to trace
|
|
// through the player
|
|
if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
|
|
{
|
|
switch( tr.hitgroup )
|
|
{
|
|
#ifdef GAME_DLL
|
|
case HITGROUP_HEAD:
|
|
{
|
|
if ( tr.m_pEnt->GetTeamNumber() != GetTeamNumber() )
|
|
{
|
|
iNumHeadshots++;
|
|
}
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case HITGROUP_LEFTARM:
|
|
case HITGROUP_RIGHTARM:
|
|
{
|
|
//DevMsg( 2, "Hit arms, tracing against alt hitboxes.. \n" );
|
|
|
|
CDODPlayer *pPlayer = ToDODPlayer( tr.m_pEnt );
|
|
|
|
// set hitbox set to "dod_no_arms"
|
|
pPlayer->SetHitboxSet( 1 );
|
|
|
|
trace_t newTr;
|
|
|
|
// re-fire the trace
|
|
UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &ignoreShooterAndPrevious, &newTr );
|
|
|
|
// if we hit the same player in the chest
|
|
if ( tr.m_pEnt == newTr.m_pEnt )
|
|
{
|
|
//DevMsg( 2, ".. and we hit the chest.\n" );
|
|
|
|
Assert( tr.hitgroup != newTr.hitgroup ); // If we hit this, hitbox sets are broken
|
|
|
|
// use that damage instead
|
|
tr = newTr;
|
|
}
|
|
|
|
// set hitboxes back to "dod"
|
|
pPlayer->SetHitboxSet( 0 );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pLastHitEntity = tr.m_pEnt;
|
|
|
|
if ( sv_showimpacts.GetBool() )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
// draw red client impact markers
|
|
debugoverlay->AddBoxOverlay( tr.endpos, Vector(-1,-1,-1), Vector(1,1,1), QAngle(0,0,0), 255, 0, 0, 127, 4 );
|
|
|
|
if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
|
|
{
|
|
C_BasePlayer *player = ToBasePlayer( tr.m_pEnt );
|
|
player->DrawClientHitboxes( 4, true );
|
|
}
|
|
#else
|
|
// draw blue server impact markers
|
|
NDebugOverlay::Box( tr.endpos, Vector(-1,-1,-1), Vector(1,1,1), 0,0,255,127, 4 );
|
|
|
|
if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
|
|
{
|
|
CBasePlayer *player = ToBasePlayer( tr.m_pEnt );
|
|
player->DrawServerHitboxes( 4, true );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
// See if the bullet ended up underwater + started out of the water
|
|
if ( enginetrace->GetPointContents( tr.endpos ) & (CONTENTS_WATER|CONTENTS_SLIME) )
|
|
{
|
|
trace_t waterTrace;
|
|
UTIL_TraceLine( vecSrc, tr.endpos, (MASK_SHOT|CONTENTS_WATER|CONTENTS_SLIME), this, iCollisionGroup, &waterTrace );
|
|
|
|
if( waterTrace.allsolid != 1 )
|
|
{
|
|
CEffectData data;
|
|
data.m_vOrigin = waterTrace.endpos;
|
|
data.m_vNormal = waterTrace.plane.normal;
|
|
data.m_flScale = random->RandomFloat( 8, 12 );
|
|
|
|
if ( waterTrace.contents & CONTENTS_SLIME )
|
|
{
|
|
data.m_fFlags |= FX_WATER_IN_SLIME;
|
|
}
|
|
|
|
DispatchEffect( "gunshotsplash", data );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Do Regular hit effects
|
|
|
|
// Don't decal nodraw surfaces
|
|
if ( !( tr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) ) )
|
|
{
|
|
CBaseEntity *pEntity = tr.m_pEnt;
|
|
if ( !( !friendlyfire.GetBool() && pEntity && pEntity->GetTeamNumber() == GetTeamNumber() ) )
|
|
{
|
|
UTIL_ImpactTrace( &tr, iDamageType );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Get surface where the bullet entered ( if it had different surfaces on enter and exit )
|
|
surfacedata_t *pSurfaceData = physprops->GetSurfaceData( tr.surface.surfaceProps );
|
|
Assert( pSurfaceData );
|
|
|
|
float flMaterialMod = GetDensityFromMaterial(pSurfaceData);
|
|
|
|
if ( iDamageType & DMG_MACHINEGUN )
|
|
{
|
|
flMaterialMod *= 0.65;
|
|
}
|
|
|
|
// try to penetrate object
|
|
Vector penetrationEnd;
|
|
float flMaxDistance = flDamage / flMaterialMod;
|
|
|
|
#ifndef CLIENT_DLL
|
|
ClearMultiDamage();
|
|
|
|
float flActualDamage = flDamage;
|
|
|
|
CTakeDamageInfo dmgInfo( info.m_pAttacker, info.m_pAttacker, flActualDamage, iDamageType );
|
|
CalculateBulletDamageForce( &dmgInfo, info.m_iAmmoType, info.m_vecDirShooting, tr.endpos );
|
|
tr.m_pEnt->DispatchTraceAttack( dmgInfo, info.m_vecDirShooting, &tr );
|
|
|
|
DevMsg( 2, "Giving damage ( %.1f ) to entity of type %s\n", flActualDamage, tr.m_pEnt->GetClassname() );
|
|
|
|
TraceAttackToTriggers( dmgInfo, tr.startpos, tr.endpos, info.m_vecDirShooting );
|
|
#endif
|
|
|
|
int stepsize = 16;
|
|
|
|
// displacement always stops the bullet
|
|
if ( tr.IsDispSurface() )
|
|
{
|
|
DevMsg( 2, "bullet was stopped by displacement\n" );
|
|
ApplyMultiDamage();
|
|
break;
|
|
}
|
|
|
|
// trace through the solid to find the exit point and how much material we went through
|
|
if ( !TraceToExit( tr.endpos, info.m_vecDirShooting, penetrationEnd, stepsize, flMaxDistance ) )
|
|
{
|
|
DevMsg( 2, "bullet was stopped\n" );
|
|
ApplyMultiDamage();
|
|
break;
|
|
}
|
|
|
|
// find exact penetration exit
|
|
CTraceFilterSimple ignoreShooter( this, iCollisionGroup );
|
|
UTIL_TraceLine( penetrationEnd, tr.endpos, iTraceMask, &ignoreShooter, &reverseTr );
|
|
|
|
// Now we can apply the damage, after we have traced the entity
|
|
// so it doesn't break or die before we have a change to test against it
|
|
#ifndef CLIENT_DLL
|
|
ApplyMultiDamage();
|
|
#endif
|
|
|
|
// Continue looking for the exit point
|
|
if( reverseTr.m_pEnt != tr.m_pEnt && reverseTr.m_pEnt != NULL )
|
|
{
|
|
// something was blocking, trace again
|
|
CTraceFilterSkipTwoEntities ignoreShooterAndBlocker( this, reverseTr.m_pEnt, iCollisionGroup );
|
|
UTIL_TraceLine( penetrationEnd, tr.endpos, iTraceMask, &ignoreShooterAndBlocker, &reverseTr );
|
|
}
|
|
|
|
if ( sv_showimpacts.GetBool() )
|
|
{
|
|
debugoverlay->AddLineOverlay( penetrationEnd, reverseTr.endpos, 255, 0, 0, true, 3.0 );
|
|
}
|
|
|
|
// penetration was successful
|
|
|
|
#ifdef CLIENT_DLL
|
|
// bullet did penetrate object, exit Decal
|
|
if ( !( reverseTr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) ) )
|
|
{
|
|
CBaseEntity *pEntity = reverseTr.m_pEnt;
|
|
if ( !( !friendlyfire.GetBool() && pEntity && pEntity->GetTeamNumber() == GetTeamNumber() ) )
|
|
{
|
|
UTIL_ImpactTrace( &reverseTr, iDamageType );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//setup new start end parameters for successive trace
|
|
|
|
// New start point is our last exit point
|
|
vecSrc = reverseTr.endpos + /* 1.0 * */ info.m_vecDirShooting;
|
|
|
|
// Reduce bullet damage by material and distanced travelled through that material
|
|
// if it is < 0 we won't go through the loop again
|
|
float flTraceDistance = VectorLength( reverseTr.endpos - tr.endpos );
|
|
|
|
flDamage -= flMaterialMod * flTraceDistance;
|
|
|
|
if( flDamage > 0 )
|
|
{
|
|
DevMsg( 2, "Completed penetration, new damage is %.1f\n", flDamage );
|
|
}
|
|
else
|
|
{
|
|
DevMsg( 2, "bullet was stopped\n" );
|
|
}
|
|
|
|
iPenetrations++;
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
HandleHeadshotAchievement( iNumHeadshots );
|
|
#endif
|
|
}
|
|
|
|
void CDODPlayer::SetSprinting( bool bIsSprinting )
|
|
{
|
|
m_Shared.SetSprinting( bIsSprinting );
|
|
}
|
|
|
|
bool CDODPlayer::IsSprinting( void )
|
|
{
|
|
float flVelSqr = GetAbsVelocity().LengthSqr();
|
|
|
|
return m_Shared.m_bIsSprinting && ( flVelSqr > 0.5f );
|
|
}
|
|
|
|
bool CDODPlayer::CanAttack( void )
|
|
{
|
|
if ( IsSprinting() )
|
|
return false;
|
|
|
|
if ( GetMoveType() == MOVETYPE_LADDER )
|
|
return false;
|
|
|
|
if ( m_Shared.IsJumping() )
|
|
return false;
|
|
|
|
if ( m_Shared.IsDefusing() )
|
|
return false;
|
|
|
|
// cannot attack while prone moving. except if you have a bazooka
|
|
if ( m_Shared.IsProne() && GetAbsVelocity().LengthSqr() > 1 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( m_Shared.IsGoingProne() || m_Shared.IsGettingUpFromProne() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CDODGameRules *rules = DODGameRules();
|
|
|
|
Assert( rules );
|
|
|
|
DODRoundState state = rules->State_Get();
|
|
|
|
if ( dod_bonusround.GetBool() )
|
|
{
|
|
if ( GetTeamNumber() == TEAM_ALLIES )
|
|
{
|
|
return ( state == STATE_RND_RUNNING || state == STATE_ALLIES_WIN );
|
|
}
|
|
else
|
|
{
|
|
return ( state == STATE_RND_RUNNING || state == STATE_AXIS_WIN );
|
|
}
|
|
}
|
|
else
|
|
return ( state == STATE_RND_RUNNING );
|
|
}
|
|
|
|
|
|
void CDODPlayer::SetAnimation( PLAYER_ANIM playerAnim )
|
|
{
|
|
// In DoD, its CPlayerAnimState object manages ALL the animation state.
|
|
return;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input :
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
const Vector CDODPlayer::GetPlayerMins( void ) const
|
|
{
|
|
if ( IsObserver() )
|
|
{
|
|
return VEC_OBS_HULL_MIN;
|
|
}
|
|
else
|
|
{
|
|
if ( GetFlags() & FL_DUCKING )
|
|
{
|
|
return VEC_DUCK_HULL_MIN;
|
|
}
|
|
else if ( m_Shared.IsProne() )
|
|
{
|
|
return VEC_PRONE_HULL_MIN;
|
|
}
|
|
else
|
|
{
|
|
return VEC_HULL_MIN;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input :
|
|
// Output : const Vector
|
|
//-----------------------------------------------------------------------------
|
|
const Vector CDODPlayer::GetPlayerMaxs( void ) const
|
|
{
|
|
if ( IsObserver() )
|
|
{
|
|
return VEC_OBS_HULL_MAX_SCALED( this );
|
|
}
|
|
else
|
|
{
|
|
if ( GetFlags() & FL_DUCKING )
|
|
{
|
|
return VEC_DUCK_HULL_MAX_SCALED( this );
|
|
}
|
|
else if ( m_Shared.IsProne() )
|
|
{
|
|
return VEC_PRONE_HULL_MAX_SCALED( this );
|
|
}
|
|
else
|
|
{
|
|
return VEC_HULL_MAX_SCALED( this );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : collisionGroup -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDODPlayer::ShouldCollide( int collisionGroup, int contentsMask ) const
|
|
{
|
|
if ( collisionGroup == COLLISION_GROUP_PLAYER_MOVEMENT || collisionGroup == COLLISION_GROUP_PROJECTILE )
|
|
{
|
|
switch( GetTeamNumber() )
|
|
{
|
|
case TEAM_ALLIES:
|
|
if ( !( contentsMask & CONTENTS_TEAM2 ) )
|
|
return false;
|
|
break;
|
|
|
|
case TEAM_AXIS:
|
|
if ( !( contentsMask & CONTENTS_TEAM1 ) )
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return BaseClass::ShouldCollide( collisionGroup, contentsMask );
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------------------------- //
|
|
// CDODPlayerShared implementation.
|
|
// --------------------------------------------------------------------------------------------------- //
|
|
|
|
CDODPlayerShared::CDODPlayerShared()
|
|
{
|
|
m_bProne = false;
|
|
m_bForceProneChange = false;
|
|
m_flNextProneCheck = 0;
|
|
|
|
m_flSlowedUntilTime = 0;
|
|
|
|
m_flUnProneTime = 0;
|
|
m_flGoProneTime = 0;
|
|
|
|
m_flDeployedHeight = STANDING_DEPLOY_HEIGHT;
|
|
m_flDeployChangeTime = gpGlobals->curtime;
|
|
|
|
SetDesiredPlayerClass( PLAYERCLASS_UNDEFINED );
|
|
|
|
m_flLastViewAnimationTime = gpGlobals->curtime;
|
|
|
|
m_pViewOffsetAnim = NULL;
|
|
}
|
|
|
|
CDODPlayerShared::~CDODPlayerShared()
|
|
{
|
|
if ( m_pViewOffsetAnim )
|
|
{
|
|
delete m_pViewOffsetAnim;
|
|
m_pViewOffsetAnim = NULL;
|
|
}
|
|
}
|
|
|
|
void CDODPlayerShared::Init( CDODPlayer *pPlayer )
|
|
{
|
|
m_pOuter = pPlayer;
|
|
}
|
|
|
|
bool CDODPlayerShared::IsDucking( void ) const
|
|
{
|
|
return !!( m_pOuter->GetFlags() & FL_DUCKING );
|
|
}
|
|
|
|
bool CDODPlayerShared::IsProne() const
|
|
{
|
|
return m_bProne;
|
|
}
|
|
|
|
bool CDODPlayerShared::IsGettingUpFromProne() const
|
|
{
|
|
return ( m_flUnProneTime > 0 );
|
|
}
|
|
|
|
bool CDODPlayerShared::IsGoingProne() const
|
|
{
|
|
return ( m_flGoProneTime > 0 );
|
|
}
|
|
|
|
void CDODPlayerShared::SetSprinting( bool bSprinting )
|
|
{
|
|
if ( bSprinting && !m_bIsSprinting )
|
|
{
|
|
StartSprinting();
|
|
|
|
// only one penalty per key press
|
|
if ( m_bGaveSprintPenalty == false )
|
|
{
|
|
m_flStamina -= INITIAL_SPRINT_STAMINA_PENALTY;
|
|
m_bGaveSprintPenalty = true;
|
|
}
|
|
}
|
|
else if ( !bSprinting && m_bIsSprinting )
|
|
{
|
|
StopSprinting();
|
|
}
|
|
}
|
|
|
|
// this is reset when we let go of the sprint key
|
|
void CDODPlayerShared::ResetSprintPenalty( void )
|
|
{
|
|
m_bGaveSprintPenalty = false;
|
|
}
|
|
|
|
void CDODPlayerShared::StartSprinting( void )
|
|
{
|
|
m_bIsSprinting = true;
|
|
|
|
#ifndef CLIENT_DLL
|
|
m_pOuter->RemoveHintTimer( HINT_USE_SPRINT );
|
|
#endif
|
|
}
|
|
|
|
void CDODPlayerShared::StopSprinting( void )
|
|
{
|
|
m_bIsSprinting = false;
|
|
}
|
|
|
|
void CDODPlayerShared::SetProne( bool bProne, bool bNoAnimation /* = false */ )
|
|
{
|
|
m_bProne = bProne;
|
|
|
|
if ( bNoAnimation )
|
|
{
|
|
m_flGoProneTime = 0;
|
|
m_flUnProneTime = 0;
|
|
|
|
// cancel the view animation!
|
|
m_bForceProneChange = true;
|
|
}
|
|
|
|
if ( !bProne /*&& IsSniperZoomed()*/ ) // forceunzoom for going prone is in StartGoingProne
|
|
{
|
|
ForceUnzoom();
|
|
}
|
|
}
|
|
|
|
void CDODPlayerShared::SetJumping( bool bJumping )
|
|
{
|
|
m_bJumping = bJumping;
|
|
|
|
if ( IsSniperZoomed() )
|
|
{
|
|
ForceUnzoom();
|
|
}
|
|
}
|
|
|
|
void CDODPlayerShared::ForceUnzoom( void )
|
|
{
|
|
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
|
|
if( pWeapon && ( pWeapon->GetDODWpnData().m_WeaponType & WPN_MASK_GUN ) )
|
|
{
|
|
CDODSniperWeapon *pSniper = dynamic_cast<CDODSniperWeapon *>(pWeapon);
|
|
|
|
if ( pSniper )
|
|
{
|
|
pSniper->ZoomOut();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CDODPlayerShared::IsBazookaDeployed( void ) const
|
|
{
|
|
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
|
|
if( pWeapon && pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_BAZOOKA )
|
|
{
|
|
CDODBaseRocketWeapon *pBazooka = (CDODBaseRocketWeapon *)pWeapon;
|
|
return pBazooka->IsDeployed() && !pBazooka->m_bInReload;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CDODPlayerShared::IsBazookaOnlyDeployed( void ) const
|
|
{
|
|
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
|
|
if( pWeapon && pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_BAZOOKA )
|
|
{
|
|
CDODBaseRocketWeapon *pBazooka = (CDODBaseRocketWeapon *)pWeapon;
|
|
return pBazooka->IsDeployed();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CDODPlayerShared::IsSniperZoomed( void ) const
|
|
{
|
|
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
|
|
if( pWeapon && ( pWeapon->GetDODWpnData().m_WeaponType & WPN_MASK_GUN ) )
|
|
{
|
|
CWeaponDODBaseGun *pGun = (CWeaponDODBaseGun *)pWeapon;
|
|
Assert( pGun );
|
|
return pGun->IsSniperZoomed();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CDODPlayerShared::IsInMGDeploy( void ) const
|
|
{
|
|
CWeaponDODBase *pWeapon = GetActiveDODWeapon();
|
|
if( pWeapon && pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_MG )
|
|
{
|
|
CDODBipodWeapon *pMG = dynamic_cast<CDODBipodWeapon *>( pWeapon );
|
|
Assert( pMG );
|
|
return pMG->IsDeployed();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CDODPlayerShared::IsProneDeployed( void ) const
|
|
{
|
|
return ( IsProne() && IsInMGDeploy() );
|
|
}
|
|
|
|
bool CDODPlayerShared::IsSandbagDeployed( void ) const
|
|
{
|
|
return ( !IsProne() && IsInMGDeploy() );
|
|
}
|
|
|
|
void CDODPlayerShared::SetDesiredPlayerClass( int playerclass )
|
|
{
|
|
m_iDesiredPlayerClass = playerclass;
|
|
}
|
|
|
|
int CDODPlayerShared::DesiredPlayerClass( void )
|
|
{
|
|
return m_iDesiredPlayerClass;
|
|
}
|
|
|
|
void CDODPlayerShared::SetPlayerClass( int playerclass )
|
|
{
|
|
m_iPlayerClass = playerclass;
|
|
}
|
|
|
|
int CDODPlayerShared::PlayerClass( void )
|
|
{
|
|
return m_iPlayerClass;
|
|
}
|
|
|
|
void CDODPlayerShared::SetStamina( float flStamina )
|
|
{
|
|
m_flStamina = clamp( flStamina, 0, 100 );
|
|
}
|
|
|
|
CWeaponDODBase* CDODPlayerShared::GetActiveDODWeapon() const
|
|
{
|
|
CBaseCombatWeapon *pWeapon = m_pOuter->GetActiveWeapon();
|
|
if ( pWeapon )
|
|
{
|
|
Assert( dynamic_cast< CWeaponDODBase* >( pWeapon ) == static_cast< CWeaponDODBase* >( pWeapon ) );
|
|
return static_cast< CWeaponDODBase* >( pWeapon );
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void CDODPlayerShared::SetDeployed( bool bDeployed, float flHeight /* = -1 */ )
|
|
{
|
|
if( gpGlobals->curtime - m_flDeployChangeTime < 0.2 )
|
|
{
|
|
Assert(0);
|
|
}
|
|
|
|
m_flDeployChangeTime = gpGlobals->curtime;
|
|
m_vecDeployedAngles = m_pOuter->EyeAngles();
|
|
|
|
if( flHeight > 0 )
|
|
{
|
|
m_flDeployedHeight = flHeight;
|
|
}
|
|
else
|
|
{
|
|
m_flDeployedHeight = m_pOuter->GetViewOffset()[2];
|
|
}
|
|
}
|
|
|
|
QAngle CDODPlayerShared::GetDeployedAngles( void ) const
|
|
{
|
|
return m_vecDeployedAngles;
|
|
}
|
|
|
|
void CDODPlayerShared::SetDeployedYawLimits( float flLeftYaw, float flRightYaw )
|
|
{
|
|
m_flDeployedYawLimitLeft = flLeftYaw;
|
|
m_flDeployedYawLimitRight = -flRightYaw;
|
|
|
|
m_vecDeployedAngles = m_pOuter->EyeAngles();
|
|
}
|
|
|
|
void CDODPlayerShared::ClampDeployedAngles( QAngle *vecTestAngles )
|
|
{
|
|
Assert( vecTestAngles );
|
|
|
|
// Clamp Pitch
|
|
vecTestAngles->x = clamp( vecTestAngles->x, MAX_DEPLOY_PITCH, MIN_DEPLOY_PITCH );
|
|
|
|
// Clamp Yaw - do a bit more work as yaw will wrap around and cause problems
|
|
float flDeployedYawCenter = GetDeployedAngles().y;
|
|
|
|
float flDelta = AngleNormalize( vecTestAngles->y - flDeployedYawCenter );
|
|
|
|
if( flDelta < m_flDeployedYawLimitRight )
|
|
{
|
|
vecTestAngles->y = flDeployedYawCenter + m_flDeployedYawLimitRight;
|
|
}
|
|
else if( flDelta > m_flDeployedYawLimitLeft )
|
|
{
|
|
vecTestAngles->y = flDeployedYawCenter + m_flDeployedYawLimitLeft;
|
|
}
|
|
|
|
/*
|
|
Msg( "delta %.1f ( left %.1f, right %.1f ) ( %.1f -> %.1f )\n",
|
|
flDelta,
|
|
flDeployedYawCenter + m_flDeployedYawLimitLeft,
|
|
flDeployedYawCenter + m_flDeployedYawLimitRight,
|
|
before,
|
|
vecTestAngles->y );
|
|
*/
|
|
|
|
}
|
|
|
|
float CDODPlayerShared::GetDeployedHeight( void ) const
|
|
{
|
|
return m_flDeployedHeight;
|
|
}
|
|
|
|
float CDODPlayerShared::GetSlowedTime( void ) const
|
|
{
|
|
return m_flSlowedUntilTime;
|
|
}
|
|
|
|
void CDODPlayerShared::SetSlowedTime( float t )
|
|
{
|
|
m_flSlowedUntilTime = gpGlobals->curtime + t;
|
|
}
|
|
|
|
void CDODPlayerShared::StartGoingProne( void )
|
|
{
|
|
// make the prone sound
|
|
CPASFilter filter( m_pOuter->GetAbsOrigin() );
|
|
filter.UsePredictionRules();
|
|
m_pOuter->EmitSound( filter, m_pOuter->entindex(), "Player.GoProne" );
|
|
|
|
// slow to prone speed
|
|
m_flGoProneTime = gpGlobals->curtime + TIME_TO_PRONE;
|
|
|
|
m_flUnProneTime = 0.0f; //reset
|
|
|
|
if ( IsSniperZoomed() )
|
|
ForceUnzoom();
|
|
}
|
|
|
|
void CDODPlayerShared::StandUpFromProne( void )
|
|
{
|
|
// make the prone sound
|
|
CPASFilter filter( m_pOuter->GetAbsOrigin() );
|
|
filter.UsePredictionRules();
|
|
m_pOuter->EmitSound( filter, m_pOuter->entindex(), "Player.UnProne" );
|
|
|
|
// speed up to target speed
|
|
m_flUnProneTime = gpGlobals->curtime + TIME_TO_PRONE;
|
|
|
|
m_flGoProneTime = 0.0f; //reset
|
|
}
|
|
|
|
bool CDODPlayerShared::CanChangePosition( void )
|
|
{
|
|
if ( IsInMGDeploy() )
|
|
return false;
|
|
|
|
if ( IsGettingUpFromProne() )
|
|
return false;
|
|
|
|
if ( IsGoingProne() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CDODPlayer::UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity )
|
|
{
|
|
Vector knee;
|
|
Vector feet;
|
|
float height;
|
|
int fLadder;
|
|
|
|
if ( m_flStepSoundTime > 0 )
|
|
{
|
|
m_flStepSoundTime -= 1000.0f * gpGlobals->frametime;
|
|
if ( m_flStepSoundTime < 0 )
|
|
{
|
|
m_flStepSoundTime = 0;
|
|
}
|
|
}
|
|
|
|
if ( m_flStepSoundTime > 0 )
|
|
return;
|
|
|
|
if ( GetFlags() & (FL_FROZEN|FL_ATCONTROLS))
|
|
return;
|
|
|
|
if ( GetMoveType() == MOVETYPE_NOCLIP || GetMoveType() == MOVETYPE_OBSERVER )
|
|
return;
|
|
|
|
if ( !sv_footsteps.GetFloat() )
|
|
return;
|
|
|
|
float speed = VectorLength( vecVelocity );
|
|
float groundspeed = Vector2DLength( vecVelocity.AsVector2D() );
|
|
|
|
// determine if we are on a ladder
|
|
fLadder = ( GetMoveType() == MOVETYPE_LADDER );
|
|
|
|
float flDuck;
|
|
|
|
if ( ( GetFlags() & FL_DUCKING) || fLadder )
|
|
{
|
|
flDuck = 100;
|
|
}
|
|
else
|
|
{
|
|
flDuck = 0;
|
|
}
|
|
|
|
static float flMinProneSpeed = 10.0f;
|
|
static float flMinSpeed = 70.0f;
|
|
static float flRunSpeed = 110.0f;
|
|
|
|
bool onground = ( GetFlags() & FL_ONGROUND );
|
|
bool movingalongground = ( groundspeed > 0.0f );
|
|
bool moving_fast_enough = ( speed >= flMinSpeed );
|
|
|
|
// always play a step sound if we are moving faster than
|
|
|
|
// To hear step sounds you must be either on a ladder or moving along the ground AND
|
|
// You must be moving fast enough
|
|
|
|
CheckProneMoveSound( groundspeed, onground );
|
|
|
|
if ( !moving_fast_enough || !(fLadder || ( onground && movingalongground )) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool bWalking = ( speed < flRunSpeed ); // or ducking!
|
|
|
|
VectorCopy( vecOrigin, knee );
|
|
VectorCopy( vecOrigin, feet );
|
|
|
|
height = GetPlayerMaxs()[ 2 ] - GetPlayerMins()[ 2 ];
|
|
|
|
knee[2] = vecOrigin[2] + 0.2 * height;
|
|
|
|
float flVol;
|
|
|
|
// find out what we're stepping in or on...
|
|
if ( fLadder )
|
|
{
|
|
psurface = physprops->GetSurfaceData( physprops->GetSurfaceIndex( "ladder" ) );
|
|
flVol = 1.0;
|
|
m_flStepSoundTime = 350;
|
|
}
|
|
else if ( enginetrace->GetPointContents( knee ) & MASK_WATER )
|
|
{
|
|
static int iSkipStep = 0;
|
|
|
|
if ( iSkipStep == 0 )
|
|
{
|
|
iSkipStep++;
|
|
return;
|
|
}
|
|
|
|
if ( iSkipStep++ == 3 )
|
|
{
|
|
iSkipStep = 0;
|
|
}
|
|
psurface = physprops->GetSurfaceData( physprops->GetSurfaceIndex( "wade" ) );
|
|
flVol = 0.65;
|
|
m_flStepSoundTime = 600;
|
|
}
|
|
else if ( enginetrace->GetPointContents( feet ) & MASK_WATER )
|
|
{
|
|
psurface = physprops->GetSurfaceData( physprops->GetSurfaceIndex( "water" ) );
|
|
flVol = bWalking ? 0.2 : 0.5;
|
|
m_flStepSoundTime = bWalking ? 400 : 300;
|
|
}
|
|
else
|
|
{
|
|
if ( !psurface )
|
|
return;
|
|
|
|
if ( bWalking )
|
|
{
|
|
m_flStepSoundTime = 400;
|
|
}
|
|
else
|
|
{
|
|
if ( speed > 200 )
|
|
{
|
|
int speeddiff = PLAYER_SPEED_SPRINT - PLAYER_SPEED_RUN;
|
|
int diff = speed - PLAYER_SPEED_RUN;
|
|
|
|
float percent = (float)diff / (float)speeddiff;
|
|
|
|
m_flStepSoundTime = 300.0f - 30.0f * percent;
|
|
}
|
|
else
|
|
{
|
|
m_flStepSoundTime = 400;
|
|
}
|
|
}
|
|
|
|
switch ( psurface->game.material )
|
|
{
|
|
default:
|
|
case CHAR_TEX_CONCRETE:
|
|
flVol = bWalking ? 0.2 : 0.5;
|
|
break;
|
|
|
|
case CHAR_TEX_METAL:
|
|
flVol = bWalking ? 0.2 : 0.5;
|
|
break;
|
|
|
|
case CHAR_TEX_DIRT:
|
|
flVol = bWalking ? 0.25 : 0.55;
|
|
break;
|
|
|
|
case CHAR_TEX_VENT:
|
|
flVol = bWalking ? 0.4 : 0.7;
|
|
break;
|
|
|
|
case CHAR_TEX_GRATE:
|
|
flVol = bWalking ? 0.2 : 0.5;
|
|
break;
|
|
|
|
case CHAR_TEX_TILE:
|
|
flVol = bWalking ? 0.2 : 0.5;
|
|
break;
|
|
|
|
case CHAR_TEX_SLOSH:
|
|
flVol = bWalking ? 0.2 : 0.5;
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_flStepSoundTime += flDuck; // slower step time if ducking
|
|
|
|
if ( GetFlags() & FL_DUCKING )
|
|
{
|
|
flVol *= 0.65;
|
|
}
|
|
|
|
// protect us from prediction errors a little bit
|
|
if ( m_flMinNextStepSoundTime > gpGlobals->curtime )
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_flMinNextStepSoundTime = gpGlobals->curtime + 0.1f;
|
|
|
|
PlayStepSound( feet, psurface, flVol, false );
|
|
}
|
|
|
|
void CDODPlayer::CheckProneMoveSound( int groundspeed, bool onground )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
bool bShouldPlay = (groundspeed > 10) && (onground == true) && m_Shared.IsProne() && IsAlive();
|
|
|
|
if ( m_bPlayingProneMoveSound && !bShouldPlay )
|
|
{
|
|
StopSound( "Player.MoveProne" );
|
|
m_bPlayingProneMoveSound= false;
|
|
}
|
|
else if ( !m_bPlayingProneMoveSound && bShouldPlay )
|
|
{
|
|
CRecipientFilter filter;
|
|
filter.AddRecipientsByPAS( WorldSpaceCenter() );
|
|
EmitSound( filter, entindex(), "Player.MoveProne" );
|
|
|
|
m_bPlayingProneMoveSound = true;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : step -
|
|
// fvol -
|
|
// force - force sound to play
|
|
//-----------------------------------------------------------------------------
|
|
void CDODPlayer::PlayStepSound( Vector &vecOrigin, surfacedata_t *psurface, float fvol, bool force )
|
|
{
|
|
if ( gpGlobals->maxClients > 1 && !sv_footsteps.GetFloat() )
|
|
return;
|
|
|
|
#if defined( CLIENT_DLL )
|
|
// during prediction play footstep sounds only once
|
|
if ( prediction->InPrediction() && !prediction->IsFirstTimePredicted() )
|
|
return;
|
|
#endif
|
|
|
|
if ( !psurface )
|
|
return;
|
|
|
|
unsigned short stepSoundName = m_Local.m_nStepside ? psurface->sounds.stepleft : psurface->sounds.stepright;
|
|
m_Local.m_nStepside = !m_Local.m_nStepside;
|
|
|
|
if ( !stepSoundName )
|
|
return;
|
|
|
|
IPhysicsSurfaceProps *physprops = MoveHelper( )->GetSurfaceProps();
|
|
const char *pSoundName = physprops->GetString( stepSoundName );
|
|
CSoundParameters params;
|
|
|
|
// we don't always know the model, so go by team
|
|
char *pModelNameForGender = DOD_PLAYERMODEL_AXIS_RIFLEMAN;
|
|
|
|
if( GetTeamNumber() == TEAM_ALLIES )
|
|
pModelNameForGender = DOD_PLAYERMODEL_US_RIFLEMAN;
|
|
|
|
if ( !CBaseEntity::GetParametersForSound( pSoundName, params, pModelNameForGender ) )
|
|
return;
|
|
|
|
CRecipientFilter filter;
|
|
filter.AddRecipientsByPAS( vecOrigin );
|
|
|
|
#ifndef CLIENT_DLL
|
|
// im MP, server removed all players in origins PVS, these players
|
|
// generate the footsteps clientside
|
|
if ( gpGlobals->maxClients > 1 )
|
|
filter.RemoveRecipientsByPVS( vecOrigin );
|
|
#endif
|
|
|
|
EmitSound_t ep;
|
|
ep.m_nChannel = params.channel;
|
|
ep.m_pSoundName = params.soundname;
|
|
ep.m_flVolume = fvol;
|
|
ep.m_SoundLevel = params.soundlevel;
|
|
ep.m_nFlags = 0;
|
|
ep.m_nPitch = params.pitch;
|
|
ep.m_pOrigin = &vecOrigin;
|
|
|
|
EmitSound( filter, entindex(), ep );
|
|
}
|
|
|
|
Activity CDODPlayer::TranslateActivity( Activity baseAct, bool *pRequired /* = NULL */ )
|
|
{
|
|
Activity translated = baseAct;
|
|
|
|
if ( GetActiveWeapon() )
|
|
{
|
|
translated = GetActiveWeapon()->ActivityOverride( baseAct, pRequired );
|
|
}
|
|
else if (pRequired)
|
|
{
|
|
*pRequired = false;
|
|
}
|
|
|
|
return translated;
|
|
}
|
|
|
|
void CDODPlayerShared::SetCPIndex( int index )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
|
|
if ( m_pOuter->IsLocalPlayer() )
|
|
{
|
|
if ( index == -1 )
|
|
{
|
|
// just left an area
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ObjectiveIconShrink" );
|
|
}
|
|
else
|
|
{
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ObjectiveIconGrow" );
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
m_iCPIndex = index;
|
|
}
|
|
|
|
void CDODPlayerShared::SetLastViewAnimTime( float flTime )
|
|
{
|
|
m_flLastViewAnimationTime = flTime;
|
|
}
|
|
|
|
float CDODPlayerShared::GetLastViewAnimTime( void )
|
|
{
|
|
return m_flLastViewAnimationTime;
|
|
}
|
|
|
|
void CDODPlayerShared::ResetViewOffsetAnimation( void )
|
|
{
|
|
if ( m_pViewOffsetAnim )
|
|
{
|
|
//cancel it!
|
|
m_pViewOffsetAnim->Reset();
|
|
}
|
|
}
|
|
|
|
void CDODPlayerShared::ViewOffsetAnimation( Vector vecDest, float flTime, ViewAnimationType type )
|
|
{
|
|
if ( !m_pViewOffsetAnim )
|
|
{
|
|
m_pViewOffsetAnim = CViewOffsetAnimation::CreateViewOffsetAnim( m_pOuter );
|
|
}
|
|
|
|
Assert( m_pViewOffsetAnim );
|
|
|
|
if ( m_pViewOffsetAnim )
|
|
{
|
|
m_pViewOffsetAnim->StartAnimation( m_pOuter->GetViewOffset(), vecDest, flTime, type );
|
|
}
|
|
}
|
|
|
|
void CDODPlayerShared::ViewAnimThink( void )
|
|
{
|
|
// Check for the flag that will reset our view animations
|
|
// when the player respawns
|
|
if ( m_bForceProneChange )
|
|
{
|
|
ResetViewOffsetAnimation();
|
|
|
|
m_pOuter->SetViewOffset( VEC_VIEW_SCALED( m_pOuter ) );
|
|
|
|
m_bForceProneChange = false;
|
|
}
|
|
|
|
if ( m_pViewOffsetAnim )
|
|
{
|
|
m_pViewOffsetAnim->Think();
|
|
}
|
|
}
|
|
|
|
void CDODPlayerShared::ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
|
|
{
|
|
Vector org = m_pOuter->GetAbsOrigin();
|
|
|
|
if ( IsProne() )
|
|
{
|
|
static Vector vecProneMin(-44, -44, 0 );
|
|
static Vector vecProneMax(44, 44, 24 );
|
|
|
|
VectorAdd( vecProneMin, org, *pVecWorldMins );
|
|
VectorAdd( vecProneMax, org, *pVecWorldMaxs );
|
|
}
|
|
else
|
|
{
|
|
static Vector vecMin(-32, -32, 0 );
|
|
static Vector vecMax(32, 32, 72 );
|
|
|
|
VectorAdd( vecMin, org, *pVecWorldMins );
|
|
VectorAdd( vecMax, org, *pVecWorldMaxs );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets whether this player is dominating the specified other player
|
|
//-----------------------------------------------------------------------------
|
|
void CDODPlayerShared::SetPlayerDominated( CDODPlayer *pPlayer, bool bDominated )
|
|
{
|
|
int iPlayerIndex = pPlayer->entindex();
|
|
m_bPlayerDominated.Set( iPlayerIndex, bDominated );
|
|
pPlayer->m_Shared.SetPlayerDominatingMe( m_pOuter, bDominated );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets whether this player is being dominated by the other player
|
|
//-----------------------------------------------------------------------------
|
|
void CDODPlayerShared::SetPlayerDominatingMe( CDODPlayer *pPlayer, bool bDominated )
|
|
{
|
|
int iPlayerIndex = pPlayer->entindex();
|
|
m_bPlayerDominatingMe.Set( iPlayerIndex, bDominated );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns whether this player is dominating the specified other player
|
|
//-----------------------------------------------------------------------------
|
|
bool CDODPlayerShared::IsPlayerDominated( int iPlayerIndex )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
// On the client, we only have data for the local player.
|
|
// As a result, it's only valid to ask for dominations related to the local player
|
|
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
|
|
if ( !pLocalPlayer )
|
|
return false;
|
|
|
|
Assert( m_pOuter->IsLocalPlayer() || pLocalPlayer->entindex() == iPlayerIndex );
|
|
|
|
if ( m_pOuter->IsLocalPlayer() )
|
|
return m_bPlayerDominated.Get( iPlayerIndex );
|
|
|
|
return pLocalPlayer->m_Shared.IsPlayerDominatingMe( m_pOuter->entindex() );
|
|
#else
|
|
// Server has all the data.
|
|
return m_bPlayerDominated.Get( iPlayerIndex );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CDODPlayerShared::IsPlayerDominatingMe( int iPlayerIndex )
|
|
{
|
|
return m_bPlayerDominatingMe.Get( iPlayerIndex );
|
|
}
|