//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "basetfplayer_shared.h"
#include "in_buttons.h"
#include "weapon_combatshield.h"
#include "weapon_flame_thrower.h"
#include "gasoline_shared.h"
#include "ammodef.h"


#define FLAME_THROWER_FIRE_INTERVAL		0.3		// Eject a fire blob entity this often.

#define FLAMETHROWER_FLAME_DISTANCE		400.0

#define FLAMETHROWER_FLAME_SPEED		500.0	//

#define FLAMETHROWER_DAMAGE_PER_SEC		1000

// How far the flame particles will spread from the center.
#define FLAMETHROWER_SPREAD_ANGLE		15.0


// ------------------------------------------------------------------------------------------------ //
// Pretty little tables.
// ------------------------------------------------------------------------------------------------ //

#if defined( CLIENT_DLL )

	#include "vstdlib/random.h"
	#include "engine/IEngineSound.h"

	#define FLAMETHROWER_PARTICLES_PER_SEC	100

#else

	#include "gasoline_blob.h"
	#include "fire_damage_mgr.h"
	#include "tf_gamerules.h"
	
	#define FLAMETHROWER_DAMAGE_INTERVAL	0.2

#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"


PRECACHE_WEAPON_REGISTER( weapon_flame_thrower );

LINK_ENTITY_TO_CLASS( weapon_flame_thrower, CWeaponFlameThrower );

IMPLEMENT_NETWORKCLASS_ALIASED( WeaponFlameThrower, DT_WeaponFlameThrower )

BEGIN_NETWORK_TABLE( CWeaponFlameThrower, DT_WeaponFlameThrower )
	#if defined( CLIENT_DLL )
		RecvPropInt( RECVINFO( m_bFiring ) )
	#else
		SendPropInt( SENDINFO( m_bFiring ), 1, SPROP_UNSIGNED )
	#endif
END_NETWORK_TABLE()
		  
BEGIN_PREDICTION_DATA( CWeaponFlameThrower )

	DEFINE_PRED_FIELD( m_bFiring, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),

END_PREDICTION_DATA()


static inline void GenerateRandomFlameThrowerVelocity( Vector &vOut, const Vector &vForward, const Vector &vRight, const Vector &vUp )
{
	static float radians = DEG2RAD( 90 - FLAMETHROWER_SPREAD_ANGLE );
	static float v = cos( radians ) / sin( radians );
	
	vOut = vForward + vRight * RandomFloat( -v, v ) + vUp * RandomFloat( -v, v );
	VectorNormalize( vOut );
}

template< class T >
int FindInArray( const T pTest, const T *pArray, int arrayLen )
{
	for ( int i=0; i < arrayLen; i++ )
	{
		if ( pTest == pArray[i] )
			return i;
	}
	return -1;
}


// ------------------------------------------------------------------------------------------------ //
// CWeaponFlameThrower implementation.
// ------------------------------------------------------------------------------------------------ //

CWeaponFlameThrower::CWeaponFlameThrower()
{
	InternalConstructor( false );
}


CWeaponFlameThrower::CWeaponFlameThrower( bool bCanister )
{
	InternalConstructor( bCanister );
}

void CWeaponFlameThrower::Precache()
{
	BaseClass::Precache();

	PrecacheScriptSound( "FlameThrower.Sound" );
}

void CWeaponFlameThrower::InternalConstructor( bool bCanister )
{
	m_bCanister = bCanister;

	m_bFiring = false;							   	
	m_flNextPrimaryAttack = -1;

	#if defined( CLIENT_DLL )
	{
		m_hFlameEmitter = CSimpleEmitter::Create( "flamethrower" );
		
		m_hFireMaterial = INVALID_MATERIAL_HANDLE;
		if ( IsGasCanister() )
		{
			m_hFireMaterial = m_hFlameEmitter->GetPMaterial( "particle/particle_noisesphere" );
		}
		else
		{
			m_hFireMaterial = m_hFlameEmitter->GetPMaterial( "particle/fire" );
		}
	
		m_FlameEvent.Init( FLAMETHROWER_PARTICLES_PER_SEC );

		m_bSoundOn = false;
	}
	#endif
}


CWeaponFlameThrower::~CWeaponFlameThrower()
{
	#if defined( CLIENT_DLL )
		StopFlameSound();
	#endif
}


bool CWeaponFlameThrower::IsGasCanister() const
{
	return m_bCanister;
}


bool CWeaponFlameThrower::IsPredicted() const
{
	return true;
}


