H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c36cfccdf0
source-engine/game/server/effects.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

2380 lines
58 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements a grab bag of visual effects entities.
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "effects.h"
#include "gib.h"
#include "beam_shared.h"
#include "decals.h"
#include "func_break.h"
#include "EntityFlame.h"
#include "entitylist.h"
#include "basecombatweapon.h"
#include "model_types.h"
#include "player.h"
#include "physics.h"
#include "baseparticleentity.h"
#include "ndebugoverlay.h"
#include "IEffects.h"
#include "vstdlib/random.h"
#include "env_wind_shared.h"
#include "filesystem.h"
#include "engine/IEngineSound.h"
#include "fire.h"
#include "te_effect_dispatch.h"
#include "Sprite.h"
#include "precipitation_shared.h"
#include "shot_manipulator.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define SF_FUNNEL_REVERSE 1 // funnel effect repels particles instead of attracting them.
#define SF_GIBSHOOTER_REPEATABLE (1<<0) // allows a gibshooter to be refired
#define SF_SHOOTER_FLAMING (1<<1) // gib is on fire
#define SF_SHOOTER_STRICT_REMOVE (1<<2) // remove this gib even if it is in the player's view
// UNDONE: This should be client-side and not use TempEnts
class CBubbling : public CBaseEntity
{
public:
DECLARE_CLASS( CBubbling, CBaseEntity );
virtual void Spawn( void );
virtual void Precache( void );
void FizzThink( void );
// Input handlers.
void InputActivate( inputdata_t &inputdata );
void InputDeactivate( inputdata_t &inputdata );
void InputToggle( inputdata_t &inputdata );
void InputSetCurrent( inputdata_t &inputdata );
void InputSetDensity( inputdata_t &inputdata );
void InputSetFrequency( inputdata_t &inputdata );
DECLARE_DATADESC();
private:
void TurnOn();
void TurnOff();
void Toggle();
int m_density;
int m_frequency;
int m_bubbleModel;
int m_state;
};
LINK_ENTITY_TO_CLASS( env_bubbles, CBubbling );
BEGIN_DATADESC( CBubbling )
DEFINE_KEYFIELD( m_flSpeed, FIELD_FLOAT, "current" ),
DEFINE_KEYFIELD( m_density, FIELD_INTEGER, "density" ),
DEFINE_KEYFIELD( m_frequency, FIELD_INTEGER, "frequency" ),
DEFINE_FIELD( m_state, FIELD_INTEGER ),
// Let spawn restore this!
// DEFINE_FIELD( m_bubbleModel, FIELD_INTEGER ),
// Function Pointers
DEFINE_FUNCTION( FizzThink ),
DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ),
DEFINE_INPUTFUNC( FIELD_VOID, "Deactivate", InputDeactivate ),
DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetCurrent", InputSetCurrent ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetDensity", InputSetDensity ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetFrequency", InputSetFrequency ),
END_DATADESC()
#define SF_BUBBLES_STARTOFF 0x0001
void CBubbling::Spawn( void )
{
Precache( );
SetModel( STRING( GetModelName() ) ); // Set size
// Make it invisible to client
SetRenderColorA( 0 );
SetSolid( SOLID_NONE ); // Remove model & collisions
if ( !HasSpawnFlags(SF_BUBBLES_STARTOFF) )
{
SetThink( &CBubbling::FizzThink );
SetNextThink( gpGlobals->curtime + 2.0 );
m_state = 1;
}
else
{
m_state = 0;
}
}
void CBubbling::Precache( void )
{
m_bubbleModel = PrecacheModel("sprites/bubble.vmt"); // Precache bubble sprite
}
void CBubbling::Toggle()
{
if (!m_state)
{
TurnOn();
}
else
{
TurnOff();
}
}
void CBubbling::TurnOn()
{
m_state = 1;
SetThink( &CBubbling::FizzThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CBubbling::TurnOff()
{
m_state = 0;
SetThink( NULL );
SetNextThink( TICK_NEVER_THINK );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBubbling::InputActivate( inputdata_t &inputdata )
{
TurnOn();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBubbling::InputDeactivate( inputdata_t &inputdata )
{
TurnOff();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBubbling::InputToggle( inputdata_t &inputdata )
{
Toggle();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CBubbling::InputSetCurrent( inputdata_t &inputdata )
{
m_flSpeed = (float)inputdata.value.Int();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CBubbling::InputSetDensity( inputdata_t &inputdata )
{
m_density = inputdata.value.Int();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CBubbling::InputSetFrequency( inputdata_t &inputdata )
{
m_frequency = inputdata.value.Int();
// Reset think time
if ( m_state )
{
if ( m_frequency > 19 )
{
SetNextThink( gpGlobals->curtime + 0.5f );
}
else
{
SetNextThink( gpGlobals->curtime + 2.5 - (0.1 * m_frequency) );
}
}
}
void CBubbling::FizzThink( void )
{
Vector center = WorldSpaceCenter();
CPASFilter filter( center );
te->Fizz( filter, 0.0, this, m_bubbleModel, m_density, (int)m_flSpeed );
if ( m_frequency > 19 )
{
SetNextThink( gpGlobals->curtime + 0.5f );
}
else
{
SetNextThink( gpGlobals->curtime + 2.5 - (0.1 * m_frequency) );
}
}
// ENV_TRACER
// Fakes a tracer
class CEnvTracer : public CPointEntity
{
public:
DECLARE_CLASS( CEnvTracer, CPointEntity );
void Spawn( void );
void TracerThink( void );
void Activate( void );
DECLARE_DATADESC();
Vector m_vecEnd;
float m_flDelay;
};
LINK_ENTITY_TO_CLASS( env_tracer, CEnvTracer );
BEGIN_DATADESC( CEnvTracer )
DEFINE_KEYFIELD( m_flDelay, FIELD_FLOAT, "delay" ),
DEFINE_FIELD( m_vecEnd, FIELD_POSITION_VECTOR ),
// Function Pointers
DEFINE_FUNCTION( TracerThink ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose: Called after keyvalues are parsed.
//-----------------------------------------------------------------------------
void CEnvTracer::Spawn( void )
{
SetSolid( SOLID_NONE );
SetMoveType( MOVETYPE_NONE );
if (!m_flDelay)
m_flDelay = 1;
}
//-----------------------------------------------------------------------------
// Purpose: Called after all the entities have been loaded.
//-----------------------------------------------------------------------------
void CEnvTracer::Activate( void )
{
BaseClass::Activate();
CBaseEntity *pEnd = gEntList.FindEntityByName( NULL, m_target );
if (pEnd != NULL)
{
m_vecEnd = pEnd->GetLocalOrigin();
SetThink( &CEnvTracer::TracerThink );
SetNextThink( gpGlobals->curtime + m_flDelay );
}
else
{
Msg( "env_tracer: unknown entity \"%s\"\n", STRING(m_target) );
}
}
// Think
void CEnvTracer::TracerThink( void )
{
UTIL_Tracer( GetAbsOrigin(), m_vecEnd );
SetNextThink( gpGlobals->curtime + m_flDelay );
}
//#################################################################################
// >> CGibShooter
//#################################################################################
enum GibSimulation_t
{
GIB_SIMULATE_POINT,
GIB_SIMULATE_PHYSICS,
GIB_SIMULATE_RAGDOLL,
};
class CGibShooter : public CBaseEntity
{
public:
DECLARE_CLASS( CGibShooter, CBaseEntity );
void Spawn( void );
void Precache( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual CGib *CreateGib( void );
protected:
// Purpose:
CBaseEntity *SpawnGib( const Vector &vecShootDir, float flSpeed );
DECLARE_DATADESC();
private:
void InitPointGib( CGib *pGib, const Vector &vecShootDir, float flSpeed );
void ShootThink( void );
protected:
int m_iGibs;
int m_iGibCapacity;
int m_iGibMaterial;
int m_iGibModelIndex;
float m_flGibVelocity;
QAngle m_angGibRotation;
float m_flGibAngVelocity;
float m_flVariance;
float m_flGibLife;
int m_nSimulationType;
int m_nMaxGibModelFrame;
float m_flDelay;
bool m_bNoGibShadows;
bool m_bIsSprite;
string_t m_iszLightingOrigin;
// ----------------
// Inputs
// ----------------
void InputShoot( inputdata_t &inputdata );
};
BEGIN_DATADESC( CGibShooter )
DEFINE_KEYFIELD( m_iGibs, FIELD_INTEGER, "m_iGibs" ),
DEFINE_KEYFIELD( m_flGibVelocity, FIELD_FLOAT, "m_flVelocity" ),
DEFINE_KEYFIELD( m_flVariance, FIELD_FLOAT, "m_flVariance" ),
DEFINE_KEYFIELD( m_flGibLife, FIELD_FLOAT, "m_flGibLife" ),
DEFINE_KEYFIELD( m_nSimulationType, FIELD_INTEGER, "Simulation" ),
DEFINE_KEYFIELD( m_flDelay, FIELD_FLOAT, "delay" ),
DEFINE_KEYFIELD( m_angGibRotation, FIELD_VECTOR, "gibangles" ),
DEFINE_KEYFIELD( m_flGibAngVelocity, FIELD_FLOAT, "gibanglevelocity"),
DEFINE_FIELD( m_bIsSprite, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iGibCapacity, FIELD_INTEGER ),
DEFINE_FIELD( m_iGibMaterial, FIELD_INTEGER ),
DEFINE_FIELD( m_iGibModelIndex, FIELD_INTEGER ),
DEFINE_FIELD( m_nMaxGibModelFrame, FIELD_INTEGER ),
DEFINE_KEYFIELD( m_iszLightingOrigin, FIELD_STRING, "LightingOrigin" ),
DEFINE_KEYFIELD( m_bNoGibShadows, FIELD_BOOLEAN, "nogibshadows" ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Shoot", InputShoot ),
// Function Pointers
DEFINE_FUNCTION( ShootThink ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( gibshooter, CGibShooter );
void CGibShooter::Precache ( void )
{
if ( g_Language.GetInt() == LANGUAGE_GERMAN )
{
m_iGibModelIndex = PrecacheModel ("models/germanygibs.mdl");
}
else
{
m_iGibModelIndex = PrecacheModel ("models/gibs/hgibs.mdl");
}
}
void CGibShooter::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
SetThink( &CGibShooter::ShootThink );
SetNextThink( gpGlobals->curtime );
}
//-----------------------------------------------------------------------------
// Purpose: Input handler for shooting gibs.
//-----------------------------------------------------------------------------
void CGibShooter::InputShoot( inputdata_t &inputdata )
{
SetThink( &CGibShooter::ShootThink );
SetNextThink( gpGlobals->curtime );
}
void CGibShooter::Spawn( void )
{
Precache();
SetSolid( SOLID_NONE );
AddEffects( EF_NODRAW );
if ( m_flDelay < 0 )
{
m_flDelay = 0.0;
}
if ( m_flGibLife == 0 )
{
m_flGibLife = 25;
}
m_iGibCapacity = m_iGibs;
m_nMaxGibModelFrame = modelinfo->GetModelFrameCount( modelinfo->GetModel( m_iGibModelIndex ) );
}
CGib *CGibShooter::CreateGib ( void )
{
ConVarRef violence_hgibs( "violence_hgibs" );
if ( violence_hgibs.IsValid() && !violence_hgibs.GetInt() )
return NULL;
CGib *pGib = CREATE_ENTITY( CGib, "gib" );
pGib->Spawn( "models/gibs/hgibs.mdl" );
pGib->SetBloodColor( BLOOD_COLOR_RED );
if ( m_nMaxGibModelFrame <= 1 )
{
DevWarning( 2, "GibShooter Body is <= 1!\n" );
}
pGib->m_nBody = random->RandomInt ( 1, m_nMaxGibModelFrame - 1 );// avoid throwing random amounts of the 0th gib. (skull).
if ( m_iszLightingOrigin != NULL_STRING )
{
// Make the gibs use the lighting origin
pGib->SetLightingOrigin( m_iszLightingOrigin );
}
return pGib;
}
void CGibShooter::InitPointGib( CGib *pGib, const Vector &vecShootDir, float flSpeed )
{
if ( pGib )
{
pGib->SetLocalOrigin( GetAbsOrigin() );
pGib->SetAbsVelocity( vecShootDir * flSpeed );
QAngle angVel( random->RandomFloat ( 100, 200 ), random->RandomFloat ( 100, 300 ), 0 );
pGib->SetLocalAngularVelocity( angVel );
float thinkTime = ( pGib->GetNextThink() - gpGlobals->curtime );
pGib->m_lifeTime = (m_flGibLife * random->RandomFloat( 0.95, 1.05 )); // +/- 5%
// HL1 gibs always die after a certain time, other games have to opt-in
#ifndef HL1_DLL
if( HasSpawnFlags( SF_SHOOTER_STRICT_REMOVE ) )
#endif
{
pGib->SetNextThink( gpGlobals->curtime + pGib->m_lifeTime );
pGib->SetThink ( &CGib::DieThink );
}
if ( pGib->m_lifeTime < thinkTime )
{
pGib->SetNextThink( gpGlobals->curtime + pGib->m_lifeTime );
pGib->m_lifeTime = 0;
}
if ( m_bIsSprite == true )
{
pGib->SetSprite( CSprite::SpriteCreate( STRING( GetModelName() ), pGib->GetAbsOrigin(), false ) );
CSprite *pSprite = (CSprite*)pGib->GetSprite();
if ( pSprite )
{
pSprite->SetAttachment( pGib, 0 );
pSprite->SetOwnerEntity( pGib );
pSprite->SetScale( 1 );
pSprite->SetTransparency( m_nRenderMode, m_clrRender->r, m_clrRender->g, m_clrRender->b, m_clrRender->a, m_nRenderFX );
pSprite->AnimateForTime( 5, m_flGibLife + 1 ); //This framerate is totally wrong
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseEntity *CGibShooter::SpawnGib( const Vector &vecShootDir, float flSpeed )
{
switch (m_nSimulationType)
{
case GIB_SIMULATE_RAGDOLL:
{
// UNDONE: Assume a mass of 200 for now
Vector force = vecShootDir * flSpeed * 200;
return CreateRagGib( STRING( GetModelName() ), GetAbsOrigin(), GetAbsAngles(), force, m_flGibLife );
}
case GIB_SIMULATE_PHYSICS:
{
CGib *pGib = CreateGib();
if ( pGib )
{
pGib->SetAbsOrigin( GetAbsOrigin() );
pGib->SetAbsAngles( m_angGibRotation );
pGib->m_lifeTime = (m_flGibLife * random->RandomFloat( 0.95, 1.05 )); // +/- 5%
pGib->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
IPhysicsObject *pPhysicsObject = pGib->VPhysicsInitNormal( SOLID_VPHYSICS, pGib->GetSolidFlags(), false );
pGib->SetMoveType( MOVETYPE_VPHYSICS );
if ( pPhysicsObject )
{
// Set gib velocity
Vector vVel = vecShootDir * flSpeed;
pPhysicsObject->AddVelocity(&vVel, NULL);
AngularImpulse torque;
torque.x = m_flGibAngVelocity * random->RandomFloat( 0.1f, 1.0f );
torque.y = m_flGibAngVelocity * random->RandomFloat( 0.1f, 1.0f );
torque.z = 0.0f;
torque *= pPhysicsObject->GetMass();
pPhysicsObject->ApplyTorqueCenter( torque );
#ifndef HL1_DLL
if( HasSpawnFlags( SF_SHOOTER_STRICT_REMOVE ) )
#endif
{
pGib->m_bForceRemove = true;
pGib->SetNextThink( gpGlobals->curtime + pGib->m_lifeTime );
pGib->SetThink ( &CGib::DieThink );
}
}
else
{
InitPointGib( pGib, vecShootDir, flSpeed );
}
}
return pGib;
}
case GIB_SIMULATE_POINT:
{
CGib *pGib = CreateGib();
if ( pGib )
{
pGib->SetAbsAngles( m_angGibRotation );
InitPointGib( pGib, vecShootDir, flSpeed );
return pGib;
}
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGibShooter::ShootThink ( void )
{
SetNextThink( gpGlobals->curtime + m_flDelay );
Vector vecShootDir, vForward,vRight,vUp;
AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );
vecShootDir = vForward;
vecShootDir = vecShootDir + vRight * random->RandomFloat( -1, 1) * m_flVariance;
vecShootDir = vecShootDir + vForward * random->RandomFloat( -1, 1) * m_flVariance;
vecShootDir = vecShootDir + vUp * random->RandomFloat( -1, 1) * m_flVariance;
VectorNormalize( vecShootDir );
SpawnGib( vecShootDir, m_flGibVelocity );
if ( --m_iGibs <= 0 )
{
if ( HasSpawnFlags(SF_GIBSHOOTER_REPEATABLE) )
{
m_iGibs = m_iGibCapacity;
SetThink ( NULL );
SetNextThink( gpGlobals->curtime );
}
else
{
SetThink ( &CGibShooter::SUB_Remove );
SetNextThink( gpGlobals->curtime );
}
}
}
class CEnvShooter : public CGibShooter
{
public:
DECLARE_CLASS( CEnvShooter, CGibShooter );
CEnvShooter() { m_flGibGravityScale = 1.0f; }
void Precache( void );
bool KeyValue( const char *szKeyName, const char *szValue );
CGib *CreateGib( void );
DECLARE_DATADESC();
public:
int m_nSkin;
float m_flGibScale;
float m_flGibGravityScale;
#if HL2_EPISODIC
float m_flMassOverride; // allow designer to force a mass for gibs in some cases
#endif
};
BEGIN_DATADESC( CEnvShooter )
DEFINE_KEYFIELD( m_nSkin, FIELD_INTEGER, "skin" ),
DEFINE_KEYFIELD( m_flGibScale, FIELD_FLOAT ,"scale" ),
DEFINE_KEYFIELD( m_flGibGravityScale, FIELD_FLOAT, "gibgravityscale" ),
#if HL2_EPISODIC
DEFINE_KEYFIELD( m_flMassOverride, FIELD_FLOAT, "massoverride" ),
#endif
END_DATADESC()
LINK_ENTITY_TO_CLASS( env_shooter, CEnvShooter );
bool CEnvShooter::KeyValue( const char *szKeyName, const char *szValue )
{
if (FStrEq(szKeyName, "shootmodel"))
{
m_bIsSprite = false;
SetModelName( AllocPooledString(szValue) );
//Adrian - not pretty...
if ( Q_stristr( szValue, ".vmt" ) )
m_bIsSprite = true;
}
else if (FStrEq(szKeyName, "shootsounds"))
{
int iNoise = atoi(szValue);
switch( iNoise )
{
case 0:
m_iGibMaterial = matGlass;
break;
case 1:
m_iGibMaterial = matWood;
break;
case 2:
m_iGibMaterial = matMetal;
break;
case 3:
m_iGibMaterial = matFlesh;
break;
case 4:
m_iGibMaterial = matRocks;
break;
default:
case -1:
m_iGibMaterial = matNone;
break;
}
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
void CEnvShooter::Precache ( void )
{
m_iGibModelIndex = PrecacheModel( STRING( GetModelName() ) );
}
CGib *CEnvShooter::CreateGib ( void )
{
CGib *pGib = CREATE_ENTITY( CGib, "gib" );
if ( m_bIsSprite == true )
{
//HACK HACK
pGib->Spawn( "" );
}
else
{
pGib->Spawn( STRING( GetModelName() ) );
}
int bodyPart = 0;
if ( m_nMaxGibModelFrame > 1 )
{
bodyPart = random->RandomInt( 0, m_nMaxGibModelFrame-1 );
}
pGib->m_nBody = bodyPart;
pGib->SetBloodColor( DONT_BLEED );
pGib->m_material = m_iGibMaterial;
pGib->m_nRenderMode = m_nRenderMode;
pGib->m_clrRender = m_clrRender;
pGib->m_nRenderFX = m_nRenderFX;
pGib->m_nSkin = m_nSkin;
pGib->m_lifeTime = gpGlobals->curtime + m_flGibLife;
pGib->SetGravity( m_flGibGravityScale );
// Spawn a flaming gib
if ( HasSpawnFlags( SF_SHOOTER_FLAMING ) )
{
// Tag an entity flame along with us
CEntityFlame *pFlame = CEntityFlame::Create( pGib, false );
if ( pFlame != NULL )
{
pFlame->SetLifetime( pGib->m_lifeTime );
pGib->SetFlame( pFlame );
}
}
if ( m_iszLightingOrigin != NULL_STRING )
{
// Make the gibs use the lighting origin
pGib->SetLightingOrigin( m_iszLightingOrigin );
}
if( m_bNoGibShadows )
{
pGib->AddEffects( EF_NOSHADOW );
}
#if HL2_EPISODIC
// if a mass override is set, apply it to the gib
if (m_flMassOverride != 0)
{
IPhysicsObject *pPhys = pGib->VPhysicsGetObject();
if (pPhys)
{
pPhys->SetMass( m_flMassOverride );
}
}
#endif
return pGib;
}
//-----------------------------------------------------------------------------
// An entity that shoots out junk when hit by a rotor wash
//-----------------------------------------------------------------------------
class CRotorWashShooter : public CEnvShooter, public IRotorWashShooter
{
public:
DECLARE_CLASS( CRotorWashShooter, CEnvShooter );
DECLARE_DATADESC();
virtual void Spawn();
public:
// Inherited from IRotorWashShooter
virtual CBaseEntity *DoWashPush( float flTimeSincePushStarted, const Vector &vecForce );
private:
// Amount of time we need to spend under the rotor before we shoot
float m_flTimeUnderRotor;
float m_flTimeUnderRotorVariance;
// Last time we were hit with a wash...
float m_flLastWashStartTime;
float m_flNextGibTime;
};
LINK_ENTITY_TO_CLASS( env_rotorshooter, CRotorWashShooter );
//-----------------------------------------------------------------------------
// Save/load
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CRotorWashShooter )
DEFINE_KEYFIELD( m_flTimeUnderRotor, FIELD_FLOAT ,"rotortime" ),
DEFINE_KEYFIELD( m_flTimeUnderRotorVariance, FIELD_FLOAT ,"rotortimevariance" ),
DEFINE_FIELD( m_flLastWashStartTime, FIELD_TIME ),
DEFINE_FIELD( m_flNextGibTime, FIELD_TIME ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Gets at the interface if the entity supports it
//-----------------------------------------------------------------------------
IRotorWashShooter *GetRotorWashShooter( CBaseEntity *pEntity )
{
CRotorWashShooter *pShooter = dynamic_cast<CRotorWashShooter*>(pEntity);
return pShooter;
}
//-----------------------------------------------------------------------------
// Inherited from IRotorWashShooter
//-----------------------------------------------------------------------------
void CRotorWashShooter::Spawn()
{
BaseClass::Spawn();
m_flLastWashStartTime = -1;
}
//-----------------------------------------------------------------------------
// Inherited from IRotorWashShooter
//-----------------------------------------------------------------------------
CBaseEntity *CRotorWashShooter::DoWashPush( float flWashStartTime, const Vector &vecForce )
{
if ( flWashStartTime == m_flLastWashStartTime )
{
if ( m_flNextGibTime > gpGlobals->curtime )
return NULL;
}
m_flLastWashStartTime = flWashStartTime;
m_flNextGibTime = gpGlobals->curtime + m_flTimeUnderRotor + random->RandomFloat( -1, 1) * m_flTimeUnderRotorVariance;
if ( m_flNextGibTime <= gpGlobals->curtime )
{
m_flNextGibTime = gpGlobals->curtime + 0.01f;
}
// Set the velocity to be what the force would cause it to accelerate to
// after one tick
Vector vecShootDir = vecForce;
VectorNormalize( vecShootDir );
vecShootDir.x += random->RandomFloat( -1, 1 ) * m_flVariance;
vecShootDir.y += random->RandomFloat( -1, 1 ) * m_flVariance;
vecShootDir.z += random->RandomFloat( -1, 1 ) * m_flVariance;
VectorNormalize( vecShootDir );
CBaseEntity *pGib = SpawnGib( vecShootDir, m_flGibVelocity /*flLength*/ );
if ( --m_iGibs <= 0 )
{
if ( HasSpawnFlags(SF_GIBSHOOTER_REPEATABLE) )
{
m_iGibs = m_iGibCapacity;
}
else
{
SetThink ( &CGibShooter::SUB_Remove );
SetNextThink( gpGlobals->curtime );
}
}
return pGib;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CTestEffect : public CBaseEntity
{
public:
DECLARE_CLASS( CTestEffect, CBaseEntity );
void Spawn( void );
void Precache( void );
// bool KeyValue( const char *szKeyName, const char *szValue );
void Think( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
int m_iLoop;
int m_iBeam;
CBeam *m_pBeam[24];
float m_flBeamTime[24];
float m_flStartTime;
};
LINK_ENTITY_TO_CLASS( test_effect, CTestEffect );
void CTestEffect::Spawn( void )
{
Precache( );
}
void CTestEffect::Precache( void )
{
PrecacheModel( "sprites/lgtning.vmt" );
}
void CTestEffect::Think( void )
{
int i;
float t = (gpGlobals->curtime - m_flStartTime);
if (m_iBeam < 24)
{
CBeam *pbeam = CBeam::BeamCreate( "sprites/lgtning.vmt", 10 );
trace_t tr;
Vector vecSrc = GetAbsOrigin();
Vector vecDir = Vector( random->RandomFloat( -1.0, 1.0 ), random->RandomFloat( -1.0, 1.0 ),random->RandomFloat( -1.0, 1.0 ) );
VectorNormalize( vecDir );
UTIL_TraceLine( vecSrc, vecSrc + vecDir * 128, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
pbeam->PointsInit( vecSrc, tr.endpos );
// pbeam->SetColor( 80, 100, 255 );
pbeam->SetColor( 255, 180, 100 );
pbeam->SetWidth( 10.0 );
pbeam->SetScrollRate( 12 );
m_flBeamTime[m_iBeam] = gpGlobals->curtime;
m_pBeam[m_iBeam] = pbeam;
m_iBeam++;
#if 0
Vector vecMid = (vecSrc + tr.endpos) * 0.5;
CBroadcastRecipientFilter filter;
TE_DynamicLight( filter, 0.0,
vecMid, 255, 180, 100, 3, 2.0, 0.0 );
#endif
}
if (t < 3.0)
{
for (i = 0; i < m_iBeam; i++)
{
t = (gpGlobals->curtime - m_flBeamTime[i]) / ( 3 + m_flStartTime - m_flBeamTime[i]);
m_pBeam[i]->SetBrightness( 255 * t );
// m_pBeam[i]->SetScrollRate( 20 * t );
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
else
{
for (i = 0; i < m_iBeam; i++)
{
UTIL_Remove( m_pBeam[i] );
}
m_flStartTime = gpGlobals->curtime;
m_iBeam = 0;
SetNextThink( TICK_NEVER_THINK );
}
}
void CTestEffect::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
SetNextThink( gpGlobals->curtime + 0.1f );
m_flStartTime = gpGlobals->curtime;
}
// Blood effects
class CBlood : public CPointEntity
{
public:
DECLARE_CLASS( CBlood, CPointEntity );
void Spawn( void );
bool KeyValue( const char *szKeyName, const char *szValue );
inline int Color( void ) { return m_Color; }
inline float BloodAmount( void ) { return m_flAmount; }
inline void SetColor( int color ) { m_Color = color; }
// Input handlers
void InputEmitBlood( inputdata_t &inputdata );
Vector Direction( void );
Vector BloodPosition( CBaseEntity *pActivator );
DECLARE_DATADESC();
Vector m_vecSprayDir;
float m_flAmount;
int m_Color;
private:
};
LINK_ENTITY_TO_CLASS( env_blood, CBlood );
BEGIN_DATADESC( CBlood )
DEFINE_KEYFIELD( m_vecSprayDir, FIELD_VECTOR, "spraydir" ),
DEFINE_KEYFIELD( m_flAmount, FIELD_FLOAT, "amount" ),
DEFINE_FIELD( m_Color, FIELD_INTEGER ),
DEFINE_INPUTFUNC( FIELD_VOID, "EmitBlood", InputEmitBlood ),
END_DATADESC()
#define SF_BLOOD_RANDOM 0x0001
#define SF_BLOOD_STREAM 0x0002
#define SF_BLOOD_PLAYER 0x0004
#define SF_BLOOD_DECAL 0x0008
#define SF_BLOOD_CLOUD 0x0010
#define SF_BLOOD_DROPS 0x0020
#define SF_BLOOD_GORE 0x0040
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBlood::Spawn( void )
{
// Convert spraydir from angles to a vector
QAngle angSprayDir = QAngle( m_vecSprayDir.x, m_vecSprayDir.y, m_vecSprayDir.z );
AngleVectors( angSprayDir, &m_vecSprayDir );
SetSolid( SOLID_NONE );
SetMoveType( MOVETYPE_NONE );
SetColor( BLOOD_COLOR_RED );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : szKeyName -
// szValue -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBlood::KeyValue( const char *szKeyName, const char *szValue )
{
if (FStrEq(szKeyName, "color"))
{
int color = atoi(szValue);
switch ( color )
{
case 1:
{
SetColor( BLOOD_COLOR_YELLOW );
break;
}
}
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
Vector CBlood::Direction( void )
{
if ( HasSpawnFlags( SF_BLOOD_RANDOM ) )
return UTIL_RandomBloodVector();
return m_vecSprayDir;
}
Vector CBlood::BloodPosition( CBaseEntity *pActivator )
{
if ( HasSpawnFlags( SF_BLOOD_PLAYER ) )
{
CBasePlayer *player;
if ( pActivator && pActivator->IsPlayer() )
{
player = ToBasePlayer( pActivator );
}
else
{
player = UTIL_GetLocalPlayer();
}
if ( player )
{
return (player->EyePosition()) + Vector( random->RandomFloat(-10,10), random->RandomFloat(-10,10), random->RandomFloat(-10,10) );
}
}
return GetLocalOrigin();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void UTIL_BloodSpray( const Vector &pos, const Vector &dir, int color, int amount, int flags )
{
if( color == DONT_BLEED )
return;
CEffectData data;
data.m_vOrigin = pos;
data.m_vNormal = dir;
data.m_flScale = (float)amount;
data.m_fFlags = flags;
data.m_nColor = color;
DispatchEffect( "bloodspray", data );
}
//-----------------------------------------------------------------------------
// Purpose: Input handler for triggering the blood effect.
//-----------------------------------------------------------------------------
void CBlood::InputEmitBlood( inputdata_t &inputdata )
{
if ( HasSpawnFlags( SF_BLOOD_STREAM ) )
{
UTIL_BloodStream( BloodPosition(inputdata.pActivator), Direction(), Color(), BloodAmount() );
}
else
{
UTIL_BloodDrips( BloodPosition(inputdata.pActivator), Direction(), Color(), BloodAmount() );
}
if ( HasSpawnFlags( SF_BLOOD_DECAL ) )
{
Vector forward = Direction();
Vector start = BloodPosition( inputdata.pActivator );
trace_t tr;
UTIL_TraceLine( start, start + forward * BloodAmount() * 2, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
UTIL_BloodDecalTrace( &tr, Color() );
}
}
//
// New-fangled blood effects.
//
if ( HasSpawnFlags( SF_BLOOD_CLOUD | SF_BLOOD_DROPS | SF_BLOOD_GORE ) )
{
int nFlags = 0;
if (HasSpawnFlags(SF_BLOOD_CLOUD))
{
nFlags |= FX_BLOODSPRAY_CLOUD;
}
if (HasSpawnFlags(SF_BLOOD_DROPS))
{
nFlags |= FX_BLOODSPRAY_DROPS;
}
if (HasSpawnFlags(SF_BLOOD_GORE))
{
nFlags |= FX_BLOODSPRAY_GORE;
}
UTIL_BloodSpray(GetAbsOrigin(), Direction(), Color(), BloodAmount(), nFlags);
}
}
//-----------------------------------------------------------------------------
// Purpose: Console command for emitting the blood spray effect from an NPC.
//-----------------------------------------------------------------------------
void CC_BloodSpray( const CCommand &args )
{
CBaseEntity *pEnt = NULL;
while ( ( pEnt = gEntList.FindEntityGeneric( pEnt, args[1] ) ) != NULL )
{
Vector forward;
pEnt->GetVectors(&forward, NULL, NULL);
UTIL_BloodSpray( (forward * 4 ) + ( pEnt->EyePosition() + pEnt->WorldSpaceCenter() ) * 0.5f, forward, BLOOD_COLOR_RED, 4, FX_BLOODSPRAY_ALL );
}
}
static ConCommand bloodspray( "bloodspray", CC_BloodSpray, "blood", FCVAR_CHEAT );
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
class CEnvFunnel : public CBaseEntity
{
DECLARE_DATADESC();
public:
DECLARE_CLASS( CEnvFunnel, CBaseEntity );
void Spawn( void );
void Precache( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
int m_iSprite; // Don't save, precache
};
LINK_ENTITY_TO_CLASS( env_funnel, CEnvFunnel );
//---------------------------------------------------------
// Save/Restore
//---------------------------------------------------------
BEGIN_DATADESC( CEnvFunnel )
// DEFINE_FIELD( m_iSprite, FIELD_INTEGER ),
END_DATADESC()
void CEnvFunnel::Precache ( void )
{
m_iSprite = PrecacheModel ( "sprites/flare6.vmt" );
}
void CEnvFunnel::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
CBroadcastRecipientFilter filter;
te->LargeFunnel( filter, 0.0,
&GetAbsOrigin(), m_iSprite, HasSpawnFlags( SF_FUNNEL_REVERSE ) ? 1 : 0 );
SetThink( &CEnvFunnel::SUB_Remove );
SetNextThink( gpGlobals->curtime );
}
void CEnvFunnel::Spawn( void )
{
Precache();
SetSolid( SOLID_NONE );
AddEffects( EF_NODRAW );
}
//=========================================================
// Beverage Dispenser
// overloaded m_iHealth, is now how many cans remain in the machine.
//=========================================================
class CEnvBeverage : public CBaseEntity
{
public:
DECLARE_CLASS( CEnvBeverage, CBaseEntity );
void Spawn( void );
void Precache( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
bool KeyValue( const char *szKeyName, const char *szValue );
// Input handlers.
void InputActivate( inputdata_t &inputdata );
DECLARE_DATADESC();
public:
bool m_CanInDispenser;
int m_nBeverageType;
};
void CEnvBeverage::Precache ( void )
{
PrecacheModel( "models/can.mdl" );
}
BEGIN_DATADESC( CEnvBeverage )
DEFINE_FIELD( m_CanInDispenser, FIELD_BOOLEAN ),
DEFINE_FIELD( m_nBeverageType, FIELD_INTEGER ),
DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( env_beverage, CEnvBeverage );
bool CEnvBeverage::KeyValue( const char *szKeyName, const char *szValue )
{
if (FStrEq(szKeyName, "beveragetype"))
{
m_nBeverageType = atoi(szValue);
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
void CEnvBeverage::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( m_CanInDispenser || m_iHealth <= 0 )
{
// no more cans while one is waiting in the dispenser, or if I'm out of cans.
return;
}
CBaseAnimating *pCan = (CBaseAnimating *)CBaseEntity::Create( "item_sodacan", GetLocalOrigin(), GetLocalAngles(), this );
if ( m_nBeverageType == 6 )
{
// random
pCan->m_nSkin = random->RandomInt( 0, 5 );
}
else
{
pCan->m_nSkin = m_nBeverageType;
}
m_CanInDispenser = true;
m_iHealth -= 1;
//SetThink (SUB_Remove);
//SetNextThink( gpGlobals->curtime );
}
void CEnvBeverage::InputActivate( inputdata_t &inputdata )
{
Use( inputdata.pActivator, inputdata.pCaller, USE_ON, 0 );
}
void CEnvBeverage::Spawn( void )
{
Precache();
SetSolid( SOLID_NONE );
AddEffects( EF_NODRAW );
m_CanInDispenser = false;
if ( m_iHealth == 0 )
{
m_iHealth = 10;
}
}
//=========================================================
// Soda can
//=========================================================
class CItemSoda : public CBaseAnimating
{
public:
DECLARE_CLASS( CItemSoda, CBaseAnimating );
void Spawn( void );
void Precache( void );
void CanThink ( void );
void CanTouch ( CBaseEntity *pOther );
DECLARE_DATADESC();
};
BEGIN_DATADESC( CItemSoda )
// Function Pointers
DEFINE_FUNCTION( CanThink ),
DEFINE_FUNCTION( CanTouch ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( item_sodacan, CItemSoda );
void CItemSoda::Precache ( void )
{
PrecacheModel( "models/can.mdl" );
PrecacheScriptSound( "ItemSoda.Bounce" );
}
void CItemSoda::Spawn( void )
{
Precache();
SetSolid( SOLID_NONE );
SetMoveType( MOVETYPE_FLYGRAVITY );
SetModel ( "models/can.mdl" );
UTIL_SetSize ( this, Vector ( 0, 0, 0 ), Vector ( 0, 0, 0 ) );
SetThink (&CItemSoda::CanThink);
SetNextThink( gpGlobals->curtime + 0.5f );
}
void CItemSoda::CanThink ( void )
{
EmitSound( "ItemSoda.Bounce" );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
UTIL_SetSize ( this, Vector ( -8, -8, 0 ), Vector ( 8, 8, 8 ) );
SetThink ( NULL );
SetTouch ( &CItemSoda::CanTouch );
}
void CItemSoda::CanTouch ( CBaseEntity *pOther )
{
if ( !pOther->IsPlayer() )
{
return;
}
// spoit sound here
pOther->TakeHealth( 1, DMG_GENERIC );// a bit of health.
if ( GetOwnerEntity() )
{
// tell the machine the can was taken
CEnvBeverage *bev = (CEnvBeverage *)GetOwnerEntity();
bev->m_CanInDispenser = false;
}
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_NONE );
AddEffects( EF_NODRAW );
SetTouch ( NULL );
SetThink ( &CItemSoda::SUB_Remove );
SetNextThink( gpGlobals->curtime );
}
#ifndef _XBOX
//=========================================================
// func_precipitation - temporary snow solution for first HL2
// technology demo
//=========================================================
class CPrecipitation : public CBaseEntity
{
public:
DECLARE_CLASS( CPrecipitation, CBaseEntity );
DECLARE_DATADESC();
DECLARE_SERVERCLASS();
CPrecipitation();
void Spawn( void );
CNetworkVar( PrecipitationType_t, m_nPrecipType );
};
LINK_ENTITY_TO_CLASS( func_precipitation, CPrecipitation );
BEGIN_DATADESC( CPrecipitation )
DEFINE_KEYFIELD( m_nPrecipType, FIELD_INTEGER, "preciptype" ),
END_DATADESC()
// Just send the normal entity crap
IMPLEMENT_SERVERCLASS_ST( CPrecipitation, DT_Precipitation)
SendPropInt( SENDINFO( m_nPrecipType ), Q_log2( NUM_PRECIPITATION_TYPES ) + 1, SPROP_UNSIGNED )
END_SEND_TABLE()
CPrecipitation::CPrecipitation()
{
m_nPrecipType = PRECIPITATION_TYPE_RAIN; // default to rain.
}
void CPrecipitation::Spawn( void )
{
PrecacheMaterial( "effects/fleck_ash1" );
PrecacheMaterial( "effects/fleck_ash2" );
PrecacheMaterial( "effects/fleck_ash3" );
PrecacheMaterial( "effects/ember_swirling001" );
Precache();
SetSolid( SOLID_NONE ); // Remove model & collisions
SetMoveType( MOVETYPE_NONE );
SetModel( STRING( GetModelName() ) ); // Set size
// Default to rain.
if ( m_nPrecipType < 0 || m_nPrecipType > NUM_PRECIPITATION_TYPES )
m_nPrecipType = PRECIPITATION_TYPE_RAIN;
m_nRenderMode = kRenderEnvironmental;
}
#endif
//-----------------------------------------------------------------------------
// EnvWind - global wind info
//-----------------------------------------------------------------------------
class CEnvWind : public CBaseEntity
{
public:
DECLARE_CLASS( CEnvWind, CBaseEntity );
void Spawn( void );
void Precache( void );
void WindThink( void );
int UpdateTransmitState( void );
DECLARE_DATADESC();
DECLARE_SERVERCLASS();
private:
#ifdef POSIX
CEnvWindShared m_EnvWindShared; // FIXME - fails to compile as networked var due to operator= problem
#else
CNetworkVarEmbedded( CEnvWindShared, m_EnvWindShared );
#endif
};
LINK_ENTITY_TO_CLASS( env_wind, CEnvWind );
BEGIN_DATADESC( CEnvWind )
DEFINE_KEYFIELD( m_EnvWindShared.m_iMinWind, FIELD_INTEGER, "minwind" ),
DEFINE_KEYFIELD( m_EnvWindShared.m_iMaxWind, FIELD_INTEGER, "maxwind" ),
DEFINE_KEYFIELD( m_EnvWindShared.m_iMinGust, FIELD_INTEGER, "mingust" ),
DEFINE_KEYFIELD( m_EnvWindShared.m_iMaxGust, FIELD_INTEGER, "maxgust" ),
DEFINE_KEYFIELD( m_EnvWindShared.m_flMinGustDelay, FIELD_FLOAT, "mingustdelay" ),
DEFINE_KEYFIELD( m_EnvWindShared.m_flMaxGustDelay, FIELD_FLOAT, "maxgustdelay" ),
DEFINE_KEYFIELD( m_EnvWindShared.m_iGustDirChange, FIELD_INTEGER, "gustdirchange" ),
DEFINE_KEYFIELD( m_EnvWindShared.m_flGustDuration, FIELD_FLOAT, "gustduration" ),
// DEFINE_KEYFIELD( m_EnvWindShared.m_iszGustSound, FIELD_STRING, "gustsound" ),
// Just here to quiet down classcheck
// DEFINE_FIELD( m_EnvWindShared, CEnvWindShared ),
DEFINE_FIELD( m_EnvWindShared.m_iWindDir, FIELD_INTEGER ),
DEFINE_FIELD( m_EnvWindShared.m_flWindSpeed, FIELD_FLOAT ),
DEFINE_OUTPUT( m_EnvWindShared.m_OnGustStart, "OnGustStart" ),
DEFINE_OUTPUT( m_EnvWindShared.m_OnGustEnd, "OnGustEnd" ),
// Function Pointers
DEFINE_FUNCTION( WindThink ),
END_DATADESC()
BEGIN_SEND_TABLE_NOBASE(CEnvWindShared, DT_EnvWindShared)
// These are parameters that are used to generate the entire motion
SendPropInt (SENDINFO(m_iMinWind), 10, SPROP_UNSIGNED ),
SendPropInt (SENDINFO(m_iMaxWind), 10, SPROP_UNSIGNED ),
SendPropInt (SENDINFO(m_iMinGust), 10, SPROP_UNSIGNED ),
SendPropInt (SENDINFO(m_iMaxGust), 10, SPROP_UNSIGNED ),
SendPropFloat (SENDINFO(m_flMinGustDelay), 0, SPROP_NOSCALE), // NOTE: Have to do this, so it's *exactly* the same on client
SendPropFloat (SENDINFO(m_flMaxGustDelay), 0, SPROP_NOSCALE),
SendPropInt (SENDINFO(m_iGustDirChange), 9, SPROP_UNSIGNED ),
SendPropInt (SENDINFO(m_iWindSeed), 32, SPROP_UNSIGNED ),
// These are related to initial state
SendPropInt (SENDINFO(m_iInitialWindDir),9, SPROP_UNSIGNED ),
SendPropFloat (SENDINFO(m_flInitialWindSpeed),0, SPROP_NOSCALE ),
SendPropFloat (SENDINFO(m_flStartTime), 0, SPROP_NOSCALE ),
SendPropFloat (SENDINFO(m_flGustDuration), 0, SPROP_NOSCALE),
// Sound related
// SendPropInt (SENDINFO(m_iszGustSound), 10, SPROP_UNSIGNED ),
END_SEND_TABLE()
// This table encodes the CBaseEntity data.
IMPLEMENT_SERVERCLASS_ST_NOBASE(CEnvWind, DT_EnvWind)
SendPropDataTable(SENDINFO_DT(m_EnvWindShared), &REFERENCE_SEND_TABLE(DT_EnvWindShared)),
END_SEND_TABLE()
void CEnvWind::Precache ( void )
{
// if (m_iszGustSound)
// {
// PrecacheScriptSound( STRING( m_iszGustSound ) );
// }
}
void CEnvWind::Spawn( void )
{
Precache();
SetSolid( SOLID_NONE );
AddEffects( EF_NODRAW );
m_EnvWindShared.Init( entindex(), 0, gpGlobals->frametime, GetLocalAngles().y, 0 );
SetThink( &CEnvWind::WindThink );
SetNextThink( gpGlobals->curtime );
}
int CEnvWind::UpdateTransmitState()
{
return SetTransmitState( FL_EDICT_ALWAYS );
}
void CEnvWind::WindThink( void )
{
SetNextThink( m_EnvWindShared.WindThink( gpGlobals->curtime ) );
}
//==================================================
// CEmbers
//==================================================
#define bitsSF_EMBERS_START_ON 0x00000001
#define bitsSF_EMBERS_TOGGLE 0x00000002
// UNDONE: This is a brush effect-in-volume entity, move client side.
class CEmbers : public CBaseEntity
{
public:
DECLARE_CLASS( CEmbers, CBaseEntity );
void Spawn( void );
void Precache( void );
void EmberUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
CNetworkVar( int, m_nDensity );
CNetworkVar( int, m_nLifetime );
CNetworkVar( int, m_nSpeed );
CNetworkVar( bool, m_bEmit );
DECLARE_DATADESC();
DECLARE_SERVERCLASS();
};
LINK_ENTITY_TO_CLASS( env_embers, CEmbers );
//Data description
BEGIN_DATADESC( CEmbers )
DEFINE_KEYFIELD( m_nDensity, FIELD_INTEGER, "density" ),
DEFINE_KEYFIELD( m_nLifetime, FIELD_INTEGER, "lifetime" ),
DEFINE_KEYFIELD( m_nSpeed, FIELD_INTEGER, "speed" ),
DEFINE_FIELD( m_bEmit, FIELD_BOOLEAN ),
//Function pointers
DEFINE_FUNCTION( EmberUse ),
END_DATADESC()
//Data table
IMPLEMENT_SERVERCLASS_ST( CEmbers, DT_Embers )
SendPropInt( SENDINFO( m_nDensity ), 32, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nLifetime ), 32, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nSpeed ), 32, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bEmit ), 2, SPROP_UNSIGNED ),
END_SEND_TABLE()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEmbers::Spawn( void )
{
Precache();
SetModel( STRING( GetModelName() ) );
SetSolid( SOLID_NONE );
SetRenderColorA( 0 );
m_nRenderMode = kRenderTransTexture;
SetUse( &CEmbers::EmberUse );
//Start off if we're targetted (unless flagged)
m_bEmit = ( HasSpawnFlags( bitsSF_EMBERS_START_ON ) || ( !GetEntityName() ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEmbers::Precache( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pActivator -
// *pCaller -
// useType -
// value -
//-----------------------------------------------------------------------------
void CEmbers::EmberUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
//If we're not toggable, only allow one use
if ( !HasSpawnFlags( bitsSF_EMBERS_TOGGLE ) )
{
SetUse( NULL );
}
//Handle it
switch ( useType )
{
case USE_OFF:
m_bEmit = false;
break;
case USE_ON:
m_bEmit = true;
break;
case USE_SET:
m_bEmit = !!(int)value;
break;
default:
case USE_TOGGLE:
m_bEmit = !m_bEmit;
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CPhysicsWire : public CBaseEntity
{
public:
DECLARE_CLASS( CPhysicsWire, CBaseEntity );
void Spawn( void );
void Precache( void );
DECLARE_DATADESC();
protected:
bool SetupPhysics( void );
int m_nDensity;
};
LINK_ENTITY_TO_CLASS( env_physwire, CPhysicsWire );
BEGIN_DATADESC( CPhysicsWire )
DEFINE_KEYFIELD( m_nDensity, FIELD_INTEGER, "Density" ),
// DEFINE_KEYFIELD( m_frequency, FIELD_INTEGER, "frequency" ),
// DEFINE_FIELD( m_flFoo, FIELD_FLOAT ),
// Function Pointers
// DEFINE_FUNCTION( WireThink ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysicsWire::Spawn( void )
{
BaseClass::Spawn();
Precache();
// if ( SetupPhysics() == false )
// return;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysicsWire::Precache( void )
{
BaseClass::Precache();
}
class CPhysBallSocket;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CPhysicsWire::SetupPhysics( void )
{
/*
CPointEntity *anchorEnt, *freeEnt;
CPhysBallSocket *socket;
char anchorName[256];
char freeName[256];
int iAnchorName, iFreeName;
anchorEnt = (CPointEntity *) CreateEntityByName( "info_target" );
if ( anchorEnt == NULL )
return false;
//Create and connect all segments
for ( int i = 0; i < m_nDensity; i++ )
{
// Create other end of our link
freeEnt = (CPointEntity *) CreateEntityByName( "info_target" );
// Create a ballsocket and attach the two
//socket = (CPhysBallSocket *) CreateEntityByName( "phys_ballsocket" );
Q_snprintf( anchorName,sizeof(anchorName), "__PWIREANCHOR%d", i );
Q_snprintf( freeName,sizeof(freeName), "__PWIREFREE%d", i+1 );
iAnchorName = MAKE_STRING( anchorName );
iFreeName = MAKE_STRING( freeName );
//Fake the names
//socket->m_nameAttach1 = anchorEnt->m_iGlobalname = iAnchorName;
//socket->m_nameAttach2 = freeEnt->m_iGlobalname = iFreeName
//socket->Activate();
//The free ent is now the anchor for the next link
anchorEnt = freeEnt;
}
*/
return true;
}
//
// Muzzle flash
//
class CEnvMuzzleFlash : public CPointEntity
{
DECLARE_CLASS( CEnvMuzzleFlash, CPointEntity );
public:
virtual void Spawn();
// Input handlers
void InputFire( inputdata_t &inputdata );
DECLARE_DATADESC();
float m_flScale;
string_t m_iszParentAttachment;
};
BEGIN_DATADESC( CEnvMuzzleFlash )
DEFINE_KEYFIELD( m_flScale, FIELD_FLOAT, "scale" ),
DEFINE_KEYFIELD( m_iszParentAttachment, FIELD_STRING, "parentattachment" ),
DEFINE_INPUTFUNC( FIELD_VOID, "Fire", InputFire ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( env_muzzleflash, CEnvMuzzleFlash );
//-----------------------------------------------------------------------------
// Spawn!
//-----------------------------------------------------------------------------
void CEnvMuzzleFlash::Spawn()
{
if ( (m_iszParentAttachment != NULL_STRING) && GetParent() && GetParent()->GetBaseAnimating() )
{
CBaseAnimating *pAnim = GetParent()->GetBaseAnimating();
int nParentAttachment = pAnim->LookupAttachment( STRING(m_iszParentAttachment) );
if ( nParentAttachment > 0 )
{
SetParent( GetParent(), nParentAttachment );
SetLocalOrigin( vec3_origin );
SetLocalAngles( vec3_angle );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CEnvMuzzleFlash::InputFire( inputdata_t &inputdata )
{
g_pEffects->MuzzleFlash( GetAbsOrigin(), GetAbsAngles(), m_flScale, MUZZLEFLASH_TYPE_DEFAULT );
}
//=========================================================
// Splash!
//=========================================================
#define SF_ENVSPLASH_FINDWATERSURFACE 0x00000001
#define SF_ENVSPLASH_DIMINISH 0x00000002
class CEnvSplash : public CPointEntity
{
DECLARE_CLASS( CEnvSplash, CPointEntity );
public:
// Input handlers
void InputSplash( inputdata_t &inputdata );
protected:
float m_flScale;
DECLARE_DATADESC();
};
BEGIN_DATADESC( CEnvSplash )
DEFINE_KEYFIELD( m_flScale, FIELD_FLOAT, "scale" ),
DEFINE_INPUTFUNC( FIELD_VOID, "Splash", InputSplash ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( env_splash, CEnvSplash );
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
#define SPLASH_MAX_DEPTH 120.0f
void CEnvSplash::InputSplash( inputdata_t &inputdata )
{
CEffectData data;
data.m_fFlags = 0;
float scale = m_flScale;
if( HasSpawnFlags( SF_ENVSPLASH_FINDWATERSURFACE ) )
{
if( UTIL_PointContents(GetAbsOrigin()) & MASK_WATER )
{
// No splash if I'm supposed to find the surface of the water, but I'm underwater.
return;
}
// Trace down and find the water's surface. This is designed for making
// splashes on the surface of water that can change water level.
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 4096 ), (MASK_WATER|MASK_SOLID_BRUSHONLY), this, COLLISION_GROUP_NONE, &tr );
data.m_vOrigin = tr.endpos;
if ( tr.contents & CONTENTS_SLIME )
{
data.m_fFlags |= FX_WATER_IN_SLIME;
}
}
else
{
data.m_vOrigin = GetAbsOrigin();
}
if( HasSpawnFlags( SF_ENVSPLASH_DIMINISH ) )
{
// Get smaller if I'm in deeper water.
float depth = 0.0f;
trace_t tr;
UTIL_TraceLine( data.m_vOrigin, data.m_vOrigin - Vector( 0, 0, 4096 ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
depth = fabs( tr.startpos.z - tr.endpos.z );
float factor = 1.0f - (depth / SPLASH_MAX_DEPTH);
if( factor < 0.1 )
{
// Don't bother making one this small.
return;
}
scale *= factor;
}
data.m_vNormal = Vector( 0, 0, 1 );
data.m_flScale = scale;
DispatchEffect( "watersplash", data );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CEnvGunfire : public CPointEntity
{
public:
DECLARE_CLASS( CEnvGunfire, CPointEntity );
CEnvGunfire()
{
// !!!HACKHACK
// These fields came along kind of late, so they get
// initialized in the constructor for now. (sjb)
m_flBias = 1.0f;
m_bCollide = false;
}
void Precache();
void Spawn();
void Activate();
void StartShooting();
void StopShooting();
void ShootThink();
void UpdateTarget();
void InputEnable( inputdata_t &inputdata );
void InputDisable( inputdata_t &inputdata );
int m_iMinBurstSize;
int m_iMaxBurstSize;
float m_flMinBurstDelay;
float m_flMaxBurstDelay;
float m_flRateOfFire;
string_t m_iszShootSound;
string_t m_iszTracerType;
bool m_bDisabled;
int m_iShotsRemaining;
int m_iSpread;
Vector m_vecSpread;
Vector m_vecTargetPosition;
float m_flTargetDist;
float m_flBias;
bool m_bCollide;
EHANDLE m_hTarget;
DECLARE_DATADESC();
};
BEGIN_DATADESC( CEnvGunfire )
DEFINE_KEYFIELD( m_iMinBurstSize, FIELD_INTEGER, "minburstsize" ),
DEFINE_KEYFIELD( m_iMaxBurstSize, FIELD_INTEGER, "maxburstsize" ),
DEFINE_KEYFIELD( m_flMinBurstDelay, FIELD_TIME, "minburstdelay" ),
DEFINE_KEYFIELD( m_flMaxBurstDelay, FIELD_TIME, "maxburstdelay" ),
DEFINE_KEYFIELD( m_flRateOfFire, FIELD_FLOAT, "rateoffire" ),
DEFINE_KEYFIELD( m_iszShootSound, FIELD_STRING, "shootsound" ),
DEFINE_KEYFIELD( m_iszTracerType, FIELD_STRING, "tracertype" ),
DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "startdisabled" ),
DEFINE_KEYFIELD( m_iSpread, FIELD_INTEGER, "spread" ),
DEFINE_KEYFIELD( m_flBias, FIELD_FLOAT, "bias" ),
DEFINE_KEYFIELD( m_bCollide, FIELD_BOOLEAN, "collisions" ),
DEFINE_FIELD( m_iShotsRemaining, FIELD_INTEGER ),
DEFINE_FIELD( m_vecSpread, FIELD_VECTOR ),
DEFINE_FIELD( m_vecTargetPosition, FIELD_VECTOR ),
DEFINE_FIELD( m_flTargetDist, FIELD_FLOAT ),
DEFINE_FIELD( m_hTarget, FIELD_EHANDLE ),
DEFINE_THINKFUNC( ShootThink ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( env_gunfire, CEnvGunfire );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::Precache()
{
PrecacheScriptSound( STRING( m_iszShootSound ) );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::Spawn()
{
Precache();
m_iShotsRemaining = 0;
m_flRateOfFire = 1.0f / m_flRateOfFire;
switch( m_iSpread )
{
case 1:
m_vecSpread = VECTOR_CONE_1DEGREES;
break;
case 5:
m_vecSpread = VECTOR_CONE_5DEGREES;
break;
case 10:
m_vecSpread = VECTOR_CONE_10DEGREES;
break;
case 15:
m_vecSpread = VECTOR_CONE_15DEGREES;
break;
default:
m_vecSpread = vec3_origin;
break;
}
if( !m_bDisabled )
{
StartShooting();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::Activate( void )
{
// Find my target
if (m_target != NULL_STRING)
{
m_hTarget = gEntList.FindEntityByName( NULL, m_target );
}
BaseClass::Activate();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::StartShooting()
{
m_iShotsRemaining = random->RandomInt( m_iMinBurstSize, m_iMaxBurstSize );
SetThink( &CEnvGunfire::ShootThink );
SetNextThink( gpGlobals->curtime );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::UpdateTarget()
{
if( m_hTarget )
{
if( m_hTarget->WorldSpaceCenter() != m_vecTargetPosition )
{
// Target has moved.
// Locate my target and cache the position and distance.
m_vecTargetPosition = m_hTarget->WorldSpaceCenter();
m_flTargetDist = (GetAbsOrigin() - m_vecTargetPosition).Length();
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::StopShooting()
{
SetThink( NULL );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::ShootThink()
{
if( !m_hTarget )
{
StopShooting();
}
SetNextThink( gpGlobals->curtime + m_flRateOfFire );
UpdateTarget();
Vector vecDir = m_vecTargetPosition - GetAbsOrigin();
VectorNormalize( vecDir );
CShotManipulator manipulator( vecDir );
vecDir = manipulator.ApplySpread( m_vecSpread, m_flBias );
Vector vecEnd;
if( m_bCollide )
{
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vecDir * 8192, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
if( tr.fraction != 1.0 )
{
DoImpactEffect( tr, DMG_BULLET );
}
vecEnd = tr.endpos;
}
else
{
vecEnd = GetAbsOrigin() + vecDir * m_flTargetDist;
}
if( m_iszTracerType != NULL_STRING )
{
UTIL_Tracer( GetAbsOrigin(), vecEnd, 0, TRACER_DONT_USE_ATTACHMENT, 5000, true, STRING(m_iszTracerType) );
}
else
{
UTIL_Tracer( GetAbsOrigin(), vecEnd, 0, TRACER_DONT_USE_ATTACHMENT, 5000, true );
}
EmitSound( STRING(m_iszShootSound) );
m_iShotsRemaining--;
if( m_iShotsRemaining == 0 )
{
StartShooting();
SetNextThink( gpGlobals->curtime + random->RandomFloat( m_flMinBurstDelay, m_flMaxBurstDelay ) );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::InputEnable( inputdata_t &inputdata )
{
m_bDisabled = false;
StartShooting();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvGunfire::InputDisable( inputdata_t &inputdata )
{
m_bDisabled = true;
SetThink( NULL );
}
//-----------------------------------------------------------------------------
// Quadratic spline beam effect
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CEnvQuadraticBeam )
DEFINE_FIELD( m_targetPosition, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_controlPosition, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_scrollRate, FIELD_FLOAT ),
DEFINE_FIELD( m_flWidth, FIELD_FLOAT ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( env_quadraticbeam, CEnvQuadraticBeam );
IMPLEMENT_SERVERCLASS_ST( CEnvQuadraticBeam, DT_QuadraticBeam )
SendPropVector(SENDINFO(m_targetPosition), -1, SPROP_COORD),
SendPropVector(SENDINFO(m_controlPosition), -1, SPROP_COORD),
SendPropFloat(SENDINFO(m_scrollRate), 8, 0, -4, 4),
SendPropFloat(SENDINFO(m_flWidth), -1, SPROP_NOSCALE),
END_SEND_TABLE()
void CEnvQuadraticBeam::Spawn()
{
BaseClass::Spawn();
m_nRenderMode = kRenderTransAdd;
SetRenderColor( 255, 255, 255 );
}
CEnvQuadraticBeam *CreateQuadraticBeam( const char *pSpriteName, const Vector &start, const Vector &control, const Vector &end, float width, CBaseEntity *pOwner )
{
CEnvQuadraticBeam *pBeam = (CEnvQuadraticBeam *)CBaseEntity::Create( "env_quadraticbeam", start, vec3_angle, pOwner );
UTIL_SetModel( pBeam, pSpriteName );
pBeam->SetSpline( control, end );
pBeam->SetScrollRate( 0.0 );
pBeam->SetWidth(width);
return pBeam;
}
void EffectsPrecache( void *pUser )
{
CBaseEntity::PrecacheScriptSound( "Underwater.BulletImpact" );
CBaseEntity::PrecacheScriptSound( "FX_RicochetSound.Ricochet" );
CBaseEntity::PrecacheScriptSound( "Physics.WaterSplash" );
CBaseEntity::PrecacheScriptSound( "BaseExplosionEffect.Sound" );
CBaseEntity::PrecacheScriptSound( "Splash.SplashSound" );
if ( gpGlobals->maxClients > 1 )
{
CBaseEntity::PrecacheScriptSound( "HudChat.Message" );
}
}
PRECACHE_REGISTER_FN( EffectsPrecache );
class CEnvViewPunch : public CPointEntity
{
public:
DECLARE_CLASS( CEnvViewPunch, CPointEntity );
virtual void Spawn();
// Input handlers
void InputViewPunch( inputdata_t &inputdata );
private:
float m_flRadius;
QAngle m_angViewPunch;
void DoViewPunch();
DECLARE_DATADESC();
};
LINK_ENTITY_TO_CLASS( env_viewpunch, CEnvViewPunch );
BEGIN_DATADESC( CEnvViewPunch )
DEFINE_KEYFIELD( m_angViewPunch, FIELD_VECTOR, "punchangle" ),
DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "radius" ),
DEFINE_INPUTFUNC( FIELD_VOID, "ViewPunch", InputViewPunch ),
END_DATADESC()
#define SF_PUNCH_EVERYONE 0x0001 // Don't check radius
#define SF_PUNCH_IN_AIR 0x0002 // Punch players in air
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvViewPunch::Spawn( void )
{
SetSolid( SOLID_NONE );
SetMoveType( MOVETYPE_NONE );
if ( GetSpawnFlags() & SF_PUNCH_EVERYONE )
{
m_flRadius = 0;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvViewPunch::DoViewPunch()
{
bool bAir = (GetSpawnFlags() & SF_PUNCH_IN_AIR) ? true : false;
UTIL_ViewPunch( GetAbsOrigin(), m_angViewPunch, m_flRadius, bAir );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvViewPunch::InputViewPunch( inputdata_t &inputdata )
{
DoViewPunch();
}
Reference in New Issue View Git Blame Copy Permalink