1116 lines
26 KiB
C++
1116 lines
26 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Player for HL1.
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "tfc_player.h"
|
|
#include "tfc_gamerules.h"
|
|
#include "KeyValues.h"
|
|
#include "viewport_panel_names.h"
|
|
#include "client.h"
|
|
#include "team.h"
|
|
#include "weapon_tfcbase.h"
|
|
#include "tfc_client.h"
|
|
#include "tfc_mapitems.h"
|
|
#include "tfc_timer.h"
|
|
#include "tfc_engineer.h"
|
|
#include "tfc_team.h"
|
|
|
|
|
|
#define TFC_PLAYER_MODEL "models/player/pyro.mdl"
|
|
|
|
|
|
// -------------------------------------------------------------------------------- //
|
|
// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
|
|
// -------------------------------------------------------------------------------- //
|
|
|
|
class CTEPlayerAnimEvent : public CBaseTempEntity
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CTEPlayerAnimEvent, CBaseTempEntity );
|
|
DECLARE_SERVERCLASS();
|
|
|
|
CTEPlayerAnimEvent( const char *name ) : CBaseTempEntity( name )
|
|
{
|
|
}
|
|
|
|
CNetworkHandle( CBasePlayer, m_hPlayer );
|
|
CNetworkVar( int, m_iEvent );
|
|
CNetworkVar( int, m_nData );
|
|
};
|
|
|
|
IMPLEMENT_SERVERCLASS_ST_NOBASE( CTEPlayerAnimEvent, DT_TEPlayerAnimEvent )
|
|
SendPropEHandle( SENDINFO( m_hPlayer ) ),
|
|
SendPropInt( SENDINFO( m_iEvent ), Q_log2( PLAYERANIMEVENT_COUNT ) + 1, SPROP_UNSIGNED )
|
|
SendPropInt( SENDINFO( m_nData ), 32 )
|
|
END_SEND_TABLE()
|
|
|
|
static CTEPlayerAnimEvent g_TEPlayerAnimEvent( "PlayerAnimEvent" );
|
|
|
|
void TE_PlayerAnimEvent( CBasePlayer *pPlayer, PlayerAnimEvent_t event, int nData )
|
|
{
|
|
CPVSFilter filter( pPlayer->EyePosition() );
|
|
|
|
// The player himself doesn't need to be sent his animation events
|
|
// unless cs_showanimstate wants to show them.
|
|
if ( !ToolsEnabled() && ( cl_showanimstate.GetInt() == pPlayer->entindex() ) )
|
|
{
|
|
filter.RemoveRecipient( pPlayer );
|
|
}
|
|
|
|
g_TEPlayerAnimEvent.m_hPlayer = pPlayer;
|
|
g_TEPlayerAnimEvent.m_iEvent = event;
|
|
g_TEPlayerAnimEvent.m_nData = nData;
|
|
g_TEPlayerAnimEvent.Create( filter, 0 );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------------------- //
|
|
// Tables.
|
|
// -------------------------------------------------------------------------------- //
|
|
|
|
LINK_ENTITY_TO_CLASS( player, CTFCPlayer );
|
|
PRECACHE_REGISTER(player);
|
|
|
|
IMPLEMENT_SERVERCLASS_ST( CTFCPlayer, DT_TFCPlayer )
|
|
SendPropExclude( "DT_BaseAnimating", "m_flPoseParameter" ),
|
|
SendPropExclude( "DT_BaseAnimating", "m_flPlaybackRate" ),
|
|
SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
|
|
SendPropExclude( "DT_BaseEntity", "m_angRotation" ),
|
|
SendPropExclude( "DT_BaseAnimatingOverlay", "overlay_vars" ),
|
|
|
|
// cs_playeranimstate and clientside animation takes care of these on the client
|
|
SendPropExclude( "DT_ServerAnimationData" , "m_flCycle" ),
|
|
SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ),
|
|
|
|
SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 0), 11 ),
|
|
SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 1), 11 ),
|
|
|
|
SendPropDataTable( SENDINFO_DT( m_Shared ), &REFERENCE_SEND_TABLE( DT_TFCPlayerShared ) )
|
|
END_SEND_TABLE()
|
|
|
|
|
|
// -------------------------------------------------------------------------------- //
|
|
|
|
void cc_CreatePredictionError_f()
|
|
{
|
|
CBaseEntity *pEnt = CBaseEntity::Instance( 1 );
|
|
pEnt->SetAbsOrigin( pEnt->GetAbsOrigin() + Vector( 63, 0, 0 ) );
|
|
}
|
|
|
|
ConCommand cc_CreatePredictionError( "CreatePredictionError", cc_CreatePredictionError_f, "Create a prediction error", FCVAR_CHEAT );
|
|
|
|
|
|
CTFCPlayer::CTFCPlayer()
|
|
{
|
|
m_PlayerAnimState = CreatePlayerAnimState( this );
|
|
item_list = 0;
|
|
|
|
UseClientSideAnimation();
|
|
m_angEyeAngles.Init();
|
|
m_pCurStateInfo = NULL;
|
|
m_lifeState = LIFE_DEAD; // Start "dead".
|
|
|
|
SetViewOffset( TFC_PLAYER_VIEW_OFFSET );
|
|
|
|
SetContextThink( &CTFCPlayer::TFCPlayerThink, gpGlobals->curtime, "TFCPlayerThink" );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::TFCPlayerThink()
|
|
{
|
|
if ( m_pCurStateInfo && m_pCurStateInfo->pfnThink )
|
|
(this->*m_pCurStateInfo->pfnThink)();
|
|
|
|
SetContextThink( &CTFCPlayer::TFCPlayerThink, gpGlobals->curtime, "TFCPlayerThink" );
|
|
}
|
|
|
|
|
|
CTFCPlayer::~CTFCPlayer()
|
|
{
|
|
m_PlayerAnimState->Release();
|
|
}
|
|
|
|
|
|
CTFCPlayer *CTFCPlayer::CreatePlayer( const char *className, edict_t *ed )
|
|
{
|
|
CTFCPlayer::s_PlayerEdict = ed;
|
|
return (CTFCPlayer*)CreateEntityByName( className );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::PostThink()
|
|
{
|
|
BaseClass::PostThink();
|
|
|
|
QAngle angles = GetLocalAngles();
|
|
angles[PITCH] = 0;
|
|
SetLocalAngles( angles );
|
|
|
|
// Store the eye angles pitch so the client can compute its animation state correctly.
|
|
m_angEyeAngles = EyeAngles();
|
|
|
|
m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::Precache()
|
|
{
|
|
for ( int i=0; i < PC_LASTCLASS; i++ )
|
|
PrecacheModel( GetTFCClassInfo( i )->m_pModelName );
|
|
|
|
PrecacheScriptSound( "Player.Spawn" );
|
|
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::InitialSpawn( void )
|
|
{
|
|
BaseClass::InitialSpawn();
|
|
|
|
State_Enter( STATE_WELCOME );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::Spawn()
|
|
{
|
|
SetModel( GetTFCClassInfo( m_Shared.GetPlayerClass() )->m_pModelName );
|
|
|
|
SetMoveType( MOVETYPE_WALK );
|
|
m_iLegDamage = 0;
|
|
|
|
BaseClass::Spawn();
|
|
|
|
// Kind of lame, but CBasePlayer::Spawn resets a lot of the state that we initially want on.
|
|
// So if we're in the welcome state, call its enter function to reset
|
|
if ( m_Shared.State_Get() == STATE_WELCOME )
|
|
{
|
|
State_Enter_WELCOME();
|
|
}
|
|
|
|
// If they were dead, then they're respawning. Put them in the active state.
|
|
if ( m_Shared.State_Get() == STATE_DYING )
|
|
{
|
|
State_Transition( STATE_ACTIVE );
|
|
}
|
|
|
|
// If they're spawning into the world as fresh meat, give them items and stuff.
|
|
if ( m_Shared.State_Get() == STATE_ACTIVE )
|
|
{
|
|
EmitSound( "Player.Spawn" );
|
|
GiveDefaultItems();
|
|
}
|
|
}
|
|
|
|
|
|
void CTFCPlayer::ForceRespawn()
|
|
{
|
|
//TFCTODO: goldsrc tfc has a big function for this.. doing what I'm doing here may not work.
|
|
respawn( this, false );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::GiveDefaultItems()
|
|
{
|
|
switch( m_Shared.GetPlayerClass() )
|
|
{
|
|
case PC_HWGUY:
|
|
{
|
|
GiveNamedItem( "weapon_crowbar" );
|
|
|
|
GiveNamedItem( "weapon_minigun" );
|
|
GiveAmmo( 176, TFC_AMMO_SHELLS );
|
|
}
|
|
break;
|
|
|
|
case PC_PYRO:
|
|
{
|
|
GiveNamedItem( "weapon_crowbar" );
|
|
}
|
|
break;
|
|
|
|
case PC_ENGINEER:
|
|
{
|
|
GiveNamedItem( "weapon_spanner" );
|
|
GiveNamedItem( "weapon_super_shotgun" );
|
|
GiveAmmo( 20, TFC_AMMO_SHELLS );
|
|
}
|
|
break;
|
|
|
|
case PC_SCOUT:
|
|
{
|
|
GiveNamedItem( "weapon_crowbar" );
|
|
GiveNamedItem( "weapon_shotgun" );
|
|
GiveNamedItem( "weapon_nailgun" );
|
|
GiveAmmo( 25, TFC_AMMO_SHELLS );
|
|
GiveAmmo( 100, TFC_AMMO_NAILS );
|
|
}
|
|
break;
|
|
|
|
case PC_SNIPER:
|
|
{
|
|
GiveNamedItem( "weapon_crowbar" );
|
|
}
|
|
break;
|
|
|
|
case PC_SOLDIER:
|
|
{
|
|
GiveNamedItem( "weapon_crowbar" );
|
|
}
|
|
break;
|
|
|
|
case PC_DEMOMAN:
|
|
{
|
|
GiveNamedItem( "weapon_crowbar" );
|
|
}
|
|
break;
|
|
|
|
case PC_SPY:
|
|
{
|
|
GiveNamedItem( "weapon_knife" );
|
|
}
|
|
break;
|
|
|
|
case PC_MEDIC:
|
|
{
|
|
GiveNamedItem( "weapon_medikit" );
|
|
GiveNamedItem( "weapon_super_nailgun" );
|
|
GiveAmmo( 100, TFC_AMMO_NAILS );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CTFCPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
|
|
{
|
|
m_PlayerAnimState->DoAnimationEvent( event, nData );
|
|
TE_PlayerAnimEvent( this, event, nData ); // Send to any clients who can see this guy.
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Transition( TFCPlayerState newState )
|
|
{
|
|
State_Leave();
|
|
State_Enter( newState );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Enter( TFCPlayerState newState )
|
|
{
|
|
m_Shared.m_iPlayerState = newState;
|
|
m_pCurStateInfo = State_LookupInfo( newState );
|
|
|
|
// Initialize the new state.
|
|
if ( m_pCurStateInfo && m_pCurStateInfo->pfnEnterState )
|
|
(this->*m_pCurStateInfo->pfnEnterState)();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Leave()
|
|
{
|
|
if ( m_pCurStateInfo && m_pCurStateInfo->pfnLeaveState )
|
|
{
|
|
(this->*m_pCurStateInfo->pfnLeaveState)();
|
|
}
|
|
}
|
|
|
|
|
|
CPlayerStateInfo* CTFCPlayer::State_LookupInfo( TFCPlayerState state )
|
|
{
|
|
// This table MUST match the
|
|
static CPlayerStateInfo playerStateInfos[] =
|
|
{
|
|
{ STATE_ACTIVE, "STATE_ACTIVE", &CTFCPlayer::State_Enter_ACTIVE, NULL, NULL },
|
|
{ STATE_WELCOME, "STATE_WELCOME", &CTFCPlayer::State_Enter_WELCOME, NULL, NULL },
|
|
{ STATE_PICKINGTEAM, "STATE_PICKINGTEAM", &CTFCPlayer::State_Enter_PICKINGTEAM, NULL, NULL },
|
|
{ STATE_PICKINGCLASS, "STATE_PICKINGCLASS", &CTFCPlayer::State_Enter_PICKINGCLASS, NULL, NULL },
|
|
{ STATE_OBSERVER_MODE, "STATE_OBSERVER_MODE", &CTFCPlayer::State_Enter_OBSERVER_MODE, NULL, NULL },
|
|
{ STATE_DYING, "STATE_DYING", &CTFCPlayer::State_Enter_DYING, NULL, NULL }
|
|
};
|
|
|
|
for ( int i=0; i < ARRAYSIZE( playerStateInfos ); i++ )
|
|
{
|
|
if ( playerStateInfos[i].m_iPlayerState == state )
|
|
return &playerStateInfos[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Enter_WELCOME()
|
|
{
|
|
SetMoveType( MOVETYPE_NONE );
|
|
AddEffects( EF_NODRAW );
|
|
AddSolidFlags( FSOLID_NOT_SOLID );
|
|
PhysObjectSleep();
|
|
|
|
// Show info panel (if it's not a simple demo map).
|
|
KeyValues *data = new KeyValues("data");
|
|
data->SetString( "title", "Message of the Day" ); // info panel title
|
|
data->SetString( "type", "3" ); // show a file
|
|
data->SetString( "msg", "motd.txt" ); // this file
|
|
data->SetString( "cmd", "joingame" ); // exec this command if panel closed
|
|
|
|
ShowViewPortPanel( "info", true, data );
|
|
|
|
data->deleteThis();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Enter_PICKINGTEAM()
|
|
{
|
|
ShowViewPortPanel( PANEL_TEAM ); // show the team menu
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Enter_PICKINGCLASS()
|
|
{
|
|
// go to spec mode, if dying keep deathcam
|
|
if ( GetObserverMode() == OBS_MODE_DEATHCAM )
|
|
{
|
|
StartObserverMode( OBS_MODE_DEATHCAM );
|
|
}
|
|
else
|
|
{
|
|
StartObserverMode( OBS_MODE_ROAMING );
|
|
}
|
|
|
|
PhysObjectSleep();
|
|
|
|
// show the class menu:
|
|
ShowViewPortPanel( PANEL_CLASS );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Enter_OBSERVER_MODE()
|
|
{
|
|
StartObserverMode( m_iObserverLastMode );
|
|
PhysObjectSleep();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Enter_ACTIVE()
|
|
{
|
|
SetMoveType( MOVETYPE_WALK );
|
|
RemoveEffects( EF_NODRAW );
|
|
RemoveSolidFlags( FSOLID_NOT_SOLID );
|
|
m_Local.m_iHideHUD = 0;
|
|
PhysObjectWake();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::State_Enter_DYING()
|
|
{
|
|
SetMoveType( MOVETYPE_NONE );
|
|
AddSolidFlags( FSOLID_NOT_SOLID );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::PhysObjectSleep()
|
|
{
|
|
IPhysicsObject *pObj = VPhysicsGetObject();
|
|
if ( pObj )
|
|
pObj->Sleep();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::PhysObjectWake()
|
|
{
|
|
IPhysicsObject *pObj = VPhysicsGetObject();
|
|
if ( pObj )
|
|
pObj->Wake();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::HandleCommand_JoinTeam( const char *pTeamName )
|
|
{
|
|
int iTeam = TEAM_RED;
|
|
if ( stricmp( pTeamName, "auto" ) == 0 )
|
|
{
|
|
iTeam = RandomInt( 0, 1 ) ? TEAM_RED : TEAM_BLUE;
|
|
}
|
|
else if ( stricmp( pTeamName, "spectate" ) == 0 )
|
|
{
|
|
iTeam = TEAM_SPECTATOR;
|
|
}
|
|
else
|
|
{
|
|
for ( int i=0; i < TEAM_MAXCOUNT; i++ )
|
|
{
|
|
if ( stricmp( pTeamName, teamnames[i] ) == 0 )
|
|
{
|
|
iTeam = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( iTeam == TEAM_SPECTATOR )
|
|
{
|
|
// Prevent this is the cvar is set
|
|
if ( !mp_allowspectators.GetInt() && !IsHLTV() )
|
|
{
|
|
ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Be_Spectator" );
|
|
return;
|
|
}
|
|
|
|
if ( GetTeamNumber() != TEAM_UNASSIGNED && !IsDead() )
|
|
{
|
|
CommitSuicide();
|
|
|
|
// add 1 to frags to balance out the 1 subtracted for killing yourself
|
|
IncrementFragCount( 1 );
|
|
}
|
|
|
|
ChangeTeam( TEAM_SPECTATOR );
|
|
|
|
// do we have fadetoblack on? (need to fade their screen back in)
|
|
if ( mp_fadetoblack.GetInt() )
|
|
{
|
|
color32_s clr = { 0,0,0,0 };
|
|
UTIL_ScreenFade( this, clr, 0.001, 0, FFADE_IN );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ChangeTeam( iTeam );
|
|
State_Transition( STATE_PICKINGCLASS );
|
|
}
|
|
}
|
|
|
|
|
|
void CTFCPlayer::ChangeTeam( int iTeamNum )
|
|
{
|
|
if ( !GetGlobalTeam( iTeamNum ) )
|
|
{
|
|
Warning( "CCSPlayer::ChangeTeam( %d ) - invalid team index.\n", iTeamNum );
|
|
return;
|
|
}
|
|
|
|
int iOldTeam = GetTeamNumber();
|
|
|
|
// if this is our current team, just abort
|
|
if ( iTeamNum == iOldTeam )
|
|
return;
|
|
|
|
BaseClass::ChangeTeam( iTeamNum );
|
|
|
|
if ( iTeamNum == TEAM_UNASSIGNED )
|
|
{
|
|
State_Transition( STATE_OBSERVER_MODE );
|
|
}
|
|
else if ( iTeamNum == TEAM_SPECTATOR )
|
|
{
|
|
State_Transition( STATE_OBSERVER_MODE );
|
|
}
|
|
else // active player
|
|
{
|
|
if ( iOldTeam == TEAM_SPECTATOR )
|
|
{
|
|
// If they're switching from being a spectator to ingame player
|
|
GetIntoGame();
|
|
}
|
|
|
|
if ( !IsDead() && iOldTeam != TEAM_UNASSIGNED )
|
|
{
|
|
// Kill player if switching teams while alive
|
|
CommitSuicide();
|
|
}
|
|
|
|
// Put up the class selection menu.
|
|
State_Transition( STATE_PICKINGCLASS );
|
|
}
|
|
}
|
|
|
|
|
|
void CTFCPlayer::HandleCommand_JoinClass( const char *pClassName )
|
|
{
|
|
int iClass = RandomInt( 0, PC_LAST_NORMAL_CLASS );
|
|
if ( stricmp( pClassName, "random" ) != 0 )
|
|
{
|
|
for ( int i=0; i < PC_LASTCLASS; i++ )
|
|
{
|
|
if ( stricmp( pClassName, GetTFCClassInfo( i )->m_pClassName ) == 0 )
|
|
{
|
|
iClass = i;
|
|
break;
|
|
}
|
|
}
|
|
if ( i == PC_LAST_NORMAL_CLASS )
|
|
{
|
|
Warning( "HandleCommand_JoinClass( %s ) - invalid class name.\n", pClassName );
|
|
}
|
|
}
|
|
|
|
m_Shared.SetPlayerClass( iClass );
|
|
|
|
if ( !IsAlive() )
|
|
GetIntoGame();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::GetIntoGame()
|
|
{
|
|
State_Transition( STATE_ACTIVE );
|
|
Spawn();
|
|
}
|
|
|
|
|
|
bool CTFCPlayer::ClientCommand( const CCommand& args )
|
|
{
|
|
const char *pcmd = args[0];
|
|
if ( FStrEq( pcmd, "joingame" ) )
|
|
{
|
|
// player just closed MOTD dialog
|
|
if ( m_Shared.m_iPlayerState == STATE_WELCOME )
|
|
{
|
|
State_Transition( STATE_PICKINGTEAM );
|
|
}
|
|
return true;
|
|
}
|
|
else if ( FStrEq( pcmd, "jointeam" ) )
|
|
{
|
|
if ( args.ArgC() >= 2 )
|
|
{
|
|
HandleCommand_JoinTeam( args[1] );
|
|
return true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pcmd, "joinclass" ) )
|
|
{
|
|
if ( args.ArgC() < 2 )
|
|
{
|
|
Warning( "Player sent bad joinclass syntax\n" );
|
|
}
|
|
|
|
HandleCommand_JoinClass( args[1] );
|
|
return true;
|
|
}
|
|
|
|
return BaseClass::ClientCommand( args );
|
|
}
|
|
|
|
|
|
bool CTFCPlayer::IsAlly( CBaseEntity *pEnt ) const
|
|
{
|
|
return pEnt->GetTeamNumber() == GetTeamNumber();
|
|
}
|
|
|
|
|
|
void CTFCPlayer::TF_AddFrags( int nFrags )
|
|
{
|
|
// TFCTODO: implement frags
|
|
}
|
|
|
|
|
|
void CTFCPlayer::ResetMenu()
|
|
{
|
|
current_menu = 0;
|
|
}
|
|
|
|
|
|
int CTFCPlayer::GetNumFlames() const
|
|
{
|
|
// TFCTODO: implement flames
|
|
return 0;
|
|
}
|
|
|
|
|
|
void CTFCPlayer::SetNumFlames( int nFlames )
|
|
{
|
|
// TFCTODO: implement frags
|
|
Assert( 0 );
|
|
}
|
|
|
|
int CTFCPlayer::TakeHealth( float flHealth, int bitsDamageType )
|
|
{
|
|
int bResult = false;
|
|
|
|
// If the bit's set, ignore the monster's max health and add over it
|
|
if ( bitsDamageType & DMG_IGNORE_MAXHEALTH )
|
|
{
|
|
int iDamage = g_pGameRules->Damage_GetTimeBased();
|
|
m_bitsDamageType &= ~(bitsDamageType & ~iDamage);
|
|
m_iHealth += flHealth;
|
|
bResult = true;
|
|
}
|
|
else
|
|
{
|
|
bResult = BaseClass::TakeHealth( flHealth, bitsDamageType );
|
|
}
|
|
|
|
// Leg Healing
|
|
if (m_iLegDamage > 0)
|
|
{
|
|
// Allow even at full health
|
|
if ( GetHealth() >= (GetMaxHealth() - 5))
|
|
m_iLegDamage = 0;
|
|
else
|
|
m_iLegDamage -= (GetHealth() + flHealth) / 20;
|
|
if (m_iLegDamage < 1)
|
|
m_iLegDamage = 0;
|
|
|
|
TeamFortress_SetSpeed();
|
|
bResult = true;
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
void CTFCPlayer::TeamFortress_SetSpeed()
|
|
{
|
|
int playerclass = m_Shared.GetPlayerClass();
|
|
float maxfbspeed;
|
|
|
|
// Spectators can move while in Classic Observer mode
|
|
if ( IsObserver() )
|
|
{
|
|
if ( GetObserverMode() == OBS_MODE_ROAMING )
|
|
SetMaxSpeed( GetTFCClassInfo( PC_SCOUT )->m_flMaxSpeed );
|
|
else
|
|
SetMaxSpeed( 0 );
|
|
|
|
return;
|
|
}
|
|
|
|
// Check for any reason why they can't move at all
|
|
if ( (m_Shared.GetStateFlags() & TFSTATE_CANT_MOVE) || (playerclass == PC_UNDEFINED) )
|
|
{
|
|
SetAbsVelocity( vec3_origin );
|
|
SetMaxSpeed( 1 );
|
|
return;
|
|
}
|
|
|
|
// First, get their max class speed
|
|
maxfbspeed = GetTFCClassInfo( playerclass )->m_flMaxSpeed;
|
|
|
|
// 2nd, see if any GoalItems are slowing them down
|
|
CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, "item_tfgoal" );
|
|
while ( pEnt )
|
|
{
|
|
CTFGoal *pGoal = dynamic_cast<CTFGoal*>( pEnt );
|
|
if ( pGoal )
|
|
{
|
|
if ( pGoal->GetOwnerEntity() == this )
|
|
{
|
|
if (pGoal->goal_activation & TFGI_SLOW)
|
|
{
|
|
maxfbspeed = maxfbspeed / 2;
|
|
}
|
|
else if (pGoal->speed_reduction)
|
|
{
|
|
float flPercent = ((float)pGoal->speed_reduction) / 100.0;
|
|
maxfbspeed = flPercent * maxfbspeed;
|
|
}
|
|
}
|
|
}
|
|
|
|
pEnt = gEntList.FindEntityByClassname( pEnt, "item_tfgoal" );
|
|
}
|
|
|
|
// 3rd, See if they're tranquilised
|
|
if (m_Shared.GetStateFlags() & TFSTATE_TRANQUILISED)
|
|
{
|
|
maxfbspeed = maxfbspeed / 2;
|
|
}
|
|
|
|
// 4th, check for leg wounds
|
|
if (m_iLegDamage)
|
|
{
|
|
if (m_iLegDamage > 6)
|
|
m_iLegDamage = 6;
|
|
|
|
// reduce speed by 10% per leg wound
|
|
maxfbspeed = (maxfbspeed * ((10 - m_iLegDamage) / 10));
|
|
}
|
|
|
|
// 5th, if they're a sniper, and they're aiming, their speed must be 80 or less
|
|
if (m_Shared.GetStateFlags() & TFSTATE_AIMING)
|
|
{
|
|
if (maxfbspeed > 80)
|
|
maxfbspeed = 80;
|
|
}
|
|
|
|
// Set the speed
|
|
SetMaxSpeed( maxfbspeed );
|
|
}
|
|
|
|
|
|
void CTFCPlayer::Event_Killed( const CTakeDamageInfo &info )
|
|
{
|
|
DoAnimationEvent( PLAYERANIMEVENT_DIE );
|
|
State_Transition( STATE_DYING ); // Transition into the dying state.
|
|
|
|
// Remove all items..
|
|
RemoveAllItems( true );
|
|
|
|
BaseClass::Event_Killed( info );
|
|
|
|
// Don't overflow the value for this.
|
|
m_iHealth = 0;
|
|
}
|
|
|
|
|
|
void CTFCPlayer::ClientHearVox( const char *pSentence )
|
|
{
|
|
//TFCTODO: implement this.
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Check all stats to make sure they're good for this class
|
|
void CTFCPlayer::TeamFortress_CheckClassStats()
|
|
{
|
|
// Check armor
|
|
if (armortype > armor_allowed)
|
|
armortype = armor_allowed;
|
|
|
|
if (ArmorValue() > GetClassInfo()->m_iMaxArmor)
|
|
SetArmorValue( GetClassInfo()->m_iMaxArmor );
|
|
|
|
if (ArmorValue() < 0)
|
|
SetArmorValue( 0 );
|
|
|
|
if (armortype < 0)
|
|
armortype = 0;
|
|
|
|
// Check ammo
|
|
for ( int iAmmoType=0; iAmmoType < TFC_NUM_AMMO_TYPES; iAmmoType++ )
|
|
{
|
|
if ( GetAmmoCount( iAmmoType ) > GetClassInfo()->m_MaxAmmo[iAmmoType] )
|
|
RemoveAmmo( GetAmmoCount( iAmmoType ) - GetClassInfo()->m_MaxAmmo[iAmmoType], iAmmoType );
|
|
}
|
|
|
|
// Check Grenades
|
|
Assert( GetAmmoCount( TFC_AMMO_GRENADES1 ) >= 0 );
|
|
Assert( GetAmmoCount( TFC_AMMO_GRENADES2 ) >= 0 );
|
|
|
|
// Limit Nails
|
|
if ( no_grenades_1() > g_nMaxGrenades[tp_grenades_1()] )
|
|
RemoveAmmo( TFC_AMMO_GRENADES1, no_grenades_1() - g_nMaxGrenades[tp_grenades_1()] );
|
|
|
|
if ( no_grenades_2() > g_nMaxGrenades[tp_grenades_2()] )
|
|
RemoveAmmo( TFC_AMMO_GRENADES2, no_grenades_2() - g_nMaxGrenades[tp_grenades_2()] );
|
|
|
|
// Check health
|
|
if (GetHealth() > GetMaxHealth() && !(m_Shared.GetItemFlags() & IT_SUPERHEALTH))
|
|
SetHealth( GetMaxHealth() );
|
|
|
|
if (GetHealth() < 0)
|
|
SetHealth( 0 );
|
|
|
|
// Update armor picture
|
|
m_Shared.RemoveItemFlags( IT_ARMOR1 | IT_ARMOR2 | IT_ARMOR3 );
|
|
if (armortype >= 0.8)
|
|
m_Shared.AddItemFlags( IT_ARMOR3 );
|
|
else if (armortype >= 0.6)
|
|
m_Shared.AddItemFlags( IT_ARMOR2 );
|
|
else if (armortype >= 0.3)
|
|
m_Shared.AddItemFlags( IT_ARMOR1 );
|
|
}
|
|
|
|
|
|
//======================================================================
|
|
// DISGUISE HANDLING
|
|
//======================================================================
|
|
// Reset spy skin and color or remove invisibility
|
|
void CTFCPlayer::Spy_RemoveDisguise()
|
|
{
|
|
if (m_Shared.GetPlayerClass() == PC_SPY)
|
|
{
|
|
if ( undercover_team || undercover_skin )
|
|
ClientPrint( this, HUD_PRINTCENTER, "#Disguise_Lost" );
|
|
|
|
// Set their color
|
|
undercover_team = 0;
|
|
undercover_skin = 0;
|
|
|
|
immune_to_check = gpGlobals->curtime + 10;
|
|
is_undercover = 0;
|
|
|
|
// undisguise weapon
|
|
TeamFortress_SetSkin();
|
|
TeamFortress_SpyCalcName();
|
|
|
|
Spy_ResetExternalWeaponModel();
|
|
|
|
// get them out of any disguise menus
|
|
if ( current_menu == MENU_SPY || current_menu == MENU_SPY_SKIN || current_menu == MENU_SPY_COLOR )
|
|
{
|
|
ResetMenu();
|
|
}
|
|
|
|
// Remove the Disguise timer
|
|
CTimer *pTimer = Timer_FindTimer( this, TF_TIMER_DISGUISE );
|
|
if (pTimer)
|
|
{
|
|
ClientPrint( this, HUD_PRINTCENTER, "#Disguise_stop" );
|
|
Timer_Remove( pTimer );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// when the spy loses disguise reset his weapon
|
|
void CTFCPlayer::Spy_ResetExternalWeaponModel( void )
|
|
{
|
|
// we don't show any weapon models if we're feigning
|
|
if ( is_feigning )
|
|
return;
|
|
|
|
#ifdef TFCTODO // spy
|
|
pev->weaponmodel = MAKE_STRING( m_pszSavedWeaponModel );
|
|
strcpy( m_szAnimExtention, m_szSavedAnimExtention );
|
|
m_iCurrentAnimationState = 0; // force the current animation sequence to be recalculated
|
|
#endif
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Try and find the player's name who's skin and team closest fit the
|
|
// current disguise of the spy
|
|
void CTFCPlayer::TeamFortress_SpyCalcName()
|
|
{
|
|
CBaseEntity *last_target = undercover_target;// don't redisguise self as this person
|
|
|
|
undercover_target = NULL;
|
|
|
|
// Find a player on the team the spy is disguised as to pretend to be
|
|
if (undercover_team != 0)
|
|
{
|
|
CTFCPlayer *pPlayer = NULL;
|
|
|
|
// Loop through players
|
|
int i;
|
|
for ( i = 1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
pPlayer = ToTFCPlayer( UTIL_PlayerByIndex( i ) );
|
|
if ( pPlayer )
|
|
{
|
|
if ( pPlayer == last_target )
|
|
{
|
|
// choose someone else, we're trying to rid ourselves of a disguise as this one
|
|
continue;
|
|
}
|
|
|
|
// First, try to find a player with same color and skins
|
|
if (pPlayer->GetTeamNumber() == undercover_team && pPlayer->m_Shared.GetPlayerClass() == undercover_skin)
|
|
{
|
|
undercover_target = pPlayer;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( i = 1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
pPlayer = ToTFCPlayer( UTIL_PlayerByIndex( i ) );
|
|
|
|
if ( pPlayer )
|
|
{
|
|
if (pPlayer->GetTeamNumber() == undercover_team)
|
|
{
|
|
undercover_target = pPlayer;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Set the skin of a player based on his/her class
|
|
void CTFCPlayer::TeamFortress_SetSkin()
|
|
{
|
|
immune_to_check = gpGlobals->curtime + 10;
|
|
|
|
// Find out whether we should show our actual class or a disguised class
|
|
int iClassToUse = m_Shared.GetPlayerClass();
|
|
if (iClassToUse == PC_SPY && undercover_skin != 0)
|
|
iClassToUse = undercover_skin;
|
|
|
|
int iTeamToUse = GetTeamNumber();
|
|
if (m_Shared.GetPlayerClass() == PC_SPY && undercover_team != 0)
|
|
iTeamToUse = undercover_team;
|
|
|
|
// TFCTODO: handle replacement_model here.
|
|
|
|
SetModel( GetTFCClassInfo( iClassToUse )->m_pModelName );
|
|
|
|
// Skins in the models should be setup using the team IDs in tfc_shareddefs.h, subtracting 1
|
|
// so they're 0-based.
|
|
m_nSkin = iTeamToUse - 1;
|
|
|
|
if ( FBitSet(GetFlags(), FL_DUCKING) )
|
|
UTIL_SetSize(this, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX);
|
|
else
|
|
UTIL_SetSize(this, VEC_HULL_MIN, VEC_HULL_MAX);
|
|
}
|
|
|
|
|
|
|
|
//=========================================================================
|
|
// Displays the state of the items specified by the Goal passed in
|
|
void CTFCPlayer::DisplayLocalItemStatus( CTFGoal *pGoal )
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (pGoal->display_item_status[i] != 0)
|
|
{
|
|
CTFGoalItem *pItem = Finditem(pGoal->display_item_status[i]);
|
|
if (pItem)
|
|
DisplayItemStatus(pGoal, this, pItem);
|
|
else
|
|
ClientPrint( this, HUD_PRINTTALK, "#Item_missing" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Removes all the Engineer's buildings
|
|
void CTFCPlayer::Engineer_RemoveBuildings()
|
|
{
|
|
// If the player's building already, stop
|
|
if (is_building == 1)
|
|
{
|
|
m_Shared.RemoveStateFlags( TFSTATE_CANT_MOVE );
|
|
TeamFortress_SetSpeed();
|
|
|
|
// Remove the timer
|
|
CTimer *pTimer = Timer_FindTimer( this, TF_TIMER_BUILD );
|
|
if (pTimer)
|
|
Timer_Remove(pTimer);
|
|
|
|
// Remove the building
|
|
UTIL_Remove( building );
|
|
building = NULL;
|
|
is_building = 0;
|
|
|
|
// Stop Build Sound
|
|
StopSound( "Engineer.Building" );
|
|
//STOP_SOUND( ENT(pev), CHAN_STATIC, "weapons/building.wav" );
|
|
|
|
if ( GetActiveWeapon() )
|
|
GetActiveWeapon()->Deploy();
|
|
}
|
|
|
|
DestroyBuilding(this, "building_dispenser");
|
|
DestroyBuilding(this, "building_sentrygun");
|
|
DestroyTeleporter(this, BUILD_TELEPORTER_ENTRY);
|
|
DestroyTeleporter(this, BUILD_TELEPORTER_EXIT);
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Removes all grenades that persist for a period of time from the world
|
|
void CTFCPlayer::TeamFortress_RemoveLiveGrenades( void )
|
|
{
|
|
RemoveOwnedEnt( "tf_weapon_napalmgrenade" );
|
|
RemoveOwnedEnt( "tf_weapon_nailgrenade" );
|
|
RemoveOwnedEnt( "tf_weapon_gasgrenade" );
|
|
RemoveOwnedEnt( "tf_weapon_caltrop" );
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Removes all rockets the player has fired into the world
|
|
// (this prevents a team kill cheat where players would fire rockets
|
|
// then change teams to kill their own team)
|
|
void CTFCPlayer::TeamFortress_RemoveRockets( void )
|
|
{
|
|
RemoveOwnedEnt( "tf_rpg_rocket" );
|
|
RemoveOwnedEnt( "tf_ic_rocket" );
|
|
}
|
|
|
|
// removes the player's pipebombs with no explosions
|
|
void CTFCPlayer::RemovePipebombs( void )
|
|
{
|
|
CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, "tf_gl_pipebomb" );
|
|
while ( pEnt )
|
|
{
|
|
CTFCPlayer *pOwner = ToTFCPlayer( pEnt->GetOwnerEntity() );
|
|
if ( pOwner == this )
|
|
{
|
|
pOwner->m_iPipebombCount--;
|
|
pEnt->AddFlag( FL_KILLME );
|
|
}
|
|
|
|
pEnt = gEntList.FindEntityByClassname( pEnt, "tf_gl_pipebomb" );
|
|
}
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Stops the setting of the detpack
|
|
void CTFCPlayer::TeamFortress_DetpackStop( void )
|
|
{
|
|
CTimer *pTimer = Timer_FindTimer( this, TF_TIMER_DETPACKSET );
|
|
|
|
if (!pTimer)
|
|
return;
|
|
|
|
ClientPrint( this, HUD_PRINTNOTIFY, "#Detpack_retrieve" );
|
|
|
|
// Return the detpack
|
|
GiveAmmo( 1, TFC_AMMO_DETPACK );
|
|
Timer_Remove(pTimer);
|
|
|
|
// Release player
|
|
m_Shared.RemoveStateFlags( TFSTATE_CANT_MOVE );
|
|
is_detpacking = 0;
|
|
TeamFortress_SetSpeed();
|
|
|
|
// Return their weapon
|
|
if ( GetActiveWeapon() )
|
|
GetActiveWeapon()->Deploy();
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Removes any detpacks the player may have set
|
|
BOOL CTFCPlayer::TeamFortress_RemoveDetpacks( void )
|
|
{
|
|
// Remove all detpacks owned by the player
|
|
CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, "detpack" );
|
|
while ( pEnt )
|
|
{
|
|
// if the player owns this detpack, remove it
|
|
if ( pEnt->GetOwnerEntity() == this )
|
|
{
|
|
UTIL_Remove( pEnt );
|
|
return TRUE;
|
|
}
|
|
|
|
pEnt = gEntList.FindEntityByClassname( pEnt, "detpack" );
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//=========================================================================
|
|
// Remove all of an ent owned by this player
|
|
void CTFCPlayer::RemoveOwnedEnt( char *pEntName )
|
|
{
|
|
CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, pEntName );
|
|
while ( pEnt )
|
|
{
|
|
// if the player owns this entity, remove it
|
|
if ( pEnt->GetOwnerEntity() == this )
|
|
pEnt->AddFlag( FL_KILLME );
|
|
|
|
pEnt = gEntList.FindEntityByClassname( pEnt, pEntName );
|
|
}
|
|
}
|
|
|
|
|