d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
532 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: abb470a471
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'abb470a471'
${ noResults }
source-engine/game/server/hl2/weapon_rpg.cpp

2376 lines
65 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "basehlcombatweapon.h"
#include "basecombatcharacter.h"
#include "movie_explosion.h"
#include "soundent.h"
#include "player.h"
#include "rope.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "explode.h"
#include "util.h"
#include "in_buttons.h"
#include "weapon_rpg.h"
#include "shake.h"
#include "ai_basenpc.h"
#include "ai_squad.h"
#include "te_effect_dispatch.h"
#include "triggers.h"
#include "smoke_trail.h"
#include "collisionutils.h"
#include "hl2_shareddefs.h"
#include "rumble_shared.h"
#include "gamestats.h"
#ifdef PORTAL
#include "portal_util_shared.h"
#endif
#ifdef HL2_DLL
extern int g_interactionPlayerLaunchedRPG;
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define RPG_SPEED 1500
static ConVar sk_apc_missile_damage("sk_apc_missile_damage", "15");
ConVar rpg_missle_use_custom_detonators( "rpg_missle_use_custom_detonators", "1" );
#define APC_MISSILE_DAMAGE sk_apc_missile_damage.GetFloat()
const char *g_pLaserDotThink = "LaserThinkContext";
//-----------------------------------------------------------------------------
// Laser Dot
//-----------------------------------------------------------------------------
class CLaserDot : public CSprite
{
DECLARE_CLASS( CLaserDot, CSprite );
public:
CLaserDot( void );
~CLaserDot( void );
static CLaserDot *Create( const Vector &origin, CBaseEntity *pOwner = NULL, bool bVisibleDot = true );
void SetTargetEntity( CBaseEntity *pTarget ) { m_hTargetEnt = pTarget; }
CBaseEntity *GetTargetEntity( void ) { return m_hTargetEnt; }
void SetLaserPosition( const Vector &origin, const Vector &normal );
Vector GetChasePosition();
void TurnOn( void );
void TurnOff( void );
bool IsOn() const { return m_bIsOn; }
void Toggle( void );
void LaserThink( void );
int ObjectCaps() { return (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_DONT_SAVE; }
void MakeInvisible( void );
protected:
Vector m_vecSurfaceNormal;
EHANDLE m_hTargetEnt;
bool m_bVisibleLaserDot;
bool m_bIsOn;
DECLARE_DATADESC();
public:
CLaserDot *m_pNext;
};
// a list of laser dots to search quickly
CEntityClassList<CLaserDot> g_LaserDotList;
template <> CLaserDot *CEntityClassList<CLaserDot>::m_pClassList = NULL;
CLaserDot *GetLaserDotList()
{
return g_LaserDotList.m_pClassList;
}
BEGIN_DATADESC( CMissile )
DEFINE_FIELD( m_hOwner, FIELD_EHANDLE ),
DEFINE_FIELD( m_hRocketTrail, FIELD_EHANDLE ),
DEFINE_FIELD( m_flAugerTime, FIELD_TIME ),
DEFINE_FIELD( m_flMarkDeadTime, FIELD_TIME ),
DEFINE_FIELD( m_flGracePeriodEndsAt, FIELD_TIME ),
DEFINE_FIELD( m_flDamage, FIELD_FLOAT ),
DEFINE_FIELD( m_bCreateDangerSounds, FIELD_BOOLEAN ),
// Function Pointers
DEFINE_FUNCTION( MissileTouch ),
DEFINE_FUNCTION( AccelerateThink ),
DEFINE_FUNCTION( AugerThink ),
DEFINE_FUNCTION( IgniteThink ),
DEFINE_FUNCTION( SeekThink ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( rpg_missile, CMissile );
class CWeaponRPG;
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CMissile::CMissile()
{
m_hRocketTrail = NULL;
m_bCreateDangerSounds = false;
}
CMissile::~CMissile()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//
//
//-----------------------------------------------------------------------------
void CMissile::Precache( void )
{
PrecacheModel( "models/weapons/w_missile.mdl" );
PrecacheModel( "models/weapons/w_missile_launch.mdl" );
PrecacheModel( "models/weapons/w_missile_closed.mdl" );
}
//-----------------------------------------------------------------------------
// Purpose:
//
//
//-----------------------------------------------------------------------------
void CMissile::Spawn( void )
{
Precache();
SetSolid( SOLID_BBOX );
SetModel("models/weapons/w_missile_launch.mdl");
UTIL_SetSize( this, -Vector(4,4,4), Vector(4,4,4) );
SetTouch( &CMissile::MissileTouch );
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
SetThink( &CMissile::IgniteThink );
SetNextThink( gpGlobals->curtime + 0.3f );
SetDamage( 200.0f );
m_takedamage = DAMAGE_YES;
m_iHealth = m_iMaxHealth = 100;
m_bloodColor = DONT_BLEED;
m_flGracePeriodEndsAt = 0;
AddFlag( FL_OBJECT );
}
//---------------------------------------------------------
//---------------------------------------------------------
void CMissile::Event_Killed( const CTakeDamageInfo &info )
{
m_takedamage = DAMAGE_NO;
ShotDown();
}
unsigned int CMissile::PhysicsSolidMaskForEntity( void ) const
{
return BaseClass::PhysicsSolidMaskForEntity() | CONTENTS_HITBOX;
}
//---------------------------------------------------------
//---------------------------------------------------------
int CMissile::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
if ( ( info.GetDamageType() & (DMG_MISSILEDEFENSE | DMG_AIRBOAT) ) == false )
return 0;
bool bIsDamaged;
if( m_iHealth <= AugerHealth() )
{
// This missile is already damaged (i.e., already running AugerThink)
bIsDamaged = true;
}
else
{
// This missile isn't damaged enough to wobble in flight yet
bIsDamaged = false;
}
int nRetVal = BaseClass::OnTakeDamage_Alive( info );
if( !bIsDamaged )
{
if ( m_iHealth <= AugerHealth() )
{
ShotDown();
}
}
return nRetVal;
}
//-----------------------------------------------------------------------------
// Purpose: Stops any kind of tracking and shoots dumb
//-----------------------------------------------------------------------------
void CMissile::DumbFire( void )
{
SetThink( NULL );
SetMoveType( MOVETYPE_FLY );
SetModel("models/weapons/w_missile.mdl");
UTIL_SetSize( this, vec3_origin, vec3_origin );
EmitSound( "Missile.Ignite" );
// Smoke trail.
CreateSmokeTrail();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMissile::SetGracePeriod( float flGracePeriod )
{
m_flGracePeriodEndsAt = gpGlobals->curtime + flGracePeriod;
// Go non-solid until the grace period ends
AddSolidFlags( FSOLID_NOT_SOLID );
}
//---------------------------------------------------------
//---------------------------------------------------------
void CMissile::AccelerateThink( void )
{
Vector vecForward;
// !!!UNDONE - make this work exactly the same as HL1 RPG, lest we have looping sound bugs again!
EmitSound( "Missile.Accelerate" );
// SetEffects( EF_LIGHT );
AngleVectors( GetLocalAngles(), &vecForward );
SetAbsVelocity( vecForward * RPG_SPEED );
SetThink( &CMissile::SeekThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
#define AUGER_YDEVIANCE 20.0f
#define AUGER_XDEVIANCEUP 8.0f
#define AUGER_XDEVIANCEDOWN 1.0f
//---------------------------------------------------------
//---------------------------------------------------------
void CMissile::AugerThink( void )
{
// If we've augered long enough, then just explode
if ( m_flAugerTime < gpGlobals->curtime )
{
Explode();
return;
}
if ( m_flMarkDeadTime < gpGlobals->curtime )
{
m_lifeState = LIFE_DYING;
}
QAngle angles = GetLocalAngles();
angles.y += random->RandomFloat( -AUGER_YDEVIANCE, AUGER_YDEVIANCE );
angles.x += random->RandomFloat( -AUGER_XDEVIANCEDOWN, AUGER_XDEVIANCEUP );
SetLocalAngles( angles );
Vector vecForward;
AngleVectors( GetLocalAngles(), &vecForward );
SetAbsVelocity( vecForward * 1000.0f );
SetNextThink( gpGlobals->curtime + 0.05f );
}
//-----------------------------------------------------------------------------
// Purpose: Causes the missile to spiral to the ground and explode, due to damage
//-----------------------------------------------------------------------------
void CMissile::ShotDown( void )
{
CEffectData data;
data.m_vOrigin = GetAbsOrigin();
DispatchEffect( "RPGShotDown", data );
if ( m_hRocketTrail != NULL )
{
m_hRocketTrail->m_bDamaged = true;
}
SetThink( &CMissile::AugerThink );
SetNextThink( gpGlobals->curtime );
m_flAugerTime = gpGlobals->curtime + 1.5f;
m_flMarkDeadTime = gpGlobals->curtime + 0.75;
// Let the RPG start reloading immediately
if ( m_hOwner != NULL )
{
m_hOwner->NotifyRocketDied();
m_hOwner = NULL;
}
}
//-----------------------------------------------------------------------------
// The actual explosion
//-----------------------------------------------------------------------------
void CMissile::DoExplosion( void )
{
// Explode
ExplosionCreate( GetAbsOrigin(), GetAbsAngles(), GetOwnerEntity(), GetDamage(), CMissile::EXPLOSION_RADIUS,
SF_ENVEXPLOSION_NOSPARKS | SF_ENVEXPLOSION_NODLIGHTS | SF_ENVEXPLOSION_NOSMOKE, 0.0f, this);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMissile::Explode( void )
{
// Don't explode against the skybox. Just pretend that
// the missile flies off into the distance.
Vector forward;
GetVectors( &forward, NULL, NULL );
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + forward * 16, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
m_takedamage = DAMAGE_NO;
SetSolid( SOLID_NONE );
if( tr.fraction == 1.0 || !(tr.surface.flags & SURF_SKY) )
{
DoExplosion();
}
if( m_hRocketTrail )
{
m_hRocketTrail->SetLifetime(0.1f);
m_hRocketTrail = NULL;
}
if ( m_hOwner != NULL )
{
m_hOwner->NotifyRocketDied();
m_hOwner = NULL;
}
StopSound( "Missile.Ignite" );
UTIL_Remove( this );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOther -
//-----------------------------------------------------------------------------
void CMissile::MissileTouch( CBaseEntity *pOther )
{
Assert( pOther );
// Don't touch triggers (but DO hit weapons)
if ( pOther->IsSolidFlagSet(FSOLID_TRIGGER|FSOLID_VOLUME_CONTENTS) && pOther->GetCollisionGroup() != COLLISION_GROUP_WEAPON )
{
// Some NPCs are triggers that can take damage (like antlion grubs). We should hit them.
if ( ( pOther->m_takedamage == DAMAGE_NO ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) )
return;
}
Explode();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMissile::CreateSmokeTrail( void )
{
if ( m_hRocketTrail )
return;
// Smoke trail.
if ( (m_hRocketTrail = RocketTrail::CreateRocketTrail()) != NULL )
{
m_hRocketTrail->m_Opacity = 0.2f;
m_hRocketTrail->m_SpawnRate = 100;
m_hRocketTrail->m_ParticleLifetime = 0.5f;
m_hRocketTrail->m_StartColor.Init( 0.65f, 0.65f , 0.65f );
m_hRocketTrail->m_EndColor.Init( 0.0, 0.0, 0.0 );
m_hRocketTrail->m_StartSize = 8;
m_hRocketTrail->m_EndSize = 32;
m_hRocketTrail->m_SpawnRadius = 4;
m_hRocketTrail->m_MinSpeed = 2;
m_hRocketTrail->m_MaxSpeed = 16;
m_hRocketTrail->SetLifetime( 999 );
m_hRocketTrail->FollowEntity( this, "0" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMissile::IgniteThink( void )
{
SetMoveType( MOVETYPE_FLY );
SetModel("models/weapons/w_missile.mdl");
UTIL_SetSize( this, vec3_origin, vec3_origin );
RemoveSolidFlags( FSOLID_NOT_SOLID );
//TODO: Play opening sound
Vector vecForward;
EmitSound( "Missile.Ignite" );
AngleVectors( GetLocalAngles(), &vecForward );
SetAbsVelocity( vecForward * RPG_SPEED );
SetThink( &CMissile::SeekThink );
SetNextThink( gpGlobals->curtime );
if ( m_hOwner && m_hOwner->GetOwner() )
{
CBasePlayer *pPlayer = ToBasePlayer( m_hOwner->GetOwner() );
if ( pPlayer )
{
color32 white = { 255,225,205,64 };
UTIL_ScreenFade( pPlayer, white, 0.1f, 0.0f, FFADE_IN );
pPlayer->RumbleEffect( RUMBLE_RPG_MISSILE, 0, RUMBLE_FLAG_RESTART );
}
}
CreateSmokeTrail();
}
//-----------------------------------------------------------------------------
// Gets the shooting position
//-----------------------------------------------------------------------------
void CMissile::GetShootPosition( CLaserDot *pLaserDot, Vector *pShootPosition )
{
if ( pLaserDot->GetOwnerEntity() != NULL )
{
//FIXME: Do we care this isn't exactly the muzzle position?
*pShootPosition = pLaserDot->GetOwnerEntity()->WorldSpaceCenter();
}
else
{
*pShootPosition = pLaserDot->GetChasePosition();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#define RPG_HOMING_SPEED 0.125f
void CMissile::ComputeActualDotPosition( CLaserDot *pLaserDot, Vector *pActualDotPosition, float *pHomingSpeed )
{
*pHomingSpeed = RPG_HOMING_SPEED;
if ( pLaserDot->GetTargetEntity() )
{
*pActualDotPosition = pLaserDot->GetChasePosition();
return;
}
Vector vLaserStart;
GetShootPosition( pLaserDot, &vLaserStart );
//Get the laser's vector
Vector vLaserDir;
VectorSubtract( pLaserDot->GetChasePosition(), vLaserStart, vLaserDir );
//Find the length of the current laser
float flLaserLength = VectorNormalize( vLaserDir );
//Find the length from the missile to the laser's owner
float flMissileLength = GetAbsOrigin().DistTo( vLaserStart );
//Find the length from the missile to the laser's position
Vector vecTargetToMissile;
VectorSubtract( GetAbsOrigin(), pLaserDot->GetChasePosition(), vecTargetToMissile );
float flTargetLength = VectorNormalize( vecTargetToMissile );
// See if we should chase the line segment nearest us
if ( ( flMissileLength < flLaserLength ) || ( flTargetLength <= 512.0f ) )
{
*pActualDotPosition = UTIL_PointOnLineNearestPoint( vLaserStart, pLaserDot->GetChasePosition(), GetAbsOrigin() );
*pActualDotPosition += ( vLaserDir * 256.0f );
}
else
{
// Otherwise chase the dot
*pActualDotPosition = pLaserDot->GetChasePosition();
}
// NDebugOverlay::Line( pLaserDot->GetChasePosition(), vLaserStart, 0, 255, 0, true, 0.05f );
// NDebugOverlay::Line( GetAbsOrigin(), *pActualDotPosition, 255, 0, 0, true, 0.05f );
// NDebugOverlay::Cross3D( *pActualDotPosition, -Vector(4,4,4), Vector(4,4,4), 255, 0, 0, true, 0.05f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMissile::SeekThink( void )
{
CBaseEntity *pBestDot = NULL;
float flBestDist = MAX_TRACE_LENGTH;
float dotDist;
// If we have a grace period, go solid when it ends
if ( m_flGracePeriodEndsAt )
{
if ( m_flGracePeriodEndsAt < gpGlobals->curtime )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
m_flGracePeriodEndsAt = 0;
}
}
//Search for all dots relevant to us
for( CLaserDot *pEnt = GetLaserDotList(); pEnt != NULL; pEnt = pEnt->m_pNext )
{
if ( !pEnt->IsOn() )
continue;
if ( pEnt->GetOwnerEntity() != GetOwnerEntity() )
continue;
dotDist = (GetAbsOrigin() - pEnt->GetAbsOrigin()).Length();
//Find closest
if ( dotDist < flBestDist )
{
pBestDot = pEnt;
flBestDist = dotDist;
}
}
if( hl2_episodic.GetBool() )
{
if( flBestDist <= ( GetAbsVelocity().Length() * 2.5f ) && FVisible( pBestDot->GetAbsOrigin() ) )
{
// Scare targets
CSoundEnt::InsertSound( SOUND_DANGER, pBestDot->GetAbsOrigin(), CMissile::EXPLOSION_RADIUS, 0.2f, pBestDot, SOUNDENT_CHANNEL_REPEATED_DANGER, NULL );
}
}
if ( rpg_missle_use_custom_detonators.GetBool() )
{
for ( int i = gm_CustomDetonators.Count() - 1; i >=0; --i )
{
CustomDetonator_t &detonator = gm_CustomDetonators[i];
if ( !detonator.hEntity )
{
gm_CustomDetonators.FastRemove( i );
}
else
{
const Vector &vPos = detonator.hEntity->CollisionProp()->WorldSpaceCenter();
if ( detonator.halfHeight > 0 )
{
if ( fabsf( vPos.z - GetAbsOrigin().z ) < detonator.halfHeight )
{
if ( ( GetAbsOrigin().AsVector2D() - vPos.AsVector2D() ).LengthSqr() < detonator.radiusSq )
{
Explode();
return;
}
}
}
else
{
if ( ( GetAbsOrigin() - vPos ).LengthSqr() < detonator.radiusSq )
{
Explode();
return;
}
}
}
}
}
//If we have a dot target
if ( pBestDot == NULL )
{
//Think as soon as possible
SetNextThink( gpGlobals->curtime );
return;
}
CLaserDot *pLaserDot = (CLaserDot *)pBestDot;
Vector targetPos;
float flHomingSpeed;
Vector vecLaserDotPosition;
ComputeActualDotPosition( pLaserDot, &targetPos, &flHomingSpeed );
if ( IsSimulatingOnAlternateTicks() )
flHomingSpeed *= 2;
Vector vTargetDir;
VectorSubtract( targetPos, GetAbsOrigin(), vTargetDir );
float flDist = VectorNormalize( vTargetDir );
if( pLaserDot->GetTargetEntity() != NULL && flDist <= 240.0f && hl2_episodic.GetBool() )
{
// Prevent the missile circling the Strider like a Halo in ep1_c17_06. If the missile gets within 20
// feet of a Strider, tighten up the turn speed of the missile so it can break the halo and strike. (sjb 4/27/2006)
if( pLaserDot->GetTargetEntity()->ClassMatches( "npc_strider" ) )
{
flHomingSpeed *= 1.75f;
}
}
Vector vDir = GetAbsVelocity();
float flSpeed = VectorNormalize( vDir );
Vector vNewVelocity = vDir;
if ( gpGlobals->frametime > 0.0f )
{
if ( flSpeed != 0 )
{
vNewVelocity = ( flHomingSpeed * vTargetDir ) + ( ( 1 - flHomingSpeed ) * vDir );
// This computation may happen to cancel itself out exactly. If so, slam to targetdir.
if ( VectorNormalize( vNewVelocity ) < 1e-3 )
{
vNewVelocity = (flDist != 0) ? vTargetDir : vDir;
}
}
else
{
vNewVelocity = vTargetDir;
}
}
QAngle finalAngles;
VectorAngles( vNewVelocity, finalAngles );
SetAbsAngles( finalAngles );
vNewVelocity *= flSpeed;
SetAbsVelocity( vNewVelocity );
if( GetAbsVelocity() == vec3_origin )
{
// Strange circumstances have brought this missile to halt. Just blow it up.
Explode();
return;
}
// Think as soon as possible
SetNextThink( gpGlobals->curtime );
#ifdef HL2_EPISODIC
if ( m_bCreateDangerSounds == true )
{
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + GetAbsVelocity() * 0.5, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
CSoundEnt::InsertSound( SOUND_DANGER, tr.endpos, 100, 0.2, this, SOUNDENT_CHANNEL_REPEATED_DANGER );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : &vecOrigin -
// &vecAngles -
// NULL -
//
// Output : CMissile
//-----------------------------------------------------------------------------
CMissile *CMissile::Create( const Vector &vecOrigin, const QAngle &vecAngles, edict_t *pentOwner = NULL )
{
//CMissile *pMissile = (CMissile *)CreateEntityByName("rpg_missile" );
CMissile *pMissile = (CMissile *) CBaseEntity::Create( "rpg_missile", vecOrigin, vecAngles, CBaseEntity::Instance( pentOwner ) );
pMissile->SetOwnerEntity( Instance( pentOwner ) );
pMissile->Spawn();
pMissile->AddEffects( EF_NOSHADOW );
Vector vecForward;
AngleVectors( vecAngles, &vecForward );
pMissile->SetAbsVelocity( vecForward * 300 + Vector( 0,0, 128 ) );
return pMissile;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CUtlVector<CMissile::CustomDetonator_t> CMissile::gm_CustomDetonators;
void CMissile::AddCustomDetonator( CBaseEntity *pEntity, float radius, float height )
{
int i = gm_CustomDetonators.AddToTail();
gm_CustomDetonators[i].hEntity = pEntity;
gm_CustomDetonators[i].radiusSq = Square( radius );
gm_CustomDetonators[i].halfHeight = height * 0.5f;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMissile::RemoveCustomDetonator( CBaseEntity *pEntity )
{
for ( int i = 0; i < gm_CustomDetonators.Count(); i++ )
{
if ( gm_CustomDetonators[i].hEntity == pEntity )
{
gm_CustomDetonators.FastRemove( i );
break;
}
}
}
//-----------------------------------------------------------------------------
// This entity is used to create little force boxes that the helicopter
// should avoid.
//-----------------------------------------------------------------------------
class CInfoAPCMissileHint : public CBaseEntity
{
DECLARE_DATADESC();
public:
DECLARE_CLASS( CInfoAPCMissileHint, CBaseEntity );
virtual void Spawn( );
virtual void Activate();
virtual void UpdateOnRemove();
static CBaseEntity *FindAimTarget( CBaseEntity *pMissile, const char *pTargetName,
const Vector &vecCurrentTargetPos, const Vector &vecCurrentTargetVel );
private:
EHANDLE m_hTarget;
typedef CHandle<CInfoAPCMissileHint> APCMissileHintHandle_t;
static CUtlVector< APCMissileHintHandle_t > s_APCMissileHints;
};
//-----------------------------------------------------------------------------
//
// This entity is used to create little force boxes that the helicopters should avoid.
//
//-----------------------------------------------------------------------------
CUtlVector< CInfoAPCMissileHint::APCMissileHintHandle_t > CInfoAPCMissileHint::s_APCMissileHints;
LINK_ENTITY_TO_CLASS( info_apc_missile_hint, CInfoAPCMissileHint );
BEGIN_DATADESC( CInfoAPCMissileHint )
DEFINE_FIELD( m_hTarget, FIELD_EHANDLE ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Spawn, remove
//-----------------------------------------------------------------------------
void CInfoAPCMissileHint::Spawn( )
{
SetModel( STRING( GetModelName() ) );
SetSolid( SOLID_BSP );
AddSolidFlags( FSOLID_NOT_SOLID );
AddEffects( EF_NODRAW );
}
void CInfoAPCMissileHint::Activate( )
{
BaseClass::Activate();
m_hTarget = gEntList.FindEntityByName( NULL, m_target );
if ( m_hTarget == NULL )
{
DevWarning( "%s: Could not find target '%s'!\n", GetClassname(), STRING( m_target ) );
}
else
{
s_APCMissileHints.AddToTail( this );
}
}
void CInfoAPCMissileHint::UpdateOnRemove( )
{
s_APCMissileHints.FindAndRemove( this );
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Where are how should we avoid?
//-----------------------------------------------------------------------------
#define HINT_PREDICTION_TIME 3.0f
CBaseEntity *CInfoAPCMissileHint::FindAimTarget( CBaseEntity *pMissile, const char *pTargetName,
const Vector &vecCurrentEnemyPos, const Vector &vecCurrentEnemyVel )
{
if ( !pTargetName )
return NULL;
float flOOSpeed = pMissile->GetAbsVelocity().Length();
if ( flOOSpeed != 0.0f )
{
flOOSpeed = 1.0f / flOOSpeed;
}
for ( int i = s_APCMissileHints.Count(); --i >= 0; )
{
CInfoAPCMissileHint *pHint = s_APCMissileHints[i];
if ( !pHint->NameMatches( pTargetName ) )
continue;
if ( !pHint->m_hTarget )
continue;
Vector vecMissileToHint, vecMissileToEnemy;
VectorSubtract( pHint->m_hTarget->WorldSpaceCenter(), pMissile->GetAbsOrigin(), vecMissileToHint );
VectorSubtract( vecCurrentEnemyPos, pMissile->GetAbsOrigin(), vecMissileToEnemy );
float flDistMissileToHint = VectorNormalize( vecMissileToHint );
VectorNormalize( vecMissileToEnemy );
if ( DotProduct( vecMissileToHint, vecMissileToEnemy ) < 0.866f )
continue;
// Determine when the target will be inside the volume.
// Project at most 3 seconds in advance
Vector vecRayDelta;
VectorMultiply( vecCurrentEnemyVel, HINT_PREDICTION_TIME, vecRayDelta );
BoxTraceInfo_t trace;
if ( !IntersectRayWithOBB( vecCurrentEnemyPos, vecRayDelta, pHint->CollisionProp()->CollisionToWorldTransform(),
pHint->CollisionProp()->OBBMins(), pHint->CollisionProp()->OBBMaxs(), 0.0f, &trace ))
{
continue;
}
// Determine the amount of time it would take the missile to reach the target
// If we can reach the target within the time it takes for the enemy to reach the
float tSqr = flDistMissileToHint * flOOSpeed / HINT_PREDICTION_TIME;
if ( (tSqr < (trace.t1 * trace.t1)) || (tSqr > (trace.t2 * trace.t2)) )
continue;
return pHint->m_hTarget;
}
return NULL;
}
//-----------------------------------------------------------------------------
// a list of missiles to search quickly
//-----------------------------------------------------------------------------
CEntityClassList<CAPCMissile> g_APCMissileList;
template <> CAPCMissile *CEntityClassList<CAPCMissile>::m_pClassList = NULL;
CAPCMissile *GetAPCMissileList()
{
return g_APCMissileList.m_pClassList;
}
//-----------------------------------------------------------------------------
// Finds apc missiles in cone
//-----------------------------------------------------------------------------
CAPCMissile *FindAPCMissileInCone( const Vector &vecOrigin, const Vector &vecDirection, float flAngle )
{
float flCosAngle = cos( DEG2RAD( flAngle ) );
for( CAPCMissile *pEnt = GetAPCMissileList(); pEnt != NULL; pEnt = pEnt->m_pNext )
{
if ( !pEnt->IsSolid() )
continue;
Vector vecDelta;
VectorSubtract( pEnt->GetAbsOrigin(), vecOrigin, vecDelta );
VectorNormalize( vecDelta );
float flDot = DotProduct( vecDelta, vecDirection );
if ( flDot > flCosAngle )
return pEnt;
}
return NULL;
}
//-----------------------------------------------------------------------------
//
// Specialized version of the missile
//
//-----------------------------------------------------------------------------
#define MAX_HOMING_DISTANCE 2250.0f
#define MIN_HOMING_DISTANCE 1250.0f
#define MAX_NEAR_HOMING_DISTANCE 1750.0f
#define MIN_NEAR_HOMING_DISTANCE 1000.0f
#define DOWNWARD_BLEND_TIME_START 0.2f
#define MIN_HEIGHT_DIFFERENCE 250.0f
#define MAX_HEIGHT_DIFFERENCE 550.0f
#define CORRECTION_TIME 0.2f
#define APC_LAUNCH_HOMING_SPEED 0.1f
#define APC_HOMING_SPEED 0.025f
#define HOMING_SPEED_ACCEL 0.01f
BEGIN_DATADESC( CAPCMissile )
DEFINE_FIELD( m_flReachedTargetTime, FIELD_TIME ),
DEFINE_FIELD( m_flIgnitionTime, FIELD_TIME ),
DEFINE_FIELD( m_bGuidingDisabled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hSpecificTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_strHint, FIELD_STRING ),
DEFINE_FIELD( m_flLastHomingSpeed, FIELD_FLOAT ),
// DEFINE_FIELD( m_pNext, FIELD_CLASSPTR ),
DEFINE_THINKFUNC( BeginSeekThink ),
DEFINE_THINKFUNC( AugerStartThink ),
DEFINE_THINKFUNC( ExplodeThink ),
DEFINE_THINKFUNC( APCSeekThink ),
DEFINE_FUNCTION( APCMissileTouch ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( apc_missile, CAPCMissile );
CAPCMissile *CAPCMissile::Create( const Vector &vecOrigin, const QAngle &vecAngles, const Vector &vecVelocity, CBaseEntity *pOwner )
{
CAPCMissile *pMissile = (CAPCMissile *)CBaseEntity::Create( "apc_missile", vecOrigin, vecAngles, pOwner );
pMissile->SetOwnerEntity( pOwner );
pMissile->Spawn();
pMissile->SetAbsVelocity( vecVelocity );
pMissile->AddFlag( FL_NOTARGET );
pMissile->AddEffects( EF_NOSHADOW );
return pMissile;
}
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CAPCMissile::CAPCMissile()
{
g_APCMissileList.Insert( this );
}
CAPCMissile::~CAPCMissile()
{
g_APCMissileList.Remove( this );
}
//-----------------------------------------------------------------------------
// Shared initialization code
//-----------------------------------------------------------------------------
void CAPCMissile::Init()
{
SetMoveType( MOVETYPE_FLY );
SetModel("models/weapons/w_missile.mdl");
UTIL_SetSize( this, vec3_origin, vec3_origin );
CreateSmokeTrail();
SetTouch( &CAPCMissile::APCMissileTouch );
m_flLastHomingSpeed = APC_HOMING_SPEED;
CreateDangerSounds( true );
if( g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE )
{
AddFlag( FL_AIMTARGET );
}
}
//-----------------------------------------------------------------------------
// For hitting a specific target
//-----------------------------------------------------------------------------
void CAPCMissile::AimAtSpecificTarget( CBaseEntity *pTarget )
{
m_hSpecificTarget = pTarget;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOther -
//-----------------------------------------------------------------------------
void CAPCMissile::APCMissileTouch( CBaseEntity *pOther )
{
Assert( pOther );
if ( !pOther->IsSolid() && !pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS) )
return;
Explode();
}
//-----------------------------------------------------------------------------
// Specialized version of the missile
//-----------------------------------------------------------------------------
void CAPCMissile::IgniteDelay( void )
{
m_flIgnitionTime = gpGlobals->curtime + 0.3f;
SetThink( &CAPCMissile::BeginSeekThink );
SetNextThink( m_flIgnitionTime );
Init();
AddSolidFlags( FSOLID_NOT_SOLID );
}
void CAPCMissile::AugerDelay( float flDelay )
{
m_flIgnitionTime = gpGlobals->curtime;
SetThink( &CAPCMissile::AugerStartThink );
SetNextThink( gpGlobals->curtime + flDelay );
Init();
DisableGuiding();
}
void CAPCMissile::AugerStartThink()
{
if ( m_hRocketTrail != NULL )
{
m_hRocketTrail->m_bDamaged = true;
}
m_flAugerTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 2.0f );
SetThink( &CAPCMissile::AugerThink );
SetNextThink( gpGlobals->curtime );
}
void CAPCMissile::ExplodeDelay( float flDelay )
{
m_flIgnitionTime = gpGlobals->curtime;
SetThink( &CAPCMissile::ExplodeThink );
SetNextThink( gpGlobals->curtime + flDelay );
Init();
DisableGuiding();
}
void CAPCMissile::BeginSeekThink( void )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
SetThink( &CAPCMissile::APCSeekThink );
SetNextThink( gpGlobals->curtime );
}
void CAPCMissile::APCSeekThink( void )
{
BaseClass::SeekThink();
bool bFoundDot = false;
//If we can't find a dot to follow around then just send me wherever I'm facing so I can blow up in peace.
for( CLaserDot *pEnt = GetLaserDotList(); pEnt != NULL; pEnt = pEnt->m_pNext )
{
if ( !pEnt->IsOn() )
continue;
if ( pEnt->GetOwnerEntity() != GetOwnerEntity() )
continue;
bFoundDot = true;
}
if ( bFoundDot == false )
{
Vector vDir = GetAbsVelocity();
VectorNormalize ( vDir );
SetAbsVelocity( vDir * 800 );
SetThink( NULL );
}
}
void CAPCMissile::ExplodeThink()
{
DoExplosion();
}
//-----------------------------------------------------------------------------
// Health lost at which augering starts
//-----------------------------------------------------------------------------
int CAPCMissile::AugerHealth()
{
return m_iMaxHealth - 25;
}
//-----------------------------------------------------------------------------
// Health lost at which augering starts
//-----------------------------------------------------------------------------
void CAPCMissile::DisableGuiding()
{
m_bGuidingDisabled = true;
}
//-----------------------------------------------------------------------------
// Guidance hints
//-----------------------------------------------------------------------------
void CAPCMissile::SetGuidanceHint( const char *pHintName )
{
m_strHint = MAKE_STRING( pHintName );
}
//-----------------------------------------------------------------------------
// The actual explosion
//-----------------------------------------------------------------------------
void CAPCMissile::DoExplosion( void )
{
if ( GetWaterLevel() != 0 )
{
CEffectData data;
data.m_vOrigin = WorldSpaceCenter();
data.m_flMagnitude = 128;
data.m_flScale = 128;
data.m_fFlags = 0;
DispatchEffect( "WaterSurfaceExplosion", data );
}
else
{
#ifdef HL2_EPISODIC
ExplosionCreate( GetAbsOrigin(), GetAbsAngles(), this, APC_MISSILE_DAMAGE, 100, true, 20000 );
#else
ExplosionCreate( GetAbsOrigin(), GetAbsAngles(), GetOwnerEntity(), APC_MISSILE_DAMAGE, 100, true, 20000 );
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAPCMissile::ComputeLeadingPosition( const Vector &vecShootPosition, CBaseEntity *pTarget, Vector *pLeadPosition )
{
Vector vecTarget = pTarget->BodyTarget( vecShootPosition, false );
float flShotSpeed = GetAbsVelocity().Length();
if ( flShotSpeed == 0 )
{
*pLeadPosition = vecTarget;
return;
}
Vector vecVelocity = pTarget->GetSmoothedVelocity();
vecVelocity.z = 0.0f;
float flTargetSpeed = VectorNormalize( vecVelocity );
Vector vecDelta;
VectorSubtract( vecShootPosition, vecTarget, vecDelta );
float flTargetToShooter = VectorNormalize( vecDelta );
float flCosTheta = DotProduct( vecDelta, vecVelocity );
// Law of cosines... z^2 = x^2 + y^2 - 2xy cos Theta
// where z = flShooterToPredictedTargetPosition = flShotSpeed * predicted time
// x = flTargetSpeed * predicted time
// y = flTargetToShooter
// solve for predicted time using at^2 + bt + c = 0, t = (-b +/- sqrt( b^2 - 4ac )) / 2a
float a = flTargetSpeed * flTargetSpeed - flShotSpeed * flShotSpeed;
float b = -2.0f * flTargetToShooter * flCosTheta * flTargetSpeed;
float c = flTargetToShooter * flTargetToShooter;
float flDiscrim = b*b - 4*a*c;
if (flDiscrim < 0)
{
*pLeadPosition = vecTarget;
return;
}
flDiscrim = sqrt(flDiscrim);
float t = (-b + flDiscrim) / (2.0f * a);
float t2 = (-b - flDiscrim) / (2.0f * a);
if ( t < t2 )
{
t = t2;
}
if ( t <= 0.0f )
{
*pLeadPosition = vecTarget;
return;
}
VectorMA( vecTarget, flTargetSpeed * t, vecVelocity, *pLeadPosition );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAPCMissile::ComputeActualDotPosition( CLaserDot *pLaserDot, Vector *pActualDotPosition, float *pHomingSpeed )
{
if ( m_bGuidingDisabled )
{
*pActualDotPosition = GetAbsOrigin();
*pHomingSpeed = 0.0f;
m_flLastHomingSpeed = *pHomingSpeed;
return;
}
if ( ( m_strHint != NULL_STRING ) && (!m_hSpecificTarget) )
{
Vector vecOrigin, vecVelocity;
CBaseEntity *pTarget = pLaserDot->GetTargetEntity();
if ( pTarget )
{
vecOrigin = pTarget->BodyTarget( GetAbsOrigin(), false );
vecVelocity = pTarget->GetSmoothedVelocity();
}
else
{
vecOrigin = pLaserDot->GetChasePosition();
vecVelocity = vec3_origin;
}
m_hSpecificTarget = CInfoAPCMissileHint::FindAimTarget( this, STRING( m_strHint ), vecOrigin, vecVelocity );
}
CBaseEntity *pLaserTarget = m_hSpecificTarget ? m_hSpecificTarget.Get() : pLaserDot->GetTargetEntity();
if ( !pLaserTarget )
{
BaseClass::ComputeActualDotPosition( pLaserDot, pActualDotPosition, pHomingSpeed );
m_flLastHomingSpeed = *pHomingSpeed;
return;
}
if ( pLaserTarget->ClassMatches( "npc_bullseye" ) )
{
if ( m_flLastHomingSpeed != RPG_HOMING_SPEED )
{
if (m_flLastHomingSpeed > RPG_HOMING_SPEED)
{
m_flLastHomingSpeed -= HOMING_SPEED_ACCEL * UTIL_GetSimulationInterval();
if ( m_flLastHomingSpeed < RPG_HOMING_SPEED )
{
m_flLastHomingSpeed = RPG_HOMING_SPEED;
}
}
else
{
m_flLastHomingSpeed += HOMING_SPEED_ACCEL * UTIL_GetSimulationInterval();
if ( m_flLastHomingSpeed > RPG_HOMING_SPEED )
{
m_flLastHomingSpeed = RPG_HOMING_SPEED;
}
}
}
*pHomingSpeed = m_flLastHomingSpeed;
*pActualDotPosition = pLaserTarget->WorldSpaceCenter();
return;
}
Vector vLaserStart;
GetShootPosition( pLaserDot, &vLaserStart );
*pHomingSpeed = APC_LAUNCH_HOMING_SPEED;
//Get the laser's vector
Vector vecTargetPosition = pLaserTarget->BodyTarget( GetAbsOrigin(), false );
// Compute leading position
Vector vecLeadPosition;
ComputeLeadingPosition( GetAbsOrigin(), pLaserTarget, &vecLeadPosition );
Vector vecTargetToMissile, vecTargetToShooter;
VectorSubtract( GetAbsOrigin(), vecTargetPosition, vecTargetToMissile );
VectorSubtract( vLaserStart, vecTargetPosition, vecTargetToShooter );
*pActualDotPosition = vecLeadPosition;
float flMinHomingDistance = MIN_HOMING_DISTANCE;
float flMaxHomingDistance = MAX_HOMING_DISTANCE;
float flBlendTime = gpGlobals->curtime - m_flIgnitionTime;
if ( flBlendTime > DOWNWARD_BLEND_TIME_START )
{
if ( m_flReachedTargetTime != 0.0f )
{
*pHomingSpeed = APC_HOMING_SPEED;
float flDeltaTime = clamp( gpGlobals->curtime - m_flReachedTargetTime, 0.0f, CORRECTION_TIME );
*pHomingSpeed = SimpleSplineRemapVal( flDeltaTime, 0.0f, CORRECTION_TIME, 0.2f, *pHomingSpeed );
flMinHomingDistance = SimpleSplineRemapVal( flDeltaTime, 0.0f, CORRECTION_TIME, MIN_NEAR_HOMING_DISTANCE, flMinHomingDistance );
flMaxHomingDistance = SimpleSplineRemapVal( flDeltaTime, 0.0f, CORRECTION_TIME, MAX_NEAR_HOMING_DISTANCE, flMaxHomingDistance );
}
else
{
flMinHomingDistance = MIN_NEAR_HOMING_DISTANCE;
flMaxHomingDistance = MAX_NEAR_HOMING_DISTANCE;
Vector vecDelta;
VectorSubtract( GetAbsOrigin(), *pActualDotPosition, vecDelta );
if ( vecDelta.z > MIN_HEIGHT_DIFFERENCE )
{
float flClampedHeight = clamp( vecDelta.z, MIN_HEIGHT_DIFFERENCE, MAX_HEIGHT_DIFFERENCE );
float flHeightAdjustFactor = SimpleSplineRemapVal( flClampedHeight, MIN_HEIGHT_DIFFERENCE, MAX_HEIGHT_DIFFERENCE, 0.0f, 1.0f );
vecDelta.z = 0.0f;
float flDist = VectorNormalize( vecDelta );
float flForwardOffset = 2000.0f;
if ( flDist > flForwardOffset )
{
Vector vecNewPosition;
VectorMA( GetAbsOrigin(), -flForwardOffset, vecDelta, vecNewPosition );
vecNewPosition.z = pActualDotPosition->z;
VectorLerp( *pActualDotPosition, vecNewPosition, flHeightAdjustFactor, *pActualDotPosition );
}
}
else
{
m_flReachedTargetTime = gpGlobals->curtime;
}
}
// Allows for players right at the edge of rocket range to be threatened
if ( flBlendTime > 0.6f )
{
float flTargetLength = GetAbsOrigin().DistTo( pLaserTarget->WorldSpaceCenter() );
flTargetLength = clamp( flTargetLength, flMinHomingDistance, flMaxHomingDistance );
*pHomingSpeed = SimpleSplineRemapVal( flTargetLength, flMaxHomingDistance, flMinHomingDistance, *pHomingSpeed, 0.01f );
}
}
float flDot = DotProduct2D( vecTargetToShooter.AsVector2D(), vecTargetToMissile.AsVector2D() );
if ( ( flDot < 0 ) || m_bGuidingDisabled )
{
*pHomingSpeed = 0.0f;
}
m_flLastHomingSpeed = *pHomingSpeed;
// NDebugOverlay::Line( vecLeadPosition, GetAbsOrigin(), 0, 255, 0, true, 0.05f );
// NDebugOverlay::Line( GetAbsOrigin(), *pActualDotPosition, 255, 0, 0, true, 0.05f );
// NDebugOverlay::Cross3D( *pActualDotPosition, -Vector(4,4,4), Vector(4,4,4), 255, 0, 0, true, 0.05f );
}
#define RPG_BEAM_SPRITE "effects/laser1_noz.vmt"
#define RPG_LASER_SPRITE "sprites/redglow1.vmt"
//=============================================================================
// RPG
//=============================================================================
BEGIN_DATADESC( CWeaponRPG )
DEFINE_FIELD( m_bInitialStateUpdate,FIELD_BOOLEAN ),
DEFINE_FIELD( m_bGuiding, FIELD_BOOLEAN ),
DEFINE_FIELD( m_vecNPCLaserDot, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_hLaserDot, FIELD_EHANDLE ),
DEFINE_FIELD( m_hMissile, FIELD_EHANDLE ),
DEFINE_FIELD( m_hLaserMuzzleSprite, FIELD_EHANDLE ),
DEFINE_FIELD( m_hLaserBeam, FIELD_EHANDLE ),
DEFINE_FIELD( m_bHideGuiding, FIELD_BOOLEAN ),
END_DATADESC()
IMPLEMENT_SERVERCLASS_ST(CWeaponRPG, DT_WeaponRPG)
END_SEND_TABLE()
LINK_ENTITY_TO_CLASS( weapon_rpg, CWeaponRPG );
PRECACHE_WEAPON_REGISTER(weapon_rpg);
acttable_t CWeaponRPG::m_acttable[] =
{
{ ACT_RANGE_ATTACK1, ACT_RANGE_ATTACK_RPG, true },
{ ACT_IDLE_RELAXED, ACT_IDLE_RPG_RELAXED, true },
{ ACT_IDLE_STIMULATED, ACT_IDLE_ANGRY_RPG, true },
{ ACT_IDLE_AGITATED, ACT_IDLE_ANGRY_RPG, true },
{ ACT_IDLE, ACT_IDLE_RPG, true },
{ ACT_IDLE_ANGRY, ACT_IDLE_ANGRY_RPG, true },
{ ACT_WALK, ACT_WALK_RPG, true },
{ ACT_WALK_CROUCH, ACT_WALK_CROUCH_RPG, true },
{ ACT_RUN, ACT_RUN_RPG, true },
{ ACT_RUN_CROUCH, ACT_RUN_CROUCH_RPG, true },
{ ACT_COVER_LOW, ACT_COVER_LOW_RPG, true },
};
IMPLEMENT_ACTTABLE(CWeaponRPG);
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CWeaponRPG::CWeaponRPG()
{
m_bReloadsSingly = true;
m_bInitialStateUpdate= false;
m_bHideGuiding = false;
m_bGuiding = false;
m_fMinRange1 = m_fMinRange2 = 40*12;
m_fMaxRange1 = m_fMaxRange2 = 500*12;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CWeaponRPG::~CWeaponRPG()
{
if ( m_hLaserDot != NULL )
{
UTIL_Remove( m_hLaserDot );
m_hLaserDot = NULL;
}
if ( m_hLaserMuzzleSprite )
{
UTIL_Remove( m_hLaserMuzzleSprite );
}
if ( m_hLaserBeam )
{
UTIL_Remove( m_hLaserBeam );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::Precache( void )
{
BaseClass::Precache();
PrecacheScriptSound( "Missile.Ignite" );
PrecacheScriptSound( "Missile.Accelerate" );
// Laser dot...
PrecacheModel( "sprites/redglow1.vmt" );
PrecacheModel( RPG_LASER_SPRITE );
PrecacheModel( RPG_BEAM_SPRITE );
UTIL_PrecacheOther( "rpg_missile" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::Activate( void )
{
BaseClass::Activate();
// Restore the laser pointer after transition
if ( m_bGuiding )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
if ( pOwner->GetActiveWeapon() == this )
{
StartGuiding();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEvent -
// *pOperator -
//-----------------------------------------------------------------------------
void CWeaponRPG::Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator )
{
switch( pEvent->event )
{
case EVENT_WEAPON_SMG1:
{
if ( m_hMissile != NULL )
return;
Vector muzzlePoint;
QAngle vecAngles;
muzzlePoint = GetOwner()->Weapon_ShootPosition();
CAI_BaseNPC *npc = pOperator->MyNPCPointer();
ASSERT( npc != NULL );
Vector vecShootDir = npc->GetActualShootTrajectory( muzzlePoint );
// look for a better launch location
Vector altLaunchPoint;
if (GetAttachment( "missile", altLaunchPoint ))
{
// check to see if it's relativly free
trace_t tr;
AI_TraceHull( altLaunchPoint, altLaunchPoint + vecShootDir * (10.0f*12.0f), Vector( -24, -24, -24 ), Vector( 24, 24, 24 ), MASK_NPCSOLID, NULL, &tr );
if( tr.fraction == 1.0)
{
muzzlePoint = altLaunchPoint;
}
}
VectorAngles( vecShootDir, vecAngles );
m_hMissile = CMissile::Create( muzzlePoint, vecAngles, GetOwner()->edict() );
m_hMissile->m_hOwner = this;
// NPCs always get a grace period
m_hMissile->SetGracePeriod( 0.5 );
pOperator->DoMuzzleFlash();
WeaponSound( SINGLE_NPC );
// Make sure our laserdot is off
m_bGuiding = false;
if ( m_hLaserDot )
{
m_hLaserDot->TurnOff();
}
}
break;
default:
BaseClass::Operator_HandleAnimEvent( pEvent, pOperator );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponRPG::HasAnyAmmo( void )
{
if ( m_hMissile != NULL )
return true;
return BaseClass::HasAnyAmmo();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponRPG::WeaponShouldBeLowered( void )
{
// Lower us if we're out of ammo
if ( !HasAnyAmmo() )
return true;
return BaseClass::WeaponShouldBeLowered();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::PrimaryAttack( void )
{
// Can't have an active missile out
if ( m_hMissile != NULL )
return;
// Can't be reloading
if ( GetActivity() == ACT_VM_RELOAD )
return;
Vector vecOrigin;
Vector vecForward;
m_flNextPrimaryAttack = gpGlobals->curtime + 0.5f;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
Vector vForward, vRight, vUp;
pOwner->EyeVectors( &vForward, &vRight, &vUp );
Vector muzzlePoint = pOwner->Weapon_ShootPosition() + vForward * 12.0f + vRight * 6.0f + vUp * -3.0f;
QAngle vecAngles;
VectorAngles( vForward, vecAngles );
m_hMissile = CMissile::Create( muzzlePoint, vecAngles, GetOwner()->edict() );
m_hMissile->m_hOwner = this;
// If the shot is clear to the player, give the missile a grace period
trace_t tr;
Vector vecEye = pOwner->EyePosition();
UTIL_TraceLine( vecEye, vecEye + vForward * 128, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0 )
{
m_hMissile->SetGracePeriod( 0.3 );
}
DecrementAmmo( GetOwner() );
// Register a muzzleflash for the AI
pOwner->SetMuzzleFlashTime( gpGlobals->curtime + 0.5 );
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
WeaponSound( SINGLE );
pOwner->RumbleEffect( RUMBLE_SHOTGUN_SINGLE, 0, RUMBLE_FLAG_RESTART );
m_iPrimaryAttacks++;
gamestats->Event_WeaponFired( pOwner, true, GetClassname() );
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 1000, 0.2, GetOwner(), SOUNDENT_CHANNEL_WEAPON );
// Check to see if we should trigger any RPG firing triggers
int iCount = g_hWeaponFireTriggers.Count();
for ( int i = 0; i < iCount; i++ )
{
if ( g_hWeaponFireTriggers[i]->IsTouching( pOwner ) )
{
if ( FClassnameIs( g_hWeaponFireTriggers[i], "trigger_rpgfire" ) )
{
g_hWeaponFireTriggers[i]->ActivateMultiTrigger( pOwner );
}
}
}
if( hl2_episodic.GetBool() )
{
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
int nAIs = g_AI_Manager.NumAIs();
string_t iszStriderClassname = AllocPooledString( "npc_strider" );
for ( int i = 0; i < nAIs; i++ )
{
if( ppAIs[ i ]->m_iClassname == iszStriderClassname )
{
ppAIs[ i ]->DispatchInteraction( g_interactionPlayerLaunchedRPG, NULL, m_hMissile );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOwner -
//-----------------------------------------------------------------------------
void CWeaponRPG::DecrementAmmo( CBaseCombatCharacter *pOwner )
{
// Take away our primary ammo type
pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : state -
//-----------------------------------------------------------------------------
void CWeaponRPG::SuppressGuiding( bool state )
{
m_bHideGuiding = state;
if ( m_hLaserDot == NULL )
{
StartGuiding();
//STILL!?
if ( m_hLaserDot == NULL )
return;
}
if ( state )
{
m_hLaserDot->TurnOff();
}
else
{
m_hLaserDot->TurnOn();
}
}
//-----------------------------------------------------------------------------
// Purpose: Override this if we're guiding a missile currently
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponRPG::Lower( void )
{
if ( m_hMissile != NULL )
return false;
return BaseClass::Lower();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::ItemPostFrame( void )
{
BaseClass::ItemPostFrame();
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( pPlayer == NULL )
return;
//If we're pulling the weapon out for the first time, wait to draw the laser
if ( ( m_bInitialStateUpdate ) && ( GetActivity() != ACT_VM_DRAW ) )
{
StartGuiding();
m_bInitialStateUpdate = false;
}
// Supress our guiding effects if we're lowered
if ( GetIdealActivity() == ACT_VM_IDLE_LOWERED || GetIdealActivity() == ACT_VM_RELOAD )
{
SuppressGuiding();
}
else
{
SuppressGuiding( false );
}
//Player has toggled guidance state
//Adrian: Players are not allowed to remove the laser guide in single player anymore, bye!
if ( g_pGameRules->IsMultiplayer() == true )
{
if ( pPlayer->m_afButtonPressed & IN_ATTACK2 )
{
ToggleGuiding();
}
}
//Move the laser
UpdateLaserPosition();
UpdateLaserEffects();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Vector
//-----------------------------------------------------------------------------
Vector CWeaponRPG::GetLaserPosition( void )
{
CreateLaserPointer();
if ( m_hLaserDot != NULL )
return m_hLaserDot->GetAbsOrigin();
//FIXME: The laser dot sprite is not active, this code should not be allowed!
assert(0);
return vec3_origin;
}
//-----------------------------------------------------------------------------
// Purpose: NPC RPG users cheat and directly set the laser pointer's origin
// Input : &vecTarget -
//-----------------------------------------------------------------------------
void CWeaponRPG::UpdateNPCLaserPosition( const Vector &vecTarget )
{
CreateLaserPointer();
// Turn the laserdot on
m_bGuiding = true;
m_hLaserDot->TurnOn();
Vector muzzlePoint = GetOwner()->Weapon_ShootPosition();
Vector vecDir = (vecTarget - muzzlePoint);
VectorNormalize( vecDir );
vecDir = muzzlePoint + ( vecDir * MAX_TRACE_LENGTH );
UpdateLaserPosition( muzzlePoint, vecDir );
SetNPCLaserPosition( vecTarget );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::SetNPCLaserPosition( const Vector &vecTarget )
{
m_vecNPCLaserDot = vecTarget;
//NDebugOverlay::Box( m_vecNPCLaserDot, -Vector(10,10,10), Vector(10,10,10), 255,0,0, 8, 3 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const Vector &CWeaponRPG::GetNPCLaserPosition( void )
{
return m_vecNPCLaserDot;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true if the rocket is being guided, false if it's dumb
//-----------------------------------------------------------------------------
bool CWeaponRPG::IsGuiding( void )
{
return m_bGuiding;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponRPG::Deploy( void )
{
m_bInitialStateUpdate = true;
return BaseClass::Deploy();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponRPG::Holster( CBaseCombatWeapon *pSwitchingTo )
{
//Can't have an active missile out
if ( m_hMissile != NULL )
return false;
StopGuiding();
return BaseClass::Holster( pSwitchingTo );
}
//-----------------------------------------------------------------------------
// Purpose: Turn on the guiding laser
//-----------------------------------------------------------------------------
void CWeaponRPG::StartGuiding( void )
{
// Don't start back up if we're overriding this
if ( m_bHideGuiding )
return;
m_bGuiding = true;
WeaponSound(SPECIAL1);
CreateLaserPointer();
StartLaserEffects();
}
//-----------------------------------------------------------------------------
// Purpose: Turn off the guiding laser
//-----------------------------------------------------------------------------
void CWeaponRPG::StopGuiding( void )
{
m_bGuiding = false;
WeaponSound( SPECIAL2 );
StopLaserEffects();
// Kill the dot completely
if ( m_hLaserDot != NULL )
{
m_hLaserDot->TurnOff();
UTIL_Remove( m_hLaserDot );
m_hLaserDot = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Toggle the guiding laser
//-----------------------------------------------------------------------------
void CWeaponRPG::ToggleGuiding( void )
{
if ( IsGuiding() )
{
StopGuiding();
}
else
{
StartGuiding();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::Drop( const Vector &vecVelocity )
{
StopGuiding();
BaseClass::Drop( vecVelocity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::UpdateLaserPosition( Vector vecMuzzlePos, Vector vecEndPos )
{
if ( vecMuzzlePos == vec3_origin || vecEndPos == vec3_origin )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
return;
vecMuzzlePos = pPlayer->Weapon_ShootPosition();
Vector forward;
if( g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE )
{
forward = pPlayer->GetAutoaimVector( AUTOAIM_SCALE_DEFAULT );
}
else
{
pPlayer->EyeVectors( &forward );
}
vecEndPos = vecMuzzlePos + ( forward * MAX_TRACE_LENGTH );
}
//Move the laser dot, if active
trace_t tr;
// Trace out for the endpoint
#ifdef PORTAL
g_bBulletPortalTrace = true;
Ray_t rayLaser;
rayLaser.Init( vecMuzzlePos, vecEndPos );
UTIL_Portal_TraceRay( rayLaser, (MASK_SHOT & ~CONTENTS_WINDOW), this, COLLISION_GROUP_NONE, &tr );
g_bBulletPortalTrace = false;
#else
UTIL_TraceLine( vecMuzzlePos, vecEndPos, (MASK_SHOT & ~CONTENTS_WINDOW), this, COLLISION_GROUP_NONE, &tr );
#endif
// Move the laser sprite
if ( m_hLaserDot != NULL )
{
Vector laserPos = tr.endpos;
m_hLaserDot->SetLaserPosition( laserPos, tr.plane.normal );
if ( tr.DidHitNonWorldEntity() )
{
CBaseEntity *pHit = tr.m_pEnt;
if ( ( pHit != NULL ) && ( pHit->m_takedamage ) )
{
m_hLaserDot->SetTargetEntity( pHit );
}
else
{
m_hLaserDot->SetTargetEntity( NULL );
}
}
else
{
m_hLaserDot->SetTargetEntity( NULL );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::CreateLaserPointer( void )
{
if ( m_hLaserDot != NULL )
return;
m_hLaserDot = CLaserDot::Create( GetAbsOrigin(), GetOwnerEntity() );
m_hLaserDot->TurnOff();
UpdateLaserPosition();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponRPG::NotifyRocketDied( void )
{
m_hMissile = NULL;
Reload();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponRPG::Reload( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return false;
if ( pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
return false;
WeaponSound( RELOAD );
SendWeaponAnim( ACT_VM_RELOAD );
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CWeaponRPG::WeaponLOSCondition( const Vector &ownerPos, const Vector &targetPos, bool bSetConditions )
{
bool bResult = BaseClass::WeaponLOSCondition( ownerPos, targetPos, bSetConditions );
if( bResult )
{
CAI_BaseNPC* npcOwner = GetOwner()->MyNPCPointer();
if( npcOwner )
{
trace_t tr;
Vector vecRelativeShootPosition;
VectorSubtract( npcOwner->Weapon_ShootPosition(), npcOwner->GetAbsOrigin(), vecRelativeShootPosition );
Vector vecMuzzle = ownerPos + vecRelativeShootPosition;
Vector vecShootDir = npcOwner->GetActualShootTrajectory( vecMuzzle );
// Make sure I have a good 10 feet of wide clearance in front, or I'll blow my teeth out.
AI_TraceHull( vecMuzzle, vecMuzzle + vecShootDir * (10.0f*12.0f), Vector( -24, -24, -24 ), Vector( 24, 24, 24 ), MASK_NPCSOLID, NULL, &tr );
if( tr.fraction != 1.0f )
bResult = false;
}
}
return bResult;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flDot -
// flDist -
// Output : int
//-----------------------------------------------------------------------------
int CWeaponRPG::WeaponRangeAttack1Condition( float flDot, float flDist )
{
if ( m_hMissile != NULL )
return 0;
// Ignore vertical distance when doing our RPG distance calculations
CAI_BaseNPC *pNPC = GetOwner()->MyNPCPointer();
if ( pNPC )
{
CBaseEntity *pEnemy = pNPC->GetEnemy();
Vector vecToTarget = (pEnemy->GetAbsOrigin() - pNPC->GetAbsOrigin());
vecToTarget.z = 0;
flDist = vecToTarget.Length();
}
if ( flDist < MIN( m_fMinRange1, m_fMinRange2 ) )
return COND_TOO_CLOSE_TO_ATTACK;
if ( m_flNextPrimaryAttack > gpGlobals->curtime )
return 0;
// See if there's anyone in the way!
CAI_BaseNPC *pOwner = GetOwner()->MyNPCPointer();
ASSERT( pOwner != NULL );
if( pOwner )
{
// Make sure I don't shoot the world!
trace_t tr;
Vector vecMuzzle = pOwner->Weapon_ShootPosition();
Vector vecShootDir = pOwner->GetActualShootTrajectory( vecMuzzle );
// Make sure I have a good 10 feet of wide clearance in front, or I'll blow my teeth out.
AI_TraceHull( vecMuzzle, vecMuzzle + vecShootDir * (10.0f*12.0f), Vector( -24, -24, -24 ), Vector( 24, 24, 24 ), MASK_NPCSOLID, NULL, &tr );
if( tr.fraction != 1.0 )
{
return COND_WEAPON_SIGHT_OCCLUDED;
}
}
return COND_CAN_RANGE_ATTACK1;
}
//-----------------------------------------------------------------------------
// Purpose: Start the effects on the viewmodel of the RPG
//-----------------------------------------------------------------------------
void CWeaponRPG::StartLaserEffects( void )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
CBaseViewModel *pBeamEnt = static_cast<CBaseViewModel *>(pOwner->GetViewModel());
if ( m_hLaserBeam == NULL )
{
m_hLaserBeam = CBeam::BeamCreate( RPG_BEAM_SPRITE, 1.0f );
if ( m_hLaserBeam == NULL )
{
// We were unable to create the beam
Assert(0);
return;
}
m_hLaserBeam->EntsInit( pBeamEnt, pBeamEnt );
int startAttachment = LookupAttachment( "laser" );
int endAttachment = LookupAttachment( "laser_end" );
m_hLaserBeam->FollowEntity( pBeamEnt );
m_hLaserBeam->SetStartAttachment( startAttachment );
m_hLaserBeam->SetEndAttachment( endAttachment );
m_hLaserBeam->SetNoise( 0 );
m_hLaserBeam->SetColor( 255, 0, 0 );
m_hLaserBeam->SetScrollRate( 0 );
m_hLaserBeam->SetWidth( 0.5f );
m_hLaserBeam->SetEndWidth( 0.5f );
m_hLaserBeam->SetBrightness( 128 );
m_hLaserBeam->SetBeamFlags( SF_BEAM_SHADEIN );
#ifdef PORTAL
m_hLaserBeam->m_bDrawInMainRender = true;
m_hLaserBeam->m_bDrawInPortalRender = false;
#endif
}
else
{
m_hLaserBeam->SetBrightness( 128 );
}
if ( m_hLaserMuzzleSprite == NULL )
{
m_hLaserMuzzleSprite = CSprite::SpriteCreate( RPG_LASER_SPRITE, GetAbsOrigin(), false );
if ( m_hLaserMuzzleSprite == NULL )
{
// We were unable to create the sprite
Assert(0);
return;
}
#ifdef PORTAL
m_hLaserMuzzleSprite->m_bDrawInMainRender = true;
m_hLaserMuzzleSprite->m_bDrawInPortalRender = false;
#endif
m_hLaserMuzzleSprite->SetAttachment( pOwner->GetViewModel(), LookupAttachment( "laser" ) );
m_hLaserMuzzleSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxNoDissipation );
m_hLaserMuzzleSprite->SetBrightness( 255, 0.5f );
m_hLaserMuzzleSprite->SetScale( 0.25f, 0.5f );
m_hLaserMuzzleSprite->TurnOn();
}
else
{
m_hLaserMuzzleSprite->TurnOn();
m_hLaserMuzzleSprite->SetScale( 0.25f, 0.25f );
m_hLaserMuzzleSprite->SetBrightness( 255 );
}
}
//-----------------------------------------------------------------------------
// Purpose: Stop the effects on the viewmodel of the RPG
//-----------------------------------------------------------------------------
void CWeaponRPG::StopLaserEffects( void )
{
if ( m_hLaserBeam != NULL )
{
m_hLaserBeam->SetBrightness( 0 );
}
if ( m_hLaserMuzzleSprite != NULL )
{
m_hLaserMuzzleSprite->SetScale( 0.01f );
m_hLaserMuzzleSprite->SetBrightness( 0, 0.5f );
}
}
//-----------------------------------------------------------------------------
// Purpose: Pulse all the effects to make them more... well, laser-like
//-----------------------------------------------------------------------------
void CWeaponRPG::UpdateLaserEffects( void )
{
if ( !m_bGuiding )
return;
if ( m_hLaserBeam != NULL )
{
m_hLaserBeam->SetBrightness( 128 + random->RandomInt( -8, 8 ) );
}
if ( m_hLaserMuzzleSprite != NULL )
{
m_hLaserMuzzleSprite->SetScale( 0.1f + random->RandomFloat( -0.025f, 0.025f ) );
}
}
//=============================================================================
// Laser Dot
//=============================================================================
LINK_ENTITY_TO_CLASS( env_laserdot, CLaserDot );
BEGIN_DATADESC( CLaserDot )
DEFINE_FIELD( m_vecSurfaceNormal, FIELD_VECTOR ),
DEFINE_FIELD( m_hTargetEnt, FIELD_EHANDLE ),
DEFINE_FIELD( m_bVisibleLaserDot, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bIsOn, FIELD_BOOLEAN ),
//DEFINE_FIELD( m_pNext, FIELD_CLASSPTR ), // don't save - regenerated by constructor
DEFINE_THINKFUNC( LaserThink ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Finds missiles in cone
//-----------------------------------------------------------------------------
CBaseEntity *CreateLaserDot( const Vector &origin, CBaseEntity *pOwner, bool bVisibleDot )
{
return CLaserDot::Create( origin, pOwner, bVisibleDot );
}
void SetLaserDotTarget( CBaseEntity *pLaserDot, CBaseEntity *pTarget )
{
CLaserDot *pDot = assert_cast< CLaserDot* >(pLaserDot );
pDot->SetTargetEntity( pTarget );
}
void EnableLaserDot( CBaseEntity *pLaserDot, bool bEnable )
{
CLaserDot *pDot = assert_cast< CLaserDot* >(pLaserDot );
if ( bEnable )
{
pDot->TurnOn();
}
else
{
pDot->TurnOff();
}
}
CLaserDot::CLaserDot( void )
{
m_hTargetEnt = NULL;
m_bIsOn = true;
g_LaserDotList.Insert( this );
}
CLaserDot::~CLaserDot( void )
{
g_LaserDotList.Remove( this );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &origin -
// Output : CLaserDot
//-----------------------------------------------------------------------------
CLaserDot *CLaserDot::Create( const Vector &origin, CBaseEntity *pOwner, bool bVisibleDot )
{
CLaserDot *pLaserDot = (CLaserDot *) CBaseEntity::Create( "env_laserdot", origin, QAngle(0,0,0) );
if ( pLaserDot == NULL )
return NULL;
pLaserDot->m_bVisibleLaserDot = bVisibleDot;
pLaserDot->SetMoveType( MOVETYPE_NONE );
pLaserDot->AddSolidFlags( FSOLID_NOT_SOLID );
pLaserDot->AddEffects( EF_NOSHADOW );
UTIL_SetSize( pLaserDot, vec3_origin, vec3_origin );
//Create the graphic
pLaserDot->SpriteInit( "sprites/redglow1.vmt", origin );
pLaserDot->SetName( AllocPooledString("TEST") );
pLaserDot->SetTransparency( kRenderGlow, 255, 255, 255, 255, kRenderFxNoDissipation );
pLaserDot->SetScale( 0.5f );
pLaserDot->SetOwnerEntity( pOwner );
pLaserDot->SetContextThink( &CLaserDot::LaserThink, gpGlobals->curtime + 0.1f, g_pLaserDotThink );
pLaserDot->SetSimulatedEveryTick( true );
if ( !bVisibleDot )
{
pLaserDot->MakeInvisible();
}
return pLaserDot;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CLaserDot::LaserThink( void )
{
SetNextThink( gpGlobals->curtime + 0.05f, g_pLaserDotThink );
if ( GetOwnerEntity() == NULL )
return;
Vector viewDir = GetAbsOrigin() - GetOwnerEntity()->GetAbsOrigin();
float dist = VectorNormalize( viewDir );
float scale = RemapVal( dist, 32, 1024, 0.01f, 0.5f );
float scaleOffs = random->RandomFloat( -scale * 0.25f, scale * 0.25f );
scale = clamp( scale + scaleOffs, 0.1f, 32.0f );
SetScale( scale );
}
void CLaserDot::SetLaserPosition( const Vector &origin, const Vector &normal )
{
SetAbsOrigin( origin );
m_vecSurfaceNormal = normal;
}
Vector CLaserDot::GetChasePosition()
{
return GetAbsOrigin() - m_vecSurfaceNormal * 10;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CLaserDot::TurnOn( void )
{
m_bIsOn = true;
if ( m_bVisibleLaserDot )
{
BaseClass::TurnOn();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CLaserDot::TurnOff( void )
{
m_bIsOn = false;
if ( m_bVisibleLaserDot )
{
BaseClass::TurnOff();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CLaserDot::MakeInvisible( void )
{
BaseClass::TurnOff();
}