d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
86 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: dc2be1dcb4
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'dc2be1dcb4'
${ noResults }
source-engine/game/server/tf/tf_passtime_logic.cpp

2312 lines
70 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_passtime_logic.h"
#include "countdown_announcer.h"
#include "entity_passtime_ball_spawn.h"
#include "func_passtime_goal.h"
#include "func_passtime_no_ball_zone.h"
#include "tf_passtime_ball.h"
#include "passtime_ballcontroller.h"
#include "passtime_convars.h"
#include "passtime_game_events.h"
#include "func_passtime_goalie_zone.h"
#include "tf_player.h"
#include "tf_team.h"
#include "tf_gamestats.h"
#include "tf_gamerules.h"
#include "pathtrack.h"
#include "tf_fx.h"
#include "tf_weapon_passtime_gun.h"
#include "team_objectiveresource.h"
#include "mapentities.h"
#include "soundenvelope.h"
#include "eventqueue.h"
#include "hl2orange.spa.h" // achievement defines from tf_shareddefs depend on this
#include "tier0/memdbgon.h"
CTFPasstimeLogic *g_pPasstimeLogic;
#ifdef _DEBUG
#define SECRETROOM_LOG Warning
#else
#define SECRETROOM_LOG (void)
#endif
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( passtime_logic, CTFPasstimeLogic );
PRECACHE_REGISTER( passtime_logic );
IMPLEMENT_SERVERCLASS_ST( CTFPasstimeLogic, DT_TFPasstimeLogic )
SendPropEHandle( SENDINFO( m_hBall ) ),
SendPropArray( SendPropVector( SENDINFO_ARRAY( m_trackPoints ), -1, SPROP_COORD_MP_INTEGRAL ), m_trackPoints ),
SendPropInt( SENDINFO( m_iNumSections ) ),
SendPropInt( SENDINFO( m_iCurrentSection ) ),
SendPropFloat( SENDINFO( m_flMaxPassRange ) ),
SendPropInt( SENDINFO( m_iBallPower ), 8 ),
SendPropFloat( SENDINFO( m_flPackSpeed ) ),
SendPropArray3( SENDINFO_ARRAY3( m_bPlayerIsPackMember ), SendPropInt( SENDINFO_ARRAY( m_bPlayerIsPackMember ), 1, SPROP_UNSIGNED ) ),
END_SEND_TABLE()
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CTFPasstimeLogic )
DEFINE_KEYFIELD( m_iNumSections, FIELD_INTEGER, "num_sections" ),
DEFINE_KEYFIELD( m_iBallSpawnCountdownSec, FIELD_INTEGER, "ball_spawn_countdown" ),
DEFINE_KEYFIELD( m_flMaxPassRange, FIELD_FLOAT, "max_pass_range" ),
DEFINE_INPUTFUNC( FIELD_VOID, "SpawnBall", InputSpawnBall ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetSection", InputSetSection ),
DEFINE_INPUTFUNC( FIELD_VOID, "TimeUp", InputTimeUp ),
DEFINE_INPUTFUNC( FIELD_VOID, "SpeedBoostUsed", InputSpeedBoostUsed ),
DEFINE_INPUTFUNC( FIELD_VOID, "JumpPadUsed", InputJumpPadUsed ),
// secret room inputs
// these strings are obfuscated for fun, not for protection
DEFINE_INPUTFUNC( FIELD_VOID, "statica", statica ), // SecretRoom_InputStartTouchPlayerSlot NOTE: intentionally not in FGD
DEFINE_INPUTFUNC( FIELD_VOID, "staticb", staticb ), // SecretRoom_InputEndTouchPlayerSlot NOTE: intentionally not in FGD
DEFINE_INPUTFUNC( FIELD_VOID, "staticc", staticc ), // SecretRoom_InputPlugDamaged NOTE: intentionally not in FGD
DEFINE_INPUTFUNC( FIELD_VOID, "RoomTriggerOnTouch", InputRoomTriggerOnTouch ),
DEFINE_OUTPUT( m_onBallFree, "OnBallFree" ),
DEFINE_OUTPUT( m_onBallGetBlu, "OnBallGetBlu" ),
DEFINE_OUTPUT( m_onBallGetRed, "OnBallGetRed" ),
DEFINE_OUTPUT( m_onBallGetAny, "OnBallGetAny" ),
DEFINE_OUTPUT( m_onBallRemoved, "OnBallRemoved" ),
DEFINE_OUTPUT( m_onScoreBlu, "OnScoreBlu" ),
DEFINE_OUTPUT( m_onScoreRed, "OnScoreRed" ),
DEFINE_OUTPUT( m_onScoreAny, "OnScoreAny" ),
DEFINE_OUTPUT( m_onBallPowerUp, "OnBallPowerUp" ),
DEFINE_OUTPUT( m_onBallPowerDown, "OnBallPowerDown" ),
END_DATADESC()
//-----------------------------------------------------------------------------
static const CCountdownAnnouncer::TimeSounds sCountdownSoundsRoundBegin = {
"Announcer.RoundBegins60seconds",
"Announcer.RoundBegins30seconds",
"Announcer.RoundBegins10seconds",
"Announcer.RoundBegins5seconds",
"Announcer.RoundBegins4seconds",
"Announcer.RoundBegins3seconds",
"Announcer.RoundBegins2seconds",
"Announcer.RoundBegins1seconds",
};
//-----------------------------------------------------------------------------
static const CCountdownAnnouncer::TimeSounds sCountdownSoundsRoundBeginMerasmus = {
"Announcer.RoundBegins60seconds",
"Announcer.RoundBegins30seconds",
"Announcer.RoundBegins10seconds",
"Merasmus.RoundBegins5seconds",
"Merasmus.RoundBegins4seconds",
"Merasmus.RoundBegins3seconds",
"Merasmus.RoundBegins2seconds",
"Merasmus.RoundBegins1seconds",
};
//-----------------------------------------------------------------------------
static bool IsGamestatePlayable()
{
gamerules_roundstate_t state = TFGameRules()->State_Get();
return (state == GR_STATE_RND_RUNNING) || (state == GR_STATE_STALEMATE);
}
//-----------------------------------------------------------------------------
CPasstimeBall *CTFPasstimeLogic::GetBall() const { return m_hBall; }
//-----------------------------------------------------------------------------
CTFPasstimeLogic::CTFPasstimeLogic()
{
m_SecretRoom_pTv = nullptr;
m_SecretRoom_pTvSound = nullptr;
m_SecretRoom_state = SecretRoomState::None;
memset( m_SecretRoom_slottedPlayers, 0, sizeof( m_SecretRoom_slottedPlayers ) );
m_flNextCrowdReactionTime = 0.0f;
m_nPackMemberBits = 0;
m_nPrevPackMemberBits = 0;
}
//-----------------------------------------------------------------------------
CTFPasstimeLogic::~CTFPasstimeLogic()
{
// note:
// it doesn't seem possible on the server that this destructor would be called
// after a new CTFPasstimeLogic is spawned, and it's worked fine so far, but
// this has been a problem in the client code.
g_pPasstimeLogic = NULL;
delete m_pRespawnCountdown;
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Spawn()
{
g_pPasstimeLogic = this;
m_iBallSpawnCountdownSec = MAX( 1, m_iBallSpawnCountdownSec );
if ( m_flMaxPassRange == 0 )
{
m_flMaxPassRange = FLT_MAX;
}
for ( int i = 0; i < m_bPlayerIsPackMember.Count(); ++i )
{
m_bPlayerIsPackMember.Set( i, 0 );
}
for ( int i = 0; i < m_trackPoints.Count(); ++i )
{
m_trackPoints.GetForModify(i).Zero();
}
const auto *pCountdownSounds = TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween )
? &sCountdownSoundsRoundBeginMerasmus
: &sCountdownSoundsRoundBegin;
m_pRespawnCountdown = new CCountdownAnnouncer( pCountdownSounds );
SetContextThink( &CTFPasstimeLogic::PostSpawn, gpGlobals->curtime, "postspawn" );
SetContextThink( &CTFPasstimeLogic::BallPower_PackHealThink, gpGlobals->curtime + 1, "packheal" );
ListenForGameEvent( "teamplay_round_stalemate" );
ListenForGameEvent( "teamplay_setup_finished" );
}
//------------------------------------------------------------------------------
// Purpose: Utility function for hooking up entity connections from code.
// Would belong in BaseEnity, but this this hacky so I'm just hiding it here.
//------------------------------------------------------------------------------
static CBaseEntityOutput *FindOutput( CBaseEntity *pEnt, const char *pOutputName )
{
if ( !pEnt || !pOutputName || !pOutputName[0] )
{
return nullptr;
}
// loop taken from ValidateEntityConnections
datamap_t *dmap = pEnt->GetDataDescMap();
while ( dmap )
{
int fields = dmap->dataNumFields;
for ( int i = 0; i < fields; i++ )
{
typedescription_t *dataDesc = &dmap->dataDesc[i];
if ( ( dataDesc->fieldType == FIELD_CUSTOM )
&& ( dataDesc->flags & FTYPEDESC_OUTPUT )
&& !strcmp( dataDesc->externalName, pOutputName ) )
{
return (CBaseEntityOutput *)((intptr_t)pEnt + (int)dataDesc->fieldOffset[0]);
}
}
dmap = dmap->baseMap;
}
return nullptr;
}
//------------------------------------------------------------------------------
// Purpose: Utility function for hooking up entity connections from code.
// Would belong in BaseEnity, but this this hacky so I'm just hiding it here.
//------------------------------------------------------------------------------
static void HookOutput( const char *pSourceName, string_t pTargetName,
const char *pOutputName, const char *pInputName,
const char *pParameter = nullptr, int nTimesToFire = EVENT_FIRE_ALWAYS )
{
Assert( pSourceName && pSourceName[0] );
Assert( pTargetName.ToCStr() && pTargetName.ToCStr()[0] );
CBaseEntity *pEnt = gEntList.FindEntityByName( nullptr, pSourceName );
if ( !pEnt )
{
Warning( "Entity %s missing", pSourceName );
return;
}
CBaseEntityOutput *pOut = FindOutput( pEnt, pOutputName );
if ( !pOut )
{
Warning( "Entity %s missing output %s", pSourceName, pOutputName );
return;
}
CEventAction *pAction = new CEventAction();
pAction->m_iTarget = pTargetName;
pAction->m_iTargetInput = AllocPooledString( pInputName );
pAction->m_nTimesToFire = nTimesToFire;
pAction->m_iParameter = pParameter
? AllocPooledString( pParameter )
: string_t();
pOut->AddEventAction( pAction );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::PostSpawn()
{
// This can't be done in spawn because GetTeamNumber doesn't return the
// correct value for any entity until after it's been Activate()d, which
// happens after all the Spawns. And it can't be done in Activate() because
// the order of Activation seems kinda non-deterministic.
const auto &goals = CFuncPasstimeGoal::GetAutoList();
if ( ( m_iNumSections == 0 ) && ( goals.Count() == 2 ) )
{
// FIXME support > 2 goals properly
CFuncPasstimeGoal *pRed = static_cast<CFuncPasstimeGoal *>( goals[0] );
CFuncPasstimeGoal *pBlu = static_cast<CFuncPasstimeGoal *>( goals[1] );
if ( pRed->GetTeamNumber() != TF_TEAM_BLUE ) // goal's color is who can score there
{
V_swap( pRed, pBlu );
}
m_trackPoints.Set( 0, pBlu->GetAbsOrigin() );
m_trackPoints.Set( 1, pRed->GetAbsOrigin() );
m_iNumSections = 1;
}
//
// Determine goal type for stats
//
int nTotalEndzone = 0;
int nTotalBasket = 0;
for ( const auto *pGoalNode : goals )
{
const auto *pGoal = (const CFuncPasstimeGoal *)pGoalNode;
if ( !pGoal->BDisableBallScore() )
{
++nTotalBasket;
}
if ( pGoal->BEnablePlayerScore() )
{
++nTotalEndzone;
}
}
if ( nTotalBasket && !nTotalEndzone )
{
CTF_GameStats.m_passtimeStats.summary.nGoalType = 1;
}
else if ( !nTotalBasket && nTotalEndzone )
{
CTF_GameStats.m_passtimeStats.summary.nGoalType = 2;
}
else
{
CTF_GameStats.m_passtimeStats.summary.nGoalType = 3;
}
CTF_GameStats.m_passtimeStats.summary.nRoundMaxSec = TFGameRules()->GetActiveRoundTimer()->GetTimerInitialLength();
// These used to happen from teamplay_setup_ended, but that event doesn't happen if there's no setup time
// These functions should be able to determine whether or not to actually do anything based on game state
SetContextThink( &CTFPasstimeLogic::BallHistSampleThink, gpGlobals->curtime, "BallHistSampleThink" );
SetContextThink( &CTFPasstimeLogic::OneSecStatsUpdateThink, gpGlobals->curtime, "OneSecStatsUpdateThink" );
BallPower_PowerThink();
BallPower_PackThink();
// secret room puzzle
if ( !V_stricmp( gpGlobals->mapname.ToCStr(), "pass_brickyard" ) )
{
SecretRoom_Spawn();
}
}
//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::AddBallPower( int iPower )
{
int iThreshold = tf_passtime_powerball_threshold.GetInt();
bool bWasAboveThreshold = m_iBallPower > iThreshold;
m_iBallPower = clamp( m_iBallPower + iPower, 0, 100 );
bool bIsAboveThreshold = m_iBallPower > iThreshold;
if ( bWasAboveThreshold && !bIsAboveThreshold )
{
m_onBallPowerDown.FireOutput( this, this );
TFGameRules()->BroadcastSound( 255, "Powerup.Reflect.Reflect" );
return true;
}
else if ( !bWasAboveThreshold && bIsAboveThreshold )
{
m_onBallPowerUp.FireOutput( this, this );
TFGameRules()->BroadcastSound( 255, "Powerup.Volume.Use" );
// reschedule think so that decay stops for a while
SetContextThink( &CTFPasstimeLogic::BallPower_PowerThink,
gpGlobals->curtime + tf_passtime_powerball_decay_delay.GetFloat(),
"BallPower_PowerThink" );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::ClearBallPower()
{
AddBallPower( -m_iBallPower );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::BallPower_PowerThink()
{
CPasstimeBall *pBall = GetBall();
if ( !IsGamestatePlayable() || !pBall )
{
SetContextThink( &CTFPasstimeLogic::BallPower_PowerThink,
gpGlobals->curtime, "BallPower_PowerThink" );
return;
}
float flTickTime = (pBall->GetTeamNumber() == TEAM_UNASSIGNED)
? tf_passtime_powerball_decaysec_neutral.GetFloat()
: tf_passtime_powerball_decaysec.GetFloat();
SetContextThink( &CTFPasstimeLogic::BallPower_PowerThink,
gpGlobals->curtime + flTickTime, "BallPower_PowerThink" );
if ( !pBall->GetHomingTarget() )
{
AddBallPower( -tf_passtime_powerball_decayamount.GetInt() );
}
}
//-----------------------------------------------------------------------------
static uint64 CalcPackMemberBits( CTFPlayer *pBallCarrier )
{
if ( !pBallCarrier || !pBallCarrier->IsAlive() )
{
return 0;
}
float flPackRangeSqr = tf_passtime_pack_range.GetFloat();
flPackRangeSqr *= flPackRangeSqr;
int iCarrierTeam = pBallCarrier->GetTeamNumber();
Vector vecCarrierPos = pBallCarrier->GetAbsOrigin();
uint64 nNewPackMemberBits = 0;
uint64 nMask = 1;
for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
{
CTFPlayer *pPlayer = (CTFPlayer*) UTIL_PlayerByIndex( i );
// must be a valid team member within range
if ( !pPlayer
|| !pPlayer->IsAlive()
|| ( pPlayer->GetTeamNumber() != iCarrierTeam )
|| ( pPlayer->GetAbsOrigin().DistToSqr( vecCarrierPos ) > flPackRangeSqr ) )
{
continue;
}
// must not be aiming (heavy spin, sniper scope, etc)
if ( pPlayer->m_Shared.InCond( TF_COND_AIMING ) )
{
continue;
}
nNewPackMemberBits |= nMask;
}
return nNewPackMemberBits;
}
//-----------------------------------------------------------------------------
static void SetSpeedOnFlaggedPlayers( uint64 playerBits )
{
if ( playerBits == 0 )
{
return;
}
uint64 nMask = 1;
for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
{
if ( playerBits & nMask )
{
CTFPlayer *pPlayer = (CTFPlayer*)UTIL_PlayerByIndex( i );
if ( pPlayer && pPlayer->IsAlive() )
{
pPlayer->TeamFortress_SetSpeed();
}
}
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::ReplicatePackMemberBits()
{
uint64 nMask = 1;
for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
{
m_bPlayerIsPackMember.Set( i, ( m_nPackMemberBits & nMask ) ? 1 : 0 );
}
}
//-----------------------------------------------------------------------------
// solo carrier is marked for death
// any close teammate (2x cart distance) removes marked for death
// close teammates are sped up to fastest teammate speed
void CTFPasstimeLogic::BallPower_PackThink()
{
SetContextThink( &CTFPasstimeLogic::BallPower_PackThink,
gpGlobals->curtime, "BallPower_PackThink" );
m_flPackSpeed = 0.0f;
m_nPrevPackMemberBits = m_nPackMemberBits;
m_nPackMemberBits = 0;
CTFPlayer *pCarrier = GetBallCarrier();
// Check if pack speed is active
if ( !tf_passtime_pack_speed.GetBool() || !IsGamestatePlayable() || !pCarrier )
{
m_nPackMemberBits = 0; // redundant assignment for clarity
ReplicatePackMemberBits();
SetSpeedOnFlaggedPlayers( m_nPrevPackMemberBits );
return;
}
// Find the pack members
m_nPackMemberBits = CalcPackMemberBits( pCarrier );
ReplicatePackMemberBits();
// Find the maximum MaxSpeed of the pack
bool bHasNearbyTeammate = false;
float flMaxMaxSpeed = -1;
uint64 nMask = 1;
for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
{
if ( m_nPackMemberBits & nMask )
{
CTFPlayer *pPlayer = (CTFPlayer*)UTIL_PlayerByIndex( i );
if ( pPlayer && pPlayer->IsAlive() )
{
bHasNearbyTeammate = bHasNearbyTeammate || ( pPlayer != pCarrier );
flMaxMaxSpeed = MAX( flMaxMaxSpeed, pPlayer->TeamFortress_CalculateMaxSpeed() );
}
}
}
// Apply marked for death if no teammates
if ( !bHasNearbyTeammate )
{
pCarrier->m_Shared.AddCond( TF_COND_PASSTIME_PENALTY_DEBUFF, TICK_INTERVAL * 2 );
}
else
{
m_flPackSpeed = flMaxMaxSpeed;
}
// Now tell all the relevant players to refresh their maxspeed
SetSpeedOnFlaggedPlayers( m_nPackMemberBits | m_nPrevPackMemberBits );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::BallPower_PackHealThink()
{
SetContextThink( &CTFPasstimeLogic::BallPower_PackHealThink, gpGlobals->curtime + 1, "packheal" );
CTFPlayer *pCarrier = GetBallCarrier();
if ( !pCarrier )
{
return;
}
uint64 nMask = 1;
uint64 nPackMemberBits = m_nPackMemberBits;
float flHealAmount = tf_passtime_pack_hp_per_sec.GetFloat();
for ( int i = 1; i <= MAX_PLAYERS; ++i, nMask <<= 1 )
{
if ( ( nPackMemberBits & nMask ) == 0 )
{
continue;
}
CTFPlayer *pPlayer = (CTFPlayer*)UTIL_PlayerByIndex( i );
if ( !pPlayer || ( pPlayer == pCarrier ) || !pPlayer->IsAlive() )
{
continue;
}
int iActualHealAmount = pPlayer->TakeHealth( flHealAmount, DMG_GENERIC );
if ( iActualHealAmount <= 0 )
{
continue;
}
// I'm abusing the player_healonhit event because it does the visual fx I want
IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_healonhit" );
if ( pEvent )
{
pEvent->SetInt( "amount", iActualHealAmount );
pEvent->SetInt( "entindex", pPlayer->entindex() );
gameeventmanager->FireEvent( pEvent );
}
}
}
//-----------------------------------------------------------------------------
float CTFPasstimeLogic::GetPackSpeed( CTFPlayer *pPlayer ) const
{
if ( pPlayer )
{
uint64 nMask = (uint64)1 << ( pPlayer->entindex() - 1 );
if ( m_nPackMemberBits & nMask )
{
return m_flPackSpeed;
}
}
return 0;
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::FireGameEvent( IGameEvent *pEvent )
{
const char *pEventName = pEvent->GetName();
if ( !V_strcmp( pEventName, "teamplay_round_stalemate" ) )
{
// this only happens when mp_stalemate_enable is on
CTF_GameStats.m_passtimeStats.summary.nRoundMaxSec =
TFGameRules()->GetActiveRoundTimer()->GetTimeRemaining();
RespawnBall();
}
else if ( !V_strcmp( pEventName, "teamplay_setup_finished" ) )
{
// respawn the ball even though it already exists so that it doesn't
// catch any rotation from any spawn box it might be sitting in that
// hasn't opened yet.
SpawnBallAtRandomSpawner();
}
}
//-----------------------------------------------------------------------------
// FIXME copypasta with tf_hud_passtime.cpp
// For stats
float CTFPasstimeLogic::CalcProgressFrac() const
{
if ( !GetBall() || (m_iNumSections == 0) )
{
return 0;
}
//
// Which point are we trying to classify?
//
Vector vecOrigin;
{
CPasstimeBall *pBall = GetBall();
CTFPlayer *pCarrier = pBall->GetCarrier();
vecOrigin = pCarrier
? pCarrier->GetAbsOrigin()
: pBall->GetAbsOrigin();
}
//
// Find distance along track from first goal to last goal
//
float flBestLen = 0;
float flTotalLen = 1; // don't set 0 so div by zero is impossible
{
float flBestDist = FLT_MAX;
Vector vecThisPoint;
Vector vecPointOnLine;
Vector vecPrevPoint = m_trackPoints[0];
float flThisFrac = 0;
float flThisLen = 0;
float flThisDist = 0;
for ( int i = 1; i < 16; ++i )
{
vecThisPoint = m_trackPoints[i];
if ( vecThisPoint.IsZero() )
{
break;
}
flThisLen = (vecThisPoint - vecPrevPoint).Length();
flTotalLen += flThisLen;
CalcClosestPointOnLineSegment( vecOrigin, vecPrevPoint, vecThisPoint, vecPointOnLine, &flThisFrac );
flThisDist = (vecPointOnLine - vecOrigin).Length();
if ( flThisDist < flBestDist )
{
flBestDist = flThisDist;
flBestLen = flTotalLen - (flThisLen * (1.0f - flThisFrac));
}
vecPrevPoint = vecThisPoint;
}
}
return (float)(flBestLen / flTotalLen);
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::BallHistSampleThink()
{
CPasstimeBall *pBall = m_hBall;
if ( IsGamestatePlayable() && pBall && !pBall->BOutOfPlay() )
{
CTF_GameStats.m_passtimeStats.AddBallFracSample( CalcProgressFrac() );
}
SetContextThink( &CTFPasstimeLogic::BallHistSampleThink, gpGlobals->curtime + 0.125f, "BallHistSampleThink" );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OneSecStatsUpdateThink()
{
CTFTeam *pBlue = GetGlobalTFTeam( TF_TEAM_BLUE );
CTFTeam *pRed = GetGlobalTFTeam( TF_TEAM_RED );
// FIXME this is a hack but it'll work for now
CTF_GameStats.m_passtimeStats.summary.nPlayersBlueMax = MAX( CTF_GameStats.m_passtimeStats.summary.nPlayersBlueMax, pBlue->GetNumPlayers() );
CTF_GameStats.m_passtimeStats.summary.nPlayersRedMax = MAX( CTF_GameStats.m_passtimeStats.summary.nPlayersRedMax, pRed->GetNumPlayers() );
SetContextThink( &CTFPasstimeLogic::OneSecStatsUpdateThink, gpGlobals->curtime + 1, "OneSecStatsUpdateThink" );
}
//-----------------------------------------------------------------------------
static void MapEventStat( CBaseEntity *pActivator, CPasstimeBall *pBall, int *pTotal, int *pCarrierTotal )
{
CTFPlayer *pPlayer = ToTFPlayer( pActivator );
if ( pPlayer )
{
++(*pTotal);
if ( pBall && (pBall->GetCarrier() == pPlayer) )
{
++(*pCarrierTotal);
}
}
}
//-----------------------------------------------------------------------------
CTFPlayer *CTFPasstimeLogic::GetBallCarrier() const
{
const CPasstimeBall *pBall = m_hBall.Get();
if ( !pBall )
{
return nullptr;
}
return pBall->GetCarrier();
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputSpeedBoostUsed( inputdata_t &input )
{
MapEventStat( input.pActivator, GetBall(),
&CTF_GameStats.m_passtimeStats.summary.nTotalSpeedBoosts,
&CTF_GameStats.m_passtimeStats.summary.nTotalCarrierSpeedBoosts );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputJumpPadUsed( inputdata_t &input )
{
MapEventStat( input.pActivator, GetBall(),
&CTF_GameStats.m_passtimeStats.summary.nTotalJumpPads,
&CTF_GameStats.m_passtimeStats.summary.nTotalCarrierJumpPads );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Precache()
{
PrecacheScriptSound( "Passtime.BallIntercepted" );
PrecacheScriptSound( "Passtime.BallStolen" );
PrecacheScriptSound( "Passtime.BallDropped" );
PrecacheScriptSound( "Passtime.BallCatch" );
PrecacheScriptSound( "Passtime.BallSpawn" );
PrecacheScriptSound( "Passtime.Crowd.Boo" );
PrecacheScriptSound( "Passtime.Crowd.Cheer" );
PrecacheScriptSound( "Passtime.Crowd.React.Neg" );
PrecacheScriptSound( "Passtime.Crowd.React.Pos" );
PrecacheScriptSound( "Powerup.Reflect.Reflect" ); // for powerball
PrecacheScriptSound( "Powerup.Volume.Use" );
PrecacheScriptSound( "Announcer.RoundBegins60seconds");
PrecacheScriptSound( "Announcer.RoundBegins30seconds");
PrecacheScriptSound( "Announcer.RoundBegins10seconds");
if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
{
PrecacheScriptSound( "Merasmus.RoundBegins5seconds");
PrecacheScriptSound( "Merasmus.RoundBegins4seconds");
PrecacheScriptSound( "Merasmus.RoundBegins3seconds");
PrecacheScriptSound( "Merasmus.RoundBegins2seconds");
PrecacheScriptSound( "Merasmus.RoundBegins1seconds");
PrecacheScriptSound( "sf14.Merasmus.Soccer.GoalRed" );
PrecacheScriptSound( "sf14.Merasmus.Soccer.GoalBlue" );
PrecacheScriptSound( "Passtime.Merasmus.Laugh" );
}
else
{
PrecacheScriptSound( "Announcer.RoundBegins5seconds");
PrecacheScriptSound( "Announcer.RoundBegins4seconds");
PrecacheScriptSound( "Announcer.RoundBegins3seconds");
PrecacheScriptSound( "Announcer.RoundBegins2seconds");
PrecacheScriptSound( "Announcer.RoundBegins1seconds");
}
PrecacheScriptSound( "Game.Overtime");
PrecacheScriptSound( "Passtime.AskForBall" );
// secret room stuff
if ( !V_stricmp( gpGlobals->mapname.ToCStr(), "pass_brickyard" ) )
{
PrecacheScriptSound( "Passtime.Tv1" );
PrecacheScriptSound( "Passtime.Tv2" );
PrecacheScriptSound( "Passtime.Tv3" );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnEnterGoal( CPasstimeBall *pBall, CFuncPasstimeGoal *pGoal )
{
if ( pGoal->BDisableBallScore() || !IsGamestatePlayable() )
{
return;
}
// -1 iPoints is a special hacked value that means "kill zone"
if ( pGoal->Points() == -1 )
{
m_onBallRemoved.FireOutput( pGoal, pGoal );
SetContextThink( &CTFPasstimeLogic::RespawnBall, gpGlobals->curtime, "spawnball" );
return;
}
if ( (pBall->GetCollisionCount() > 0) || (pBall->GetTeamNumber() == TEAM_UNASSIGNED) )
{
return;
}
CTFPlayer *pOwner = pBall->GetThrower();
if ( pOwner && (pBall->GetTeamNumber() == pGoal->GetTeamNumber()) )
{
Score( pBall, pGoal );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnEnterGoal( CTFPlayer *pPlayer, CFuncPasstimeGoal *pGoal )
{
if ( IsGamestatePlayable()
&& pGoal->BEnablePlayerScore()
&& pPlayer->m_Shared.HasPasstimeBall()
&& (pPlayer->GetTeamNumber() == pGoal->GetTeamNumber()) )
{
Score( pPlayer, pGoal );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnExitGoal( CPasstimeBall *pBall, CFuncPasstimeGoal *pGoal )
{
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnStayInGoal( CTFPlayer *pPlayer, CFuncPasstimeGoal *pGoal )
{
OnEnterGoal( pPlayer, pGoal );
}
//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::OnBallCollision( CPasstimeBall *pBall, int index, gamevcollisionevent_t *pEvent )
{
if ( !IsGamestatePlayable() )
{
return false;
}
// FIXME
//if ( pBall && pBall->BAnyControllerApplied() )
//{
// return false;
//}
return true;
}
//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::BCanPlayerPickUpBall( CTFPlayer *pPlayer, HudNotification_t *pReason ) const
{
if ( pReason ) *pReason = (HudNotification_t) 0;
const auto *pBall = m_hBall.Get();
if ( !pBall )
{
return false;
}
if ( !pPlayer || !IsGamestatePlayable() )
{
return false;
}
if ( pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE )
|| pPlayer->m_Shared.InCond( TF_COND_PHASE )
|| pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_INVULN;
return false;
}
if ( pPlayer->m_Shared.IsStealthed() )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_CLOAK;
return false;
}
// let disguised spies pick up enemy ball, which amounts to interception and fake passes
auto bEnemyBall = ( pBall->GetTeamNumber() != TEAM_UNASSIGNED )
&& ( pBall->GetTeamNumber() != pPlayer->GetTeamNumber() );
if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && !bEnemyBall )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_DISGUISE;
return false;
}
if ( pPlayer->m_Shared.IsCarryingObject() )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_CARRY;
return false;
}
if ( pPlayer->m_Shared.InCond( TF_COND_SELECTED_TO_TELEPORT ) )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_TELE;
return false;
}
if ( pPlayer->IsTaunting() )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_TAUNT;
return false;
}
if ( !pPlayer->IsAllowedToPickUpFlag()
|| !pPlayer->IsAlive() // NOTE: it's possible to be !alive and !dead at the same time
|| pPlayer->IsAwayFromKeyboard()
|| pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE )
|| pPlayer->m_Shared.IsControlStunned() )
{
return false;
}
if ( pPlayer->m_bIsTeleportingUsingEurekaEffect )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_TELE;
return false;
}
CTFWeaponBase *pActiveWeapon = pPlayer->GetActiveTFWeapon();
if ( pActiveWeapon )
{
bool bCanHolster = pActiveWeapon->CanHolster()
&& !( pActiveWeapon->IsReloading() && pActiveWeapon->ReloadsSingly() && pActiveWeapon->CanOverload() ); // semihack to fix beggars bazooka problems
if ( pActiveWeapon && ( pActiveWeapon->GetWeaponID() != TF_WEAPON_PASSTIME_GUN ) && !bCanHolster )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_HOLSTER;
return false;
}
}
if ( EntityIsInNoBallZone( pPlayer ) )
{
if ( pReason ) *pReason = HUD_NOTIFY_PASSTIME_NO_OOB;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
int CTFPasstimeLogic::UpdateTransmitState()
{
return SetTransmitState( FL_EDICT_ALWAYS );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::RespawnBall()
{
Assert( m_hBall );
if ( !m_hBall ) // paranoia
{
return;
}
ClearBallPower();
// TFGameRules only checks capture limit once per second, so this code can't rely on game state changing
int iScoreLimit = tf_passtime_scores_per_round.GetInt();
bool bGameOver = ( TFTeamMgr()->GetFlagCaptures( TF_TEAM_RED ) >= iScoreLimit )
|| ( TFTeamMgr()->GetFlagCaptures( TF_TEAM_BLUE ) >= iScoreLimit );
gamerules_roundstate_t state = TFGameRules()->State_Get();
if ( bGameOver || (state == GR_STATE_GAME_OVER) || (state == GR_STATE_TEAM_WIN) || (state == GR_STATE_RESTART) )
{
m_hBall->SetStateOutOfPlay();
MoveBallToSpawner();
}
else if ( (state == GR_STATE_RND_RUNNING) || (state == GR_STATE_STALEMATE) )
{
// TODO just end the game if there's not enough time to respawn the ball
m_hBall->SetStateOutOfPlay();
MoveBallToSpawner();
CTeamRoundTimer *pTimer = TFGameRules()->GetActiveRoundTimer();
if ( !pTimer || ( pTimer->GetTimeRemaining() > m_iBallSpawnCountdownSec ) )
{
m_pRespawnCountdown->Start( m_iBallSpawnCountdownSec );
SpawnBallAtRandomSpawnerThink();
}
}
else // pre-round etc
{
SpawnBallAtRandomSpawner();
}
m_ballLastHeldTimes.RemoveAll();
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SpawnBallAtRandomSpawnerThink()
{
if ( TFGameRules()->State_Get() == GR_STATE_GAME_OVER )
{
m_hBall->SetStateOutOfPlay();
m_pRespawnCountdown->Disable();
}
else if ( m_pRespawnCountdown->Tick( 1 ) )
{
SpawnBallAtRandomSpawner();
}
else
{
SetContextThink( &CTFPasstimeLogic::SpawnBallAtRandomSpawnerThink, gpGlobals->curtime + 1, "spawnball" );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SpawnBallAtRandomSpawner()
{
const auto &allSpawns = IPasstimeBallSpawnAutoList::AutoList();
int i = RandomInt( 0, allSpawns.Count() - 1 );
CPasstimeBallSpawn *pSpawner = static_cast< CPasstimeBallSpawn *>( allSpawns[i] );
SpawnBallAtSpawner( pSpawner );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::MoveBallToSpawner()
{
const auto &allSpawns = IPasstimeBallSpawnAutoList::AutoList();
int i = RandomInt( 0, allSpawns.Count() - 1 );
CPasstimeBallSpawn *pSpawner = static_cast< CPasstimeBallSpawn *>( allSpawns[i] );
m_hBall->MoveTo( pSpawner->GetAbsOrigin(), Vector( 0, 0, 0 ) );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SpawnBallAtSpawner( CPasstimeBallSpawn *pSpawner )
{
if ( !m_hBall )
{
// NOTE: this is the first place where the ball is created - on first spawn
m_hBall = CPasstimeBall::Create( pSpawner->GetAbsOrigin(), QAngle(0,0,0) );
}
StopAskForBallEffects();
m_hBall->SetStateFree();
m_hBall->MoveToSpawner( pSpawner->GetAbsOrigin() );
m_hBall->ChangeTeam( pSpawner->GetTeamNumber() );
m_onBallFree.FireOutput( m_hBall, this );
pSpawner->m_onSpawnBall.FireOutput( pSpawner, pSpawner );
TFGameRules()->BroadcastSound( 255, "Passtime.BallSpawn" );
if ( TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
{
TFGameRules()->BroadcastSound( 255, "Passtime.Merasmus.Laugh" );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::StopAskForBallEffects()
{
for( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer )
{
pPlayer->m_Shared.SetAskForBallTime( 0 );
}
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnBallCarrierMeleeHit( CTFPlayer *pPlayer, CTFPlayer *pAttacker )
{
// TODO refactor OnBallCarrierMeleeHit and OnBallCarrierDamaged for less copypasta
if ( !pPlayer || !pAttacker || (pPlayer == pAttacker) || !TFGameRules() )
{
// shouldn't happen, but who knows
return;
}
Assert( pPlayer->m_Shared.HasPasstimeBall() );
if ( !pPlayer->m_Shared.HasPasstimeBall() )
{
return;
}
if ( !pPlayer->InSameTeam( pAttacker) )
{
// currently handled by OnBallCarrierDamaged
return;
}
Assert( m_hBall );
if( !m_hBall )
{
return;
}
bool bTooLong = (m_hBall->GetCarryDuration() > tf_passtime_teammate_steal_time.GetFloat());
if ( pPlayer->m_bPasstimeBallSlippery || bTooLong )
{
// once a player has held the ball too long, mark them as a jerk
// so they can't hoard the ball ever again
StealBall( pPlayer, pAttacker );
pPlayer->m_bPasstimeBallSlippery = true;
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnBallCarrierDamaged( CTFPlayer *pPlayer, CTFPlayer *pAttacker,
const CTakeDamageInfo& info )
{
// TODO refactor OnBallCarrierMeleeHit and OnBallCarrierDamaged for less copypasta
// NOTE: it's possible that neither player has the ball if the attacker
// killed the carrier, which would cause EjectBall to happen before
// this call. There's no good way around it.
if ( !pPlayer || !pAttacker || (pPlayer == pAttacker) || !TFGameRules() )
{
// happens from world damage
return;
}
//
// Only care about melee damage
//
// DMG_CLUB is demo charge
if ( !tf_passtime_steal_on_melee.GetBool() || !(info.GetDamageType() & (DMG_MELEE | DMG_CLUB)) )
{
return;
}
Assert( m_hBall );
if ( !m_hBall )
{
return;
}
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BASEBALL )
{
auto launch = CPasstimeGun::CalcLaunch( pPlayer, false );
LaunchBall(pPlayer, launch.startPos, launch.startVel );
}
else
{
StealBall( pPlayer, pAttacker );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::CrowdReactionSound( int iTeam )
{
if ( m_flNextCrowdReactionTime <= gpGlobals->curtime )
{
TFGameRules()->BroadcastSound( iTeam, "Passtime.Crowd.React.Pos" );
TFGameRules()->BroadcastSound( GetEnemyTeam( iTeam ), "Passtime.Crowd.React.Neg" );
m_flNextCrowdReactionTime = gpGlobals->curtime + 10.0f;
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::StealBall( CTFPlayer *pFrom, CTFPlayer *pTo )
{
if ( pFrom->m_Shared.HasPasstimeBall() )
{
EjectBall( pFrom, pTo );
}
HudNotification_t cantPickUpReason;
if ( BCanPlayerPickUpBall( pTo, &cantPickUpReason ) )
{
if ( !pFrom->m_bPasstimeBallSlippery )
{
CTF_GameStats.Event_PlayerAwardBonusPoints( pTo, pTo, 10 );
}
TFGameRules()->BroadcastSound( 255, "Passtime.BallStolen" );
++CTF_GameStats.m_passtimeStats.summary.nTotalSteals;
m_hBall->SetStateCarried( pTo );
OnBallGet();
pTo->m_Shared.AddCond( TF_COND_PASSTIME_INTERCEPTION, tf_passtime_speedboost_on_get_ball_time.GetFloat() );
int pointsToAward = 5;
if ( CFuncPasstimeGoalieZone::BPlayerInAny( pTo ) )
{
++CTF_GameStats.m_passtimeStats.summary.nTotalStealsNearGoal;
pointsToAward = 10; // Extra points for last second defend.
}
if ( !pFrom->m_bPasstimeBallSlippery )
{
CTF_GameStats.Event_PlayerAwardBonusPoints( pTo, 0, pointsToAward );
}
PasstimeGameEvents::BallStolen( pFrom->entindex(), pTo->entindex() ).Fire();
CrowdReactionSound( pTo->GetTeamNumber() );
}
else if ( cantPickUpReason )
{
CSingleUserReliableRecipientFilter filter( pTo );
TFGameRules()->SendHudNotification( filter, cantPickUpReason );
}
}
//-----------------------------------------------------------------------------
float CTFPasstimeLogic::GetLastHeldTime( CTFPlayer* pPlayer )
{
float lastHeldTime = 0.0f;
for ( int i = 0; i < m_ballLastHeldTimes.Count(); i++ )
{
if ( m_ballLastHeldTimes[i].first == pPlayer )
{
lastHeldTime = m_ballLastHeldTimes[i].second;
break;
}
}
return lastHeldTime;
}
//-----------------------------------------------------------------------------
float CTFPasstimeLogic::GetLastPassTime( CTFPlayer* pPlayer )
{
float lastPassTime = 0.0f;
for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
{
if ( m_ballLastPassTimes[i].first == pPlayer )
{
lastPassTime = m_ballLastPassTimes[i].second;
break;
}
}
return lastPassTime;
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SetLastPassTime( CTFPlayer* pPlayer )
{
std::pair<CTFPlayer*, float> toAdd( pPlayer, gpGlobals->realtime );
bool skipTheRest = false;
for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
{
if ( m_ballLastPassTimes[i].first == pPlayer )
{
m_ballLastPassTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
skipTheRest = true;
break;
}
}
if ( !skipTheRest )
{
m_ballLastPassTimes.AddToTail( toAdd );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::EjectBall( CTFPlayer *pPlayer, CTFPlayer *pAttacker )
{
if ( !m_hBall )
{
// I'm not sure how this is possible, but if I'm recording with hltv in
// a listen server that has bots in it (which requires a hack in the bot
// concommand) and I restart the game while a bot is holding the ball...
// then m_hBall is invalid.
if ( pPlayer )
{
// This has to be true to get into this function for the case I just
// described above, and since the ball has been deleted somehow during
// the round restart, it probably isn't necessary to set this to 0
// because the player's going to be reset anyway. But I want to make
// sure it's correct.
pPlayer->m_Shared.SetHasPasstimeBall( 0 );
}
return;
}
m_hBall->SetStateFree();
m_hBall->ChangeTeam( TEAM_UNASSIGNED );
Vector vecEjectVel( 0, 0, 600 );
vecEjectVel += pPlayer->GetAbsVelocity() * 0.1f;
m_hBall->MoveTo( pPlayer->GetAbsOrigin() + Vector( 0, 0, 32 ), vecEjectVel );
if ( pPlayer != pAttacker )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_LOST_OBJECT );
pAttacker->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_TAUNTS );
}
m_onBallFree.FireOutput( m_hBall, this );
std::pair<CTFPlayer*, float> toAdd( pPlayer, gpGlobals->realtime );
for ( int i = 0; i < m_ballLastHeldTimes.Count(); i++ )
{
if ( m_ballLastHeldTimes[i].first == pPlayer )
{
m_ballLastHeldTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
return;
}
}
m_ballLastHeldTimes.AddToTail( toAdd );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::LaunchBall( CTFPlayer *pPlayer, const Vector &vecPos, const Vector &vecVel )
{
StopAskForBallEffects();
m_hBall->SetStateFree();
m_hBall->MoveTo( vecPos, vecVel );
m_onBallFree.FireOutput( m_hBall, this );
std::pair<CTFPlayer*, float> toAdd( pPlayer, gpGlobals->realtime );
for ( int i = 0; i < m_ballLastHeldTimes.Count(); i++ )
{
if ( m_ballLastHeldTimes[i].first == pPlayer )
{
m_ballLastHeldTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
return;
}
}
m_ballLastHeldTimes.AddToTail( toAdd );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Score( CTFPlayer *pPlayer, CFuncPasstimeGoal *pGoal )
{
Assert( pPlayer && pGoal );
pGoal->OnScore( pPlayer->GetTeamNumber() );
Score( pPlayer, pGoal->GetTeamNumber(), pGoal->Points(), pGoal->BWinOnScore() );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Score( CPasstimeBall *pBall, CFuncPasstimeGoal *pGoal )
{
Assert( pBall && pGoal );
CTFPlayer* pPlayer = pBall->GetThrower();
Assert( pPlayer );
pGoal->OnScore( pPlayer->GetTeamNumber() );
Score( pPlayer, pGoal->GetTeamNumber(), pGoal->Points(), pGoal->BWinOnScore() );
}
//-----------------------------------------------------------------------------
// static
void CTFPasstimeLogic::AddCondToTeam( ETFCond eCond, int iTeam, float flTime )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pTFPlayer && (pTFPlayer->GetTeamNumber() == iTeam) && pTFPlayer->IsAlive() )
{
pTFPlayer->m_Shared.AddCond( eCond, flTime );
}
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::Score( CTFPlayer *pPlayer, int iTeam, int iPoints, bool bForceWin )
{
StopAskForBallEffects();
m_pRespawnCountdown->Disable();
Assert( pPlayer );
if ( !pPlayer || ( iTeam == TEAM_UNASSIGNED ) )
{
return;
}
if ( bForceWin )
{
iPoints = MAX( 1, tf_passtime_scores_per_round.GetInt() - TFTeamMgr()->GetFlagCaptures( iTeam ) );
}
//
// Update stats
//
++CTF_GameStats.m_passtimeStats.summary.nTotalScores;
++CTF_GameStats.m_passtimeStats.classes[ pPlayer->GetPlayerClass()->GetClassIndex() ].nTotalScores;
CTF_GameStats.Event_PlayerCapturedPoint( pPlayer );
//
// Award player points
//
CTF_GameStats.Event_PlayerAwardBonusPoints( pPlayer, 0, 25 );
//
// Award player assist points
//
{
CTFPlayer *pAssister = nullptr;
float flAssisterTime = FLT_MAX;
for ( unsigned short i = 0; i < m_ballLastHeldTimes.Count(); i++ )
{
auto &tempPair = m_ballLastHeldTimes[i];
auto *pPossibleAssister = tempPair.first;
auto timeLastHeld = tempPair.second;
auto flSecAgo = gpGlobals->realtime - timeLastHeld;
if ( ( pPossibleAssister->GetTeamNumber() == pPlayer->GetTeamNumber() )
&& ( pPossibleAssister != pPlayer )
&& ( flSecAgo < 10.0f )
&& ( flSecAgo < flAssisterTime ) )
{
pAssister = pPossibleAssister;
flAssisterTime = flSecAgo;
}
}
if ( pAssister )
{
CTF_GameStats.Event_PlayerAwardBonusPoints( pAssister, 0, 10 );
PasstimeGameEvents::Score( pPlayer->entindex(), pAssister->entindex(), iPoints ).Fire();
}
else
{
PasstimeGameEvents::Score( pPlayer->entindex(), iPoints ).Fire();
}
}
//
// Award team points
//
while ( iPoints-- > 0 )
{
TFTeamMgr()->IncrementFlagCaptures( iTeam );
}
//
// Award bonus conditions
//
AddCondToTeam( TF_COND_CRITBOOSTED_CTF_CAPTURE, pPlayer->GetTeamNumber(), tf_passtime_score_crit_sec.GetFloat() );
//
// Feedback
//
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_FLAGCAPTURED );
TFGameRules()->BroadcastSound( iTeam, "Passtime.Crowd.Cheer" );
TFGameRules()->BroadcastSound( GetEnemyTeam( iTeam ), "Passtime.Crowd.Boo" );
if ( TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
{
const char* pszSound = ( iTeam == TF_TEAM_RED )
? "sf14.Merasmus.Soccer.GoalRed"
: "sf14.Merasmus.Soccer.GoalBlue";
TFGameRules()->BroadcastSound( 255, pszSound );
}
//
// Game state management
//
ClearBallPower();
m_hBall->SetStateOutOfPlay();
MoveBallToSpawner(); // move it now instead of when it spawns to avoid lerping
//
// Finish round or respawn ball
//
CTeamRoundTimer *pRoundTimer = TFGameRules()->GetActiveRoundTimer();
if ( ( TFGameRules()->State_Get() == GR_STATE_STALEMATE ) || ( pRoundTimer && ( pRoundTimer->GetTimeRemaining() <= 0.0f ) ) )
{
EndRoundExpiredTimer();
}
else
{
SetContextThink( &CTFPasstimeLogic::RespawnBall, gpGlobals->curtime, "spawnball" );
}
//
// Fire outputs
//
m_onScoreAny.FireOutput( pPlayer, this );
if( iTeam == TF_TEAM_RED )
{
m_onScoreRed.FireOutput( pPlayer, this );
}
else if( iTeam == TF_TEAM_BLUE )
{
m_onScoreBlu.FireOutput( pPlayer, this );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnPlayerTouchBall( CTFPlayer *pCatcher, CPasstimeBall *pBall )
{
if ( pBall != m_hBall )
{
return;
}
const int iCatcherTeam = pCatcher->GetTeamNumber();
float flFeet = pBall->GetAirtimeDistance() / 16.0f;
auto iExperiment = (EPasstimeExperiment_Telepass) tf_passtime_experiment_telepass.GetInt();
//
// Check for pass and interception
//
CTFPlayer *pThrower = pBall->GetThrower();
if ( pThrower // ball must must have been thrown...
&& (pBall->GetCollisionCount() == 0) // and not bounced...
&& (pBall->GetTeamNumber() != TEAM_UNASSIGNED) // and not be neutral...
&& (pCatcher != pBall->GetPrevCarrier())) // and not passed to yourself...
{
PasstimeGameEvents::PassCaught( pThrower->entindex(), pCatcher->entindex(), flFeet, pBall->GetAirtimeSec() ).Fire();
bool bAllowCheerSound = true;
int iDistanceBonus = ( int ) ( pBall->GetAirtimeSec() * tf_passtime_powerball_airtimebonus.GetFloat() );
iDistanceBonus = clamp( iDistanceBonus, 0, tf_passtime_powerball_maxairtimebonus.GetInt() );
int iPassPoints = tf_passtime_powerball_passpoints.GetInt();
AddBallPower( iPassPoints + iDistanceBonus );
bAllowCheerSound = m_iBallPower < tf_passtime_powerball_threshold.GetInt();
CPASFilter pasFilter( pCatcher->GetAbsOrigin() );
pCatcher->EmitSound( pasFilter, pCatcher->entindex(), "Passtime.BallCatch" );
// make sure this happens before BeginCarry/SEtOwner etc
if ( pThrower->GetTeamNumber() == iCatcherTeam )
{
if ( pBall->GetHomingTarget() )
{
// pass was caught by teammate
++CTF_GameStats.m_passtimeStats.summary.nTotalPassesCompleted;
CTF_GameStats.m_passtimeStats.AddPassTravelDistSample( pBall->GetAirtimeDistance() );
// award bonus effects for pass
pCatcher->m_Shared.AddCond( TF_COND_SPEED_BOOST, tf_passtime_speedboost_on_get_ball_time.GetFloat() );
if ( CFuncPasstimeGoalieZone::BPlayerInAny( pCatcher ) )
{
++CTF_GameStats.m_passtimeStats.summary.nTotalPassesCompletedNearGoal;
}
if ( iExperiment != EPasstimeExperiment_Telepass::None )
{
// origins need to be a copy
auto throwerOrigin = pThrower->GetAbsOrigin();
auto catcherOrigin = pCatcher->GetAbsOrigin();
CPVSFilter filterThrower( throwerOrigin );
switch( pThrower->GetTeamNumber() )
{
case TF_TEAM_RED:
TE_TFParticleEffect( filterThrower, 0.0, "teleported_red", throwerOrigin, vec3_angle );
TE_TFParticleEffect( filterThrower, 0.0, "player_sparkles_red", throwerOrigin, vec3_angle, pThrower, PATTACH_ABSORIGIN );
break;
case TF_TEAM_BLUE:
TE_TFParticleEffect( filterThrower, 0.0, "teleported_blue", throwerOrigin, vec3_angle );
TE_TFParticleEffect( filterThrower, 0.0, "player_sparkles_blue", throwerOrigin, vec3_angle, pThrower, PATTACH_ABSORIGIN );
break;
default:
break;
}
pThrower->EmitSound( "Building_Teleporter.Send" );
pCatcher->EmitSound( "Building_Teleporter.Receive" );
// then move the player
pThrower->Teleport( &catcherOrigin, nullptr, nullptr );
if ( iExperiment == EPasstimeExperiment_Telepass::SwapWithCatcher )
{
pCatcher->Teleport( &throwerOrigin, nullptr, nullptr );
CPVSFilter filterCatcher( catcherOrigin );
switch( pCatcher->GetTeamNumber() )
{
case TF_TEAM_RED:
TE_TFParticleEffect( filterCatcher, 0.0, "teleported_red", catcherOrigin, vec3_angle );
TE_TFParticleEffect( filterCatcher, 0.0, "player_sparkles_red", catcherOrigin, vec3_angle, pCatcher, PATTACH_ABSORIGIN );
break;
case TF_TEAM_BLUE:
TE_TFParticleEffect( filterCatcher, 0.0, "teleported_blue", catcherOrigin, vec3_angle );
TE_TFParticleEffect( filterCatcher, 0.0, "player_sparkles_blue", catcherOrigin, vec3_angle, pCatcher, PATTACH_ABSORIGIN );
break;
default:
break;
}
}
// then start the effects
pThrower->TeleportEffect();
}
}
else
{
// toss was caught by teammate
++CTF_GameStats.m_passtimeStats.summary.nTotalTossesCompleted;
}
float lastPassTime = 0.0f;
for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
{
if ( m_ballLastPassTimes[i].first == pThrower)
{
lastPassTime = m_ballLastPassTimes[i].second;
break;
}
}
// successful pass
if ( flFeet > 30 )
{
// fanfare and points if the pass was long enough (and we haven't been spamming throw/catch for points)
if ( gpGlobals->realtime - lastPassTime > 6.0f ) // FIXME literal balance value
{
CTF_GameStats.Event_PlayerAwardBonusPoints( pThrower, pThrower, 15 ); // FIXME literal balance value
}
if ( bAllowCheerSound && ( pBall->GetAirtimeSec() > 2.0f ) ) // FIXME literal balance value
{
TFGameRules()->BroadcastSound( 255, "TFPlayer.StunImpactRange" );
}
}
else// flFeet <= 30
{
// (points conditional on we haven't had the ball in the last 6 seconds)
if ( gpGlobals->realtime - lastPassTime > 6.0f ) // FIXME literal balance value
{
CTF_GameStats.Event_PlayerAwardBonusPoints( pThrower, pThrower, 5 ); // FIXME literal balance value
}
}
std::pair<CTFPlayer*, float> toAdd( pThrower, gpGlobals->realtime );
bool skipTheRest = false;
for ( int i = 0; i < m_ballLastPassTimes.Count(); i++ )
{
if ( m_ballLastPassTimes[i].first == pThrower)
{
m_ballLastPassTimes[i].second = toAdd.second;// replace old time rather than add a new pair to the vector
skipTheRest = true;
break;
}
}
if ( !skipTheRest )
{
m_ballLastPassTimes.AddToTail( toAdd );
}
}
else
{
if ( pBall->GetHomingTarget() )
{
// pass was intercepted
++CTF_GameStats.m_passtimeStats.summary.nTotalPassesIntercepted;
CTF_GameStats.m_passtimeStats.AddPassTravelDistSample( pBall->GetAirtimeDistance() );
}
else
{
// toss was intercepted
++CTF_GameStats.m_passtimeStats.summary.nTotalTossesIntercepted;
}
// interception can happen at any range, extra points if intercepted within the goal area
int bonusPointsToAward = 15; // FIXME literal balance value
if ( CFuncPasstimeGoalieZone::BPlayerInAny( pCatcher ) )
{
bonusPointsToAward = 25; // FIXME literal balance value
if ( pBall->GetHomingTarget() )
{
++CTF_GameStats.m_passtimeStats.summary.nTotalPassesInterceptedNearGoal;
}
else
{
++CTF_GameStats.m_passtimeStats.summary.nTotalTossesInterceptedNearGoal;
}
}
// award bonus effects for interception
pCatcher->m_Shared.AddCond( TF_COND_PASSTIME_INTERCEPTION, tf_passtime_speedboost_on_get_ball_time.GetFloat() );
pCatcher->m_Shared.AddCond( TF_COND_SPEED_BOOST, tf_passtime_speedboost_on_get_ball_time.GetFloat() );
CTF_GameStats.Event_PlayerAwardBonusPoints( pCatcher, pCatcher, bonusPointsToAward );
TFGameRules()->BroadcastSound( 255, "Passtime.BallIntercepted" );
CrowdReactionSound( pCatcher->GetTeamNumber() );
}
}
else
{
++CTF_GameStats.m_passtimeStats.summary.nTotalRecoveries;
CTFPlayer *pPrevCarrier = pBall->GetPrevCarrier();
if ( pCatcher != pPrevCarrier )
{
// Gain a point for picking up a neutral ball.
CTF_GameStats.Event_PlayerAwardBonusPoints( pCatcher, pThrower, 5 ); // FIXME literal balance value
}
PasstimeGameEvents::BallGet( pCatcher->entindex() ).Fire();
}
if ( ((iExperiment == EPasstimeExperiment_Telepass::TeleportToCatcherMaintainPossession)
|| (iExperiment == EPasstimeExperiment_Telepass::SwapWithCatcher))
&& BCanPlayerPickUpBall( pThrower, nullptr ) )
{
EjectBall( pCatcher, pThrower );
m_hBall->SetStateCarried( pThrower );
OnBallGet();
}
else
{
pBall->SetStateCarried( pCatcher );
OnBallGet();
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::OnBallGet()
{
StopAskForBallEffects();
if ( CTFPlayer *pPlayer = m_hBall->GetCarrier() )
{
m_onBallGetAny.FireOutput( pPlayer, this );
if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
{
m_onBallGetRed.FireOutput( pPlayer, this );
}
else if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
m_onBallGetBlu.FireOutput( pPlayer, this );
}
CPasstimeBallController::BallPickedUp( m_hBall, pPlayer );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputSpawnBall( inputdata_t &input )
{
RespawnBall();
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputTimeUp( inputdata_t &input )
{
int iRedScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_RED );
int iBlueScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_BLUE );
int iPointDifference = abs( iRedScore - iBlueScore );
// going through the list of goals to calculate the max possible point gain
// is possible but tricky since goals can be enabled/disabled and there's no
// way to know which goals are actually possible to score in, so this is
// simply hard-coded to work correctly for the official maps where there's
// a 3-point unlockable goal.
int iMaxPossibleScoreGain = 3;
if ( ( iPointDifference <= iMaxPossibleScoreGain ) && !ShouldEndOvertime() )
{
m_pRespawnCountdown->Disable();
TFGameRules()->BroadcastSound( 255, "Game.Overtime" );
ThinkExpiredTimer();
}
else
{
EndRoundExpiredTimer();
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::ThinkExpiredTimer()
{
if ( TFGameRules() && (TFGameRules()->State_Get() != GR_STATE_RND_RUNNING) )
{
if ( m_pRespawnCountdown )
{
// just in case
m_pRespawnCountdown->Disable();
}
return;
}
if ( ShouldEndOvertime() || m_pRespawnCountdown->Tick( gpGlobals->frametime ) )
{
EndRoundExpiredTimer();
return;
}
// Check again every frame until either something else ends the round
// or the conditions are met that allow an expired timer to end the round.
SetContextThink( &CTFPasstimeLogic::ThinkExpiredTimer, gpGlobals->curtime, "ThinkExpiredTimer" );
Assert( m_hBall ); // verified in ShouldEndOvertime
Assert( m_pRespawnCountdown ); // always valid after Spawn
bool bBallUnassigned = m_hBall->GetTeamNumber() == TEAM_UNASSIGNED;
bool bCountdownRunning = !m_pRespawnCountdown->IsDisabled();
if ( bBallUnassigned && !bCountdownRunning )
{
// start the countdown when the ball turns neutral
m_pRespawnCountdown->Start( tf_passtime_overtime_idle_sec.GetFloat() );
}
else if ( !bBallUnassigned && bCountdownRunning )
{
// stop the countdown when the ball is picked up
m_pRespawnCountdown->Disable();
}
}
//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::ShouldEndOvertime() const
{
if ( !m_hBall || !TFGameRules() )
{
return true;
}
// if nobody has the ball, only the respawn countdown can end overtime
CTFPlayer *pBallCarrier = m_hBall->GetCarrier();
if ( m_hBall->GetTeamNumber() == TEAM_UNASSIGNED || !pBallCarrier )
{
return false;
}
// if the teams are tied, someone has to score
int iRedScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_RED );
int iBluScore = TFTeamMgr()->GetFlagCaptures( TF_TEAM_BLUE );
if ( iRedScore == iBluScore )
{
return false;
}
// if the winning team has posession, they win
int iWinningTeam = ( iRedScore > iBluScore )
? TF_TEAM_RED
: TF_TEAM_BLUE;
return pBallCarrier->GetTeamNumber() == iWinningTeam;
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::EndRoundExpiredTimer()
{
StopAskForBallEffects();
m_pRespawnCountdown->Disable();
SetContextThink( &CTFPasstimeLogic::ThinkExpiredTimer, TICK_NEVER_THINK, "ThinkExpiredTimer" );
// copied from TeamplayRoundBasedGameRules::State_Think_RND_RUNNING
int iDrawScoreCheck = -1;
int iWinningTeam = 0;
bool bTeamsAreDrawn = true;
for ( int i = FIRST_GAME_TEAM; (i < GetNumberOfTeams()) && bTeamsAreDrawn; i++ )
{
int iTeamScore = TFTeamMgr()->GetFlagCaptures( i );
if ( iTeamScore > iDrawScoreCheck )
{
iWinningTeam = i;
}
if ( iTeamScore != iDrawScoreCheck )
{
if ( iDrawScoreCheck == -1 )
{
iDrawScoreCheck = iTeamScore;
}
else
{
bTeamsAreDrawn = false;
}
}
}
if ( bTeamsAreDrawn )
{
TFGameRules()->SetStalemate( STALEMATE_SERVER_TIMELIMIT, true );
}
else
{
TFGameRules()->SetWinningTeam( iWinningTeam, WINREASON_TIMELIMIT, true, false, false );
}
}
//-----------------------------------------------------------------------------
struct SetSectionParams
{
int num;
CPathTrack *pSectionStart;
CPathTrack *pSectionEnd;
SetSectionParams() : num(-1), pSectionStart(0), pSectionEnd(0) {}
};
//-----------------------------------------------------------------------------
bool CTFPasstimeLogic::ParseSetSection( const char *pStr, SetSectionParams &s ) const
{
char pszStartName[64];
char pszEndName[64];
const int iScanCount = sscanf( pStr, "%i %s %s", &s.num, pszStartName, pszEndName ); // WHAT YEAR IS IT
if ( iScanCount != 3 )
{
return false;
}
s.pSectionStart = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( 0, pszStartName ) );
s.pSectionEnd = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( 0, pszEndName ) );
if ( s.num < 0 )
Warning( "SetSection number (%i) must be > 0\n", s.num );
if ( s.num >= m_iNumSections )
Warning( "SetSection number (%i) must be < section count (%i)\n", s.num, m_iNumSections.Get() );
if ( !s.pSectionStart )
Warning( "Failed to find section start path_track named %s\n", pszStartName );
if ( !s.pSectionEnd)
Warning( "Failed to find section end path_track named %s\n", pszEndName );
return (s.num >= 0)
&& (s.num < m_iNumSections)
&& s.pSectionStart
&& s.pSectionEnd;
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputSetSection( inputdata_t &input )
{
SetSectionParams params;
if ( !ParseSetSection( input.value.String(), params ) )
{
Warning( "Error in SetSection input: %s\n", input.value.String() );
return;
}
for ( int i = 0; i < m_trackPoints.Count(); ++i )
{
m_trackPoints.GetForModify(i).Zero();
}
int iTrackPoint = 0;
for ( CPathTrack *pTrack = params.pSectionStart; pTrack; pTrack = pTrack->GetNext(), ++iTrackPoint )
{
if ( iTrackPoint == m_trackPoints.Count() )
{
Warning( "Too many track_path in section (%i max, easily changed but must be fixed).", m_trackPoints.Count() );
return;
}
m_trackPoints.Set( iTrackPoint, pTrack->GetAbsOrigin() );
if ( pTrack->GetAbsOrigin() == Vector( 0, 0, 0 ) )
{
// Because I'm using 0,0,0 to represent "no point" in a fixed 16-element array
Warning( "Can't have track_path at 0,0,0" );
}
if ( pTrack == params.pSectionEnd )
{
break;
}
}
m_iCurrentSection = params.num;
}
//
// Secret Room
//
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SecretRoom_Spawn()
{
SECRETROOM_LOG( "@@@@ SECRET ROOM: Spawn\n" );
m_SecretRoom_pTv = gEntList.FindEntityByName( nullptr, "tv" );
string_t self = GetEntityName();
// plug_breakable.OnDamaged -> this.InputPlugDamaged
HookOutput( "plug_breakable", self, "OnDamaged", "staticc", nullptr, 1 );
// player triggers
// the names are generated gibberish words
// (Blu) (1)Scout: "comillow"
HookOutput( "comillow", self, "OnStartTouch", "statica" );
HookOutput( "comillow", self, "OnEndTouch", "staticb" );
// (Red) (2)Soldier: "unissubs"
HookOutput( "unissubs", self, "OnStartTouch", "statica" );
HookOutput( "unissubs", self, "OnEndTouch", "staticb" );
// (Red) (3)Pyro: "amment"
HookOutput( "amment", self, "OnStartTouch", "statica" );
HookOutput( "amment", self, "OnEndTouch", "staticb" );
// (Blu) (4)Demo: "memagold"
HookOutput( "memagold", self, "OnStartTouch", "statica" );
HookOutput( "memagold", self, "OnEndTouch", "staticb" );
// (Red) (5)Heavy: "subcla"
HookOutput( "subcla", self, "OnStartTouch", "statica" );
HookOutput( "subcla", self, "OnEndTouch", "staticb" );
// (Blu) (6)Engineer: "enempose"
HookOutput( "enempose", self, "OnStartTouch", "statica" );
HookOutput( "enempose", self, "OnEndTouch", "staticb" );
// (Red) (7)Medic: "irlenous"
HookOutput( "irlenous", self, "OnStartTouch", "statica" );
HookOutput( "irlenous", self, "OnEndTouch", "staticb" );
// (Red) (8)Sniper: "donked"
HookOutput( "donked", self, "OnStartTouch", "statica" );
HookOutput( "donked", self, "OnEndTouch", "staticb" );
// (Blu) (9)Spy: "finear"
HookOutput( "finear", self, "OnStartTouch", "statica" );
HookOutput( "finear", self, "OnEndTouch", "staticb" );
// the room trigger for keeping track of who gets the achievement
HookOutput( "room_trigger", self, "OnStartTouch", "RoomTriggerOnTouch" );
g_EventQueue.AddEvent( "room_trigger", "Enable", variant_t(), 0.0f, this, this );
}
//-----------------------------------------------------------------------------
int CTFPasstimeLogic::SecretRoom_CountSlottedPlayers() const
{
int iNumSlotsFilled = 0;
for ( CTFPlayer *pPlayer : m_SecretRoom_slottedPlayers )
{
if ( pPlayer ) ++iNumSlotsFilled;
}
return iNumSlotsFilled;
}
//-----------------------------------------------------------------------------
// this doesn't need a template, but something like this in variant_t.h would
// be nice. Or maybe just some explicit overloaded constructors.
template <typename T> variant_t make_variant( T value );
template <> variant_t make_variant( int value )
{
variant_t v;
v.SetInt( value );
return v;
}
//-----------------------------------------------------------------------------
static void SecretRoom_PlayTvSound( CSoundPatch **ppPatch, int iEntIndex, const char *pSoundName, float flVolume )
{
Assert( ppPatch );
Assert( iEntIndex > 0 );
Assert( pSoundName && *pSoundName );
Assert( flVolume > 0 );
CSoundEnvelopeController &snd = CSoundEnvelopeController::GetController();
if ( *ppPatch )
{
SECRETROOM_LOG( " @@ SECRET ROOM: Destroy sound patch\n" );
snd.SoundDestroy( *ppPatch );
*ppPatch = nullptr;
}
SECRETROOM_LOG( " @@ SECRET ROOM: Create sound patch for %s volume %f\n", pSoundName, flVolume );
CReliableBroadcastRecipientFilter filter;
*ppPatch = snd.SoundCreate( filter, iEntIndex, pSoundName );
snd.Play( *ppPatch, flVolume, PITCH_NORM );
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SecretRoom_UpdateTv( int iNumSlotsFilled )
{
if ( iNumSlotsFilled == 9 )
{
SECRETROOM_LOG( " @@ SECRET ROOM: Update TV all slots filled\n" );
g_EventQueue.AddEvent( "screen", "Skin", make_variant( 3 ), 0.0f, this, this );
SecretRoom_PlayTvSound( &m_SecretRoom_pTvSound,
m_SecretRoom_pTv->entindex(), "Passtime.Tv3", 1.0f );
}
else
{
// sound
float volume = (float)( iNumSlotsFilled + 1 ) / 10.0f;
const char *pSoundName = ( iNumSlotsFilled >= 4 )
? "Passtime.Tv2"
: "Passtime.Tv1";
SECRETROOM_LOG( " @@ SECRET ROOM: Update TV %i slots filled\n", iNumSlotsFilled );
SecretRoom_PlayTvSound( &m_SecretRoom_pTvSound,
m_SecretRoom_pTv->entindex(), pSoundName, volume );
// skin
int iSkin = ( iNumSlotsFilled >= 4 ) ? 2 : 1;
g_EventQueue.AddEvent( "screen", "Skin", make_variant( iSkin ), 0.0f, this, this );
}
}
//-----------------------------------------------------------------------------
struct SecretRoom_TriggerInfo
{
int iIndex;
const char *pTriggerName;
int iClass;
int iTeam;
} static const s_SecretRoom_TriggerInfo[9] =
{
{ 0, "comillow", TF_CLASS_SCOUT, TF_TEAM_BLUE },
{ 1, "unissubs", TF_CLASS_SOLDIER, TF_TEAM_RED },
{ 2, "amment", TF_CLASS_PYRO, TF_TEAM_RED },
{ 3, "memagold", TF_CLASS_DEMOMAN, TF_TEAM_BLUE },
{ 4, "subcla", TF_CLASS_HEAVYWEAPONS, TF_TEAM_RED },
{ 5, "enempose", TF_CLASS_ENGINEER, TF_TEAM_BLUE },
{ 6, "irlenous", TF_CLASS_MEDIC, TF_TEAM_RED },
{ 7, "donked", TF_CLASS_SNIPER, TF_TEAM_RED },
{ 8, "finear", TF_CLASS_SPY, TF_TEAM_BLUE },
};
//-----------------------------------------------------------------------------
static const SecretRoom_TriggerInfo &SecretRoom_GetSlotInfoForTrigger(
const char *pTriggerName )
{
for ( const auto &info : s_SecretRoom_TriggerInfo )
{
if ( !V_strcmp( info.pTriggerName, pTriggerName ) )
{
return info;
}
}
Error( "Invalid trigger" );
// in case some platforms don't have noreturn attribute on Error
static SecretRoom_TriggerInfo unused;
return unused;
}
//-----------------------------------------------------------------------------
// SecretRoom_InputStartTouchPlayerSlot
void CTFPasstimeLogic::statica( inputdata_t &input )
{
SECRETROOM_LOG( "@@@@ SECRET ROOM: Start touch player slot\n" );
if ( m_SecretRoom_state != SecretRoomState::Open )
{
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - state is not open\n" );
// shouldn't happen because triggers should be disabled
return;
}
if ( !input.pCaller || !input.pActivator )
{
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - no caller or activator\n" );
return;
}
CTFPlayer *pActivator = ToTFPlayer( input.pActivator );
SECRETROOM_LOG( " @ SECRET ROOM: Toucher is %s\n", pActivator->GetPlayerName() );
if ( !pActivator || pActivator->IsDead() || !pActivator->IsAlive() )
{
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - bad player\n" );
// not a player or not normal
return;
}
const char *pTriggerName = input.pCaller->GetEntityName().ToCStr();
const auto& info = SecretRoom_GetSlotInfoForTrigger( pTriggerName );
SECRETROOM_LOG( " @ SECRET ROOM: Trigger is %s, slot is %i\n", pTriggerName, info.iIndex );
if ( m_SecretRoom_slottedPlayers[info.iIndex] )
{
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - slot already filled by %s\n", m_SecretRoom_slottedPlayers[info.iIndex]->GetPlayerName() );
// already someone filling the slot
return;
}
int iActivatorTeam = pActivator->GetTeamNumber();
int iActivatorClass = pActivator->GetPlayerClass()->GetClassIndex();
if ( !pActivator
|| ( info.iTeam != iActivatorTeam )
|| ( info.iClass != iActivatorClass ) )
{
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - wrong class %i (%i) or team %i (%i) \n",
iActivatorTeam, info.iTeam, info.iClass, iActivatorClass );
// doesn't match
return;
}
SECRETROOM_LOG( " @ SECRET ROOM: Set slot %i to %s\n", info.iIndex, pActivator->GetPlayerName() );
// set slot
m_SecretRoom_slottedPlayers[info.iIndex] = pActivator;
// either solve puzzle or update effects
int iNumSlotsFilled = SecretRoom_CountSlottedPlayers();
SECRETROOM_LOG( " @ SECRET ROOM: %i slots filled\n", iNumSlotsFilled );
if ( iNumSlotsFilled == 9 )
{
SecretRoom_Solve();
}
else
{
SecretRoom_UpdateTv( iNumSlotsFilled );
}
}
//-----------------------------------------------------------------------------
// SecretRoom_InputEndTouchPlayerSlot
void CTFPasstimeLogic::staticb( inputdata_t &input )
{
SECRETROOM_LOG( "@@@@ SECRET ROOM: End touch player slot\n" );
if ( m_SecretRoom_state != SecretRoomState::Open )
{
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - state is not open\n" );
// shouldn't happen because triggers should be disabled
return;
}
const char *pTriggerName = input.pCaller->GetEntityName().ToCStr();
const auto& info = SecretRoom_GetSlotInfoForTrigger( pTriggerName );
SECRETROOM_LOG( " @ SECRET ROOM: Trigger is %s, slot is %i\n", pTriggerName, info.iIndex );
// input.pActivator can be null if a player disconnects while inside
// the trigger. but there's no way to tell if it's the player occupying
// the slot, so clear the slot just in case
if ( input.pActivator )
{
CTFPlayer *pActivator = ToTFPlayer( input.pActivator );
SECRETROOM_LOG( " @ SECRET ROOM: Toucher is %s\n", pActivator->GetPlayerName() );
if ( !pActivator || pActivator->IsDead() || !pActivator->IsAlive() )
{
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - bad player\n" );
// not a player or not normal
return;
}
if ( m_SecretRoom_slottedPlayers[info.iIndex] != input.pActivator )
{
if ( m_SecretRoom_slottedPlayers[info.iIndex] )
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - slot is held by %s\n", m_SecretRoom_slottedPlayers[info.iIndex]->GetPlayerName() );
else
SECRETROOM_LOG( " @ SECRET ROOM: Ignore - slot is empty\n" );
// slot is empty already or some other player exiting the trigger
// if slot is empty: due to this code not using proper filters,
// this can be caused by players suiciding after changing teams
// while standing inside the trigger, because the suicide happens
// after the team change. this case is the entire reason for
// m_SecretRoom_slottedPlayers.
return;
}
}
// clear the slot
// note: in the case where two matching players are in the trigger
// and the one that entered first exits, the remaining player won't count
// and will have to re-enter the trigger
SECRETROOM_LOG( " @ SECRET ROOM: Clear slot %i\n", info.iIndex );
m_SecretRoom_slottedPlayers[info.iIndex] = nullptr;
// update effects
SecretRoom_UpdateTv( SecretRoom_CountSlottedPlayers() );
}
//-----------------------------------------------------------------------------
// SecretRoom_InputPlugDamaged
void CTFPasstimeLogic::staticc( inputdata_t &input )
{
SECRETROOM_LOG( "@@@@ SECRET ROOM: Plug destroyed\n" );
NOTE_UNUSED( input );
m_SecretRoom_state = SecretRoomState::Open;
// set fx for puzzle open
SecretRoom_UpdateTv( 0 );
// enable triggers
for ( const auto& info : s_SecretRoom_TriggerInfo )
{
g_EventQueue.AddEvent( info.pTriggerName, "Enable",
variant_t(), 0.0f, this, this );
}
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::SecretRoom_Solve()
{
if ( m_SecretRoom_state != SecretRoomState::Open )
{
// paranoia
Assert( m_SecretRoom_state == SecretRoomState::Open );
return;
}
SECRETROOM_LOG( "@@@@ SECRET ROOM: Solved\n" );
m_SecretRoom_state = SecretRoomState::Solved;
// set fx for puzzle solved
g_EventQueue.AddEvent( "light", "TurnOn", variant_t(), 0.0f, this, this );
g_EventQueue.AddEvent( "spotlight", "LightOn", variant_t(), 0.0f, this, this );
g_EventQueue.AddEvent( "tv_particles", "Start", variant_t(), 0.0f, this, this );
g_EventQueue.AddEvent( "screen_image", "Enable", variant_t(), 0.0f, this, this );
SecretRoom_UpdateTv( 9 );
// disable triggers
for ( const auto& info : s_SecretRoom_TriggerInfo )
{
g_EventQueue.AddEvent( info.pTriggerName, "Disable",
variant_t(), 0.0f, this, this );
}
// achieves
for ( auto id : m_SecretRoom_playersThatTouchedRoom )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerBySteamID( id ) );
if ( pPlayer )
{
pPlayer->AwardAchievement( ACHIEVEMENT_TF_PASS_TIME_HAT );
}
}
m_SecretRoom_playersThatTouchedRoom.RemoveAll(); // paranoia
}
//-----------------------------------------------------------------------------
void CTFPasstimeLogic::InputRoomTriggerOnTouch( inputdata_t &input )
{
CTFPlayer *pPlayer = ToTFPlayer( input.pActivator );
if ( !pPlayer || pPlayer->IsBot() )
{
return;
}
CSteamID id;
pPlayer->GetSteamID( &id );
if ( id.IsValid() && ( m_SecretRoom_playersThatTouchedRoom.Find( id ) == -1 ) )
{
SECRETROOM_LOG( "@@@@ SECRET ROOM: Tracking %s for achievement\n", pPlayer->GetPlayerName() );
m_SecretRoom_playersThatTouchedRoom.AddToTail( id );
}
}