685 lines
17 KiB
C++
685 lines
17 KiB
C++
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "soundenvelope.h"
|
|
#include "entitylist.h"
|
|
#include "ai_basenpc.h"
|
|
#include "soundent.h"
|
|
#include "physics.h"
|
|
#include "physics_saverestore.h"
|
|
#include "asw_tesla_trap.h"
|
|
#include "movevars_shared.h"
|
|
#include "vphysics/constraints.h"
|
|
#include "ai_hint.h"
|
|
#include "particle_parse.h"
|
|
#include "world.h"
|
|
#include "asw_gamerules.h"
|
|
#include "asw_util_shared.h"
|
|
#include "asw_trace_filter_shot.h"
|
|
#include "asw_alien.h"
|
|
#include "asw_marine.h"
|
|
|
|
enum
|
|
{
|
|
TESLATRAP_STATE_DORMANT = 0,
|
|
TESLATRAP_STATE_DEPLOY, // Try to lock down and arm
|
|
TESLATRAP_STATE_CHARGING, // Held in the physgun
|
|
TESLATRAP_STATE_CHARGED, // Locked down and looking for targets
|
|
};
|
|
|
|
// for the Modification keyfield
|
|
enum
|
|
{
|
|
TESLATRAP_MODIFICATION_NORMAL = 0,
|
|
TESLATRAP_MODIFICATION_CAVERN,
|
|
};
|
|
|
|
// the citizen modified skins for the mine (inclusive):
|
|
#define TESLATRAP_CITIZEN_SKIN_MIN 1
|
|
#define TESLATRAP_CITIZEN_SKIN_MAX 2
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
// Approximate radius of the bomb's model
|
|
#define ASW_TESLATRAP_RADIUS 24
|
|
|
|
IMPLEMENT_SERVERCLASS_ST( CASW_TeslaTrap, DT_ASW_TeslaTrap )
|
|
SendPropInt( SENDINFO( m_iTrapState )),
|
|
SendPropInt( SENDINFO( m_iAmmo )),
|
|
SendPropInt( SENDINFO( m_iMaxAmmo )),
|
|
SendPropFloat( SENDINFO( m_flRadius )),
|
|
SendPropFloat( SENDINFO( m_flDamage )),
|
|
SendPropFloat( SENDINFO( m_flNextFullChargeTime )),
|
|
SendPropBool( SENDINFO( m_bAssembled )),
|
|
END_SEND_TABLE()
|
|
|
|
BEGIN_DATADESC( CASW_TeslaTrap )
|
|
DEFINE_ENTITYFUNC( TeslaTouch ),
|
|
DEFINE_THINKFUNC( TeslaSearchThink ),
|
|
DEFINE_THINKFUNC( TeslaChargeThink ),
|
|
DEFINE_THINKFUNC( TeslaSettleThink ),
|
|
|
|
DEFINE_SOUNDPATCH( m_pWarnSound ),
|
|
|
|
//DEFINE_KEYFIELD( m_flExplosionDelay, FIELD_FLOAT, "ExplosionDelay" ),
|
|
|
|
//DEFINE_FIELD( m_bCharged, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_hNearestNPC, FIELD_EHANDLE ),
|
|
|
|
DEFINE_KEYFIELD( m_bLockSilently, FIELD_BOOLEAN, "LockSilently" ),
|
|
DEFINE_FIELD( m_bFoeNearest, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_flIgnoreWorldTime, FIELD_TIME ),
|
|
DEFINE_KEYFIELD( m_bDisarmed, FIELD_BOOLEAN, "StartDisarmed" ),
|
|
//DEFINE_KEYFIELD( m_iModification, FIELD_INTEGER, "Modification" ),
|
|
|
|
DEFINE_FIELD( m_bPlacedByPlayer, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_iTrapState, FIELD_INTEGER ),
|
|
|
|
DEFINE_FIELD( m_flRadius, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_flDamage, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_flNextFullChargeTime, FIELD_FLOAT ),
|
|
|
|
END_DATADESC()
|
|
|
|
CUtlVector<CASW_TeslaTrap*> g_aTeslaTraps;
|
|
|
|
CASW_TeslaTrap::CASW_TeslaTrap()
|
|
{
|
|
m_pWarnSound = NULL;
|
|
m_bPlacedByPlayer = true;
|
|
g_aTeslaTraps.AddToTail( this );
|
|
m_hMarineDeployer = NULL;
|
|
m_CreatorWeaponClass = (Class_T)CLASS_ASW_UNKNOWN;
|
|
}
|
|
|
|
CASW_TeslaTrap::~CASW_TeslaTrap()
|
|
{
|
|
g_aTeslaTraps.FindAndRemove( this );
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CASW_TeslaTrap::Precache()
|
|
{
|
|
PrecacheModel( "models/items/teslaCoil/teslacoil.mdl" );
|
|
|
|
PrecacheScriptSound( "ASW_Tesla_Trap.Zap" );
|
|
}
|
|
|
|
static const char *s_pTeslaAnimThink = "TeslaAnimThink";
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CASW_TeslaTrap::Spawn()
|
|
{
|
|
Precache();
|
|
|
|
SetModel("models/items/teslaCoil/teslacoil.mdl");
|
|
|
|
UTIL_SetSize( this, Vector( -24, -24, -1 ), Vector( 24, 24, 80 ) );
|
|
SetSolid( SOLID_BBOX );
|
|
AddSolidFlags( FSOLID_NOT_STANDABLE );
|
|
|
|
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
|
|
|
|
m_takedamage = DAMAGE_YES;
|
|
|
|
SetFriction( 0.9f );
|
|
SetGravity( UTIL_ScaleForGravity( 1000 ) );
|
|
|
|
AddEffects( EF_NOSHADOW|EF_NORECEIVESHADOW );
|
|
AddFlag( FL_OBJECT );
|
|
AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL | EFL_NO_PHYSCANNON_INTERACTION );
|
|
|
|
SetCollisionGroup( ASW_COLLISION_GROUP_PASSABLE );
|
|
|
|
|
|
m_takedamage = DAMAGE_EVENTS_ONLY;
|
|
|
|
SetBloodColor( DONT_BLEED );
|
|
SetHealth( 100 );
|
|
|
|
ResetSequence( LookupSequence( "closed" ) );
|
|
|
|
//m_iModification = TESLATRAP_MODIFICATION_CAVERN;
|
|
|
|
if( !GetParent() )
|
|
{
|
|
// Create vphysics now if I'm not being carried.
|
|
CreateVPhysics();
|
|
}
|
|
|
|
if( m_bDisarmed )
|
|
{
|
|
SetTrapState( TESLATRAP_STATE_DORMANT );
|
|
}
|
|
else
|
|
{
|
|
SetTrapState( TESLATRAP_STATE_DEPLOY );
|
|
}
|
|
|
|
|
|
m_flRadius = 200.0f;
|
|
m_flDamage = 5.0f;
|
|
m_iAmmo = 30;
|
|
m_iMaxAmmo = 30;
|
|
m_flChargeInterval = 0.3f;
|
|
m_bAssembled = false;
|
|
m_bActive = false;
|
|
m_flNextFullChargeTime = gpGlobals->curtime + 1.0f;
|
|
|
|
SetContextThink( &CASW_TeslaTrap::RunAnimation, gpGlobals->curtime + 0.1f, s_pTeslaAnimThink );
|
|
}
|
|
|
|
|
|
void CASW_TeslaTrap::RunAnimation()
|
|
{
|
|
m_flPlaybackRate = 1.0f;
|
|
StudioFrameAdvance();
|
|
DispatchAnimEvents( this );
|
|
if ( m_bAssembled && !m_bActive )
|
|
{
|
|
ResetSequence( LookupSequence( "active" ) );
|
|
m_bActive = true;
|
|
|
|
}
|
|
SetContextThink( &CASW_TeslaTrap::RunAnimation, gpGlobals->curtime + 0.1f, s_pTeslaAnimThink );
|
|
}
|
|
|
|
void CASW_TeslaTrap::ReachedEndOfSequence()
|
|
{
|
|
if ( ( GetSequence() == LookupSequence( "deploy") ) )
|
|
{
|
|
m_bAssembled = true;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CASW_TeslaTrap::OnRestore()
|
|
{
|
|
BaseClass::OnRestore();
|
|
|
|
//if( VPhysicsGetObject() )
|
|
//{
|
|
// VPhysicsGetObject()->SetCharged();
|
|
//}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CASW_TeslaTrap::SetTrapState( int iState )
|
|
{
|
|
m_iTrapState = iState;
|
|
|
|
switch( iState )
|
|
{
|
|
case TESLATRAP_STATE_DEPLOY:
|
|
SetThink( &CASW_TeslaTrap::TeslaSettleThink );
|
|
SetTouch( &CASW_TeslaTrap::TeslaTouch );
|
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
|
break;
|
|
|
|
case TESLATRAP_STATE_CHARGING:
|
|
m_flNextFullChargeTime = gpGlobals->curtime + m_flChargeInterval;
|
|
SetThink( &CASW_TeslaTrap::TeslaChargeThink );
|
|
SetTouch( NULL );
|
|
SetNextThink( gpGlobals->curtime + 0.05f );
|
|
break;
|
|
|
|
case TESLATRAP_STATE_CHARGED:
|
|
SetThink( &CASW_TeslaTrap::TeslaSearchThink );
|
|
SetTouch( NULL );
|
|
SetNextThink( gpGlobals->curtime + 0.05f );
|
|
break;
|
|
|
|
default:
|
|
DevMsg("**Unknown Trap State: %d\n", iState );
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CASW_TeslaTrap::UpdateLight( bool bTurnOn, unsigned int r, unsigned int g, unsigned int b, unsigned int a )
|
|
{
|
|
if( bTurnOn )
|
|
{
|
|
Assert( a > 0 );
|
|
|
|
// Throw the old sprite away
|
|
if( m_hSprite )
|
|
{
|
|
UTIL_Remove( m_hSprite );
|
|
m_hSprite.Set( NULL );
|
|
}
|
|
|
|
if( !m_hSprite.Get() )
|
|
{
|
|
Vector up;
|
|
GetVectors( NULL, NULL, &up );
|
|
|
|
// Light isn't on.
|
|
m_hSprite = CSprite::SpriteCreate( "sprites/glow01.vmt", GetAbsOrigin() + up * 10.0f, false );
|
|
CSprite *pSprite = (CSprite *)m_hSprite.Get();
|
|
|
|
if( m_hSprite )
|
|
{
|
|
pSprite->SetParent( this );
|
|
pSprite->SetTransparency( kRenderTransAdd, r, g, b, a, kRenderFxNone );
|
|
pSprite->SetScale( 0.95, 0.0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Update color
|
|
CSprite *pSprite = (CSprite *)m_hSprite.Get();
|
|
pSprite->SetTransparency( kRenderTransAdd, r, g, b, a, kRenderFxNone );
|
|
}
|
|
}
|
|
|
|
if( !bTurnOn )
|
|
{
|
|
if( m_hSprite )
|
|
{
|
|
UTIL_Remove( m_hSprite );
|
|
m_hSprite.Set( NULL );
|
|
}
|
|
}
|
|
|
|
if ( !m_hSprite )
|
|
{
|
|
m_LastSpriteColor.SetRawColor( 0 );
|
|
}
|
|
else
|
|
{
|
|
m_LastSpriteColor.SetColor( r, g, b, a );
|
|
}
|
|
}
|
|
*/
|
|
/*
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CASW_TeslaTrap::SetCharged( bool bCharged )
|
|
{
|
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
|
|
CReliableBroadcastRecipientFilter filter;
|
|
|
|
if ( bCharged )
|
|
SetTrapState( TESLATRAP_STATE_CHARGED );
|
|
|
|
if( !m_pWarnSound )
|
|
{
|
|
m_pWarnSound = controller.SoundCreate( filter, entindex(), "Combine_TeslaTrap.ActiveLoop" );
|
|
controller.Play( m_pWarnSound, 1.0, PITCH_NORM );
|
|
}
|
|
|
|
if( bCharged )
|
|
{
|
|
// Turning on
|
|
if( m_bFoeNearest )
|
|
{
|
|
SetTrapState( TESLATRAP_STATE_CHARGED );
|
|
EmitSound( "Combine_TeslaTrap.TurnOn" );
|
|
controller.SoundChangeVolume( m_pWarnSound, 1.0, 0.1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Turning off
|
|
if( m_bFoeNearest )
|
|
{
|
|
EmitSound( "Combine_TeslaTrap.TurnOff" );
|
|
}
|
|
|
|
SetNearestNPC( NULL );
|
|
controller.SoundChangeVolume( m_pWarnSound, 0.0, 0.1 );
|
|
}
|
|
|
|
m_bCharged = bCharged;
|
|
}
|
|
*/
|
|
//---------------------------------------------------------
|
|
// Returns distance to the nearest BaseCombatCharacter.
|
|
//---------------------------------------------------------
|
|
float CASW_TeslaTrap::FindNearestNPC()
|
|
{
|
|
float flNearest = (m_flRadius+100.0f * m_flRadius+100.0f) + 1.0;
|
|
|
|
// Assume this search won't find anyone.
|
|
SetNearestNPC( NULL );
|
|
|
|
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
|
|
int nAIs = g_AI_Manager.NumAIs();
|
|
|
|
for ( int i = 0; i < nAIs; i++ )
|
|
{
|
|
CAI_BaseNPC *pNPC = ppAIs[ i ];
|
|
|
|
if( pNPC->IsAlive() )
|
|
{
|
|
// ignore hidden objects
|
|
if ( pNPC->IsEffectActive( EF_NODRAW ) )
|
|
continue;
|
|
|
|
// Don't bother with NPC's that are below me.
|
|
if( (pNPC->EyePosition().z + 4.0f) < GetAbsOrigin().z )
|
|
continue;
|
|
|
|
// Disregard things that want to be disregarded
|
|
if( pNPC->Classify() == CLASS_NONE )
|
|
continue;
|
|
|
|
// Disregard bullseyes
|
|
if( pNPC->Classify() == CLASS_BULLSEYE )
|
|
continue;
|
|
|
|
// ignore marines
|
|
if( pNPC->Classify() == CLASS_ASW_MARINE || pNPC->Classify() == CLASS_ASW_COLONIST )
|
|
continue;
|
|
|
|
float flDist = (GetAbsOrigin() - pNPC->GetAbsOrigin()).LengthSqr();
|
|
|
|
if( flDist < flNearest )
|
|
{
|
|
// Now do a visibility test.
|
|
//UTIL_TraceLine( EyePosition(), pNPC->WorldSpaceCenter(), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_)
|
|
if( FVisible( pNPC, MASK_SOLID_BRUSHONLY ) )
|
|
{
|
|
CASW_Alien *pAlien = dynamic_cast<CASW_Alien*>( pNPC );
|
|
bool bAlreadyZapped = pAlien && pAlien->IsElectroStunned();
|
|
|
|
if ( bAlreadyZapped && m_hNearestNPC.Get() != NULL )
|
|
continue;
|
|
|
|
flNearest = flDist;
|
|
SetNearestNPC( pNPC );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_hNearestNPC.Get() )
|
|
{
|
|
// If sprite is active, update its color to reflect who is nearest.
|
|
if( IsFriend( m_hNearestNPC ) )
|
|
{
|
|
if( m_bFoeNearest )
|
|
{
|
|
// Changing state to where a friend is nearest.
|
|
|
|
if( IsFriend( m_hNearestNPC ) )
|
|
{
|
|
// Friend
|
|
//UpdateLight( true, 0, 255, 0, 190 );
|
|
m_bFoeNearest = false;
|
|
}
|
|
}
|
|
}
|
|
else // it's a foe
|
|
{
|
|
if( !m_bFoeNearest )
|
|
{
|
|
// Changing state to where a foe is nearest.
|
|
//UpdateLight( true, 255, 0, 0, 190 );
|
|
m_bFoeNearest = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return sqrt( flNearest );
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
bool CASW_TeslaTrap::IsFriend( CBaseEntity *pEntity )
|
|
{
|
|
if ( !pEntity )
|
|
return true;
|
|
|
|
int classify = pEntity->Classify();
|
|
bool bIsFriendly = false;
|
|
|
|
if( classify == CLASS_ASW_MARINE )
|
|
{
|
|
bIsFriendly = true;
|
|
}
|
|
|
|
if( !m_bPlacedByPlayer )
|
|
{
|
|
return !bIsFriendly;
|
|
}
|
|
else
|
|
{
|
|
return bIsFriendly;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
void CASW_TeslaTrap::TeslaSearchThink()
|
|
{
|
|
|
|
if( !UTIL_FindClientInPVS(edict()) )
|
|
{
|
|
// Sleep!
|
|
SetNextThink( gpGlobals->curtime + 0.5 );
|
|
return;
|
|
}
|
|
|
|
/*
|
|
if( (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )
|
|
{
|
|
if( IsCharged() )
|
|
{
|
|
SetCharged(false);
|
|
}
|
|
|
|
SetNextThink( gpGlobals->curtime + 0.5 );
|
|
return;
|
|
}*/
|
|
|
|
float flNearestNPCDist = FindNearestNPC();
|
|
|
|
if( flNearestNPCDist <= m_flRadius && !IsFriend( m_hNearestNPC ) )
|
|
{
|
|
// Don't pop up in the air, just explode if the NPC gets closer than explode radius.
|
|
if ( ZapTarget( m_hNearestNPC ) )
|
|
{
|
|
m_iAmmo = m_iAmmo - 1;
|
|
if ( m_iAmmo.Get() <= 0 )
|
|
{
|
|
SetThink( &CASW_TeslaTrap::SUB_Remove );
|
|
}
|
|
}
|
|
}
|
|
|
|
SetNextThink( gpGlobals->curtime + 0.05 );
|
|
}
|
|
|
|
void CASW_TeslaTrap::LayFlat()
|
|
{
|
|
QAngle angFacing = GetAbsAngles();
|
|
//if (angFacing[PITCH] > 0 && angFacing[PITCH] < 180.0f)
|
|
angFacing[PITCH] = 0; //90
|
|
//else
|
|
// angFacing[PITCH] = 270;
|
|
SetAbsAngles(angFacing);
|
|
//Msg("Laying flat to %f, %f, %f\n", angFacing[PITCH], angFacing[YAW], angFacing[ROLL]);
|
|
}
|
|
|
|
void CASW_TeslaTrap::TeslaTouch( CBaseEntity *pOther )
|
|
{
|
|
Assert( pOther );
|
|
if ( !pOther->IsSolid() )
|
|
return;
|
|
|
|
// don't touch npcs
|
|
if ( pOther->IsNPC() )
|
|
return;
|
|
|
|
// Change our flight characteristics
|
|
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
|
|
SetGravity( UTIL_ScaleForGravity( 640 ) );
|
|
|
|
// Slow down
|
|
Vector vecNewVelocity = GetAbsVelocity();
|
|
vecNewVelocity.x *= 0.8f;
|
|
vecNewVelocity.y *= 0.8f;
|
|
SetAbsVelocity( vecNewVelocity );
|
|
|
|
//Stopped?
|
|
if ( GetAbsVelocity().Length() < 128.0f )
|
|
{
|
|
LayFlat();
|
|
SetAbsVelocity( vec3_origin );
|
|
SetMoveType( MOVETYPE_NONE );
|
|
//RemoveSolidFlags( FSOLID_NOT_SOLID );
|
|
//AddSolidFlags( FSOLID_TRIGGER );
|
|
SetTouch( NULL );
|
|
ResetSequence( LookupSequence( "deploy" ) );
|
|
SetTrapState( TESLATRAP_STATE_CHARGING );
|
|
}
|
|
}
|
|
|
|
int CASW_TeslaTrap::DrawDebugTextOverlays()
|
|
{
|
|
int text_offset = BaseClass::DrawDebugTextOverlays();
|
|
|
|
if (m_debugOverlays & OVERLAY_TEXT_BIT)
|
|
{
|
|
NDebugOverlay::EntityText( entindex(),text_offset,CFmtStr( "State: %d", m_iTrapState.Get() ),0 );
|
|
text_offset++;
|
|
}
|
|
return text_offset;
|
|
}
|
|
|
|
|
|
void CASW_TeslaTrap::TeslaSettleThink( void )
|
|
{
|
|
//float deltaTime = ( m_flTimeBurnOut - gpGlobals->curtime );
|
|
//if ( m_flTimeBurnOut != -1.0f )
|
|
//{
|
|
//Burned out
|
|
//if ( m_flTimeBurnOut < gpGlobals->curtime )
|
|
//{
|
|
// UTIL_Remove( this );
|
|
// return;
|
|
//}
|
|
//}
|
|
|
|
if ( GetAbsVelocity().Length() < 128.0f && GetGroundEntity() )//!m_bSettled &&
|
|
{
|
|
TeslaTouch( GetGroundEntity() );
|
|
}
|
|
|
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
|
}
|
|
|
|
void CASW_TeslaTrap::TeslaChargeThink( void )
|
|
{
|
|
if ( m_flNextFullChargeTime <= gpGlobals->curtime )
|
|
{
|
|
SetTrapState( TESLATRAP_STATE_CHARGED );
|
|
return;
|
|
}
|
|
SetNextThink( gpGlobals->curtime + 0.05f );
|
|
}
|
|
|
|
bool CASW_TeslaTrap::ZapTarget( CBaseEntity *pEntity )
|
|
{
|
|
if ( !pEntity )
|
|
return false;
|
|
|
|
if ( !m_bAssembled )
|
|
return false;
|
|
|
|
// trace from the device position to the victim
|
|
trace_t shockTR;
|
|
Vector vecShockSrc = WorldSpaceCenter();
|
|
Vector vecAIPos = pEntity->WorldSpaceCenter();
|
|
CASWTraceFilterShot traceFilter( this, NULL, COLLISION_GROUP_NONE );
|
|
AI_TraceLine( vecShockSrc, vecAIPos, MASK_SHOT, &traceFilter, &shockTR );
|
|
|
|
if ( shockTR.fraction != 1.0 && shockTR.m_pEnt )
|
|
{
|
|
Vector vecFXSrc;
|
|
QAngle vecFXAng;
|
|
|
|
GetAttachment( "effects", vecFXSrc, vecFXAng );
|
|
|
|
vecAIPos = shockTR.endpos;
|
|
ClearMultiDamage();
|
|
CTakeDamageInfo shockDmgInfo( this, this, m_flDamage, DMG_SHOCK );
|
|
Vector vecDir = vecAIPos - vecShockSrc;
|
|
VectorNormalize( vecDir );
|
|
shockDmgInfo.SetDamagePosition( shockTR.endpos );
|
|
shockDmgInfo.SetDamageForce( vecDir );
|
|
shockDmgInfo.ScaleDamageForce( 1.0 );
|
|
shockDmgInfo.SetWeapon( m_hCreatorWeapon );
|
|
|
|
shockTR.m_pEnt->DispatchTraceAttack( shockDmgInfo, vecDir, &shockTR );
|
|
ApplyMultiDamage();
|
|
|
|
//shockTR.m_pEnt->EmitSound( "Electricity.Zap" );
|
|
CASW_Alien *pAlien = dynamic_cast<CASW_Alien*>( shockTR.m_pEnt );
|
|
if ( pAlien )
|
|
{
|
|
// pAlien->ElectroShockBig( vecDir * 5, pAlien->GetAbsOrigin() - GetAbsOrigin() );
|
|
}
|
|
|
|
// spawn a shock effect
|
|
/*
|
|
CBaseEntity *pHelpHelpImBeingSupressed = (CBaseEntity*) te->GetSuppressHost();
|
|
te->SetSuppressHost( NULL );
|
|
DispatchParticleEffect( "tracer_electricity", vecFXSrc, vecAIPos, vec3_angle );
|
|
te->SetSuppressHost( pHelpHelpImBeingSupressed );
|
|
*/
|
|
|
|
CRecipientFilter filter;
|
|
filter.AddAllPlayers();
|
|
UserMessageBegin( filter, "ASWEnemyZappedByTesla" );
|
|
WRITE_FLOAT( vecShockSrc.x );
|
|
WRITE_FLOAT( vecShockSrc.y );
|
|
WRITE_FLOAT( vecShockSrc.z );
|
|
WRITE_SHORT( pEntity->entindex() );
|
|
MessageEnd();
|
|
|
|
//UTIL_ASW_ScreenShake( vecShockSrc, 10.0, 100.0, 2.0, 350, SHAKE_START );
|
|
|
|
SetTrapState( TESLATRAP_STATE_CHARGING );
|
|
if( IsPlayerPlaced() && m_hMarineDeployer.Get() )
|
|
m_hMarineDeployer->OnWeaponFired( this, 1 );
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
CASW_TeslaTrap* CASW_TeslaTrap::Tesla_Trap_Create( const Vector &position, const QAngle &angles, const Vector &velocity, const AngularImpulse &angVelocity, CBaseEntity *pOwner, CBaseEntity *pCreatorWeapon )
|
|
{
|
|
CASW_TeslaTrap *pEnt = (CASW_TeslaTrap*)CreateEntityByName( "asw_tesla_trap" );
|
|
pEnt->SetAbsAngles( angles );
|
|
pEnt->Spawn();
|
|
pEnt->SetOwnerEntity( pOwner );
|
|
UTIL_SetOrigin( pEnt, position );
|
|
pEnt->SetAbsVelocity( velocity );
|
|
pEnt->m_hCreatorWeapon.Set( pCreatorWeapon );
|
|
if( pCreatorWeapon )
|
|
pEnt->m_CreatorWeaponClass = pCreatorWeapon->Classify();
|
|
|
|
return pEnt;
|
|
}
|
|
|
|
LINK_ENTITY_TO_CLASS( asw_tesla_trap, CASW_TeslaTrap );
|