asw_barrel_explosive.cpp

#include "cbase.h"
#include "world.h"
#include "asw_barrel_explosive.h"
#include "asw_marine.h"
#include "asw_player.h"
#include "asw_gamerules.h"
#include "particle_parse.h"
#include "asw_util_shared.h"
#include "cvisibilitymonitor.h"
#include "asw_deathmatch_mode_light.h"

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

#define ASW_EXPLOSIVE_BARREL_MODEL_NAME "models/swarm/Barrel/barrel.mdl"


ConVar asw_barrel_health_base( "asw_barrel_health_base", "3", FCVAR_CHEAT, "Health of barrel at level 1" );
ConVar asw_barrel_health_growth( "asw_barrel_health_growth", "0.15", FCVAR_CHEAT, "% change in health per level" );


LINK_ENTITY_TO_CLASS( asw_barrel_explosive, CASW_Barrel_Explosive );

BEGIN_DATADESC( CASW_Barrel_Explosive )	
	
END_DATADESC()


CASW_Barrel_Explosive::CASW_Barrel_Explosive()
{
	m_iExplosionDamage = 200;
}

void CASW_Barrel_Explosive::Spawn()
{
	DisableAutoFade();
	SetModelName( AllocPooledString( ASW_EXPLOSIVE_BARREL_MODEL_NAME ) );
	Precache();
	SetModel( ASW_EXPLOSIVE_BARREL_MODEL_NAME );

	AddSpawnFlags( SF_PHYSPROP_AIMTARGET );
	BaseClass::Spawn();

	InitHealth();

	VisibilityMonitor_AddEntity( this, asw_visrange_generic.GetFloat() * 0.9f, NULL, NULL );
}

void CASW_Barrel_Explosive::Precache()
{
	PrecacheParticleSystem( "explosion_barrel" );
	PrecacheScriptSound( "ASWBarrel.Explode" );
	PrecacheModel( ASW_EXPLOSIVE_BARREL_MODEL_NAME );

	BaseClass::Precache();
}

int CASW_Barrel_Explosive::OnTakeDamage( const CTakeDamageInfo &info )
{
	// don't be destroyed by buzzers
	CBaseEntity* pAttacker = info.GetAttacker();
	if ( pAttacker && pAttacker->Classify() == CLASS_ASW_BUZZER )
		return 0;

	// prevent barrel exploding when knocked around
	if ( info.GetDamageType() & DMG_CRUSH )
		return 0;
	
	CASW_Marine* pMarine = NULL;
	if ( pAttacker && pAttacker->Classify() == CLASS_ASW_MARINE )
	{
		m_hAttacker = pAttacker;

		pMarine = assert_cast< CASW_Marine* >(pAttacker);
		// prevent AI marines blowing up barrels as it makes the player ANGRY ANGRY
		// BenLubar(deathmatch-improvements): ...except in deathmatch
		if ( !pMarine->IsInhabited() && !ASWDeathmatchMode() )
			return 0;
	}

	int saveFlags = m_takedamage;
	// don't burst open if melee'd
	if ( info.GetDamageType() & ( DMG_CLUB | DMG_SLASH ) )
	{
		m_takedamage = DAMAGE_EVENTS_ONLY;

		if( !m_bMeleeHit )
		{
			if ( pMarine )
			{
				IGameEvent * event = gameeventmanager->CreateEvent( "physics_melee" );
				if ( event )
				{
					CASW_Player *pCommander = pMarine->GetCommander();
					event->SetInt( "attacker", pCommander ? pCommander->GetUserID() : 0 );
					event->SetInt( "entindex", entindex() );
					gameeventmanager->FireEvent( event );
				}
			}
			m_bMeleeHit = true;
		}
	}

	if ( pMarine )
	{
		pMarine->HurtJunkItem(this, info);
	}

	// skip the breakable prop's complex damage handling and just hurt us
	int iResult = CBaseEntity::OnTakeDamage(info);
	m_takedamage = saveFlags;

	return iResult;
}

void CASW_Barrel_Explosive::Event_Killed( const CTakeDamageInfo &info )
{
	IPhysicsObject *pPhysics = VPhysicsGetObject();
	if ( pPhysics && !pPhysics->IsMoveable() )
	{
		pPhysics->EnableMotion( true );
		VPhysicsTakeDamage( info );
	}

	QueueForExplode( info );

	// Break( info.GetInflictor(), info );
	// DoExplosion();
}

void CASW_Barrel_Explosive::ExplodeNow( const CTakeDamageInfo &info )
{
	Break( info.GetInflictor(), info );
	DoExplosion();
}

void CASW_Barrel_Explosive::DoExplosion()
{
	// scorch decals
	Vector vecForward = GetAbsVelocity();
	float flTraceDist = 80.0f;
	if ( vecForward.LengthSqr() < 0.001f )
		vecForward = Vector( 0, 0, -1 );
	VectorNormalize( vecForward );
	trace_t tr;
	UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + flTraceDist * vecForward, MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr );

	if ( ( tr.m_pEnt != GetWorldEntity() ) || ( tr.hitbox != 0 ) )
	{
		// non-world needs smaller decals
		if ( tr.m_pEnt )
		{
			UTIL_DecalTrace( &tr, "SmallScorch" );
		}
	}
	else
	{
		UTIL_DecalTrace( &tr, "Scorch" );
	}

	UTIL_ASW_ScreenShake( GetAbsOrigin(), 25.0, 150.0, 1.0, 750, SHAKE_START );

	// explosion effects
	Vector vecExplosionPos = GetAbsOrigin();
	CPASFilter filter( vecExplosionPos );
	UserMessageBegin( filter, "ASWBarrelExplosion" );
	WRITE_FLOAT( vecExplosionPos.x );
	WRITE_FLOAT( vecExplosionPos.y );
	WRITE_FLOAT( vecExplosionPos.z );
	WRITE_FLOAT( 160.0f );
	MessageEnd();

	EmitSound( "ASWBarrel.Explode" );

	// damage to nearby things
	CTakeDamageInfo info( this, ( m_hAttacker.Get() ? m_hAttacker.Get() : this ), m_iExplosionDamage, DMG_BLAST );
	info.SetDamageCustom( DAMAGE_FLAG_HALF_FALLOFF );
	ASWGameRules()->RadiusDamage( info, GetAbsOrigin(), 160.0f, CLASS_NONE, NULL );
}

