BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/server/tf/tf_passtime_ball.cpp

1438 lines
42 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_passtime_ball.h"
#include "tf_passtime_logic.h"
#include "passtime_ballcontroller.h"
#include "passtime_convars.h"
#include "passtime_game_events.h"
#include "func_passtime_no_ball_zone.h"
#include "tf_shareddefs.h"
#include "tf_player.h"
#include "vcollide_parse.h"
#include "SpriteTrail.h"
#include "soundenvelope.h"
#include "soundent.h"
#include "tf_gamerules.h"
#include "inetchannelinfo.h"
#include "tf_gamestats.h"
#include "tf_team.h"
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
static const float s_flPickupDist = 1000.f;
static const float s_flBlockDist = 30.0f;
static const float s_flClearDist = 50.0f;
static const char *s_pHalloweenBallModel = "models/passtime/ball/passtime_ball_halloween.mdl";
//-----------------------------------------------------------------------------
static objectparams_t SBallVPhysicsObjectParams()
{
objectparams_t params = g_PhysDefaultObjectParams;
params.mass = tf_passtime_ball_mass.GetFloat();
params.dragCoefficient = tf_passtime_ball_drag_coefficient.GetFloat();
params.damping = tf_passtime_ball_damping_scale.GetFloat();
params.rotdamping = tf_passtime_ball_rotdamping_scale.GetFloat();
params.inertia = tf_passtime_ball_inertia_scale.GetFloat();
return params;
}
//-----------------------------------------------------------------------------
// CBallPlayerToucher exists because we need the ball to touch both players and
// triggers. If the ball has FSOLID_TRIGGER, it will touch players but not
// triggers. And if it doesn't have that, it will touch triggers but not players.
// So this is a hack (there's probably a right way to do this) so the ball can
// just be solid and touch triggers, and this will touch players.
class CBallPlayerToucher : public CBaseEntity
{
public:
DECLARE_CLASS( CBallPlayerToucher, CBaseEntity );
CBallPlayerToucher() : m_pBall( 0 ) {}
//-----------------------------------------------------------------------------
virtual void Spawn() OVERRIDE
{
// NOTE: this used to create its own vphysics sphere, but it turns out that
// the engine totally ignores it.
SetCollisionGroup( COLLISION_GROUP_PROJECTILE );
SetModelIndex( m_pBall->GetModelIndex() );
SetMoveType( MOVETYPE_NONE ); // DIFFERENT
m_takedamage = DAMAGE_NO;
SetNextThink( TICK_NEVER_THINK );
m_iHealth = 0;
m_iMaxHealth = 1;
VPhysicsInitNormal( SOLID_NONE, 0, false );
SetSolid( SOLID_VPHYSICS );
SetSolidFlags( FSOLID_TRIGGER );
SetMoveType( MOVETYPE_NONE ); // DIFFERENT
SetParent( m_pBall );
SetLocalOrigin( Vector( 0,0,0 ) );
SetLocalAngles( QAngle( 0,0,0 ) );
SetTransmitState( FL_EDICT_DONTSEND );
AddEffects( EF_NODRAW );
SetTouch( &CBallPlayerToucher::OnTouch );
}
//-----------------------------------------------------------------------------
bool ShouldCollide( int iCollisionGroup, int iContentsMask ) const OVERRIDE
{
NOTE_UNUSED( iContentsMask );
return iCollisionGroup == COLLISION_GROUP_PLAYER_MOVEMENT;
}
private:
friend class CPasstimeBall;
CPasstimeBall *m_pBall;
void OnTouch( CBaseEntity *pOther )
{
m_pBall->OnTouch( pOther );
}
};
LINK_ENTITY_TO_CLASS( _ballplayertoucher, CBallPlayerToucher );
//-----------------------------------------------------------------------------
IMPLEMENT_SERVERCLASS_ST( CPasstimeBall, DT_PasstimeBall )
SendPropInt(SENDINFO(m_iCollisionCount)),
SendPropEHandle(SENDINFO(m_hHomingTarget)),
SendPropEHandle(SENDINFO(m_hCarrier)),
SendPropEHandle(SENDINFO(m_hPrevCarrier)),
END_SEND_TABLE()
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( passtime_ball, CPasstimeBall );
PRECACHE_REGISTER( passtime_ball );
CTFPlayer *CPasstimeBall::GetCarrier() const { return m_hCarrier; }
CTFPlayer *CPasstimeBall::GetPrevCarrier() const { return m_hPrevCarrier; }
//-----------------------------------------------------------------------------
CPasstimeBall::CPasstimeBall()
{
m_bLeftOwner = false;
m_pHumLoop = 0;
m_pBeepLoop = 0;
m_pPlayerToucher = 0;
m_flLastTeamChangeTime = 0;
m_flBeginCarryTime = 0;
m_flIdleRespawnTime = 0;
m_bTrailActive = false;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::Precache()
{
PrecacheModel( "passtime/passtime_balltrail_red.vmt" );
PrecacheModel( "passtime/passtime_balltrail_blu.vmt" );
PrecacheModel( "passtime/passtime_balltrail_unassigned.vmt" );
if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
{
PrecacheModel( s_pHalloweenBallModel );
}
else
{
PrecacheModel( tf_passtime_ball_model.GetString() );
}
PrecacheScriptSound( "Passtime.BallSmack" );
PrecacheScriptSound( "Passtime.BallGet" );
PrecacheScriptSound( "Passtime.BallIdle" );
PrecacheScriptSound( "Passtime.BallHoming" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
CTFPlayer *CPasstimeBall::GetThrower() const
{
return m_hThrower.Get();
}
//-----------------------------------------------------------------------------
void CPasstimeBall::SetThrower( CTFPlayer *pPlayer )
{
m_hThrower = pPlayer;
if ( !pPlayer )
{
ChangeTeam( TEAM_UNASSIGNED );
}
else
{
ChangeTeam( pPlayer->GetTeamNumber() );
}
}
//-----------------------------------------------------------------------------
unsigned int CPasstimeBall::PhysicsSolidMaskForEntity() const
{
return MASK_PLAYERSOLID; // must include CONTENT_PLAYERCLIP
}
//-----------------------------------------------------------------------------
int CPasstimeBall::GetCollisionCount() const { return m_iCollisionCount; }
//-----------------------------------------------------------------------------
int CPasstimeBall::GetCarryDuration() const
{
return ( (m_flBeginCarryTime > 0) && (m_flBeginCarryTime < gpGlobals->curtime) )
? (gpGlobals->curtime - m_flBeginCarryTime)
: 0;
}
//-----------------------------------------------------------------------------
static const char *GetTrailEffectForTeam( int iTeam )
{
switch ( iTeam )
{
case TF_TEAM_RED: return "passtime/passtime_balltrail_red.vmt";
case TF_TEAM_BLUE: return "passtime/passtime_balltrail_blu.vmt";
default: return "passtime/passtime_balltrail_unassigned.vmt";
};
}
//-----------------------------------------------------------------------------
void CPasstimeBall::ChangeTeam( int iTeam )
{
// this isn't really the right place for this stats code, but its function
// is directly dependent on m_flLastTeamChangeTime so I wanted to keep it
// here to help avoid bugs creeping in.
// NOTE you can't rely on m_hCarrier being valid or correct here, the order
// of operations on calling ChangeTeam isn't stable between all the
// different places where it's called.
float flElapsedTimeOnThisTeam = gpGlobals->curtime - m_flLastTeamChangeTime;
if ( TFGameRules() && TFGameRules()->IsPasstimeMode() && g_pPasstimeLogic )
{
gamerules_roundstate_t state = TFGameRules()->State_Get();
if ( ((state == GR_STATE_RND_RUNNING) || (state == GR_STATE_STALEMATE) || (state == GR_STATE_TEAM_WIN)) && (flElapsedTimeOnThisTeam > 0) )
{
int nElapsedTimeOnThisTeam = MAX( 0, Float2Int( flElapsedTimeOnThisTeam ) );
if ( GetTeamNumber() == TEAM_UNASSIGNED )
{
CTF_GameStats.m_passtimeStats.summary.nBallNeutralSec += nElapsedTimeOnThisTeam;
}
else
{
CTF_GameStats.m_passtimeStats.summary.nTotalCarrySec += nElapsedTimeOnThisTeam;
}
CTFPlayer *pPlayer = GetThrower();
if ( !pPlayer ) pPlayer = GetCarrier(); // this happens when the round ends or player dies or something
if ( pPlayer )
{
CTFTeam *pPlayerTeam = GetGlobalTFTeam( pPlayer->GetTeamNumber() );
CTFTeam *pPlayerEnemyTeam = GetGlobalTFTeam( GetEnemyTeam( pPlayer->GetTeamNumber() ) );
// NOTE: if the ball carrier switches teams and suicides, this will incorrectly
// attribute the time to the wrong team, but I don't care.
if ( pPlayerTeam->GetFlagCaptures() > pPlayerEnemyTeam->GetFlagCaptures() )
{
CTF_GameStats.m_passtimeStats.summary.nTotalWinningTeamBallCarrySec += Float2Int( flElapsedTimeOnThisTeam );
}
else if ( pPlayerTeam->GetFlagCaptures() < pPlayerEnemyTeam->GetFlagCaptures() )
{
CTF_GameStats.m_passtimeStats.summary.nTotalLosingTeamBallCarrySec += Float2Int( flElapsedTimeOnThisTeam );
}
}
}
}
m_flLastTeamChangeTime = gpGlobals->curtime;
BaseClass::ChangeTeam( iTeam );
// teams: TEAM_UNASSIGNED, spectator, TF_TEAM_RED, TF_TEAM_BLUE
// skins: red, blu, unassigned
// NOTE: skins are in this order because we use the same model as the weapon viewmodel
// and m_bHasTeamSkins_Viewmodel expects them in this order
const int skinForTeam[] = { 2, 2, 0, 1 };
iTeam = GetTeamNumber(); // paranoia; set by BaseClass::ChangeTeam
Assert( iTeam >= 0 && iTeam < 4 );
if ( iTeam >= 0 && iTeam < 4 ) // paranoia
{
m_nSkin = skinForTeam[iTeam];
}
if ( m_bTrailActive )
{
const char *pszTrailEffectName = GetTrailEffectForTeam( iTeam );
m_pTrail->SetModel( pszTrailEffectName );
}
if ( iTeam == TEAM_UNASSIGNED )
{
// NOTE: don't call SetThrower here, it'll be recursive.
m_hThrower = 0;
}
}
//-----------------------------------------------------------------------------
bool CPasstimeBall::CreateModelCollider()
{
solid_t tmpSolid;
PhysModelParseSolid( tmpSolid, this, GetModelIndex() );
tmpSolid.params = SBallVPhysicsObjectParams();
tmpSolid.params.pGameData = static_cast<void *>( this );
auto *pPhysObj = VPhysicsInitNormal( SOLID_VPHYSICS, 0, false, &tmpSolid );
if ( !pPhysObj )
{
return false;
}
SetSolidFlags( FSOLID_NOT_STANDABLE );
AddFlag( FL_GRENADE ); // required for airblast deflection to work
pPhysObj->Wake();
return true;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::CreateSphereCollider()
{
// NOTE: calling VPhysicsInitNormal(SOLID_BBOX) doesn't work right.
// Not calling SetSolid after also doesn't work right.
// In order for CreateSphereObject to work and not crash, you must do
// VPhysicsInitNormal( SOLID_NONE followed by SetSolid(whatever)
// Seems like VPHYSICS or BBOX do the same thing.
// Must have FSOLID_TRIGGER to touch players. Unfortunately, triggers can't trigger triggers.
VPhysicsInitNormal( SOLID_NONE, 0, false );
SetSolid( SOLID_VPHYSICS );
SetSolidFlags( FSOLID_NOT_STANDABLE );
AddFlag( FL_GRENADE ); // required for airblast deflection to work
auto params = SBallVPhysicsObjectParams();
params.pGameData = static_cast<void *>( this );
const float flBallRadius = tf_passtime_ball_sphere_radius.GetFloat();
const float flFourThirdsPi = 4.1888f;
params.volume = flFourThirdsPi * (flBallRadius*flBallRadius*flBallRadius);
const int iPhysMat = physprops->GetSurfaceIndex("passtime_ball");
IPhysicsObject *pPhysObj = physenv->CreateSphereObject( flBallRadius, iPhysMat, GetAbsOrigin(), GetAbsAngles(), &params, false );
VPhysicsSetObject( pPhysObj );
SetMoveType( MOVETYPE_VPHYSICS );
pPhysObj->Wake();
}
//-----------------------------------------------------------------------------
void CPasstimeBall::Spawn()
{
// not sure why this has to come first, but iirc it does.
SetCollisionGroup( COLLISION_GROUP_NONE );
// === CBaseProp::Spawn
const char *pszModelName = (char*) STRING( GetModelName() );
if ( !pszModelName || !*pszModelName )
{
if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
{
pszModelName = s_pHalloweenBallModel;
}
else
{
pszModelName = tf_passtime_ball_model.GetString();
}
}
PrecacheModel( pszModelName );
Precache();
SetModel( pszModelName );
SetMoveType( MOVETYPE_PUSH );
m_takedamage = DAMAGE_NO;
SetNextThink( TICK_NEVER_THINK );
m_flAnimTime = gpGlobals->curtime;
m_flPlaybackRate = 0.0f;
SetCycle( 0 );
// === CBreakableProp::Spawn
m_flFadeScale = 1;
m_iHealth = 0;
m_takedamage = tf_passtime_ball_takedamage.GetBool()
? DAMAGE_EVENTS_ONLY
: DAMAGE_NO;
m_iMaxHealth = 1;
// === CPhysicsProp::Spawn
if( IsMarkedForDeletion() )
{
return;
}
m_pPlayerToucher = CreateEntityByName( "_ballplayertoucher" );
((CBallPlayerToucher*)m_pPlayerToucher)->m_pBall = this;
DispatchSpawn( m_pPlayerToucher );
if ( tf_passtime_ball_sphere_collision.GetBool() || !CreateModelCollider() )
{
CreateSphereCollider();
}
// === My spawn
m_flLastTeamChangeTime = gpGlobals->curtime;
m_flBeginCarryTime = -1;
ResetTrail();
ChangeTeam( TEAM_UNASSIGNED );
if ( TFGameRules()->IsPasstimeMode() )
{
// TODO the ball used to be functional in non-wasabi maps, but I haven't maintained it
SetThink( &CPasstimeBall::DefaultThink );
SetNextThink( gpGlobals->curtime );
SetTransmitState( FL_EDICT_ALWAYS );
m_playerSeek.SetIsEnabled( true );
}
m_flLastCollisionTime = gpGlobals->curtime;
m_flAirtimeDistance = 0;
m_eState = STATE_OUT_OF_PLAY;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::SetIdleRespawnTime()
{
auto *pTimer = TFGameRules()->GetActiveRoundTimer();
if ( !pTimer ) return;
auto ts = pTimer->GetTimerState();
auto grs = TFGameRules()->State_Get();
m_flIdleRespawnTime = ((grs == GR_STATE_RND_RUNNING) && (ts == RT_STATE_NORMAL))
? (gpGlobals->curtime + tf_passtime_ball_reset_time.GetFloat())
: 0;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::DisableIdleRespawnTime()
{
m_flIdleRespawnTime = 0;
}
//-----------------------------------------------------------------------------
bool CPasstimeBall::ShouldCollide( int iCollisionGroup, int iContentsMask ) const
{
// note: returning false for COLLISION_GROUP_PLAYER_MOVEMENT means the ball won't
// stop player movement. the only real visible effect when this function doesn't
// return false for COLLISION_GROUP_PLAYER_MOVEMENT is that the ball is unable
// to impart physics forces on itself when a player blocks it, since the player
// will set velocity to zero due to being "stuck" on the ball, even though the
// ball won't actually prevent the player from moving through it.
return (iCollisionGroup != COLLISION_GROUP_PLAYER_MOVEMENT);
}
//-----------------------------------------------------------------------------
void CPasstimeBall::ResetTrail()
{
// ideally this would just drop all of the existing trail points instead of
// re-creating all the entities, but I couldn't find a clean way to do it in
// a reasonable amount of time.
HideTrail();
const char *pszTrailEffect = GetTrailEffectForTeam( GetTeamNumber() );
Vector origin = GetAbsOrigin();
float flStartRadius = tf_passtime_ball_sphere_radius.GetFloat() * 2;
float flEndRadius = tf_passtime_ball_sphere_radius.GetFloat() * 3;
m_pTrail = CSpriteTrail::SpriteTrailCreate( pszTrailEffect, origin, true );
m_pTrail->SetAttachment( this, 0 );
m_pTrail->SetTransmit( true ); // this actually controls whether the attachment parent receives it
m_pTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 200, kRenderFxNone );
m_pTrail->SetStartWidth( flStartRadius );
m_pTrail->SetEndWidth( flEndRadius );
m_pTrail->SetTextureResolution( 1 );
m_pTrail->SetLifeTime( 3.0f );
m_bTrailActive = true;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::HideTrail()
{
// ideally this would just hide the existing trails instead of deleting
// them all, but I couldn't find a clean way to do it in a reasonable
// amount of time.
if ( !m_bTrailActive )
{
return;
}
// this is sometimes called from a physics callback (reset trail on collision)
// so use PhysCallbackRemove instead of UTIL_Remove
PhysCallbackRemove( m_pTrail->NetworkProp() );
m_pTrail = nullptr;
m_bTrailActive = false;
}
//-----------------------------------------------------------------------------
CPasstimeBall::~CPasstimeBall()
{
// trail is automatically removed because it's a child
// m_pPlayerToucher is automatically removed because it's a child
if ( m_pHumLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pHumLoop );
}
if ( m_pBeepLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pBeepLoop );
}
}
//-----------------------------------------------------------------------------
// OnBecomeNotCarried: common boilerplate between SetStateFree/OutOfPlay
void CPasstimeBall::OnBecomeNotCarried()
{
CTFPlayer *pCarrier = m_hCarrier;
//
// Carrier management and events
//
if ( pCarrier && pCarrier->m_Shared.HasPasstimeBall() )
{
pCarrier->m_Shared.SetHasPasstimeBall( false );
pCarrier->m_Shared.RemoveCond( TF_COND_SPEED_BOOST, true );
pCarrier->m_Shared.RemoveCond( TF_COND_PASSTIME_INTERCEPTION, true );
pCarrier->TeamFortress_SetSpeed();
PasstimeGameEvents::BallFree( pCarrier->entindex() ).Fire();
}
//
// Stats
//
if( m_flBeginCarryTime > 0 )
{
int nClass = pCarrier->GetPlayerClass()->GetClassIndex();
int nCarrySec = MAX( 0, Float2Int( gpGlobals->curtime - m_flBeginCarryTime ) );
CTF_GameStats.m_passtimeStats.classes[ nClass].nTotalCarrySec += nCarrySec;
m_flBeginCarryTime = -1;
}
//
// Reset various tracking and counters
//
m_iCollisionCount = 0;
m_flAirtimeDistance = 0;
m_flLastCollisionTime = gpGlobals->curtime;
m_bLeftOwner = false;
//m_playerSeek.SetIsEnabled( false ); // TODO: seek will re-enable itself
SetParent( 0 );
}
//-----------------------------------------------------------------------------
void CPasstimeBall::SetStateFree()
{
if ( BOutOfPlay() )
{
// this is a hack to prevent the out-of-play time from counting in the stats
m_flLastTeamChangeTime = gpGlobals->curtime;
}
//
// Change state
//
m_eState = STATE_FREE;
OnBecomeNotCarried();
//
// Make interactive
//
DisableIdleRespawnTime();
RemoveEffects( EF_NODRAW );
m_pPlayerToucher->RemoveSolidFlags( FSOLID_NOT_SOLID );
m_pPlayerToucher->SetSolid( SOLID_VPHYSICS );
m_takedamage = tf_passtime_ball_takedamage.GetBool() ? DAMAGE_EVENTS_ONLY : DAMAGE_NO;
SetMoveType( MOVETYPE_VPHYSICS );
SetSolid( SOLID_VPHYSICS );
SetSolidFlags( FSOLID_NOT_STANDABLE );
SetThrower( m_hCarrier );
TFGameRules()->SetObjectiveObserverTarget( this );
VPhysicsGetObject()->EnableGravity( true );
VPhysicsGetObject()->Wake();
//
// Trail management
//
if ( !m_bTrailActive )
{
// create trails if there aren't any
ResetTrail();
}
//
// Sounds
//
if ( !m_pHumLoop )
{
CReliableBroadcastRecipientFilter filter;
m_pHumLoop = CSoundEnvelopeController::GetController().SoundCreate(
filter, entindex(), "Passtime.BallIdle" );
CSoundEnvelopeController::GetController().Play( m_pHumLoop, 1, PITCH_NORM );
}
//
// Bookeeping
//
if ( m_hCarrier )
{
m_hPrevCarrier = m_hCarrier;
}
m_hCarrier = 0;
}
//-----------------------------------------------------------------------------
bool CPasstimeBall::BOutOfPlay() const { return m_eState == STATE_OUT_OF_PLAY; }
//-----------------------------------------------------------------------------
void CPasstimeBall::SetStateOutOfPlay()
{
// This can be called redundantly during RespawnBall
if ( BOutOfPlay() )
{
return;
}
// this is a hack to make sure the carrier stats are captured because
// ChangeTeam updates some stats and may not be called at end of round.
ChangeTeam( TEAM_UNASSIGNED );
//
// Change state
//
m_eState = STATE_OUT_OF_PLAY;
OnBecomeNotCarried();
//
// Make noninteractive
//
DisableIdleRespawnTime();
AddEffects( EF_NODRAW );
m_pPlayerToucher->AddSolidFlags( FSOLID_NOT_SOLID );
m_pPlayerToucher->SetSolid( SOLID_NONE );
m_takedamage = DAMAGE_NO;
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_NONE );
SetSolidFlags( FSOLID_NOT_SOLID );
SetThrower( 0 );
TFGameRules()->SetObjectiveObserverTarget( 0 );
VPhysicsGetObject()->EnableGravity( false );
//
// Trail management
//
HideTrail();
//
// Sounds
//
if ( m_pHumLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pHumLoop );
m_pHumLoop = 0;
}
if ( m_pBeepLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pBeepLoop );
m_pBeepLoop = 0;
}
//
// Bookeeping
//
if ( m_hCarrier )
{
m_hPrevCarrier = m_hCarrier;
}
m_hCarrier = 0;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::SetStateCarried( CTFPlayer *pCarrier )
{
// this can be called when m_eState==STATE_CARRIED when the ball is being
// directly transferred between players.
m_eState = STATE_CARRIED;
Assert( pCarrier );
if ( !pCarrier )
{
SetStateOutOfPlay();
return;
}
//
// Carrier management and events
// FIXME move all of the event handling for ball events into CTFPasstimeLogic
//
Assert( !pCarrier->m_Shared.HasPasstimeBall() );
pCarrier->RemoveInvisibility();
pCarrier->RemoveDisguise();
pCarrier->EndClassSpecialSkill(); // abort demo charge
pCarrier->m_Shared.SetHasPasstimeBall( true );
if ( pCarrier != m_hPrevCarrier )
{
pCarrier->m_Shared.AddCond( TF_COND_SPEED_BOOST, tf_passtime_speedboost_on_get_ball_time.GetFloat() );
// Limit points by time so we can't just throw back and forth a ton for points.
// FIXME awarding points here and also in passtime_logic?
if ( gpGlobals->realtime - g_pPasstimeLogic->GetLastPassTime(pCarrier) > 6.0f ) // FIXME literal balance value
{
CTF_GameStats.Event_PlayerAwardBonusPoints(pCarrier, 0, 5); // FIXME literal balance value
g_pPasstimeLogic->SetLastPassTime(pCarrier);
}
}
pCarrier->TeamFortress_SetSpeed();
//
// Adjust things common to all states
//
DisableIdleRespawnTime();
AddEffects( EF_NODRAW );
m_iCollisionCount = 0;
m_flAirtimeDistance = 0;
m_flLastCollisionTime = gpGlobals->curtime;
m_bLeftOwner = false;
//m_playerSeek.SetIsEnabled( false ); // TODO: seek will re-enable itself
m_pPlayerToucher->AddSolidFlags( FSOLID_NOT_SOLID );
m_pPlayerToucher->SetSolid( SOLID_NONE );
m_takedamage = DAMAGE_NO;
SetMoveType( MOVETYPE_NONE );
SetParent( pCarrier, pCarrier->LookupAttachment( "effect_hand_R" ) );
SetSolid( SOLID_NONE );
SetSolidFlags( FSOLID_NOT_SOLID );
TFGameRules()->SetObjectiveObserverTarget( pCarrier );
VPhysicsGetObject()->EnableGravity( false );
//
// Unique to this state
//
m_bTouchedSinceSpawn = true;
SetLocalOrigin( Vector( 0,0,0 ) ); // because SetParent(pCarrier)
//
// Sounds
//
EmitSound( "Passtime.BallGet" );
if ( m_pHumLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pHumLoop );
m_pHumLoop = 0;
}
if ( m_pBeepLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pBeepLoop );
m_pBeepLoop = 0;
}
//
// Stats
//
m_flBeginCarryTime = gpGlobals->curtime;
//
// Bookeeping
//
if ( m_hCarrier )
{
m_hPrevCarrier = m_hCarrier;
}
m_hCarrier = pCarrier;
ChangeTeam( pCarrier->GetTeamNumber() );
}
//-----------------------------------------------------------------------------
void CPasstimeBall::MoveToSpawner( const Vector &pos )
{
MoveTo( pos, Vector( 0,0,0 ) );
m_bTouchedSinceSpawn = false;
m_hPrevCarrier = 0;
}
//-----------------------------------------------------------------------------
bool CPasstimeBall::IsDeflectable()
{
return m_eState == STATE_FREE;
}
//-----------------------------------------------------------------------------
int CPasstimeBall::UpdateTransmitState()
{
if ( !TFGameRules()->IsPasstimeMode() )
{
return BaseClass::UpdateTransmitState();
}
return SetTransmitState(FL_EDICT_ALWAYS);
}
//-----------------------------------------------------------------------------
void CPasstimeBall::MoveTo( const Vector &pos, const Vector &vecVel )
{
// NOTE: using Teleport() causes some weird interpolation errors
// because it handles it specially as a "teleport list" etc
SetAbsOrigin( pos );
SetAbsVelocity( vecVel );
SetAbsAngles( QAngle( 0, 0, 0 ) );
IPhysicsObject *pPhys = VPhysicsGetObject();
pPhys->SetPosition( pos, QAngle( 0, 0, 0 ), true );
Vector fwd = vecVel.Normalized();
AngularImpulse angular( fwd.x * 0, fwd.y * 0, fwd.z * 1 ); // TODO
pPhys->SetVelocity( &vecVel, &angular );
PhysicsTouchTriggers();
m_vecPrevOrigin = pos; // used for tracking pass distance
CPasstimeBallController::BallSpawned( this );
}
//-----------------------------------------------------------------------------
bool CPasstimeBall::BShouldPanicRespawn() const
{
if ( !TFGameRules()
|| ( TFGameRules()->State_Get() != GR_STATE_RND_RUNNING )
|| ( m_eState != STATE_FREE ) )
{
return false;
}
if ( ( m_flIdleRespawnTime > 0 ) && ( m_flIdleRespawnTime < gpGlobals->curtime ) )
{
return true;
}
return ( enginetrace->GetPointContents( GetAbsOrigin() ) == CONTENTS_SOLID );
}
//-----------------------------------------------------------------------------
void CPasstimeBall::DefaultThink()
{
UpdateLagCompensationHistory();
if( IsMarkedForDeletion() || !g_pPasstimeLogic )
{
return;
}
SetNextThink( gpGlobals->curtime );
if ( BShouldPanicRespawn() )
{
g_pPasstimeLogic->RespawnBall();
return;
}
//
// Eject the ball if the carrier isn't allowed to carry it
//
CTFPlayer *pCarrier = m_hCarrier;
if ( pCarrier )
{
HudNotification_t ejectReason;
if ( !g_pPasstimeLogic->BCanPlayerPickUpBall( pCarrier, &ejectReason ) )
{
if ( ejectReason && TFGameRules() )
{
CSingleUserReliableRecipientFilter filter( pCarrier );
TFGameRules()->SendHudNotification( filter, ejectReason );
}
g_pPasstimeLogic->EjectBall( pCarrier, pCarrier );
SetIdleRespawnTime(); // have to do this here because need to guarantee it happens for no ball zones
EmitSound( "Passtime.BallDropped");
return;
}
}
//
// Track airtime and apply controllers
//
if ( m_eState == STATE_FREE )
{
{
Vector vecOrigin = GetAbsOrigin();
m_flAirtimeDistance += vecOrigin.DistTo( m_vecPrevOrigin );
m_vecPrevOrigin = vecOrigin;
}
IPhysicsObject *pPhysObj = VPhysicsGetObject();
Vector vecVel;
pPhysObj->GetVelocity( &vecVel, 0 );
SetAbsVelocity( vecVel );
// this is a hack to work around some issues where GetAbsVelocity was just
// returning some huge value. this seems to fix it, so something is probably fubar in physics :/
// hopefully just related to using the sphere collider that nothing else uses.
pPhysObj->Wake(); // NEVER SLEEP
//m_playerSeek.SetIsEnabled( !m_bTouchedSinceSpawn );
CPasstimeBallController::ApplyTo( this );
}
}
//-----------------------------------------------------------------------------
extern ConVar sv_maxunlag;
void CPasstimeBall::UpdateLagCompensationHistory()
{
// adapted from CLagCompensationManager::FrameUpdatePostEntityThink
Assert( m_lagCompensationHistory.Count() < 1000 ); // insanity check
m_flLagCompensationTeleportDistanceSqr = 64*64;
// remove tail records that are too old
int tailIndex = m_lagCompensationHistory.Tail();
int flDeadtime = gpGlobals->curtime - sv_maxunlag.GetFloat();
while ( m_lagCompensationHistory.IsValidIndex( tailIndex ) )
{
LagRecord &tail = m_lagCompensationHistory.Element( tailIndex );
// if tail is within limits, stop
if ( tail.flSimulationTime >= flDeadtime )
break;
// remove tail, get new tail
m_lagCompensationHistory.Remove( tailIndex );
tailIndex = m_lagCompensationHistory.Tail();
}
// check if head has same simulation time
if ( m_lagCompensationHistory.Count() > 0 )
{
LagRecord &head = m_lagCompensationHistory.Element( m_lagCompensationHistory.Head() );
// check if player changed simulation time since last time updated
if ( head.flSimulationTime >= GetSimulationTime() )
return; // don't add new entry for same or older time
}
// add new record to player track
LagRecord &record = m_lagCompensationHistory.Element( m_lagCompensationHistory.AddToHead() );
record.flSimulationTime = GetSimulationTime();
record.vecOrigin = GetAbsOrigin();
}
//-----------------------------------------------------------------------------
void CPasstimeBall::StartLagCompensation( CBasePlayer *player, CUserCmd *cmd )
{
m_bLagCompensationNeedsRestore = false; // set to true if it actually backtracks
if ( m_lagCompensationHistory.Count() <= 0 )
return;
// adapted from CLagCompensationManager::StartLagCompensation
int targettick = cmd->tick_count;
{
// correct is the amout of time we have to correct game time
float correct = 0.0f;
INetChannelInfo *nci = engine->GetPlayerNetInfo( player->entindex() );
if ( nci )
{
// add network latency
correct+= nci->GetLatency( FLOW_OUTGOING );
}
// calc number of view interpolation ticks - 1
int lerpTicks = TIME_TO_TICKS( player->m_fLerpTime );
// add view interpolation latency see C_BaseEntity::GetInterpolationAmount()
correct += TICKS_TO_TIME( lerpTicks );
// check bouns [0,sv_maxunlag]
correct = clamp( correct, 0.0f, sv_maxunlag.GetFloat() );
// correct tick send by player
targettick = cmd->tick_count - lerpTicks;
// calc difference between tick send by player and our latency based tick
float deltaTime = correct - TICKS_TO_TIME(gpGlobals->tickcount - targettick);
if ( fabs( deltaTime ) > 0.2f )
{
// difference between cmd time and latency is too big > 200ms, use time correction based on latency
// DevMsg("StartLagCompensation: delta too big (%.3f)\n", deltaTime );
targettick = gpGlobals->tickcount - TIME_TO_TICKS( correct );
}
}
// copied from BacktrackPlayer
Vector org;
float flTargetTime = TICKS_TO_TIME( targettick );
{
int curr = m_lagCompensationHistory.Head();
LagRecord *prevRecord = 0;
LagRecord *record = 0;
Vector prevOrg = GetAbsOrigin();
// Walk context looking for any invalidating pEvent
while( m_lagCompensationHistory.IsValidIndex(curr) )
{
// remember last record
prevRecord = record;
// get next record
record = &m_lagCompensationHistory.Element( curr );
Vector delta = record->vecOrigin - prevOrg;
if ( delta.Length2DSqr() > m_flLagCompensationTeleportDistanceSqr )
{
// lost track, too much difference
return;
}
// did we find a context smaller than target time ?
if ( record->flSimulationTime <= flTargetTime )
break; // hurra, stop
prevOrg = record->vecOrigin;
// go one step back
curr = m_lagCompensationHistory.Next( curr );
}
Assert( record );
if ( !record )
{
return; // that should never happen
}
float frac = 0.0f;
if ( prevRecord &&
(record->flSimulationTime < flTargetTime) &&
(record->flSimulationTime < prevRecord->flSimulationTime) )
{
// we didn't find the exact time but have a valid previous record
// so interpolate between these two records;
Assert( prevRecord->flSimulationTime > record->flSimulationTime );
Assert( flTargetTime < prevRecord->flSimulationTime );
// calc fraction between both records
frac = ( flTargetTime - record->flSimulationTime ) /
( prevRecord->flSimulationTime - record->flSimulationTime );
Assert( frac > 0 && frac < 1 ); // should never extrapolate
org = Lerp( frac, record->vecOrigin, prevRecord->vecOrigin );
}
else
{
// we found the exact record or no other record to interpolate with
// just copy these values since they are the best we have
org = record->vecOrigin;
}
}
Vector orgdiff = GetAbsOrigin() - org;
m_lagCompensationRestore.flSimulationTime = GetSimulationTime();
m_lagCompensationRestore.vecOrigin = GetAbsOrigin();
SetAbsOrigin( org );
SetSimulationTime( flTargetTime );
m_bLagCompensationNeedsRestore = true;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::FinishLagCompensation( CBasePlayer *player )
{
// adapted from CLagCompensationManager::BacktrackPlayer
if ( !m_bLagCompensationNeedsRestore )
{
return;
}
SetAbsOrigin( m_lagCompensationRestore.vecOrigin ); // this is probably not correct?
SetSimulationTime( m_lagCompensationRestore.flSimulationTime );
}
//-----------------------------------------------------------------------------
bool CPasstimeBall::BIgnorePlayer( CTFPlayer *pPlayer )
{
// NOTE: it's possible to be !alive and !dead at the same time
if ( !pPlayer || !pPlayer->IsAlive() )
{
return true;
}
if ( !m_bLeftOwner && (pPlayer == GetThrower()) )
{
const float flDist = CalcDistanceToAABB(
pPlayer->WorldAlignMins(),
pPlayer->WorldAlignMaxs(),
GetAbsOrigin() - pPlayer->GetAbsOrigin() );
m_bLeftOwner = flDist > s_flClearDist;
return !m_bLeftOwner;
}
else
{
m_bLeftOwner = true;
return false;
}
}
//-----------------------------------------------------------------------------
void CPasstimeBall::TouchPlayer( CTFPlayer *pPlayer )
{
if ( !TFGameRules() )
{
return;
}
//
// Is this player close enough to hit it?
// TODO is this still necessary since we use actual physics touching now?
//
{
const Vector& vecMyOrigin = GetAbsOrigin();
const Vector& vecOtherOrigin = pPlayer->GetAbsOrigin();
const Vector vecOtherHead = vecOtherOrigin + Vector( 0, 0, pPlayer->BoundingRadius() + 8 );
float t = 0;
const float flDist = CalcDistanceToLineSegment( vecMyOrigin, vecOtherOrigin, vecOtherHead, &t );
if ( (flDist > s_flBlockDist) && (flDist > s_flPickupDist) )
{
return;
}
}
const bool bSameTeam = GetThrower() && (pPlayer->GetTeamNumber() == GetThrower()->GetTeamNumber());
//
// Can this player get the ball?
//
bool bCanPickUp = false;
{
HudNotification_t cantPickUpReason;
bCanPickUp = g_pPasstimeLogic->BCanPlayerPickUpBall( pPlayer, &cantPickUpReason );
if ( cantPickUpReason )
{
CSingleUserReliableRecipientFilter filter( pPlayer );
TFGameRules()->SendHudNotification( filter, cantPickUpReason );
}
}
if ( bCanPickUp )
{
m_bTouchedSinceSpawn = true;
g_pPasstimeLogic->OnPlayerTouchBall( pPlayer, this );
}
else if ( !bSameTeam )
{
// can't pick it up and not on the same team = block
// NOTE: BlockDamage has to come after BlockReflect in order for
// the reflection to work right. BlockDamage might apply a force
// to the player, which will taint the reflection vector.
// NOTE: because some of these functions might change the ball's
// velocity, get it once and then pass it to each.
IPhysicsObject* pPhysObj = VPhysicsGetObject();
Vector vecBallVel;
pPhysObj->GetVelocity( &vecBallVel, 0 );
BlockReflect( pPlayer, pPlayer->GetAbsOrigin(), vecBallVel );
BlockDamage( pPlayer, vecBallVel );
if ( GetThrower() )
{
// ball was in flight
PasstimeGameEvents::BallBlocked( GetThrower()->entindex(), pPlayer->entindex() ).Fire();
}
CPasstimeBallController::DisableOn( this );
m_iCollisionCount++;
SetThrower( 0 );
m_flAirtimeDistance = 0;
m_flLastCollisionTime = gpGlobals->curtime;
}
}
//-----------------------------------------------------------------------------
void CPasstimeBall::BlockReflect( CTFPlayer *pPlayer, const Vector& vecBallOrigin, const Vector& vecBallVel )
{
if ( m_hBlocker == pPlayer )
{
// this helps prevent the ball from getting stuck inside players
return;
}
m_hBlocker = pPlayer;
const Vector vecMyOrigin = GetAbsOrigin();
Vector vecBallDir = vecBallVel;
vecBallDir.z = 0;
const float flBallSpeed = vecBallDir.NormalizeInPlace();
Vector vecReflectVel = vecMyOrigin - vecBallOrigin;
vecReflectVel.z = 0;
vecReflectVel.NormalizeInPlace();
vecReflectVel = vecReflectVel.Cross( vecBallDir );
vecReflectVel.NormalizeInPlace();
vecReflectVel = vecBallDir.Cross( vecReflectVel );
vecReflectVel.NormalizeInPlace();
vecReflectVel -= vecBallDir;
vecReflectVel *= flBallSpeed / 2.0f;
vecReflectVel += pPlayer->GetAbsVelocity();
AngularImpulse spin(0,0,0);
SetAbsVelocity( vecReflectVel );
VPhysicsGetObject()->SetVelocity( &vecReflectVel, &spin );
if ( flBallSpeed > 300 )
{
EmitSound( "Passtime.BallSmack" );
}
}
//-----------------------------------------------------------------------------
void CPasstimeBall::BlockDamage( CTFPlayer *pPlayer, const Vector& vecBallVel )
{
const float flSpeed = vecBallVel.Length();
const float flDamageSpeed = 1000;
pPlayer->m_Shared.OnSpyTouchedByEnemy();
if ( flSpeed >= flDamageSpeed )
{
CTakeDamageInfo di;
di.SetAttacker( GetThrower() );
di.SetDamage( 1 );
di.SetDamageType( DMG_CLUB );
di.SetInflictor( this );
di.SetDamagePosition( GetAbsOrigin() );
di.SetDamageForce( vecBallVel ); // needs to be set to nonzero
if ( flSpeed > 1200 )
{
di.AddDamageType( DMG_CRITICAL );
}
pPlayer->TakeDamage( di );
}
}
//-----------------------------------------------------------------------------
static bool IsGroundCollision( int index, const gamevcollisionevent_t *pEvent )
{
// this little arcane incantation stolen from somewhere else
const int otherindex = !index;
IPhysicsObject *pPhysObj = pEvent->pObjects[otherindex];
CBaseEntity *pOther = static_cast<CBaseEntity *>(pPhysObj->GetGameData());
if ( !pOther || !pEvent->pInternalData )
{
return false; // paranoia
}
Vector vecNormal;
pEvent->pInternalData->GetSurfaceNormal( vecNormal );
return Vector( 0, 0, 1 ).Dot( vecNormal ) < -0.7f; // why is this backwards?
}
//-----------------------------------------------------------------------------
void CPasstimeBall::OnTouch( CBaseEntity *pOther )
{
// If two players touch the ball in the same frame inside the physics system,
// the ball will get a touch callback for both regardless of what happens
// in response to the first call (i.e. it's just iterating a contact list).
// This catches the case where the ball was already picked up this frame.
if ( !TFGameRules()->IsPasstimeMode() || (m_eState != STATE_FREE) )
{
return;
}
CTFPlayer *pPlayer = ToTFPlayer( pOther );
if ( !BIgnorePlayer( pPlayer ) )
{
TouchPlayer( pPlayer );
}
}
//-----------------------------------------------------------------------------
void CPasstimeBall::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
BaseClass::VPhysicsCollision( index, pEvent );
if ( !TFGameRules()->IsPasstimeMode() )
{
return;
}
if ( g_pPasstimeLogic && (g_pPasstimeLogic->GetBall() == this)
&& g_pPasstimeLogic->OnBallCollision( this, index, pEvent )
&& IsGroundCollision( index, pEvent ) )
{
OnCollision();
}
CPasstimeBallController::BallCollision( this, index, pEvent );
m_hBlocker.Term();
}
//-----------------------------------------------------------------------------
void CPasstimeBall::OnCollision()
{
m_flAirtimeDistance = 0;
m_flLastCollisionTime = gpGlobals->curtime;
++m_iCollisionCount;
if ( m_iCollisionCount == 1 )
{
SetThrower( 0 );
if ( m_bTouchedSinceSpawn )
{
SetIdleRespawnTime();
}
}
m_hBlocker.Term();
}
//-----------------------------------------------------------------------------
int CPasstimeBall::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( !tf_passtime_ball_takedamage.GetBool() )
{
// this can happen if the cvar is disabled after the ball has spawned
return 0;
}
if ( !m_bTouchedSinceSpawn && (GetCollisionCount() == 0) )
{
++CTF_GameStats.m_passtimeStats.summary.nTotalBallSpawnShots;
}
if ( TFGameRules()->IsPasstimeMode() )
{
CPasstimeBallController::BallDamaged( this );
CPasstimeBallController::DisableOn( this );
OnCollision();
}
if ( IPhysicsObject* pPhysObj = VPhysicsGetObject() )
{
pPhysObj->EnableMotion( true );
pPhysObj->ApplyForceOffset( info.GetDamageForce().Normalized() * tf_passtime_ball_takedamage_force.GetFloat(), GetAbsOrigin() );
}
return 0;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::Deflected(CBaseEntity *pDeflectedBy, Vector& vecDir )
{
NOTE_UNUSED( pDeflectedBy );
IPhysicsObject* pPhysObj = VPhysicsGetObject();
if ( !pPhysObj )
{
return;
}
// WeaponBase::DeflectEntity will redirect the velocity with the same flSpeed,
// which means that a stationary ball won't move since it has 0 flSpeed. this
// will just make sure the velocity is what it should be
// vecDir points from the point under the player's crosshair to the ball's origin.
// this will make ball deflection work just like rockets, except the velocity
// is normalized instead of just being whatever magnitude it was before deflection.
Vector vecVel = -vecDir * tf_passtime_ball_takedamage_force.GetFloat();
pPhysObj->SetVelocity( &vecVel, 0 );
if ( TFGameRules()->IsPasstimeMode() )
{
++CTF_GameStats.m_passtimeStats.summary.nTotalBallDeflects;
// stop passing, etc
CPasstimeBallController::DisableOn( this );
// count as a collision
OnCollision();
}
}
//-----------------------------------------------------------------------------
//static
CPasstimeBall *CPasstimeBall::Create( Vector vecPosition, QAngle angles )
{
// mostly copied from CreatePhysicsToy
MDLCACHE_CRITICAL_SECTION();
MDLHandle_t hMdl = mdlcache->FindMDL( tf_passtime_ball_model.GetString() );
Assert( hMdl != MDLHANDLE_INVALID );
if( hMdl == MDLHANDLE_INVALID )
{
return 0;
}
studiohdr_t *pStudioHdr = mdlcache->GetStudioHdr( hMdl );
Assert( pStudioHdr );
if( !pStudioHdr )
{
return 0;
}
// i don't know what this "allow precache" stuff does,
// i copied it from other code and forgot to note where it was
bool oldAllowPrecache = CBaseEntity::IsPrecacheAllowed();
CBaseEntity::SetAllowPrecache( true );
CPasstimeBall *pBall = dynamic_cast< CPasstimeBall* >( CreateEntityByName( "passtime_ball" ) );
char pszBuf[512];
Q_snprintf( pszBuf, sizeof( pszBuf ), "%.10f %.10f %.10f", vecPosition.x, vecPosition.y, vecPosition.z );
pBall->KeyValue( "origin", pszBuf );
Q_snprintf( pszBuf, sizeof( pszBuf ), "%.10f %.10f %.10f", angles.x, angles.y, angles.z );
pBall->KeyValue( "angles", pszBuf );
pBall->KeyValue( "fademindist", "-1" );
pBall->KeyValue( "fademaxdist", "0" );
pBall->KeyValue( "fadescale", "1" );
DispatchSpawn( pBall );
pBall->Activate();
CBaseEntity::SetAllowPrecache( oldAllowPrecache );
mdlcache->Release( hMdl );
return pBall;
}
//-----------------------------------------------------------------------------
void CPasstimeBall::SetHomingTarget( CTFPlayer *pPlayer )
{
m_hHomingTarget = pPlayer;
if ( m_hHomingTarget )
{
if ( !m_pBeepLoop )
{
CReliableBroadcastRecipientFilter filter;
m_pBeepLoop = CSoundEnvelopeController::GetController().SoundCreate(
filter, entindex(), "Passtime.BallHoming" );
CSoundEnvelopeController::GetController().Play( m_pBeepLoop, 1, PITCH_NORM );
}
}
else
{
if ( m_pBeepLoop )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pBeepLoop );
m_pBeepLoop = 0;
}
}
}
//-----------------------------------------------------------------------------
CTFPlayer *CPasstimeBall::GetHomingTarget() const
{
return m_hHomingTarget;
}
//-----------------------------------------------------------------------------
float CPasstimeBall::GetAirtimeSec() const
{
return MAX( 0, gpGlobals->curtime - m_flLastCollisionTime );
}
//-----------------------------------------------------------------------------
float CPasstimeBall::GetAirtimeDistance() const
{
return m_flAirtimeDistance;
}
Reference in New Issue View Git Blame Copy Permalink