1117 lines
28 KiB
C++
1117 lines
28 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Auto Repair
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "tf/halloween/merasmus/merasmus.h"
|
|
#include "tf/halloween/merasmus/merasmus_dancer.h"
|
|
#include "tf_gamerules.h"
|
|
#include "tf_weapon_jar.h"
|
|
#include "tf_wheel_of_doom.h"
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( wheel_of_doom, CWheelOfDoom );
|
|
|
|
// Data Description
|
|
BEGIN_DATADESC( CWheelOfDoom )
|
|
|
|
// Keyfields
|
|
DEFINE_KEYFIELD( m_flDuration, FIELD_FLOAT, "effect_duration" ),
|
|
DEFINE_KEYFIELD( m_bHasSpiral, FIELD_BOOLEAN, "has_spiral" ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "Spin", Spin ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "ClearAllEffects", ClearAllEffects ),
|
|
|
|
// Outputs
|
|
DEFINE_OUTPUT( m_EffectApplied, "OnEffectApplied" ),
|
|
DEFINE_OUTPUT( m_EffectExpired, "OnEffectExpired" ),
|
|
|
|
END_DATADESC()
|
|
|
|
extern ConVar sv_gravity;
|
|
|
|
#define WHEEL_SPIN_TIME 5.75f
|
|
#define WHEEL_SPIN_TIME_BIAS 0.3f
|
|
#define WHEEL_FASTEST_SPIN_RATE 0.1f
|
|
#define WHEEL_SLOWEST_SPIN_RATE 0.55f
|
|
|
|
#define WHEEL_SPIRAL_GROW_RATE 0.55f
|
|
#define WHEEL_SPIRAL_SHRINK_RATE 0.55f
|
|
|
|
|
|
#define EFFECT_WHAMMY 1<<0
|
|
#define EFFECT_DOES_NOT_REAPPLY_ON_SPAWN 1<<1
|
|
|
|
|
|
class CWheelOfDoomSpiral : public CBaseAnimating
|
|
{
|
|
DECLARE_CLASS( CWheelOfDoom, CBaseAnimating );
|
|
DECLARE_DATADESC();
|
|
|
|
public:
|
|
CWheelOfDoomSpiral()
|
|
{
|
|
m_flScale = 0.f;
|
|
SetModelScale( 0.f );
|
|
}
|
|
|
|
virtual void Spawn()
|
|
{
|
|
SetThink( NULL );
|
|
}
|
|
|
|
virtual void Precache()
|
|
{
|
|
PrecacheModel( "models/props_lakeside_event/wof_plane2.mdl" );
|
|
}
|
|
|
|
void GrowAndBecomeVisible()
|
|
{
|
|
RemoveEffects( EF_NODRAW );
|
|
|
|
SetThink( &CWheelOfDoomSpiral::GrowThink );
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
void ShrinkAndHide()
|
|
{
|
|
SetThink( &CWheelOfDoomSpiral::ShrinkThink );
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
private:
|
|
|
|
void GrowThink()
|
|
{
|
|
// Grow ourselves over time
|
|
m_flScale += WHEEL_SPIRAL_GROW_RATE * gpGlobals->frametime;
|
|
|
|
if( m_flScale >= 1.f )
|
|
{
|
|
m_flScale = 1.f;
|
|
SetThink( NULL );
|
|
}
|
|
|
|
SetModelScale( m_flScale );
|
|
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
void ShrinkThink()
|
|
{
|
|
// Shrink ourselves over time
|
|
m_flScale -= WHEEL_SPIRAL_SHRINK_RATE * gpGlobals->frametime;
|
|
|
|
if( m_flScale <= 0.f )
|
|
{
|
|
m_flScale = 0.f;
|
|
AddEffects( EF_NODRAW );
|
|
SetThink( NULL );
|
|
}
|
|
|
|
SetModelScale( m_flScale );
|
|
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
float m_flScale;
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS( wheel_of_doom_spiral, CWheelOfDoomSpiral );
|
|
|
|
// Data Description
|
|
BEGIN_DATADESC( CWheelOfDoomSpiral )
|
|
END_DATADESC()
|
|
|
|
#ifdef STAGING_ONLY
|
|
static void ProcWheelEffect( const CCommand &args )
|
|
{
|
|
CBaseEntity *pOther = gEntList.FindEntityByClassname( NULL, "wheel_of_doom" );
|
|
|
|
CWheelOfDoom* pWheel = dynamic_cast<CWheelOfDoom*>( pOther );
|
|
if( pWheel )
|
|
{
|
|
pWheel->DBG_ApplyEffectByName( args.ArgS() );
|
|
}
|
|
}
|
|
ConCommand cc_proc_wheel_effect( "cc_proc_wheel_effect", ProcWheelEffect, "Force a Wheel of Doom entity to apply the specified effect" );
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CWheelOfDoom::CWheelOfDoom( void ) :
|
|
m_EffectManager( this ),
|
|
m_pChosenEffect( NULL ),
|
|
m_pSpiral( NULL ),
|
|
m_flFinishBroadcastingEffectTime( 0.f )
|
|
{
|
|
AddEffects( EF_NODRAW );
|
|
|
|
RegisterEffect( new WOD_UberEffect() );
|
|
RegisterEffect( new WOD_CritsEffect() );
|
|
RegisterEffect( new WOD_SuperSpeedEffect() );
|
|
RegisterEffect( new WOD_SuperJumpEffect() );
|
|
RegisterEffect( new WOD_BigHeadEffect() );
|
|
RegisterEffect( new WOD_SmallHeadEffect() );
|
|
RegisterEffect( new WOD_LowGravityEffect() );
|
|
RegisterEffect( new WOD_Dance(), EFFECT_DOES_NOT_REAPPLY_ON_SPAWN );
|
|
RegisterEffect( new WOD_Pee(), EFFECT_WHAMMY | EFFECT_DOES_NOT_REAPPLY_ON_SPAWN );
|
|
RegisterEffect( new WOD_Burn(), EFFECT_WHAMMY | EFFECT_DOES_NOT_REAPPLY_ON_SPAWN );
|
|
RegisterEffect( new WOD_Ghosts(), EFFECT_WHAMMY | EFFECT_DOES_NOT_REAPPLY_ON_SPAWN );
|
|
}
|
|
|
|
|
|
CWheelOfDoom::~CWheelOfDoom( void )
|
|
{
|
|
m_EffectManager.ClearEffects();
|
|
m_vecEffects.PurgeAndDeleteElements();
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::RegisterEffect( WOD_BaseEffect* pEffect, int nFlags )
|
|
{
|
|
pEffect->SetListFlags( nFlags );
|
|
m_vecEffects.AddToTail( pEffect );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWheelOfDoom::Precache( void )
|
|
{
|
|
PrecacheModel( GetScreenModelName() );
|
|
PrecacheModel( "models/props_lakeside_event/wof_plane2.mdl" );
|
|
|
|
PrecacheScriptSound( "Halloween.WheelofFate" );
|
|
PrecacheScriptSound( "Halloween.dance_howl" );
|
|
PrecacheScriptSound( "Halloween.dance_loop" );
|
|
|
|
PrecacheScriptSound( "Halloween.HeadlessBossAxeHitWorld" );
|
|
PrecacheScriptSound( "Halloween.LightsOn" );
|
|
PrecacheScriptSound( "Weapon_StickyBombLauncher.BoltForward" );
|
|
PrecacheScriptSound( "TFPlayer.InvulnerableOff" );
|
|
|
|
m_EffectManager.Precache();
|
|
}
|
|
|
|
const char* CWheelOfDoom::GetScreenModelName()
|
|
{
|
|
return "models/props_lakeside_event/buff_plane.mdl";
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWheelOfDoom::Spawn( void )
|
|
{
|
|
Precache();
|
|
|
|
SetModel( GetScreenModelName() );
|
|
|
|
SetSolid( SOLID_BBOX );
|
|
AddSolidFlags( FSOLID_NOT_SOLID );
|
|
SetMoveType( MOVETYPE_NONE );
|
|
|
|
ListenForGameEvent( "player_spawn" );
|
|
|
|
SetThink( &CWheelOfDoom::IdleThink );
|
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
|
|
|
if ( TFGameRules() != NULL )
|
|
{
|
|
TFGameRules()->ClearHalloweenEffectStatus();
|
|
}
|
|
|
|
if( m_bHasSpiral )
|
|
{
|
|
m_pSpiral = assert_cast<CWheelOfDoomSpiral*>( CreateEntityByName( "wheel_of_doom_spiral" ) );
|
|
Assert( m_pSpiral );
|
|
m_pSpiral->SetModel( "models/props_lakeside_event/wof_plane2.mdl" );
|
|
m_pSpiral->AddEffects( EF_NODRAW );
|
|
m_pSpiral->SetAbsOrigin( GetAbsOrigin() );
|
|
m_pSpiral->SetAbsAngles( GetAbsAngles() );
|
|
m_pSpiral->SetParent( this );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::FireGameEvent( IGameEvent *gameEvent )
|
|
{
|
|
if( FStrEq( gameEvent->GetName(), "player_spawn" ) )
|
|
{
|
|
const int nUserID = gameEvent->GetInt( "userid" );
|
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByUserId( nUserID ) );
|
|
if( pPlayer )
|
|
{
|
|
m_EffectManager.ApplyAllEffectsToPlayer( pPlayer );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWheelOfDoom::IdleThink( void )
|
|
{
|
|
if( m_EffectManager.UpdateAndClearExpiredEffects() )
|
|
{
|
|
AddEffects( EF_NODRAW );
|
|
|
|
m_EffectExpired.FireOutput( this, this );
|
|
|
|
// Clear the skin to blank
|
|
SetSkin( 0 );
|
|
|
|
// Clear the HUD
|
|
TFGameRules()->ClearHalloweenEffectStatus();
|
|
|
|
if( m_bHasSpiral )
|
|
{
|
|
// Make our spirals shrink down and hide themselves
|
|
m_pSpiral->ShrinkAndHide();
|
|
FOR_EACH_VEC( m_vecOtherWODs, i )
|
|
{
|
|
if( m_vecOtherWODs[i]->m_bHasSpiral )
|
|
{
|
|
m_vecOtherWODs[i]->m_pSpiral->ShrinkAndHide();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Next update
|
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
|
}
|
|
|
|
void CWheelOfDoom::SetSkin( int nSkin )
|
|
{
|
|
m_nSkin = nSkin;
|
|
|
|
FOR_EACH_VEC( m_vecOtherWODs, i )
|
|
{
|
|
m_vecOtherWODs[i]->m_nSkin = nSkin;
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::SetScale( float flScale )
|
|
{
|
|
SetModelScale( flScale );
|
|
|
|
FOR_EACH_VEC( m_vecOtherWODs, i )
|
|
{
|
|
m_vecOtherWODs[i]->SetModelScale( flScale );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::PlaySound( const char* pszSound )
|
|
{
|
|
EmitSound( pszSound );
|
|
|
|
FOR_EACH_VEC( m_vecOtherWODs, i )
|
|
{
|
|
m_vecOtherWODs[i]->EmitSound( pszSound );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::SpinThink( void )
|
|
{
|
|
if( m_EffectManager.UpdateAndClearExpiredEffects() )
|
|
{
|
|
m_EffectExpired.FireOutput( this, this );
|
|
|
|
// Clear the HUD
|
|
TFGameRules()->ClearHalloweenEffectStatus();
|
|
}
|
|
|
|
// Are we done spinning?
|
|
if( gpGlobals->curtime > m_flStopSpinTime )
|
|
{
|
|
if( gpGlobals->curtime > m_flStopSpinTime + 1.f )
|
|
{
|
|
//PlaySound( "Halloween.LightsOn" );
|
|
SetScale( 1.f );
|
|
|
|
m_EffectApplied.FireOutput( this, this );
|
|
|
|
// Apply the effect!
|
|
SetSkin( m_EffectManager.AddEffect( m_pChosenEffect, m_flDuration ) );
|
|
|
|
SetThink( &CWheelOfDoom::IdleThink );
|
|
|
|
m_flStopSpinTime = 0.f;
|
|
m_flNextTickTime = 0.f;
|
|
m_pChosenEffect = NULL;
|
|
}
|
|
}
|
|
// Is it time for another tick of the wheel?
|
|
else if( gpGlobals->curtime > m_flNextTickTime )
|
|
{
|
|
int nRandSkin = RandomInt( 1, EFFECT_COUNT-1 );
|
|
if( nRandSkin == m_nSkin )
|
|
++nRandSkin;
|
|
|
|
// Roll over to 1. 0 is blank so skip that one.
|
|
if( nRandSkin == EFFECT_COUNT )
|
|
nRandSkin = 1;
|
|
|
|
SetSkin( nRandSkin );
|
|
SetScale( RemapVal( CalcSpinCompletion(), 0.f, 1.f, 0.3f, 0.9f) );
|
|
|
|
m_flNextTickTime = CalcNextTickTime();
|
|
}
|
|
|
|
//Is it time for Merasmus to announce the spin?
|
|
if (gpGlobals->curtime > m_flNextAnnounceTime && !m_bAnnounced)
|
|
{
|
|
m_bAnnounced = true;
|
|
CMerasmus* pMerasmus = assert_cast< CMerasmus* >( TFGameRules()->GetActiveBoss() );
|
|
if (pMerasmus)
|
|
{
|
|
pMerasmus->PlayHighPrioritySound("Halloween.MerasmusWheelSpin");
|
|
}
|
|
else
|
|
{
|
|
TFGameRules()->BroadcastSound(255,"Halloween.MerasmusWheelSpin");
|
|
}
|
|
}
|
|
|
|
// Next update
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
float CWheelOfDoom::CalcNextTickTime() const
|
|
{
|
|
float flProgress = CalcSpinCompletion();
|
|
float flBias = Bias( flProgress, WHEEL_SPIN_TIME_BIAS );
|
|
return gpGlobals->curtime + (( 1 - flBias ) * WHEEL_FASTEST_SPIN_RATE) + (flBias) * WHEEL_SLOWEST_SPIN_RATE;
|
|
}
|
|
|
|
|
|
float CWheelOfDoom::CalcSpinCompletion() const
|
|
{
|
|
const float& flDuration = WHEEL_SPIN_TIME;
|
|
return ( flDuration - (m_flStopSpinTime - gpGlobals->curtime) ) / flDuration;
|
|
}
|
|
|
|
void CWheelOfDoom::StartSpin( void )
|
|
{
|
|
RemoveEffects( EF_NODRAW );
|
|
m_vecOtherWODs.Purge();
|
|
CBaseEntity *pOther = gEntList.FindEntityByClassname( NULL, "wheel_of_doom" );
|
|
|
|
// Play the sound of the wheel starting to spin
|
|
if( TFGameRules() )
|
|
{
|
|
TFGameRules()->BroadcastSound( 255, "Halloween.WheelofFate" );
|
|
}
|
|
|
|
// Gather all of the other WheelofDoom entities so we can control their screens as we spin
|
|
while ( pOther )
|
|
{
|
|
if( pOther != this )
|
|
{
|
|
m_vecOtherWODs.AddToTail( dynamic_cast<CWheelOfDoom*>( pOther ) );
|
|
}
|
|
|
|
// Change the target over
|
|
pOther = gEntList.FindEntityByClassname( pOther, "wheel_of_doom" );
|
|
}
|
|
|
|
if( m_bHasSpiral )
|
|
{
|
|
// Make our spirals show up and grow
|
|
m_pSpiral->GrowAndBecomeVisible();
|
|
FOR_EACH_VEC( m_vecOtherWODs, i )
|
|
{
|
|
if( m_vecOtherWODs[i]->m_bHasSpiral )
|
|
{
|
|
m_vecOtherWODs[i]->m_pSpiral->GrowAndBecomeVisible();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Setup spin logic
|
|
m_flStopSpinTime = gpGlobals->curtime + WHEEL_SPIN_TIME;
|
|
m_flNextTickTime = CalcNextTickTime();
|
|
m_flNextAnnounceTime = gpGlobals->curtime + 1.6;
|
|
m_bAnnounced = false;
|
|
|
|
m_flFinishBroadcastingEffectTime = m_flStopSpinTime + 10.f;
|
|
|
|
SetThink( &CWheelOfDoom::SpinThink );
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::Spin( inputdata_t& inputdata )
|
|
{
|
|
// Remember which effect was chosen so we can apply it once the spinning is done
|
|
m_pChosenEffect = GetRandomEffectWithFlags();
|
|
StartSpin();
|
|
}
|
|
|
|
|
|
CWheelOfDoom::WOD_BaseEffect* CWheelOfDoom::GetRandomEffectWithFlags()
|
|
{
|
|
int nNumWhammys = 0;
|
|
int nNumGoodEffects = 0;
|
|
CUtlVector<WOD_BaseEffect*> vecMatchingEffects;
|
|
|
|
// Collect all of the effects that match our criteria.
|
|
// Buffs in the front of the vector and whammys on the end
|
|
FOR_EACH_VEC( m_vecEffects, i )
|
|
{
|
|
WOD_BaseEffect* pEffect = m_vecEffects[i];
|
|
|
|
if( pEffect->GetListFlags() & EFFECT_WHAMMY )
|
|
{
|
|
// Tally up all the whammys
|
|
++nNumWhammys;
|
|
vecMatchingEffects.AddToTail( pEffect );
|
|
}
|
|
else
|
|
{
|
|
++nNumGoodEffects;
|
|
vecMatchingEffects.AddToHead( pEffect );
|
|
}
|
|
}
|
|
|
|
// No matching effects. Return null
|
|
if( vecMatchingEffects.Count() == 0 )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// No Whammies? Just return a random one
|
|
if( nNumWhammys == 0 )
|
|
{
|
|
return vecMatchingEffects[RandomInt( 0, nNumGoodEffects-1 )];
|
|
}
|
|
|
|
// Given n good buffs, give a 1/n+1 chance of hitting a whammy
|
|
int nRand = RandomInt( 0, nNumGoodEffects );
|
|
|
|
// Rolled a whammy!
|
|
if( nRand == nNumGoodEffects )
|
|
{
|
|
//Roll again to find out which whammy we get
|
|
nRand = nNumGoodEffects + RandomInt( 0, nNumWhammys-1 );
|
|
}
|
|
|
|
return vecMatchingEffects[nRand];
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::ClearAllEffects( inputdata_t& inputdata )
|
|
{
|
|
m_EffectManager.ClearEffects();
|
|
}
|
|
|
|
|
|
bool CWheelOfDoom::IsDoneBoardcastingEffectSound() const
|
|
{
|
|
return gpGlobals->curtime > m_flFinishBroadcastingEffectTime;
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::DBG_ApplyEffectByName( const char* pszEffectName )
|
|
{
|
|
FOR_EACH_VEC( m_vecEffects, i )
|
|
{
|
|
WOD_BaseEffect* pEffect = m_vecEffects[i];
|
|
if( FStrEq( pEffect->GetName(), pszEffectName ) )
|
|
{
|
|
m_EffectManager.AddEffect( pEffect, m_flDuration );
|
|
}
|
|
}
|
|
}
|
|
|
|
CWheelOfDoom::WOD_BaseEffect::WOD_BaseEffect()
|
|
{
|
|
m_flExpireTime = 0;
|
|
m_pszEffectAnnouncementSound = NULL;
|
|
m_pszName = NULL;
|
|
m_iListFlags = 0;
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_BaseEffect::InitEffect( float flDefaultDuration )
|
|
{
|
|
m_flExpireTime = gpGlobals->curtime + flDefaultDuration;
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_BaseEffect::SetListFlags( int iFlags )
|
|
{
|
|
m_iListFlags = iFlags;
|
|
}
|
|
|
|
CWheelOfDoom::EffectManager::~EffectManager()
|
|
{
|
|
}
|
|
|
|
int CWheelOfDoom::EffectManager::AddEffect( WOD_BaseEffect* pEffect, float flDefaultDuration )
|
|
{
|
|
Assert( pEffect );
|
|
|
|
EffectData_t data;
|
|
data.m_pWheel = m_pWheel;
|
|
CollectPlayers( &data.m_vecPlayers );
|
|
pEffect->InitEffect( flDefaultDuration );
|
|
pEffect->ActivateEffect( data );
|
|
|
|
float flExpireDiff = pEffect->m_flExpireTime - gpGlobals->curtime;
|
|
DevMsg( "[WHEEL OF DOOM]\t Activating: \"%s\" set to expire in %3.2fs\n", pEffect->m_pszName, flExpireDiff );
|
|
|
|
if( TFGameRules() )
|
|
{
|
|
CMerasmus* pMerasmus = assert_cast< CMerasmus* >( TFGameRules()->GetActiveBoss() );
|
|
if (pMerasmus)
|
|
{
|
|
pMerasmus->PlayHighPrioritySound(pEffect->m_pszEffectAnnouncementSound);
|
|
}
|
|
else
|
|
{
|
|
TFGameRules()->BroadcastSound(255,pEffect->m_pszEffectAnnouncementSound);
|
|
}
|
|
// Update the HUD
|
|
TFGameRules()->SetHalloweenEffectStatus( int(pEffect->m_nSkin), flExpireDiff );
|
|
SpeakMagicConceptToAllPlayers(pEffect->m_pszEffectAnnouncementSound);
|
|
}
|
|
|
|
// Remember this effect
|
|
m_vecActiveEffects.AddToTail( pEffect );
|
|
|
|
return pEffect->m_nSkin;
|
|
}
|
|
|
|
void CWheelOfDoom::EffectManager::ApplyAllEffectsToPlayer( CTFPlayer* pPlayer )
|
|
{
|
|
EffectData_t data;
|
|
data.m_pWheel = m_pWheel;
|
|
data.m_vecPlayers.AddToTail( pPlayer );
|
|
|
|
FOR_EACH_VEC( m_vecActiveEffects, i )
|
|
{
|
|
if( m_vecActiveEffects[i]->GetListFlags() & EFFECT_DOES_NOT_REAPPLY_ON_SPAWN )
|
|
continue;
|
|
|
|
m_vecActiveEffects[i]->ActivateEffect( data );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::EffectManager::ClearEffects()
|
|
{
|
|
FOR_EACH_VEC( m_vecActiveEffects, i )
|
|
{
|
|
DevMsg( "[WHEEL OF DOOM]\t Deactivating: %s\n", m_vecActiveEffects[i]->m_pszName );
|
|
|
|
EffectData_t data;
|
|
data.m_pWheel = m_pWheel;
|
|
CollectPlayers( &data.m_vecPlayers );
|
|
|
|
m_vecActiveEffects[i]->DeactivateEffect( data );
|
|
}
|
|
|
|
m_vecActiveEffects.Purge();
|
|
}
|
|
|
|
bool CWheelOfDoom::EffectManager::UpdateAndClearExpiredEffects()
|
|
{
|
|
bool bEffectExpired = false;
|
|
|
|
EffectData_t data;
|
|
data.m_pWheel = m_pWheel;
|
|
CollectPlayers( &data.m_vecPlayers );
|
|
|
|
FOR_EACH_VEC_BACK( m_vecActiveEffects, i )
|
|
{
|
|
// Check if the effect is expired. If so, run its DeactivateEffect and remove it
|
|
WOD_BaseEffect* pEffect = m_vecActiveEffects[i];
|
|
if( gpGlobals->curtime > pEffect->m_flExpireTime )
|
|
{
|
|
DevMsg( "[WHEEL OF DOOM]\t Effect expired: %s\n", pEffect->m_pszName );
|
|
bEffectExpired = true;
|
|
|
|
pEffect->DeactivateEffect( data );
|
|
|
|
m_vecActiveEffects.Remove( i );
|
|
}
|
|
else // If it's not expired, then update
|
|
{
|
|
pEffect->UpdateEffect( data );
|
|
}
|
|
}
|
|
|
|
return bEffectExpired;
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::EffectManager::Precache()
|
|
{
|
|
FOR_EACH_VEC( m_vecActiveEffects, i )
|
|
{
|
|
PrecacheScriptSound( m_vecActiveEffects[i]->m_pszEffectAnnouncementSound );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::SpeakMagicConceptToAllPlayers( const char* pszEffect )
|
|
{
|
|
int iConcept = -1;
|
|
|
|
if ( !V_stricmp( pszEffect, "Halloween.MerasmusWheelBigHead") )
|
|
{
|
|
iConcept = MP_CONCEPT_MAGIC_BIGHEAD;
|
|
}
|
|
else if ( !V_stricmp( pszEffect, "Halloween.MerasmusWheelShrunkHead") )
|
|
{
|
|
iConcept = MP_CONCEPT_MAGIC_SMALLHEAD;
|
|
}
|
|
else if ( !V_stricmp( pszEffect, "Halloween.MerasmusWheelGravity") )
|
|
{
|
|
iConcept = MP_CONCEPT_MAGIC_GRAVITY;
|
|
}
|
|
else if ( (!V_stricmp( pszEffect, "Halloween.MerasmusWheelCrits")) || (!V_stricmp( pszEffect, "Halloween.MerasmusWheelUber")) || (!V_stricmp( pszEffect, "Halloween.MerasmusWheelSuperSpeed")))
|
|
{
|
|
iConcept = MP_CONCEPT_MAGIC_GOOD;
|
|
}
|
|
else if ( !V_stricmp( pszEffect, "Halloween.MerasmusWheelDance") )
|
|
{
|
|
iConcept = MP_CONCEPT_MAGIC_DANCE;
|
|
}
|
|
|
|
if (iConcept >= 0)
|
|
{
|
|
CUtlVector< CTFPlayer * > playerVector;
|
|
CollectPlayers( &playerVector );
|
|
FOR_EACH_VEC( playerVector, i )
|
|
{
|
|
playerVector[i]->SpeakConceptIfAllowed(iConcept);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CWheelOfDoom::ApplyAttributeToAllPlayers( const char* pszAttribName, float flValue )
|
|
{
|
|
CUtlVector< CTFPlayer * > playerVector;
|
|
CollectPlayers( &playerVector );
|
|
FOR_EACH_VEC( playerVector, i )
|
|
{
|
|
ApplyAttributeToPlayer( playerVector[i], pszAttribName, flValue );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::ApplyAttributeToPlayer( CTFPlayer* pPlayer, const char* pszAttribName, float flValue )
|
|
{
|
|
Assert( pPlayer );
|
|
|
|
const CEconItemAttributeDefinition *pDef = GetItemSchema()->GetAttributeDefinitionByName( pszAttribName );
|
|
|
|
pPlayer->GetAttributeList()->SetRuntimeAttributeValue( pDef, flValue );
|
|
pPlayer->TeamFortress_SetSpeed();
|
|
}
|
|
|
|
void CWheelOfDoom::RemoveAttributeFromAllPlayers( const char* pszAttributeName )
|
|
{
|
|
const CEconItemAttributeDefinition *pDef = GetItemSchema()->GetAttributeDefinitionByName( pszAttributeName );
|
|
|
|
CUtlVector< CTFPlayer * > playerVector;
|
|
CollectPlayers( &playerVector );
|
|
FOR_EACH_VEC( playerVector, i )
|
|
{
|
|
CTFPlayer* pPlayer = playerVector[i];
|
|
pPlayer->GetAttributeList()->RemoveAttribute( pDef );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::RemoveAttributeFromPlayer( CTFPlayer* pPlayer, const char* pszAttribName )
|
|
{
|
|
const CEconItemAttributeDefinition *pDef = GetItemSchema()->GetAttributeDefinitionByName( pszAttribName );
|
|
pPlayer->GetAttributeList()->RemoveAttribute( pDef );
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_UberEffect::InitEffect( float flDefaultExpireTime )
|
|
{
|
|
m_flExpireTime = gpGlobals->curtime + Min( flDefaultExpireTime, 10.f );
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_UberEffect::ActivateEffect( EffectData_t& data )
|
|
{
|
|
float flDuration = m_flExpireTime - gpGlobals->curtime;
|
|
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
pPlayer->m_Shared.AddCond( TF_COND_INVULNERABLE, flDuration );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_CritsEffect::ActivateEffect( EffectData_t& data )
|
|
{
|
|
float flDuration = m_flExpireTime - gpGlobals->curtime;
|
|
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
pPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_PUMPKIN, flDuration );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_SuperSpeedEffect::ActivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
CWheelOfDoom::ApplyAttributeToPlayer( pPlayer, "major move speed bonus", 2.f );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_SuperSpeedEffect::DeactivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
CWheelOfDoom::RemoveAttributeFromPlayer( pPlayer, "major move speed bonus" );
|
|
// Recalc our max speed
|
|
pPlayer->TeamFortress_SetSpeed();
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_SuperJumpEffect::ActivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
CWheelOfDoom::ApplyAttributeToPlayer( pPlayer, "major increased jump height", 3.f );
|
|
CWheelOfDoom::ApplyAttributeToPlayer( pPlayer, "cancel falling damage", 1.f );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_SuperJumpEffect::DeactivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
CWheelOfDoom::RemoveAttributeFromPlayer( pPlayer, "major increased jump height" );
|
|
CWheelOfDoom::RemoveAttributeFromPlayer( pPlayer, "cancel falling damage" );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_BigHeadEffect::ActivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
ApplyAttributeToPlayer( pPlayer, "voice pitch scale", 0.85f );
|
|
ApplyAttributeToPlayer( pPlayer, "head scale", 3.f );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_BigHeadEffect::DeactivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
RemoveAttributeFromPlayer( pPlayer, "voice pitch scale" );
|
|
RemoveAttributeFromPlayer( pPlayer, "head scale" );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_SmallHeadEffect::ActivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
ApplyAttributeToPlayer( pPlayer, "voice pitch scale", 1.3f );
|
|
ApplyAttributeToPlayer( pPlayer, "head scale", 0.5f );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_SmallHeadEffect::DeactivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
RemoveAttributeFromPlayer( pPlayer, "voice pitch scale" );
|
|
RemoveAttributeFromPlayer( pPlayer, "head scale" );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CWheelOfDoom::WOD_LowGravityEffect::ActivateEffect( EffectData_t& /*data*/ )
|
|
{
|
|
if ( TFGameRules() )
|
|
{
|
|
TFGameRules()->SetGravityMultiplier( 0.25f );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_LowGravityEffect::DeactivateEffect( EffectData_t& /*data*/ )
|
|
{
|
|
if ( TFGameRules() )
|
|
{
|
|
TFGameRules()->SetGravityMultiplier( 1.0f );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_Pee::ActivateEffect( EffectData_t& data )
|
|
{
|
|
m_vecClouds.Purge();
|
|
|
|
// Collect all of the "spawn_cloud" entities
|
|
CBaseEntity *pOther = gEntList.FindEntityByName( NULL, "spawn_cloud" );
|
|
while( pOther )
|
|
{
|
|
m_vecClouds.AddToTail( pOther );
|
|
pOther = gEntList.FindEntityByName( pOther, "spawn_cloud" );
|
|
}
|
|
|
|
m_flNextPeeTime = gpGlobals->curtime + 0.25f;
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_Pee::UpdateEffect( EffectData_t& data )
|
|
{
|
|
if( gpGlobals->curtime < m_flNextPeeTime || m_vecClouds.Count() == 0 )
|
|
return;
|
|
|
|
m_flNextPeeTime = gpGlobals->curtime + RandomFloat(0.2f, 0.5f);
|
|
|
|
// Choose one at random
|
|
int nRandIndex = RandomInt( 0, m_vecClouds.Count() - 1 );
|
|
CBaseEntity* pCloud = m_vecClouds[nRandIndex];
|
|
|
|
// Get a random point within the brush
|
|
Vector vWorldMins = pCloud->WorldAlignMins();
|
|
Vector vWorldMaxs = pCloud->WorldAlignMaxs();
|
|
Vector vBoxMin = pCloud->GetAbsOrigin() + vWorldMins;
|
|
Vector vBoxMax = pCloud->GetAbsOrigin() + vWorldMaxs;
|
|
Vector vRandomPos( RandomFloat( vBoxMin.x, vBoxMax.x ),
|
|
RandomFloat( vBoxMin.y, vBoxMax.y ),
|
|
RandomFloat( vBoxMin.z, vBoxMax.z ) );
|
|
|
|
// Drop some pee
|
|
CTFProjectile_Jar *pGrenade = static_cast<CTFProjectile_Jar*>( CBaseEntity::CreateNoSpawn( "tf_projectile_jar", vRandomPos, QAngle(0,0,0), NULL ) );
|
|
DispatchSpawn( pGrenade );
|
|
|
|
// Random angular impulse
|
|
Vector angImpulse( RandomFloat( -300.f, 300.f ),
|
|
RandomFloat( -300.f, 300.f ),
|
|
RandomFloat( -300.f, 300.f ) );
|
|
|
|
// Add some spin
|
|
IPhysicsObject *pPhysicsObject = pGrenade->VPhysicsGetObject();
|
|
if ( pPhysicsObject )
|
|
{
|
|
pPhysicsObject->AddVelocity( &vec3_origin, &angImpulse );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_Burn::InitEffect( float flDefaultDuration )
|
|
{
|
|
m_flExpireTime = gpGlobals->curtime + 10.f;
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_Burn::ActivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
pPlayer->m_Shared.SelfBurn( Min( data.m_pWheel->GetDuration(), 10.f ) );
|
|
}
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_Ghosts::ActivateEffect( EffectData_t& data )
|
|
{
|
|
if( TFGameRules() )
|
|
{
|
|
TFGameRules()->BeginHaunting( 4, data.m_pWheel->GetDuration() / 2.f, data.m_pWheel->GetDuration() );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_Ghosts::DeactivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
pPlayer->m_Shared.RemoveCond( TF_COND_BURNING );
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_Dance::InitEffect( float /*flDefaultExpireTime*/ )
|
|
{
|
|
// Don't do the same order every time
|
|
m_iCurrentMerasmusCreateInfo = RandomInt( 0, 1 );
|
|
|
|
// Ignore the passed in expire time. We want to have the buff for 5 seconds with 2 taunt cycles
|
|
m_flExpireTime = gpGlobals->curtime + 8.f;
|
|
m_flNextDanceTime = gpGlobals->curtime + 1.5f;
|
|
|
|
m_vecDancers.PurgeAndDeleteElements();
|
|
|
|
CUtlVector< CTFPlayer * > playerVector;
|
|
CollectPlayers( &playerVector, TEAM_ANY, true );
|
|
|
|
// We'll calculate the average position and place merasmus there
|
|
float aMerasmusY[2] = { FLT_MAX, -FLT_MAX };
|
|
float flMerasmusX = 0.0f, flMerasmusZ = 0.0f;
|
|
int nNumPositions = 0; // Keep a separate count for the average, since there's a case pOther can be NULL below
|
|
|
|
FOR_EACH_VEC( playerVector, i )
|
|
{
|
|
CTFPlayer* pPlayer = playerVector[i];
|
|
|
|
// Get our params
|
|
const char* pzsTeam = pPlayer->GetTeamNumber() == TF_TEAM_RED ? "red" : "blue";
|
|
int nInfoNumber = GetNumOFTeamDancing( pPlayer->GetTeamNumber() );
|
|
|
|
// Cook up the name of the entity we want
|
|
const char* pszTargetName = CFmtStr( "dance_teleport_%s%d", pzsTeam, nInfoNumber );
|
|
// If we got it, then do the magic
|
|
CBaseEntity *pOther = gEntList.FindEntityByName( NULL, pszTargetName );
|
|
if( pOther )
|
|
{
|
|
Dancer_t* dancer = new Dancer_t();
|
|
|
|
dancer->m_vecPos = pOther->GetAbsOrigin();
|
|
dancer->m_vecAngles = pOther->GetAbsAngles();
|
|
dancer->m_hPlayer.Set( pPlayer );
|
|
|
|
// Average in the player's position
|
|
aMerasmusY[0] = MIN( aMerasmusY[0], dancer->m_vecPos.y );
|
|
aMerasmusY[1] = MAX( aMerasmusY[1], dancer->m_vecPos.y );
|
|
flMerasmusX += dancer->m_vecPos.x;
|
|
flMerasmusZ = dancer->m_vecPos.z;
|
|
++nNumPositions;
|
|
|
|
// Slam them, for the jam
|
|
SlamPosAndAngles( pPlayer, dancer->m_vecPos, dancer->m_vecAngles );
|
|
|
|
// Force the halloween taunt. This will force the player to stand still.
|
|
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_THRILLER );
|
|
|
|
// Remember we're effecting this player
|
|
m_vecDancers.AddToTail( dancer );
|
|
}
|
|
}
|
|
|
|
// Average out the Merasmus position
|
|
flMerasmusX /= nNumPositions;
|
|
|
|
m_vecMerasmusDancerCreateInfos.AddToTail( MerasmusCreateInfo_t( Vector( flMerasmusX, aMerasmusY[0], flMerasmusZ ), QAngle( 0.0f, 90.0f, 0.0f ) ) );
|
|
m_vecMerasmusDancerCreateInfos.AddToTail( MerasmusCreateInfo_t( Vector( flMerasmusX, aMerasmusY[1], flMerasmusZ ), QAngle( 0.0f,-90.0f, 0.0f ) ) );
|
|
}
|
|
|
|
|
|
void CWheelOfDoom::WOD_Dance::UpdateEffect( EffectData_t& /*data*/ )
|
|
{
|
|
bool bShouldSlam = ( m_flNextDanceTime - gpGlobals->curtime ) < 0.2f;
|
|
|
|
bool bShouldTaunt = false;
|
|
if( gpGlobals->curtime > m_flNextDanceTime )
|
|
{
|
|
bShouldTaunt = true;
|
|
m_flNextDanceTime = gpGlobals->curtime + 3.5f;
|
|
}
|
|
|
|
FOR_EACH_VEC_BACK( m_vecDancers, i )
|
|
{
|
|
Dancer_t* dancer = m_vecDancers[i];
|
|
CTFPlayer* pPlayer = dancer->m_hPlayer.Get();
|
|
|
|
// This players is no more (disconnected). Forget about them.
|
|
if( pPlayer == NULL )
|
|
{
|
|
delete dancer;
|
|
m_vecDancers.Remove(i);
|
|
continue;
|
|
}
|
|
|
|
if( bShouldTaunt )
|
|
{
|
|
pPlayer->Taunt();
|
|
|
|
}
|
|
|
|
if( bShouldSlam )
|
|
{
|
|
// Slam them, for the jam
|
|
SlamPosAndAngles( pPlayer, dancer->m_vecPos, dancer->m_vecAngles );
|
|
}
|
|
}
|
|
|
|
// Party time.
|
|
if ( bShouldTaunt )
|
|
{
|
|
if ( m_hMerasmusDancer )
|
|
{
|
|
m_hMerasmusDancer->Vanish(); // Poof!
|
|
}
|
|
|
|
// Create a new Merasmus
|
|
const MerasmusCreateInfo_t &info = m_vecMerasmusDancerCreateInfos[ m_iCurrentMerasmusCreateInfo % m_vecMerasmusDancerCreateInfos.Count() ];
|
|
m_hMerasmusDancer = (CMerasmusDancer *)CBaseEntity::Create( "merasmus_dancer", info.m_vecPos, info.m_vecAngles );
|
|
|
|
if ( m_hMerasmusDancer )
|
|
{
|
|
m_hMerasmusDancer->Dance();
|
|
}
|
|
|
|
// Move to the next location
|
|
m_iCurrentMerasmusCreateInfo = ( m_iCurrentMerasmusCreateInfo + 1 ) % m_vecMerasmusDancerCreateInfos.Count();
|
|
}
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_Dance::DeactivateEffect( EffectData_t& data )
|
|
{
|
|
FOR_EACH_VEC( data.m_vecPlayers, i )
|
|
{
|
|
CTFPlayer* pPlayer = data.m_vecPlayers[i];
|
|
pPlayer->m_Shared.RemoveCond( TF_COND_HALLOWEEN_THRILLER );
|
|
}
|
|
|
|
m_vecDancers.Purge();
|
|
|
|
if ( m_hMerasmusDancer )
|
|
{
|
|
m_hMerasmusDancer->BlastOff();
|
|
m_vecMerasmusDancerCreateInfos.Purge();
|
|
}
|
|
}
|
|
|
|
|
|
int CWheelOfDoom::WOD_Dance::GetNumOFTeamDancing( int nTeam ) const
|
|
{
|
|
int nCount = 0;
|
|
FOR_EACH_VEC( m_vecDancers, i )
|
|
{
|
|
if( m_vecDancers[i]->m_hPlayer.Get()->GetTeamNumber() == nTeam )
|
|
nCount++;
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
|
|
void CWheelOfDoom::WOD_Dance::SlamPosAndAngles( CTFPlayer* pPlayer, const Vector& vPos, const QAngle& vAng )
|
|
{
|
|
// This calls: SetAbsOrigin(), SetAbsVelocity( vec3_origin ), SetLocalAngles(), SnapEyeAngles()
|
|
pPlayer->Teleport( &vPos, &vAng, &vec3_origin );
|
|
pPlayer->pl.v_angle = vAng;
|
|
} |