524 lines
16 KiB
C++
524 lines
16 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Sapper's draining beam
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "basetfplayer_shared.h"
|
|
#include "in_buttons.h"
|
|
#include "weapon_combatshield.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "grenade_base_empable.h"
|
|
|
|
#if defined( CLIENT_DLL )
|
|
|
|
#include "particles_simple.h"
|
|
|
|
#else
|
|
|
|
#include "tf_gamerules.h"
|
|
#include "tf_class_sapper.h"
|
|
|
|
#endif
|
|
|
|
#include "weapon_drainbeam.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
#define PARTICLE_PATH_VEL 140.0
|
|
#define NUM_PATH_PARTICLES_PER_SEC 600.0f
|
|
#define NUM_DRIBBLE_PARTICLES_PER_SEC 20.0f
|
|
|
|
#define NUM_DRAINBEAM_PATH_POINTS 8
|
|
|
|
// Buff ranges
|
|
static ConVar weapon_drainbeam_target_range( "weapon_drainbeam_target_range", "900", FCVAR_REPLICATED, "The farthest away you can be for the drain gun to initially lock onto a target." );
|
|
static ConVar weapon_drainbeam_stick_range( "weapon_drainbeam_stick_range", "612", FCVAR_REPLICATED, "How far away the drain gun can stay locked onto a target." );
|
|
static ConVar weapon_drainbeam_max_rate( "weapon_drainbeam_max_rate", "10", FCVAR_REPLICATED );
|
|
static ConVar weapon_drainbeam_max_rate_time( "weapon_drainbeam_max_rate_time", "5", FCVAR_REPLICATED );
|
|
static ConVar weapon_drainbeam_emp_time_factor( "weapon_drainbeam_emp_time_factor", "0.75", FCVAR_REPLICATED );
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( weapon_drainbeam, CWeaponDrainBeam );
|
|
|
|
PRECACHE_WEAPON_REGISTER( weapon_drainbeam );
|
|
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponDrainBeam, DT_WeaponDrainBeam )
|
|
|
|
BEGIN_NETWORK_TABLE( CWeaponDrainBeam, DT_WeaponDrainBeam )
|
|
#if !defined( CLIENT_DLL )
|
|
SendPropInt( SENDINFO( m_bDraining ), 1, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO( m_bAttacking ), 1, SPROP_UNSIGNED ),
|
|
SendPropVector( SENDINFO( m_vFireTarget ), 0, SPROP_COORD ),
|
|
SendPropEHandle( SENDINFO( m_hDrainTarget ) ),
|
|
#else
|
|
RecvPropInt( RECVINFO( m_bAttacking ) ),
|
|
RecvPropInt( RECVINFO( m_bDraining ) ),
|
|
RecvPropVector( RECVINFO(m_vFireTarget) ),
|
|
RecvPropEHandle( RECVINFO(m_hDrainTarget) ),
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_PREDICTION_DATA( CWeaponDrainBeam )
|
|
|
|
DEFINE_PRED_FIELD( m_bDraining, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_bAttacking, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD_TOL( m_vFireTarget, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.125f ),
|
|
|
|
DEFINE_PRED_FIELD( m_hDrainTarget, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
|
|
|
|
// DEFINE_PRED_FIELD( m_pEmitter, FIELD_POINTER ),
|
|
// DEFINE_PRED_FIELD( m_hParticleMaterial, FIELD_???, ),
|
|
// DEFINE_PRED_FIELD( m_PathParticleEvent, FIELD_???, ),
|
|
// DEFINE_PRED_FIELD( m_DribbleParticleEvent, FIELD_??? ),
|
|
// DEFINE_PRED_FIELD( m_bPlayingSound, FIELD_BOOLEAN ),
|
|
|
|
END_PREDICTION_DATA()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CWeaponDrainBeam::CWeaponDrainBeam( void )
|
|
{
|
|
m_bDraining = false;
|
|
m_bAttacking = false;
|
|
m_flNextBuzzTime = 0;
|
|
|
|
SetPredictionEligible( true );
|
|
#if defined( CLIENT_DLL )
|
|
m_pEmitter = NULL;
|
|
m_hParticleMaterial = INVALID_MATERIAL_HANDLE;
|
|
m_PathParticleEvent.Init( NUM_PATH_PARTICLES_PER_SEC );
|
|
m_DribbleParticleEvent.Init( NUM_DRIBBLE_PARTICLES_PER_SEC );
|
|
m_bPlayingSound = false;
|
|
#endif
|
|
}
|
|
|
|
void CWeaponDrainBeam::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
|
|
PrecacheScriptSound( "WeaponRepairGun.Healing" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CWeaponDrainBeam::Holster( CBaseCombatWeapon *pSwitchingTo )
|
|
{
|
|
RemoveDrainTarget();
|
|
|
|
return BaseClass::Holster( pSwitchingTo );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns a pointer to a drainable target
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CWeaponDrainBeam::GetTargetToDrain( CBaseEntity *pCurDrainTarget )
|
|
{
|
|
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
|
|
if ( !pOwner )
|
|
return NULL;
|
|
|
|
#if !defined( CLIENT_DLL )
|
|
Vector vecSrc = pOwner->Weapon_ShootPosition( );
|
|
|
|
// ROBIN: Disabled drainbeam locking to target
|
|
/*
|
|
// If we're already draining something, stick onto it as long as possible.
|
|
CBaseEntity *pEntity = pCurDrainTarget;
|
|
if ( pEntity && pEntity->IsAlive() )
|
|
{
|
|
// Make sure the target didn't go out of range.
|
|
Vector vecTargetCenter = pEntity->Center();
|
|
if ( (vecTargetCenter - vecSrc).Length() < weapon_drainbeam_stick_range.GetFloat() )
|
|
{
|
|
// Now make sure there isn't something other than team players in the way.
|
|
class CDrainFilter : public CTraceFilterSimple
|
|
{
|
|
public:
|
|
CDrainFilter( CBaseEntity *pShooter ) : CTraceFilterSimple( pShooter, TFCOLLISION_GROUP_WEAPON )
|
|
{
|
|
m_pShooter = pShooter;
|
|
}
|
|
|
|
virtual bool ShouldHitEntity( IServerEntity *pServerEntity, int contentsMask )
|
|
{
|
|
// If it hit an edict the isn't the target and is on our team, then the ray is blocked.
|
|
CBaseEntity *pEnt = (CBaseEntity *)pServerEntity;
|
|
|
|
// Ignore collisions with the shooter
|
|
if ( pEnt == m_pShooter )
|
|
return false;
|
|
|
|
// Ignore neutral objects
|
|
if ( pEnt->GetTeamNumber() == 0 )
|
|
return false;
|
|
|
|
// Ignore collisions with teammates
|
|
if ( pEnt->GetTeam() == m_pShooter->GetTeam() )
|
|
return false;
|
|
|
|
// Ignore players
|
|
if ( pEnt->IsPlayer() )
|
|
return false;
|
|
|
|
return CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask );
|
|
}
|
|
|
|
CBaseEntity *m_pShooter;
|
|
};
|
|
|
|
trace_t tr;
|
|
CDrainFilter drainFilter( pOwner );
|
|
engine->TraceLine( vecSrc, vecTargetCenter, MASK_SHOT, &drainFilter, &tr );
|
|
|
|
if (( tr.fraction == 1.0f) || (tr.m_pEnt == pEntity))
|
|
return pEntity;
|
|
}
|
|
|
|
// Return null so we can't target this player but m_hDrainTarget stays set to them.
|
|
return NULL;
|
|
}
|
|
else
|
|
*/
|
|
{
|
|
// Ok, try to find a new target to drain.
|
|
// Get the target point and location
|
|
Vector vecAiming;
|
|
pOwner->EyeVectors( &vecAiming );
|
|
|
|
// Find a player in range of this player, and make sure they're drainable.
|
|
Vector vecEnd = vecSrc + vecAiming * weapon_drainbeam_target_range.GetFloat();
|
|
trace_t tr;
|
|
|
|
// Use WeaponTraceLine so shields are tested...
|
|
TFGameRules()->WeaponTraceLine( vecSrc, vecEnd, MASK_SHOT & (~CONTENTS_HITBOX), pOwner, DMG_PROBE, &tr );
|
|
|
|
if ( tr.fraction != 1.0 )
|
|
{
|
|
CBaseEntity *pEntity = tr.m_pEnt;
|
|
if ( pEntity && (pEntity != pOwner) && pEntity->IsAlive() )
|
|
{
|
|
// Target needs to not be a player, take EMP damage, and needs to be an enemy
|
|
if ( !pEntity->IsPlayer() && pEntity->CanBePoweredUp() && pEntity->GetTeamNumber() != 0 && !pEntity->InSameTeam( pOwner ) )
|
|
{
|
|
// If we've just locked onto a new target, restart our drain rate
|
|
if ( pCurDrainTarget != pEntity )
|
|
{
|
|
m_flDrainStartedAt = gpGlobals->curtime;
|
|
}
|
|
return pEntity;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Overloaded to handle the hold-down draining
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::ItemPostFrame( void )
|
|
{
|
|
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
|
|
if ( !pOwner )
|
|
return;
|
|
|
|
// Try to start draining
|
|
m_bAttacking = false;
|
|
if ( (pOwner->m_nButtons & IN_ATTACK) && GetShieldState() == SS_DOWN )
|
|
{
|
|
PrimaryAttack();
|
|
m_bAttacking = true;
|
|
}
|
|
else if ( GetCurDrainTarget() )
|
|
{
|
|
// Detach from the player if they release the attack button.
|
|
RemoveDrainTarget();
|
|
}
|
|
|
|
// Prevent shield post frame if we're not ready to attack, or we're draining
|
|
AllowShieldPostFrame( !m_bAttacking );
|
|
|
|
WeaponIdle();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::RemoveDrainTarget( void )
|
|
{
|
|
m_hDrainTarget = NULL;
|
|
m_bDraining = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Attempt to drain any player within range of the medikit
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::PrimaryAttack( void )
|
|
{
|
|
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
|
|
if ( !pOwner )
|
|
return;
|
|
|
|
#if !defined( CLIENT_DLL )
|
|
// Find a target to drain
|
|
CBaseEntity *pTarget = GetTargetToDrain( GetCurDrainTarget() );
|
|
if ( pTarget )
|
|
{
|
|
// EMP the target
|
|
if ( pTarget->CanBePoweredUp() )
|
|
{
|
|
// Increase the EMP time based upon the time we spent draining
|
|
float flDrainTime = (gpGlobals->curtime - m_flDrainStartedAt);
|
|
float flPostDrainTime = weapon_drainbeam_emp_time_factor.GetFloat() * flDrainTime;
|
|
if ( pTarget->AttemptToPowerup( POWERUP_EMP, flPostDrainTime ) )
|
|
{
|
|
// Crank up the drain rate based on the time since we started draining this target
|
|
flDrainTime = MIN( weapon_drainbeam_max_rate_time.GetFloat(), flDrainTime );
|
|
float flDrainAmount = weapon_drainbeam_max_rate.GetFloat() * ( flDrainTime / weapon_drainbeam_max_rate_time.GetFloat() );
|
|
|
|
// It uses floating point in here so it doesn't lose the fractional part on small frame times.
|
|
static float flCurDamageAmt = 0.99;
|
|
float flOldDamageAmt = flCurDamageAmt;
|
|
flCurDamageAmt += gpGlobals->frametime * flDrainAmount;
|
|
int iDamage = (int)flCurDamageAmt - (int)flOldDamageAmt;
|
|
|
|
// Accumulated enough to do something?
|
|
if ( iDamage )
|
|
{
|
|
// EMPed my target, make it take damage
|
|
if ( pTarget->GetHealth() )
|
|
{
|
|
pTarget->TakeDamage( CTakeDamageInfo( this, pOwner, iDamage, DMG_GENERIC ) );
|
|
}
|
|
|
|
// Increase my health
|
|
if ( pOwner->GetHealth() < pOwner->GetMaxHealth() )
|
|
{
|
|
int maxHealthToAdd = pOwner->GetMaxHealth() - pOwner->GetHealth();
|
|
int nHealthAdded = MIN( iDamage, maxHealthToAdd );
|
|
pOwner->TakeHealth( nHealthAdded, DMG_GENERIC );
|
|
}
|
|
|
|
// If I'm a sapper, I store off the energy
|
|
if ( pOwner->IsClass( TFCLASS_SAPPER ) )
|
|
{
|
|
((CPlayerClassSapper*)pOwner->GetPlayerClass())->AddDrainedEnergy( iDamage );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tell the client who we're trying to drain.
|
|
m_bDraining = true;
|
|
m_vFireTarget = pTarget->WorldSpaceCenter();
|
|
m_hDrainTarget = pTarget;
|
|
}
|
|
else
|
|
{
|
|
RemoveDrainTarget();
|
|
}
|
|
#endif
|
|
|
|
// Fire continuously.
|
|
m_flNextPrimaryAttack = gpGlobals->curtime;
|
|
|
|
CheckRemoveDisguise();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::PlayAttackAnimation( int activity )
|
|
{
|
|
SendWeaponAnim( activity );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::WeaponIdle( void )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::GainedNewTechnology( CBaseTechnology *pTechnology )
|
|
{
|
|
}
|
|
|
|
#if defined( CLIENT_DLL )
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::StopDrainSound( bool bStopHealingSound, bool bStopNoTargetSound )
|
|
{
|
|
if ( bStopHealingSound )
|
|
StopSound( entindex(), "WeaponRepairGun.Healing" );
|
|
|
|
if ( bStopNoTargetSound )
|
|
StopSound( entindex(), "WeaponRepairGun.NoTarget" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnDataChanged( updateType );
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
m_pEmitter = CSimpleEmitter::Create( "C_WeaponDrainBeam" );
|
|
m_hParticleMaterial = m_pEmitter->GetPMaterial( "sprites/chargeball" );
|
|
|
|
ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
|
|
}
|
|
|
|
// Think?
|
|
if ( !m_bDraining )
|
|
{
|
|
m_bPlayingSound = false;
|
|
StopDrainSound( true, false );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponDrainBeam::ClientThink()
|
|
{
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// Don't show it while the player is dead. Ideally, we'd respond to m_bDraining in OnDataChanged,
|
|
// but it stops sending the weapon when it's holstered, and it gets holstered when the player dies.
|
|
C_BasePlayer *pFiringPlayer = dynamic_cast< C_BasePlayer* >( GetOwner() );
|
|
if ( !pFiringPlayer || pFiringPlayer->IsPlayerDead() )
|
|
{
|
|
m_bPlayingSound = false;
|
|
StopDrainSound();
|
|
return;
|
|
}
|
|
|
|
// Abort if we're not draining, or the player doesn't have the fire button down
|
|
if ( !m_bDraining && !m_bAttacking )
|
|
return;
|
|
|
|
// Ready for particle emission, sir
|
|
m_pEmitter->SetSortOrigin( (m_vFireTarget + pPlayer->GetAbsOrigin()) * 0.5f );
|
|
float flCur = gpGlobals->frametime;
|
|
Vector vForward, vOrigin;
|
|
QAngle vAngles;
|
|
GetShootPosition( vOrigin, vAngles );
|
|
AngleVectors( vAngles, &vForward );
|
|
|
|
// Are they holding the attack button but not draining anyone? Give feedback.
|
|
if ( !m_bDraining )
|
|
{
|
|
// Add random short-lived particles from the gun tip to the target.
|
|
while ( m_DribbleParticleEvent.NextEvent( flCur ) )
|
|
{
|
|
Vector vPos = vOrigin;
|
|
vPos += RandomVector( -2, 2 );
|
|
SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
|
|
if ( pParticle )
|
|
{
|
|
// Move the points along the path.
|
|
pParticle->m_vecVelocity = vForward;
|
|
pParticle->m_vecVelocity *= 50;
|
|
|
|
pParticle->m_flRoll = 0;
|
|
pParticle->m_flRollDelta = 0;
|
|
pParticle->m_flDieTime = 0.4f;
|
|
pParticle->m_flLifetime = 0;
|
|
pParticle->m_uchColor[0] = 255;
|
|
pParticle->m_uchColor[1] = 255;
|
|
pParticle->m_uchColor[2] = 255;
|
|
pParticle->m_uchStartAlpha = 32;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
pParticle->m_uchStartSize = 4;
|
|
pParticle->m_uchEndSize = 0;
|
|
pParticle->m_iFlags = 0;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( !m_bPlayingSound )
|
|
{
|
|
m_bPlayingSound = true;
|
|
CLocalPlayerFilter filter;
|
|
|
|
EmitSound( filter, entindex(), "WeaponRepairGun.Healing" );
|
|
}
|
|
|
|
Vector points[NUM_DRAINBEAM_PATH_POINTS];
|
|
|
|
// First generate a sequence of points so we can parameterize the (curvy) path from the
|
|
// tip of the gun to the target.
|
|
Vector vDirTo = m_vFireTarget - vOrigin;
|
|
float flDistanceTo = vDirTo.Length();
|
|
vDirTo /= flDistanceTo;
|
|
|
|
float flBendDist = flDistanceTo * 3;
|
|
const Vector A = vOrigin - vForward * flBendDist;
|
|
const Vector &B = vOrigin;
|
|
const Vector &C = m_vFireTarget;
|
|
const Vector D = m_vFireTarget - vForward * flBendDist;
|
|
|
|
for ( int i=0; i < NUM_DRAINBEAM_PATH_POINTS; i++ )
|
|
{
|
|
Catmull_Rom_Spline( A, B, C, D, (float)i / (NUM_DRAINBEAM_PATH_POINTS-1), points[i] );
|
|
}
|
|
|
|
// Add random short-lived particles from the gun tip to the target.
|
|
while ( m_PathParticleEvent.NextEvent( flCur ) )
|
|
{
|
|
float t = RandomFloat( 0, 1 );
|
|
int iPrev = (int)( t * (NUM_DRAINBEAM_PATH_POINTS - 1.001) );
|
|
float tPrev = (float)iPrev / (NUM_DRAINBEAM_PATH_POINTS - 1);
|
|
float tNext = (float)(iPrev+1) / (NUM_DRAINBEAM_PATH_POINTS - 1);
|
|
Assert( tNext <= NUM_DRAINBEAM_PATH_POINTS-1 );
|
|
|
|
Vector vPos;
|
|
VectorLerp( points[iPrev], points[iPrev+1], (t-tPrev) / (tNext - tPrev), vPos );
|
|
vPos += RandomVector( -2, 2 );
|
|
|
|
SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
|
|
if ( pParticle )
|
|
{
|
|
// Move the points along the path.
|
|
pParticle->m_vecVelocity = points[iPrev+1] - points[iPrev];
|
|
VectorNormalize( pParticle->m_vecVelocity );
|
|
pParticle->m_vecVelocity *= -PARTICLE_PATH_VEL;
|
|
|
|
pParticle->m_flRoll = 0;
|
|
pParticle->m_flRollDelta = 0;
|
|
pParticle->m_flDieTime = 0.2f;
|
|
pParticle->m_flLifetime = 0;
|
|
pParticle->m_uchColor[0] = 255;
|
|
pParticle->m_uchColor[1] = 255;
|
|
pParticle->m_uchColor[2] = 255;
|
|
pParticle->m_uchStartAlpha = 32;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
pParticle->m_uchStartSize = 4;
|
|
pParticle->m_uchEndSize = 2;
|
|
pParticle->m_iFlags = 0;
|
|
}
|
|
}
|
|
}
|
|
#endif
|