source-engine/game/server/tf/tf_projectile_flare.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// TF Nail
//
//=============================================================================
#include "cbase.h"
#include "tf_projectile_flare.h"
#include "soundent.h"
#include "tf_fx.h"
#include "tf_player.h"
#include "tf_weapon_flaregun.h"
#include "tf_gamerules.h"

//=============================================================================
//
// TF Flare Projectile functions (Server specific).
//
#define FLARE_MODEL					"models/weapons/w_models/w_flaregun_shell.mdl"
#define FLARE_GRAVITY				0.3f
#define FLARE_SPEED					2000.0f

#define FLARE_THINK_CONTEXT			"CTFProjectile_FlareThink"

LINK_ENTITY_TO_CLASS( tf_projectile_flare, CTFProjectile_Flare );
PRECACHE_WEAPON_REGISTER( tf_projectile_flare );

IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_Flare, DT_TFProjectile_Flare )

BEGIN_NETWORK_TABLE( CTFProjectile_Flare, DT_TFProjectile_Flare )
	SendPropBool( SENDINFO( m_bCritical ) ),
END_NETWORK_TABLE()

BEGIN_DATADESC( CTFProjectile_Flare )
DEFINE_THINKFUNC( ImpactThink ),
END_DATADESC()

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Flare::CTFProjectile_Flare()
{
	m_bIsFromTaunt = false;
	m_bCritical = false;
	m_bImpact = false;
	m_flImpactTime = 0.0f;
	m_flNextSeekUpdate = 0.0f;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Flare::~CTFProjectile_Flare()
{

}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Flare *CTFProjectile_Flare::Create( CBaseEntity *pLauncher, const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
	CTFProjectile_Flare *pFlare = static_cast<CTFProjectile_Flare*>( CBaseEntity::CreateNoSpawn( "tf_projectile_flare", vecOrigin, vecAngles, pOwner ) );
	if ( !pFlare )
		return NULL;

	pFlare->SetLauncher( pLauncher );

	// Initialize the owner.
	pFlare->SetOwnerEntity( pOwner );

	// Set team.
	pFlare->ChangeTeam( pOwner->GetTeamNumber() );

	// Save the scoring player.
	pFlare->SetScorer( pScorer );

	// Spawn.
	DispatchSpawn( pFlare );

	// Setup the initial velocity.
	Vector vecForward, vecRight, vecUp;
	AngleVectors( vecAngles, &vecForward, &vecRight, &vecUp );

	float flLaunchSpeed = pFlare->GetProjectileSpeed();

	Vector vecVelocity = vecForward * flLaunchSpeed;
	pFlare->SetAbsVelocity( vecVelocity );	
	pFlare->SetupInitialTransmittedGrenadeVelocity( vecVelocity );

	float flGravity = FLARE_GRAVITY;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pLauncher, flGravity, mult_projectile_speed );
	pFlare->SetGravity( flGravity );

	// Setup the initial angles.
	QAngle angles;
	VectorAngles( vecVelocity, angles );
	pFlare->SetAbsAngles( angles );

	return pFlare;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::Spawn()
{
	SetModel( FLARE_MODEL );
	BaseClass::Spawn();

	float flHeatSeekPower = GetHeatSeekPower();

	if ( flHeatSeekPower > 0.0f )
	{
		SetMoveType( MOVETYPE_CUSTOM, MOVECOLLIDE_DEFAULT );
		SetGravity( FLARE_GRAVITY );
	}
	else
	{
		SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
		SetGravity( FLARE_GRAVITY );
	}

	// Set team.
	m_nSkin = ( GetTeamNumber() == TF_TEAM_BLUE ) ? 1 : 0;

	m_flCreationTime = gpGlobals->curtime;

	CTFPlayer *pScorer = ToTFPlayer( GetScorer() );
	if ( pScorer && pScorer->IsTaunting() && m_flCreationTime >= pScorer->GetTauntAttackTime() )
	{
		m_bIsFromTaunt = true;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::Precache()
{
	PrecacheModel( FLARE_MODEL );
	PrecacheParticleSystem( "flaregun_trail_red" );
	PrecacheParticleSystem( "flaregun_trail_crit_red" );
	PrecacheParticleSystem( "flaregun_trail_blue" );
	PrecacheParticleSystem( "flaregun_trail_crit_blue" );
	PrecacheParticleSystem( "drg_manmelter_projectile" );
	PrecacheParticleSystem( "scorchshot_trail_red" );
	PrecacheParticleSystem( "scorchshot_trail_crit_red" );
	PrecacheParticleSystem( "scorchshot_trail_blue" );
	PrecacheParticleSystem( "scorchshot_trail_crit_blue" );
	PrecacheParticleSystem( "Explosions_MA_FlyingEmbers" );

	PrecacheParticleSystem( "pyrovision_flaregun_trail_blue" );
	PrecacheParticleSystem( "pyrovision_flaregun_trail_red" );
	PrecacheParticleSystem( "pyrovision_flaregun_trail_crit_blue" );
	PrecacheParticleSystem( "pyrovision_flaregun_trail_crit_red" );
	PrecacheParticleSystem( "pyrovision_scorchshot_trail_blue" );
	PrecacheParticleSystem( "pyrovision_scorchshot_trail_red" );
	PrecacheParticleSystem( "pyrovision_scorchshot_trail_crit_blue" );
	PrecacheParticleSystem( "pyrovision_scorchshot_trail_crit_red" );

	BaseClass::Precache();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::SetScorer( CBaseEntity *pScorer )
{
	m_Scorer = pScorer;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBasePlayer *CTFProjectile_Flare::GetScorer( void )
{
	return dynamic_cast<CBasePlayer *>( m_Scorer.Get() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTFProjectile_Flare::GetDamageType() 
{ 
	int iDmgType = BaseClass::GetDamageType();
	if ( m_bCritical )
	{
		iDmgType |= DMG_CRITICAL;
	}

	return iDmgType;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::Explode( trace_t *pTrace, CBaseEntity *pOther )
{
	Vector vecOrigin = GetAbsOrigin();

	CBaseEntity *pAttacker = GetOwnerEntity();
	IScorer *pScorerInterface = dynamic_cast<IScorer*>( pAttacker );
	if ( pScorerInterface )
	{
		pAttacker = pScorerInterface->GetScorer();
	}

	CTFPlayer *pTFVictim = ToTFPlayer( pOther );

	CTFFlareGun *pFlareGun = dynamic_cast< CTFFlareGun* >( GetLauncher() );
	if ( pFlareGun )
	{
		if ( pFlareGun->GetFlareGunType() == FLAREGUN_SCORCHSHOT )
		{
			// When the scorch shot hits a player...
			if ( pTFVictim )
			{
				// Now it only collides with the world
				SetCollisionGroup( COLLISION_GROUP_DEBRIS );

				Vector vVelocity = GetAbsVelocity();

				// Check if burning before damage
				bool bIsBurningVictim = pTFVictim->m_Shared.InCond( TF_COND_BURNING );
				int iDamageType = GetDamageType();
				
				// Prevent the normal push force cause we are going to add it
				iDamageType |= DMG_PREVENT_PHYSICS_FORCE;

				// Damage the player to push them back
				CTakeDamageInfo info( this, pAttacker, m_hLauncher, vec3_origin, vecOrigin, GetDamage(), iDamageType, m_bIsFromTaunt ? TF_DMG_CUSTOM_FLARE_PELLET : 0 );
				pTFVictim->TakeDamage( info );

				bool bIsEnemy = pAttacker && pTFVictim->GetTeamNumber() != pAttacker->GetTeamNumber();
				
				// Quick Fix Uber and teammates are immune to the force
				if ( !pTFVictim->m_Shared.InCond( TF_COND_MEGAHEAL ) && bIsEnemy )
				{
					Vector vecToTarget;
					vecToTarget = vVelocity;
					VectorNormalize( vecToTarget );
					vecToTarget.z = 1.0;

					// apply airblast - Apply stun if they are effectively grounded so we can knock them up
					if ( !pTFVictim->m_Shared.InCond( TF_COND_KNOCKED_INTO_AIR ) )
					{
						pTFVictim->m_Shared.StunPlayer( 0.5, 1.f, TF_STUN_MOVEMENT, ToTFPlayer( pAttacker ) );
					}
					
					float flForce = bIsBurningVictim ? 400.0f : 100.0f;
					pTFVictim->ApplyAirBlastImpulse( vecToTarget * flForce );
				}

				// It loses almost all of its speed and pops into the air
				vVelocity.x *= 0.07f;
				vVelocity.y *= 0.07f;
				vVelocity.z = 100.0f;
				SetAbsVelocity( vVelocity + RandomVector( -2.0f, 2.0f ) );

				// Point the new direction and randomly flip
				QAngle angForward;
				VectorAngles( vVelocity, angForward );
				SetAbsAngles( angForward );

				QAngle angRotation = RandomAngle( 180.0f, 720.0f );
				angRotation.x *= ( RandomInt( 0, 1 ) == 0 ? 1 : -1 );
				angRotation.y *= ( RandomInt( 0, 1 ) == 0 ? 1 : -1 );
				angRotation.z *= ( RandomInt( 0, 1 ) == 0 ? 1 : -1 );

				SetLocalAngularVelocity( angRotation );

				CPVSFilter filter( vecOrigin );
				EmitSound( filter, entindex(), "Rubber.BulletImpact" );

				// Save this entity as enemy, they will take 100% damage.
				if ( m_hEnemy.Get() == NULL )
				{
					m_hEnemy = pTFVictim;
				}

				return;
			}
		}
	}

	// If we've already got an impact time, don't impact again.
	if ( m_flImpactTime > 0.0 )
		return;

	// Save this entity as enemy, they will take 100% damage.
	if ( m_hEnemy.Get() == NULL )
	{
		m_hEnemy = pOther;
	}

	if ( !pTFVictim )
	{
		m_bImpact = true;
	}

	// Invisible.
	AddSolidFlags( FSOLID_NOT_SOLID );
	m_takedamage = DAMAGE_NO;

	bool bDetonate = false;
	bool bNoRandomCrit = false;
	if ( pFlareGun )
	{
		switch ( pFlareGun->GetFlareGunType() )
		{
		case FLAREGUN_DETONATE:
			bDetonate = true;
			break;

		case FLAREGUN_GRORDBORT:
			bNoRandomCrit = true;
			break;

		case FLAREGUN_SCORCHSHOT:
			bDetonate = true;
			bNoRandomCrit = true;
			break;
		}
	}

	// Flares that hit a burning player crit, unless it's a detonate flare - they mini-crit
	if ( pTFVictim && pTFVictim->m_Shared.InCond( TF_COND_BURNING ) && !bDetonate && !bNoRandomCrit )
	{
		m_bCritical = true;
	}

	CTakeDamageInfo info( this, pAttacker, m_hLauncher, vec3_origin, vecOrigin, GetDamage(), GetDamageType(), TF_DMG_CUSTOM_BURNING_FLARE );
	pOther->TakeDamage( info );

	// Remove the flare.
	if ( m_bImpact )
	{
		SetMoveType( MOVETYPE_FLY );
		SetAbsVelocity( vec3_origin );

		m_vecImpactNormal = pTrace->plane.normal;
		m_flImpactTime = gpGlobals->curtime + 0.1f;

		// Stick into and object and fizzle a little while.
		SetContextThink( &CTFProjectile_Flare::ImpactThink, gpGlobals->curtime, FLARE_THINK_CONTEXT );

		// Only do this for the Detonator
		if ( bDetonate )
		{
			// Scorch Shot can still light others in this case
			Detonate( pFlareGun->GetFlareGunType() != FLAREGUN_SCORCHSHOT );
		}
	}
	else
	{
		// Impact player sound.
		CPVSFilter filter( vecOrigin );
		EmitSound( filter, pOther->entindex(), "TFPlayer.FlareImpact" );

		SendDeathNotice();
		UTIL_Remove( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Custom explode for air burst flare
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::Explode_Air( trace_t *pTrace, int bitsDamageType, bool bSelfOnly )
{
	// Invisible.
	AddSolidFlags( FSOLID_NOT_SOLID );
	m_takedamage = DAMAGE_NO;

	// Play explosion sound and effect.
	Vector vecOrigin = GetAbsOrigin();
	CPVSFilter filter( vecOrigin );

	CBaseEntity *pAttacker = GetOwnerEntity();
	int nDefID = -1;
	WeaponSound_t nSound = SPECIAL1;
	if ( pAttacker )
	{
		CTFFlareGun *pFlareGun = dynamic_cast<CTFFlareGun*>( ToTFPlayer( pAttacker )->GetActiveWeapon() );
		if ( pFlareGun )
		{
			CEconItemView *pItem = pFlareGun->GetAttributeContainer()->GetItem();
			nDefID = pItem->GetItemDefIndex();
		}

		// Damage.
		IScorer *pScorerInterface = dynamic_cast<IScorer*>( pAttacker );
		if ( pScorerInterface )
		{
			pAttacker = pScorerInterface->GetScorer();
		}

		float flRadius = bSelfOnly ? 0.f : GetRadius();

		if ( bSelfOnly )
		{
			bitsDamageType |= DMG_BLAST;
			nSound = SPECIAL2;
		}

#if defined( _DEBUG ) && defined( STAGING_ONLY )
		// Debug!
		ConVarRef tf_rocket_show_radius( "tf_rocket_show_radius" );
		if ( tf_rocket_show_radius.GetBool() )
		{
			DrawRadius( flRadius );
		}
#endif
		CTakeDamageInfo info( this, pAttacker, m_hLauncher, vec3_origin, vecOrigin, GetDamage(), bitsDamageType | DMG_HALF_FALLOFF, TF_DMG_CUSTOM_FLARE_EXPLOSION );
		CTFRadiusDamageInfo radiusinfo( &info, vecOrigin, flRadius, NULL, TF_FLARE_RADIUS_FOR_FJS );
		TFGameRules()->RadiusDamage( radiusinfo );
	}

	const char *pszParticle = bSelfOnly ? "Explosions_MA_FlyingEmbers" : "ExplosionCore_MidAir_Flare";
	TE_TFExplosion( filter, 0.0f, vecOrigin, pTrace->plane.normal, GetWeaponID(), entindex(), nDefID, nSound );
	TE_TFParticleEffect( filter, 0.0f, pszParticle, vecOrigin, pTrace->plane.normal, vec3_angle );
	CSoundEnt::InsertSound ( SOUND_COMBAT, vecOrigin, 1024, 3.0 );

	SendDeathNotice();
	UTIL_Remove( this );
}

//-----------------------------------------------------------------------------
// Purpose: Alt-fire air burst flare
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::Detonate( bool bSelfOnly )
{
	trace_t		tr;
	Vector		vecSpot;

	SetThink( NULL );

	vecSpot = GetAbsOrigin() + Vector ( 0 , 0 , 8 );
	UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -32 ), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, & tr);

	Explode_Air( &tr, GetDamageType(), bSelfOnly );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFProjectile_Flare::GetRadius( void ) 
{ 
	float flRadius = TF_FLARE_DET_RADIUS;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_hLauncher, flRadius, mult_explosion_radius );
	return flRadius; 
}

//-----------------------------------------------------------------------------
// Purpose: Let the flaregun know we're gone
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::SendDeathNotice( void ) 
{ 
	CBaseEntity *pAttacker = GetOwnerEntity();
	if ( !pAttacker )
		return;

	CTFFlareGun *pFlareGun = dynamic_cast<CTFFlareGun*>( ToTFPlayer( pAttacker )->GetActiveWeapon() );
	if ( pFlareGun && pFlareGun->GetFlareGunType() == FLAREGUN_DETONATE )
	{
		pFlareGun->DeathNotice( this );
	}
}	

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::ImpactThink( void )
{
	if ( gpGlobals->curtime > m_flImpactTime )
	{
		// If we hit anything other than the player create an impact - effect, sound, etc.
		if ( m_hEnemy.Get() )
		{
			Vector vecOrigin = GetAbsOrigin();
			CPVSFilter filter( vecOrigin );
			TE_TFExplosion( filter, 0.0f, vecOrigin, m_vecImpactNormal, GetWeaponID(), m_hEnemy.Get()->entindex() );
		}

		SendDeathNotice();
		UTIL_Remove( this );
		SetContextThink( NULL, 0, FLARE_THINK_CONTEXT );
	}
	else
	{
		SetContextThink( &CTFProjectile_Flare::ImpactThink, gpGlobals->curtime + 0.1f, FLARE_THINK_CONTEXT );
	}
}

void CTFProjectile_Flare::PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity )
{
	if ( m_flNextSeekUpdate < gpGlobals->curtime )
	{
		CTFPlayer *pBestTarget = NULL;
		const float flMaxSeekDistanceSqr = ( 1024.0f * 1024.0f );
		float flBestDistance = flMaxSeekDistanceSqr;

		// Loop through players and attempt to find a seek target
		int i;
		for ( i = 1; i <= gpGlobals->maxClients; i++ )
		{
			CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
			if ( !pPlayer )
				continue;

			bool bBurning = pPlayer->m_Shared.InCond( TF_COND_BURNING );

			if ( !bBurning || 
				 pPlayer->InSameTeam( this ) || 
				 ( pPlayer->m_Shared.GetDisguiseTeam() == GetTeamNumber() && !bBurning ) ||
				 ( pPlayer->m_Shared.IsStealthed() && !bBurning ) || 
				 pPlayer->GetTeamNumber() == TEAM_SPECTATOR ||
				 !pPlayer->IsAlive() )
			{
				continue;
			}

			Vector vToTarget = pPlayer->WorldSpaceCenter() - GetAbsOrigin();
			VectorNormalize( vToTarget );

			Vector vForward = *pNewVelocity;
			VectorNormalize( vForward );

			if ( vToTarget.Dot( vForward ) < -0.25f )
				continue;

			float flDistanceSqr = pPlayer->WorldSpaceCenter().DistToSqr( GetAbsOrigin() );
			if ( flBestDistance > flDistanceSqr )
			{
				trace_t tr;
				UTIL_TraceLine( pPlayer->WorldSpaceCenter(), GetAbsOrigin(), MASK_SOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, &tr );
				if ( !tr.DidHit() || tr.m_pEnt == this )
				{
					flBestDistance = flDistanceSqr;
					pBestTarget = pPlayer;
				}
			}
		}

		float flHeatSeekPower = GetHeatSeekPower();

		QAngle angToTarget = *pNewAngles;

		if ( pBestTarget )
		{
			Vector vToTarget = pBestTarget->WorldSpaceCenter() - GetAbsOrigin();
			VectorAngles( vToTarget, angToTarget );
		}

		const float flUpdatesPerSecond = 4.0f;

		if ( angToTarget != *pNewAngles )
		{
			pNewAngVelocity->x = Approach( UTIL_AngleDiff( angToTarget.x, pNewAngles->x ) * flUpdatesPerSecond, pNewAngVelocity->x, flHeatSeekPower );
			pNewAngVelocity->y = Approach( UTIL_AngleDiff( angToTarget.y, pNewAngles->y ) * flUpdatesPerSecond, pNewAngVelocity->y, flHeatSeekPower );
			pNewAngVelocity->z = Approach( UTIL_AngleDiff( angToTarget.z, pNewAngles->z ) * flUpdatesPerSecond, pNewAngVelocity->z, flHeatSeekPower );

			const float flMaxAngularVelocity = 360.0f;
			pNewAngVelocity->x = clamp( pNewAngVelocity->x, -flMaxAngularVelocity, flMaxAngularVelocity );
			pNewAngVelocity->y = clamp( pNewAngVelocity->y, -flMaxAngularVelocity, flMaxAngularVelocity );
			pNewAngVelocity->z = clamp( pNewAngVelocity->z, -flMaxAngularVelocity, flMaxAngularVelocity );
		}

		m_flNextSeekUpdate = gpGlobals->curtime + ( 1.0f / flUpdatesPerSecond );
	}

	*pNewAngles += *pNewAngVelocity * gpGlobals->frametime;

	Vector vForward;
	AngleVectors( *pNewAngles, &vForward );
	*pNewVelocity = vForward * GetProjectileSpeed();

	*pNewPosition += *pNewVelocity * gpGlobals->frametime;
}

//-----------------------------------------------------------------------------
// Purpose: Flare was deflected.
//-----------------------------------------------------------------------------
void CTFProjectile_Flare::Deflected( CBaseEntity *pDeflectedBy, Vector &vecDir )
{
	CTFPlayer *pTFDeflector = ToTFPlayer( pDeflectedBy );
	if ( !pTFDeflector )
		return;

	ChangeTeam( pTFDeflector->GetTeamNumber() );
	SetLauncher( pTFDeflector->GetActiveWeapon() );

	CTFPlayer* pOldOwner = ToTFPlayer( GetOwnerEntity() );
	SetOwnerEntity( pTFDeflector );

	if ( pOldOwner )
	{
		pOldOwner->SpeakConceptIfAllowed( MP_CONCEPT_DEFLECTED, "projectile:1,victim:1" );
	}

	if ( pTFDeflector->m_Shared.IsCritBoosted() )
	{
		SetCritical( true );
	}

	CTFWeaponBase::SendObjectDeflectedEvent( pTFDeflector, pOldOwner, GetWeaponID(), this );

	IncrementDeflected();
	SetScorer( pTFDeflector );
}

float CTFProjectile_Flare::GetProjectileSpeed( void ) const
{
	float flLaunchSpeed = FLARE_SPEED;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_hLauncher, flLaunchSpeed, mult_projectile_speed );

	return flLaunchSpeed;
}

float CTFProjectile_Flare::GetHeatSeekPower( void ) const
{
	float flHeatSeekPower = 0.0;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( m_hLauncher, flHeatSeekPower, mod_projectile_heat_seek_power );

	return flHeatSeekPower;
}