//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: TF2's player object.
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include <stdarg.h>
#include "player.h"
#include "tf_player.h"
#include "gamerules.h"
#include "trains.h"
#include "entitylist.h"
#include "menu_base.h"
#include "basecombatweapon.h"
#include "controlzone.h"
#include "tf_shareddefs.h"
#include "AmmoDef.h"
#include "techtree.h"
#include "in_buttons.h"
#include "tf_team.h"
#include "client.h"
#include "baseviewmodel.h"
#include "tf_gamerules.h"
#include "tf_obj.h"
#include "weapon_builder.h"
#include "orders.h"
#include "decals.h"
#include "tf_func_resource.h"
#include "resource_chunk.h"
#include "team_messages.h"
#include "tier0/dbg.h"
#include "tf_obj_respawn_station.h"
#include "tf_obj_resourcepump.h"
#include "tf_class_commando.h"
#include "tf_class_defender.h"
#include "tf_class_escort.h"
#include "tf_class_infiltrator.h"
#include "tf_class_medic.h"
#include "tf_class_recon.h"
#include "tf_class_sniper.h"
#include "tf_class_support.h"
#include "tf_class_sapper.h"
#include "sendproxy.h"
#include "ragdoll_shadow.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "bone_setup.h"
#include "weapon_combatshield.h"
#include "weapon_twohandedcontainer.h"
#include "NDebugOverlay.h"
#include "tier1/strtools.h"
#include "IEffects.h"
#include "info_act.h"
#include "ai_basehumanoid.h"
#include "tf_stats.h"
#include "iservervehicle.h"
#include "tf_vehicle_teleport_station.h"
#include "globals.h"
#define MAX_EXPLOSIVE_VELOCITY 600.0f
extern ConVar tf_knockdowntime;
extern ConVar inv_demo;
ConVar tf_autoteam( "tf_autoteam", "1", 0, "Automatically place players on the team with the least players." );
ConVar tf_destroyobjects( "tf_destroyobjects", "1", FCVAR_CHEAT, "Destroy objects when players change class or team." );
IMPLEMENT_SERVERCLASS_ST(CBaseTFPlayer, DT_BaseTFPlayer)
SendPropDataTable(SENDINFO_DT(m_TFLocal), &REFERENCE_SEND_TABLE(DT_TFLocal), SendProxy_SendLocalDataTable),
SendPropInt(SENDINFO(m_iPlayerClass), 4, SPROP_UNSIGNED),
// Class Data Tables
SendPropDataTable( SENDINFO_DT( m_PlayerClasses ), &REFERENCE_SEND_TABLE( DT_AllPlayerClasses ), SendProxy_SendLocalDataTable ),
SendPropEHandle( SENDINFO( m_hSelectedMCV ) ),
SendPropInt( SENDINFO(m_iCurrentZoneState ), 3 ),
SendPropInt( SENDINFO(m_iMaxHealth ), 8, SPROP_UNSIGNED ),
SendPropInt( SENDINFO(m_TFPlayerFlags), TF_PLAYER_NUMFLAGS, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bUnderAttack ), 1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bIsBlocking ), 1, SPROP_UNSIGNED ),
// Sniper - will get moved to a class data table
SendPropVector( SENDINFO(m_vecDeployedAngles), -1, SPROP_COORD ),
SendPropInt( SENDINFO( m_bDeployed ), 1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bDeploying ), 1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bUnDeploying ), 1, SPROP_UNSIGNED ),
// Infiltrator - will get moved to a class data table
SendPropFloat( SENDINFO( m_flCamouflageAmount ), 7, SPROP_ROUNDDOWN, 0.0f, 100.0f ),
SendPropEHandle(SENDINFO(m_hSpawnPoint)),
SendPropExclude( "DT_BaseAnimating" , "m_flPoseParameter" ),
SendPropExclude( "DT_BaseAnimating" , "m_flPlaybackRate" ),
END_SEND_TABLE()
LINK_ENTITY_TO_CLASS( player, CBaseTFPlayer );
PRECACHE_REGISTER(player);
BEGIN_DATADESC( CBaseTFPlayer )
DEFINE_INPUTFUNC( FIELD_VOID, "Respawn", InputRespawn ),
// Function Pointers
DEFINE_THINKFUNC( TFPlayerDeathThink ),
END_DATADESC()
BEGIN_PREDICTION_DATA_NO_BASE( CTFPlayerLocalData )
END_PREDICTION_DATA()
BEGIN_PREDICTION_DATA( CBaseTFPlayer )
END_PREDICTION_DATA()
bool IsSpawnPointValid( CBaseEntity *pPlayer, CBaseEntity *pSpot );
void respawn( CBaseEntity *pEdict, bool fCopyCorpse );
int TrainSpeed(int iSpeed, int iMax);
void BulletWizz( Vector vecSrc, Vector vecEndPos, edict_t *pShooter, bool isTracer );
extern float g_flNextReinforcementTime;
extern short g_sModelIndexFireball;
extern CBaseEntity *g_pLastSpawn;
//-----------------------------------------------------------------------------
// Purpose: Don't do anything for now
// Input : *pFormat -
// ... -
// Output : static void
//-----------------------------------------------------------------------------
void StatusPrintf( bool clear, int destination, char *pFormat, ... )
{
return;
/*
va_list marker;
char msg[8192];
va_start(marker, pFormat);
Q_vsnprintf(msg, sizeof( msg ), pFormat, marker);
va_end(marker);
Msg( msg );
*/
}
#pragma warning( disable : 4355 )
//=====================================================================
// PLAYER HANDLING
//=====================================================================
CBaseTFPlayer::CBaseTFPlayer() :
m_PlayerClasses( this ), m_PlayerAnimState( this )
{
// HACK because player's have pev set in baseclass constructor
// which triggers an assert that we want to keep.
{
edict_t *savepev = edict();
NetworkProp()->SetEdict( NULL );
UseClientSideAnimation();
NetworkProp()->SetEdict( savepev );
}
m_bWasMoving = false;
m_iLastSecondsToGo = -1;
m_TFLocal.m_nInTacticalView = 0;
m_TFLocal.m_pPlayer = this;
m_bSwitchingView = false;
ClearActiveWeapon();
m_iPlayerClass = TFCLASS_UNDECIDED;
SetPlayerClass( TFCLASS_UNDECIDED );
m_pCurrentMenu = NULL;
m_TFPlayerFlags = 0;
m_bDeploying = false;
m_bDeployed = false;
m_bUnDeploying = false;
m_flFinishedDeploying = 0;
SetOrder( NULL );
m_nPreferredTechnology = -1;
m_nMedicDamageBoosts = 0;
m_hSpawnPoint = NULL;
m_flLastTimeDamagedByEnemy = -1000;
int i;
for ( i = 0; i < MOMENTUM_MAXSIZE; i++ )
{
m_aMomentum[ i ] = 1.0f;
}
}
void CBaseTFPlayer::UpdateOnRemove( void )
{
if ( m_hSelectedOrder )
{
GetTFTeam()->RemoveOrdersToPlayer( this );
Assert( !m_hSelectedOrder.Get() );
}
ClearPlayerClass();
ClearClientRagdoll( false );
// Chain at end to mimic destructor unwind order
BaseClass::UpdateOnRemove();
}
CBaseTFPlayer::~CBaseTFPlayer()
{
SetPlayerClass( (TFClass)-1 );
}
bool CBaseTFPlayer::IsHidden() const
{
return (m_TFPlayerFlags & TF_PLAYER_HIDDEN) != 0;
}
void CBaseTFPlayer::SetHidden( bool bHidden )
{
if ( bHidden )
m_TFPlayerFlags |= TF_PLAYER_HIDDEN;
else
m_TFPlayerFlags &= ~TF_PLAYER_HIDDEN;
}
//-----------------------------------------------------------------------------
// Purpose: Called everytime the player's respawned
//-----------------------------------------------------------------------------
void CBaseTFPlayer::Spawn( void )
{
m_bUnderAttack = false;
m_pCurrentZone = NULL;
ClearClientRagdoll( false );
g_pNotify->ReportNamedEvent( this, "PlayerSpawned" );
DeactivateMovementConstraint();
if ( IsInAVehicle() )
{
LeaveVehicle();
}
// If the player doesn't have a spawn station set, find one
if ( m_hSpawnPoint == NULL || !InSameTeam( m_hSpawnPoint ) )
{
m_hSpawnPoint = GetInitialSpawnPoint();
}
if ( inv_demo.GetBool() )
{
if ( !GetPlayerClass() )
{
ChangeClass( TFCLASS_MEDIC );
m_Local.m_iHideHUD |= HIDEHUD_MISCSTATUS;
engine->ServerCommand("r_DispEnableLOD 0\n");
}
}
// Must be done before baseclass spawn, so it's correct for when we find a spawnpoint
if ( GetPlayerClass() )
{
GetPlayerClass()->SetPlayerHull();
}
// Use human commando model until we know our class
SetModel( "models/player/human_commando.mdl" );
BaseClass::Spawn();
m_flFractionalBoost = 0.0f;
// Create second view model ( for support/commando, etc )
CreateViewModel( 1 );
// Tell the PlayerClass that this player's just respawned
if ( GetPlayerClass() )
{
RemoveFlag( FL_NOTARGET );
RemoveSolidFlags( FSOLID_NOT_SOLID );
GetPlayerClass()->RespawnClass();
if ( GetActiveWeapon() )
{
// Holster weapon immediately, to allow it to cleanup
// GetActiveWeapon()->Holster( ); // NJS: test
if (GetActiveWeapon()->HasAnyAmmo())
{
Weapon_Switch( GetActiveWeapon() );
}
else
{
SwitchToNextBestWeapon( GetActiveWeapon() );
}
}
else
{
SwitchToNextBestWeapon( NULL );
}
SetPlayerModel();
// Make sure they're not deployed
FinishUnDeploying();
// Remove my personal orders
if ( GetTFTeam() )
{
GetTFTeam()->RemoveOrdersToPlayer( this );
}
RemoveAllDecals();
}
else
{
// No class? can't target this dude
AddFlag( FL_NOTARGET );
// Remove everything
RemoveAllItems( false );
// Set/unset m_bHidden instead to hide the tf player
SetHidden( true );
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_NONE );
SetModel( "models/player/human_commando.mdl" );
// If they're not in a team, bring up the Team Menu
if ( !IsInAnyTeam() )
{
if ( tf_autoteam.GetFloat() )
{
// Autoteam the player
PlacePlayerInTeam();
ForceRespawn();
}
else
{
// Let players choose their team
m_pCurrentMenu = gMenus[MENU_TEAM];
}
}
else // Bring up the Class Menu
{
m_pCurrentMenu = gMenus[MENU_CLASS];
}
m_MenuRefreshTime = gpGlobals->curtime;
m_nPreferredTechnology = -1;
}
SetCantMove( false );
m_TFLocal.m_nInTacticalView = 0;
m_flLastTimeDamagedByEnemy = -1000;
// Purge resource chunks
for ( int i=0; i < m_TFLocal.m_iResourceAmmo.Count(); i++ )
m_TFLocal.m_iResourceAmmo.Set( i, 0 );
ResetKnockdown();
SetGagged( false );
SetUsingThermalVision( false );
ClearCamouflage();
SetIDEnt( NULL );
m_iPowerups = 0;
// MUST set the right player hull before placing the player somewhere.
if ( GetPlayerClass() )
GetPlayerClass()->SetPlayerHull();
g_pGameRules->GetPlayerSpawnSpot( this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::CleanupOnActStart( void )
{
// Tell all our weapons
for ( int i = 0; i < WeaponCount(); i++ )
{
if ( GetWeapon(i) )
{
((CBaseTFCombatWeapon*)GetWeapon(i))->CleanupOnActStart();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::RecalculateSpeed( void )
{
if ( GetPlayerClass() )
{
GetPlayerClass()->SetMaxSpeed( GetPlayerClass()->GetMaxSpeed() );
}
}
//-----------------------------------------------------------------------------
// Purpose: I just killed another player
//-----------------------------------------------------------------------------
void CBaseTFPlayer::KilledPlayer( CBaseTFPlayer *pVictim )
{
TFStats()->IncrementPlayerStat( this, TF_PLAYER_STAT_KILL_COUNT, 1 );
TFStats()->IncrementTeamStat( GetTeamNumber(), TF_TEAM_STAT_KILL_COUNT, 1 );
// Am I in a rampage?
if ( HasPowerup( POWERUP_RUSH ) && IsInRampage() )
{
// Extend my rush
AttemptToPowerup( POWERUP_RUSH, ADRENALIN_RAMPAGE_EXTEND );
// Let 'em know
EmitSound( "BaseTFPlayer.BloodSportKiller" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Called only the first time a player's placed in the map
//-----------------------------------------------------------------------------
void CBaseTFPlayer::InitialSpawn( void )
{
BaseClass::InitialSpawn();
SetWeaponBuilder( NULL );
m_bFirstTeamSpawn = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::Precache( void )
{
//!! hack for radar
BaseClass::Precache();
PrecacheScriptSound( "BaseTFPlayer.BloodSportKiller" );
PrecacheScriptSound( "Humans.Death" );
PrecacheScriptSound( "AlienCommando.Death" );
PrecacheScriptSound( "AlienMedic.Death" );
PrecacheScriptSound( "AlienDefender.Death" );
PrecacheScriptSound( "AlienEscort.Death" );
PrecacheScriptSound( "BaseTFPlayer.StartDeploying" );
PrecacheScriptSound( "BaseTFPlayer.StartUnDeploying" );
PrecacheScriptSound( "BaseTFPlayer.KnockedDown" );
PrecacheScriptSound( "BaseTFPlayer.ThermalOn" );
PrecacheScriptSound( "BaseTFPlayer.ThermalOff" );
PrecacheScriptSound( "BaseTFPlayer.PickupResources" );
PrecacheScriptSound( "BaseTFPlayer.DonateResources" );
// Class specific sounds
PrecacheScriptSound( "Commando.BootHit" );
PrecacheScriptSound( "Commando.BootSwing" );
PrecacheScriptSound( "Commando.BullRushScream" );
PrecacheScriptSound( "Commando.BullRushFlesh" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::UpdateClientData( void )
{
CTeam *pTeam = GetTeam();
if ( pTeam )
pTeam->UpdateClientData( this );
BaseClass::UpdateClientData();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ForceClientDllUpdate( void )
{
BaseClass::ForceClientDllUpdate();
// Force any active menu to be reset
m_MenuRefreshTime = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Forces an immediate respawn of the player
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ForceRespawn( void )
{
Spawn();
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that forces a respawn of the player.
//-----------------------------------------------------------------------------
void CBaseTFPlayer::InputRespawn( inputdata_t &inputdata )
{
ForceRespawn();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::InitHUD( void )
{
CSingleUserRecipientFilter user( this );
user.MakeReliable();
// If we're in an act, tell it to update the client
if ( g_hCurrentAct )
{
g_hCurrentAct->UpdateClient( this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Player has just tried to switch to a new weapon
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SelectItem( const char *pstr, int iSubType )
{
// can't change weapon while deployed
if ( IsPlayerLockedInPlace() || IsDeployed() || IsDeploying() )
return;
// Pass through to CBaseCombatWeapon code
BaseClass::SelectItem( pstr, iSubType );
}
//-----------------------------------------------------------------------------
// Purpose: Put the player in the specified team
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ChangeTeam( int iTeamNum )
{
// If we're changing team, clear my order
if ( iTeamNum != GetTeamNumber() )
{
SetOrder(NULL);
if ( tf_destroyobjects.GetFloat() )
{
RemoveAllObjects( false );
}
}
// Force full tech tree update
for ( int i = 0 ; i < MAX_TECHNOLOGIES; i++ )
{
m_rgClientTechAvail[ i ].m_nAvailable = -1;
}
BaseClass::ChangeTeam( iTeamNum );
// Now handle resources:
// - If it's the first spawn ever, give the player the team's currently calculated resource amount
// - If the player has more resources than the team's joining amount, drop his resources to that amount. Otherwise, he can keep his current.
if ( GetGlobalTFTeam( iTeamNum ) )
{
float flJoiningResources = GetGlobalTFTeam( iTeamNum )->GetJoiningPlayerResources();
if ( m_bFirstTeamSpawn )
{
m_bFirstTeamSpawn = false;
SetBankResources( flJoiningResources );
}
else
{
if ( flJoiningResources < GetBankResources() )
{
SetBankResources( flJoiningResources );
}
}
}
// Clear the client ragdoll, when changing teams.
ClearClientRagdoll( false );
}
//-----------------------------------------------------------------------------
// Purpose: Automatically place the player in the most appropriate team
//-----------------------------------------------------------------------------
void CBaseTFPlayer::PlacePlayerInTeam( void )
{
CTFTeam *pTargetTeam = NULL;
// Find the team with the least players in it
for ( int i = 0; i < MAX_TF_TEAMS; i++ )
{
CTFTeam *pTeam = GetGlobalTFTeam(i);
if ( pTargetTeam )
{
if ( pTeam->GetNumPlayers() < pTargetTeam->GetNumPlayers() )
pTargetTeam = pTeam;
}
else
{
pTargetTeam = pTeam;
}
}
ChangeTeam( pTargetTeam->GetTeamNumber() );
}
//-----------------------------------------------------------------------------
// Purpose: Return true if the specified class is available to this player
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsClassAvailable( TFClass iClass )
{
char str[128];
Q_snprintf( str, sizeof( str ), "class_%s", GetTFClassInfo( iClass )->m_pClassName );
return HasNamedTechnology( str );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ChangeClass( TFClass iClass )
{
// If they've got a playerclass, kill it
if ( GetPlayerClass() )
{
if ( tf_destroyobjects.GetFloat() )
{
RemoveAllObjects( false, iClass );
}
ClearPlayerClass();
}
// can't change class if we have no team
if ( !IsInAnyTeam() )
return;
// Make sure client .dll can find out about it.
SetPlayerClass( iClass );
// Clear out current vote....
CTFTeam *pTFTeam = GetTFTeam();
SetPreferredTechnology( pTFTeam->m_pTechnologyTree, -1 );
// Force a respawn if they're alive
if ( IsAlive() )
{
ForceRespawn();
}
}
//-----------------------------------------------------------------------------
// Purpose: Reset player class
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ClearPlayerClass( void )
{
// Remove all weapons & items
if ( GetPlayerClass() )
{
RemoveAllItems( false );
m_hWeaponCombatShield = NULL;
}
m_iPowerups = 0;
SetPlayerClass( TFCLASS_UNDECIDED );
}
//-----------------------------------------------------------------------------
// Purpose: Set the player's model to the correct one, taking into account
// class, gender, team, and disguise.
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetPlayerModel( void )
{
if (!GetPlayerClass())
{
SetHidden( true );
return;
}
string_t sModel = GetPlayerClass()->GetClassModel( GetTeamNumber() );
// If they don't have a model, make the player invisible
if ( !sModel )
{
SetHidden( true );
return;
}
// Make the player visible
SetHidden( false );
// Set the model
SetModel( STRING( sModel ) );
if ( GetFlags() & FL_DUCKING )
UTIL_SetSize(this, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX);
else
UTIL_SetSize(this, VEC_HULL_MIN, VEC_HULL_MAX);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::PlayerRespawn( void )
{
m_nButtons = 0;
m_iRespawnFrames = 0;
// don't copy a corpse if we're in deathcam.
respawn( this, !IsObserver() );
SetThink( NULL );
}
//-----------------------------------------------------------------------------
// Purpose: Play a sound when we die
//-----------------------------------------------------------------------------
void CBaseTFPlayer::DeathSound( const CTakeDamageInfo &info )
{
if ( GetTeamNumber() == TEAM_HUMANS )
{
EmitSound( "Humans.Death" );
}
else if ( GetTeamNumber() == TEAM_ALIENS )
{
switch( PlayerClass() )
{
case TFCLASS_COMMANDO:
EmitSound( "AlienCommando.Death" );
break;
case TFCLASS_MEDIC:
EmitSound( "AlienMedic.Death" );
break;
case TFCLASS_DEFENDER:
EmitSound( "AlienDefender.Death" );
break;
case TFCLASS_ESCORT:
EmitSound( "AlienEscort.Death" );
break;
default:
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ItemPostFrame()
{
// Don't process items while in a vehicle.
if ( IsInAVehicle() )
{
IServerVehicle *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 ( GetPlayerClass() )
{
GetPlayerClass()->ItemPostFrame(); // Let the player class handle it.
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::Jump( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::PreThink(void)
{
CheckBuffs();
// Riding a vehicle?
if ( IsInAVehicle() )
{
BaseClass::PreThink();
return;
}
CheckDeployFinish();
CheckKnockdown();
CheckCamouflage();
CheckSapperAttaching();
// Update reinforcement state
if (m_lifeState >= LIFE_DYING)
{
// After 3 seconds, move them to the Tactical Map
if ( (gpGlobals->curtime - m_flTimeOfDeath) > 3.0 )
{
if ( m_TFLocal.m_nInTacticalView == false )
{
ShowTacticalView( 1 );
}
}
// ROBIN: Maps will define whether or not teams reinforce
/*
// Aliens respawn in waves
if ( GetTeamNumber() == TEAM_ALIENS )
{
int iSecondsToGo = (int)(g_flNextReinforcementTime - gpGlobals->curtime);
if ( iSecondsToGo != m_iLastSecondsToGo && iSecondsToGo >= 1 )
{
m_iLastSecondsToGo = iSecondsToGo;
ClientPrint( this, HUD_PRINTCENTER, UTIL_VarArgs("\nReinforcing in %d %s\n", iSecondsToGo, iSecondsToGo > 1 ? "seconds" : "second" ) );
}
}
*/
TFPlayerDeathThink();
}
// Update zone state
if ( m_pCurrentZone )
{
m_iCurrentZoneState = m_pCurrentZone->GetControllingTeam();
if ( m_iCurrentZoneState != ZONE_CONTESTED )
{
// Set the Zone state to the correct one
if ( m_iCurrentZoneState == GetTeamNumber() )
m_iCurrentZoneState = ZONE_FRIENDLY;
else
m_iCurrentZoneState = ZONE_ENEMY;
}
}
else
{
m_iCurrentZoneState = 0;
}
BaseClass::PreThink();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::PostThink()
{
BaseClass::PostThink();
// Make sure we have a valid MCV id.
CVehicleTeleportStation *pMCV = GetSelectedMCV();
if ( !pMCV || !pMCV->IsDeployed() )
{
m_hSelectedMCV = CVehicleTeleportStation::GetFirstDeployedMCV( GetTeamNumber() );
}
// Tell the client if our damage is boosted so it can do a smurfy effect on the weapon.
if ( GetAttackDamageScale( NULL ) == 1 )
m_TFPlayerFlags &= ~TF_PLAYER_DAMAGE_BOOST;
else
m_TFPlayerFlags |= TF_PLAYER_DAMAGE_BOOST;
m_PlayerAnimState.Update();
// SetLocalAngles( m_PlayerAnimState.GetRenderAngles() );
float flTimeSinceAttacked = gpGlobals->curtime - LastTimeDamagedByEnemy();
m_bUnderAttack = ((flTimeSinceAttacked >= 0.0f) && (flTimeSinceAttacked < 1.0f));
// TODO: This collision hull is set in the base class PostThink (so this is
// redundant), but I don't wanna re-write the whole thing at this point.
// We will just have to deal with a little redundancy for now.
if ( GetPlayerClass() )
{
GetPlayerClass()->SetPlayerHull();
}
// Menus
MenuDisplay();
// Player class Think
if (GetPlayerClass())
{
GetPlayerClass()->ClassThink();
}
if ( m_bSwitchingView )
{
m_bSwitchingView = false;
SetMoveType( m_TFLocal.m_nInTacticalView ? MOVETYPE_ISOMETRIC : MOVETYPE_WALK );
}
FollowClientRagdoll();
}
//-----------------------------------------------------------------------------
// Purpose: selects a valid point that the player can spawn at
// Output : edict_t - the point in the world to spawn at
//-----------------------------------------------------------------------------
CBaseEntity *CBaseTFPlayer::EntSelectSpawnPoint( void )
{
// If we're in a team, ask the team for a spawnpoint
if ( GetTeam() )
{
CBaseEntity *entity = NULL;
if ( GetPlayerClass() )
{
// Let individual player classes override the respawn point
entity = GetPlayerClass()->SelectSpawnPoint();
if ( entity )
{
return entity;
}
// Do we have a selected spawn point (from a respawn station)?
entity = m_hSpawnPoint;
if (entity && (entity->GetTeam() == GetTeam()))
{
PlayRespawnEffect( entity );
return entity;
}
}
entity = GetTeam()->SpawnPlayer( this );
if ( entity )
return entity;
}
// If we're not in a team, or the team didn't have a spawnpoint for us,
// fall back to the basic spawnpoint code.
return BaseClass::EntSelectSpawnPoint();
}
void CBaseTFPlayer::RemoveShieldOverlays( void )
{
RemoveGesture( ACT_OVERLAY_SHIELD_UP );
RemoveGesture( ACT_OVERLAY_SHIELD_DOWN );
RemoveGesture( ACT_OVERLAY_SHIELD_UP_IDLE );
RemoveGesture( ACT_OVERLAY_SHIELD_ATTACK );
RemoveGesture( ACT_OVERLAY_SHIELD_KNOCKBACK );
}
static bool IsShieldOverlay( Activity activity )
{
switch ( activity )
{
default:
return false;
case ACT_OVERLAY_SHIELD_UP:
case ACT_OVERLAY_SHIELD_DOWN:
case ACT_OVERLAY_SHIELD_UP_IDLE:
case ACT_OVERLAY_SHIELD_ATTACK:
case ACT_OVERLAY_SHIELD_KNOCKBACK:
return true;
}
return false;
}
int CBaseTFPlayer::RemoveShieldOverlaysExcept( Activity activity, bool addifnotpresent /*= true */ )
{
int skip = FindGestureLayer( activity );
int i;
for ( i = 0; i < CBaseAnimatingOverlay::MAX_OVERLAYS; i++ )
{
if ( i == skip )
continue;
if ( IsShieldOverlay( GetLayerActivity( i ) ) )
{
RemoveLayer( i, 0.0, 0.0f );
}
}
// Add it in if it's not present already
if ( addifnotpresent && ( skip == -1 ) )
{
return AddGesture( activity );
}
else
{
return skip;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : activity - i/o : can be changed to a new activity
// overlayindex - o: if an overlay is picked, this gets changed
// Rest of paramters are input only
// moving - is player moving
// ducked - is player ducking
// overlay - animation choices for this state (either full body crouch/stand, or overlay on top of base crouch/stand )
// crouch -
// normal -
// Overlay parameters
// autokill - if false, overlay will loop indefinitely
// blendin - amount of time over which to blend in (0.0f for snap)
// blendout - same but for blending out instead
//-----------------------------------------------------------------------------
void CBaseTFPlayer::PickShieldAnimation( Activity& activity, int& overlayindex, bool moving, bool ducked,
Activity overlay, Activity crouch, Activity normal,
bool autokill /*=true*/, float blendin /*=0.0f*/, float blendout /*=0.0f*/ )
{
if ( moving )
{
overlayindex = RemoveShieldOverlaysExcept( overlay );
if ( overlayindex != -1 )
{
if ( blendin > 0.0f )
{
SetLayerBlendIn( overlayindex, blendin );
}
if ( blendout > 0.0f )
{
SetLayerBlendOut( overlayindex, blendout );
}
if ( !autokill )
{
SetLayerAutokill( overlayindex, false );
}
}
}
else
{
activity = ducked ? crouch : normal;
}
}
Activity CBaseTFPlayer::ShieldTranslateActivity( Activity activity )
{
CWeaponTwoHandedContainer *container = dynamic_cast< CWeaponTwoHandedContainer * >( GetActiveWeapon() );
if ( !container )
return activity;
CWeaponCombatShield *pShield = dynamic_cast< CWeaponCombatShield * >( container->GetLeftWeapon() );
if ( !pShield )
{
pShield = dynamic_cast< CWeaponCombatShield * >( container->GetRightWeapon() );
if ( !pShield )
{
return activity;
}
}
float speed = GetAbsVelocity().Length2D();
bool isMoving = speed != 0 ? true : false;
//bool isRunning = speed > 75 ? true : false;
bool isDucked = ( GetFlags() & FL_DUCKING ) ? true : false;
int shieldState = pShield->GetShieldState();
float startframe = 0.0f;
bool movechanged = isMoving ^ m_bWasMoving;
if ( movechanged)
{
// Grab frame from overlay
if ( !isMoving )
{
for ( int i = 0; i < MAX_OVERLAYS; i++ )
{
if ( IsShieldOverlay( GetLayerActivity( i ) ) )
{
startframe = GetLayerCycle( i );
}
}
RemoveShieldOverlays();
}
else
{
switch ( GetActivity() )
{
case ACT_SHIELD_UP:
case ACT_SHIELD_DOWN:
case ACT_SHIELD_UP_IDLE:
case ACT_SHIELD_ATTACK:
//case ACT_SHIELD_KNOCKBACK:
case ACT_CROUCHING_SHIELD_UP:
case ACT_CROUCHING_SHIELD_DOWN:
case ACT_CROUCHING_SHIELD_UP_IDLE:
case ACT_CROUCHING_SHIELD_ATTACK:
//case ACT_CROUCHING_SHIELD_KNOCKBACK:
startframe = GetCycle();
break;
default:
break;
}
}
}
// Asume we should fix up animation based on move/stationary state change
bool fixup = true;
// Assume no overlay
int idx = -1;
switch ( shieldState )
{
default:
case SS_DOWN:
case SS_UNAVAILABLE:
RemoveShieldOverlays();
// By default, remove shield overlays and don't do fixup
fixup = false;
break;
case SS_LOWERING:
{
PickShieldAnimation( activity, idx, isMoving, isDucked,
ACT_OVERLAY_SHIELD_DOWN, ACT_CROUCHING_SHIELD_DOWN, ACT_SHIELD_DOWN,
true, 0.0f, 0.2f );
}
break;
case SS_RAISING:
{
PickShieldAnimation( activity, idx, isMoving, isDucked,
ACT_OVERLAY_SHIELD_UP, ACT_CROUCHING_SHIELD_UP, ACT_SHIELD_UP,
true, 0.2f, 0.0f );
}
break;
case SS_UP:
{
PickShieldAnimation( activity, idx, isMoving, isDucked,
ACT_OVERLAY_SHIELD_UP_IDLE, ACT_CROUCHING_SHIELD_UP_IDLE, ACT_SHIELD_UP_IDLE,
false );
}
break;
case SS_PARRYING:
{
PickShieldAnimation( activity, idx, isMoving, isDucked,
ACT_OVERLAY_SHIELD_ATTACK, ACT_CROUCHING_SHIELD_ATTACK, ACT_SHIELD_ATTACK,
true, 0.1f, 0.1f );
}
break;
}
// If started or stopped moving and still using shield, match the cycle to/from the overlay/base animation
// being used beforehand
if ( movechanged && fixup )
{
// Fixup overlay frame
if ( idx != -1 )
{
SetLayerCycle( idx, startframe );
}
else
{
// Force animation blend
ResetSequenceInfo();
// Match start frame
SetCycle( startframe );
}
}
// Remember previous state
m_bWasMoving = isMoving;
// Return translated activity
return activity;
}
void CBaseTFPlayer::StoreCycle( void )
{
m_flStoredCycle = GetCycle(); // !!!!!
}
float CBaseTFPlayer::RetrieveCycle( void )
{
return m_flStoredCycle;
}
//-----------------------------------------------------------------------------
// Purpose: Certain activities have matched cycles
// Input : newActivity -
// currentActivity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::ShouldMatchCycles( Activity newActivity, Activity currentActivity )
{
if ( ( newActivity == ACT_WALK || newActivity == ACT_RUN ) &&
( currentActivity == ACT_WALK || currentActivity == ACT_RUN ) )
{
// Don't blend either
IncrementInterpolationFrame();
return true;
}
return false;
}
#define ARBITRARY_RUN_SPEED 75.0f
//-----------------------------------------------------------------------------
// Purpose: Set the activity based on an event or current state
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetAnimation( PLAYER_ANIM playerAnim )
{
// Assume no change
Activity idealActivity = GetActivity();
int animDesired = GetSequence();
float speed = GetAbsVelocity().Length2D();
bool isMoving = ( speed != 0.0f ) ? true : false;
bool isRunning = false;
if ( GetPlayerClass() )
{
// FIXME: TF2 makes no distinction between walking and running for now,
// use the run animation always
if ( speed > 10.0f )
{
isRunning = true;
}
}
else
{
if ( speed > ARBITRARY_RUN_SPEED )
{
isRunning = true;
}
}
bool isDucked = ( GetFlags() & FL_DUCKING ) ? true : false;
bool isStillJumping = !( GetFlags() & FL_ONGROUND ) && ( GetActivity() == ACT_HOP );
StoreCycle();
// Decide upon an animation activity based upon the desired Player animation
switch ( playerAnim )
{
default:
case PLAYER_RELOAD:
case PLAYER_ATTACK1:
case PLAYER_IDLE:
case PLAYER_WALK:
// Are we still jumping?
// If so, keep playing the jump animation.
if ( !isStillJumping )
{
idealActivity = ACT_WALK;
if ( isDucked )
{
idealActivity = !isMoving ? ACT_CROUCHIDLE : ACT_CROUCH;
}
else
{
if ( isRunning )
{
idealActivity = ACT_RUN;
}
else
{
idealActivity = isMoving ? ACT_WALK : ACT_IDLE;
}
}
// Allow shield to override
idealActivity = ShieldTranslateActivity( idealActivity );
// Allow body yaw to override for standing and turning in place
idealActivity = m_PlayerAnimState.BodyYawTranslateActivity( idealActivity );
}
break;
case PLAYER_IN_VEHICLE:
// For now, use manned gun pose for all vehicles
idealActivity = ACT_RIDE_MANNED_GUN;
break;
case PLAYER_JUMP:
idealActivity = ACT_HOP;
break;
case PLAYER_DIE:
// Uses Ragdoll now???
idealActivity = ACT_DIESIMPLE;
break;
// FIXME: Use overlays for reload, start/leave aiming, attacking
case PLAYER_START_AIMING:
case PLAYER_LEAVE_AIMING:
idealActivity = ACT_WALK;
break;
}
// No change requested?
if ( ( GetActivity() == idealActivity ) && ( GetSequence() != -1 ) )
return;
bool useStoredCycle = ShouldMatchCycles( idealActivity, GetActivity() );
animDesired = SelectWeightedSequence( idealActivity );
SetActivity( idealActivity );
// Already using the desired animation?
if ( GetSequence() == animDesired )
return;
ResetSequence( animDesired );
// Reset to first frame of desired animation or match previous animation if activities are
// meant to synchronize
SetCycle( useStoredCycle ? RetrieveCycle() : 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::CheatImpulseCommands( int iImpulse )
{
switch(iImpulse)
{
case 101:
if ( GetPlayerClass() )
{
GetPlayerClass()->ResupplyAmmo( 1.0f, RESUPPLY_ALL_FROM_STATION );
}
break;
case 150:
if ( GetTFTeam() )
GetTFTeam()->PostMessage( TEAMMSG_REINFORCEMENTS_ARRIVED );
break;
default:
BaseClass::CheatImpulseCommands(iImpulse);
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetRespawnStation( CBaseEntity* pRespawnStation )
{
// This can happen because the object may get killed and its index reused
// between time the message was sent and the
if( !pRespawnStation || !FClassnameIs( pRespawnStation, "obj_respawn_station" ) )
return;
// Team could have changed (stolen object)
if ( GetTeam() != pRespawnStation->GetTeam() )
return;
// If the respawn station is the same one, then unselect!
if ( pRespawnStation != m_hSpawnPoint )
{
// Make sure the respawn station is a respawn station; it could be some
m_hSpawnPoint = pRespawnStation;
}
else
{
m_hSpawnPoint = 0;
}
}
//-----------------------------------------------------------------------------
// Purpose: Find a starting respawn station
//-----------------------------------------------------------------------------
CBaseEntity *CBaseTFPlayer::GetInitialSpawnPoint( void )
{
if ( !GetTFTeam() )
return NULL;
CBaseEntity *pFirstStation = NULL;
// Cycle through all the respawn stations on my team
for ( int i = 0; i < GetTFTeam()->GetNumObjects(); i++ )
{
CBaseObject *pObject = GetTFTeam()->GetObject(i);
if ( pObject->GetType() == OBJ_RESPAWN_STATION )
{
// Store off the first station we find
if ( !pFirstStation )
{
pFirstStation = pObject;
}
// Map specified initial spawnpoint?
if ( ((CObjectRespawnStation*)pObject)->IsInitialSpawnPoint() )
return pObject;
}
}
return pFirstStation;
}
CBaseEntity *FindEntityForward( CBasePlayer *pMe, bool fHull );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::ClientCommand( const CCommand &args )
{
if( HasClass() )
{
if ( GetPlayerClass()->ClientCommand( args ) )
return true;
const char *cmd = args[0];
if ( FStrEq( cmd, "emp" ) )
{
Msg( "Self-inflicted EMP: testing\n" );
float flTime = 10;
if ( args.ArgC() == 2 )
{
flTime = atof( args[ 1 ] );
}
AttemptToPowerup( POWERUP_EMP, flTime );
return true;
}
if ( FStrEq( cmd, "emp_target" ) )
{
CBaseEntity *pEntity = FindEntityForward( this, true );
if ( pEntity && pEntity->CanBePoweredUp() )
{
float flTime = 10;
if ( args.ArgC() == 2 )
{
flTime = atof( args[ 1 ] );
}
pEntity->AttemptToPowerup( POWERUP_EMP, flTime );
}
return true;
}
if ( FStrEq( cmd, "dmg_target" ) )
{
CBaseEntity *pEntity = FindEntityForward( this, true );
if ( pEntity && pEntity->m_takedamage )
{
float flDamage = 1;
if ( args.ArgC() == 2 )
{
flDamage = atof( args[ 1 ] );
}
CBaseEntity *world = CBaseEntity::Instance( engine->PEntityOfEntIndex( 0 ) );
if ( world )
{
pEntity->OnTakeDamage( CTakeDamageInfo( world, world, flDamage, DMG_GENERIC ) );
}
}
return true;
}
}
if ( !stricmp( cmd, "kd" ) )
{
Vector force( 0, 0, 0 );
if ( args.ArgC() == 1 )
{
force.x = random->RandomFloat( 0.5, 1.0 );
force.y = random->RandomFloat( 0.5, 1.0 );
if ( random->RandomFloat( 0, 1 ) > 0.5 )
{
force.x *= -1.0f;
}
if ( random->RandomFloat( 0, 1 ) > 0.5 )
{
force.y *= -1.0f;
}
force.z = random->RandomFloat( 0.5, 1.0 );
}
else
{
Vector fwd;
Vector right;
AngleVectors( GetAbsAngles(), &fwd, &right, NULL );
if ( !stricmp( args[ 1 ], "f" ) )
{
force = fwd * -1.0f;
}
else if ( !stricmp( args[ 1 ], "b" ) )
{
force = fwd;
}
else if ( !stricmp( args[ 1 ], "r" ) )
{
force = right * -1.0f;
}
else if ( !stricmp( args[ 1 ], "l" ) )
{
force = right;
}
else if ( !stricmp( args[ 1 ], "fr" ) )
{
force = fwd * -1.0f;
force += right * -1.0f;
}
else if ( !stricmp( args[ 1 ], "br" ) )
{
force = fwd;
force += right * -1.0f;
}
else if ( !stricmp( args[ 1 ], "fl" ) )
{
force = fwd * -1.0f;
force += right;
}
else if ( !stricmp( args[ 1 ], "bl" ) )
{
force = fwd;
force += right;
}
force.z = 0.8f;
VectorNormalize( force );
}
KnockDownPlayer( force, 500.0f, 3.0f );
return true;
}
if ( FStrEq( cmd, "veryweak" ) )
{
int ouch = m_iHealth - 1;
CBaseEntity *world = CBaseEntity::Instance( engine->PEntityOfEntIndex( 0 ) );
if ( world )
{
OnTakeDamage( CTakeDamageInfo( world, world, (float)ouch, DMG_GENERIC ) );
}
return true;
}
if ( FStrEq( cmd, "ragdoll" ) )
{
bool on = true;
if ( args.ArgC() >= 2 )
{
on = atoi( args[ 1 ] ) ? true : false;
}
if ( on )
{
Vector force = RandomVector( -500, 500 );
force.z = fabs( force.z );
force.z = MIN( 200.0f, force.z );
BecomeRagdollOnClient( force );
}
else
{
ClearClientRagdoll( true );
}
return true;
}
if ( FStrEq( cmd, "hbset" ) )
{
if ( args.ArgC() >= 2 )
{
SetHitboxSet( atoi( args[ 1 ] ) );
Msg( "Hitboxset forced to %i %s\n", GetHitboxSet(), GetHitboxSetName() );
}
return true;
}
return BaseClass::ClientCommand( args );
}
//=========================================================
// Purpose: Override base TraceAttack
//=========================================================
void CBaseTFPlayer::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
if ( m_takedamage )
{
// Prevent team damage here so blood doesn't appear
if ( info.GetAttacker() )
{
// Take damage from myself
if ( InSameTeam( info.GetAttacker() ) && info.GetAttacker() != this )
return;
}
// If we hit our shield, ignore the damage
float flDamage = info.GetDamage();
if ( IsHittingShield( vecDir, &flDamage ))
return;
// Shield may have blocked some
CTakeDamageInfo subInfo = info;
subInfo.SetDamage( flDamage );
SetLastHitGroup( ptr->hitgroup );
// Hit groups aren't evaluated here, like base TraceAttack.
// Weapons factor hit location into flDamage before it gets here
/* //SpawnBlood( ptr->endpos - (vecDir * 5), BloodColor(), subInfo.GetDamage() );
//TraceBleed( subInfo.GetDamage(), vecDir, ptr, subInfo.GetDamageType() );
// Show the personal shield effect.
// What we do here is collide the trace line with an ellipse that is slightly larger
// than the player and put the effect there.
// Translate the line so the player's (and the ellipse's) center is at the origin.
Vector vCenter = Center();
Vector vStart = ptr->startpos - vCenter;
Vector vEnd = ptr->endpos - vCenter;
// Figure out the ellipse dimensions.
Vector vDims = (WorldAlignMaxs() - WorldAlignMins()) * 0.5f;
Vector vEllipse = vDims * 1.5;
// Squash the line we're testing so we're testing against a sphere of radius 1 at the origin.
vStart /= vEllipse;
vEnd /= vEllipse;
// See where the line hits the sphere.
Vector vLineDir = vEnd - vStart;
float f1, f2;
if ( IntersectInfiniteRayWithSphere( vStart, vLineDir, vec3_origin, 1, &f1, &f2 ) )
{
// Use the closest hit point on the sphere.
float fMin = MIN( f1, f2 );
Vector vPos = vStart + vLineDir * fMin;
// Unsquash back to the ellipse's dimensions.
vPos *= vEllipse;
ShowPersonalShieldEffect( vPos, vecDir, subInfo.GetDamage() );
}
*/
AddMultiDamage( subInfo, this );
}
}
//-----------------------------------------------------------------------------
// Applies a force on the player when he takes damage
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ApplyDamageForce( const CTakeDamageInfo &info, int nDamageToDo )
{
if (nDamageToDo <= 0)
return;
if ( (info.GetDamageType() & (DMG_ENERGYBEAM | DMG_BLAST)) == 0 )
return;
if ( !info.GetInflictor() || (info.GetInflictor() == this) || info.GetAttacker()->IsSolidFlagSet(FSOLID_TRIGGER) )
return;
// Don't blow ragdolls around
if ( IsClientRagdoll() )
return;
// Don't bother with crouched players, or classes that have other rules about it
if ( GetFlags() & FL_DUCKING )
return;
if (!GetPlayerClass() || !GetPlayerClass()->ShouldApplyDamageForce( info ))
return;
Vector vecDir;
// If the inflictor isn't moving, use the delta between it & me. If it's moving, use it's velocity.
Vector vecInflictorVelocity;
info.GetInflictor()->GetVelocity( &vecInflictorVelocity, NULL );
// Explosives never use the velocity of the inflictor
if ( !(info.GetDamageType() & DMG_BLAST) && vecInflictorVelocity != vec3_origin )
{
vecDir = vecInflictorVelocity;
}
else
{
vecDir = WorldSpaceCenter( );
vecDir -= info.GetInflictor()->WorldSpaceCenter( );
}
VectorNormalize( vecDir );
float flForce = (nDamageToDo * 2) + 20;
if (flForce > 1000.0)
flForce = 1000.0;
// Escorts get knocked half as far
if ( PlayerClass() == TFCLASS_ESCORT )
{
flForce *= 0.5;
}
vecDir *= flForce;
if ( (GetMoveType() != MOVETYPE_FLY) && (GetMoveType() != MOVETYPE_FLYGRAVITY) && ((GetFlags() & FL_ONGROUND) != 0) )
{
// Need large x-y component to overcome walking friction
vecDir.x *= 3;
vecDir.y *= 3;
}
Vector vecNewVelocity = GetAbsVelocity();
vecNewVelocity += vecDir;
Vector vecTestVel = vecNewVelocity;
float flLen = VectorNormalize( vecTestVel );
if (flLen > MAX_EXPLOSIVE_VELOCITY)
VectorMultiply( vecTestVel, MAX_EXPLOSIVE_VELOCITY, vecNewVelocity );
SetAbsVelocity( vecNewVelocity );
}
//-----------------------------------------------------------------------------
// Purpose: Deal damage to the player
//-----------------------------------------------------------------------------
int CBaseTFPlayer::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( !IsAlive() )
return 0;
//if ( GetFlags() & FL_GODMODE )
//return 0;
// Generate a global order event.
COrderEvent_PlayerDamaged event;
event.m_pPlayerDamaged = this;
event.m_TakeDamageInfo = info;
GlobalOrderEvent( &event );
// Don't do damage if the player's in a vehicle, in a non-damagable spot.
if ( IsInAVehicle() && m_hVehicle.Get() )
{
IServerVehicle* pVehicle = m_hVehicle.Get()->GetServerVehicle();
Assert( pVehicle );
int nRole = pVehicle->GetPassengerRole(this);
if( ( nRole < 0 )
|| !pVehicle->IsPassengerVisible(nRole)
|| !pVehicle->IsPassengerDamagable(nRole) )
{
return 0;
}
}
// Check teams
CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)info.GetAttacker();
if ( pPlayer )
{
// Take damage from myself
if ( pPlayer != this )
{
if ( InSameTeam(pPlayer) )
{
return 0;
}
else
{
// Store off the last time we were damaged by an enemy so commandos can
// get orders to assist.
m_flLastTimeDamagedByEnemy = gpGlobals->curtime;
}
}
}
CTakeDamageInfo subInfo = info;
// Let the playerclass at it
if ( GetPlayerClass() )
{
subInfo.SetDamage( GetPlayerClass()->OnTakeDamage( subInfo ) );
}
if ( !subInfo.GetDamage() )
return 0;
//Msg( "Weapon did: %f\n", flDamage );
int iDamageToDo = Ceil2Int( subInfo.GetDamage() );
if ( !(GetFlags() & FL_GODMODE) )
{
// Only certain damage types knock players around
ApplyDamageForce( info, iDamageToDo );
m_iHealth = MAX(0, m_iHealth - iDamageToDo);
}
//Msg( "m_iHealth: %d\n\n", m_iHealth );
// Dead?
if ( m_iHealth < 1 )
{
Event_Killed( subInfo );
}
// Let the client know
// Try and figure out where the damage is coming from
Vector vecDamageOrigin = info.GetReportedPosition();
// If we didn't get an origin to use, try using the attacker's origin
if ( vecDamageOrigin == vec3_origin && info.GetAttacker() )
{
vecDamageOrigin = info.GetAttacker()->GetAbsOrigin();
}
CSingleUserRecipientFilter user( this );
UserMessageBegin( user, "Damage" );
WRITE_BYTE( clamp( iDamageToDo, 0, 255 ) );
WRITE_FLOAT( vecDamageOrigin.x ); // BUG: Should be fixed point (to hud) not floats
WRITE_FLOAT( vecDamageOrigin.y ); // BUG: However, the HUD does _not_ implement bitfield messages (yet)
WRITE_FLOAT( vecDamageOrigin.z ); // BUG: We use WRITE_VEC3COORD for everything else
MessageEnd();
// Do special explosion damage effect
if ( info.GetDamageType() & DMG_BLAST )
{
OnDamagedByExplosion( info );
}
return iDamageToDo;
}
void CBaseTFPlayer::ShowPersonalShieldEffect(
const Vector &vOffsetFromEnt,
const Vector &vIncomingDirection,
float flDamage )
{
Vector vNormalized = vIncomingDirection;
VectorNormalize( vNormalized );
EntityMessageBegin( this );
WRITE_BYTE( PLAYER_MSG_PERSONAL_SHIELD );
WRITE_VEC3COORD( vOffsetFromEnt );
WRITE_VEC3NORMAL( vNormalized );
WRITE_SHORT( (short)flDamage );
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Player is being healed
//-----------------------------------------------------------------------------
int CBaseTFPlayer::TakeHealth( float flHealth, int bitsDamageType )
{
if ( m_iHealth == m_iMaxHealth )
return 0;
// Heal the location
float flAmountToHeal = flHealth;
if ( flAmountToHeal > (m_iMaxHealth - m_iHealth) )
flAmountToHeal = (m_iMaxHealth - m_iHealth);
m_iHealth += flAmountToHeal;
//Msg( "Health: %d\n", m_iHealth );
return flAmountToHeal;
}
//=====================================================================
// MENU HANDLING
//=====================================================================
void CBaseTFPlayer::MenuDisplay( void )
{
if ( !m_pCurrentMenu )
{
m_MenuRefreshTime = 0;
return;
}
if ( m_MenuRefreshTime > gpGlobals->curtime )
{
// guard against sudden clock changes
m_MenuRefreshTime = MIN( m_MenuRefreshTime, gpGlobals->curtime + MENU_UPDATETIME );
return;
}
m_MenuRefreshTime = gpGlobals->curtime + MENU_UPDATETIME;
if ( m_pCurrentMenu )
m_pCurrentMenu->Display( this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::MenuInput( int iInput )
{
if ( m_pCurrentMenu )
{
return m_pCurrentMenu->Input( this, iInput );
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::MenuReset( void )
{
CSingleUserRecipientFilter user( this );
user.MakeReliable();
UserMessageBegin( user, "ShowMenu" );
WRITE_SHORT( 0 );
WRITE_CHAR( 0 ); // display time (-1 means unlimited)
WRITE_BYTE( false ); // is there more message to come? no
WRITE_STRING( "" );
MessageEnd();
Q_strncpy( m_MenuStringBuffer, "" , sizeof(m_MenuStringBuffer) );
m_MenuRefreshTime = m_MenuDisplayTime = 0;
m_pCurrentMenu = NULL;
};
//-----------------------------------------------------------------------------
// Purpose: Enables/disables tactical/map view for the player
// Input : bTactical - true == enable it
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ShowTacticalView( bool bTactical )
{
// TODO: Decide if we are going to keep the tactical view in TF2
if ( !inv_demo.GetBool() )
return;
m_bSwitchingView = true;
m_TFLocal.m_nInTacticalView = bTactical ? 1 : 0;
}
//-----------------------------------------------------------------------------
// returns true if we're in tactical view
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsInTacticalView( void ) const
{
return m_TFLocal.m_nInTacticalView;
}
int CBaseTFPlayer::UpdateTransmitState()
{
return SetTransmitState( FL_EDICT_FULLCHECK );
}
//-----------------------------------------------------------------------------
// Purpose: Note, an entity can override the send table ( e.g., to send less data or to send minimal data for
// objects ( prob. players ) that are not in the pvs.
// Input : **ppSendTable -
// *recipient -
// *pvs -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
int CBaseTFPlayer::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
// Don't transmit if we have no team or class
if ((PlayerClass() == TFCLASS_UNDECIDED) || (GetTeamNumber() == 0))
return FL_EDICT_DONTSEND;
// Thermal vision in effect, if so, cull some players who are too far away
CBaseTFPlayer *pPlayer = ( ( CBaseTFPlayer * )CBaseEntity::Instance( pInfo->m_pClientEnt ) );
if ( pPlayer )
{
if ( pPlayer->IsUsingThermalVision() )
{
// Do a radius check, and force sending of guys nearby (so we can see them through walls)
Vector dist = GetAbsOrigin() - pPlayer->GetAbsOrigin();
if ( dist.Length() < THERMAL_VISION_RADIUS )
return FL_EDICT_ALWAYS;
}
// If the player we might see is camouflaged and not on our team, we can preclude based
// on distance
if ( IsCamouflaged() && !InSameTeam( pPlayer ) )
{
Vector dist = GetAbsOrigin() - pPlayer->GetAbsOrigin();
if ( dist.Length() > CAMO_OUTER_RADIUS )
{
return FL_EDICT_ALWAYS;
}
}
}
// Use default pvs etc. rules
return BaseClass::ShouldTransmit( pInfo );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTechnologyTree *CBaseTFPlayer::GetTechTree( void )
{
CTFTeam *pTeam = GetTFTeam();
if ( pTeam )
return pTeam->m_pTechnologyTree;
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseTFPlayer::PlayerClass( void )
{
return m_iPlayerClass;
}
CPlayerClass *CBaseTFPlayer::GetPlayerClass()
{
return m_PlayerClasses.GetPlayerClass( PlayerClass() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetPreferredTechnology( CTechnologyTree *pTechnologyTree, int iTechIndex )
{
Assert( pTechnologyTree );
// Have to be on a team to vote for tech
CTFTeam *pTeam = GetTFTeam();
if ( !pTeam )
return;
if ( iTechIndex == -1 )
{
m_nPreferredTechnology = -1;
}
else
{
if ( iTechIndex < 0 || iTechIndex >= pTechnologyTree->GetNumberTechnologies() )
{
Msg( "%s tried to set voting preference to unknown technology index : %d\n",
GetPlayerName(), iTechIndex );
return;
}
CBaseTechnology *tech = pTechnologyTree->GetTechnology( iTechIndex );
if ( !tech )
return;
// Has the tech got incomplete dependancies?
if ( tech->HasInactiveDependencies() )
return;
// Already have it?
if ( tech->GetAvailable() )
return;
// Can't prefer a hidden tech
if ( tech->IsHidden() )
return;
m_nPreferredTechnology = iTechIndex;
}
pTeam->RecomputePreferences();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CBaseTFPlayer::GetPreferredTechnology( void )
{
return m_nPreferredTechnology;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::HasNamedTechnology( const char *name )
{
if ( GetTFTeam() == NULL )
return false;
return GetTFTeam()->HasNamedTechnology( name );
}
//-----------------------------------------------------------------------------
// Purpose: Networking is about to update this player, let it override and specify it's own pvs
// Input : **pvs -
// **pas -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize )
{
// Normal PVS
BaseClass::SetupVisibility( pViewEntity, pvs, pvssize );
// PVS has an additional origin
if ( m_vecAdditionalPVSOrigin != vec3_origin )
{
// Add an additional origin to the pvs
engine->AddOriginToPVS( m_vecAdditionalPVSOrigin );
}
if ( m_vecCameraPVSOrigin != vec3_origin )
{
engine->AddOriginToPVS( m_vecCameraPVSOrigin );
}
// If in tactical mode, merge in pvs from all of our teammates, too
// send all the others team info
if ( m_TFLocal.m_nInTacticalView )
{
int i;
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseTFPlayer *plr = ToBaseTFPlayer( UTIL_PlayerByIndex(i) );
if ( plr &&
( plr != this ) &&
( plr->TeamID() == TeamID() ) )
{
Vector org;
org = plr->EyePosition();
engine->AddOriginToPVS( org );
}
}
}
}
//--------------------------------------------------------------------------------------------------------------
// ORDERS
//-----------------------------------------------------------------------------
// Purpose: Assign the player to the specified order
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetOrder( COrder *pOrder )
{
if ( m_hSelectedOrder.Get() && m_hSelectedOrder != pOrder )
{
m_hSelectedOrder->SetOwner( NULL );
}
m_hSelectedOrder = pOrder;
}
int CBaseTFPlayer::GetNumResourceZoneOrders()
{
return GetTFTeam()->CountOrders( COUNTORDERS_TYPE | COUNTORDERS_OWNER, ORDER_ATTACK, 0, this ) +
GetTFTeam()->CountOrders( COUNTORDERS_TYPE | COUNTORDERS_OWNER, ORDER_DEFEND, 0, this ) +
GetTFTeam()->CountOrders( COUNTORDERS_TYPE | COUNTORDERS_OWNER, ORDER_CAPTURE, 0, this );
}
void CBaseTFPlayer::KillResourceZoneOrders()
{
if( GetNumResourceZoneOrders() )
GetTFTeam()->RemoveOrdersToPlayer( this );
}
//--------------------------------------------------------------------------------------------------------------
// DEPLOYMENT
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::StartDeploying( void )
{
if ( !GetPlayerClass() )
return;
m_bDeploying = true;
m_vecDeployedAngles = GetLocalAngles();
// No pitch or roll, though
m_vecDeployedAngles.SetX( 0 );
m_vecDeployedAngles.SetZ( 0 );
SetCantMove( true );
m_flFinishedDeploying = gpGlobals->curtime + GetPlayerClass()->GetDeployTime();
SetAnimation( PLAYER_START_AIMING );
EmitSound( "BaseTFPlayer.StartDeploying" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::StartUnDeploying( void )
{
if ( !GetPlayerClass() )
return;
m_bUnDeploying = true;
SetCantMove( true );
m_flFinishedDeploying = gpGlobals->curtime + GetPlayerClass()->GetDeployTime();
SetAnimation( PLAYER_LEAVE_AIMING );
EmitSound( "BaseTFPlayer.StartUnDeploying" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::CheckDeployFinish( void )
{
// Check to see if deployment has finished
if ( m_bDeploying )
{
if ( gpGlobals->curtime > m_flFinishedDeploying )
{
FinishDeploying();
}
return;
}
// Check to see if un-deployment has finished
if ( m_bUnDeploying )
{
if ( gpGlobals->curtime > m_flFinishedDeploying )
{
FinishUnDeploying();
}
return;
}
// Check to see if the player's trying to move while deployed
if ( IsAlive() && m_bDeployed )
{
if ( m_nButtons & (IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT ) )
{
StartUnDeploying();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::FinishDeploying( void )
{
m_bDeploying = false;
m_bDeployed = true;
SetCantMove( true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::FinishUnDeploying( void )
{
m_bUnDeploying = false;
m_bDeployed = false;
SetCantMove( false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsDeployed( void )
{
return m_bDeployed;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsDeploying( void )
{
return (m_bDeploying || m_bUnDeploying);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsUnDeploying( void )
{
return m_bUnDeploying;
}
void CBaseTFPlayer::OnVehicleStart()
{
// Do any class-specific stuff
if (GetPlayerClass())
{
GetPlayerClass()->OnVehicleStart();
}
IServerVehicle *pVehicle = GetVehicle();
CBaseCombatWeapon *weapon = GetActiveWeapon();
if ( pVehicle && weapon )
{
// Get Role for this player
int role = pVehicle->GetPassengerRole( this );
bool allowweapons = pVehicle->IsPassengerUsingStandardWeapons( role );
if ( !allowweapons )
{
weapon->Holster();
}
}
}
void CBaseTFPlayer::OnVehicleEnd( Vector &playerDestPosition )
{
// Do any class-specific stuff
if (GetPlayerClass())
{
GetPlayerClass()->OnVehicleEnd();
}
Vector vNewPos;
if ( !EntityPlacementTest( this, playerDestPosition, vNewPos, true) )
{
Warning("Can't find valid place to exit vehicle.\n");
return;
}
// Move the player up a bit to be safe
playerDestPosition = vNewPos + Vector(0,0,16);
CBaseCombatWeapon *weapon = GetActiveWeapon();
if ( weapon )
{
weapon->Deploy();
}
}
//--------------------------------------------------------------------------------------------------------------
// Purpose:
//--------------------------------------------------------------------------------------------------------------
bool CBaseTFPlayer::CanGetInVehicle( void )
{
// Class-specific?
if ( GetPlayerClass() )
{
return GetPlayerClass()->CanGetInVehicle();
}
return true;
}
CVehicleTeleportStation* CBaseTFPlayer::GetSelectedMCV() const
{
return dynamic_cast< CVehicleTeleportStation* >( m_hSelectedMCV.Get() );
}
void CBaseTFPlayer::SetSelectedMCV( CVehicleTeleportStation *pMCV )
{
m_hSelectedMCV = pMCV;
}
//-----------------------------------------------------------------------------
// Purpose: Restore this player's ammo count to it's starting state
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::ResupplyAmmo( float flPercentage, ResupplyReason_t reason )
{
if ( !GetPlayerClass() )
return false;
return GetPlayerClass()->ResupplyAmmo(flPercentage, reason);
}
//-----------------------------------------------------------------------------
// Purpose: Medic has provided this player with a health boost
//-----------------------------------------------------------------------------
void CBaseTFPlayer::TakeHealthBoost( int iHealthBoost, int iTarget, int iDuration )
{
m_iHealth += iHealthBoost;
m_iHealthBoostTarget = iTarget;
m_flHealthBoostDecrement = ceil((m_iHealth - iTarget) / (float)iDuration);
// Start the health ticking down
m_flHealthBoostTime = gpGlobals->curtime + 1.0;
if ( iTarget >= m_iMaxHealth )
{
m_bBuffHealthBoost = true;
}
}
//-----------------------------------------------------------------------------
// Purpose: Remove health buffs
//-----------------------------------------------------------------------------
void CBaseTFPlayer::RemoveHealthBoost( void )
{
m_bBuffHealthBoost = false;
m_iHealthBoostTarget = 0;
m_flHealthBoostTime = 0;
if ( m_iHealth > m_iMaxHealth )
{
m_iHealth = m_iMaxHealth;
}
}
//-----------------------------------------------------------------------------
// Purpose: Check the state of all buffs on this player
//-----------------------------------------------------------------------------
void CBaseTFPlayer::CheckBuffs( void )
{
// Health boost?
if ( m_bBuffHealthBoost )
{
// Dropped below normal max health?
if ( m_iHealth <= m_iHealthBoostTarget )
{
RemoveHealthBoost();
}
else
{
if ( m_flHealthBoostTime < gpGlobals->curtime )
{
// Ticking down from a boost? or suffering poison damage?
if ( m_iHealth > m_iMaxHealth )
{
// Drop back to normal health in 20 seconds
m_iHealth -= m_flHealthBoostDecrement;
}
m_flHealthBoostTime = gpGlobals->curtime + 1.0;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Powerup has just started
//-----------------------------------------------------------------------------
void CBaseTFPlayer::PowerupStart( int iPowerup, float flAmount, CBaseEntity *pAttacker, CDamageModifier *pDamageModifier )
{
Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS );
switch( iPowerup )
{
case POWERUP_BOOST:
{
m_hLastBoostEntity = pAttacker;
// Power up their shield
if ( GetCombatShield() )
{
GetCombatShield()->AddShieldHealth( 0.06 );
}
// Let their playerclass know
GetPlayerClass()->PowerupStart( iPowerup, flAmount, pAttacker, pDamageModifier );
}
break;
case POWERUP_EMP:
{
// Let the playerclass know about it
GetPlayerClass()->PowerupStart( iPowerup, flAmount, pAttacker, pDamageModifier );
}
break;
case POWERUP_RUSH:
{
// Speed up
// We need to set this here so RecalculateSpeed() can check HasPowerup(POWERUP_RUSH)
m_iPowerups |= (1 << iPowerup);
RecalculateSpeed();
}
break;
default:
break;
}
BaseClass::PowerupStart( iPowerup, flAmount, pAttacker, pDamageModifier );
}
//-----------------------------------------------------------------------------
// Purpose: Powerup has just started
//-----------------------------------------------------------------------------
void CBaseTFPlayer::PowerupEnd( int iPowerup )
{
switch( iPowerup )
{
case POWERUP_EMP:
{
GetPlayerClass()->PowerupEnd(iPowerup);
}
break;
case POWERUP_RUSH:
{
// Slow down
RecalculateSpeed();
}
break;
default:
break;
}
BaseClass::PowerupEnd( iPowerup );
}
//--------------------------------------------------------------------------------------------------------------
// OBJECTS
//-----------------------------------------------------------------------------
// Purpose: Return true if this player's allowed to build another one of the specified object
//-----------------------------------------------------------------------------
int CBaseTFPlayer::CanBuild( int iObjectType )
{
if ( iObjectType < 0 || iObjectType >= OBJ_LAST )
return CB_NOT_RESEARCHED;
if ( GetPlayerClass() )
{
return GetPlayerClass()->CanBuild( iObjectType );
}
return CB_NOT_RESEARCHED;
}
//-----------------------------------------------------------------------------
// Purpose: Get the number of objects of the specified type that this player has
//-----------------------------------------------------------------------------
int CBaseTFPlayer::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 CBaseTFPlayer::GetObjectCount( void )
{
return m_TFLocal.m_aObjects.Count();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseObject *CBaseTFPlayer::GetObject( int index )
{
return m_TFLocal.m_aObjects[index].Get();
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if this player is building something
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsBuilding( void )
{
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
return pBuilder->IsBuilding();
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Object built by this player has been destroyed
//-----------------------------------------------------------------------------
void CBaseTFPlayer::OwnedObjectDestroyed( CBaseObject *pObject )
{
TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseTFPlayer::OwnedObjectDestroyed player %s object %p:%s\n", gpGlobals->curtime,
GetPlayerName(),
pObject,
pObject->GetClassname() ) );
if ( GetPlayerClass() )
{
GetPlayerClass()->OwnedObjectDestroyed( pObject );
}
RemoveObject( pObject );
// Tell our builder weapon so it recalculates the state of the build icons
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
{
pBuilder->GainedNewTechnology( NULL );
}
}
//-----------------------------------------------------------------------------
// Removes an object from the player
//-----------------------------------------------------------------------------
void CBaseTFPlayer::RemoveObject( CBaseObject *pObject )
{
TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseTFPlayer::RemoveObject %p:%s from player %s\n", gpGlobals->curtime,
pObject,
pObject->GetClassname(),
GetPlayerName() ) );
Assert( pObject );
for (int i = m_TFLocal.m_aObjects.Count(); --i >= 0; )
{
// Also, while we're at it, remove all other bogus ones too...
if ((!m_TFLocal.m_aObjects[i].Get()) || (m_TFLocal.m_aObjects[i] == pObject))
{
m_TFLocal.m_aObjects.FastRemove(i);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject -
// *pNewOwner -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::OwnedObjectChangeTeam( CBaseObject *pObject, CBaseTFPlayer *pNewOwner )
{
TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseTFPlayer::OwnedObjectChangeTeam player %s object %p:%s new player %s\n", gpGlobals->curtime,
GetPlayerName(),
pObject,
pObject->GetClassname(),
pNewOwner->GetPlayerName() ) );
if ( pNewOwner && pNewOwner->GetPlayerClass() )
{
pNewOwner->GetPlayerClass()->OwnedObjectChangeFromTeam( pObject, this );
}
// Remove from my list of objects
RemoveObject( pObject );
// Add to new team
if ( pNewOwner )
{
pNewOwner->AddObject( pObject );
}
if ( GetPlayerClass() )
{
GetPlayerClass()->OwnedObjectChangeToTeam( pObject, pNewOwner );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pZone -
// Output : int
//-----------------------------------------------------------------------------
int CBaseTFPlayer::NumPumpsOnResourceZone( CResourceZone *pZone )
{
int ret = 0;
for( int iObj=0; iObj < GetObjectCount(); iObj++ )
{
CBaseObject *pObj = GetObject(iObj);
if( pObj->GetType() == OBJ_RESOURCEPUMP )
{
CObjectResourcePump *pPump = (CObjectResourcePump*)pObj;
// Ok, this guy already has a pump here.
if( pPump->GetResourceZone() == pZone )
++ret;
}
}
return ret;
}
//-----------------------------------------------------------------------------
// Purpose: Remove all the player's objects
// If bForceAll is set, remove all of them immediately.
// Otherwise, make them all deteriorate over time.
// If iClass is passed in, don't remove any objects that can be built
// by that class. If bReturnResources is set, the cost of any destroyed
// objects will be returned to the player.
//-----------------------------------------------------------------------------
void CBaseTFPlayer::RemoveAllObjects( bool bForceAll, int iClass, bool bReturnResources )
{
// Remove all the player's objects
int iSize = GetObjectCount();
for (int i = iSize-1; i >= 0; i--)
{
CBaseObject *obj = GetObject(i);
Assert( obj );
if ( !obj )
{
continue;
}
if ( !bForceAll )
{
if ( iClass )
{
// Can our new class build this object?
if ( ClassCanBuild( iClass, obj->GetType() ) )
continue;
}
// Vehicles don't deteriorate when their owner changes teams/leaves.
// They'll deteriorate naturally if they're unused for a while.
if ( IsObjectAVehicle(obj->GetType()) )
{
RemoveObject( obj );
// Just remove it from my list
obj->SetBuilder( NULL );
continue;
}
}
// Return the cost of the object?
if ( bReturnResources )
{
GetPlayerClass()->PickupObject( obj );
}
// Remove or deteriorate?
if ( bForceAll )
{
UTIL_Remove( obj );
}
else
{
OwnedObjectDestroyed( obj );
obj->StartDeteriorating();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::StopPlacement( void )
{
// Tell our builder weapon
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
{
pBuilder->StopPlacement();
}
}
//-----------------------------------------------------------------------------
// Purpose: Player has started building an object
//-----------------------------------------------------------------------------
int CBaseTFPlayer::StartedBuildingObject( int iObjectType )
{
// Tell our playerclass
if ( GetPlayerClass() )
return GetPlayerClass()->StartedBuildingObject( iObjectType );
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Player has aborted building something
//-----------------------------------------------------------------------------
void CBaseTFPlayer::StoppedBuilding( int iObjectType )
{
// Tell our playerclass
if ( GetPlayerClass() )
{
GetPlayerClass()->StoppedBuilding( iObjectType );
}
// Tell our builder weapon
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
{
pBuilder->StoppedBuilding( iObjectType );
}
}
//-----------------------------------------------------------------------------
// Purpose: Object has been built by this player
//-----------------------------------------------------------------------------
void CBaseTFPlayer::FinishedObject( CBaseObject *pObject )
{
AddObject( pObject );
// Tell our playerclass
if ( GetPlayerClass() )
{
GetPlayerClass()->FinishedObject( pObject );
}
// Tell our builder weapon
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
{
pBuilder->FinishedObject();
}
}
//-----------------------------------------------------------------------------
// Purpose: Add the specified object to this player's object list.
//-----------------------------------------------------------------------------
void CBaseTFPlayer::AddObject( CBaseObject *pObject )
{
TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseTFPlayer::AddObject adding object %p:%s to player %s\n", gpGlobals->curtime, pObject, pObject->GetClassname(), GetPlayerName() ) );
// Make a handle out of it
CHandle<CBaseObject> hObject;
hObject = pObject;
// Make sure it's not in the list already
bool alreadyInList = (m_TFLocal.m_aObjects.Find( hObject ) != -1);
Assert( !alreadyInList );
if ( !alreadyInList )
{
m_TFLocal.m_aObjects.AddToTail( hObject );
}
// Stop it deterioating, if it is
pObject->StopDeteriorating();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetWeaponBuilder( CWeaponBuilder *pBuilder )
{
m_hWeaponBuilder = pBuilder;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CWeaponBuilder *CBaseTFPlayer::GetWeaponBuilder( void )
{
return m_hWeaponBuilder;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *attacker -
// sourceDir -
// duration -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::KnockDownPlayer( const Vector& sourceDir, float magnitude, float duration )
{
// Already knocked down
if ( m_TFLocal.m_bKnockedDown )
return;
// In a vehicle
if ( IsInAVehicle() )
return;
m_TFLocal.m_bKnockedDown = true;
// Randomize it a bit
Vector jitter( 0, 0, 0 );
//jitter.Random( -0.1, 0.1 );
Vector dir = sourceDir + jitter;
VectorNormalize( dir );
Vector force = dir * magnitude;
ApplyAbsVelocityImpulse( force );
VectorAngles( dir, m_TFLocal.m_vecKnockDownDir.GetForModify() );
QAngle ang = GetAbsAngles();
Vector forward, right;
AngleVectors( ang, &forward, &right, NULL );
float dotFwd = dir.Dot( forward );
float dotRight = dir.Dot( right );
if ( dotFwd >= 0)
{
// if get hit from behind, pitch down a bit
m_TFLocal.m_vecKnockDownDir.SetX( dotFwd * 20.0f );
// look in the direction you fell
m_TFLocal.m_vecKnockDownDir.SetZ( dotRight * 80.0f );
}
else
{
//Invert knock yaw if hit from front, so you are looking straight up at the direction
// the hit cam efrom
m_TFLocal.m_vecKnockDownDir += QAngle( 0, 180, 0 );
// Look up in the air
m_TFLocal.m_vecKnockDownDir.SetX( fabs( dotFwd ) * -60.0f );
// And a bit to the side the hit came from
m_TFLocal.m_vecKnockDownDir.SetZ( dotRight * 20.0f );
}
m_flKnockdownEndTime = gpGlobals->curtime + duration;
// Play some kind of knockdown sound
EmitSound( "BaseTFPlayer.KnockedDown" );
if ( BecomeRagdollOnClient( force ) )
{
// We we are using ragdoll flight, then don't change underlying player
// velocity
ApplyAbsVelocityImpulse( -force );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ResetKnockdown( void )
{
// Don't get up if I'm dead
if ( IsAlive() )
{
if ( !ClearClientRagdoll( true ) )
return;
}
m_TFLocal.m_bKnockedDown = false;
m_TFLocal.m_vecKnockDownDir.Init();
m_flKnockdownEndTime = 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsKnockedDown( void )
{
return m_TFLocal.m_bKnockedDown;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::CheckKnockdown( void )
{
if ( !m_TFLocal.m_bKnockedDown )
return;
if ( gpGlobals->curtime < m_flKnockdownEndTime )
return;
// Remove knockdown
ResetKnockdown();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsGagged( void )
{
return m_bGagged;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : gag -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetGagged( bool gag )
{
m_bGagged = gag;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::CanSpeak( void )
{
return !IsGagged();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsUsingThermalVision( void )
{
return m_TFLocal.m_bThermalVision;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetIDEnt( CBaseEntity *pEntity )
{
if ( pEntity )
m_TFLocal.m_iIDEntIndex = pEntity->entindex();
else
m_TFLocal.m_iIDEntIndex = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : thermal -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetUsingThermalVision( bool thermal )
{
// Play sounds if we're changing
if ( m_TFLocal.m_bThermalVision != thermal )
{
if ( thermal )
{
EmitSound( "BaseTFPlayer.ThermalOn" );
}
else
{
EmitSound( "BaseTFPlayer.ThermalOff" );
}
}
m_TFLocal.m_bThermalVision = thermal;
}
//-----------------------------------------------------------------------------
// Purpose: Add the specified number of resource chunks to the player. Return true if he can carry it all.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::AddResourceChunks( int iChunks, bool bProcessed )
{
// Am I allowed to carry any more chunks?
int iCurrentCount = GetTotalResourceChunks();
// Somewhat hacky
int iIndex = GetAmmoDef()->Index("ResourceChunks");
int iMax = GetAmmoDef()->MaxCarry( iIndex );
if ( iCurrentCount >= iMax )
{
bool bSwapped = false;
// If this is a processed chunk, see if we can swap it for an unprocessed chunk
if ( bProcessed )
{
if ( m_TFLocal.m_iResourceAmmo[ NORMAL_RESOURCES ] )
{
// Drop this unprocessed chunk
Vector vecVelocity = Vector( random->RandomFloat( -250,250 ), random->RandomFloat( -250,250 ), random->RandomFloat( 200,450 ) );
CResourceChunk::Create( false, GetAbsOrigin() + Vector(0,0,32), vecVelocity );
RemoveResourceChunks( 1, false );
bSwapped = true;
}
}
if ( !bSwapped )
return false;
}
m_TFLocal.m_iResourceAmmo.Set( bProcessed, MIN( iMax, m_TFLocal.m_iResourceAmmo[ bProcessed ] + iChunks ) );
SetAmmoCount( GetTotalResourceChunks(), iIndex );
CPASAttenuationFilter filter( this,"BaseTFPlayer.PickupResources" );
EmitSound( filter, entindex(),"BaseTFPlayer.PickupResources" );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Remove the specified number of resources chunks from the player.
//-----------------------------------------------------------------------------
void CBaseTFPlayer::RemoveResourceChunks( int iChunks, bool bProcessed )
{
// Remove the amount
m_TFLocal.m_iResourceAmmo.Set( bProcessed, MAX( 0, m_TFLocal.m_iResourceAmmo[ bProcessed ] - iChunks ) );
int iIndex = GetAmmoDef()->Index("ResourceChunks");
SetAmmoCount( GetTotalResourceChunks(), iIndex );
}
//-----------------------------------------------------------------------------
// Purpose: Get the number of resource chunks of this type the player's carrying
//-----------------------------------------------------------------------------
int CBaseTFPlayer::GetResourceChunkCount( bool bProcessed )
{
return m_TFLocal.m_iResourceAmmo[ bProcessed ];
}
//-----------------------------------------------------------------------------
// Purpose: Get the total number of resource chunks being carried by the player
//-----------------------------------------------------------------------------
int CBaseTFPlayer::GetTotalResourceChunks( void )
{
int iCurrentCount = 0;
for ( int i = 0; i < RESOURCE_TYPES; i++ )
{
iCurrentCount += m_TFLocal.m_iResourceAmmo[i];
}
return iCurrentCount;
}
//-----------------------------------------------------------------------------
// Purpose: Drop some resource chunks
//-----------------------------------------------------------------------------
void CBaseTFPlayer::DropAllResourceChunks( void )
{
Vector vecOrigin = GetAbsOrigin() + Vector(0,0,32);
TFStats()->IncrementTeamStat( GetTeamNumber(), TF_TEAM_STAT_RESOURCE_CHUNKS_DROPPED, resource_chunk_value.GetFloat() );
// Drop a resource chunk
Vector vecVelocity = Vector( random->RandomFloat( -250,250 ), random->RandomFloat( -250,250 ), random->RandomFloat( 200,450 ) );
CResourceChunk *pChunk = CResourceChunk::Create( FALSE, vecOrigin, vecVelocity );
pChunk->ChangeTeam( GetTeamNumber() );
}
//------------------------------------------------------------------------------------------------------------------
// RESOURCE BANK
//-----------------------------------------------------------------------------
// Purpose: Get the amount of a resource in this player's bank
//-----------------------------------------------------------------------------
int CBaseTFPlayer::GetBankResources( void )
{
return m_TFLocal.ResourceCount();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetBankResources( int iAmount )
{
int nOldAmount = m_TFLocal.ResourceCount();
TFStats()->IncrementPlayerStat( this, TF_PLAYER_STAT_RESOURCES_ACQUIRED, iAmount - nOldAmount );
m_TFLocal.SetResources( iAmount );
// Tell the player's builder weapon to update
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
{
pBuilder->GainedNewTechnology( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose: Add resources to this player's Bank
//-----------------------------------------------------------------------------
void CBaseTFPlayer::AddBankResources( int iAmount )
{
m_TFLocal.AddResources( iAmount );
// Tell the player's builder weapon to update
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
{
pBuilder->GainedNewTechnology( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose: Remove resources to this player's Bank
//-----------------------------------------------------------------------------
void CBaseTFPlayer::RemoveBankResources( int iAmount, bool bSpent )
{
m_TFLocal.RemoveResources( iAmount );
// Tell the player's builder weapon to update
CWeaponBuilder *pBuilder = GetWeaponBuilder();
if ( pBuilder )
{
pBuilder->GainedNewTechnology( NULL );
}
if (bSpent)
{
TFStats()->IncrementPlayerStat( this, TF_PLAYER_STAT_RESOURCES_SPENT, iAmount );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsCamouflaged( void )
{
return ( m_flCamouflageAmount > 0.0f ) ? true : false;
}
//-----------------------------------------------------------------------------
// Purpose: Change state over time
//-----------------------------------------------------------------------------
void CBaseTFPlayer::CheckCamouflage( void )
{
if ( m_flCamouflageAmount == m_flGoalCamouflageAmount )
return;
float remaining = m_flGoalCamouflageAmount - m_flCamouflageAmount;
float maxstep = m_flGoalCamouflageChangeRate * gpGlobals->frametime;
if ( remaining > 0.0f )
{
m_flCamouflageAmount += MIN( remaining, maxstep );
}
else
{
remaining = -remaining;
m_flCamouflageAmount -= MIN( remaining, maxstep );
}
m_flCamouflageAmount = MAX( 0.0f, m_flCamouflageAmount );
m_flCamouflageAmount = MIN( 100.0f, m_flCamouflageAmount );
}
//-----------------------------------------------------------------------------
// Purpose: Goal % and rate in percent/second to achieve the goal
// Input : percentage -
// changerate -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetCamouflaged( int percentage, float changerate )
{
m_flGoalCamouflageAmount = (float)percentage;
m_flGoalCamouflageChangeRate = changerate;
}
//-----------------------------------------------------------------------------
// Purpose: Remove the player's camo
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ClearCamouflage( void )
{
SetCamouflaged( 0, 1000 );
// Tell the playerclass
if ( GetPlayerClass() )
{
GetPlayerClass()->ClearCamouflage();
}
}
//-----------------------------------------------------------------------------
// Purpose: Confirm powerup durations
//-----------------------------------------------------------------------------
float CBaseTFPlayer::PowerupDuration( int iPowerup, float flTime )
{
// Medics are never EMPed for long
if ( PlayerClass() == TFCLASS_MEDIC && iPowerup == POWERUP_EMP )
return 0.2;
return BaseClass::PowerupDuration( iPowerup, flTime );
}
//-----------------------------------------------------------------------------
// Purpose: Return the player's anim speed multiplier. Used for speeding up viewmodels while rushed.
//-----------------------------------------------------------------------------
float CBaseTFPlayer::GetDefaultAnimSpeed( void )
{
if ( HasPowerup( POWERUP_RUSH ) )
return ADRENALIN_ANIM_SPEED;
// Weapons may modify animation times
if ( GetActiveWeapon() )
return GetActiveWeapon()->GetDefaultAnimSpeed();
return 1.0;
}
//-----------------------------------------------------------------------------
// Donate resources to a teammate
//-----------------------------------------------------------------------------
void CBaseTFPlayer::DonateResources( CBaseTFPlayer *pTarget, int pCount )
{
Assert( pTarget );
int nTotalCountDonated = 0;
int nDonationCount = GetBankResources();
if ( pCount < nDonationCount )
nDonationCount = pCount;
if (nDonationCount)
{
RemoveBankResources( nDonationCount, false );
pTarget->AddBankResources( nDonationCount );
nTotalCountDonated += nDonationCount;
}
if (nTotalCountDonated > 0)
{
char buf[1024];
Q_snprintf( buf, sizeof( buf ), "%s has donated %d resources to you\n",
GetPlayerName(), nTotalCountDonated );
ClientPrint( pTarget, HUD_PRINTCENTER, buf );
CSingleUserRecipientFilter filter( this );
EmitSound( filter, entindex(), "BaseTFPlayer.DonateResources" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Infilitrator's can +use a corpse to consume it
//-----------------------------------------------------------------------------
void CBaseTFPlayer::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( pActivator->IsPlayer() )
{
CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>(pActivator);
if ( InSameTeam( pActivator ))
{
// Resource donation
pPlayer->DonateResources( this, 25 );
}
}
BaseClass::Use( pActivator, pCaller, useType, value );
}
//-----------------------------------------------------------------------------
// The player's usable...
//-----------------------------------------------------------------------------
int CBaseTFPlayer::ObjectCaps( void )
{
return ( (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_IMPULSE_USE );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::CantMove( void )
{
return m_bCantMove;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetCantMove( bool bCantMove )
{
m_bCantMove = bCantMove;
RecalculateSpeed();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ResetViewOffset( void )
{
if ( GetPlayerClass() )
{
GetPlayerClass()->ResetViewOffset();
}
else
{
SetViewOffset( VEC_VIEW_SCALED( this ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: If ragdolling, move the player along the path that the ragdoll takes
//-----------------------------------------------------------------------------
void CBaseTFPlayer::FollowClientRagdoll( void )
{
if (( m_hRagdollShadow == NULL ) || ( GetPlayerClass() == NULL ))
return;
Vector vecMin, vecMax;
GetPlayerClass()->GetPlayerHull( ( ( GetFlags() & FL_DUCKING ) == 1 ), vecMin, vecMax );
// Follow shadow object
trace_t tr;
UTIL_TraceHull(
m_hRagdollShadow->GetAbsOrigin() + Vector(0,0,18),
m_hRagdollShadow->GetAbsOrigin(),
vecMin,
vecMax,
MASK_PLAYERSOLID,
m_hRagdollShadow,
COLLISION_GROUP_NONE,
&tr );
// Only move if we can find a valid spot under where shadow rolled
if ( !tr.allsolid )
{
UTIL_SetOrigin( this, tr.endpos );
VectorCopy( tr.endpos, m_vecLastGoodRagdollPos );
}
}
//-----------------------------------------------------------------------------
// Purpose: Stop being a ragdoll
// Input : moveplayertofinalspot -
// Output : return whether or not the ragdoll was cleared
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::ClearClientRagdoll( bool moveplayertofinalspot )
{
if ( m_hRagdollShadow )
{
if ( GetContainingEntity( edict() ) )
{
if ( moveplayertofinalspot )
{
// Move player to resting spot of shadow object
FollowClientRagdoll();
// Check for a valid standing position. If an entity is blocking impart some
// velocity to them and check again.
trace_t trace;
if ( CheckRagdollToStand( trace ) )
{
// Switch back to normal movement and kill off ragdoll bone setup on client
SetMoveType( MOVETYPE_WALK );
m_nRenderFX = kRenderFxNone;
//RemoveSolidFlags( FSOLID_NOTSOLID );
Assert( GetPlayerClass() != NULL );
Vector vecMin, vecMax;
GetPlayerClass()->GetPlayerHull( ( ( GetFlags() & FL_DUCKING ) == 1 ), vecMin, vecMax );
UTIL_SetSize( this, vecMin, vecMax );
}
else
{
CBaseEntity *pEntity = trace.m_pEnt;
if ( pEntity != GetContainingEntity( INDEXENT( 0 ) ) )
{
// Check for a physics object and apply force!
IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
if ( pPhysObject )
{
Vector vecDirection( random->RandomFloat( 0.0f, 1.0f ),
random->RandomFloat( 0.0f, 1.0f ),
random->RandomFloat( 0.0f, 1.0f ) );
vecDirection *= 40000.0f;
pPhysObject->ApplyForceCenter( vecDirection );
}
return false;
}
else
{
UTIL_SetOrigin( this, Vector( m_vecLastGoodRagdollPos.x, m_vecLastGoodRagdollPos.y, m_vecLastGoodRagdollPos.z + 18.0f ) );
return false;
}
}
}
}
// Kill the shadow object
UTIL_Remove( m_hRagdollShadow );
m_hRagdollShadow = NULL;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::CheckRagdollToStand( trace_t &trace )
{
Assert( GetPlayerClass() != NULL );
Vector vecMin, vecMax;
GetPlayerClass()->GetPlayerHull( ( ( GetFlags() & FL_DUCKING ) == 1 ), vecMin, vecMax );
// Write this better -- this is just a test to get things started.
UTIL_TraceHull(
m_vecLastGoodRagdollPos + Vector( 0, 0, 18 ),
m_vecLastGoodRagdollPos,
vecMin,
vecMax,
MASK_PLAYERSOLID,
m_hRagdollShadow,
COLLISION_GROUP_NONE,
&trace );
if ( !trace.allsolid )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Start being a ragdoll, creates client ragdoll object and server
// physics shadow object
// Input : &force -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::BecomeRagdollOnClient( const Vector &force )
{
// Defender doesn't support it yet
if ( PlayerClass() == TFCLASS_INFILTRATOR )
return false;
// Initialize the good ragdoll position.
VectorCopy( GetAbsOrigin(), m_vecLastGoodRagdollPos );
bool bret = BaseClass::BecomeRagdollOnClient( force );
// ROBIN: Disabled ragdoll shadows for now.
// We'll re-enable them if we need to know the end position again
// If we re-enable them, we need to fix the ragdoll shadow not having the correct mass
return bret;
AddSolidFlags( FSOLID_NOT_SOLID );
// Clear any old shadow object ( should never occur )
ClearClientRagdoll( false );
// Create new shadow object
m_hRagdollShadow = CRagdollShadow::Create( this, force );
return bret;
}
//=========================================================
// AddGesture - add a gesture into the animation queue
//=========================================================
int CBaseTFPlayer::AddGesture( Activity activity, bool autokill /*= true*/ )
{
int layer = BaseClass::AddGesture( activity, autokill );
SetLayerBlendIn( layer, 0.0 );
SetLayerBlendOut( layer, 0.0 );
return layer;
}
//-----------------------------------------------------------------------------
// Purpose: Class specific touch functionality!
//-----------------------------------------------------------------------------
void CBaseTFPlayer::ClassTouch( CBaseEntity *pTouched )
{
if ( m_pfnClassTouch && HasClass() )
{
(GetPlayerClass()->*m_pfnClassTouch)( pTouched );
}
}
const char* CBaseTFPlayer::GetClassModelString( int iClass, int iTeam )
{
return m_PlayerClasses.GetPlayerClass( iClass )->GetClassModelString( iTeam );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bRampage -
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetRampage( bool bRampage )
{
m_bRampage = bRampage;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseTFPlayer::IsInRampage( void )
{
return m_bRampage;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::SetPlayerClass( TFClass iClass )
{
if ( m_iPlayerClass != iClass )
{
m_Timer.End();
if ( m_iPlayerClass >= 0 && m_iPlayerClass < TFCLASS_CLASS_COUNT )
{
void AddPlayerClassTime( int classnum, float seconds );
AddPlayerClassTime( m_iPlayerClass, m_Timer.GetDuration().GetSeconds() );
}
}
if ( m_iPlayerClass >= 0 )
{
if ( GetPlayerClass() )
{
GetPlayerClass()->ClassDeactivate();
}
}
m_iPlayerClass = iClass;
if ( m_iPlayerClass >= 0 )
{
SetPlayerModel();
m_Timer.Start();
if ( GetPlayerClass() )
{
GetPlayerClass()->ClassActivate();
// Setup the class on initial spawn
GetPlayerClass()->CreateClass();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseTFPlayer::ClassCostAdjustment( ResupplyBuyType_t nType )
{
if ( m_iPlayerClass >= 0 )
{
return GetPlayerClass()->ClassCostAdjustment( nType );
}
return 0;
}
//=============================================================================
//
// Player Physics Shadow Code
//
class CPhysicsTFPlayerCallback : public IPhysicsPlayerControllerEvent
{
public:
int ShouldMoveTo( IPhysicsObject *pObject, const Vector &position )
{
CBaseTFPlayer *pPlayer = ( CBaseTFPlayer* )pObject->GetGameData();
if ( pPlayer->TouchedPhysics() )
{
return 0;
}
return 1;
}
};
static CPhysicsTFPlayerCallback TFPlayerCallback;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFPlayer::InitVCollision( void )
{
if ( GetPlayerClass() )
{
GetPlayerClass()->InitVCollision();
}
// Setup the HL2 specific callback.
if ( GetPhysicsController() )
{
GetPhysicsController()->SetEventHandler( &TFPlayerCallback );
}
}
//-----------------------------------------------------------------------------
// Purpose: Return the entity that should receive the score
//-----------------------------------------------------------------------------
CBasePlayer *CBaseTFPlayer::GetScorer( void )
{
return this;
}
//-----------------------------------------------------------------------------
// Purpose: Return the entity that should get assistance credit
//-----------------------------------------------------------------------------
CBasePlayer *CBaseTFPlayer::GetAssistant( void )
{
// If I'm in a vehicle, the builder gets credit
if ( IsInAVehicle() )
{
CBaseObject *pObject = dynamic_cast<CBaseObject*>( GetVehicle() );
if ( pObject )
{
CBasePlayer *pBuilder = pObject->GetBuilder();
if ( pBuilder && pBuilder != this )
return pBuilder;
}
}
// If I'm boosted, someone's getting the assist
if ( HasPowerup( POWERUP_BOOST ) && m_hLastBoostEntity.Get() )
{
// I may have boosted myself
if ( m_hLastBoostEntity.Get() != this )
{
if ( m_hLastBoostEntity->IsPlayer() )
return (CBasePlayer*)m_hLastBoostEntity.Get();
// If it's an object, give the builder the assist (i.e. buff station)
CBaseObject *pObject = dynamic_cast<CBaseObject*>( m_hLastBoostEntity.Get() );
if ( pObject )
{
CBasePlayer *pBuilder = pObject->GetBuilder();
if ( pBuilder && pBuilder != this )
return pBuilder;
}
}
}
return NULL;
}