void CASW_Barrel_Explosive::OnDifficultyChanged( int iDifficulty )
{
	InitHealth();
}

void CASW_Barrel_Explosive::InitHealth()
{
	m_iMinHealthDmg = 0;
	m_iHealth = asw_barrel_health_base.GetInt();
	const float flHealthGrowth = asw_barrel_health_growth.GetFloat();
	m_iHealth = m_iHealth + m_iHealth * flHealthGrowth * ( ASWGameRules()->GetMissionDifficulty() - 1 );
	SetMaxHealth( m_iHealth );

	m_iExplosionDamage = 200.0f;
	/*
	int iExplosiveDamage = 120.0f;
	m_iExplosionDamage = iExplosiveDamage + iExplosiveDamage * flHealthGrowth * ( ASWGameRules()->GetMissionDifficulty() - 1 );
	//SetExplosiveRadius( 160.0f );
	*/
}


// the queue of explodable objects
class CDeferredExplosionQueue : public CAutoGameSystemPerFrame
{
public:
	CDeferredExplosionQueue() : CAutoGameSystemPerFrame("CDeferredExplosionQueue"), m_fLastExplosionTime(0) {};

	/// enqueue an object for explosion. may call ExplodeNow() immediately
	/// if nothing has or is slated to detonate this frame.
	void Enqueue( CASW_Exploding_Prop *pBoom, const CTakeDamageInfo &damageInfo, bool bImmediateExplosionAllowed = true );

	// game system interface
	virtual void FrameUpdatePreEntityThink( );
	virtual void LevelInitPreEntity();
	virtual void LevelShutdownPostEntity();

	float m_fLastExplosionTime; //< the gpglobals->tickcount when the last explosion happened
protected:
	// tell an enqued object to detonate. 
	inline void Detonate( CASW_Exploding_Prop *pBoom, const CTakeDamageInfo &damageInfo );

	class QueueCell_t
	{
	public:
		QueueCell_t(){};
		QueueCell_t( const CHandle<CASW_Exploding_Prop> &handle, const CTakeDamageInfo &damageInfo ) : m_hHandle(handle), m_damageInfo(damageInfo)
		{};

		CHandle<CASW_Exploding_Prop> m_hHandle;
		CTakeDamageInfo m_damageInfo;
	};

	CUtlQueue< QueueCell_t > m_Explodables;
};
CDeferredExplosionQueue g_ASWDeferredExplosionQueue;


void CDeferredExplosionQueue::Enqueue( CASW_Exploding_Prop *pBoom, const CTakeDamageInfo &damageInfo, bool bImmediateExplosionAllowed )
{
	// can it detonate immediately?
	if ( bImmediateExplosionAllowed && 
		 m_fLastExplosionTime <= gpGlobals->curtime - ASW_EXPLODING_PROP_INTERVAL && 
		 m_Explodables.Count() == 0 )
	{
		Detonate( pBoom, damageInfo );
	}
	else
	{
		// must be queued for later detonation. (unless it's already queued)
		const int count = m_Explodables.Count();
		for ( int i = 0 ; i < count ; ++i )
		{
			if ( m_Explodables[i].m_hHandle == pBoom )
				return; // bail out
		}
		m_Explodables.Insert( QueueCell_t(pBoom, damageInfo) );
	}
}

inline void CDeferredExplosionQueue::Detonate( CASW_Exploding_Prop *pBoom, const CTakeDamageInfo &damageInfo )
{
	m_fLastExplosionTime = gpGlobals->curtime;
	pBoom->ExplodeNow( damageInfo );
}

void CDeferredExplosionQueue::FrameUpdatePreEntityThink( )
{
	// if nothing has exploded this frame and we've got something in the queue, blow it up
	if ( m_fLastExplosionTime <= gpGlobals->curtime - ASW_EXPLODING_PROP_INTERVAL && 
		 m_Explodables.Count() > 0 )
	{
		CASW_Exploding_Prop *pBoom = m_Explodables.Head().m_hHandle.Get();
		if ( pBoom ) 
		{
			Detonate( pBoom, m_Explodables.Head().m_damageInfo );
		}
		m_Explodables.RemoveAtHead();
	}
}

void CDeferredExplosionQueue::LevelInitPreEntity()
{
	m_fLastExplosionTime = 0;
}

void CDeferredExplosionQueue::LevelShutdownPostEntity()
{
	// empty out everything in the queue
	m_Explodables.Purge();
}

void CASW_Exploding_Prop::QueueForExplode( const CTakeDamageInfo &damageInfo )
{
	g_ASWDeferredExplosionQueue.Enqueue( this, damageInfo );
}