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.
 
 
 
 
 
 

760 lines
23 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: CTF HealthKit.
//
//=============================================================================//
#include "cbase.h"
#include "entity_halloween_pickup.h"
#ifdef GAME_DLL
#include "items.h"
#include "tf_gamerules.h"
#include "tf_player.h"
#include "tf_team.h"
#include "engine/IEngineSound.h"
#include "entity_halloween_pickup.h"
#include "tf_fx.h"
#include "tf_logic_halloween_2014.h"
#endif // GAME_DLL
#ifdef CLIENT_DLL
#include "c_tf_player.h"
#endif
#include "tf_shareddefs.h"
#include "tf_duckleaderboard.h"
#define TF_HALLOWEEN_PICKUP_RETURN_DELAY 10
#ifdef GAME_DLL
IMPLEMENT_AUTO_LIST( IHalloweenGiftSpawnAutoList );
#endif // GAME_DLL
//=============================================================================
//
// CTF Halloween Pickup defines.
IMPLEMENT_NETWORKCLASS_ALIASED( HalloweenPickup, DT_CHalloweenPickup )
BEGIN_NETWORK_TABLE( CHalloweenPickup, DT_CHalloweenPickup )
END_NETWORK_TABLE()
BEGIN_DATADESC( CHalloweenPickup )
DEFINE_KEYFIELD( m_iszSound, FIELD_STRING, "pickup_sound" ),
DEFINE_KEYFIELD( m_iszParticle, FIELD_STRING, "pickup_particle" ),
#ifdef GAME_DLL
DEFINE_OUTPUT( m_OnRedPickup, "OnRedPickup" ),
DEFINE_OUTPUT( m_OnBluePickup, "OnBluePickup" ),
#endif
END_DATADESC();
LINK_ENTITY_TO_CLASS( tf_halloween_pickup, CHalloweenPickup );
// ************************************************************************************
BEGIN_DATADESC( CBonusDuckPickup )
// DEFINE_KEYFIELD( m_iszSound, FIELD_STRING, "pickup_sound" ),
// DEFINE_KEYFIELD( m_iszParticle, FIELD_STRING, "pickup_particle" ),
END_DATADESC();
IMPLEMENT_NETWORKCLASS_ALIASED( BonusDuckPickup, DT_CBonusDuckPickup )
BEGIN_NETWORK_TABLE( CBonusDuckPickup, DT_CBonusDuckPickup )
#ifdef GAME_DLL
SendPropBool( SENDINFO( m_bSpecial ) ),
#else
RecvPropBool( RECVINFO( m_bSpecial ) ),
#endif
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_bonus_duck_pickup, CBonusDuckPickup );
// ************************************************************************************
#ifdef GAME_DLL
LINK_ENTITY_TO_CLASS( tf_halloween_gift_spawn_location, CHalloweenGiftSpawnLocation );
#endif
// ************************************************************************************
IMPLEMENT_NETWORKCLASS_ALIASED( HalloweenGiftPickup, DT_CHalloweenGiftPickup )
BEGIN_NETWORK_TABLE( CHalloweenGiftPickup, DT_CHalloweenGiftPickup )
#ifdef CLIENT_DLL
RecvPropEHandle( RECVINFO( m_hTargetPlayer ) ),
#else
SendPropEHandle( SENDINFO( m_hTargetPlayer ) ),
#endif
END_NETWORK_TABLE()
BEGIN_DATADESC( CHalloweenGiftPickup )
END_DATADESC();
LINK_ENTITY_TO_CLASS( tf_halloween_gift_pickup, CHalloweenGiftPickup );
// ************************************************************************************
// ************************************************************************************
ConVar tf_halloween_gift_lifetime( "tf_halloween_gift_lifetime", "240", FCVAR_CHEAT | FCVAR_REPLICATED );
#ifdef STAGING_ONLY
ConVar tf_halloween_gift_soul_value( "tf_halloween_gift_soul_value", "10", FCVAR_CHEAT | FCVAR_REPLICATED );
#endif
//=============================================================================
//
// CTF Halloween Pickup functions.
//
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CHalloweenPickup::CHalloweenPickup()
{
#ifdef GAME_DLL
ChangeTeam( TEAM_UNASSIGNED );
#endif
m_iszSound = MAKE_STRING( "Halloween.Quack" );
m_iszParticle = MAKE_STRING( "halloween_explosion" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CHalloweenPickup::~CHalloweenPickup()
{
}
//-----------------------------------------------------------------------------
// Purpose: Precache function for the pickup
//-----------------------------------------------------------------------------
void CHalloweenPickup::Precache( void )
{
// We deliberately allow late precaches here
bool bAllowPrecache = CBaseEntity::IsPrecacheAllowed();
CBaseEntity::SetAllowPrecache( true );
PrecacheScriptSound( TF_HALLOWEEN_PICKUP_DEFAULT_SOUND );
if ( m_iszSound != NULL_STRING )
{
PrecacheScriptSound( STRING( m_iszSound ) );
}
if ( m_iszParticle != NULL_STRING )
{
PrecacheParticleSystem( STRING( m_iszParticle ) );
}
BaseClass::Precache();
CBaseEntity::SetAllowPrecache( bAllowPrecache );
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CHalloweenPickup::UpdateTransmitState()
{
return SetTransmitState( FL_EDICT_ALWAYS );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CHalloweenPickup::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
return FL_EDICT_ALWAYS;
}
//-----------------------------------------------------------------------------
// Purpose: MyTouch function for the pickup
//-----------------------------------------------------------------------------
bool CHalloweenPickup::MyTouch( CBasePlayer *pPlayer )
{
bool bSuccess = false;
if ( ValidTouch( pPlayer ) )
{
bSuccess = true;
switch( pPlayer->GetTeamNumber() )
{
case TF_TEAM_BLUE:
m_OnBluePickup.FireOutput( this, this );
break;
case TF_TEAM_RED:
m_OnRedPickup.FireOutput( this, this );
break;
}
Vector vecOrigin = GetAbsOrigin() + Vector( 0, 0, 32 );
CPVSFilter filter( vecOrigin );
if ( m_iszSound != NULL_STRING )
{
EmitSound( filter, entindex(), STRING( m_iszSound ) );
}
else
{
EmitSound( filter, entindex(), TF_HALLOWEEN_PICKUP_DEFAULT_SOUND );
}
if ( m_iszParticle != NULL_STRING )
{
TE_TFParticleEffect( filter, 0.0, STRING( m_iszParticle ), vecOrigin, vec3_angle );
}
// Increment score directly during 2014 halloween
if ( CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() )
{
inputdata_t inputdata;
inputdata.pActivator = NULL;
inputdata.pCaller = NULL;
inputdata.value.SetInt( 1 );
inputdata.nOutputID = 0;
if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
{
CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame()->InputScoreTeamRed( inputdata );
}
else
{
CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame()->InputScoreTeamBlue( inputdata );
}
}
if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer )
{
pTFPlayer->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_DOOMSDAY_COLLECT_DUCKS );
IGameEvent *pEvent = gameeventmanager->CreateEvent( "halloween_duck_collected" );
if ( pEvent )
{
pEvent->SetInt( "collector", pTFPlayer->GetUserID() );
gameeventmanager->FireEvent( pEvent, true );
}
}
}
}
return bSuccess;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHalloweenPickup::ValidTouch( CBasePlayer *pPlayer )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer && pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
return false;
return BaseClass::ValidTouch( pPlayer );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CHalloweenPickup::GetRespawnDelay( void )
{
return TF_HALLOWEEN_PICKUP_RETURN_DELAY;
}
//-----------------------------------------------------------------------------
// Purpose: Do everything that our base does, but don't change our origin
//-----------------------------------------------------------------------------
CBaseEntity* CHalloweenPickup::Respawn( void )
{
SetTouch( NULL );
AddEffects( EF_NODRAW );
VPhysicsDestroyObject();
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
m_bRespawning = true;
//UTIL_SetOrigin( this, g_pGameRules->VecItemRespawnSpot( this ) );// blip to whereever you should respawn.
SetAbsAngles( g_pGameRules->VecItemRespawnAngles( this ) );// set the angles.
#if !defined( TF_DLL )
UTIL_DropToFloor( this, MASK_SOLID );
#endif
RemoveAllDecals(); //remove any decals
SetThink ( &CItem::Materialize );
SetNextThink( gpGlobals->curtime + GetRespawnDelay() );
return this;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHalloweenPickup::ItemCanBeTouchedByPlayer( CBasePlayer *pPlayer )
{
if ( m_flThrowerTouchTime > 0.f && gpGlobals->curtime < m_flThrowerTouchTime )
{
return false;
}
return BaseClass::ItemCanBeTouchedByPlayer( pPlayer );
}
#endif // GAME_DLL
// ***********************************************************************************************
ConVar tf_duck_allow_team_pickup( "tf_duck_allow_team_pickup", "1", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
CBonusDuckPickup::CBonusDuckPickup()
{
#ifdef GAME_DLL
ChangeTeam( TEAM_UNASSIGNED );
m_iCreatorId = -1;
m_iVictimId = -1;
m_iAssisterId = -1;
m_iFlags = 0;
#else
pGlowEffect = NULL;
#endif
m_bSpecial = false;
m_iszSound = MAKE_STRING( BONUS_DUCK_CREATED_SOUND );
m_iszParticle = MAKE_STRING( "duck_pickup" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBonusDuckPickup::~CBonusDuckPickup()
{
#ifdef GAME_DLL
m_flLifeTime = 0;
#else
if ( pGlowEffect )
{
ParticleProp()->StopEmission( pGlowEffect );
pGlowEffect = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
void CBonusDuckPickup::Precache( void )
{
// We deliberately allow late precaches here
bool bAllowPrecache = CBaseEntity::IsPrecacheAllowed();
CBaseEntity::SetAllowPrecache( true );
PrecacheParticleSystem( BONUS_DUCK_GLOW );
PrecacheParticleSystem( BONUS_DUCK_TRAIL_RED );
PrecacheParticleSystem( BONUS_DUCK_TRAIL_BLUE );
PrecacheParticleSystem( BONUS_DUCK_TRAIL_SPECIAL_RED );
PrecacheParticleSystem( BONUS_DUCK_TRAIL_SPECIAL_BLUE );
PrecacheScriptSound( BONUS_DUCK_CREATED_SOUND );
BaseClass::Precache();
CBaseEntity::SetAllowPrecache( bAllowPrecache );
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBonusDuckPickup::ValidTouch( CBasePlayer *pPlayer )
{
// Is the item enabled?
if ( IsDisabled() )
return false;
// Only touch a live player.
if ( !pPlayer || !pPlayer->IsPlayer() || !pPlayer->IsAlive() )
return false;
if ( ( GetTeamNumber() >= FIRST_GAME_TEAM ) && ( pPlayer->GetTeamNumber() == GetTeamNumber() ) )
return false;
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer && pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
#define DUCK_BLINK_TIME 3.0f
void CBonusDuckPickup::Spawn( void )
{
BaseClass::Spawn();
//SetCycle( RandomFloat(0, 60.0f) );
//align to the ground so we're not standing on end
QAngle angle = vec3_angle;
// rotate randomly in yaw
angle[1] = random->RandomFloat( 0, 360 );
SetAbsAngles( angle );
float flLifeTime = GetLifeTime();
m_flKillTime = gpGlobals->curtime + flLifeTime;
m_nBlinkCount = 0;
SetContextThink( &CBonusDuckPickup::BlinkThink, gpGlobals->curtime + flLifeTime - DUCK_BLINK_TIME, "BonusDuckBlinkThink" );
SetContextThink( &CBonusDuckPickup::UpdateCollisionBounds, gpGlobals->curtime + 2.0f, "UpdateCollisionBoundsThink" );
}
//-----------------------------------------------------------------------------
bool CBonusDuckPickup::MyTouch( CBasePlayer *pPlayer )
{
bool bSuccess = false;
if ( tf_duck_allow_team_pickup.GetBool() || ValidTouch( pPlayer ) )
{
bSuccess = true;
Vector vecOrigin = GetAbsOrigin();
CPVSFilter pvsFilter( vecOrigin );
if ( m_iszSound != NULL_STRING )
{
EmitSound( pvsFilter, entindex(), STRING( m_iszSound ) );
}
else
{
EmitSound( pvsFilter, entindex(), TF_HALLOWEEN_PICKUP_DEFAULT_SOUND );
}
if ( m_iszParticle != NULL_STRING )
{
TE_TFParticleEffect( pvsFilter, 0.0, STRING( m_iszParticle ), vecOrigin, vec3_angle );
}
if ( m_bSpecial )
{
CSingleUserRecipientFilter userfilter( pPlayer );
UserMessageBegin( userfilter, "BonusDucks" );
WRITE_BYTE( pPlayer->entindex() );
WRITE_BYTE( true );
MessageEnd();
}
// Notify User that they picked up a EOTL duck if the holiday is active
if ( pPlayer && TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_EOTL ) && !TFGameRules()->HaveCheatsBeenEnabledDuringLevel() )
{
int iFlags = m_iFlags;
if ( m_bSpecial )
{
iFlags |= DUCK_FLAG_BONUS;
}
// Send Message to Toucher and Creator if Creator is same team as toucher
// Tell your team you picked up a duck
// IsCreated, ID of Creator, ID of Victim, Count, IsGolden
// Message to Toucher
{
CSingleUserRecipientFilter userfilter( pPlayer );
UserMessageBegin( userfilter, "EOTLDuckEvent" );
WRITE_BYTE( false );
WRITE_BYTE( m_iCreatorId );
WRITE_BYTE( m_iVictimId );
WRITE_BYTE( pPlayer->entindex() );
WRITE_BYTE( GetTeamNumber() );
WRITE_BYTE( 1 );
WRITE_BYTE( iFlags );
MessageEnd();
}
// Notify Creator
if ( m_iCreatorId != pPlayer->entindex() )
{
CBasePlayer *pCreator = UTIL_PlayerByIndex( m_iCreatorId );
if ( pCreator && pCreator->InSameTeam( pPlayer ) )
{
CSingleUserRecipientFilter userfilter( pCreator );
UserMessageBegin( userfilter, "EOTLDuckEvent" );
WRITE_BYTE( false );
WRITE_BYTE( m_iCreatorId );
WRITE_BYTE( m_iVictimId );
WRITE_BYTE( pPlayer->entindex() );
WRITE_BYTE( GetTeamNumber() );
WRITE_BYTE( 1 );
WRITE_BYTE( iFlags );
MessageEnd();
}
}
// Notify Assister someone picked up their duck as well
if ( m_iAssisterId != -1 && m_iAssisterId != pPlayer->entindex() )
{
CBasePlayer *pAssister = UTIL_PlayerByIndex( m_iAssisterId );
if ( pAssister && pAssister->InSameTeam( pPlayer ) )
{
CSingleUserRecipientFilter userfilter( pAssister );
UserMessageBegin( userfilter, "EOTLDuckEvent" );
WRITE_BYTE( false );
WRITE_BYTE( m_iAssisterId );
WRITE_BYTE( m_iVictimId );
WRITE_BYTE( pPlayer->entindex() );
WRITE_BYTE( GetTeamNumber() );
WRITE_BYTE( 1 );
WRITE_BYTE( iFlags );
MessageEnd();
}
}
}
}
return bSuccess;
}
//-----------------------------------------------------------------------------
void CBonusDuckPickup::DropSingleInstance( Vector &vecLaunchVel, CBaseCombatCharacter *pThrower, float flThrowerTouchDelay, float flResetTime /*= 0.1f*/ )
{
// Remove ourselves after some time
SetContextThink( &CBonusDuckPickup::NotifyFadeOut, gpGlobals->curtime + GetLifeTime(), "CBonusDuckPreRemoveThink" );
BaseClass::DropSingleInstance( vecLaunchVel, pThrower, flThrowerTouchDelay, flResetTime );
}
//-----------------------------------------------------------------------------
void CBonusDuckPickup::NotifyFadeOut( void )
{
//// Notify User that they picked up a EOTL duck if the holiday is active
//if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_EOTL ) )
//{
// int iFlags = 0;
// if ( m_bSpecial )
// {
// iFlags |= DUCK_FLAG_BONUS;
// }
// // Tell your team you picked up a duck
// // IsCreated, ID of Creator, ID of Victim, Count, IsGolden
// CTeamRecipientFilter userfilter( GetTeamNumber(), true );
// UserMessageBegin( userfilter, "EOTLDuckEvent" );
// WRITE_BYTE( false );
// WRITE_BYTE( m_iCreatorId );
// WRITE_BYTE( m_iVictimId );
// WRITE_BYTE( 0 );
// WRITE_BYTE( GetTeamNumber() );
// WRITE_BYTE( 1 );
// WRITE_BYTE( iFlags );
// MessageEnd();
//}
}
//-----------------------------------------------------------------------------
void CBonusDuckPickup::UpdateCollisionBounds()
{
CollisionProp()->SetCollisionBounds( Vector( -50, -50, -50 ), Vector( 50, 50, 50 ) );
}
//-----------------------------------------------------------------------------
void CBonusDuckPickup::BlinkThink()
{
float flTimeToKill = m_flKillTime - gpGlobals->curtime;
float flNextBlink = RemapValClamped( flTimeToKill, DUCK_BLINK_TIME, 0.f, 0.3f, 0.05f );
SetContextThink( &CBonusDuckPickup::BlinkThink, gpGlobals->curtime + flNextBlink, "BonusDuckBlinkThink" );
SetRenderMode( kRenderTransAlpha );
++m_nBlinkCount;
if ( m_nBlinkCount % 2 == 0 )
{
SetRenderColorA( 50 );
}
else
{
SetRenderColorA( 255 );
}
}
#else
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBonusDuckPickup::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged( updateType );
if ( updateType == DATA_UPDATE_CREATED )
{
if ( !IsDormant() )
{
if ( pGlowEffect )
{
ParticleProp()->StopEmission( pGlowEffect );
pGlowEffect = NULL;
}
if ( m_bSpecial )
{
pGlowEffect = ParticleProp()->Create( BONUS_DUCK_GLOW, PATTACH_ABSORIGIN_FOLLOW, 0, Vector( 0, 0, 10 ) );
// these are fire and forget
ParticleProp()->Create( ( GetTeamNumber() == TF_TEAM_RED ) ? BONUS_DUCK_TRAIL_SPECIAL_RED : BONUS_DUCK_TRAIL_SPECIAL_BLUE, PATTACH_ABSORIGIN_FOLLOW );
}
else
{
// these are fire and forget
ParticleProp()->Create( ( GetTeamNumber() == TF_TEAM_RED ) ? BONUS_DUCK_TRAIL_RED : BONUS_DUCK_TRAIL_BLUE, PATTACH_ABSORIGIN_FOLLOW );
}
CPVSFilter filter( GetAbsOrigin() );
EmitSound( filter, entindex(), BONUS_DUCK_CREATED_SOUND );
}
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Halloween Gift Spawn
//-----------------------------------------------------------------------------
#ifdef GAME_DLL
CHalloweenGiftSpawnLocation::CHalloweenGiftSpawnLocation()
{
}
#endif
//-----------------------------------------------------------------------------
CHalloweenGiftPickup::CHalloweenGiftPickup()
{
m_hTargetPlayer = NULL;
#ifdef CLIENT_DLL
m_pPreviousTargetPlayer = NULL;
#endif
}
//-----------------------------------------------------------------------------
void CHalloweenGiftPickup::Precache( void )
{
BaseClass::Precache();
PrecacheScriptSound( "sf15.Merasmus.Gargoyle.Spawn" );
PrecacheScriptSound( "sf15.Merasmus.Gargoyle.Gone" );
PrecacheScriptSound( "sf15.Merasmus.Gargoyle.Got" );
}
//------------------------------------------------------------------------
void CHalloweenGiftPickup::Spawn( void )
{
BaseClass::Spawn();
#ifdef GAME_DLL
// Set a timer
SetContextThink( &CHalloweenGiftPickup::DespawnGift, gpGlobals->curtime + tf_halloween_gift_lifetime.GetInt(), "DespawnGift" );
AddSpawnFlags( SF_NORESPAWN );
#endif // CLIENT_DLL
}
#ifdef GAME_DLL
//------------------------------------------------------------------------
// Despawn (and notify client) and then remove
//------------------------------------------------------------------------
void CHalloweenGiftPickup::DespawnGift()
{
SetTargetPlayer( NULL );
SetContextThink( &CHalloweenGiftPickup::RemoveGift, gpGlobals->curtime + 1.0, "RemoveGift" );
}
//------------------------------------------------------------------------
void CHalloweenGiftPickup::RemoveGift()
{
UTIL_Remove( this );
}
//------------------------------------------------------------------------
void CHalloweenGiftPickup::SetTargetPlayer( CTFPlayer *pTarget )
{
m_hTargetPlayer = pTarget;
}
//------------------------------------------------------------------------
bool CHalloweenGiftPickup::ValidTouch( CBasePlayer *pPlayer )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer && pTFPlayer != m_hTargetPlayer.Get() )
return false;
return true;
}
//------------------------------------------------------------------------
bool CHalloweenGiftPickup::MyTouch( CBasePlayer *pPlayer )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer && pTFPlayer != m_hTargetPlayer.Get() )
return false;
// TODO: Give contract points
// Visual effects
Vector vecOrigin = GetAbsOrigin();
CPVSFilter filter( vecOrigin );
TE_TFParticleEffect( filter, 0.0, "duck_collect_green", vecOrigin, vec3_angle );
// Sound effects
CSingleUserRecipientFilter touchingFilter( pPlayer );
EmitSound( touchingFilter, entindex(), "Halloween.PumpkinPickup" );
EmitSound( touchingFilter, entindex(), "sf15.Merasmus.Gargoyle.Got" );
// Give souls to the collecting player
#ifdef STAGING_ONLY
for( int i=0; i<tf_halloween_gift_soul_value.GetInt(); ++i )
#else
for( int i=0; i<10; ++i )
#endif // STAGING_ONLY
{
TFGameRules()->DropHalloweenSoulPack( 1, vecOrigin, pPlayer, TEAM_SPECTATOR );
}
// Achievement
if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_MANN_MANOR ) )
{
pTFPlayer->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_COLLECT_GOODY_BAG );
}
return true;
}
#endif // GAME_DLL
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
void CHalloweenGiftPickup::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged( updateType );
if ( updateType == DATA_UPDATE_DATATABLE_CHANGED )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer )
{
// Gift Added
if ( m_hTargetPlayer.Get() != NULL && m_pPreviousTargetPlayer == NULL && m_hTargetPlayer.Get() == pLocalPlayer )
{
// Notification
CEconNotification *pNotification = new CEconNotification();
pNotification->SetText( "#TF_HalloweenItem_SoulAppeared" );
pNotification->SetLifetime( 5.0f );
pNotification->SetSoundFilename( "ui/halloween_loot_spawn.wav" );
NotificationQueue_Add( pNotification );
pLocalPlayer->EmitSound( "sf15.Merasmus.Gargoyle.Spawn" );
}
// Gift Despawned
if ( m_hTargetPlayer.Get() == NULL && m_pPreviousTargetPlayer != NULL && m_pPreviousTargetPlayer == pLocalPlayer )
{
// Notification
CEconNotification *pNotification = new CEconNotification();
pNotification->SetText( "#TF_HalloweenItem_SoulDisappeared" );
pNotification->SetLifetime( 5.0f );
pNotification->SetSoundFilename( "ui/halloween_loot_found.wav" );
NotificationQueue_Add( pNotification );
pLocalPlayer->EmitSound( "sf15.Merasmus.Gargoyle.Gone" );
}
m_pPreviousTargetPlayer = m_hTargetPlayer.Get();
}
}
}
//------------------------------------------------------------------------
bool CHalloweenGiftPickup::ShouldDraw()
{
CTFPlayer *pOwner = m_hTargetPlayer.Get();
if ( pOwner != C_TFPlayer::GetLocalTFPlayer() )
return false;
return BaseClass::ShouldDraw();
}
#endif