diff options
Diffstat (limited to 'game/client/tf2/c_basetfplayer.cpp')
| -rw-r--r-- | game/client/tf2/c_basetfplayer.cpp | 2705 |
1 files changed, 2705 insertions, 0 deletions
diff --git a/game/client/tf2/c_basetfplayer.cpp b/game/client/tf2/c_basetfplayer.cpp new file mode 100644 index 0000000..a85c2ed --- /dev/null +++ b/game/client/tf2/c_basetfplayer.cpp @@ -0,0 +1,2705 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// +#include "cbase.h" +#include "c_basetfplayer.h" +#include "beamdraw.h" +#include <stdarg.h> +#include "ivmodemanager.h" +#include "shake.h" +#include "ivieweffects.h" +#include "c_tfteam.h" +#include "view.h" +#include "UserCmd.h" +#include "ivrenderview.h" +#include "model_types.h" +#include "view_shared.h" +#include "hud_orders.h" +#include "weapon_twohandedcontainer.h" +#include "particles_simple.h" +#include "playerandobjectenumerator.h" +#include "iclientvehicle.h" +#include "input.h" +#include "basetfvehicle.h" +#include "c_vehicle_teleport_station.h" +#include "weapon_combatshield.h" +#include "hud_vehicle_role.h" +#include "hud_technologytreedoc.h" +#include "iclientmode.h" +#include "weapon_selection.h" +#include "clienteffectprecachesystem.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + + +// Don't alias here +#if defined( CBaseTFPlayer ) +#undef CBaseTFPlayer +#endif + +void CAM_ToThirdPerson(void); +void CAM_ToFirstPerson(void); +void FX_ReconParticle( const Vector &vecOrigin, bool bBlue ); + +static ConVar tf2_showstate( "tf2_showstate", "0", 0, "Print state name\n" ); +extern ConVar mannedgun_usethirdperson; +ConVar damageboost_modeloffset( "damageboost_modeloffset", "1" ); +ConVar damageboost_modelphasespeed_min( "damageboost_modelphasespeed_min", "99" ); +ConVar damageboost_modelphasespeed_max( "damageboost_modelphasespeed_max", "170" ); + + +CLIENTEFFECT_REGISTER_BEGIN( PrecacheBaseTFPlayer ) +CLIENTEFFECT_MATERIAL( "sprites/physbeam" ) +CLIENTEFFECT_MATERIAL( "player/infiltratorcamo/infiltratorcamo" ) +CLIENTEFFECT_REGISTER_END() + + +class CPersonalShieldEffect +{ +public: + + static CPersonalShieldEffect* Create( C_BaseTFPlayer *pEnt, const Vector &vOffsetFromEnt, const Vector &vIncomingDirection, int iDamage ); + + ~CPersonalShieldEffect(); + + // Returns false if the effect is done and should be deleted. + bool Update( float dt ); + + void Render(); // Draw the effect. + +private: + + CPersonalShieldEffect(); + +private: + + CHandle<C_BaseTFPlayer> m_hEnt; + Vector m_vOffsetFromEnt; + Vector m_vIncomingDirection; + float m_flDamage; + + enum + { + NUM_TRACERS = 10 + }; + + Vector m_vTracerEndPoints[NUM_TRACERS]; // These are relative to the model's origin. + float m_flLifetimeRemaining; + float m_flTotalLifetime; +}; + + +CPersonalShieldEffect* CPersonalShieldEffect::Create( + C_BaseTFPlayer *pEnt, + const Vector &vOffsetFromEnt, + const Vector &vIncomingDirection, + int iDamage ) +{ + CPersonalShieldEffect *pRet = new CPersonalShieldEffect; + if ( pRet ) + { + pRet->m_hEnt = pEnt; + pRet->m_vOffsetFromEnt = vOffsetFromEnt; + pRet->m_flDamage = iDamage; + + Vector vNormal = vIncomingDirection; + VectorNormalize( vNormal ); + + for ( int i=0; i < CPersonalShieldEffect::NUM_TRACERS; i++ ) + { + pRet->m_vTracerEndPoints[i] = pRet->m_vOffsetFromEnt; + + Vector vOffset = RandomVector( -1, 1 ); + + // Make it tangent to a sphere enclosing the player. + float flDot = vNormal.Dot( vOffset ); + vOffset -= vNormal * flDot; + + VectorNormalize( vOffset ); + vOffset *= 10; + + pRet->m_vTracerEndPoints[i] += vOffset; + } + + pRet->m_flLifetimeRemaining = pRet->m_flTotalLifetime = 0.15; + pRet->m_vIncomingDirection = vIncomingDirection; + } + return pRet; +} + +CPersonalShieldEffect::CPersonalShieldEffect() +{ +} + + +CPersonalShieldEffect::~CPersonalShieldEffect() +{ +} + + +bool CPersonalShieldEffect::Update( float dt ) +{ + if ( !m_hEnt.Get() ) + return false; + + m_flLifetimeRemaining -= dt; + if ( m_flLifetimeRemaining >= 0 ) + { + return true; + } + else + { + return false; + } +} + + +void CPersonalShieldEffect::Render() +{ + if ( !m_hEnt.Get() ) + return; + + Vector vCenter = m_hEnt->WorldSpaceCenter( ); + + const Vector vBasePos = vCenter + m_vOffsetFromEnt; + IMaterial *pMat = materials->FindMaterial( "sprites/physbeam", TEXTURE_GROUP_CLIENT_EFFECTS ); + + CBeamSeg seg; + + // Get redder as their health goes down. + float flColor = (float)m_hEnt->GetHealth() / m_hEnt->GetMaxHealth(); + flColor = clamp(flColor, 0, 1); + seg.m_vColor.Init( 0.5 + 0.5*flColor, flColor, flColor ); + + seg.m_flAlpha = 1; + seg.m_flTexCoord = 0; + seg.m_flWidth = 2; + + for ( int i=0; i < CPersonalShieldEffect::NUM_TRACERS; i++ ) + { + const Vector vEndPos = vCenter + m_vTracerEndPoints[i]; + + static int nSegs = 5; + + CBeamSegDraw beamDraw; + beamDraw.Start( nSegs, pMat ); + + for ( int iSeg=0; iSeg < nSegs; iSeg++ ) + { + float t = (float)iSeg / (nSegs-1); + VectorLerp( vBasePos, vEndPos, t, seg.m_vPos ); + + // Add a random offset. + seg.m_vPos += RandomVector( -3, 3 ); + seg.m_flTexCoord += 0.1f; + + beamDraw.NextSeg( &seg ); + } + + beamDraw.End(); + } + +/* + Vector vEggBounds[2]; + m_hEnt->GetBounds( vEggBounds[0], vEggBounds[1] ); + vEggBounds[0] += m_hEnt->GetAbsOrigin(); + vEggBounds[1] += m_hEnt->GetAbsOrigin(); + Vector vEggCenter = (vEggBounds[0] + vEggBounds[1]) * 0.5f; + Vector vEggDims = (vEggBounds[1] - vEggBounds[0]) * 0.5f; + + Vector vUp( 0, 0, 1 ); + Vector vForward = m_vIncomingDirection; + vForward.z = 0; + VectorNormalize( vForward ); + Vector vRight = vUp.Cross( vForward ); + + // Now draw an eggshell around the player showing their health. + seg.m_vColor.Init( 1, flColor, flColor ); + seg.m_flAlpha = 0.3f; + seg.m_flWidth = 1; + + static int nSamples = 30; + CBeamSegDraw beamDraw; + beamDraw.Start( nSamples, pMat ); + + for ( int iSeg=0; iSeg < nSamples; iSeg++ ) + { + float t = (float)iSeg / (nSamples-1); + float angle = M_PI * 2.0f * t; + seg.m_vPos = vEggCenter + vUp*vEggDims.z*sin( angle ) + vRight*vEggDims.x*cos( angle ); + beamDraw.NextSeg( &seg ); + } + + beamDraw.End(); +*/ +} + + +//----------------------------------------------------------------------------- +// Purpose: Helper for animation state machine +// Input : clear - +// destination - +// *pFormat - +// ... - +//----------------------------------------------------------------------------- +void StatusPrintf( bool clear, int destination, char *pFormat, ... ) +{ + if ( destination != 4 && destination != 5 ) + return; + char data[ 2048 ]; + va_list argptr; + + va_start( argptr, pFormat ); + Q_vsnprintf( data, sizeof( data ), pFormat, argptr ); + va_end( argptr ); + + char *out = data; + if ( destination == 5 ) + out += 2; + + if ( destination == 5 ) + { + char slot[3]; + Q_strncpy( slot, data, 3 ); + + slot[2] = 0; + + int s = atoi( slot ); + s &= 31; + + engine->Con_NPrintf( s, "%s", out ); + } + else + { + Msg( "%s", out ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: RecvProxy that converts the Player's object UtlVector to entindexes +//----------------------------------------------------------------------------- +void RecvProxy_PlayerObjectList( const CRecvProxyData *pData, void *pStruct, void *pOut ) +{ + CTFPlayerLocalData *pLocalData = (CTFPlayerLocalData*)pStruct; + CBaseHandle *pHandle = (CBaseHandle*)(&(pLocalData->m_aObjects[pData->m_iElement])); + RecvProxy_IntToEHandle( pData, pStruct, pHandle ); +} + + +void RecvProxyArrayLength_PlayerObjects( void *pStruct, int objectID, int currentArrayLength ) +{ + CTFPlayerLocalData *pLocalData = (CTFPlayerLocalData*)pStruct; + + if ( pLocalData->m_aObjects.Count() != currentArrayLength ) + { + pLocalData->m_aObjects.SetSize( currentArrayLength ); + } +} + +BEGIN_RECV_TABLE_NOBASE( CTFPlayerLocalData, DT_TFLocal ) + RecvPropInt( RECVINFO(m_nInTacticalView) ), + RecvPropInt( RECVINFO( m_bKnockedDown )), + RecvPropVector( RECVINFO( m_vecKnockDownDir )), + RecvPropInt( RECVINFO( m_bThermalVision )), + RecvPropInt( RECVINFO( m_iIDEntIndex )), + RecvPropArray( RecvPropInt( RECVINFO(m_iResourceAmmo[0])), m_iResourceAmmo), + RecvPropInt( RECVINFO(m_iBankResources) ), + RecvPropArray2( + RecvProxyArrayLength_PlayerObjects, + RecvPropInt( "player_object_array_element", 0, SIZEOF_IGNORE, 0, RecvProxy_PlayerObjectList ), + MAX_OBJECTS_PER_PLAYER, + 0, + "player_object_array" ), + RecvPropInt( RECVINFO( m_bAttachingSapper ) ), + RecvPropFloat( RECVINFO( m_flSapperAttachmentFrac ) ), + RecvPropInt( RECVINFO( m_bForceMapOverview ) ), +END_RECV_TABLE() + +IMPLEMENT_CLIENTCLASS_DT(C_BaseTFPlayer, DT_BaseTFPlayer, CBaseTFPlayer) + RecvPropDataTable(RECVINFO_DT(m_TFLocal),0, &REFERENCE_RECV_TABLE(DT_TFLocal), DataTableRecvProxy_StaticDataTable), + + // Class Data Tables + RecvPropInt( RECVINFO(m_iPlayerClass)), + RecvPropDataTable( RECVINFO_DT( m_PlayerClasses ), 0, &REFERENCE_RECV_TABLE( DT_AllPlayerClasses ), DataTableRecvProxy_StaticDataTable ), + + RecvPropEHandle( RECVINFO( m_hSelectedMCV ) ), + RecvPropInt( RECVINFO(m_iCurrentZoneState ) ), + RecvPropInt( RECVINFO(m_iMaxHealth ) ), + RecvPropInt( RECVINFO(m_TFPlayerFlags) ), + RecvPropInt( RECVINFO( m_bUnderAttack )), + RecvPropInt( RECVINFO( m_bIsBlocking )), + + // Sniper - will get moved to a class data table + RecvPropVector( RECVINFO(m_vecDeployedAngles) ), + RecvPropInt( RECVINFO( m_bDeployed )), + RecvPropInt( RECVINFO( m_bDeploying )), + RecvPropInt( RECVINFO( m_bUnDeploying )), + + // Infiltrator - will get moved to a class data table + RecvPropFloat( RECVINFO( m_flCamouflageAmount )), + RecvPropEHandle(RECVINFO(m_hSpawnPoint)), +END_RECV_TABLE() + +BEGIN_PREDICTION_DATA_NO_BASE( CTFPlayerLocalData ) + + DEFINE_PRED_FIELD( m_nInTacticalView, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bKnockedDown, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_vecKnockDownDir, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bThermalVision, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), +// DEFINE_PRED_FIELD( m_iIDEntIndex, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_iBankResources, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_ARRAY( m_iResourceAmmo, FIELD_INTEGER, RESOURCE_TYPES, FTYPEDESC_INSENDTABLE ), + //DEFINE_PRED_ARRAY( m_aObjects, FIELD_EHANDLE, MAX_OBJECTS_PER_PLAYER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bAttachingSapper, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_flSapperAttachmentFrac, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bForceMapOverview, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), + +END_PREDICTION_DATA() + + +// TODO: consolidate all these includes and the DEFINE_PRED... for each class type +// into tf_shareddefs.h. +#include "c_tf_class_commando.h" +#include "c_tf_class_defender.h" +#include "c_tf_class_escort.h" +#include "c_tf_class_infiltrator.h" +#include "c_tf_class_medic.h" +#include "c_tf_class_recon.h" +#include "c_tf_class_sniper.h" +#include "c_tf_class_support.h" +#include "c_tf_class_sapper.h" +#include "c_tf_class_pyro.h" + + +BEGIN_PREDICTION_DATA( C_BaseTFPlayer ) + + DEFINE_PRED_TYPEDESCRIPTION( m_TFLocal, CTFPlayerLocalData ), + + DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_PRIVATE | FTYPEDESC_OVERRIDE ), + DEFINE_PRED_FIELD( m_flPlaybackRate, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_PRIVATE | FTYPEDESC_OVERRIDE ), + + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_COMMANDO], C_PlayerClassCommando ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_DEFENDER], C_PlayerClassDefender ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_ESCORT], C_PlayerClassEscort ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_INFILTRATOR], C_PlayerClassInfiltrator ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_MEDIC], C_PlayerClassMedic ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_RECON], C_PlayerClassRecon ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_SNIPER], C_PlayerClassSniper ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_SUPPORT], C_PlayerClassSupport ), + DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_SAPPER], C_PlayerClassSapper ), + + DEFINE_PRED_FIELD( m_iPlayerClass, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_flCamouflageAmount, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_hSpawnPoint, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_iMaxHealth, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bDeployed, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bDeploying, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bUnDeploying, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_vecDeployedAngles, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_iCurrentZoneState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_TFPlayerFlags, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_bUnderAttack, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ), + + DEFINE_PRED_FIELD( m_vecConstraintCenter, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_flConstraintRadius, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_flConstraintWidth, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_flConstraintSpeedFactor, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ), + + DEFINE_FIELD( m_vecPosDelta, FIELD_VECTOR ), + DEFINE_ARRAY( m_aMomentum, FIELD_FLOAT, C_BaseTFPlayer::MOMENTUM_MAXSIZE ), + DEFINE_FIELD( m_iMomentumHead, FIELD_INTEGER ), + //DEFINE_FIELD( m_iSelectedTarget, FIELD_INTEGER ), + //DEFINE_FIELD( m_iPersonalTarget, FIELD_INTEGER ), + //DEFINE_FIELD( m_iLastHealth, FIELD_INTEGER ), + //DEFINE_FIELD( m_nOldTacticalView, FIELD_INTEGER ), + //DEFINE_FIELD( m_nOldPlayerClass, FIELD_INTEGER ), + //DEFINE_FIELD( m_bOldThermalVision, FIELD_BOOLEAN ), + //DEFINE_FIELD( m_bOldKnockDownState, FIELD_BOOLEAN ), + //DEFINE_FIELD( m_flStartKnockdown, FIELD_FLOAT ), + //DEFINE_FIELD( m_flEndKnockdown, FIELD_FLOAT ), + //DEFINE_FIELD( m_vecOriginalViewAngles, FIELD_VECTOR ), + //DEFINE_FIELD( m_vecCurrentKnockdownAngles, FIELD_VECTOR ), + //DEFINE_FIELD( m_vecKnockDownGoalAngles, FIELD_VECTOR ), + //DEFINE_FIELD( m_bKnockdownOverrideAngles, FIELD_BOOLEAN ), + //DEFINE_FIELD( m_flKnockdownViewheightAdjust, FIELD_FLOAT ), + //DEFINE_FIELD( m_flLastMoveTime, FIELD_FLOAT ), + //DEFINE_FIELD( m_vecLastOrigin, FIELD_VECTOR ), + //DEFINE_FIELD( m_flLastDamageTime, FIELD_FLOAT ), + //DEFINE_FIELD( m_flLastGainHealthTime, FIELD_FLOAT ), + //DEFINE_FIELD( m_flDampeningAmount, FIELD_FLOAT ), + //DEFINE_FIELD( m_flGoalDampeningAmount, FIELD_FLOAT ), + //DEFINE_FIELD( m_flDampeningStayoutTime, FIELD_FLOAT ), + //DEFINE_FIELD( m_flMovementCamoSuppression, FIELD_FLOAT ), + //DEFINE_FIELD( m_flGoalMovementCamoSuppressionAmount, FIELD_FLOAT ), + //DEFINE_FIELD( m_flMovementCamoSuppressionStayoutTime, FIELD_FLOAT ), + //DEFINE_FIELD( m_flNextAdrenalinEffect, FIELD_FLOAT ), + //DEFINE_FIELD( m_bFadingIn, FIELD_BOOLEAN ), + //DEFINE_FIELD( m_iIDEntIndex, FIELD_INTEGER ), + //DEFINE_ARRAY( m_BoostModelAngles, FIELD_FLOAT, 3 ), + + // DEFINE_PRED_TYPEDESCRIPTION( m_RideVehicle, CRideVehicle ), + // DEFINE_FIELD( m_aTargetReticles, CUtlVector < CTargetReticle * > ), + // DEFINE_FIELD( m_aSpyCameras, CUtlVector < C_SpyCamera * > ), + // DEFINE_FIELD( m_ParticleEffect, CParticleEffectBinding ), + // DEFINE_FIELD( m_ParticleTimer, TimedEvent ), + // DEFINE_FIELD( m_MaterialHandle, PMaterialHandle ), + // DEFINE_FIELD( m_pParticleMgr, CParticleMgr ), + // DEFINE_FIELD( m_pThermalMaterial, IMaterial ), + // DEFINE_FIELD( m_pCamoEffectMaterial, IMaterial ), + // DEFINE_FIELD( m_BoostMaterial, CMaterialReference ), + // DEFINE_FIELD( m_EMPMaterial, CMaterialReference ), + // DEFINE_FIELD( m_PersonalShieldEffects, CUtlLinkedList < CPersonalShieldEffect* , int > ), + // DEFINE_FIELD( m_hSelectedOrder, CHandle < C_Order > ), + // DEFINE_FIELD( m_hPersonalOrder, FIELD_EHANDLE ), + // DEFINE_FIELD( m_hSelectedObject, CHandle < C_BaseObject > ), + +END_PREDICTION_DATA() + +LINK_ENTITY_TO_CLASS( player, C_BaseTFPlayer ); + +ConVar cl_TargetInfoFadeDist("cl_TargetInfoFadeDist", "800", 0, "Distance at which TF player targetting info fades out."); + +//----------------------------------------------------------------------------- +// Purpose: Return true if the local player is the specified class +//----------------------------------------------------------------------------- +bool IsLocalPlayerClass( int iClass ) +{ + C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer(); + if ( pPlayer ) + { + return ( pPlayer->PlayerClass() == iClass ); + } + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Return the local player's class +//----------------------------------------------------------------------------- +int GetLocalPlayerClass( void ) +{ + C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer(); + if ( pPlayer ) + { + return pPlayer->PlayerClass(); + } + return TFCLASS_UNDECIDED; +} + +//----------------------------------------------------------------------------- +// returns true if the local player is in tactical view +//----------------------------------------------------------------------------- +bool IsLocalPlayerInTactical( void ) +{ + C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer(); + if (!pPlayer) + return false; + + return !!pPlayer->m_TFLocal.m_nInTacticalView; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +C_BaseTFPlayer::C_BaseTFPlayer() : + m_PlayerClasses( this ), m_PlayerAnimState( this ) +{ + Clear(); +} + +void C_BaseTFPlayer::Clear() +{ + m_iPlayerClass = TFCLASS_UNDECIDED; + m_iCurrentZoneState = 0; + m_TFPlayerFlags = 0; + m_hSelectedOrder = NULL; + m_hPersonalOrder = NULL; + m_hSelectedObject = NULL; + m_iSelectedTarget = 0; + m_iPersonalTarget = 0; + m_iIDEntIndex = 0; + m_bStoreRagdollInfo = true; + m_flNextUseCheck = 0; + m_pSapperAttachmentStatus = NULL; + + int i; + for ( i=0; i < ARRAYSIZE( m_BoostModelAngles ); i++ ) + { + m_BoostModelAngles[i] = RandomFloat( 0, 360 ); + } + + + for ( i = 0; i < MOMENTUM_MAXSIZE; i++ ) + { + m_aMomentum[ i ] = 1.0f; + } +} + + +bool C_BaseTFPlayer::IsHidden() const +{ + return (m_TFPlayerFlags & TF_PLAYER_HIDDEN) != 0; +} + + +bool C_BaseTFPlayer::IsDamageBoosted() const +{ + return (m_TFPlayerFlags & TF_PLAYER_DAMAGE_BOOST) != 0; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +C_BaseTFPlayer::~C_BaseTFPlayer() +{ + int iSize = m_aTargetReticles.Size(); + for (int i = iSize-1; i >= 0; i-- ) + { + delete m_aTargetReticles[i]; + } + m_aTargetReticles.Purge(); + + if ( m_pThermalMaterial ) + { + m_pThermalMaterial->DecrementReferenceCount(); + } + if ( m_pCamoEffectMaterial ) + { + m_pCamoEffectMaterial->DecrementReferenceCount(); + } + + m_PersonalShieldEffects.PurgeAndDeleteElements(); + + if ( m_pSapperAttachmentStatus ) + { + delete m_pSapperAttachmentStatus; + } +} + +//----------------------------------------------------------------------------- +// Add, remove object from the panel +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetDormant( bool bDormant ) +{ + BaseClass::SetDormant( bDormant ); + ENTITY_PANEL_ACTIVATE( "player", !bDormant ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::HasNamedTechnology( const char *name ) +{ + CTechnologyTree *pTree = GetTechnologyTreeDoc().GetTechnologyTree(); + if ( !pTree ) + return false; + + CBaseTechnology *pItem = pTree->GetTechnology(name); + // If the tech doesn't exist, everyone has it by default + if ( !pItem ) + return true; + + return pItem->GetActive(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::ShouldDraw() +{ + if ( IsHidden() ) + return false; + + C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer(); + if ( local && local->IsUsingThermalVision() ) + return true; + + // Draw the local player if he's the driver of a vehicle. + // We can safely return true here because vehicles will hide drivers that shouldn't be visible. + if ( mannedgun_usethirdperson.GetInt() && IsVehicleMounted() && IsLocalPlayer() ) + { + IClientVehicle *pVehicle = GetVehicle(); + int nRole = pVehicle->GetPassengerRole( this ); + if ( nRole == VEHICLE_ROLE_DRIVER ) + return !IsEffectActive(EF_NODRAW); + } + + return BaseClass::ShouldDraw(); +} + + +//----------------------------------------------------------------------------- +// Should this object cast shadows? +//----------------------------------------------------------------------------- +ShadowType_t C_BaseTFPlayer::ShadowCastType() +{ + // FIXME: This check can be removed once we've dealt with the interpolation problem + C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer(); + if (local == this) + return SHADOWS_NONE; + + if (IsCamouflaged()) + return SHADOWS_NONE; + + return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC; +} + + +//----------------------------------------------------------------------------- +// Purpose: Called once per frame for the local player only. +// Called after rendering ( called in PostRender() ) the 3d objects ( i.e., other players ) +// but before vgui paints 2d overlays so that we can update the positions of all world +// targets before rendering +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::UpdateTargetReticles( void ) +{ + // Update all the target reticles + for ( int i = 0; i < m_aTargetReticles.Size(); i++ ) + { + m_aTargetReticles[i]->Update(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Called to update hud elements contained in the player +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::ClientThink( void ) +{ + BaseClass::ClientThink(); + + SetNextClientThink( CLIENT_THINK_ALWAYS ); + + CheckKnockdownState(); + CheckMovementCamoSuppression(); + CheckCamoDampening(); + CheckLastMovement(); + CheckAdrenalin(); + UpdateIDTarget(); + + // update personal shield effects. + int iNext; + for ( int i=m_PersonalShieldEffects.Head(); i != m_PersonalShieldEffects.InvalidIndex(); i = iNext ) + { + iNext = m_PersonalShieldEffects.Next( i ); + CPersonalShieldEffect *pEffect = m_PersonalShieldEffects[i]; + + if ( !pEffect->Update( gpGlobals->frametime ) ) + { + delete pEffect; + m_PersonalShieldEffects.Remove( i ); + } + } + + // Let the classes think as well. + if ( GetPlayerClass() ) + { + GetPlayerClass()->ClassThink(); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Store off old movetype ( commander or not ) +// Input : bnewentity - +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::OnPreDataChanged( DataUpdateType_t updateType ) +{ + BaseClass::OnPreDataChanged( updateType ); + + m_nOldTacticalView = m_TFLocal.m_nInTacticalView; + + m_iLastHealth = GetHealth(); + m_bOldKnockDownState = m_TFLocal.m_bKnockedDown; + + m_bOldThermalVision = m_TFLocal.m_bThermalVision; + + m_nOldPlayerClass = m_iPlayerClass; + + // Chain. + if ( GetPlayerClass() ) + { + GetPlayerClass()->ClassPreDataUpdate(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Switch to/from commander mode if necessary +// Input : bnewentity - +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::OnDataChanged( DataUpdateType_t updateType ) +{ + bool bnewentity = (updateType == DATA_UPDATE_CREATED); + if ( bnewentity ) + { + // Do the minimap panel thing here because we don't + // want predicted players to have traces + CONSTRUCT_MINIMAP_PANEL( "minimap_player", MINIMAP_PLAYERS ); + + SetNextClientThink( CLIENT_THINK_ALWAYS ); + m_BoostMaterial.Init( "player/damageboost/thermal", TEXTURE_GROUP_CLIENT_EFFECTS ); + m_EMPMaterial.Init( "player/empeffect", TEXTURE_GROUP_CLIENT_EFFECTS ); + } + + BaseClass::OnDataChanged( updateType ); + + // Only care about this stuff for the local player + if ( IsLocalPlayer() ) + { + // Check to see if we switched into/out of the commander mode. + if ( m_TFLocal.m_nInTacticalView != m_nOldTacticalView ) + { + // Is this the local player + C_BasePlayer *player = C_BasePlayer::GetLocalPlayer(); + if ( player == this ) + { + // Tell mode switcher that server changed our mode + modemanager->SwitchMode( m_TFLocal.m_nInTacticalView ? true : false, false ); + } + } + + // Knockdown + if ( m_bOldKnockDownState != m_TFLocal.m_bKnockedDown ) + { + if ( IsKnockedDown() ) + { + m_flStartKnockdown = gpGlobals->curtime; + m_vecOriginalViewAngles = GetAbsAngles(); + + m_vecKnockDownGoalAngles = m_TFLocal.m_vecKnockDownDir; + } + else + { + m_flEndKnockdown = gpGlobals->curtime; + } + } + + // Thermal Vision + if ( m_bOldThermalVision != m_TFLocal.m_bThermalVision ) + { + if ( m_TFLocal.m_bThermalVision ) + { + ScreenFade_t sf; + memset( &sf, 0, sizeof( sf ) ); + sf.a = 128; + sf.r = 0; + sf.g = 0; + sf.b = 255; + sf.duration = 0; // not used + sf.holdTime = (float)(1<<SCREENFADE_FRACBITS) * 30.0f; + sf.fadeFlags = FFADE_STAYOUT; + vieweffects->Fade( sf ); + } + else + { + vieweffects->ClearPermanentFades(); + } + } + + if ( m_nOldPlayerClass != m_iPlayerClass ) + { + engine->ClientCmd( "cancelselect\n" ); + } + } + + if ( bnewentity ) + { + m_iLastHealth = GetHealth(); + m_flLastDamageTime = -10000; + m_flLastGainHealthTime = -10000; + } + + if (m_iLastHealth != GetHealth()) + { + if (m_iLastHealth > GetHealth()) + { + if (GetHealth() < GetMaxHealth()) + { + m_flLastDamageTime = gpGlobals->curtime; + + C_TFTeam *pTeam = static_cast<C_TFTeam*>(GetTeam()); + if (pTeam && !IsLocalPlayer() && m_bUnderAttack ) + pTeam->NotifyBaseUnderAttack( GetAbsOrigin(), false ); + } + } + else + { + m_flLastGainHealthTime = gpGlobals->curtime; + + // If we were just fully healed, remove all decals + if ( GetHealth() >= GetMaxHealth() ) + { + RemoveAllDecals(); + } + } + } + + // Snap to 100 % since we round down + if ( m_flCamouflageAmount > 99.0f ) + { + m_flCamouflageAmount = 100.0f; + } + + // Chain. + if ( GetPlayerClass() ) + { + GetPlayerClass()->ClassOnDataChanged(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::PreDataUpdate( DataUpdateType_t updateType ) +{ + BaseClass::PreDataUpdate( updateType ); + + m_bOldAttachingSapper = m_TFLocal.m_bAttachingSapper; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::PostDataUpdate( DataUpdateType_t updateType ) +{ + BaseClass::PostDataUpdate( updateType ); + + // Only care about this stuff for the local player + if ( IsLocalPlayer() ) + { + // Sapper attachment + if ( m_bOldAttachingSapper != m_TFLocal.m_bAttachingSapper || m_TFLocal.m_bAttachingSapper ) + { + if ( !m_pSapperAttachmentStatus ) + { + // Create the attachment status + m_pSapperAttachmentStatus = new CHealthBarPanel(); + vgui::Panel *pParent = g_pClientMode->GetViewport(); + m_pSapperAttachmentStatus->SetParent( pParent ); + m_pSapperAttachmentStatus->SetAutoDelete( false ); + m_pSapperAttachmentStatus->SetPos( XRES(320) - XRES(40), YRES(250) ); + m_pSapperAttachmentStatus->SetSize( XRES(80), YRES(8) ); + m_pSapperAttachmentStatus->SetGoodColor( 240, 180, 63, 192 ); + m_pSapperAttachmentStatus->SetBadColor( 0, 0, 0, 192 ); + } + + m_pSapperAttachmentStatus->SetVisible( m_TFLocal.m_bAttachingSapper ); + if ( m_TFLocal.m_bAttachingSapper ) + { + m_pSapperAttachmentStatus->SetHealth( m_TFLocal.m_flSapperAttachmentFrac ); + } + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::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 BASEENTITY_MSG_REMOVE_DECALS: + { + RemoveAllDecals(); + } + break; + case PLAYER_MSG_PERSONAL_SHIELD: + { + Vector vOffsetFromEnt; + msg.ReadBitVec3Coord( vOffsetFromEnt ); + + // Show a personal shield effect. + Vector vIncomingDirection; + msg.ReadBitVec3Normal( vIncomingDirection ); + + short iDamage = msg.ReadShort(); + + // Show the effect. + CPersonalShieldEffect *pEffect = CPersonalShieldEffect::Create( this, vOffsetFromEnt, vIncomingDirection, iDamage ); + if ( pEffect ) + m_PersonalShieldEffects.AddToTail( pEffect ); + } + break; + default: + break; + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Free this entity +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::Release( void ) +{ + // Remove any reticles on this entity + C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer(); + if ( pPlayer ) + { + pPlayer->Remove_Target( this ); + } + + BaseClass::Release(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::ItemPostFrame( void ) +{ + if ( m_flNextUseCheck < gpGlobals->curtime ) + { + m_flNextUseCheck = gpGlobals->curtime + 0.3; + + CVehicleRoleHudElement *pElement = GET_HUDELEMENT( CVehicleRoleHudElement ); + Assert( pElement ); + pElement->ShowVehicleRole( -1 ); + + // See if there's an entity we can +use + if ( IsAlive() && !GetVehicle() && ( gpGlobals->curtime > m_flNextAttack ) ) + { + CBaseEntity *pUseEntity = FindUseEntity(); + if ( pUseEntity ) + { + // Vehicles need to show we're going to get in them + C_BaseTFVehicle *pVehicle = dynamic_cast<C_BaseTFVehicle*>( pUseEntity ); + if ( pVehicle && InSameTeam(pVehicle) && !pVehicle->IsPlacing() && !pVehicle->IsBuilding() && pVehicle->GetMaxPassengerCount() >= 2 ) + { + pElement->ShowVehicleRole( pVehicle->LocateEntryPoint( this ) ); + } + } + } + } + + // Don't process items while in a vehicle. + if ( IsInAVehicle() ) + { + IClientVehicle *pVehicle = GetVehicle(); + Assert( pVehicle ); + + // NOTE: We *have* to do this before ItemPostFrame because ItemPostFrame + // may dump us out of the vehicle + int nRole = pVehicle->GetPassengerRole( this ); + bool bUsingStandardWeapons = pVehicle->IsPassengerUsingStandardWeapons( nRole ); + + pVehicle->ItemPostFrame( this ); + + // Fall through and check weapons, etc. if we're using them + if (!bUsingStandardWeapons || !IsInAVehicle()) + return; + } + + // If we're attaching a sapper, handle player use only + if ( m_TFLocal.m_bAttachingSapper ) + { + PlayerUse(); + return; + } + + BaseClass::ItemPostFrame(); + +#if 0 + if ( GetPlayerClass() ) + { + GetPlayerClass()->ItemPostFrame(); // Let the player class handle it. + } +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if I'm in a vehicle that's mounted on another vehicle +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsVehicleMounted() const +{ + CBaseTFVehicle *pVehicle = dynamic_cast< CBaseTFVehicle* >( GetMoveParent() ); + if ( pVehicle ) + return dynamic_cast< CBaseTFVehicle* >( pVehicle->GetMoveParent() ) != NULL; + + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::DrawModel( int flags ) +{ + int drawn = 0; + + if ( !m_bReadyToDraw ) + return 0; + + QAngle saveAngles(0,0,0); + Vector saveLocalOrigin(0,0,0); + bool angleschanged = false; + bool originchanged = false; + + // If we're in a vehicle, use the vehicle's angles for the local player + if ( IsInAVehicle() && !IsInAVehicle() ) + { + IClientVehicle *pVehicle = GetVehicle(); + int nRole = pVehicle->GetPassengerRole( this ); + if ( nRole == VEHICLE_ROLE_DRIVER ) + { + C_BaseTFVehicle *pVehicleEntity = (CBaseTFVehicle*)pVehicle->GetVehicleEnt(); + angleschanged = true; + SetLocalAngles( pVehicleEntity->GetPassengerAngles( saveAngles, VEHICLE_ROLE_DRIVER ) ); + + // HACK: Stomp the origin + originchanged = true; + SetLocalOrigin( vec3_origin ); + } + } + else + { + angleschanged = true; + SetLocalAngles( m_PlayerAnimState.GetRenderAngles() ); + } + + drawn = BaseClass::DrawModel(flags); + + if ( angleschanged ) + { + SetLocalAngles( saveAngles ); + } + if ( originchanged ) + { + SetLocalOrigin( saveLocalOrigin ); + } + + // Draw all personal shield effects. + FOR_EACH_LL( m_PersonalShieldEffects, i ) + { + m_PersonalShieldEffects[i]->Render(); + } + + return drawn; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::GetClass( void ) +{ + if ( !GetPlayerClass() ) + return TFCLASS_UNDECIDED; + + return m_iPlayerClass; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::OverrideView( CViewSetup *pSetup ) +{ + if ( CheckKnockdownAngleOverride() ) + { + float adj = GetKnockdownViewheightAdjust(); + + pSetup->origin.z -= adj; + + return; + } + + BaseClass::OverrideView( pSetup ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::ShouldDrawViewModel() +{ + if ( CheckKnockdownAngleOverride() ) + return false; + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Hack to search up the hierarchy looking for bones whose ultimate parent is 1 ( i.e., the pelvis ) since +// these are the lower body bones +//----------------------------------------------------------------------------- +bool ParentIsPelvis( mstudiobone_t *bones, int start, int pelvis, int spine ) +{ + int current = start; + + while ( bones[ current ].parent ) + { + // Root? + if ( bones[ current ].parent <= 0 ) + { + return false; + } + + if ( bones[ current ].parent == pelvis ) + return true; + + if ( bones[ current ].parent == spine ) + return false; + + current = bones[ current ].parent; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Hack to find the bone indices of the pelvis and the spine so we can +// more quickly determine if a bones parent is the pelvis so we can merge bones correctly +//----------------------------------------------------------------------------- +static void FindPelvisAndSpine( int numbones, mstudiobone_t *bones, int *pelvis, int *spine ) +{ + *pelvis = *spine = -1; + + mstudiobone_t *bone = bones; + for ( int i = 0; i < numbones; i++, bone++ ) + { + if ( !stricmp( bone->pszName(), "Bip01 Pelvis" ) ) + { + *pelvis = i; + } + else if ( !stricmp( bone->pszName(), "Bip01 Spine" ) ) + { + *spine = i; + } + + if ( *spine >= 0 && *pelvis >= 0 ) + break; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Another hack, the TFC 1.5 v. 2 models expect controllers at the midpoint +// Input : controllers[MAXSTUDIOBONECTRLS] - +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS]) +{ + // Set controllers to a their zero value. + for(int i=0; i < MAXSTUDIOBONECTRLS; i++) + { + controllers[i] = 0.5; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Get a text description for the object target +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::GetTargetDescription( char *pDest, int bufferSize ) +{ + const char *pStr = GetPlayerName(); + if ( pStr ) + { + Q_strncpy( pDest, pStr, bufferSize ); + } + else + { + pDest[0] = 0; + } +} + +//===================================================================================================== +// ORDERS +//===================================================================================================== + + +//----------------------------------------------------------------------------- +// Purpose: Player has received a new personal order +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetPersonalOrder( C_Order *pOrder ) +{ + // Do we have an order already? + RemoveOrderTarget(); + + m_hPersonalOrder = pOrder; + m_iPersonalTarget = pOrder->GetTarget(); + + // Add a new target to our list + if ( pOrder->ShouldDrawReticle() ) + { + int iTargetIndex = pOrder->GetTarget(); + if ( iTargetIndex ) + { + C_BaseEntity *pTarget = cl_entitylist->GetBaseEntity( iTargetIndex ); + if ( pTarget ) + { + char desc[512]; + pOrder->GetTargetDescription( desc, sizeof( desc ) ); + Add_Target( pTarget, desc ); + } + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Remove the target reticle for the specified order +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::RemoveOrderTarget() +{ + if ( m_iPersonalTarget ) + { + C_BaseEntity *pTarget = cl_entitylist->GetBaseEntity( m_iPersonalTarget ); + if ( pTarget ) + { + Remove_Target( pTarget ); + } + + m_iPersonalTarget = 0; + } +} + +//==================================================================================================== +// RESOURCES +//==================================================================================================== +// Purpose: +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::GetBankResources( void ) +{ + return m_TFLocal.m_iBankResources; +} + + +//==================================================================================================== +// OBJECTS +//==================================================================================================== +// Purpose: Player has selected an Object +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetSelectedObject( C_BaseObject *pObject ) +{ + // Do we have an order already? + if ( m_hSelectedObject ) + { + Remove_Target( m_hSelectedObject ); + + // If we selected our existing one, we just wanted to deselect + if ( pObject == m_hSelectedObject ) + { + m_hSelectedObject = NULL; + return; + } + } + + m_hSelectedObject = pObject; + + // Add a new target to our list + if ( pObject ) + { + Add_Target( pObject, pObject->GetTargetDescription() ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Get the currently selected object +//----------------------------------------------------------------------------- +C_BaseObject *C_BaseTFPlayer::GetSelectedObject( void ) +{ + return m_hSelectedObject; +} + +//==================================================================================================== +// TARGET RETICLES +//==================================================================================================== +// Purpose: Add a new entity to the list of targets +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::Add_Target( C_BaseEntity *pTarget, const char *sName ) +{ + CTargetReticle *pTargetReticle = new CTargetReticle(); + pTargetReticle->Init( pTarget, sName ); + + m_aTargetReticles.AddToTail( pTargetReticle ); +} + +//----------------------------------------------------------------------------- +// Purpose: Remove an entity from the list of targets +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::Remove_Target( C_BaseEntity *pTarget ) +{ + for (int i = 0; i < m_aTargetReticles.Size(); i++ ) + { + CTargetReticle *pTargetReticle = m_aTargetReticles[i]; + if ( pTargetReticle->GetTarget() == pTarget ) + { + Remove_Target( pTargetReticle ); + return; + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Remove a specific reticle from our list +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::Remove_Target( CTargetReticle *pTargetReticle ) +{ + m_aTargetReticles.FindAndRemove( pTargetReticle ); + delete pTargetReticle; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsUsingThermalVision( void ) const +{ + return m_TFLocal.m_bThermalVision; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::GetIDTarget( void ) const +{ + return m_iIDEntIndex; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsKnockedDown( void ) const +{ + return m_TFLocal.m_bKnockedDown; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : ang - +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetKnockdownAngles( const QAngle& ang ) +{ + m_bKnockdownOverrideAngles = true; + QAngle fixedAngles = ang; + NormalizeAngles( fixedAngles ); + m_vecCurrentKnockdownAngles = fixedAngles; + engine->SetViewAngles( fixedAngles ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : outAngles - +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::GetKnockdownAngles( QAngle& outAngles ) +{ + outAngles = m_vecCurrentKnockdownAngles; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::CheckKnockdownState( void ) +{ + m_bKnockdownOverrideAngles = false; + + if ( m_flStartKnockdown == 0.0f && + m_flEndKnockdown == 0.0f && + !IsKnockedDown() ) + { + m_flKnockdownViewheightAdjust = 0.0f; + return; + } + + float frac = 0.0f; + float dt; + if ( IsKnockedDown() ) + { + if ( m_flStartKnockdown != 0.0f ) + { + + dt = gpGlobals->curtime - m_flStartKnockdown; + if ( dt >= 0.0f && dt < KNOCKDOWN_BLEND_IN ) + { + frac = ( dt / KNOCKDOWN_BLEND_IN ); + frac = MAX( 0.0f, frac ); + frac = MIN( 1.0f, frac ); + } + else if ( dt >= KNOCKDOWN_BLEND_IN) + { + m_flStartKnockdown = 0.0f; + frac = 1.0f; + } + } + else + { + frac = 1.0f; + } + } + else + { + if ( m_flEndKnockdown != 0.0f ) + { + frac = 0.0f; + dt = gpGlobals->curtime - m_flEndKnockdown; + if ( dt >= 0 && dt < KNOCKDOWN_BLEND_OUT ) + { + frac = ( dt / KNOCKDOWN_BLEND_OUT ); + frac = 1.0f - frac; + } + else if ( dt >= KNOCKDOWN_BLEND_OUT ) + { + m_flEndKnockdown = 0.0f; + } + else + { + frac = 1.0f; + } + } + } + + if ( frac == 0.0f ) + { + SetKnockdownAngles( m_vecOriginalViewAngles ); + } + else if ( frac == 1.0f ) + { + SetKnockdownAngles( m_vecKnockDownGoalAngles ); + } + else + { + QAngle current; + InterpolateAngles( m_vecOriginalViewAngles, m_vecKnockDownGoalAngles, current, frac ); + SetKnockdownAngles( current ); + } + + Vector eyeZOffset; + VectorSubtract( EyePosition(), GetAbsOrigin(), eyeZOffset ); + float zsize = eyeZOffset.z; + + m_flKnockdownViewheightAdjust = frac * ( zsize - 12 ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::CheckKnockdownAngleOverride( void ) const +{ + return m_bKnockdownOverrideAngles; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : float +//----------------------------------------------------------------------------- +float C_BaseTFPlayer::GetKnockdownViewheightAdjust( void ) const +{ + return m_flKnockdownViewheightAdjust; +} + + +//----------------------------------------------------------------------------- +// Purpose: Player has changed to a new team +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::TeamChange( int iNewTeam ) +{ + BaseClass::TeamChange( iNewTeam ); + + // Did we change team? or did we just join our first team? + if ( iNewTeam != GetTeamNumber() ) + { + // Tell the tech tree to reload itself + GetTechnologyTreeDoc().ReloadTechTree(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: // Override so infiltrator's disguised as other team will work +// Output : int +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::GetRenderTeamNumber( void ) +{ + return GetTeamNumber(); +} + + +// 50 % per second +#define CAMO_DAMPENING_CHANGERATE 300.0f +#define CAMO_MOVESUPPRESSION_CHANGERATE 100.0f +#define CAMO_DAMPENINGVELOCITY_CUTOFF 50.0f +#define CAMO_DAMPENINGVELOCITY_MAX 400.0f +#define CAMO_DAMPENINGAVEL_CUTOFF 1.0f +#define CAMO_DAMPENINGAVEL_MAX 5.0f +#define CAMO_STAYOUT_TIME 1.0f +#define CAMO_MOVEMENT_PENALTYTIME 1.0f + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsCamouflaged( void ) +{ + return ( m_flCamouflageAmount > 0.0f ) ? true : false; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : float +//----------------------------------------------------------------------------- +float C_BaseTFPlayer::GetCamouflageAmount( void ) +{ + return m_flCamouflageAmount; +} + +//----------------------------------------------------------------------------- +// Purpose: 0 to 1, where 1 means hardly visible and 0 means pretty noticeable +// Output : float +//----------------------------------------------------------------------------- + +#define DISTANCE_CAMO_EFFECT_AMOUNT 0.1f +#define LOCAL_MOTION_CAMO_EFFECT_AMOUNT 0.3f +#define MOVEMENT_CAMO_EFFECT_AMOUNT 0.2f + +float C_BaseTFPlayer::ComputeCamoEffectAmount( void ) +{ + if ( !IsCamouflaged() ) + return 1.0f; + + // Start with the amount from the server.... + float effect_amount = m_flCamouflageAmount / 100.0f; + + // If this player has moved recently, camo will not be as effective for him + effect_amount -= MOVEMENT_CAMO_EFFECT_AMOUNT * GetMovementCamoSuppression() / 100.0f; + if (effect_amount < 0) + effect_amount = 0; + + // Determine distance to render origin + Vector delta = GetAbsOrigin() - CurrentViewOrigin(); + float distance = delta.Length(); + + // At the max distance, make it n% less likely to see the camoed dude... + // At min distance, we're no less likely to see the dude + if ( distance >= CAMO_INNER_RADIUS ) + effect_amount *= 1 + DISTANCE_CAMO_EFFECT_AMOUNT; + else + { + float frac = distance / CAMO_INNER_RADIUS; + effect_amount *= 1 - frac + (1 + DISTANCE_CAMO_EFFECT_AMOUNT) * frac; + } + + // Local viewer movements make it n% less likely to see the camoed dude... + // No movement means we're no less likely to see the dude + // Dampening is based on the local viewer's movements + float dampening = 0.0f; + C_BaseTFPlayer *local = GetLocalPlayer(); + if ( local ) + { + dampening = local->GetDampeningAmount() / 100.0f; + } + + // Now apply suppression (i.e., less visible) based on camera and viewer movement + effect_amount *= 1 + LOCAL_MOTION_CAMO_EFFECT_AMOUNT * dampening; + + // Clamp to valid range + effect_amount = MAX( 0.0f, effect_amount ); + effect_amount = MIN( 0.99f, effect_amount ); + + return effect_amount; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : int +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::ComputeCamoAlpha( void ) +{ + Assert( IsCamouflaged() ); + + // Determine distance to render origin + Vector delta = GetAbsOrigin() - CurrentViewOrigin(); + float distance = delta.Length(); + + int baseline = 0; + + // Too far, just blend out completely + if ( distance >= CAMO_OUTER_RADIUS ) + { + baseline = 0; + } + else if ( distance >= CAMO_INNER_RADIUS ) + { + float frac = ( distance - CAMO_INNER_RADIUS ) / ( CAMO_OUTER_RADIUS - CAMO_INNER_RADIUS ); + frac = 1 - frac; + baseline = (int)( (float)( 255 - CAMO_INNER_ALPHA ) * frac ); + } + else if ( distance >= CAMO_INVIS_RADIUS ) + { + // We'll also render with the special effect + float frac = ( distance - CAMO_INVIS_RADIUS ) / ( CAMO_INNER_RADIUS - CAMO_INVIS_RADIUS ); + baseline = (int)( (float)( CAMO_INNER_ALPHA ) * frac ); + } + else + { + // NOTE: return 1 or else the renderer will skip drawing and we won't be + // able to draw the up close effect + baseline = 1; + } + + // Suppress everything based on server ramp + return baseline + (int)( (float)( 255 - baseline ) * ( m_flCamouflageAmount / 100.0f ) ); + +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : int +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::ComputeFxBlend( void ) +{ + if ( !IsCamouflaged() ) + { + BaseClass::ComputeFxBlend(); + return; + } + + m_nRenderFXBlend = ComputeCamoAlpha(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsTransparent( void ) +{ + if ( IsCamouflaged() ) + { + return true; + } + + return BaseClass::IsTransparent(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::ViewModel_IsTransparent( void ) +{ + if ( IsCamouflaged() ) + { + return true; + } + + return BaseClass::ViewModel_IsTransparent(); +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if the player's viewmodel should match the player's model data +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsOverridingViewmodel( void ) +{ + // Don't override medic weapons since we have effects for them + if ( PlayerClass() == TFCLASS_MEDIC ) + return BaseClass::IsOverridingViewmodel(); + + if ( IsDamageBoosted() || IsCamouflaged() || HasPowerup(POWERUP_EMP) ) + return true; + + return BaseClass::IsOverridingViewmodel(); +} + +//----------------------------------------------------------------------------- +// Purpose: Draw my viewmodel in some special way +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::DrawOverriddenViewmodel( C_BaseViewModel *pViewmodel, int flags ) +{ + int ret = 0; + + if ( IsCamouflaged() && ( ComputeCamoEffectAmount() != 1.0f ) ) + { + if ( GetCamoMaterial() ) + { + modelrender->ForcedMaterialOverride( GetCamoMaterial() ); + ret = pViewmodel->DrawOverriddenViewmodel( flags ); + modelrender->ForcedMaterialOverride( NULL ); + } + } + + if ( IsDamageBoosted() || HasPowerup(POWERUP_EMP) ) + { + + // First draw the model once normally. + pViewmodel->DrawOverriddenViewmodel( flags ); + + // NOTE: for the demo we do a different "BOOST" effect. What do we want to do here? + if ( !inv_demo.GetInt() ) + { + if ( IsDamageBoosted() && + pViewmodel->ViewModelIndex() != 0 ) + { + return ret; + } + + // Now overlay some shimmering ones. + render->SetBlend( 0.3 ); + + if ( IsDamageBoosted() ) + { + // Radeon 9700 having a problem with this guy: + modelrender->ForcedMaterialOverride( m_BoostMaterial ); + } + else + { + modelrender->ForcedMaterialOverride( m_EMPMaterial ); + } + + Vector vStart = pViewmodel->GetAbsOrigin(); + + float flOffset = damageboost_modeloffset.GetFloat(); + for ( int i=0; i < 3; i++ ) + { + // Place the model at a slight offset. + vStart[i] += flOffset * sin( m_BoostModelAngles[i] ); + pViewmodel->SetLocalOrigin( vStart ); + m_BoostModelAngles[i] += RandomFloat( damageboost_modelphasespeed_min.GetFloat(), damageboost_modelphasespeed_max.GetFloat() ) * gpGlobals->frametime; + + // Invalidate the bones because they've been setup with our original position and cached, + // and we want to render it in a new spot with different bone transforms. + pViewmodel->InvalidateBoneCache(); + ret = pViewmodel->DrawOverriddenViewmodel( flags ); + } + + // Reset the position and bone info. + pViewmodel->SetLocalOrigin( vStart ); + pViewmodel->InvalidateBoneCache(); + + modelrender->ForcedMaterialOverride( NULL ); + render->SetBlend( 1 ); + } + } + + return ret; +} + +//----------------------------------------------------------------------------- +// Purpose: Players under adrenalin animate faster +//----------------------------------------------------------------------------- +float C_BaseTFPlayer::GetDefaultAnimSpeed( void ) +{ + if ( HasPowerup( POWERUP_RUSH ) ) + return ADRENALIN_ANIM_SPEED; + + // Weapons may modify animation times + if ( GetActiveWeapon() ) + return GetActiveWeapon()->GetDefaultAnimSpeed(); + + return 1.0; +} + +//----------------------------------------------------------------------------- +// Purpose: This is used to penalize the local viewer for moving around or rotating +// the camera, it causes camo'd guys who are close to fade out their "white" effect +// for a bit of time +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::CheckCameraMovement( void ) +{ + float dt = gpGlobals->frametime; + + float vel = GetAbsVelocity().Length(); + float avel = fabs( GetLocalAngles().y - GetPrevLocalAngles().y ); + if ( dt > 0.0f ) + { + avel *= 1.0f / dt; + } + + float frac1 = 0.0f; + if ( vel > CAMO_DAMPENINGVELOCITY_CUTOFF ) + { + frac1 = ( vel - CAMO_DAMPENINGVELOCITY_CUTOFF ) / ( CAMO_DAMPENINGVELOCITY_MAX - CAMO_DAMPENINGVELOCITY_CUTOFF ); + frac1 = MIN( 0.0f, frac1 ); + frac1 = MAX( 1.0f, frac1 ); + + frac1 *= 50.0f; + + m_flDampeningStayoutTime = gpGlobals->curtime + CAMO_STAYOUT_TIME; + + } + + float frac2 = 0.0f; + if ( avel > CAMO_DAMPENINGAVEL_CUTOFF ) + { + frac2 = ( avel - CAMO_DAMPENINGAVEL_CUTOFF ) / ( CAMO_DAMPENINGAVEL_MAX - CAMO_DAMPENINGAVEL_CUTOFF ); + frac2 = MIN( 0.0f, frac2 ); + frac2 = MAX( 1.0f, frac2 ); + + frac2 *= 50.0f; + + m_flDampeningStayoutTime = gpGlobals->curtime + CAMO_STAYOUT_TIME; + + } + + // Pick the greater + float amount = MAX( frac1, frac2 ); + + SetCamoDampening( amount ); +} + +//----------------------------------------------------------------------------- +// Purpose: Decay suppression camo amount +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::CheckCamoDampening( void ) +{ + CheckCameraMovement(); + + if ( m_flGoalDampeningAmount == m_flDampeningAmount ) + return; + + // Camouflage + float dt = gpGlobals->frametime; + float changeamount = ( dt * CAMO_DAMPENING_CHANGERATE ); + + // Move but don't overshoot + if ( m_flGoalDampeningAmount > m_flDampeningAmount ) + { + m_flDampeningAmount += changeamount; + m_flDampeningAmount = MIN( m_flDampeningAmount, m_flGoalDampeningAmount ); + } + else + { + if ( gpGlobals->curtime < m_flDampeningStayoutTime ) + return; + + m_flDampeningAmount -= changeamount; + m_flDampeningAmount = MAX( m_flDampeningAmount, m_flGoalDampeningAmount ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Force amount, decay happens in CheckCamoDampening +// Input : amount - +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetCamoDampening( float amount ) +{ + m_flGoalDampeningAmount = amount; +} + +//----------------------------------------------------------------------------- +// Purpose: For camera movement by local player +// Output : float +//----------------------------------------------------------------------------- +float C_BaseTFPlayer::GetDampeningAmount( void ) +{ + return m_flDampeningAmount; +} + +//----------------------------------------------------------------------------- +// Purpose: This is used so that if you are watching a camo'd guy who is moving +// he becomes more visible for a bit of time, before fading back out. +// Input : amount - +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetMovementCamoSuppression( float amount ) +{ + m_flGoalMovementCamoSuppressionAmount = amount; +} + +//----------------------------------------------------------------------------- +// Purpose: This is used so that if you are watching a camo'd guy who is moving +// he becomes more visible for a bit of time, before fading back out. +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::CheckMovementCamoSuppression( void ) +{ + // FIXME: Don't bother with suppression during deployment... + if ( m_bDeployed ) + { + m_flMovementCamoSuppression = 0; + return; + } + + float flSuppression = 0; + + // Rotation blends them in a bit too + float avel = fabs( GetLocalAngles().y - GetPrevLocalAngles().y ) + fabs( GetLocalAngles().x - GetPrevLocalAngles().x ); + if ( avel > CAMO_DAMPENINGAVEL_CUTOFF ) + { + float frac2 = ( avel - CAMO_DAMPENINGAVEL_CUTOFF ) / ( CAMO_DAMPENINGAVEL_MAX - CAMO_DAMPENINGAVEL_CUTOFF ); + frac2 = MIN( 0.0f, frac2 ); + frac2 = MAX( 1.0f, frac2 ); + flSuppression = 50.0f * frac2; + } + + // Add in velocity blend + float vel = GetAbsVelocity().Length(); + if ( vel > CAMO_DAMPENINGVELOCITY_CUTOFF ) + { + float frac = ( vel- CAMO_DAMPENINGVELOCITY_CUTOFF ) / ( CAMO_DAMPENINGVELOCITY_MAX - CAMO_DAMPENINGVELOCITY_CUTOFF ); + frac = MIN( 1.0f, frac ); + flSuppression = MIN( 100.f, flSuppression + (100.0f * frac) ); + } + + // Set the camo aount + SetMovementCamoSuppression( flSuppression ); + if ( flSuppression ) + { + m_flMovementCamoSuppressionStayoutTime = gpGlobals->curtime + CAMO_MOVEMENT_PENALTYTIME; + } + + if ( m_flGoalMovementCamoSuppressionAmount == m_flMovementCamoSuppression ) + return; + + // Camouflage + float dt = gpGlobals->frametime; + float changeamount = ( dt * CAMO_MOVESUPPRESSION_CHANGERATE ); + + // Move but don't overshoot + if ( m_flGoalMovementCamoSuppressionAmount > m_flMovementCamoSuppression ) + { + m_flMovementCamoSuppression += changeamount; + m_flMovementCamoSuppression = MIN( m_flMovementCamoSuppression, m_flGoalMovementCamoSuppressionAmount ); + } + else + { + if ( gpGlobals->curtime < m_flMovementCamoSuppressionStayoutTime ) + return; + + m_flMovementCamoSuppression -= changeamount; + m_flMovementCamoSuppression = MAX( m_flMovementCamoSuppression, m_flGoalMovementCamoSuppressionAmount ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Get the material used for this player's camo +//----------------------------------------------------------------------------- +IMaterial *C_BaseTFPlayer::GetCamoMaterial( void ) +{ + if ( !m_pCamoEffectMaterial ) + { + m_pCamoEffectMaterial = materials->FindMaterial("player/infiltratorcamo/infiltratorcamo", TEXTURE_GROUP_CLIENT_EFFECTS); + if ( m_pCamoEffectMaterial ) + { + m_pCamoEffectMaterial->IncrementReferenceCount(); + } + } + + return m_pCamoEffectMaterial; +} + +//----------------------------------------------------------------------------- +// Purpose: Percentage suppression of camo effect up close based on velocity +// Output : float +//----------------------------------------------------------------------------- +float C_BaseTFPlayer::GetMovementCamoSuppression( void ) +{ + return m_flMovementCamoSuppression; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::CheckLastMovement( void ) +{ + if ( GetAbsOrigin() != m_vecLastOrigin ) + { + m_vecLastOrigin = GetAbsOrigin(); + m_flLastMoveTime = gpGlobals->curtime; + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : float +//----------------------------------------------------------------------------- +float C_BaseTFPlayer::GetLastMoveTime( void ) +{ + return m_flLastMoveTime; +} + +float C_BaseTFPlayer::GetLastDamageTime( void ) const +{ + return m_flLastDamageTime; +} + +float C_BaseTFPlayer::GetLastGainHealthTime( void ) const +{ + return m_flLastGainHealthTime; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Output : float +//----------------------------------------------------------------------------- +float C_BaseTFPlayer::GetOverlayAlpha( void ) +{ + float alpha = 1.0f; + + C_BaseTFPlayer *local = GetLocalPlayer(); + if ( local && local != this ) + { + if ( local && GetTeamNumber() != local->GetTeamNumber() ) + { + if ( IsCamouflaged() ) + { + float frac = ( GetCamouflageAmount() / 100.0f ); + alpha *= ( 1.0f - frac ); + } + + // Only applies to sniper right now + if ( m_iPlayerClass == TFCLASS_SNIPER ) + { + float dt = gpGlobals->curtime - GetLastMoveTime(); + if ( dt > SNIPER_STATIONARY_FADESTART ) + { + if ( dt > SNIPER_STATIONARY_FADEFINISH ) + { + alpha = 0.0; + } + else + { + float frac = ( dt - SNIPER_STATIONARY_FADESTART ) / ( SNIPER_STATIONARY_FADEFINISH - SNIPER_STATIONARY_FADESTART ); + alpha *= ( 1.0f - frac ); + } + } + } + } + } + + alpha = MIN( 1.0f, alpha ); + alpha = MAX( 0.0f, alpha ); + + return alpha; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsDeployed( void ) +{ + return m_bDeployed; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsDeploying( void ) +{ + return m_bDeploying; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsUnDeploying( void ) +{ + return m_bUnDeploying; +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if the player's allowed to switch weapons in his current state +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsAllowedToSwitchWeapons( void ) +{ + // Can't switch while deployed + if ( IsDeployed() || IsDeploying() || IsUnDeploying() ) + return false; + + if ( IsInAVehicle() && GetVehicle() ) + { + IClientVehicle *pVehicle = GetVehicle(); + int nRole = pVehicle->GetPassengerRole( this ); + if (!pVehicle->IsPassengerUsingStandardWeapons(nRole)) + { + return false; + } + } + + // See if the weapon will allow us to switch + if ( GetActiveWeapon() && GetActiveWeapon()->IsAllowedToSwitch() == false ) + return false; + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Get the number of objects of the specified type that this player has +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::GetNumObjects( int iObjectType ) +{ + int iCount = 0; + for (int i = 0; i < GetObjectCount(); i++) + { + if ( !GetObject(i) ) + continue; + + if ( GetObject(i)->GetType() == iObjectType ) + { + iCount++; + } + } + + return iCount; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int C_BaseTFPlayer::GetObjectCount( void ) +{ + return m_TFLocal.m_aObjects.Count(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +C_BaseObject *C_BaseTFPlayer::GetObject( int index ) +{ + return m_TFLocal.m_aObjects[index].Get(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::AddEntity( void ) +{ + BaseClass::AddEntity(); + + // Zero out model pitch, blending takes care of all of it. + SetLocalAnglesDim( X_INDEX, 0 ); + + m_PlayerAnimState.Update(); +} + +//----------------------------------------------------------------------------- +// Purpose: See if it's time to start another adrenalin effect +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::CheckAdrenalin( void ) +{ + if ( m_flNextAdrenalinEffect && gpGlobals->curtime > m_flNextAdrenalinEffect ) + { + ScreenFade_t sf; + memset( &sf, 0, sizeof( sf ) ); + sf.a = 128; + sf.r = 0; + sf.g = 128; + sf.b = 0; + // One second + sf.duration = (unsigned short)((float)(1<<SCREENFADE_FRACBITS) * 1.0f ); + if ( m_bFadingIn ) + { + sf.fadeFlags = FFADE_IN; + } + else + { + sf.fadeFlags = FFADE_OUT; + } + vieweffects->Fade( sf ); + + m_bFadingIn = !m_bFadingIn; + m_flNextAdrenalinEffect = gpGlobals->curtime + 1.0; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Update this client's target entity +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::UpdateIDTarget( void ) +{ + if ( !IsLocalPlayer() ) + return; + + // If the server's forcing us to a specific ID target, use it instead + if ( m_TFLocal.m_iIDEntIndex ) + { + m_iIDEntIndex = m_TFLocal.m_iIDEntIndex; + return; + } + + // Clear old target and find a new one + m_iIDEntIndex = 0; + + trace_t tr; + Vector vecStart, vecEnd; + VectorMA( MainViewOrigin(), 1500, MainViewForward(), vecEnd ); + VectorMA( MainViewOrigin(), 48, MainViewForward(), vecStart ); + UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr ); + if ( tr.DidHitNonWorldEntity() ) + { + C_BaseEntity *pEntity = tr.m_pEnt; + IClientVehicle *vehicle = GetVehicle(); + C_BaseEntity *pVehicleEntity = vehicle ? vehicle->GetVehicleEnt() : NULL; + + if ( pEntity && (pEntity != this) && (pEntity != pVehicleEntity) ) + { + // Make sure it's not an object + if ( !dynamic_cast<C_BaseObject*>( pEntity ) ) + { + m_iIDEntIndex = pEntity->entindex(); + } + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Return the weapon to have open the weapon selection on, based upon our currently active weapon +// If the currently active weapon is a two handed weapon, returns it's primary weapon. +//----------------------------------------------------------------------------- +C_BaseCombatWeapon *C_BaseTFPlayer::GetActiveWeaponForSelection( void ) +{ + C_WeaponTwoHandedContainer *pTwoHandedWeapon = dynamic_cast<C_WeaponTwoHandedContainer*>( GetActiveWeapon() ); + if ( pTwoHandedWeapon ) + return pTwoHandedWeapon->m_hLeftWeapon; + + return BaseClass::GetActiveWeaponForSelection(); +} + +//----------------------------------------------------------------------------- +// HACK: Until we get a recon model, trail recon particles +//----------------------------------------------------------------------------- +void FX_ReconParticle( const Vector &vecOrigin, bool bBlue ) +{ + CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "reconparticle" ); + pSimple->SetSortOrigin( vecOrigin ); + pSimple->SetNearClip( 32, 64 ); + + SimpleParticle *pParticle; + + Vector offset; + + for ( int i = 0; i < 1; i++ ) + { + pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[0], vecOrigin ); + + if ( pParticle != NULL ) + { + pParticle->m_flLifetime = 0.0f; + pParticle->m_flDieTime = random->RandomFloat( 1.0f, 1.5f ); + + pParticle->m_vecVelocity = vec3_origin; + + int color = random->RandomInt( 128, 192 ); + + if ( bBlue ) + { + pParticle->m_uchColor[0] = color; + pParticle->m_uchColor[1] = color; + pParticle->m_uchColor[2] = 255; + } + else + { + pParticle->m_uchColor[0] = 255; + pParticle->m_uchColor[1] = color; + pParticle->m_uchColor[2] = color; + } + pParticle->m_uchStartAlpha = random->RandomInt( 192, 255 ); + pParticle->m_uchEndAlpha = 0; + pParticle->m_uchStartSize = random->RandomInt( 12, 16 ); + pParticle->m_uchEndSize = 0; + pParticle->m_flRoll = random->RandomInt( 0, 360 ); + pParticle->m_flRollDelta = random->RandomFloat( -1.0f, 1.0f ); + } + } +} + +// Prediction stuff +void C_BaseTFPlayer::PreThink( void ) +{ + BaseClass::PreThink(); + + // Chain pre-think to player class. + if ( GetPlayerClass() ) + { + GetPlayerClass()->PreClassThink(); + } +} + +void C_BaseTFPlayer::PostThink( void ) +{ + BaseClass::PostThink(); + + // Chain post-think to player class. + if ( GetPlayerClass() ) + { + GetPlayerClass()->PostClassThink(); + } +} + +C_PlayerClass *C_BaseTFPlayer::GetPlayerClass( void ) +{ + return m_PlayerClasses.GetPlayerClass( PlayerClass() ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetVehicleRole( int nRole ) +{ + if ( IsInAVehicle() ) + { + C_BaseTFVehicle *pVehicle = ( C_BaseTFVehicle* )GetVehicle(); + if ( pVehicle ) + { + if ( nRole >= pVehicle->GetMaxPassengerCount() ) + return; + } + } + + char szCmd[64]; + Q_snprintf( szCmd, sizeof( szCmd ), "vehicleRole %i\n", nRole ); + engine->ServerCmd( szCmd ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::CanGetInVehicle( void ) +{ + if ( GetPlayerClass() ) + { + return GetPlayerClass()->CanGetInVehicle(); + } + + return true; +} + + +// How fast to avoid collisions with center of other object, in units per second +#define AVOID_SPEED 1000.0f +extern ConVar cl_forwardspeed; +extern ConVar cl_backspeed; +extern ConVar cl_sidespeed; + +static ConVar tf2_solidplayers( "tf2_solidplayers", "1", 0, "Treat players and objects as solid." ); + +//----------------------------------------------------------------------------- +// Client-side obstacle avoidance +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::PerformClientSideObstacleAvoidance( float flFrameTime, CUserCmd *pCmd ) +{ + if ( !tf2_solidplayers.GetBool() ) + { + return; + } + + // Don't avoid if noclipping or in movetype none + switch ( GetMoveType() ) + { + case MOVETYPE_NOCLIP: + case MOVETYPE_NONE: + return; + default: + break; + } + + // Try to steer away from any objects/players we might interpenetrate + Vector size = WorldAlignSize(); + + float radius = 0.5f * sqrt( size.x * size.x + size.y * size.y ); + float curspeed = GetAbsVelocity().Length2D(); + + // int slot = 1; + + //engine->Con_NPrintf( slot++, "speed %f\n", curspeed ); + //engine->Con_NPrintf( slot++, "radius %f\n", radius ); + + // If running, use a larger radius + if ( curspeed > 100.0f ) + { + float factor = ( 1.0f + ( curspeed - 100.0f ) / 100.0f ); + + // engine->Con_NPrintf( slot++, "scaleup (%f) to radius %f\n", factor, radius * factor ); + + radius = radius * factor; + } + + CPlayerAndObjectEnumerator avoid( radius ); + partition->EnumerateElementsInSphere( PARTITION_CLIENT_SOLID_EDICTS, GetAbsOrigin(), radius, false, &avoid ); + + // Okay, decide how to avoid if there's anything close by + int c = avoid.GetObjectCount(); + if ( c <= 0 ) + return; + + Vector currentdir; + Vector rightdir; + AngleVectors( pCmd->viewangles, ¤tdir, &rightdir, NULL ); + + bool istryingtomove = false; + bool ismovingforward = false; + if ( fabs( pCmd->forwardmove ) > 0.0f || + fabs( pCmd->sidemove ) > 0.0f ) + { + istryingtomove = true; + if ( pCmd->forwardmove > 1.0f ) + { + ismovingforward = true; + } + } + + //engine->Con_NPrintf( slot++, "moving %s forward %s\n", istryingtomove ? "true" : "false", ismovingforward ? "true" : "false" ); + + float adjustforwardmove = 0.0f; + float adjustsidemove = 0.0f; + + int i; + for ( i = 0; i < c; i++ ) + { + C_BaseEntity *obj = avoid.GetObject( i ); + if( !obj ) + continue; + + float flHit1, flHit2; + + // Figure out a 2D radius for the object + Vector vecWorldMins, vecWorldMaxs; + obj->CollisionProp()->WorldSpaceAABB( &vecWorldMins, &vecWorldMaxs ); + Vector objSize = vecWorldMaxs - vecWorldMins; + + float objectradius = /*0.5f **/ 1.0 * sqrt( objSize.x * objSize.x + objSize.y * objSize.y ); + + if ( !IntersectInfiniteRayWithSphere( + GetAbsOrigin(), + currentdir, + obj->GetAbsOrigin(), + objectradius, + &flHit1, + &flHit2 ) ) + continue; + + float force = 0.0f; + + float forward = 0.0f, side = 0.0f; + + Vector vecToObject = obj->GetAbsOrigin() - GetAbsOrigin(); + Vector cross = vecToObject.Cross( currentdir ); + + //engine->Con_NPrintf( slot++, "object side %s\n", sign > 0.0f ? "right" : "left" ); + + if ( 0 && istryingtomove ) + { +/* + // Okay, line hits sphere in two points + // Determine how close line is to center of sphere and move sideways to avoid if we are + // actually trying to move forward + Vector deltaHit = vHit2 - vHit1; + float leg1 = ( deltaHit.Length() ) / 2.0f; + + float distfromcenter = sqrt( leg1 * leg1 + objectradius * objectradius ); + + force = distfromcenter / radius; + force = clamp( force, 0.0f, 1.0f ); + force = 1.0f - force; + + if ( force <= 0.5f ) + continue; + + side = force * AVOID_SPEED; + + // Move to right or left of object + side *= sign; +*/ + } + else + { + Vector deltaObject = vecToObject; + float dist = deltaObject.Length2D(); + + force = dist / radius; + force = clamp( force, 0.0f, 1.0f ); + force = 1.0f - force; + + //engine->Con_NPrintf( slot++, "dist %f/radius %f == %f\n", dist, radius, force ); + + if ( force <= 0.3f ) + continue; + + force = sqrt( force ); + + //engine->Con_NPrintf( slot++, "sqrt(force) == %f\n", force ); + + Vector moveDir = -vecToObject; + VectorNormalize( moveDir ); + + float fwd = currentdir.Dot( moveDir ); + float rt = rightdir.Dot( moveDir ); + + //engine->Con_NPrintf( slot++, "fwd %f right %f\n", fwd, rt ); + + float sidescale = 2.0f; + float forwardscale = 1.0f; + + if ( istryingtomove ) + { + // If running, then do a lot more sideways veer since we're not going to do anything to + // forward velocity + sidescale = 4.0f; + forwardscale = 2.0f; + } + + forward = forwardscale * fwd * force * AVOID_SPEED; + side = sidescale * rt * force * AVOID_SPEED; + + //engine->Con_NPrintf( slot++, "forward %f side %f\n", forward, side ); + } + + adjustforwardmove += forward; + adjustsidemove += side; + } + + pCmd->forwardmove += adjustforwardmove; + pCmd->sidemove += adjustsidemove; + + if ( pCmd->forwardmove > 0.0f ) + { + pCmd->forwardmove = clamp( pCmd->forwardmove, -cl_forwardspeed.GetFloat(), cl_forwardspeed.GetFloat() ); + } + else + { + pCmd->forwardmove = clamp( pCmd->forwardmove, -cl_backspeed.GetFloat(), cl_backspeed.GetFloat() ); + } + pCmd->sidemove = clamp( pCmd->sidemove, -cl_sidespeed.GetFloat(), cl_sidespeed.GetFloat() ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Input handling +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::CreateMove( float flInputSampleTime, CUserCmd *pCmd ) +{ + BaseClass::CreateMove( flInputSampleTime, pCmd ); + + // If the frozen flag is set, prevent view movement (server prevents the rest of the movement) + if ( GetFlags() & FL_FROZEN ) + { + return; + } + + if (!IsInVGuiInputMode() && !IsInAVehicle()) + { + PerformClientSideObstacleAvoidance( TICK_INTERVAL, pCmd ); + } +} + + +C_BaseAnimating* C_BaseTFPlayer::GetRenderedWeaponModel() +{ + // Attach to either their weapon model or their view model. + if ( C_BasePlayer::ShouldDrawLocalPlayer() || !IsLocalPlayer() ) + { + // Hook it to their external weapon model. + C_BaseCombatWeapon *pWeapon = GetActiveWeapon(); + if ( !pWeapon ) + return NULL; + + // If this a two-handed container (shield + weapon), return the left weapon. + C_WeaponTwoHandedContainer *pContainer = dynamic_cast< C_WeaponTwoHandedContainer* >( pWeapon ); + if ( pContainer ) + { + return pContainer->GetLeftWeapon(); + } + else + { + return pWeapon; + } + } + else + { + return GetViewModel(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::SetIDEnt( C_BaseEntity *pEntity ) +{ + if ( pEntity ) + m_TFLocal.m_iIDEntIndex = pEntity->entindex(); + else + m_TFLocal.m_iIDEntIndex = 0; +} + + +C_VehicleTeleportStation* C_BaseTFPlayer::GetSelectedMCV() const +{ + return dynamic_cast< C_VehicleTeleportStation* >( m_hSelectedMCV.Get() ); +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if this object can be +used by the player +//----------------------------------------------------------------------------- +bool C_BaseTFPlayer::IsUseableEntity( CBaseEntity *pEntity ) +{ + // I can use vehicles + return dynamic_cast<C_BaseTFVehicle*>( pEntity ); +} + +//----------------------------------------------------------------------------- +// Purpose: Powerup has just started +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::PowerupStart( int iPowerup, bool bInitial ) +{ + Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS ); + + switch( iPowerup ) + { + case POWERUP_RUSH: + { + // Play the rage start + if ( bInitial ) + { + EmitSound( "BaseTFPlayer.Rage" ); + } + + // Start the looping breathing + CPASAttenuationFilter filter( this, "BaseTFPlayer.HeavyBreathing" ); + EmitSound( filter, entindex(), "BaseTFPlayer.HeavyBreathing" ); + + if ( IsLocalPlayer() ) + { + // Start the visual effects + if ( !m_flNextAdrenalinEffect ) + { + m_flNextAdrenalinEffect = gpGlobals->curtime; + m_bFadingIn = false; + } + } + } + break; + + default: + break; + } + + BaseClass::PowerupStart( iPowerup, bInitial ); +} + +//----------------------------------------------------------------------------- +// Purpose: Powerup has just finished +//----------------------------------------------------------------------------- +void C_BaseTFPlayer::PowerupEnd( int iPowerup ) +{ + Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS ); + + switch( iPowerup ) + { + case POWERUP_RUSH: + { + // Stop the looping breathing + StopSound( "BaseTFPlayer.HeavyBreathing" ); + + if ( IsLocalPlayer() ) + { + // Stop the visual effects + if ( m_flNextAdrenalinEffect ) + { + vieweffects->ClearAllFades(); + } + + m_flNextAdrenalinEffect = 0; + } + } + break; + + default: + break; + } + + BaseClass::PowerupEnd( iPowerup ); +} |