void CWeaponFlameThrower::ItemPostFrame()
{
	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

	if ( pOwner->IsAlive() && 
		(pOwner->m_nButtons & IN_ATTACK) && 
		GetShieldState() == SS_DOWN &&
		GetPrimaryAmmo() > 2 )
	{
		PrimaryAttack();
		m_bFiring = true;

		// Prevent shield post frame if we're not ready to attack, or we're healing
		AllowShieldPostFrame( false );
	}
	else
	{
		AllowShieldPostFrame( true );
		m_flNextPrimaryAttack = -1;
		m_bFiring = false;

#if defined( CLIENT_DLL )
#else
		m_hPrevBlob = NULL;

		// It's easy to lay down gasoline and forget to leave enough ammo to ignite it, so
		// this allows the pyro to ignite any nearby gasoline blobs for free.
		if ( !m_bCanister && GetPrimaryAmmo() <= 2 )
		{
			IgniteNearbyGasolineBlobs();
		}
#endif
	}
}


void CWeaponFlameThrower::PrimaryAttack()
{
	#if defined( CLIENT_DLL )
	
	#else

		CBasePlayer *pOwner = ToBaseTFPlayer( GetOwner() );
		if ( !pOwner )
			return;
		
		// Ok.. find eligible entities in a cone in front of us.
		Vector vOrigin = pOwner->Weapon_ShootPosition( );
		Vector vForward, vRight, vUp;
		AngleVectors( pOwner->GetAbsAngles(), &vForward, &vRight, &vUp );

		// Find some entities to burn.
		CBaseEntity *pHitEnts[64];
		int nHitEnts = 0;

		#define NUM_TEST_VECTORS	30
		for ( int iTest=0; iTest < NUM_TEST_VECTORS; iTest++ )
		{	
			Vector vVel;  
			GenerateRandomFlameThrowerVelocity( vVel, vForward, vRight, vUp );

			trace_t tr;
			UTIL_TraceLine( vOrigin, vOrigin + vVel * FLAMETHROWER_FLAME_DISTANCE, MASK_SHOT & (~CONTENTS_HITBOX), NULL, COLLISION_GROUP_NONE, &tr );
			if ( tr.m_pEnt )
			{
				if ( TFGameRules()->IsTraceBlockedByWorldOrShield( vOrigin, vOrigin + vVel * FLAMETHROWER_FLAME_DISTANCE, GetOwner(), DMG_BURN | DMG_PROBE, &tr ) == false )
				{
					CBaseEntity *pTestEnt = tr.m_pEnt;
					if ( pTestEnt && IsBurnableEnt( pTestEnt, GetTeamNumber() ) )
					{
						if ( FindInArray( pTestEnt, pHitEnts, nHitEnts ) == -1 )
						{
							pHitEnts[nHitEnts++] = pTestEnt;
							if ( nHitEnts >= ARRAYSIZE( pHitEnts ) )
								break;
						}
					}
				}	
			}
		}

		for ( int iHitEnt=0; iHitEnt < nHitEnts; iHitEnt++ )
		{
			CBaseEntity *pEnt = pHitEnts[iHitEnt];

			float flDist = (pEnt->GetAbsOrigin() - vOrigin).Length();
			float flPercent = 1.0 - flDist / FLAMETHROWER_FLAME_DISTANCE;
			if ( flPercent < 0.1 )
				flPercent = 0.1;

			float flDamage = flPercent * FLAMETHROWER_DAMAGE_PER_SEC;
			GetFireDamageMgr()->AddDamage( pEnt, GetOwner(), flDamage, !IsGasolineBlob( pEnt ) );
		}
		

		// Drop a new petrol blob.
		if ( gpGlobals->curtime >= m_flNextPrimaryAttack )
		{
			float flLifetime = MAX_LIT_GASOLINE_BLOB_LIFETIME;
			if ( IsGasCanister() )
				flLifetime = MAX_UNLIT_GASOLINE_BLOB_LIFETIME;

			CGasolineBlob *pBlob = CGasolineBlob::Create( GetOwner(), vOrigin, vForward * FLAMETHROWER_FLAME_SPEED, false, FLAMETHROWER_FLAME_DISTANCE / FLAMETHROWER_FLAME_SPEED, flLifetime );
			if ( pBlob )
			{
				if ( IsGasCanister() )
				{
					// Link the previous blob to this one.
					pBlob->AddAutoBurnBlob( m_hPrevBlob );
					if ( m_hPrevBlob.Get() )
						m_hPrevBlob->AddAutoBurnBlob( pBlob );

					m_hPrevBlob = pBlob;
				}
				else
				{
					pBlob->SetLit( true );
				}
			}

			pOwner->RemoveAmmo( 2, m_iPrimaryAmmoType );

			// Drop a blob every half second.
			m_flNextPrimaryAttack = gpGlobals->curtime + FLAME_THROWER_FIRE_INTERVAL;
		}

	#endif
}


