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.
 
 
 
 
 
 

1288 lines
38 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Entities for use in the Robot Destruction TF2 game mode.
//
//=========================================================================//
#include "cbase.h"
#include "tf_logic_halloween_2014.h"
#include "tf_shareddefs.h"
#include "tf_gamerules.h"
#ifdef GAME_DLL
#include "particle_parse.h"
#include "halloween/tf_weapon_spellbook.h"
#include "tf_weapon_sniperrifle.h"
#include "ai_activity.h"
#include "halloween/halloween_base_boss.h"
#include "halloween/tf_weapon_spellbook.h"
#include "engine/IEngineSound.h"
#include "tf_props.h"
#endif
IMPLEMENT_AUTO_LIST( IMinigameAutoList );
#ifdef GAME_DLL
extern ConVar tf_teleporter_fov_time;
extern ConVar tf_teleporter_fov_start;
ConVar tf_fortune_teller_warning_time( "tf_fortune_teller_warning_time", "2", FCVAR_CHEAT, "Warning time (in second) before fortune teller tells a fortune." );
ConVar tf_fortune_teller_interval_time( "tf_fortune_teller_interval_time", "120", FCVAR_CHEAT, "Time until the next fortune teller event (in second)." );
ConVar tf_fortune_teller_fortune_duration( "tf_fortune_teller_fortune_duration", "30", FCVAR_CHEAT, "Duration of the fortune time." );
ConVar tf_minigame_suddendeath_time( "tf_minigame_suddendeath_time", "-1", FCVAR_CHEAT, "Override Sudden Death Time." );
BEGIN_DATADESC( CTFMiniGame )
DEFINE_KEYFIELD( m_iszYourTeamScoreSound, FIELD_STRING, "your_team_score_sound" ),
DEFINE_KEYFIELD( m_iszEnemyTeamScoreSound, FIELD_STRING, "enemy_team_score_sound" ),
DEFINE_KEYFIELD( m_iszHudResFile, FIELD_STRING, "hud_res_file" ),
DEFINE_KEYFIELD( m_pszTeamSpawnPoint[ TF_TEAM_RED ], FIELD_STRING, "RedSpawn" ),
DEFINE_KEYFIELD( m_pszTeamSpawnPoint[ TF_TEAM_BLUE ], FIELD_STRING, "BlueSpawn" ),
DEFINE_KEYFIELD( m_bMinigameAllowedInRamdomPool, FIELD_BOOLEAN, "InRandomPool" ),
DEFINE_KEYFIELD( m_nMaxScoreForMiniGame, FIELD_INTEGER, "MaxScore" ),
DEFINE_KEYFIELD( m_eScoringType, FIELD_INTEGER, "ScoreType" ),
DEFINE_KEYFIELD( m_flSuddenDeathTime, FIELD_FLOAT, "SuddenDeathTime" ),
DEFINE_OUTPUT( m_OnRedHitMaxScore, "OnRedHitMaxScore" ),
DEFINE_OUTPUT( m_OnBlueHitMaxScore, "OnBlueHitMaxScore" ),
DEFINE_OUTPUT( m_OnTeleportToMinigame, "OnTeleportToMinigame" ),
DEFINE_OUTPUT( m_OnReturnFromMinigame, "OnReturnFromMinigame" ),
DEFINE_OUTPUT( m_OnAllRedDead, "OnAllRedDead" ),
DEFINE_OUTPUT( m_OnAllBlueDead, "OnAllBlueDead" ),
DEFINE_OUTPUT( m_OnSuddenDeathStart, "OnSuddenDeathStart" ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "ScoreTeamRed", InputScoreTeamRed ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "ScoreTeamBlue", InputScoreTeamBlue ),
DEFINE_INPUTFUNC( FIELD_STRING, "ChangeHudResFile", InputChangeHudResFile ),
END_DATADESC()
#endif
LINK_ENTITY_TO_CLASS( tf_base_minigame, CTFMiniGame );
IMPLEMENT_NETWORKCLASS_ALIASED( TFMiniGame, DT_TFMinigame )
BEGIN_NETWORK_TABLE_NOBASE( CTFMiniGame, DT_TFMinigame )
#ifdef CLIENT_DLL
RecvPropArray3( RECVINFO_ARRAY( m_nMinigameTeamScore ), RecvPropInt( RECVINFO( m_nMinigameTeamScore[0] ) ) ),
RecvPropInt( RECVINFO( m_nMaxScoreForMiniGame ) ),
RecvPropString( RECVINFO( m_pszHudResFile ) ),
RecvPropInt( RECVINFO( m_eScoringType ) ),
#else
SendPropArray3( SENDINFO_ARRAY3( m_nMinigameTeamScore ), SendPropInt( SENDINFO_ARRAY( m_nMinigameTeamScore ), -1, SPROP_UNSIGNED | SPROP_VARINT ) ),
SendPropInt( SENDINFO( m_nMaxScoreForMiniGame ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
SendPropString( SENDINFO( m_pszHudResFile ) ),
SendPropInt( SENDINFO( m_eScoringType ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
#endif
END_NETWORK_TABLE()
#define NO_TEAM_ADVANTAGE -1
CTFMiniGame::CTFMiniGame()
{
m_nMaxScoreForMiniGame = 0;
m_nMinigameTeamScore.Set( TF_TEAM_RED, 0 );
m_nMinigameTeamScore.Set( TF_TEAM_BLUE, 0 );
#ifdef GAME_DLL
m_bMinigameAllowedInRamdomPool = true;
m_bIsActive = false;
m_pszTeamSpawnPoint[ TF_TEAM_RED ] = NULL;
m_pszTeamSpawnPoint[ TF_TEAM_BLUE ] = NULL;
m_eMinigameType = MINIGAME_GENERIC;
m_iszYourTeamScoreSound = NULL_STRING;
m_iszEnemyTeamScoreSound = NULL_STRING;
m_flSuddenDeathTime = -1.0f; // No sudden death.
m_iAdvantagedTeam = NO_TEAM_ADVANTAGE;
ListenForGameEvent( "player_death" );
ListenForGameEvent( "player_turned_to_ghost" );
ListenForGameEvent( "player_disconnect" );
ListenForGameEvent( "player_team" );
ListenForGameEvent( "player_spawn" );
#endif
}
#ifdef GAME_DLL
void CTFMiniGame::Spawn()
{
Precache();
BaseClass::Spawn();
V_strncpy( m_pszHudResFile.GetForModify(), STRING( m_iszHudResFile ), MAX_PATH );
}
void CTFMiniGame::Precache()
{
BaseClass::Precache();
if ( m_iszYourTeamScoreSound.ToCStr() )
{
PrecacheScriptSound( m_iszYourTeamScoreSound.ToCStr() );
}
if ( m_iszEnemyTeamScoreSound.ToCStr() )
{
PrecacheScriptSound( m_iszEnemyTeamScoreSound.ToCStr() );
}
}
void CTFMiniGame::FireGameEvent( IGameEvent * pEvent )
{
// Only look for dead players when the round is running or else we'll get
// victories while in the spawn room as we respawn
if ( ( TFGameRules() && TFGameRules()->State_Get() != GR_STATE_RND_RUNNING ) || !m_bIsActive )
return;
const char *pszEventName = pEvent->GetName();
if ( !V_strcmp( pszEventName, "player_turned_to_ghost" )
|| !V_strcmp( pszEventName, "player_disconnect" )
|| !V_strcmp( pszEventName, "player_team" )
|| !V_strcmp( pszEventName, "player_death" )
|| !V_strcmp( pszEventName, "player_spawn" ) )
{
bool bCanWin = true;
// Blue gets the chance to win first
UpdateDeadPlayers( TF_TEAM_RED, m_OnBlueHitMaxScore, m_OnAllRedDead, bCanWin );
UpdateDeadPlayers( TF_TEAM_BLUE, m_OnRedHitMaxScore, m_OnAllBlueDead, bCanWin );
}
}
void CTFMiniGame::TeleportAllPlayers()
{
// remove all projectiles and objects before we go to minigame
TFGameRules()->RemoveAllProjectilesAndBuildings();
CUtlVector< CTFPlayer* > vecTeleportedPlayers;
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_RED, m_pszTeamSpawnPoint[ TF_TEAM_RED ], &vecTeleportedPlayers );
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_BLUE, m_pszTeamSpawnPoint[ TF_TEAM_BLUE ], &vecTeleportedPlayers );
FOR_EACH_VEC( vecTeleportedPlayers, i )
{
OnTeleportPlayerToMinigame( vecTeleportedPlayers[i] );
}
m_iAdvantagedTeam = NO_TEAM_ADVANTAGE; // reset advantage
m_bIsActive = true;
m_OnTeleportToMinigame.FireOutput( this, this );
if ( tf_minigame_suddendeath_time.GetFloat() != -1 )
{
m_flSuddenDeathTime = tf_minigame_suddendeath_time.GetFloat();
DevMsg( "Setting m_flSuddenDeathTime to %f\n", m_flSuddenDeathTime );
}
// If we've got a sudden death start time, trigger a think function callback.
if ( m_flSuddenDeathTime >= 0.0f )
{
SetContextThink( &CTFHalloweenMinigame::SuddenDeathTimeStartThink, gpGlobals->curtime + m_flSuddenDeathTime, "SuddenDeathTimeStart" );
}
}
void CTFMiniGame::OnTeleportPlayerToMinigame( CTFPlayer *pPlayer )
{
// Do a zoom effect
pPlayer->SetFOV( pPlayer, tf_teleporter_fov_start.GetInt() );
pPlayer->SetFOV( pPlayer, 0, 1.f, tf_teleporter_fov_start.GetInt() );
// Screen flash
color32 fadeColor = {255,255,255,100};
UTIL_ScreenFade( pPlayer, fadeColor, 0.25, 0.4, FFADE_IN );
}
void CTFMiniGame::ReturnAllPlayers()
{
// Send everyone back
CUtlVector< CTFPlayer * > vecPlayers;
CollectPlayers( &vecPlayers, TEAM_ANY, false );
FOR_EACH_VEC( vecPlayers, i )
{
vecPlayers[ i ]->ForceRespawn();
}
m_nMinigameTeamScore.Set( TF_TEAM_RED, 0 );
m_nMinigameTeamScore.Set( TF_TEAM_BLUE, 0 );
m_bIsActive = false;
m_OnReturnFromMinigame.FireOutput( this, this );
}
void CTFMiniGame::ScorePointsForTeam( int nTeamNum, int nPoints )
{
// Don't tally more points if a team already hit the max
if ( !m_bIsActive || ( m_nMinigameTeamScore.Get( TF_TEAM_RED ) == m_nMaxScoreForMiniGame ) || ( m_nMinigameTeamScore.Get( TF_TEAM_BLUE ) == m_nMaxScoreForMiniGame ) )
{
return;
}
// Are we playing sudden death right now?
bool bInSuddenDeath = ( m_flSuddenDeathTime == 0.0f );
// Increment score for the appropriate team
auto& nTeamPoints = m_nMinigameTeamScore.GetForModify( nTeamNum );
nTeamPoints += nPoints;
nTeamPoints = clamp( nTeamPoints, 0, m_nMaxScoreForMiniGame );
// If they went to the max score or we're in sudden death, fire winning output.
if ( ( nTeamPoints == m_nMaxScoreForMiniGame ) || bInSuddenDeath )
{
auto& eventMaxScoreHit = ( nTeamNum == TF_TEAM_RED ) ? m_OnRedHitMaxScore : m_OnBlueHitMaxScore;
eventMaxScoreHit.FireOutput( this, this );
CUtlVector<CTFPlayer *> vecPlayers;
CollectPlayers( &vecPlayers, nTeamNum );
for ( auto pPlayer : vecPlayers )
{
HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( pPlayer, kKillEaterEvent_Halloween_MinigamesWon );
IGameEvent *pEvent = gameeventmanager->CreateEvent( "minigame_won" );
if ( pEvent )
{
pEvent->SetInt( "player", pPlayer->GetUserID() );
pEvent->SetInt( "game", GetMinigameType() );
gameeventmanager->FireEvent( pEvent, true );
}
}
}
// Can not be specified, and we dont want to do anything in that case
if ( m_iszYourTeamScoreSound.ToCStr() && *m_iszYourTeamScoreSound.ToCStr()
&& m_iszEnemyTeamScoreSound.ToCStr() && *m_iszEnemyTeamScoreSound.ToCStr() )
{
// Get everyone
CUtlVector< CTFPlayer* > vecPlayer;
CollectPlayers( &vecPlayer );
// Play a sound based on if the scoring team is the player's team
for( CTFPlayer *pPlayer : vecPlayer )
{
EmitSound_t params;
float soundlen = 0;
params.m_flSoundTime = 0;
params.m_pSoundName = NULL;
params.m_pflSoundDuration = &soundlen;
params.m_pSoundName = pPlayer->GetTeamNumber() == nTeamNum ? m_iszYourTeamScoreSound.ToCStr() : m_iszEnemyTeamScoreSound.ToCStr();
params.m_nPitch = RemapValClamped( nTeamPoints, m_nMaxScoreForMiniGame * 0.75, m_nMaxScoreForMiniGame, 100, 120 );
params.m_nFlags |= SND_CHANGE_PITCH;
params.m_flVolume = 0.25f; // Pretty quiet
params.m_nFlags |= SND_CHANGE_VOL;
// Play in the player's ears
CSingleUserRecipientFilter filter( pPlayer );
filter.MakeReliable();
pPlayer->StopSound( params.m_pSoundName );
pPlayer->EmitSound( filter, pPlayer->entindex(), params );
}
}
}
void CTFMiniGame::InputScoreTeamRed( inputdata_t &inputdata )
{
ScorePointsForTeam( TF_TEAM_RED, inputdata.value.Int() );
InternalHandleInputScore( inputdata );
}
void CTFMiniGame::InputScoreTeamBlue( inputdata_t &inputdata )
{
ScorePointsForTeam( TF_TEAM_BLUE, inputdata.value.Int() );
InternalHandleInputScore( inputdata );
}
void CTFMiniGame::InputChangeHudResFile( inputdata_t &inputdata )
{
const char *resFile = inputdata.value.String();
Assert( resFile && resFile[ 0 ] );
if ( resFile && resFile[ 0 ] )
{
V_strncpy( m_pszHudResFile.GetForModify(), resFile, MAX_PATH );
}
}
//-----------------------------------------------------------------------------
// Purpose: Find spawn point entity for specified team
//-----------------------------------------------------------------------------
const char *CTFMiniGame::GetTeamSpawnPointName( int nTeamNum ) const
{
if ( !IsValidTFTeam( nTeamNum ) )
return NULL;
return m_pszTeamSpawnPoint[ nTeamNum ];
}
void CTFMiniGame::UpdateDeadPlayers( int nTeam, COutputEvent& eventWin, COutputEvent& eventAllDead, bool& bCanWin )
{
// Update the score for a team
CUtlVector< CTFPlayer * > vecPlayers;
CollectPlayers( &vecPlayers, nTeam, true );
int nNumDead = 0;
FOR_EACH_VEC( vecPlayers, i )
{
// Tally the number dead/ghosts
if ( vecPlayers[i]->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) || vecPlayers[i]->IsDead() )
++nNumDead;
}
// Only update the score if this is the SCORING_TYPE_PLAYERS_ALIVE mode
if ( m_eScoringType == SCORING_TYPE_PLAYERS_ALIVE )
{
auto& nScore = m_nMinigameTeamScore.GetForModify( nTeam );
nScore = vecPlayers.Count() - nNumDead;
}
// Everyone is dead
if ( nNumDead == vecPlayers.Count() && !vecPlayers.IsEmpty() )
{
m_bIsActive = false;
// If everyone is dead, and we're allowed to win, fire the win event
if ( bCanWin && m_eScoringType == SCORING_TYPE_PLAYERS_ALIVE )
{
eventWin.FireOutput( this, this );
bCanWin = false;
}
// Fire the team dead event
eventAllDead.FireOutput( this, this );
CUtlVector<CTFPlayer *> vecEnemyPlayers;
CollectPlayers( &vecEnemyPlayers, GetEnemyTeam( nTeam ) );
for ( auto pPlayer : vecEnemyPlayers )
{
HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( pPlayer, kKillEaterEvent_Halloween_MinigamesWon );
IGameEvent *pEvent = gameeventmanager->CreateEvent( "minigame_won" );
if ( pEvent )
{
pEvent->SetInt( "player", pPlayer->GetUserID() );
pEvent->SetInt( "game", GetMinigameType() );
gameeventmanager->FireEvent( pEvent, true );
}
}
}
}
// "SuddenDeathTimeStart"
void CTFMiniGame::SuddenDeathTimeStartThink()
{
// If we're active, fire the sudden death time start event.
if ( m_bIsActive )
{
m_flSuddenDeathTime = 0.0f; // In sudden death!
m_OnSuddenDeathStart.FireOutput( this, this );
}
}
#else
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFMiniGame::GetScoreForTeam( int nTeamNum ) const
{
if ( !IsValidTFTeam( nTeamNum ) )
return 0;
return m_nMinigameTeamScore[ nTeamNum ];
}
#endif // GAME_DLL
#ifdef GAME_DLL
BEGIN_DATADESC( CTFHalloweenMinigame )
DEFINE_KEYFIELD( m_eMinigameType, FIELD_INTEGER, "MinigameType" ),
DEFINE_INPUTFUNC( FIELD_VOID, "KartWinAnimationRed", InputKartWinAnimationRed ),
DEFINE_INPUTFUNC( FIELD_VOID, "KartWinAnimationBlue", InputKartWinAnimationBlue ),
DEFINE_INPUTFUNC( FIELD_VOID, "KartLoseAnimationRed", InputKartLoseAnimationRed ),
DEFINE_INPUTFUNC( FIELD_VOID, "KartLoseAnimationBlue", InputKartLoseAnimationBlue ),
DEFINE_INPUTFUNC( FIELD_STRING, "EnableSpawnBoss", InputEnableSpawnBoss ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableSpawnBoss", InputDisableSpawnBoss ),
END_DATADESC()
#endif
LINK_ENTITY_TO_CLASS( tf_halloween_minigame, CTFHalloweenMinigame );
IMPLEMENT_NETWORKCLASS_ALIASED( TFHalloweenMinigame, DT_TFHalloweenMinigame )
BEGIN_NETWORK_TABLE( CTFHalloweenMinigame, DT_TFHalloweenMinigame )
END_NETWORK_TABLE()
#ifdef GAME_DLL
CTFHalloweenMinigame::CTFHalloweenMinigame()
{
m_hBossSpawnPoint = NULL;
ListenForGameEvent( "pumpkin_lord_killed" );
}
void CTFHalloweenMinigame::Spawn()
{
BaseClass::Spawn();
}
void CTFHalloweenMinigame::FireGameEvent( IGameEvent * event )
{
BaseClass::FireGameEvent( event );
if ( FStrEq( event->GetName(), "pumpkin_lord_killed" ) )
{
if ( m_hBossSpawnPoint && ( !m_hHalloweenBoss || m_hHalloweenBoss->IsMarkedForDeletion() ) )
{
m_hHalloweenBoss = CHalloweenBaseBoss::SpawnBossAtPos( HALLOWEEN_BOSS_HHH, m_hBossSpawnPoint->GetAbsOrigin() );
}
}
}
void CTFHalloweenMinigame::InternalHandleInputScore( inputdata_t &inputdata )
{
CPropSoccerBall *pSoccerBall = dynamic_cast< CPropSoccerBall* >( inputdata.pActivator );
if ( pSoccerBall )
{
CTFPlayer *pTFPlayer = pSoccerBall->GetLastToucher();
if ( pTFPlayer && TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
pTFPlayer->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_DOOMSDAY_SCORE_GOALS );
}
}
}
void CTFHalloweenMinigame::TeleportAllPlayers()
{
CUtlVector< CTFPlayer * > vecPlayers;
CollectPlayers( &vecPlayers, TEAM_ANY, false );
FOR_EACH_VEC( vecPlayers, i )
{
CTFPlayer *pPlayer = vecPlayers[i];
// Only do these effects if the player is alive
if ( !pPlayer->IsAlive() )
continue;
// Fade to white
color32 fadeColor = {255,255,255,255};
UTIL_ScreenFade( pPlayer, fadeColor, 2.f, 0.5f, FFADE_OUT | FFADE_PURGE );
// Do a zoom in effect
pPlayer->SetFOV( pPlayer, 10.f, 2.5f, 0.f );
// Rumble like something important happened
UTIL_ScreenShake(pPlayer->GetAbsOrigin(), 100.f, 150, 4.f, 0.f, SHAKE_START, true );
}
// Play a sound for all players
TFGameRules()->BroadcastSound( 255, "Halloween.hellride" );
SetContextThink( &CTFHalloweenMinigame::TeleportAllPlayersThink, gpGlobals->curtime + 2.0f, "TeleportToHell" );
}
void CTFHalloweenMinigame::TeleportAllPlayersThink()
{
RemoveAll2013HalloweenTeleportSpellsInMidFlight();
CUtlVector< CTFPlayer * > vecPlayers;
CollectPlayers( &vecPlayers, TEAM_ANY, false );
BaseClass::TeleportAllPlayers();
FOR_EACH_VEC( vecPlayers, i )
{
CTFPlayer *pPlayer = vecPlayers[i];
pPlayer->CancelEurekaTeleport();
// Fade from white
color32 fadeColor = {255,255,255,255};
UTIL_ScreenFade( pPlayer, fadeColor, 1.f, 0.2f, FFADE_IN );
}
// Set this flag. Lets us check elsewhere if it's hell time
// HACK: Should we be doing this for 2014?!?
if ( TFGameRules() )
{
TFGameRules()->SetPlayersInHell( true );
}
}
void CTFHalloweenMinigame::OnTeleportPlayerToMinigame( CTFPlayer *pPlayer )
{
BaseClass::OnTeleportPlayerToMinigame( pPlayer );
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL );
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_KART );
const float flCageTime = 3.f;
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_KART_CAGE, flCageTime );
pPlayer->m_Shared.AddCond( TF_COND_FREEZE_INPUT, flCageTime );
pPlayer->SetAbsVelocity( vec3_origin );
pPlayer->EmitSound( "BumperCar.Spawn" );
// if its set
if ( m_iAdvantagedTeam != NO_TEAM_ADVANTAGE )
{
if ( pPlayer->GetTeamNumber() != m_iAdvantagedTeam )
{
pPlayer->AddKartDamage( 66 );
}
}
}
void CTFHalloweenMinigame::ReturnAllPlayers()
{
// Set this flag. Lets us check elsewhere if it's hell time
// HACK: Should we be doing this for 2014?!?
if ( TFGameRules() )
{
TFGameRules()->SetPlayersInHell( false );
}
BaseClass::ReturnAllPlayers();
}
void CTFHalloweenMinigame::InputKartWinAnimationRed( inputdata_t &inputdata )
{
CUtlVector< CTFPlayer* > players;
CollectPlayers( &players, TF_TEAM_RED, true );
for ( int i=0; i<players.Count(); ++i )
{
if ( players[i]->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
players[i]->DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, ACT_KART_GESTURE_POSITIVE );
}
}
}
void CTFHalloweenMinigame::InputKartWinAnimationBlue( inputdata_t &inputdata )
{
CUtlVector< CTFPlayer* > players;
CollectPlayers( &players, TF_TEAM_BLUE, true );
for ( int i=0; i<players.Count(); ++i )
{
if ( players[i]->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
players[i]->DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, ACT_KART_GESTURE_POSITIVE );
}
}
}
void CTFHalloweenMinigame::InputKartLoseAnimationRed( inputdata_t &inputdata )
{
CUtlVector< CTFPlayer* > players;
CollectPlayers( &players, TF_TEAM_RED, true );
for ( int i=0; i<players.Count(); ++i )
{
if ( players[i]->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
players[i]->DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, ACT_KART_GESTURE_NEGATIVE );
}
}
}
void CTFHalloweenMinigame::InputKartLoseAnimationBlue( inputdata_t &inputdata )
{
CUtlVector< CTFPlayer* > players;
CollectPlayers( &players, TF_TEAM_BLUE, true );
for ( int i=0; i<players.Count(); ++i )
{
if ( players[i]->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
players[i]->DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, ACT_KART_GESTURE_NEGATIVE );
}
}
}
void CTFHalloweenMinigame::InputEnableSpawnBoss( inputdata_t &inputdata )
{
if ( !m_hBossSpawnPoint )
{
const char *pszSpawnPoint = inputdata.value.String();
if ( pszSpawnPoint )
{
m_hBossSpawnPoint = gEntList.FindEntityByName( NULL, pszSpawnPoint );
}
}
if ( m_hBossSpawnPoint )
{
m_hHalloweenBoss = CHalloweenBaseBoss::SpawnBossAtPos( HALLOWEEN_BOSS_HHH, m_hBossSpawnPoint->GetAbsOrigin() );
}
}
void CTFHalloweenMinigame::InputDisableSpawnBoss( inputdata_t &inputdata )
{
m_hBossSpawnPoint = NULL;
}
#endif
#ifdef GAME_DLL
BEGIN_DATADESC( CTFHalloweenMinigame_FallingPlatforms )
DEFINE_INPUTFUNC( FIELD_VOID, "ChoosePlatform", InputChoosePlatform ),
DEFINE_OUTPUT( m_OutputSafePlatform, "OutputSafePlatform" ),
DEFINE_OUTPUT( m_OutputRemovePlatform, "OutputRemovePlatform" ),
END_DATADESC()
#endif
LINK_ENTITY_TO_CLASS( tf_halloween_minigame_falling_platforms, CTFHalloweenMinigame_FallingPlatforms );
IMPLEMENT_NETWORKCLASS_ALIASED( TFHalloweenMinigame_FallingPlatforms, DT_TFHalloweenMinigame_FallingPlatforms )
BEGIN_NETWORK_TABLE( CTFHalloweenMinigame_FallingPlatforms, DT_TFHalloweenMinigame_FallingPlatforms )
END_NETWORK_TABLE()
#ifdef GAME_DLL
CTFHalloweenMinigame_FallingPlatforms::CTFHalloweenMinigame_FallingPlatforms()
{
// Corners
CUtlVector<int> vecFirstSet;
vecFirstSet.AddToTail( 1 );
vecFirstSet.AddToTail( 3 );
vecFirstSet.AddToTail( 7 );
vecFirstSet.AddToTail( 9 );
vecFirstSet.Shuffle();
// On Axis
CUtlVector<int> vecSecondSet;
vecSecondSet.AddToTail( 2 );
vecSecondSet.AddToTail( 4 );
vecSecondSet.AddToTail( 6 );
vecSecondSet.AddToTail( 8 );
vecSecondSet.Shuffle();
m_vecRemainingPlatforms.AddVectorToTail( vecFirstSet );
m_vecRemainingPlatforms.AddVectorToTail( vecSecondSet );
m_vecRemainingPlatforms.AddToTail( 5 ); // The center
}
void CTFHalloweenMinigame_FallingPlatforms::InputChoosePlatform( inputdata_t &inputdata )
{
variant_t nVal;
// If there's more than 1 platforms remaining, mark another to never come back
if ( m_vecRemainingPlatforms.Count() > 1 )
{
nVal.SetInt( m_vecRemainingPlatforms.Head() );
m_vecRemainingPlatforms.Remove( 0 );
m_OutputRemovePlatform.FireOutput( nVal, this, this );
}
// The which one is supposed to be the safe platform
int nIndex = RandomInt( 0, m_vecRemainingPlatforms.Count() - 1 );
int nSafePlatform = m_vecRemainingPlatforms[ nIndex ];
nVal.SetInt( nSafePlatform );
m_OutputSafePlatform.FireOutput( nVal, this, this );
}
void CTFHalloweenMinigame_FallingPlatforms::FireGameEvent( IGameEvent * pEvent )
{
const char *pszEventName = pEvent->GetName();
// In the falling platforms game, we dont want ghosts to get stuck in platforms.
// This hack sets the collision of ghosts to collide with triggers, but not with
// other players. This should allow us to use the relative teleport trigger on the
// ghosts to prevent stuckage.
if ( m_bIsActive && !V_strcmp( pszEventName, "player_turned_to_ghost" ) )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByUserId( pEvent->GetInt( "userid" ) ) );
if ( pPlayer )
{
pPlayer->SetSolid( SOLID_BBOX );
pPlayer->SetSolidFlags( FSOLID_NOT_STANDABLE );
pPlayer->SetCollisionGroup( COLLISION_GROUP_DEBRIS_TRIGGER ); // Dont run into other players
}
}
BaseClass::FireGameEvent( pEvent );
}
#endif
#ifdef GAME_DLL
BEGIN_DATADESC( CTFMinigameLogic )
DEFINE_INPUTFUNC( FIELD_INTEGER, "TeleportToMinigame", InputTeleportToMinigame ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetAdvantageTeam", InputSetAdvantageTeam ),
DEFINE_INPUTFUNC( FIELD_VOID, "TeleportToRandomMinigame", InputTeleportToRandomMinigame ),
DEFINE_INPUTFUNC( FIELD_VOID, "ReturnFromMinigame", InputReturnFromMinigame ),
END_DATADESC()
#endif
LINK_ENTITY_TO_CLASS( tf_logic_minigames, CTFMinigameLogic );
IMPLEMENT_NETWORKCLASS_ALIASED( TFMinigameLogic, DT_TFMinigameLogic )
BEGIN_NETWORK_TABLE_NOBASE( CTFMinigameLogic, DT_TFMinigameLogic )
#ifdef CLIENT_DLL
RecvPropEHandle( RECVINFO( m_hActiveMinigame ) ),
#else
SendPropEHandle( SENDINFO( m_hActiveMinigame ) ),
#endif
END_NETWORK_TABLE()
CTFMinigameLogic* CTFMinigameLogic::m_sMinigameLogic = NULL;
CTFMinigameLogic::CTFMinigameLogic()
{
m_hActiveMinigame = NULL;
m_sMinigameLogic = this;
#ifdef GAME_DLL
m_iAdvantagedTeam = NO_TEAM_ADVANTAGE;
#endif
}
CTFMinigameLogic::~CTFMinigameLogic()
{
if ( m_sMinigameLogic == this )
{
m_sMinigameLogic = NULL;
}
}
#ifdef GAME_DLL
void CTFMinigameLogic::TeleportToMinigame( int nMiniGameIndex )
{
Assert( m_hActiveMinigame == NULL );
CTFMiniGame *pMinigame = static_cast< CTFMiniGame* >( IMinigameAutoList::AutoList()[ nMiniGameIndex ] );
if ( pMinigame )
{
m_hActiveMinigame = pMinigame;
m_hActiveMinigame->SetAdvantagedTeam( m_iAdvantagedTeam );
m_hActiveMinigame->TeleportAllPlayers( );
m_iAdvantagedTeam = NO_TEAM_ADVANTAGE;
}
}
void CTFMinigameLogic::ReturnFromMinigame()
{
if ( m_hActiveMinigame )
{
m_hActiveMinigame->ReturnAllPlayers();
}
m_hActiveMinigame = NULL;
}
void CTFMinigameLogic::InputTeleportToMinigame( inputdata_t &inputdata )
{
int nInput = inputdata.value.Int();
if ( nInput >= 0 && nInput < IMinigameAutoList::AutoList().Count() )
{
TeleportToMinigame( nInput );
}
}
void CTFMinigameLogic::InputSetAdvantageTeam( inputdata_t &inputdata )
{
m_iAdvantagedTeam = FStrEq( inputdata.value.String(), "red" ) ? TF_TEAM_RED : TF_TEAM_BLUE;
}
void CTFMinigameLogic::InputReturnFromMinigame( inputdata_t &inputdata )
{
ReturnFromMinigame();
}
void CTFMinigameLogic::InputTeleportToRandomMinigame( inputdata_t &inputdata )
{
static int nLastChosenIndex = -1;
CUtlVector< int > m_vecRandomableMiniGames;
FOR_EACH_VEC( IMinigameAutoList::AutoList(), i )
{
CTFMiniGame *pMinigame = static_cast< CTFMiniGame* >( IMinigameAutoList::AutoList()[ i ] );
if ( pMinigame->AllowedInRandom() && nLastChosenIndex != i )
{
m_vecRandomableMiniGames.AddToTail( i );
}
}
if ( !m_vecRandomableMiniGames.IsEmpty() )
{
int nChosenIndex = m_vecRandomableMiniGames[ RandomInt( 0, m_vecRandomableMiniGames.Count() - 1 ) ];
nLastChosenIndex = nChosenIndex;
TeleportToMinigame( nChosenIndex );
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CConditionFortuneTellerEffect
#ifdef GAME_DLL
: public CGameEventListener
#endif
{
public:
CConditionFortuneTellerEffect( const char* pszActivateSound, ETFCond eCond )
: m_pszActivateSound( pszActivateSound )
, m_eCondition( eCond )
, m_bUseTimer( false )
{}
void OnActivateEffect( bool bUseTimer )
{
#ifdef GAME_DLL
m_bUseTimer = bUseTimer;
float flConditionDuration = m_bUseTimer ? tf_fortune_teller_fortune_duration.GetFloat() : PERMANENT_CONDITION;
CUtlVector< CTFPlayer* > vecPlayers;
CollectPlayers<CTFPlayer>( &vecPlayers, TEAM_ANY, true );
for ( CTFPlayer *pPlayer : vecPlayers )
{
// Permanently add condition. We'll remove it when we're done
pPlayer->m_Shared.AddCond( m_eCondition, flConditionDuration );
}
ListenForGameEvent( "player_spawn" );
#endif
}
void OnDeactivateEffect()
{
#ifdef GAME_DLL
m_bUseTimer = false;
StopListeningForAllEvents();
CUtlVector< CTFPlayer* > vecPlayers;
CollectPlayers<CTFPlayer>( &vecPlayers, TEAM_ANY, true );
for ( CTFPlayer *pPlayer : vecPlayers )
{
// We're done. Remove this condition
pPlayer->m_Shared.RemoveCond( m_eCondition );
}
#endif
}
#ifdef GAME_DLL
virtual void FireGameEvent( IGameEvent * event ) OVERRIDE
{
// don't do anything when players are in hell
if ( TFGameRules() && TFGameRules()->ArePlayersInHell() )
return;
float flConditionDuration = m_bUseTimer ? tf_fortune_teller_fortune_duration.GetFloat() : PERMANENT_CONDITION;
// Add the condition to anyone who spawns in
if ( FStrEq( event->GetName(), "player_spawn" ) )
{
const int nUserID = event->GetInt( "userid" );
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByUserId( nUserID ) );
if( pPlayer )
{
pPlayer->m_Shared.AddCond( m_eCondition, flConditionDuration );
}
}
}
#endif
const char *GetActivationSound() const
{
return m_pszActivateSound;
}
const char *m_pszActivateSound;
ETFCond m_eCondition;
bool m_bUseTimer;
};
static CConditionFortuneTellerEffect g_FortuneTellerEffect_BalloonHead = { "Announcer.SD_Event_BigHeadCurse", TF_COND_BALLOON_HEAD }; // FIXME: need 2014 sound link
static CConditionFortuneTellerEffect g_FortuneTellerEffect_MeleeOnly = { "Announcer.SD_Event_NoGunsCurse", TF_COND_MELEE_ONLY };
static CConditionFortuneTellerEffect g_FortuneTellerEffect_SwimmingCurse = { "Announcer.SD_Event_SwimmingCurse", TF_COND_SWIMMING_CURSE }; // FIXME: need 2014 sound link
static CConditionFortuneTellerEffect *g_GlobalFortuneTellerEffects[] =
{
&g_FortuneTellerEffect_BalloonHead,
&g_FortuneTellerEffect_MeleeOnly,
&g_FortuneTellerEffect_SwimmingCurse,
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static const char *s_pszFortuneTellerSpinSound = "Halloween.WheelofFateQuiet";
// Data Description
BEGIN_DATADESC( CTFHalloweenFortuneTeller )
#ifdef GAME_DLL
DEFINE_INPUTFUNC( FIELD_VOID, "EnableFortuneTelling",InputEnableFortuneTelling ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableFortuneTelling",InputDisableFortuneTelling ),
DEFINE_INPUTFUNC( FIELD_VOID, "StartFortuneTelling", InputStartFortuneTelling ),
DEFINE_INPUTFUNC( FIELD_VOID, "EndFortuneTelling", InputEndFortuneTelling ),
DEFINE_OUTPUT( m_OnFortuneWarning, "OnFortuneWarning" ),
DEFINE_OUTPUT( m_OnFortuneTold, "OnFortuneTold" ),
DEFINE_OUTPUT( m_OnFortuneCurse, "OnFortuneCurse" ),
DEFINE_OUTPUT( m_OnFortuneEnd, "OnFortuneEnd" ),
DEFINE_KEYFIELD( m_iszRedTeleport, FIELD_STRING, "red_teleport" ),
DEFINE_KEYFIELD( m_iszBlueTeleport, FIELD_STRING, "blue_teleport" ),
#endif // GAME_DLLs
END_DATADESC()
LINK_ENTITY_TO_CLASS( halloween_fortune_teller, CTFHalloweenFortuneTeller );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFHalloweenFortuneTeller::CTFHalloweenFortuneTeller()
{
#ifdef GAME_DLL
m_bUseTimer = false;
m_bWasUsingTimer = false;
#endif // GAME_DLL
}
CTFHalloweenFortuneTeller::~CTFHalloweenFortuneTeller()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::Precache()
{
PrecacheScriptSound( s_pszFortuneTellerSpinSound );
for ( const auto *pEffect : g_GlobalFortuneTellerEffects )
{
PrecacheScriptSound( pEffect->GetActivationSound() );
}
PrecacheModel( "models/bots/merasmus/merasmas_misfortune_teller.mdl" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::Spawn()
{
Precache();
SetThink( NULL );
SetModel( "models/bots/merasmus/merasmas_misfortune_teller.mdl" );
ResetSequence( LookupSequence( "ref" ) );
#ifdef GAME_DLL
ResetTimer();
ListenForGameEvent( "sentry_on_go_active" );
#endif // GAME_DLLFireGameEvent
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::UpdateOnRemove()
{
#ifdef GAME_DLL
if ( m_pActiveFortune )
{
m_pActiveFortune->OnDeactivateEffect();
m_pActiveFortune = NULL;
}
#endif // GAME_DLL
BaseClass::UpdateOnRemove();
}
#ifdef GAME_DLL
void CTFHalloweenFortuneTeller::InputEnableFortuneTelling( inputdata_t & )
{
m_bWasUsingTimer = m_bUseTimer;
m_bUseTimer = true;
if ( m_pActiveFortune )
{
m_pActiveFortune->OnDeactivateEffect();
m_pActiveFortune = NULL;
}
if ( !m_bWasUsingTimer )
UpdateFortuneTellerTime();
}
void CTFHalloweenFortuneTeller::InputDisableFortuneTelling( inputdata_t & )
{
m_bWasUsingTimer = m_bUseTimer;
m_bUseTimer = false;
if ( m_pActiveFortune )
{
m_pActiveFortune->OnDeactivateEffect();
m_pActiveFortune = NULL;
}
// keep track of when we pause
if ( m_bWasUsingTimer )
PauseTimer();
}
void CTFHalloweenFortuneTeller::InputStartFortuneTelling( inputdata_t & )
{
// don't manually call this while using timer
Assert( !m_bUseTimer );
StartFortuneTell();
}
void CTFHalloweenFortuneTeller::InputEndFortuneTelling( inputdata_t & )
{
// don't manually call this while using timer
Assert( !m_bUseTimer );
EndFortuneTell();
}
void CTFHalloweenFortuneTeller::FireGameEvent( IGameEvent* pEvent )
{
const char *pszEventName = pEvent->GetName();
if ( FStrEq( pszEventName, "sentry_on_go_active" ) )
{
// While curses are active, no ammo in sentries
if ( m_pActiveFortune )
{
TFGameRules()->RemoveAllSentriesAmmo();
return;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::UpdateFortuneTellerTime()
{
// unpause time, compute new start time
m_flStartTime = gpGlobals->curtime - ( m_flPauseTime - m_flStartTime );
const float flWarningTime = tf_fortune_teller_interval_time.GetFloat() - tf_fortune_teller_warning_time.GetFloat();
float flTimePast = gpGlobals->curtime - m_flStartTime;
// warning time
if ( flTimePast < flWarningTime )
{
float flTimeBeforeEvent = flWarningTime - flTimePast;
SetContextThink( &CTFHalloweenFortuneTeller::StartFortuneWarning, gpGlobals->curtime + flTimeBeforeEvent, "StartFortuneWarning" );
}
else
{
float flTimeBeforeEvent = tf_fortune_teller_interval_time.GetFloat() - flTimePast;
SetContextThink( &CTFHalloweenFortuneTeller::StartFortuneTell, gpGlobals->curtime + flTimeBeforeEvent, "StartFortuneTell" );
}
}
void CTFHalloweenFortuneTeller::PauseTimer()
{
m_flPauseTime = gpGlobals->curtime;
// Cancel any fortunes in flight
SetContextThink( NULL, 0, "StartFortuneWarning" );
SetContextThink( NULL, 0, "StartFortuneTell" );
SetContextThink( NULL, 0, "TellFortune" );
SetContextThink( NULL, 0, "EndFortuneTell" );
}
void CTFHalloweenFortuneTeller::ResetTimer()
{
m_flStartTime = m_flPauseTime = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::StartFortuneWarning()
{
// disable nagging
TFGameRules()->StopDoomsdayTicketsTimer();
m_OnFortuneWarning.FireOutput( this, this );
SetContextThink( &CTFHalloweenFortuneTeller::StartFortuneTell, gpGlobals->curtime + tf_fortune_teller_warning_time.GetFloat(), "StartFortuneTell" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::StartFortuneTell()
{
// Common effects.
m_OnFortuneTold.FireOutput( this, this );
// Broadcast the spin sound for the team-wide
TFGameRules()->BroadcastSound( 255, s_pszFortuneTellerSpinSound );
// Set when to actually perform the fortune telling
SetContextThink( &CTFHalloweenFortuneTeller::TellFortune, gpGlobals->curtime + 6.1f, "TellFortune" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::EndFortuneTell()
{
// resume nagging
TFGameRules()->StartDoomsdayTicketsTimer();
// Cancel any fortunes in flight
SetContextThink( NULL, 0, "TellFortune" );
m_OnFortuneEnd.FireOutput( this, this );
if ( m_pActiveFortune )
{
m_pActiveFortune->OnDeactivateEffect();
m_pActiveFortune = NULL;
}
if ( m_bUseTimer )
{
// restart fortune teller time
ResetTimer();
UpdateFortuneTellerTime();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHalloweenFortuneTeller::TellFortune()
{
if ( m_pActiveFortune )
{
m_pActiveFortune->OnDeactivateEffect();
m_pActiveFortune = NULL;
}
m_pActiveFortune = g_GlobalFortuneTellerEffects[ RandomInt( 0, ARRAYSIZE( g_GlobalFortuneTellerEffects ) - 1 ) ];
if ( !m_pActiveFortune )
return;
// prevent stickies trap before the dance off
TFGameRules()->RemoveAllProjectiles();
TFGameRules()->RemoveAllSentriesAmmo();
// Teleport RED
CUtlVector< CTFPlayer* > vecRedPlayers;
CollectPlayers<CTFPlayer>( &vecRedPlayers, TF_TEAM_RED, true );
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_RED, m_iszRedTeleport.ToCStr(), &vecRedPlayers );
// Teleport BLUE
CUtlVector< CTFPlayer* > vecBluePlayers;
CollectPlayers<CTFPlayer>( &vecBluePlayers, TF_TEAM_BLUE, true );
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_BLUE, m_iszBlueTeleport.ToCStr(), &vecBluePlayers );
CUtlVector< CTFPlayer* > vecPlayers;
CollectPlayers<CTFPlayer>( &vecPlayers, TEAM_ANY, true );
// Effects
for( CTFPlayer * pPlayer : vecPlayers )
{
if ( pPlayer->m_Shared.IsCarryingObject() && pPlayer->m_Shared.GetCarriedObject() != NULL)
{
pPlayer->m_Shared.GetCarriedObject()->DetonateObject();
}
// Do a zoom effect
pPlayer->SetFOV( pPlayer, tf_teleporter_fov_start.GetInt() );
pPlayer->SetFOV( pPlayer, 0, 1.f, tf_teleporter_fov_start.GetInt() );
// Screen flash
color32 fadeColor = {255,255,255,100};
UTIL_ScreenFade( pPlayer, fadeColor, 0.25, 0.4, FFADE_IN );
// Plays music and makes it so Taunt() always performs a thriller
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_THRILLER, 6.f );
}
// Speak after the 1st thriller
SetContextThink( &CTFHalloweenFortuneTeller::SpeakThink, gpGlobals->curtime + 3.f, "SpeakThink" );
// Apply the effect after the 2nd thriller
SetContextThink( &CTFHalloweenFortuneTeller::ApplyFortuneEffect, gpGlobals->curtime + 6.f, "FortuneActivate" );
const float flDanceTime = 0.5f;
const float flDanceDuration = 2.75f;
// Queue up the thrillers
SetContextThink( &CTFHalloweenFortuneTeller::DanceThink, gpGlobals->curtime + flDanceTime, "DanceThink1" );
SetContextThink( &CTFHalloweenFortuneTeller::DanceThink, gpGlobals->curtime + flDanceTime + flDanceDuration, "DanceThink2" );
}
void CTFHalloweenFortuneTeller::ApplyFortuneEffect()
{
m_OnFortuneCurse.FireOutput( this, this );
// Apply the actual effects.
if ( m_pActiveFortune )
m_pActiveFortune->OnActivateEffect( m_bUseTimer );
if ( m_bUseTimer )
{
SetContextThink( &CTFHalloweenFortuneTeller::EndFortuneTell, gpGlobals->curtime + tf_fortune_teller_fortune_duration.GetFloat(), "EndFortuneTell" );
}
}
void CTFHalloweenFortuneTeller::SpeakThink()
{
float flSoundDuration = 0.0f;
if ( m_pActiveFortune )
{
// Speak
const char *pszActivationSound = m_pActiveFortune->GetActivationSound();
TFGameRules()->BroadcastSound( 255, pszActivationSound );
// Do speaking anim
SetSequence( LookupSequence( "jaw_talking" ) );
//flSoundDuration = enginesound->GetSoundDuration( pszActivationSound );
}
// Tell ourselves to stop speaking after awhile
SetContextThink( &CTFHalloweenFortuneTeller::StopTalkingAnim, gpGlobals->curtime + flSoundDuration, "StopTalkingAnim" );
}
void CTFHalloweenFortuneTeller::StopTalkingAnim()
{
SetSequence( LookupSequence( "ref" ) );
}
void CTFHalloweenFortuneTeller::DanceThink()
{
CUtlVector< CTFPlayer* > vecPlayers;
CollectPlayers<CTFPlayer>( &vecPlayers, TEAM_ANY, true );
// No mere mortal can resist the magic of Merasmus
for( CTFPlayer * pPlayer : vecPlayers )
{
pPlayer->Taunt();
}
}
#endif // GAME_DLLs