diff options
Diffstat (limited to 'game/server/tf2/tf_player.cpp')
| -rw-r--r-- | game/server/tf2/tf_player.cpp | 3720 |
1 files changed, 3720 insertions, 0 deletions
diff --git a/game/server/tf2/tf_player.cpp b/game/server/tf2/tf_player.cpp new file mode 100644 index 0000000..6631454 --- /dev/null +++ b/game/server/tf2/tf_player.cpp @@ -0,0 +1,3720 @@ +//========= 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; +} |