1464 lines
37 KiB
C++
1464 lines
37 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
#include "cbase.h"
|
|
#include "decals.h"
|
|
#include "fire.h"
|
|
#include "entitylist.h"
|
|
#include "basecombatcharacter.h"
|
|
#include "ndebugoverlay.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "ispatialpartition.h"
|
|
#include "collisionutils.h"
|
|
#include "tier0/vprof.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
/********************************************************************
|
|
NOTE: if you are looking at this file becase you would like flares
|
|
to be considered as fires (and thereby trigger gas traps), be aware
|
|
that the env_flare class is actually found in weapon_flaregun.cpp
|
|
and is really a repurposed piece of ammunition. (env_flare isn't the
|
|
rod-like safety flare prop, but rather the bit of flame on the end.)
|
|
|
|
You will have some difficulty making it work here, because CFlare
|
|
does not inherit from CFire and will thus not be enumerated by
|
|
CFireSphere::EnumElement(). In order to have flares be detected and
|
|
used by this system, you will need to promote certain member functions
|
|
of CFire into an interface class from which both CFire and CFlare
|
|
inherit. You will also need to modify CFireSphere::EnumElement so that
|
|
it properly disambiguates between fires and flares.
|
|
|
|
For some partial work towards this end, see changelist 192474.
|
|
|
|
********************************************************************/
|
|
|
|
|
|
|
|
|
|
#define FIRE_HEIGHT 256.0f
|
|
#define FIRE_SCALE_FROM_SIZE(firesize) (firesize * (1/FIRE_HEIGHT))
|
|
|
|
#define FIRE_MAX_GROUND_OFFSET 24.0f //(2 feet)
|
|
|
|
#define DEFAULT_ATTACK_TIME 4.0f
|
|
#define DEFAULT_DECAY_TIME 8.0f
|
|
|
|
// UNDONE: This shouldn't be constant but depend on specific fire
|
|
#define FIRE_WIDTH 128
|
|
#define FIRE_MINS Vector(-20,-20,0 ) // Sould be FIRE_WIDTH in size
|
|
#define FIRE_MAXS Vector( 20, 20,20) // Sould be FIRE_WIDTH in size
|
|
#define FIRE_SPREAD_DAMAGE_MULTIPLIER 2.0
|
|
|
|
#define FIRE_MAX_HEAT_LEVEL 64.0f
|
|
#define FIRE_NORMAL_ATTACK_TIME 20.0f
|
|
#define FIRE_THINK_INTERVAL 0.1
|
|
|
|
ConVar fire_maxabsorb( "fire_maxabsorb", "50" );
|
|
ConVar fire_absorbrate( "fire_absorbrate", "3" );
|
|
ConVar fire_extscale("fire_extscale", "12");
|
|
ConVar fire_extabsorb("fire_extabsorb", "5");
|
|
ConVar fire_heatscale( "fire_heatscale", "1.0" );
|
|
ConVar fire_incomingheatscale( "fire_incomingheatscale", "0.1" );
|
|
ConVar fire_dmgscale( "fire_dmgscale", "0.1" );
|
|
ConVar fire_dmgbase( "fire_dmgbase", "1" );
|
|
ConVar fire_growthrate( "fire_growthrate", "1.0" );
|
|
ConVar fire_dmginterval( "fire_dmginterval", "1.0" );
|
|
|
|
#define VPROF_FIRE(s) VPROF( s )
|
|
|
|
class CFire : public CBaseEntity
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CFire, CBaseEntity );
|
|
|
|
int DrawDebugTextOverlays(void);
|
|
|
|
CFire( void );
|
|
|
|
virtual void UpdateOnRemove( void );
|
|
|
|
void Precache( void );
|
|
void Init( const Vector &position, float scale, float attackTime, float fuel, int flags, int fireType );
|
|
bool GoOut();
|
|
|
|
void BurnThink();
|
|
void GoOutThink();
|
|
void GoOutInSeconds( float seconds );
|
|
|
|
void SetOwner( CBaseEntity *hOwner ) { m_hOwner = hOwner; }
|
|
|
|
void Scale( float end, float time );
|
|
void AddHeat( float heat, bool selfHeat = false );
|
|
int OnTakeDamage( const CTakeDamageInfo &info );
|
|
|
|
bool IsBurning( void ) const;
|
|
|
|
bool GetFireDimensions( Vector *pFireMins, Vector *pFireMaxs );
|
|
|
|
void Extinguish( float heat );
|
|
void DestroyEffect();
|
|
|
|
virtual void Update( float simTime );
|
|
|
|
void Spawn( void );
|
|
void Activate( void );
|
|
void StartFire( void );
|
|
void Start();
|
|
void SetToOutSize()
|
|
{
|
|
UTIL_SetSize( this, Vector(-8,-8,0), Vector(8,8,8) );
|
|
}
|
|
|
|
float GetHeatLevel() { return m_flHeatLevel; }
|
|
|
|
virtual int UpdateTransmitState();
|
|
|
|
void DrawDebugGeometryOverlays(void)
|
|
{
|
|
if (m_debugOverlays & OVERLAY_BBOX_BIT)
|
|
{
|
|
if ( m_lastDamage > gpGlobals->curtime && m_flHeatAbsorb > 0 )
|
|
{
|
|
NDebugOverlay::EntityBounds(this, 88, 255, 128, 0 ,0);
|
|
char tempstr[512];
|
|
Q_snprintf( tempstr, sizeof(tempstr), "Heat: %.1f", m_flHeatAbsorb );
|
|
EntityText(1,tempstr, 0);
|
|
}
|
|
else if ( !IsBurning() )
|
|
{
|
|
NDebugOverlay::EntityBounds(this, 88, 88, 128, 0 ,0);
|
|
}
|
|
|
|
if ( IsBurning() )
|
|
{
|
|
Vector mins, maxs;
|
|
if ( GetFireDimensions( &mins, &maxs ) )
|
|
{
|
|
NDebugOverlay::Box(GetAbsOrigin(), mins, maxs, 128, 0, 0, 10, 0);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
BaseClass::DrawDebugGeometryOverlays();
|
|
}
|
|
|
|
void Disable();
|
|
|
|
//Inputs
|
|
void InputStartFire( inputdata_t &inputdata );
|
|
void InputExtinguish( inputdata_t &inputdata );
|
|
void InputExtinguishTemporary( inputdata_t &inputdata );
|
|
void InputEnable( inputdata_t &inputdata );
|
|
void InputDisable( inputdata_t &inputdata );
|
|
|
|
protected:
|
|
|
|
void Spread( void );
|
|
void SpawnEffect( fireType_e type, float scale );
|
|
|
|
CHandle<CBaseFire> m_hEffect;
|
|
EHANDLE m_hOwner;
|
|
|
|
int m_nFireType;
|
|
|
|
float m_flFuel;
|
|
float m_flDamageTime;
|
|
float m_lastDamage;
|
|
float m_flFireSize; // size of the fire in world units
|
|
|
|
float m_flHeatLevel; // Used as a "health" for the fire. > 0 means the fire is burning
|
|
float m_flHeatAbsorb; // This much heat must be "absorbed" before it gets transferred to the flame size
|
|
float m_flDamageScale;
|
|
|
|
float m_flMaxHeat;
|
|
float m_flLastHeatLevel;
|
|
|
|
//NOTENOTE: Lifetime is an expression of the sum total of these amounts plus the global time when started
|
|
float m_flAttackTime; //Amount of time to scale up
|
|
|
|
bool m_bEnabled;
|
|
bool m_bStartDisabled;
|
|
bool m_bDidActivate;
|
|
|
|
|
|
COutputEvent m_OnIgnited;
|
|
COutputEvent m_OnExtinguished;
|
|
|
|
DECLARE_DATADESC();
|
|
};
|
|
|
|
class CFireSphere : public IPartitionEnumerator
|
|
{
|
|
public:
|
|
CFireSphere( CFire **pList, int listMax, bool onlyActiveFires, const Vector &origin, float radius );
|
|
// This gets called by the enumeration methods with each element
|
|
// that passes the test.
|
|
virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity );
|
|
|
|
int GetCount() { return m_count; }
|
|
bool AddToList( CFire *pEntity );
|
|
|
|
private:
|
|
Vector m_origin;
|
|
float m_radiusSqr;
|
|
CFire **m_pList;
|
|
int m_listMax;
|
|
int m_count;
|
|
bool m_onlyActiveFires;
|
|
};
|
|
|
|
CFireSphere::CFireSphere( CFire **pList, int listMax, bool onlyActiveFires, const Vector &origin, float radius )
|
|
{
|
|
m_pList = pList;
|
|
m_listMax = listMax;
|
|
m_count = 0;
|
|
m_onlyActiveFires = onlyActiveFires;
|
|
m_origin = origin;
|
|
m_radiusSqr = radius * radius;
|
|
}
|
|
|
|
bool CFireSphere::AddToList( CFire *pFire )
|
|
{
|
|
if ( m_count >= m_listMax )
|
|
return false;
|
|
m_pList[m_count] = pFire;
|
|
m_count++;
|
|
return true;
|
|
}
|
|
|
|
IterationRetval_t CFireSphere::EnumElement( IHandleEntity *pHandleEntity )
|
|
{
|
|
CBaseEntity *pEntity = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() );
|
|
if ( pEntity )
|
|
{
|
|
// UNDONE: Measure which of these is faster
|
|
// CFire *pFire = dynamic_cast<CFire *>(pEntity);
|
|
if ( !FClassnameIs( pEntity, "env_fire" ) )
|
|
return ITERATION_CONTINUE;
|
|
|
|
CFire *pFire = static_cast<CFire *>(pEntity);
|
|
if ( pFire )
|
|
{
|
|
if ( !m_onlyActiveFires || pFire->IsBurning() )
|
|
{
|
|
if ( (m_origin - pFire->GetAbsOrigin()).LengthSqr() < m_radiusSqr )
|
|
{
|
|
if ( !AddToList( pFire ) )
|
|
return ITERATION_STOP;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ITERATION_CONTINUE;
|
|
}
|
|
|
|
|
|
int FireSystem_GetFiresInSphere( CFire **pList, int listMax, bool onlyActiveFires, const Vector &origin, float radius )
|
|
{
|
|
CFireSphere sphereEnum( pList, listMax, onlyActiveFires, origin, radius );
|
|
partition->EnumerateElementsInSphere( PARTITION_ENGINE_NON_STATIC_EDICTS, origin, radius, false, &sphereEnum );
|
|
|
|
return sphereEnum.GetCount();
|
|
}
|
|
|
|
|
|
bool FireSystem_IsValidFirePosition( const Vector &position, float testRadius )
|
|
{
|
|
CFire *pList[1];
|
|
int count = FireSystem_GetFiresInSphere( pList, ARRAYSIZE(pList), true, position, testRadius );
|
|
if ( count > 0 )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
bool FireSystem_IsFireInWall( Vector &position, fireType_e type )
|
|
{
|
|
// Don't check natural fire against walls
|
|
if (type == FIRE_NATURAL)
|
|
return false;
|
|
|
|
trace_t tr;
|
|
UTIL_TraceHull( position, position+Vector(0,0,0.1), FIRE_MINS,FIRE_MAXS,MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
|
|
if (tr.fraction != 1.0 || tr.startsolid)
|
|
{
|
|
//NDebugOverlay::Box(position,FIRE_MINS,FIRE_MAXS,255,0,0,50,10);
|
|
return true;
|
|
}
|
|
//NDebugOverlay::Box(position,FIRE_MINS,FIRE_MAXS,0,255,0,50,10);
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines whether or not a new fire may be placed at a given location
|
|
// Input : &position - where we are trying to put the new fire
|
|
// separationRadius - the maximum distance fires must be apart from one another
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool FireSystem_CanAddFire( Vector *position, float separationRadius, fireType_e type, int flags )
|
|
{
|
|
//See if we found a fire inside the sphere
|
|
if ( !FireSystem_IsValidFirePosition( *position, separationRadius ) )
|
|
return false;
|
|
|
|
// Unless our fire is floating, make sure were not too high
|
|
if (!(flags & SF_FIRE_DONT_DROP))
|
|
{
|
|
trace_t tr;
|
|
Vector startpos = *position;
|
|
Vector endpos = *position;
|
|
|
|
startpos[2] += 1;
|
|
endpos[2] -= FIRE_MAX_GROUND_OFFSET;
|
|
|
|
UTIL_TraceLine( startpos, endpos, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
|
|
|
|
//See if we're floating too high
|
|
if ( ( tr.allsolid ) || ( tr.startsolid) || ( tr.fraction == 1.0f ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//TODO: If we've hit an entity here, start it on fire
|
|
CBaseEntity *pEntity = tr.m_pEnt;
|
|
|
|
if ( ENTINDEX( pEntity->edict() ) != 0 )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Check if fire is in a wall, if so try shifting around a bit
|
|
if (FireSystem_IsFireInWall( *position, type ))
|
|
{
|
|
Vector vTestPos = *position;
|
|
vTestPos.x += 10;
|
|
if (FireSystem_IsValidFirePosition( vTestPos, separationRadius ) && !FireSystem_IsFireInWall( vTestPos, type ))
|
|
{
|
|
*position = vTestPos;
|
|
return true;
|
|
}
|
|
vTestPos.y += 10;
|
|
if (FireSystem_IsValidFirePosition( vTestPos, separationRadius ) && !FireSystem_IsFireInWall( vTestPos, type ))
|
|
{
|
|
*position = vTestPos;
|
|
return true;
|
|
}
|
|
vTestPos.y -= 20;
|
|
if (FireSystem_IsValidFirePosition( vTestPos, separationRadius ) && !FireSystem_IsFireInWall( vTestPos, type ))
|
|
{
|
|
*position = vTestPos;
|
|
return true;
|
|
}
|
|
vTestPos.x -= 20;
|
|
if (FireSystem_IsValidFirePosition( vTestPos, separationRadius ) && !FireSystem_IsFireInWall( vTestPos, type ))
|
|
{
|
|
*position = vTestPos;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//Able to add here
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Starts a fire at a specified location
|
|
// Input : &position - position to start the fire at
|
|
// flags - any special modifiers
|
|
//-----------------------------------------------------------------------------
|
|
bool FireSystem_StartFire( const Vector &position, float fireHeight, float attack, float fuel, int flags, CBaseEntity *owner, fireType_e type )
|
|
{
|
|
VPROF_FIRE( "FireSystem_StartFire1" );
|
|
|
|
Vector testPos = position;
|
|
//Must be okay to add fire here
|
|
if ( FireSystem_CanAddFire( &testPos, 16.0f, type, flags ) == false )
|
|
{
|
|
CFire *pFires[16];
|
|
int fireCount = FireSystem_GetFiresInSphere( pFires, ARRAYSIZE(pFires), true, position, 16.0f );
|
|
for ( int i = 0; i < fireCount; i++ )
|
|
{
|
|
// add to this fire
|
|
pFires[i]->AddHeat( fireHeight, false );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//Create a new fire entity
|
|
CFire *fire = (CFire *) CreateEntityByName( "env_fire" );
|
|
|
|
if ( fire == NULL )
|
|
return false;
|
|
|
|
//Spawn the fire
|
|
// Fires not placed by a designer should be cleaned up automatically (not catch fire again)
|
|
fire->AddSpawnFlags( SF_FIRE_DIE_PERMANENT );
|
|
fire->Spawn();
|
|
fire->Init( testPos, fireHeight, attack, fuel, flags, type );
|
|
fire->Start();
|
|
fire->SetOwner( owner );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Starts a fire on a specified model.
|
|
// Input : pEntity - The model entity to catch on fire.
|
|
// fireHeight -
|
|
// attack -
|
|
// fuel -
|
|
// flags -
|
|
// owner -
|
|
// type -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool FireSystem_StartFire( CBaseAnimating *pEntity, float fireHeight, float attack, float fuel, int flags, CBaseEntity *owner, fireType_e type )
|
|
{
|
|
VPROF_FIRE( "FireSystem_StartFire2" );
|
|
|
|
Vector position = pEntity->GetAbsOrigin();
|
|
Vector testPos = position;
|
|
|
|
// Make sure its a valid position for fire (not in a wall, etc)
|
|
if ( FireSystem_CanAddFire( &testPos, 16.0f, type, flags ) == false )
|
|
{
|
|
// Contribute heat to all fires within 16 units of this fire.
|
|
CFire *pFires[16];
|
|
int fireCount = FireSystem_GetFiresInSphere( pFires, ARRAYSIZE(pFires), true, position, 16.0f );
|
|
for ( int i = 0; i < fireCount; i++ )
|
|
{
|
|
pFires[i]->AddHeat( fireHeight, false );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Create a new fire entity
|
|
CFire *fire = (CFire *) CreateEntityByName( "env_fire" );
|
|
if ( fire == NULL )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Spawn the fire.
|
|
// Fires not placed by a designer should be cleaned up automatically (not catch fire again).
|
|
fire->AddSpawnFlags( SF_FIRE_DIE_PERMANENT );
|
|
fire->Spawn();
|
|
fire->Init( testPos, fireHeight, attack, fuel, flags, type );
|
|
fire->Start();
|
|
fire->SetOwner( owner );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void FireSystem_ExtinguishInRadius( const Vector &origin, float radius, float rate )
|
|
{
|
|
// UNDONE: pass this instead of percent
|
|
float heat = (1-rate) * fire_extscale.GetFloat();
|
|
|
|
CFire *pFires[32];
|
|
int fireCount = FireSystem_GetFiresInSphere( pFires, ARRAYSIZE(pFires), false, origin, radius );
|
|
for ( int i = 0; i < fireCount; i++ )
|
|
{
|
|
pFires[i]->Extinguish( heat );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &origin -
|
|
// radius -
|
|
// heat -
|
|
//-----------------------------------------------------------------------------
|
|
void FireSystem_AddHeatInRadius( const Vector &origin, float radius, float heat )
|
|
{
|
|
VPROF_FIRE( "FireSystem_AddHeatInRadius" );
|
|
|
|
CFire *pFires[32];
|
|
|
|
int fireCount = FireSystem_GetFiresInSphere( pFires, ARRAYSIZE(pFires), false, origin, radius );
|
|
for ( int i = 0; i < fireCount; i++ )
|
|
{
|
|
pFires[i]->AddHeat( heat );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool FireSystem_GetFireDamageDimensions( CBaseEntity *pEntity, Vector *pFireMins, Vector *pFireMaxs )
|
|
{
|
|
CFire *pFire = dynamic_cast<CFire *>(pEntity);
|
|
|
|
if ( pFire && pFire->GetFireDimensions( pFireMins, pFireMaxs ) )
|
|
{
|
|
*pFireMins /= FIRE_SPREAD_DAMAGE_MULTIPLIER;
|
|
*pFireMaxs /= FIRE_SPREAD_DAMAGE_MULTIPLIER;
|
|
return true;
|
|
}
|
|
pFireMins->Init();
|
|
pFireMaxs->Init();
|
|
return false;
|
|
}
|
|
|
|
|
|
//==================================================
|
|
// CFire
|
|
//==================================================
|
|
BEGIN_DATADESC( CFire )
|
|
|
|
DEFINE_FIELD( m_hEffect, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_hOwner, FIELD_EHANDLE ),
|
|
DEFINE_KEYFIELD( m_nFireType, FIELD_INTEGER, "firetype" ),
|
|
|
|
DEFINE_FIELD( m_flFuel, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_flDamageTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_lastDamage, FIELD_TIME ),
|
|
DEFINE_KEYFIELD( m_flFireSize, FIELD_FLOAT, "firesize" ),
|
|
|
|
DEFINE_KEYFIELD( m_flHeatLevel, FIELD_FLOAT, "ignitionpoint" ),
|
|
DEFINE_FIELD( m_flHeatAbsorb, FIELD_FLOAT ),
|
|
DEFINE_KEYFIELD( m_flDamageScale,FIELD_FLOAT, "damagescale" ),
|
|
|
|
DEFINE_FIELD( m_flMaxHeat, FIELD_FLOAT ),
|
|
//DEFINE_FIELD( m_flLastHeatLevel, FIELD_FLOAT ),
|
|
|
|
DEFINE_KEYFIELD( m_flAttackTime, FIELD_FLOAT, "fireattack" ),
|
|
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
|
|
DEFINE_KEYFIELD( m_bStartDisabled, FIELD_BOOLEAN, "StartDisabled" ),
|
|
DEFINE_FIELD( m_bDidActivate, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FUNCTION( BurnThink ),
|
|
DEFINE_FUNCTION( GoOutThink ),
|
|
|
|
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "StartFire", InputStartFire ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "Extinguish", InputExtinguish ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "ExtinguishTemporary", InputExtinguishTemporary ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
|
|
|
|
DEFINE_OUTPUT( m_OnIgnited, "OnIgnited" ),
|
|
DEFINE_OUTPUT( m_OnExtinguished, "OnExtinguished" ),
|
|
|
|
END_DATADESC()
|
|
|
|
LINK_ENTITY_TO_CLASS( env_fire, CFire );
|
|
|
|
//==================================================
|
|
// CFire
|
|
//==================================================
|
|
|
|
CFire::CFire( void )
|
|
{
|
|
m_flFuel = 0.0f;
|
|
m_flAttackTime = 0.0f;
|
|
m_flDamageTime = 0.0f;
|
|
m_lastDamage = 0;
|
|
m_nFireType = FIRE_NATURAL;
|
|
|
|
//Spreading
|
|
m_flHeatAbsorb = 8.0f;
|
|
m_flHeatLevel = 0;
|
|
|
|
// Must be in the constructor!
|
|
AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// UpdateOnRemove
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::UpdateOnRemove( void )
|
|
{
|
|
//Stop any looping sounds that might be playing
|
|
StopSound( "Fire.Plasma" );
|
|
|
|
DestroyEffect();
|
|
|
|
// Chain at end to mimic destructor unwind order
|
|
BaseClass::UpdateOnRemove();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::Precache( void )
|
|
{
|
|
if ( m_nFireType == FIRE_NATURAL )
|
|
{
|
|
UTIL_PrecacheOther("_firesmoke");
|
|
|
|
if ( m_spawnflags & SF_FIRE_SMOKELESS )
|
|
{
|
|
PrecacheParticleSystem( "env_fire_tiny" );
|
|
PrecacheParticleSystem( "env_fire_small" );
|
|
PrecacheParticleSystem( "env_fire_medium" );
|
|
PrecacheParticleSystem( "env_fire_large" );
|
|
}
|
|
else
|
|
{
|
|
PrecacheParticleSystem( "env_fire_tiny_smoke" );
|
|
PrecacheParticleSystem( "env_fire_small_smoke" );
|
|
PrecacheParticleSystem( "env_fire_medium_smoke" );
|
|
PrecacheParticleSystem( "env_fire_large_smoke" );
|
|
}
|
|
}
|
|
|
|
if ( m_nFireType == FIRE_PLASMA )
|
|
{
|
|
UTIL_PrecacheOther("_plasma");
|
|
}
|
|
|
|
PrecacheScriptSound( "Fire.Plasma" );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Input handler for starting the fire.
|
|
//------------------------------------------------------------------------------
|
|
void CFire::InputStartFire( inputdata_t &inputdata )
|
|
{
|
|
if ( !m_bEnabled )
|
|
return;
|
|
|
|
StartFire();
|
|
}
|
|
|
|
void CFire::InputEnable( inputdata_t &inputdata )
|
|
{
|
|
m_bEnabled = true;
|
|
}
|
|
|
|
void CFire::InputDisable( inputdata_t &inputdata )
|
|
{
|
|
Disable();
|
|
}
|
|
|
|
void CFire::Disable()
|
|
{
|
|
m_bEnabled = false;
|
|
if ( IsBurning() )
|
|
{
|
|
GoOut();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &inputdata -
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::InputExtinguish( inputdata_t &inputdata )
|
|
{
|
|
m_spawnflags &= ~SF_FIRE_INFINITE;
|
|
GoOutInSeconds( inputdata.value.Float() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &inputdata -
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::InputExtinguishTemporary( inputdata_t &inputdata )
|
|
{
|
|
GoOutInSeconds( inputdata.value.Float() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Starts burning.
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::StartFire( void )
|
|
{
|
|
if ( m_hEffect != NULL )
|
|
return;
|
|
|
|
// Trace down and start a fire there. Nothing fancy yet.
|
|
Vector vFirePos;
|
|
trace_t tr;
|
|
if ( m_spawnflags & SF_FIRE_DONT_DROP )
|
|
{
|
|
vFirePos = GetAbsOrigin();
|
|
}
|
|
else
|
|
{
|
|
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 1024 ), MASK_FIRE_SOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
vFirePos = tr.endpos;
|
|
}
|
|
|
|
int spawnflags = m_spawnflags;
|
|
m_spawnflags |= SF_FIRE_START_ON;
|
|
Init( vFirePos, m_flFireSize, m_flAttackTime, GetHealth(), m_spawnflags, (fireType_e) m_nFireType );
|
|
Start();
|
|
m_spawnflags = spawnflags;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::Spawn( void )
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
Precache();
|
|
|
|
m_takedamage = DAMAGE_NO;
|
|
|
|
SetSolid( SOLID_NONE );
|
|
AddEffects( EF_NODRAW );
|
|
SetToOutSize();
|
|
|
|
// set up the ignition point
|
|
m_flHeatAbsorb = m_flHeatLevel * 0.05;
|
|
m_flHeatLevel = 0;
|
|
Init( GetAbsOrigin(), m_flFireSize, m_flAttackTime, m_flFuel, m_spawnflags, m_nFireType );
|
|
|
|
if( m_bStartDisabled )
|
|
{
|
|
Disable();
|
|
}
|
|
else
|
|
{
|
|
m_bEnabled = true;
|
|
}
|
|
}
|
|
|
|
int CFire::UpdateTransmitState()
|
|
{
|
|
// Don't want to be FL_EDICT_DONTSEND because our fire entity may make us transmit.
|
|
return SetTransmitState( FL_EDICT_ALWAYS );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::Activate( void )
|
|
{
|
|
BaseClass::Activate();
|
|
|
|
//See if we should start active
|
|
if ( !m_bDidActivate && ( m_spawnflags & SF_FIRE_START_ON ) )
|
|
{
|
|
m_flHeatLevel = m_flMaxHeat;
|
|
|
|
StartFire();
|
|
}
|
|
|
|
m_bDidActivate = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::SpawnEffect( fireType_e type, float scale )
|
|
{
|
|
CBaseFire *pEffect = NULL;
|
|
switch ( type )
|
|
{
|
|
default:
|
|
case FIRE_NATURAL:
|
|
{
|
|
CFireSmoke *fireSmoke = (CFireSmoke *) CreateEntityByName( "_firesmoke" );
|
|
fireSmoke->EnableSmoke( ( m_spawnflags & SF_FIRE_SMOKELESS )==false );
|
|
fireSmoke->EnableGlow( ( m_spawnflags & SF_FIRE_NO_GLOW )==false );
|
|
fireSmoke->EnableVisibleFromAbove( ( m_spawnflags & SF_FIRE_VISIBLE_FROM_ABOVE )!=false );
|
|
|
|
pEffect = fireSmoke;
|
|
m_nFireType = FIRE_NATURAL;
|
|
m_takedamage = DAMAGE_YES;
|
|
}
|
|
break;
|
|
|
|
case FIRE_PLASMA:
|
|
{
|
|
CPlasma *plasma = (CPlasma *) CreateEntityByName( "_plasma" );
|
|
plasma->EnableSmoke( true );
|
|
|
|
pEffect = plasma;
|
|
m_nFireType = FIRE_PLASMA;
|
|
m_takedamage = DAMAGE_YES;
|
|
|
|
// Start burn sound
|
|
EmitSound( "Fire.Plasma" );
|
|
}
|
|
break;
|
|
}
|
|
|
|
UTIL_SetOrigin( pEffect, GetAbsOrigin() );
|
|
pEffect->Spawn();
|
|
pEffect->SetParent( this );
|
|
pEffect->Scale( m_flFireSize, m_flFireSize, 0 );
|
|
//Start it going
|
|
pEffect->Enable( ( m_spawnflags & SF_FIRE_START_ON ) );
|
|
m_hEffect = pEffect;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Spawn and initialize the fire
|
|
// Input : &position - where the fire resides
|
|
// lifetime -
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::Init( const Vector &position, float scale, float attackTime, float fuel, int flags, int fireType )
|
|
{
|
|
m_flAttackTime = attackTime;
|
|
|
|
m_spawnflags = flags;
|
|
m_nFireType = fireType;
|
|
|
|
if ( flags & SF_FIRE_INFINITE )
|
|
{
|
|
fuel = 0;
|
|
}
|
|
m_flFuel = fuel;
|
|
if ( m_flFuel )
|
|
{
|
|
m_spawnflags |= SF_FIRE_DIE_PERMANENT;
|
|
}
|
|
|
|
Vector localOrigin = position;
|
|
if ( GetMoveParent() )
|
|
{
|
|
EntityMatrix parentMatrix;
|
|
parentMatrix.InitFromEntity( GetMoveParent() );
|
|
localOrigin = parentMatrix.WorldToLocal( position );
|
|
}
|
|
UTIL_SetOrigin( this, localOrigin );
|
|
|
|
SetSolid( SOLID_NONE );
|
|
m_flFireSize = scale;
|
|
m_flMaxHeat = FIRE_MAX_HEAT_LEVEL * FIRE_SCALE_FROM_SIZE(scale);
|
|
//See if we should start on
|
|
if ( m_spawnflags & SF_FIRE_START_FULL )
|
|
{
|
|
m_flHeatLevel = m_flMaxHeat;
|
|
}
|
|
m_flLastHeatLevel = 0;
|
|
|
|
}
|
|
|
|
void CFire::Start()
|
|
{
|
|
float boxWidth = (m_flFireSize * (FIRE_WIDTH/FIRE_HEIGHT))*0.5f;
|
|
UTIL_SetSize(this, Vector(-boxWidth,-boxWidth,0),Vector(boxWidth,boxWidth,m_flFireSize));
|
|
|
|
//Spawn the client-side effect
|
|
SpawnEffect( (fireType_e)m_nFireType, FIRE_SCALE_FROM_SIZE(m_flFireSize) );
|
|
m_OnIgnited.FireOutput( this, this );
|
|
SetThink( &CFire::BurnThink );
|
|
m_flDamageTime = 0;
|
|
// think right now
|
|
BurnThink();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines whether or not the fire is still active
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CFire::IsBurning( void ) const
|
|
{
|
|
if ( m_flHeatLevel > 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the damage box of the fire
|
|
//-----------------------------------------------------------------------------
|
|
bool CFire::GetFireDimensions( Vector *pFireMins, Vector *pFireMaxs )
|
|
{
|
|
if ( m_flHeatLevel <= 0 )
|
|
{
|
|
pFireMins->Init();
|
|
pFireMaxs->Init();
|
|
return false;
|
|
}
|
|
|
|
float scale = m_flHeatLevel / m_flMaxHeat;
|
|
float damageRadius = scale * m_flFireSize * FIRE_WIDTH / FIRE_HEIGHT * 0.5;
|
|
|
|
damageRadius *= FIRE_SPREAD_DAMAGE_MULTIPLIER; //FIXME: Trying slightly larger radius for burning
|
|
|
|
if ( damageRadius < 16 )
|
|
{
|
|
damageRadius = 16;
|
|
}
|
|
|
|
pFireMins->Init(-damageRadius,-damageRadius,0);
|
|
pFireMaxs->Init(damageRadius,damageRadius,m_flFireSize*scale);
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Update the fire and its children
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::Update( float simTime )
|
|
{
|
|
VPROF_FIRE( "CFire::Update" );
|
|
|
|
if ( m_flFuel != 0 )
|
|
{
|
|
m_flFuel -= simTime;
|
|
if ( m_flFuel <= 0 )
|
|
{
|
|
GoOutInSeconds( 1 );
|
|
return;
|
|
}
|
|
}
|
|
|
|
float strength = m_flHeatLevel / FIRE_MAX_HEAT_LEVEL;
|
|
if ( m_flHeatLevel != m_flLastHeatLevel )
|
|
{
|
|
m_flLastHeatLevel = m_flHeatLevel;
|
|
// Make the effect the appropriate size given the heat level
|
|
m_hEffect->Scale( strength, 0.5f );
|
|
}
|
|
// add heat to myself (grow)
|
|
float addedHeat = (m_flAttackTime > 0) ? m_flMaxHeat / m_flAttackTime : m_flMaxHeat;
|
|
addedHeat *= simTime * fire_growthrate.GetFloat();
|
|
AddHeat( addedHeat, true );
|
|
|
|
// add heat to nearby fires
|
|
float outputHeat = strength * m_flHeatLevel;
|
|
|
|
Vector fireMins;
|
|
Vector fireMaxs;
|
|
Vector fireEntityDamageMins;
|
|
Vector fireEntityDamageMaxs;
|
|
|
|
GetFireDimensions( &fireMins, &fireMaxs );
|
|
|
|
if ( FIRE_SPREAD_DAMAGE_MULTIPLIER != 1.0 ) // if set to 1.0, optimizer will remove this code
|
|
{
|
|
fireEntityDamageMins = fireMins / FIRE_SPREAD_DAMAGE_MULTIPLIER;
|
|
fireEntityDamageMaxs = fireMaxs / FIRE_SPREAD_DAMAGE_MULTIPLIER;
|
|
}
|
|
|
|
//NDebugOverlay::Box( GetAbsOrigin(), fireMins, fireMaxs, 255, 255, 255, 0, fire_dmginterval.GetFloat() );
|
|
fireMins += GetAbsOrigin();
|
|
fireMaxs += GetAbsOrigin();
|
|
|
|
if ( FIRE_SPREAD_DAMAGE_MULTIPLIER != 1.0 )
|
|
{
|
|
fireEntityDamageMins += GetAbsOrigin();
|
|
fireEntityDamageMaxs += GetAbsOrigin();
|
|
}
|
|
|
|
CBaseEntity *pNearby[256];
|
|
CFire *pFires[16];
|
|
int nearbyCount = UTIL_EntitiesInBox( pNearby, ARRAYSIZE(pNearby), fireMins, fireMaxs, 0 );
|
|
int fireCount = 0;
|
|
int i;
|
|
|
|
// is it time to do damage?
|
|
bool damage = false;
|
|
int outputDamage = 0;
|
|
if ( m_flDamageTime <= gpGlobals->curtime )
|
|
{
|
|
m_flDamageTime = gpGlobals->curtime + fire_dmginterval.GetFloat();
|
|
outputDamage = (fire_dmgbase.GetFloat() + outputHeat * fire_dmgscale.GetFloat() * m_flDamageScale) * fire_dmginterval.GetFloat();
|
|
if ( outputDamage )
|
|
{
|
|
damage = true;
|
|
}
|
|
}
|
|
int damageFlags = (m_nFireType == FIRE_NATURAL) ? DMG_BURN : DMG_PLASMA;
|
|
for ( i = 0; i < nearbyCount; i++ )
|
|
{
|
|
CBaseEntity *pOther = pNearby[i];
|
|
|
|
if ( pOther == this )
|
|
{
|
|
continue;
|
|
}
|
|
else if ( FClassnameIs( pOther, "env_fire" ) )
|
|
{
|
|
if ( fireCount < ARRAYSIZE(pFires) )
|
|
{
|
|
pFires[fireCount] = (CFire *)pOther;
|
|
fireCount++;
|
|
}
|
|
continue;
|
|
}
|
|
else if ( pOther->m_takedamage == DAMAGE_NO )
|
|
{
|
|
pNearby[i] = NULL;
|
|
}
|
|
else if ( damage )
|
|
{
|
|
bool bDoDamage;
|
|
|
|
if ( FIRE_SPREAD_DAMAGE_MULTIPLIER != 1.0 && !pOther->IsPlayer() ) // if set to 1.0, optimizer will remove this code
|
|
{
|
|
Vector otherMins, otherMaxs;
|
|
pOther->CollisionProp()->WorldSpaceAABB( &otherMins, &otherMaxs );
|
|
bDoDamage = IsBoxIntersectingBox( otherMins, otherMaxs,
|
|
fireEntityDamageMins, fireEntityDamageMaxs );
|
|
|
|
}
|
|
else
|
|
bDoDamage = true;
|
|
|
|
if ( bDoDamage )
|
|
{
|
|
// Make sure can actually see entity (don't damage through walls)
|
|
trace_t tr;
|
|
UTIL_TraceLine( this->WorldSpaceCenter(), pOther->WorldSpaceCenter(), MASK_FIRE_SOLID, pOther, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if (tr.fraction == 1.0 && !tr.startsolid)
|
|
{
|
|
pOther->TakeDamage( CTakeDamageInfo( this, this, outputDamage, damageFlags ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
outputHeat *= fire_heatscale.GetFloat() * simTime;
|
|
|
|
if ( fireCount > 0 )
|
|
{
|
|
outputHeat /= fireCount;
|
|
for ( i = 0; i < fireCount; i++ )
|
|
{
|
|
pFires[i]->AddHeat( outputHeat, false );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Destroy any effect I have
|
|
void CFire::DestroyEffect()
|
|
{
|
|
CBaseFire *pEffect = m_hEffect;
|
|
if ( pEffect != NULL )
|
|
{
|
|
//disable the graphics and remove the entity
|
|
pEffect->Enable( false );
|
|
UTIL_Remove( pEffect );
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Think
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::BurnThink( void )
|
|
{
|
|
SetNextThink( gpGlobals->curtime + FIRE_THINK_INTERVAL );
|
|
|
|
Update( FIRE_THINK_INTERVAL );
|
|
}
|
|
|
|
void CFire::GoOutThink()
|
|
{
|
|
GoOut();
|
|
}
|
|
|
|
void CFire::GoOutInSeconds( float seconds )
|
|
{
|
|
Scale( 0.0f, seconds );
|
|
|
|
SetThink( &CFire::GoOutThink );
|
|
SetNextThink( gpGlobals->curtime + seconds );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose : Blasts of significant size blow out fires that take damage
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
int CFire::OnTakeDamage( const CTakeDamageInfo &info )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void CFire::AddHeat( float heat, bool selfHeat )
|
|
{
|
|
if ( m_bEnabled )
|
|
{
|
|
if ( !selfHeat )
|
|
{
|
|
if ( IsBurning() )
|
|
{
|
|
// scale back the incoming heat from surrounding fires
|
|
// if I've already ignited
|
|
heat *= fire_incomingheatscale.GetFloat();
|
|
}
|
|
}
|
|
m_lastDamage = gpGlobals->curtime + 0.5;
|
|
bool start = m_flHeatLevel <= 0 ? true : false;
|
|
if ( m_flHeatAbsorb > 0 )
|
|
{
|
|
float absorbDamage = heat * fire_absorbrate.GetFloat();
|
|
if ( absorbDamage > m_flHeatAbsorb )
|
|
{
|
|
heat -= m_flHeatAbsorb / fire_absorbrate.GetFloat();
|
|
m_flHeatAbsorb = 0;
|
|
}
|
|
else
|
|
{
|
|
m_flHeatAbsorb -= absorbDamage;
|
|
heat = 0;
|
|
}
|
|
}
|
|
|
|
m_flHeatLevel += heat;
|
|
if ( start && m_flHeatLevel > 0 && m_hEffect == NULL )
|
|
{
|
|
StartFire();
|
|
}
|
|
if ( m_flHeatLevel > m_flMaxHeat )
|
|
m_flHeatLevel = m_flMaxHeat;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : end -
|
|
// time -
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::Scale( float end, float time )
|
|
{
|
|
CBaseFire *pEffect = m_hEffect;
|
|
if ( pEffect )
|
|
{
|
|
pEffect->Scale( end, time );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : time -
|
|
//-----------------------------------------------------------------------------
|
|
void CFire::Extinguish( float heat )
|
|
{
|
|
if ( !m_bEnabled )
|
|
return;
|
|
|
|
m_lastDamage = gpGlobals->curtime + 0.5;
|
|
bool out = m_flHeatLevel > 0 ? true : false;
|
|
|
|
m_flHeatLevel -= heat;
|
|
m_flHeatAbsorb += fire_extabsorb.GetFloat() * heat;
|
|
if ( m_flHeatAbsorb > fire_maxabsorb.GetFloat() )
|
|
{
|
|
m_flHeatAbsorb = fire_maxabsorb.GetFloat();
|
|
}
|
|
|
|
// drift toward the average attack time after being sprayed
|
|
// some fires are heavily scripted so their attack looks weird
|
|
// once interacted with. Basically, this blends out the scripting
|
|
// as the fire is sprayed with the extinguisher.
|
|
float averageAttackTime = m_flMaxHeat * (FIRE_NORMAL_ATTACK_TIME/FIRE_MAX_HEAT_LEVEL);
|
|
m_flAttackTime = Approach( averageAttackTime, m_flAttackTime, 2 * gpGlobals->frametime );
|
|
|
|
if ( m_flHeatLevel <= 0 )
|
|
{
|
|
m_flHeatLevel = 0;
|
|
if ( out )
|
|
{
|
|
GoOut();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CFire::GoOut()
|
|
{
|
|
//Signal death
|
|
m_OnExtinguished.FireOutput( this, this );
|
|
|
|
DestroyEffect();
|
|
m_flHeatLevel -= 20;
|
|
if ( m_flHeatLevel > 0 )
|
|
m_flHeatLevel = 0;
|
|
|
|
m_flLastHeatLevel = m_flHeatLevel;
|
|
SetThink(NULL);
|
|
SetNextThink( TICK_NEVER_THINK );
|
|
if ( m_spawnflags & SF_FIRE_DIE_PERMANENT )
|
|
{
|
|
UTIL_Remove( this );
|
|
return true;
|
|
}
|
|
SetToOutSize();
|
|
|
|
return false;
|
|
}
|
|
|
|
//==================================================
|
|
// CEnvFireSource is a source of heat that the player
|
|
// cannot put out
|
|
//==================================================
|
|
|
|
#define FIRESOURCE_THINK_TIME 0.25 // seconds to
|
|
|
|
#define SF_FIRESOURCE_START_ON 0x0001
|
|
|
|
class CEnvFireSource : public CBaseEntity
|
|
{
|
|
DECLARE_CLASS( CEnvFireSource, CBaseEntity );
|
|
public:
|
|
void Spawn();
|
|
void Think();
|
|
void TurnOn();
|
|
void TurnOff();
|
|
void InputEnable( inputdata_t &inputdata );
|
|
void InputDisable( inputdata_t &inputdata );
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
private:
|
|
bool m_bEnabled;
|
|
float m_radius;
|
|
float m_damage;
|
|
};
|
|
|
|
BEGIN_DATADESC( CEnvFireSource )
|
|
|
|
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
|
|
DEFINE_KEYFIELD( m_radius, FIELD_FLOAT, "fireradius" ),
|
|
DEFINE_KEYFIELD( m_damage,FIELD_FLOAT, "firedamage" ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
|
|
|
|
|
|
END_DATADESC()
|
|
|
|
LINK_ENTITY_TO_CLASS( env_firesource, CEnvFireSource );
|
|
|
|
void CEnvFireSource::Spawn()
|
|
{
|
|
if ( m_spawnflags & SF_FIRESOURCE_START_ON )
|
|
{
|
|
TurnOn();
|
|
}
|
|
else
|
|
{
|
|
TurnOff();
|
|
}
|
|
}
|
|
|
|
void CEnvFireSource::Think()
|
|
{
|
|
if ( !m_bEnabled )
|
|
return;
|
|
SetNextThink( gpGlobals->curtime + FIRESOURCE_THINK_TIME );
|
|
|
|
CFire *pFires[128];
|
|
int fireCount = FireSystem_GetFiresInSphere( pFires, ARRAYSIZE(pFires), false, GetAbsOrigin(), m_radius );
|
|
|
|
for ( int i = 0; i < fireCount; i++ )
|
|
{
|
|
pFires[i]->AddHeat( m_damage * FIRESOURCE_THINK_TIME );
|
|
}
|
|
}
|
|
|
|
void CEnvFireSource::TurnOn()
|
|
{
|
|
if ( m_bEnabled )
|
|
return;
|
|
|
|
m_bEnabled = true;
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
|
|
void CEnvFireSource::TurnOff()
|
|
{
|
|
if ( !m_bEnabled )
|
|
return;
|
|
|
|
m_bEnabled = false;
|
|
SetNextThink( TICK_NEVER_THINK );
|
|
}
|
|
void CEnvFireSource::InputEnable( inputdata_t &inputdata )
|
|
{
|
|
TurnOn();
|
|
}
|
|
void CEnvFireSource::InputDisable( inputdata_t &inputdata )
|
|
{
|
|
TurnOff();
|
|
}
|
|
|
|
//==================================================
|
|
// CEnvFireSensor detects changes in heat
|
|
//==================================================
|
|
#define SF_FIRESENSOR_START_ON 1
|
|
|
|
class CEnvFireSensor : public CBaseEntity
|
|
{
|
|
DECLARE_CLASS( CEnvFireSensor, CBaseEntity );
|
|
public:
|
|
void Spawn();
|
|
void Think();
|
|
void TurnOn();
|
|
void TurnOff();
|
|
void InputEnable( inputdata_t &inputdata );
|
|
void InputDisable( inputdata_t &inputdata );
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
private:
|
|
bool m_bEnabled;
|
|
bool m_bHeatAtLevel;
|
|
float m_radius;
|
|
float m_targetLevel;
|
|
float m_targetTime;
|
|
float m_levelTime;
|
|
|
|
COutputEvent m_OnHeatLevelStart;
|
|
COutputEvent m_OnHeatLevelEnd;
|
|
};
|
|
|
|
BEGIN_DATADESC( CEnvFireSensor )
|
|
|
|
DEFINE_KEYFIELD( m_radius, FIELD_FLOAT, "fireradius" ),
|
|
DEFINE_KEYFIELD( m_targetLevel, FIELD_FLOAT, "heatlevel" ),
|
|
DEFINE_KEYFIELD( m_targetTime, FIELD_FLOAT, "heattime" ),
|
|
|
|
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bHeatAtLevel, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_levelTime, FIELD_FLOAT ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
|
|
|
|
DEFINE_OUTPUT( m_OnHeatLevelStart, "OnHeatLevelStart"),
|
|
DEFINE_OUTPUT( m_OnHeatLevelEnd, "OnHeatLevelEnd"),
|
|
|
|
END_DATADESC()
|
|
|
|
LINK_ENTITY_TO_CLASS( env_firesensor, CEnvFireSensor );
|
|
|
|
void CEnvFireSensor::Spawn()
|
|
{
|
|
if ( m_spawnflags & SF_FIRESENSOR_START_ON )
|
|
{
|
|
TurnOn();
|
|
}
|
|
else
|
|
{
|
|
TurnOff();
|
|
}
|
|
}
|
|
|
|
void CEnvFireSensor::Think()
|
|
{
|
|
if ( !m_bEnabled )
|
|
return;
|
|
|
|
float time = m_targetTime * 0.25;
|
|
if ( time < 0.1 )
|
|
{
|
|
time = 0.1;
|
|
}
|
|
SetNextThink( gpGlobals->curtime + time );
|
|
|
|
float heat = 0;
|
|
CFire *pFires[128];
|
|
int fireCount = FireSystem_GetFiresInSphere( pFires, ARRAYSIZE(pFires), true, GetAbsOrigin(), m_radius );
|
|
for ( int i = 0; i < fireCount; i++ )
|
|
{
|
|
heat += pFires[i]->GetHeatLevel();
|
|
}
|
|
|
|
if ( heat >= m_targetLevel )
|
|
{
|
|
m_levelTime += time;
|
|
if ( m_levelTime >= m_targetTime )
|
|
{
|
|
if ( !m_bHeatAtLevel )
|
|
{
|
|
m_bHeatAtLevel = true;
|
|
m_OnHeatLevelStart.FireOutput( this, this );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_levelTime = 0;
|
|
if ( m_bHeatAtLevel )
|
|
{
|
|
m_bHeatAtLevel = false;
|
|
m_OnHeatLevelEnd.FireOutput( this, this );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CEnvFireSensor::TurnOn()
|
|
{
|
|
if ( m_bEnabled )
|
|
return;
|
|
|
|
m_bEnabled = true;
|
|
SetNextThink( gpGlobals->curtime );
|
|
m_bHeatAtLevel = false;
|
|
m_levelTime = 0;
|
|
}
|
|
|
|
void CEnvFireSensor::TurnOff()
|
|
{
|
|
if ( !m_bEnabled )
|
|
return;
|
|
|
|
m_bEnabled = false;
|
|
SetNextThink( TICK_NEVER_THINK );
|
|
if ( m_bHeatAtLevel )
|
|
{
|
|
m_bHeatAtLevel = false;
|
|
m_OnHeatLevelEnd.FireOutput( this, this );
|
|
}
|
|
|
|
}
|
|
void CEnvFireSensor::InputEnable( inputdata_t &inputdata )
|
|
{
|
|
TurnOn();
|
|
}
|
|
void CEnvFireSensor::InputDisable( inputdata_t &inputdata )
|
|
{
|
|
TurnOff();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw any debug text overlays
|
|
// Output : Current text offset from the top
|
|
//-----------------------------------------------------------------------------
|
|
int CFire::DrawDebugTextOverlays( void )
|
|
{
|
|
int text_offset = BaseClass::DrawDebugTextOverlays();
|
|
|
|
if (m_debugOverlays & OVERLAY_TEXT_BIT)
|
|
{
|
|
char tempstr[512];
|
|
|
|
// print flame size
|
|
Q_snprintf(tempstr,sizeof(tempstr)," size: %f", m_flFireSize);
|
|
EntityText(text_offset,tempstr,0);
|
|
text_offset++;
|
|
}
|
|
return text_offset;
|
|
}
|