source-engine/game/server/tf/func_capture_zone.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

756 lines
20 KiB
C++

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: CTF Flag Capture Zone.
//
//=============================================================================//
#include "cbase.h"
#include "func_capture_zone.h"
#include "tf_player.h"
#include "tf_item.h"
#include "tf_team.h"
#include "tf_gamerules.h"
#include "entity_capture_flag.h"
#include "tf_logic_player_destruction.h"
//=============================================================================
//
// CTF Flag Capture Zone tables.
//
BEGIN_DATADESC( CCaptureZone )
// Keyfields.
DEFINE_KEYFIELD( m_nCapturePoint, FIELD_INTEGER, "CapturePoint" ),
DEFINE_KEYFIELD( m_flCaptureDelay, FIELD_FLOAT, "capture_delay" ),
DEFINE_KEYFIELD( m_flCaptureDelayOffset, FIELD_FLOAT, "capture_delay_offset" ),
DEFINE_KEYFIELD( m_bShouldBlock, FIELD_BOOLEAN, "shouldBlock" ),
// Functions.
DEFINE_FUNCTION( CCaptureZoneShim::Touch ),
// Inputs.
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
// Outputs.
DEFINE_OUTPUT( m_outputOnCapture, "OnCapture" ),
DEFINE_OUTPUT( m_OnCapTeam1, "OnCapTeam1" ),
DEFINE_OUTPUT( m_OnCapTeam2, "OnCapTeam2" ),
DEFINE_OUTPUT( m_OnCapTeam1_PD, "OnCapTeam1_PD" ),
DEFINE_OUTPUT( m_OnCapTeam2_PD, "OnCapTeam2_PD" ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( func_capturezone, CCaptureZone );
IMPLEMENT_SERVERCLASS_ST( CCaptureZone, DT_CaptureZone )
SendPropBool( SENDINFO( m_bDisabled ) ),
END_SEND_TABLE()
IMPLEMENT_AUTO_LIST( ICaptureZoneAutoList );
//=============================================================================
//
// CTF Flag Capture Zone functions.
//
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CCaptureZone::CCaptureZone()
{
m_bShouldBlock = true;
m_flCaptureDelay = 1.1f;
m_flCaptureDelayOffset = 0.025f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCaptureZone::Spawn()
{
InitTrigger();
SetTouch( &CCaptureZoneShim::Touch );
if ( m_bDisabled )
{
SetDisabled( true );
}
m_flNextTouchingEnemyZoneWarning = -1;
AddSpawnFlags( SF_TRIGGER_ALLOW_ALL ); // so we can keep track of who is touching us
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCaptureZone::Activate( void )
{
BaseClass::Activate();
if ( TFGameRules() && ( TFGameRules()->GetGameType() == TF_GAMETYPE_PD ) )
{
SetThink( &CCaptureZone::PlayerDestructionThink );
SetNextThink( gpGlobals->curtime + 0.1 );
}
else
{
SetThink( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCaptureZone::PlayerDestructionThink( void )
{
SetNextThink( gpGlobals->curtime + 0.1 );
if ( !IsDisabled() )
{
bool bRedInZone = false;
bool bBlueInZone = false;
// nothing to do while no-one is touching us
if ( m_hTouchingEntities.Count() == 0 )
return;
// loop through the touching players to figure out the teams involved
for ( int i = 0; i < m_hTouchingEntities.Count(); i++ )
{
CBaseEntity *pEnt = m_hTouchingEntities[i];
if ( pEnt && pEnt->IsPlayer() )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pEnt );
if ( pTFPlayer && pTFPlayer->IsAlive() )
{
if ( pTFPlayer->GetTeamNumber() == TF_TEAM_RED )
{
bRedInZone = true;
}
else if ( pTFPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
bBlueInZone = true;
}
}
}
}
// safety check, but this should have already been caught by the ( m_hTouchingEntities.Count() == 0 ) check above
if ( !bRedInZone && !bBlueInZone )
return;
if ( m_bShouldBlock )
{
// both teams are touching the zone and they block each other
if ( bRedInZone && bBlueInZone )
return;
}
CUtlVector< CTFPlayer* > playerVector;
CollectPlayers( &playerVector, TF_TEAM_RED );
CollectPlayers( &playerVector, TF_TEAM_BLUE, false, APPEND_PLAYERS );
float flCaptureDelay = m_flCaptureDelay - ( m_flCaptureDelayOffset * playerVector.Count() );
// let's see if anyone has any player destruction points to capture
for ( int i = 0; i < m_hTouchingEntities.Count(); i++ )
{
CBaseEntity *pEnt = m_hTouchingEntities[i];
if ( pEnt && pEnt->IsPlayer() )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pEnt );
if ( pTFPlayer && pTFPlayer->IsAlive() )
{
// does this capture point have a team number assigned?
if ( ( GetTeamNumber() != TEAM_UNASSIGNED ) && ( pTFPlayer->GetTeamNumber() != GetTeamNumber() ) )
continue;
if ( pTFPlayer->HasTheFlag() && pTFPlayer->CanScorePointForPD() )
{
CCaptureFlag *pFlag = dynamic_cast< CCaptureFlag* >( pTFPlayer->GetItem() );
int nPoints = pFlag->GetPointValue();
if ( nPoints > 0 )
{
// decrease the number of points
pFlag->AddPointValue( -1 );
// fire the output
switch ( pTFPlayer->GetTeamNumber() )
{
case TF_TEAM_RED:
m_OnCapTeam1_PD.FireOutput( this, this );
break;
case TF_TEAM_BLUE:
m_OnCapTeam2_PD.FireOutput( this, this );
break;
default:
break;
}
IGameEvent *event = gameeventmanager->CreateEvent( "special_score" );
if ( event )
{
event->SetInt( "player", pTFPlayer->entindex() );
gameeventmanager->FireEvent( event );
}
}
// remove this flag if this was the last point
if ( pFlag->GetPointValue() == 0 )
{
UTIL_Remove( pFlag );
}
if ( CTFPlayerDestructionLogic::GetPlayerDestructionLogic() )
{
CTFPlayerDestructionLogic::GetPlayerDestructionLogic()->CalcTeamLeader( pTFPlayer->GetTeamNumber() );
}
pTFPlayer->SetNextScorePointForPD( gpGlobals->curtime + flCaptureDelay );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCaptureZone::ShimTouch( CBaseEntity *pOther )
{
// Is the zone enabled?
if ( IsDisabled() )
return;
// Get the TF player.
CTFPlayer *pPlayer = ToTFPlayer( pOther );
if ( pPlayer )
{
// Check to see if the player has the capture flag.
if ( pPlayer->HasItem() && ( pPlayer->GetItem()->GetItemID() == TF_ITEM_CAPTURE_FLAG ) )
{
CCaptureFlag *pFlag = dynamic_cast<CCaptureFlag*>( pPlayer->GetItem() );
if ( pFlag )
{
// we have a special think that will handle the player destruction flags
if ( pFlag->GetType() == TF_FLAGTYPE_PLAYER_DESTRUCTION )
return;
if ( !pFlag->IsCaptured() )
{
// does this capture point have a team number assigned?
if ( GetTeamNumber() != TEAM_UNASSIGNED )
{
// Check to see if the capture zone team matches the player's team.
if ( pPlayer->GetTeamNumber() != TEAM_UNASSIGNED && pPlayer->GetTeamNumber() != GetTeamNumber() )
{
if ( pFlag->GetType() == TF_FLAGTYPE_CTF )
{
// Do this at most once every 5 seconds
if ( m_flNextTouchingEnemyZoneWarning < gpGlobals->curtime )
{
CSingleUserRecipientFilter filter( pPlayer );
TFGameRules()->SendHudNotification( filter, HUD_NOTIFY_TOUCHING_ENEMY_CTF_CAP );
m_flNextTouchingEnemyZoneWarning = gpGlobals->curtime + 5;
}
}
// else if ( pFlag->GetGameType() == TF_FLAGTYPE_INVADE )
// {
// }
return;
}
}
}
// in MvM, the "flag" is the bomb and is captured when the carrying bot deploys it
if ( TFGameRules()->FlagsMayBeCapped() && !TFGameRules()->IsMannVsMachineMode() )
{
Capture( pOther );
}
}
}
}
}
void CCaptureZone::Capture( CBaseEntity *pOther )
{
CTFPlayer *pPlayer = ToTFPlayer( pOther );
if ( pPlayer )
{
// Check to see if the player has the capture flag and flag is allowed to be captured.
if ( pPlayer->HasItem() && ( pPlayer->GetItem()->GetItemID() == TF_ITEM_CAPTURE_FLAG ) && TFGameRules()->CanFlagBeCaptured( pOther ) )
{
CCaptureFlag *pFlag = dynamic_cast< CCaptureFlag* >( pPlayer->GetItem() );
if ( !pFlag )
return;
// we have a special think that will handle the player destruction flags
if ( pFlag->GetType() == TF_FLAGTYPE_PLAYER_DESTRUCTION )
return;
if ( !pFlag->IsCaptured() )
{
pFlag->Capture( pPlayer, m_nCapturePoint );
// Outputs
m_outputOnCapture.FireOutput( this, this );
switch ( pPlayer->GetTeamNumber() )
{
case TF_TEAM_RED:
m_OnCapTeam1.FireOutput( this, this );
break;
case TF_TEAM_BLUE:
m_OnCapTeam2.FireOutput( this, this );
break;
default:
break;
}
IGameEvent *event = gameeventmanager->CreateEvent( "ctf_flag_captured" );
if ( event )
{
int iCappingTeam = pPlayer->GetTeamNumber();
int iCappingTeamScore = 0;
CTFTeam* pCappingTeam = pPlayer->GetTFTeam();
if ( pCappingTeam )
{
iCappingTeamScore = pCappingTeam->GetFlagCaptures();
}
event->SetInt( "capping_team", iCappingTeam );
event->SetInt( "capping_team_score", iCappingTeamScore );
event->SetInt( "capper", pPlayer->GetUserID() );
event->SetInt( "priority", 9 ); // HLTV priority
gameeventmanager->FireEvent( event );
}
if ( TFGameRules() )
{
if ( TFGameRules()->IsHolidayActive( kHoliday_EOTL ) )
{
TFGameRules()->DropBonusDuck( pPlayer->GetAbsOrigin(), pPlayer, NULL, NULL, false, true );
}
else if ( TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
{
TFGameRules()->DropHalloweenSoulPackToTeam( 5, GetAbsOrigin(), pPlayer->GetTeamNumber(), TEAM_SPECTATOR );
}
}
}
}
else if ( !TFGameRules()->CanFlagBeCaptured( pOther ) && TFGameRules()->IsPowerupMode() )
{
ClientPrint( pPlayer, HUD_PRINTCENTER, "Cannot capture - your flag is not at base!" );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: The timer is always transmitted to clients
//-----------------------------------------------------------------------------
int CCaptureZone::UpdateTransmitState()
{
// ALWAYS transmit to all clients.
return SetTransmitState( FL_EDICT_ALWAYS );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CCaptureZone::IsDisabled( void )
{
return m_bDisabled;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCaptureZone::InputEnable( inputdata_t &inputdata )
{
SetDisabled( false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCaptureZone::InputDisable( inputdata_t &inputdata )
{
SetDisabled( true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCaptureZone::SetDisabled( bool bDisabled )
{
m_bDisabled.Set( bDisabled );
if ( bDisabled )
{
BaseClass::Disable();
SetTouch( NULL );
}
else
{
BaseClass::Enable();
SetTouch( &CCaptureZoneShim::Touch );
}
}
//=============================================================================
//
// Flag Detection Zone tables.
//
BEGIN_DATADESC( CFlagDetectionZone )
DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ),
DEFINE_KEYFIELD( m_bShouldAlarm, FIELD_BOOLEAN, "alarm" ),
// Inputs.
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Test", InputTest ),
// Outputs.
DEFINE_OUTPUT( m_outputOnStartTouchFlag, "OnStartTouchFlag" ),
DEFINE_OUTPUT( m_outputOnEndTouchFlag, "OnEndTouchFlag" ),
DEFINE_OUTPUT( m_outputOnDroppedFlag, "OnDroppedFlag" ),
DEFINE_OUTPUT( m_outputOnPickedUpFlag, "OnPickedUpFlag" ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( func_flagdetectionzone, CFlagDetectionZone );
IMPLEMENT_AUTO_LIST( IFlagDetectionZoneAutoList );
//=============================================================================
//
// Flag Detection Zone functions.
//
CFlagDetectionZone::CFlagDetectionZone()
{
m_bShouldAlarm = false;
}
void CFlagDetectionZone::Spawn()
{
InitTrigger();
if ( m_bDisabled )
{
SetDisabled( true );
}
}
void CFlagDetectionZone::StartTouch( CBaseEntity *pOther )
{
// Is the zone enabled?
if ( IsDisabled() )
return;
if ( pOther->IsPlayer() )
{
EHANDLE hOther;
hOther = pOther;
if ( m_hTouchingPlayers.Find( hOther ) == m_hTouchingPlayers.InvalidIndex() )
{
m_hTouchingPlayers.AddToTail( hOther );
}
}
if ( EntityIsFlagCarrier( pOther ) )
{
EHANDLE hOther;
hOther = pOther;
bool bAdded = false;
if ( m_hTouchingEntities.Find( hOther ) == m_hTouchingEntities.InvalidIndex() )
{
m_hTouchingEntities.AddToTail( hOther );
bAdded = true;
}
m_OnStartTouch.FireOutput( pOther, this );
if ( bAdded && ( m_hTouchingEntities.Count() == 1 ) )
{
// First entity to touch us that passes our filters
m_outputOnStartTouchFlag.FireOutput( pOther, this );
m_OnStartTouchAll.FireOutput( pOther, this );
}
IGameEvent *event = gameeventmanager->CreateEvent( "flag_carried_in_detection_zone" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
}
}
void CFlagDetectionZone::EndTouch( CBaseEntity *pOther )
{
// Is the zone enabled?
if ( IsDisabled() )
return;
if ( pOther->IsPlayer() )
{
EHANDLE hOther;
hOther = pOther;
m_hTouchingPlayers.FindAndRemove( hOther );
}
if ( IsTouching( pOther ) )
{
EHANDLE hOther;
hOther = pOther;
m_hTouchingEntities.FindAndRemove( hOther );
m_OnEndTouch.FireOutput(pOther, this);
// If there are no more entities touching this trigger, fire the lost all touches
// Loop through the touching entities backwards. Clean out old ones, and look for existing
bool bFoundOtherTouchee = false;
int iSize = m_hTouchingEntities.Count();
for ( int i = iSize-1; i >= 0; i-- )
{
EHANDLE hOther;
hOther = m_hTouchingEntities[i];
if ( !hOther )
{
m_hTouchingEntities.Remove( i );
}
else if ( hOther->IsPlayer() && !hOther->IsAlive() )
{
#ifdef STAGING_ONLY
AssertMsg( false, "Dead player [%s] is still touching this trigger at [%f %f %f]", hOther->GetEntityName().ToCStr(), XYZ( hOther->GetAbsOrigin() ) );
Warning( "Dead player [%s] is still touching this trigger at [%f %f %f]", hOther->GetEntityName().ToCStr(), XYZ( hOther->GetAbsOrigin() ) );
#endif
m_hTouchingEntities.Remove( i );
}
else
{
bFoundOtherTouchee = true;
}
}
//FIXME: Without this, triggers fire their EndTouch outputs when they are disabled!
// Didn't find one?
if ( !bFoundOtherTouchee /*&& !m_bDisabled*/ )
{
m_outputOnEndTouchFlag.FireOutput( this, this );
m_OnEndTouchAll.FireOutput( pOther, this);
}
}
}
void CFlagDetectionZone::InputEnable( inputdata_t &inputdata )
{
SetDisabled( false );
}
void CFlagDetectionZone::InputDisable( inputdata_t &inputdata )
{
SetDisabled( true );
}
void CFlagDetectionZone::InputTest( inputdata_t &inputdata )
{
// Loop through the touching entities backwards. Clean out old ones, and look for existing
int iSize = m_hTouchingEntities.Count();
for ( int i = iSize-1; i >= 0; i-- )
{
EHANDLE hOther;
hOther = m_hTouchingEntities[i];
if ( !hOther )
{
m_hTouchingEntities.Remove( i );
}
else if ( hOther->IsPlayer() && !hOther->IsAlive() )
{
#ifdef STAGING_ONLY
AssertMsg( false, "Dead player [%s] is still touching this trigger at [%f %f %f]", hOther->GetEntityName().ToCStr(), XYZ( hOther->GetAbsOrigin() ) );
Warning( "Dead player [%s] is still touching this trigger at [%f %f %f]", hOther->GetEntityName().ToCStr(), XYZ( hOther->GetAbsOrigin() ) );
#endif
m_hTouchingEntities.Remove( i );
}
}
if ( m_hTouchingEntities.Count() )
{
m_OnStartTouch.FireOutput( m_hTouchingEntities[ 0 ], this );
m_outputOnStartTouchFlag.FireOutput( this, this );
}
else
{
m_outputOnEndTouchFlag.FireOutput( this, this );
m_OnEndTouchAll.FireOutput( this, this );
}
}
void CFlagDetectionZone::SetDisabled( bool bDisabled )
{
m_bDisabled = bDisabled;
if ( bDisabled )
{
BaseClass::Disable();
SetTouch( NULL );
}
else
{
BaseClass::Enable();
}
}
void CFlagDetectionZone::FlagDropped( CBasePlayer *pPlayer )
{
EHANDLE hOther;
hOther = pPlayer;
if ( m_hTouchingEntities.Find( hOther ) != m_hTouchingEntities.InvalidIndex() )
{
m_outputOnDroppedFlag.FireOutput( pPlayer, this );
EndTouch( pPlayer );
// Still touching as a non-carrierz
m_hTouchingPlayers.AddToTail( hOther );
}
}
void CFlagDetectionZone::FlagPickedUp( CBasePlayer *pPlayer )
{
EHANDLE hOther;
hOther = pPlayer;
if ( m_hTouchingPlayers.Find( hOther ) != m_hTouchingPlayers.InvalidIndex() )
{
m_outputOnPickedUpFlag.FireOutput( pPlayer, this );
StartTouch( pPlayer );
}
}
bool CFlagDetectionZone::EntityIsFlagCarrier( CBaseEntity *pEntity )
{
// Get the TF player.
CTFPlayer *pPlayer = ToTFPlayer( pEntity );
if ( pPlayer )
{
// Check to see if the player has the capture flag.
if ( pPlayer->HasItem() && ( pPlayer->GetItem()->GetItemID() == TF_ITEM_CAPTURE_FLAG ) )
{
CCaptureFlag *pFlag = dynamic_cast<CCaptureFlag*>( pPlayer->GetItem() );
if ( pFlag && !pFlag->IsCaptured() )
{
return true;
}
}
}
return false;
}
void CFlagDetectionZone::FlagCaptured( CBasePlayer *pPlayer )
{
if ( !pPlayer )
return;
if ( FStrEq( "sd_doomsday", STRING( gpGlobals->mapname ) ) )
{
EHANDLE hOther;
hOther = pPlayer;
if ( m_hTouchingPlayers.Find( hOther ) != m_hTouchingPlayers.InvalidIndex() )
{
int nWinningTeam = pPlayer->GetTeamNumber();
CUtlVector< EHANDLE > winningPlayers;
for ( int i = 0 ; i < m_hTouchingPlayers.Count() ; i++ )
{
EHANDLE hTemp = m_hTouchingPlayers[i];
if ( hTemp && ( hTemp->GetTeamNumber() == nWinningTeam ) )
{
winningPlayers.AddToHead( hTemp );
}
}
// ACHIEVEMENT_TF_MAPS_DOOMSDAY_RIDE_THE_ELEVATOR
if ( winningPlayers.Count() >= 5 )
{
// loop through and award the achievement
for ( int i = 0 ; i < winningPlayers.Count() ; i++ )
{
EHANDLE hTemp = winningPlayers[i];
if ( hTemp )
{
CTFPlayer *pTFPlayer = ToTFPlayer( hTemp );
if ( pTFPlayer )
{
pTFPlayer->AwardAchievement( ACHIEVEMENT_TF_MAPS_DOOMSDAY_RIDE_THE_ELEVATOR );
}
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles if the specified entity is dropped in a detection zone
//-----------------------------------------------------------------------------
void HandleFlagDroppedInDetectionZone( CBasePlayer *pPlayer )
{
for ( int i=0; i<IFlagDetectionZoneAutoList::AutoList().Count(); ++i )
{
CFlagDetectionZone *pZone = static_cast<CFlagDetectionZone *>( IFlagDetectionZoneAutoList::AutoList()[i] );
if ( !pZone->IsDisabled() )
{
pZone->FlagDropped( pPlayer );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles if the specified entity is picked up in a detection zone
//-----------------------------------------------------------------------------
void HandleFlagPickedUpInDetectionZone( CBasePlayer *pPlayer )
{
for ( int i=0; i<IFlagDetectionZoneAutoList::AutoList().Count(); ++i )
{
CFlagDetectionZone *pZone = static_cast<CFlagDetectionZone *>( IFlagDetectionZoneAutoList::AutoList()[i] );
if ( !pZone->IsDisabled() )
{
pZone->FlagPickedUp( pPlayer );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles if the specified entity is captured in a detection zone
//-----------------------------------------------------------------------------
void HandleFlagCapturedInDetectionZone( CBasePlayer *pPlayer )
{
for ( int i=0; i<IFlagDetectionZoneAutoList::AutoList().Count(); ++i )
{
CFlagDetectionZone *pZone = static_cast<CFlagDetectionZone *>( IFlagDetectionZoneAutoList::AutoList()[i] );
if ( !pZone->IsDisabled() )
{
pZone->FlagCaptured( pPlayer );
}
}
}