//========= 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