851 lines
24 KiB
C++
851 lines
24 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: The Escort's Shield weapon
|
|
//
|
|
// $Revision: $
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "in_buttons.h"
|
|
#include "tf_shieldshared.h"
|
|
#include "tf_shareddefs.h"
|
|
#include "baseentity_shared.h"
|
|
|
|
#if defined( CLIENT_DLL )
|
|
|
|
#include "c_shield.h"
|
|
|
|
#else
|
|
|
|
#include "tf_shield.h"
|
|
#include "gamerules.h"
|
|
|
|
#endif
|
|
|
|
|
|
#if defined( CLIENT_DLL )
|
|
#define CShieldMobile C_ShieldMobile
|
|
#define CShield C_Shield
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// ConVars
|
|
//-----------------------------------------------------------------------------
|
|
ConVar shield_mobile_power( "shield_mobile_power","30", FCVAR_REPLICATED, "Max power level of a escort's mobile projected shield." );
|
|
ConVar shield_mobile_recharge_delay( "shield_mobile_recharge_delay","0.1", FCVAR_REPLICATED, "Time after taking damage before mobile projected shields begin to recharge." );
|
|
ConVar shield_mobile_recharge_amount( "shield_mobile_recharge_amount","2", FCVAR_REPLICATED, "Power recharged each recharge tick for mobile projected shields." );
|
|
ConVar shield_mobile_recharge_time( "shield_mobile_recharge_time","0.5", FCVAR_REPLICATED, "Time between each recharge tick for mobile projected shields." );
|
|
|
|
|
|
#define EMP_WAVE_AMPLITUDE 8.0f
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Mobile version of the shield
|
|
//-----------------------------------------------------------------------------
|
|
class CShieldMobile;
|
|
class CShieldMobileActiveVertList : public IActiveVertList
|
|
{
|
|
public:
|
|
void Init( CShieldMobile *pShield );
|
|
|
|
// IActiveVertList overrides.
|
|
public:
|
|
|
|
virtual int GetActiveVertState( int iVert );
|
|
virtual void SetActiveVertState( int iVert, int bOn );
|
|
|
|
private:
|
|
CShieldMobile *m_pShield;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Mobile version of the shield
|
|
//-----------------------------------------------------------------------------
|
|
class CShieldMobile : public CShield, public IEntityEnumerator
|
|
{
|
|
DECLARE_CLASS( CShieldMobile, CShield );
|
|
|
|
public:
|
|
DECLARE_NETWORKCLASS();
|
|
DECLARE_PREDICTABLE();
|
|
|
|
friend class CShieldMobileActiveVertList;
|
|
|
|
CShieldMobile();
|
|
|
|
#ifndef CLIENT_DLL
|
|
DECLARE_DATADESC();
|
|
#endif
|
|
|
|
public:
|
|
void Spawn( void );
|
|
void Precache( void );
|
|
void ShieldThink( void );
|
|
virtual void ClientThink();
|
|
virtual void SetAngularSpringConstant( float flConstant );
|
|
virtual void SetFrontDistance( float flDistance );
|
|
virtual void ComputeWorldSpaceSurroundingBox( Vector *pWorldMins, Vector *pWorldMaxs );
|
|
|
|
virtual void SetAttachmentIndex( int nAttachmentIndex );
|
|
virtual void SetEMPed( bool isEmped );
|
|
virtual void SetAlwaysOrient( bool bOrient );
|
|
virtual bool IsAlwaysOrienting( );
|
|
|
|
virtual int Width();
|
|
virtual int Height();
|
|
virtual bool IsPanelActive( int x, int y );
|
|
virtual const Vector& GetPoint( int x, int y );
|
|
virtual void SetCenterAngles( const QAngle& angles );
|
|
virtual void SetThetaPhi( float flTheta, float flPhi );
|
|
|
|
virtual void GetRenderBounds( Vector& mins, Vector& maxs );
|
|
|
|
// All predicted weapons need to implement and return true
|
|
virtual bool IsPredicted( void ) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public:
|
|
#ifdef CLIENT_DLL
|
|
virtual void OnDataChanged( DataUpdateType_t updateType );
|
|
virtual void GetBounds( Vector& mins, Vector& maxs );
|
|
virtual void AddEntity( );
|
|
virtual void GetShieldData( const Vector** ppVerts, float* pOpacity, float* pBlend );
|
|
|
|
virtual bool ShouldPredict( void )
|
|
{
|
|
if ( GetOwnerEntity() == C_BasePlayer::GetLocalPlayer() )
|
|
return true;
|
|
|
|
return BaseClass::ShouldPredict();
|
|
}
|
|
|
|
#endif
|
|
|
|
public:
|
|
// Inherited from IEntityEnumerator
|
|
virtual bool EnumEntity( IHandleEntity *pHandleEntity );
|
|
|
|
private:
|
|
// Teleport!
|
|
void OnTeleported( );
|
|
void SimulateShield( void );
|
|
|
|
private:
|
|
struct SweepContext_t
|
|
{
|
|
SweepContext_t( const CBaseEntity *passentity, int collisionGroup ) :
|
|
m_Filter( passentity, collisionGroup ) {}
|
|
|
|
CTraceFilterSimple m_Filter;
|
|
Vector m_vecStartDelta;
|
|
Vector m_vecEndDelta;
|
|
};
|
|
|
|
enum
|
|
{
|
|
NUM_SUBDIVISIONS = 21,
|
|
};
|
|
|
|
enum
|
|
{
|
|
SHIELD_ORIENT_TO_OWNER = 0x2
|
|
};
|
|
|
|
private:
|
|
CShieldMobile( const CShieldMobile & );
|
|
void ComputeBoundingBox( void );
|
|
void DetermineObstructions( );
|
|
|
|
private:
|
|
#ifdef CLIENT_DLL
|
|
// Is a particular panel an edge?
|
|
bool IsVertexValid( float s, float t ) const;
|
|
void PreRender( );
|
|
#endif
|
|
|
|
private:
|
|
CShieldMobileActiveVertList m_VertList;
|
|
QAngle m_tmpAngLockedAngles;
|
|
|
|
// Bitfield indicating which vertices are active
|
|
CShieldEffect m_ShieldEffect;
|
|
CNetworkArray( unsigned char, m_pVertsActive, SHIELD_NUM_CONTROL_POINTS >> 3 );
|
|
CNetworkVar( unsigned char, m_ShieldState );
|
|
CNetworkVar( float, m_flFrontDistance );
|
|
CNetworkVar( QAngle, m_angLockedAngles );
|
|
SweepContext_t *m_pEnumCtx;
|
|
|
|
// This is the width + height of the shield, not the current theta, phi
|
|
CNetworkVar( float, m_flShieldTheta );
|
|
CNetworkVar( float, m_flShieldPhi );
|
|
CNetworkVar( float, m_flSpringConstant );
|
|
CNetworkVar( int, m_nAttachmentIndex );
|
|
};
|
|
|
|
|
|
//=============================================================================
|
|
// Shield effect
|
|
//=============================================================================
|
|
#ifndef CLIENT_DLL
|
|
|
|
BEGIN_DATADESC( CShieldMobile )
|
|
|
|
DEFINE_THINKFUNC( ShieldThink ),
|
|
|
|
END_DATADESC()
|
|
|
|
#endif
|
|
|
|
LINK_ENTITY_TO_CLASS( shield_mobile, CShieldMobile );
|
|
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( ShieldMobile, DT_ShieldMobile );
|
|
|
|
// -------------------------------------------------------------------------------- //
|
|
// This data only gets sent to clients that ARE this player entity.
|
|
// -------------------------------------------------------------------------------- //
|
|
|
|
BEGIN_NETWORK_TABLE(CShieldMobile, DT_ShieldMobile)
|
|
#if !defined( CLIENT_DLL )
|
|
SendPropInt (SENDINFO(m_ShieldState), 2, SPROP_UNSIGNED ),
|
|
SendPropArray(
|
|
SendPropInt( SENDINFO_ARRAY(m_pVertsActive), 8, SPROP_UNSIGNED),
|
|
m_pVertsActive),
|
|
|
|
SendPropFloat( SENDINFO(m_flFrontDistance), 0, SPROP_NOSCALE ),
|
|
SendPropFloat( SENDINFO(m_flShieldTheta), 0, SPROP_NOSCALE ),
|
|
SendPropFloat( SENDINFO(m_flShieldPhi), 0, SPROP_NOSCALE ),
|
|
SendPropFloat( SENDINFO(m_flSpringConstant), 0, SPROP_NOSCALE ),
|
|
SendPropQAngles( SENDINFO(m_angLockedAngles), 9 ),
|
|
SendPropInt (SENDINFO(m_nAttachmentIndex), 10, SPROP_UNSIGNED ),
|
|
|
|
// Don't bother sending these, they are totally controlled by the think function
|
|
SendPropExclude( "DT_BaseEntity", "m_vecOrigin" ),
|
|
SendPropExclude( "DT_BaseEntity", "m_angAbsRotation[0]" ),
|
|
SendPropExclude( "DT_BaseEntity", "m_angAbsRotation[1]" ),
|
|
SendPropExclude( "DT_BaseEntity", "m_angAbsRotation[2]" ),
|
|
|
|
#else
|
|
RecvPropInt( RECVINFO(m_ShieldState) ),
|
|
RecvPropArray(
|
|
RecvPropInt( RECVINFO(m_pVertsActive[0])),
|
|
m_pVertsActive
|
|
),
|
|
RecvPropFloat( RECVINFO(m_flFrontDistance) ),
|
|
RecvPropFloat( RECVINFO(m_flShieldTheta) ),
|
|
RecvPropFloat( RECVINFO(m_flShieldPhi) ),
|
|
RecvPropFloat( RECVINFO(m_flSpringConstant) ),
|
|
RecvPropQAngles( RECVINFO( m_angLockedAngles ) ),
|
|
RecvPropInt (RECVINFO(m_nAttachmentIndex) ),
|
|
#endif
|
|
|
|
END_NETWORK_TABLE()
|
|
|
|
|
|
BEGIN_PREDICTION_DATA( CShieldMobile )
|
|
|
|
DEFINE_PRED_FIELD( m_ShieldState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_flFrontDistance, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_angLockedAngles, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_TYPEDESCRIPTION( m_ShieldEffect, CShieldEffect ),
|
|
DEFINE_FIELD( m_nNextThinkTick, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_tmpAngLockedAngles, FIELD_VECTOR ),
|
|
|
|
// FIXME: How can I make this work now that I have an embedded collision property?
|
|
// DEFINE_PRED_FIELD( m_vecMins, FIELD_VECTOR, FTYPEDESC_INSENDTABLE | FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
|
|
// DEFINE_PRED_FIELD( m_vecMaxs, FIELD_VECTOR, FTYPEDESC_INSENDTABLE | FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
|
|
|
|
#ifdef CLIENT_DLL
|
|
DEFINE_PRED_FIELD( m_vecNetworkOrigin, FIELD_VECTOR, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
|
|
DEFINE_PRED_FIELD( m_angNetworkAngles, FIELD_VECTOR, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
|
|
#endif
|
|
|
|
END_PREDICTION_DATA()
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CShieldMobileActiveVertList functions
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobileActiveVertList::Init( CShieldMobile *pShield )
|
|
{
|
|
m_pShield = pShield;
|
|
}
|
|
|
|
|
|
int CShieldMobileActiveVertList::GetActiveVertState( int iVert )
|
|
{
|
|
return m_pShield->m_pVertsActive[iVert>>3] & (1 << (iVert & 7));
|
|
}
|
|
|
|
|
|
void CShieldMobileActiveVertList::SetActiveVertState( int iVert, int bOn )
|
|
{
|
|
unsigned char val;
|
|
if ( bOn )
|
|
val = m_pShield->m_pVertsActive[iVert>>3] | (1 << (iVert & 7));
|
|
else
|
|
val = m_pShield->m_pVertsActive[iVert>>3] & ~(1 << (iVert & 7));
|
|
|
|
m_pShield->m_pVertsActive.Set( iVert>>3, val );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// constructor
|
|
//-----------------------------------------------------------------------------
|
|
CShieldMobile::CShieldMobile()
|
|
{
|
|
SetPredictionEligible( true );
|
|
m_VertList.Init( this );
|
|
m_flFrontDistance = 0;
|
|
SetAngularSpringConstant( 2.0f );
|
|
SetThetaPhi( SHIELD_INITIAL_THETA, SHIELD_INITIAL_PHI );
|
|
m_nAttachmentIndex = 0;
|
|
|
|
#ifdef CLIENT_DLL
|
|
InitShield( SHIELD_NUM_HORIZONTAL_POINTS, SHIELD_NUM_VERTICAL_POINTS, NUM_SUBDIVISIONS );
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::Precache( void )
|
|
{
|
|
m_ShieldEffect.SetActiveVertexList( &m_VertList );
|
|
m_ShieldEffect.SetCollisionGroup( TFCOLLISION_GROUP_SHIELD );
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::Spawn( void )
|
|
{
|
|
Precache();
|
|
BaseClass::Spawn();
|
|
AddSolidFlags( FSOLID_FORCE_WORLD_ALIGNED );
|
|
|
|
// Assert( GetOwnerEntity() );
|
|
m_angLockedAngles.Set( vec3_angle );
|
|
m_tmpAngLockedAngles = vec3_angle;
|
|
m_ShieldEffect.Spawn(GetAbsOrigin(), GetAbsAngles());
|
|
m_ShieldState = 0;
|
|
SetAlwaysOrient( true );
|
|
|
|
// All movement occurs during think
|
|
SetMoveType( MOVETYPE_NONE );
|
|
|
|
SetThink( ShieldThink );
|
|
SetNextThink( gpGlobals->curtime + 0.01f );
|
|
|
|
#ifdef CLIENT_DLL
|
|
// This goofiness is required so that non-predicted entities work
|
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::SetAlwaysOrient( bool bOrient )
|
|
{
|
|
if (bOrient)
|
|
{
|
|
m_ShieldState.Set( m_ShieldState.Get() | SHIELD_ORIENT_TO_OWNER );
|
|
}
|
|
else
|
|
{
|
|
m_angLockedAngles.Set( m_tmpAngLockedAngles );
|
|
m_ShieldState.Set( m_ShieldState.Get() & (~SHIELD_ORIENT_TO_OWNER) );
|
|
}
|
|
}
|
|
|
|
int CShieldMobile::Width()
|
|
{
|
|
return SHIELD_NUM_HORIZONTAL_POINTS;
|
|
}
|
|
|
|
int CShieldMobile::Height()
|
|
{
|
|
return SHIELD_NUM_VERTICAL_POINTS;
|
|
}
|
|
|
|
const Vector& CShieldMobile::GetPoint( int x, int y )
|
|
{
|
|
return m_ShieldEffect.GetPoint( x, y );
|
|
}
|
|
|
|
|
|
void CShieldMobile::SetAttachmentIndex( int nAttachmentIndex )
|
|
{
|
|
m_nAttachmentIndex = nAttachmentIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the render bounds
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::GetRenderBounds( Vector& mins, Vector& maxs )
|
|
{
|
|
mins = m_ShieldEffect.GetRenderMins();
|
|
maxs = m_ShieldEffect.GetRenderMaxs();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Return true if the panel is active
|
|
//-----------------------------------------------------------------------------
|
|
bool CShieldMobile::IsPanelActive( int x, int y )
|
|
{
|
|
return m_ShieldEffect.IsPanelActive(x, y);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the shield is EMPed
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::SetEMPed( bool isEmped )
|
|
{
|
|
CShield::SetEMPed(isEmped);
|
|
if (IsEMPed())
|
|
m_ShieldState |= SHIELD_MOBILE_EMP;
|
|
else
|
|
m_ShieldState &= ~SHIELD_MOBILE_EMP;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Set the shield angles
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::SetCenterAngles( const QAngle& angles )
|
|
{
|
|
// The tmp ang locked angles is simply there to prevent unnecessary network traffic
|
|
m_tmpAngLockedAngles = angles;
|
|
if ( ( m_ShieldState.Get() & SHIELD_ORIENT_TO_OWNER ) == 0 )
|
|
{
|
|
m_angLockedAngles.Set( angles );
|
|
}
|
|
}
|
|
|
|
bool CShieldMobile::IsAlwaysOrienting( )
|
|
{
|
|
return ( m_ShieldState.Get() & SHIELD_ORIENT_TO_OWNER ) != 0;
|
|
}
|
|
|
|
void CShieldMobile::SetAngularSpringConstant( float flConstant )
|
|
{
|
|
m_flSpringConstant = flConstant;
|
|
m_ShieldEffect.SetAngularSpringConstant( flConstant );
|
|
}
|
|
|
|
void CShieldMobile::SetFrontDistance( float flDistance )
|
|
{
|
|
m_flFrontDistance = flDistance;
|
|
}
|
|
|
|
void CShieldMobile::SetThetaPhi( float flTheta, float flPhi )
|
|
{
|
|
// This sets the bounds of the shield; how tall + wide is it?
|
|
m_flShieldTheta = flTheta;
|
|
m_flShieldPhi = flPhi;
|
|
m_ShieldEffect.SetThetaPhi(flTheta, flPhi);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the shield bounding box
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::ComputeBoundingBox( void )
|
|
{
|
|
Vector mins, maxs;
|
|
m_ShieldEffect.ComputeBounds(mins, maxs);
|
|
SetCollisionBounds( mins, maxs );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute world axis-aligned bounding box
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::ComputeWorldSpaceSurroundingBox( Vector *pWorldMins, Vector *pWorldMaxs )
|
|
{
|
|
// We don't use USE_SPECIFIED_BOUNDS because that would generate a ton of network traffic
|
|
VectorAdd( CollisionProp()->GetCollisionOrigin(), CollisionProp()->OBBMins(), *pWorldMins );
|
|
VectorAdd( CollisionProp()->GetCollisionOrigin(), CollisionProp()->OBBMaxs(), *pWorldMaxs );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Determines shield obstructions
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::DetermineObstructions( )
|
|
{
|
|
m_ShieldEffect.ComputeVertexActivity();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the enumerator call in ShieldThink
|
|
//-----------------------------------------------------------------------------
|
|
bool CShieldMobile::EnumEntity( IHandleEntity *pHandleEntity )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
CBaseEntity *pOther = cl_entitylist->GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
|
|
#else
|
|
CBaseEntity *pOther = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() );
|
|
#endif
|
|
|
|
if (!pOther)
|
|
return true;
|
|
|
|
// Blow off non-solid things
|
|
if ( !::IsSolid(pOther->GetSolid(), pOther->GetSolidFlags()) )
|
|
return true;
|
|
|
|
// No model, blow it off
|
|
if ( !pOther->GetModelIndex() )
|
|
return true;
|
|
|
|
// Blow off point-sized things....
|
|
if ( pOther->IsPointSized() )
|
|
return true;
|
|
|
|
// Don't bother if we shouldn't be colliding with this guy...
|
|
if (!m_pEnumCtx->m_Filter.ShouldHitEntity( pOther, MASK_SOLID ))
|
|
return true;
|
|
|
|
// The shield is in its final position, so we're gonna have to determine the
|
|
// point of collision by working in the space of the final position....
|
|
// We do this by moving the obstruction by the relative movement amount...
|
|
Vector vecObsMins, vecObsMaxs, vecObsCenter;
|
|
pOther->CollisionProp()->WorldSpaceAABB( &vecObsMins, &vecObsMaxs );
|
|
vecObsCenter = (vecObsMins + vecObsMaxs) * 0.5f;
|
|
vecObsMins -= vecObsCenter;
|
|
vecObsMaxs -= vecObsCenter;
|
|
|
|
Vector vecStart, vecEnd;
|
|
VectorAdd( vecObsCenter, m_pEnumCtx->m_vecStartDelta, vecStart );
|
|
VectorAdd( vecStart, m_pEnumCtx->m_vecEndDelta, vecEnd );
|
|
|
|
|
|
Ray_t ray;
|
|
ray.Init( vecStart, vecEnd, vecObsMins, vecObsMaxs );
|
|
|
|
trace_t tr;
|
|
if (TestCollision( ray, pOther->PhysicsSolidMaskForEntity(), tr ))
|
|
{
|
|
// Ok, we got a collision. Let's indicate it happened...
|
|
// At the moment, we'll report the collision point as being on the
|
|
// surface of the shield in its final position, which is kind of bogus...
|
|
pOther->PhysicsImpact( this, tr );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Update the shield position:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::SimulateShield( void )
|
|
{
|
|
CBaseEntity *owner = GetOwnerEntity();
|
|
Vector origin;
|
|
if ( owner )
|
|
{
|
|
if ( m_ShieldState & SHIELD_ORIENT_TO_OWNER )
|
|
{
|
|
if ( owner->IsPlayer() )
|
|
{
|
|
m_ShieldEffect.SetDesiredAngles( owner->EyeAngles() );
|
|
}
|
|
else
|
|
{
|
|
m_ShieldEffect.SetDesiredAngles( owner->GetAbsAngles() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_ShieldEffect.SetDesiredAngles( m_angLockedAngles );
|
|
}
|
|
|
|
if ( m_nAttachmentIndex == 0 )
|
|
{
|
|
origin = owner->EyePosition();
|
|
}
|
|
else
|
|
{
|
|
QAngle angles;
|
|
CBaseAnimating *pAnim = dynamic_cast<CBaseAnimating*>( owner );
|
|
if (pAnim)
|
|
{
|
|
pAnim->GetAttachment( m_nAttachmentIndex, origin, angles );
|
|
}
|
|
else
|
|
{
|
|
origin = owner->EyePosition();
|
|
}
|
|
}
|
|
|
|
if ( m_flFrontDistance )
|
|
{
|
|
Vector vForward;
|
|
AngleVectors( m_ShieldEffect.GetDesiredAngles(), &vForward );
|
|
origin += vForward * m_flFrontDistance;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
origin = vec3_origin;
|
|
}
|
|
|
|
// We pretty much always need to recompute this
|
|
CollisionProp()->MarkSurroundingBoundsDirty();
|
|
|
|
Vector vecOldOrigin = m_ShieldEffect.GetCurrentPosition();
|
|
|
|
Vector vecDelta;
|
|
VectorSubtract( origin, vecOldOrigin, vecDelta );
|
|
|
|
float flMaxDist = 100 + m_flFrontDistance;
|
|
if (vecDelta.LengthSqr() > flMaxDist * flMaxDist )
|
|
{
|
|
OnTeleported();
|
|
return;
|
|
}
|
|
|
|
m_ShieldEffect.SetDesiredOrigin( origin );
|
|
m_ShieldEffect.Simulate(gpGlobals->frametime);
|
|
DetermineObstructions();
|
|
SetAbsOrigin( m_ShieldEffect.GetCurrentPosition() );
|
|
SetAbsAngles( m_ShieldEffect.GetCurrentAngles() );
|
|
|
|
#ifdef CLIENT_DLL
|
|
// Necessary because we exclude the network origin
|
|
SetNetworkOrigin( m_ShieldEffect.GetCurrentPosition() );
|
|
SetNetworkAngles( m_ShieldEffect.GetCurrentAngles() );
|
|
#endif
|
|
|
|
// Compute a composite bounding box surrounding the initial + new positions..
|
|
Vector vecCompositeMins = WorldAlignMins() + vecOldOrigin;
|
|
Vector vecCompositeMaxs = WorldAlignMaxs() + vecOldOrigin;
|
|
|
|
ComputeBoundingBox();
|
|
|
|
// Sweep the shield through the world + touch things it hits...
|
|
SweepContext_t ctx( this, GetCollisionGroup() );
|
|
VectorSubtract( GetAbsOrigin(), vecOldOrigin, ctx.m_vecStartDelta );
|
|
|
|
if (ctx.m_vecStartDelta != vec3_origin)
|
|
{
|
|
// FIXME: Brutal hack; needed because IntersectRayWithTriangle misses stuff
|
|
// especially with short rays; I'm not sure what to do about this.
|
|
// This basically simulates a shield thickness of 15 units
|
|
ctx.m_vecEndDelta = ctx.m_vecStartDelta;
|
|
VectorNormalize( ctx.m_vecEndDelta );
|
|
ctx.m_vecEndDelta *= -15.0f;
|
|
|
|
Vector vecNewMins = WorldAlignMins() + GetAbsOrigin();
|
|
Vector vecNewMaxs = WorldAlignMaxs() + GetAbsOrigin();
|
|
VectorMin( vecCompositeMins, vecNewMins, vecCompositeMins );
|
|
VectorMax( vecCompositeMaxs, vecNewMaxs, vecCompositeMaxs );
|
|
|
|
m_pEnumCtx = &ctx;
|
|
enginetrace->EnumerateEntities( vecCompositeMins, vecCompositeMaxs, this );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Update the shield position:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::ShieldThink( void )
|
|
{
|
|
SimulateShield();
|
|
|
|
#ifdef CLIENT_DLL
|
|
m_ShieldEffect.ComputeControlPoints();
|
|
m_ShieldEffect.ComputePanelActivity();
|
|
#endif
|
|
|
|
SetNextThink( gpGlobals->curtime + 0.01f );
|
|
}
|
|
|
|
void CShieldMobile::ClientThink()
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
if ( GetPredictable() )
|
|
return;
|
|
|
|
SimulateShield();
|
|
m_ShieldEffect.ComputeControlPoints();
|
|
m_ShieldEffect.ComputePanelActivity();
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Teleport!
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::OnTeleported( )
|
|
{
|
|
CBaseEntity *owner = GetOwnerEntity();
|
|
if (!owner)
|
|
return;
|
|
|
|
m_ShieldEffect.SetCurrentAngles( owner->GetAbsAngles() );
|
|
|
|
Vector origin;
|
|
origin = owner->EyePosition();
|
|
if ( m_flFrontDistance )
|
|
{
|
|
Vector vForward;
|
|
AngleVectors( m_ShieldEffect.GetCurrentAngles(), &vForward );
|
|
origin += vForward * m_flFrontDistance;
|
|
}
|
|
|
|
m_ShieldEffect.SetCurrentPosition( origin );
|
|
}
|
|
|
|
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Get this after the data changes
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnDataChanged( updateType );
|
|
m_ShieldEffect.SetThetaPhi( m_flShieldTheta, m_flShieldPhi );
|
|
m_ShieldEffect.SetAngularSpringConstant( m_flSpringConstant );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A little pre-render processing
|
|
//-----------------------------------------------------------------------------
|
|
void C_ShieldMobile::PreRender( )
|
|
{
|
|
if (m_ShieldState & SHIELD_MOBILE_EMP)
|
|
{
|
|
// Decay fade if we've been EMPed or if we're inactive
|
|
if (m_FadeValue > 0.0f)
|
|
{
|
|
m_FadeValue -= gpGlobals->frametime / SHIELD_EMP_FADE_TIME;
|
|
if (m_FadeValue < 0.0f)
|
|
{
|
|
m_FadeValue = 0.0f;
|
|
|
|
// Reset the shield to un-wobbled state
|
|
m_ShieldEffect.ComputeControlPoints();
|
|
}
|
|
else
|
|
{
|
|
Vector dir;
|
|
AngleVectors( m_ShieldEffect.GetCurrentAngles(), & dir, 0, 0 );
|
|
|
|
// Futz with the control points if we've been EMPed
|
|
for (int i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i)
|
|
{
|
|
// Get the direction for the point
|
|
float factor = -EMP_WAVE_AMPLITUDE * sin( i * M_PI * 0.5f + gpGlobals->curtime * M_PI / SHIELD_EMP_WOBBLE_TIME );
|
|
m_ShieldEffect.GetPoint(i) += dir * factor;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fade back in, no longer EMPed
|
|
if (m_FadeValue < 1.0f)
|
|
{
|
|
m_FadeValue += gpGlobals->frametime / SHIELD_EMP_FADE_TIME;
|
|
if (m_FadeValue >= 1.0f)
|
|
{
|
|
m_FadeValue = 1.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CShieldMobile::AddEntity( )
|
|
{
|
|
BaseClass::AddEntity( );
|
|
PreRender();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Bounds computation
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::GetBounds( Vector& mins, Vector& maxs )
|
|
{
|
|
m_ShieldEffect.ComputeBounds( mins, maxs );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets at the control point data; who knows how it was made?
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldMobile::GetShieldData( const Vector** ppVerts, float* pOpacity, float* pBlend )
|
|
{
|
|
for ( int i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
|
|
{
|
|
ppVerts[i] = &m_ShieldEffect.GetControlPoint(i);
|
|
|
|
if ( m_pVertsActive[i >> 3] & (1 << (i & 0x7)) )
|
|
{
|
|
pOpacity[i] = m_ShieldEffect.ComputeOpacity( *ppVerts[i], GetAbsOrigin() );
|
|
pBlend[i] = 1.0f;
|
|
}
|
|
else
|
|
{
|
|
pOpacity[i] = 192.0f;
|
|
pBlend[i] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#endif // CLIENT_DLL
|
|
|
|
|
|
#ifndef CLIENT_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Create a mobile version of the shield
|
|
//-----------------------------------------------------------------------------
|
|
CShield *CreateMobileShield( CBaseEntity *owner, float flFrontDistance )
|
|
{
|
|
CShieldMobile *pShield = (CShieldMobile*)CreateEntityByName("shield_mobile");
|
|
|
|
pShield->SetOwnerEntity( owner );
|
|
pShield->SetLocalAngles( owner->GetAbsAngles() );
|
|
pShield->SetFrontDistance( flFrontDistance );
|
|
|
|
// Start it in the right place
|
|
Vector vForward;
|
|
AngleVectors( owner->GetAbsAngles(), &vForward );
|
|
Vector vecOrigin = owner->EyePosition() + (vForward * flFrontDistance);
|
|
UTIL_SetOrigin( pShield, vecOrigin );
|
|
|
|
pShield->ChangeTeam( owner->GetTeamNumber() );
|
|
pShield->SetupRecharge( shield_mobile_power.GetFloat(), shield_mobile_recharge_delay.GetFloat(), shield_mobile_recharge_amount.GetFloat(), shield_mobile_recharge_time.GetFloat() );
|
|
pShield->Spawn();
|
|
|
|
return pShield;
|
|
}
|
|
|
|
#endif
|
|
|