#if defined( CLIENT_DLL )

	bool CWeaponFlameThrower::ShouldPredict()
	{
		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
			return true;

		return BaseClass::ShouldPredict();
	}


	void CWeaponFlameThrower::NotifyShouldTransmit( ShouldTransmitState_t state )
	{
		BaseClass::NotifyShouldTransmit( state );

		if ( state == SHOULDTRANSMIT_START )
		{
			SetNextClientThink( CLIENT_THINK_ALWAYS );
		}		
		else if ( state == SHOULDTRANSMIT_END )
		{
			SetNextClientThink( CLIENT_THINK_NEVER );
			StopFlameSound();
		}
	}

	void CWeaponFlameThrower::ClientThink()
	{
		// Spew some particles out.
		if ( !IsDormant() && IsCarrierAlive() && m_bFiring && m_hFlameEmitter.IsValid() )
		{
			unsigned char color[4] = { 255, 128, 0, 255 };
			if ( IsGasCanister() )
			{
				color[0] = color[1] = color[2] = 200;
				color[3] = 255;
			}

			StartSound();
			
			Vector vForward, vUp, vRight, vOrigin;
			QAngle vAngles;
			GetShootPosition( vOrigin, vAngles );
			AngleVectors( vAngles, &vForward, &vRight, &vUp );
			
			// Spew out flame particles.
			float dt = gpGlobals->frametime;
			while ( m_FlameEvent.NextEvent( dt ) )
			{
				SimpleParticle *p = m_hFlameEmitter->AddSimpleParticle( 
					m_hFireMaterial, 
					vOrigin + RandomVector( -3, 3 ),
					FLAMETHROWER_FLAME_DISTANCE / FLAMETHROWER_FLAME_SPEED,	// lifetime,
					9	// size
					);

				if ( p )
				{
					p->m_uchColor[0] = color[0];
					p->m_uchColor[1] = color[1];
					p->m_uchColor[2] = color[2];
					p->m_uchStartAlpha = color[3];
					p->m_uchEndAlpha = 0;
					GenerateRandomFlameThrowerVelocity( p->m_vecVelocity, vForward, vRight, vUp );
					p->m_vecVelocity *= RandomFloat( FLAMETHROWER_FLAME_SPEED * 0.9, FLAMETHROWER_FLAME_SPEED * 1.1 );
				}
			}
		}
		else
		{
			StopFlameSound();
		}
	}


	void CWeaponFlameThrower::StartSound()
	{
		if ( !m_bSoundOn )
		{
			CLocalPlayerFilter filter;
			EmitSound( filter, entindex(), "FlameThrower.Sound" );

			m_bSoundOn = true;
		}
	}


	void CWeaponFlameThrower::StopFlameSound()
	{
		if ( m_bSoundOn )
		{
			StopSound( entindex(), "FlameThrower.Sound" );
			m_bSoundOn = false;
		}
	}


#else

	bool CWeaponFlameThrower::Holster( CBaseCombatWeapon *pSwitchingTo )
	{
		m_bFiring = false;
		
		return BaseClass::Holster( pSwitchingTo );
	}


	void CWeaponFlameThrower::IgniteNearbyGasolineBlobs()
	{
		CBasePlayer *pOwner = ToBaseTFPlayer( GetOwner() );
		if ( !pOwner )
			return;

		Vector vOrigin = pOwner->Weapon_ShootPosition( );
		CBaseEntity *ents[128];
		float dists[128];
		int nEnts = FindBurnableEntsInSphere(
			ents,
			dists,
			ARRAYSIZE( dists ),
			vOrigin,
			50,
			pOwner );

		for ( int i=0; i < nEnts; i++ )
		{
			CGasolineBlob *pBlob = dynamic_cast< CGasolineBlob* >( ents[i] );
			if ( pBlob )
			{
				GetFireDamageMgr()->AddDamage( pBlob, pOwner, 500, false );
			}
		}
	}

#endif