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.
3432 lines
92 KiB
3432 lines
92 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
//=============================================================================// |
|
|
|
#include "cbase.h" |
|
#include "soundenvelope.h" |
|
#include "npc_manhack.h" |
|
#include "ai_default.h" |
|
#include "ai_node.h" |
|
#include "ai_navigator.h" |
|
#include "ai_pathfinder.h" |
|
#include "ai_moveprobe.h" |
|
#include "ai_memory.h" |
|
#include "ai_squad.h" |
|
#include "ai_route.h" |
|
#include "explode.h" |
|
#include "basegrenade_shared.h" |
|
#include "ndebugoverlay.h" |
|
#include "decals.h" |
|
#include "gib.h" |
|
#include "game.h" |
|
#include "ai_interactions.h" |
|
#include "IEffects.h" |
|
#include "vstdlib/random.h" |
|
#include "engine/IEngineSound.h" |
|
#include "movevars_shared.h" |
|
#include "npcevent.h" |
|
#include "props.h" |
|
#include "te_effect_dispatch.h" |
|
#include "ai_squadslot.h" |
|
#include "world.h" |
|
#include "smoke_trail.h" |
|
#include "func_break.h" |
|
#include "physics_impact_damage.h" |
|
#include "weapon_physcannon.h" |
|
#include "physics_prop_ragdoll.h" |
|
#include "soundent.h" |
|
#include "ammodef.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
// When the engine is running and the manhack is operating under power |
|
// we don't let gravity affect him. |
|
#define MANHACK_GRAVITY 0.000 |
|
|
|
#define MANHACK_GIB_COUNT 5 |
|
#define MANHACK_INGORE_WATER_DIST 384 |
|
|
|
// Sound stuff |
|
#define MANHACK_PITCH_DIST1 512 |
|
#define MANHACK_MIN_PITCH1 (100) |
|
#define MANHACK_MAX_PITCH1 (160) |
|
#define MANHACK_WATER_PITCH1 (85) |
|
#define MANHACK_VOLUME1 0.55 |
|
|
|
#define MANHACK_PITCH_DIST2 400 |
|
#define MANHACK_MIN_PITCH2 (85) |
|
#define MANHACK_MAX_PITCH2 (190) |
|
#define MANHACK_WATER_PITCH2 (90) |
|
|
|
#define MANHACK_NOISEMOD_HIDE 5000 |
|
|
|
#define MANHACK_BODYGROUP_BLADE 1 |
|
#define MANHACK_BODYGROUP_BLUR 2 |
|
#define MANHACK_BODYGROUP_OFF 0 |
|
#define MANHACK_BODYGROUP_ON 1 |
|
|
|
// ANIMATION EVENTS |
|
#define MANHACK_AE_START_ENGINE 50 |
|
#define MANHACK_AE_DONE_UNPACKING 51 |
|
#define MANHACK_AE_OPEN_BLADE 52 |
|
|
|
//#define MANHACK_GLOW_SPRITE "sprites/laserdot.vmt" |
|
#define MANHACK_GLOW_SPRITE "sprites/glow1.vmt" |
|
|
|
#define MANHACK_CHARGE_MIN_DIST 200 |
|
|
|
ConVar sk_manhack_health( "sk_manhack_health","0"); |
|
ConVar sk_manhack_melee_dmg( "sk_manhack_melee_dmg","0"); |
|
ConVar sk_manhack_v2( "sk_manhack_v2","1"); |
|
|
|
extern void SpawnBlood(Vector vecSpot, const Vector &vAttackDir, int bloodColor, float flDamage); |
|
extern float GetFloorZ(const Vector &origin); |
|
|
|
//----------------------------------------------------------------------------- |
|
// Private activities. |
|
//----------------------------------------------------------------------------- |
|
Activity ACT_MANHACK_UNPACK; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Manhack Conditions |
|
//----------------------------------------------------------------------------- |
|
enum ManhackConditions |
|
{ |
|
COND_MANHACK_START_ATTACK = LAST_SHARED_CONDITION, // We are able to do a bombing run on the current enemy. |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Manhack schedules. |
|
//----------------------------------------------------------------------------- |
|
enum ManhackSchedules |
|
{ |
|
SCHED_MANHACK_ATTACK_HOVER = LAST_SHARED_SCHEDULE, |
|
SCHED_MANHACK_DEPLOY, |
|
SCHED_MANHACK_REGROUP, |
|
SCHED_MANHACK_SWARM_IDLE, |
|
SCHED_MANHACK_SWARM, |
|
SCHED_MANHACK_SWARM_FAILURE, |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Manhack tasks. |
|
//----------------------------------------------------------------------------- |
|
enum ManhackTasks |
|
{ |
|
TASK_MANHACK_HOVER = LAST_SHARED_TASK, |
|
TASK_MANHACK_UNPACK, |
|
TASK_MANHACK_FIND_SQUAD_CENTER, |
|
TASK_MANHACK_FIND_SQUAD_MEMBER, |
|
TASK_MANHACK_MOVEAT_SAVEPOSITION, |
|
}; |
|
|
|
BEGIN_DATADESC( CNPC_Manhack ) |
|
|
|
DEFINE_FIELD( m_vForceVelocity, FIELD_VECTOR), |
|
|
|
DEFINE_FIELD( m_vTargetBanking, FIELD_VECTOR), |
|
DEFINE_FIELD( m_vForceMoveTarget, FIELD_POSITION_VECTOR), |
|
DEFINE_FIELD( m_fForceMoveTime, FIELD_TIME), |
|
DEFINE_FIELD( m_vSwarmMoveTarget, FIELD_POSITION_VECTOR), |
|
DEFINE_FIELD( m_fSwarmMoveTime, FIELD_TIME), |
|
DEFINE_FIELD( m_fEnginePowerScale, FIELD_FLOAT), |
|
|
|
DEFINE_FIELD( m_flNextEngineSoundTime, FIELD_TIME), |
|
DEFINE_FIELD( m_flEngineStallTime, FIELD_TIME), |
|
DEFINE_FIELD( m_flNextBurstTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_flWaterSuspendTime, FIELD_TIME), |
|
DEFINE_FIELD( m_nLastSpinSound, FIELD_INTEGER ), |
|
|
|
// Death |
|
DEFINE_FIELD( m_fSparkTime, FIELD_TIME), |
|
DEFINE_FIELD( m_fSmokeTime, FIELD_TIME), |
|
|
|
DEFINE_FIELD( m_bDirtyPitch, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( m_bGib, FIELD_BOOLEAN), |
|
DEFINE_FIELD( m_bHeld, FIELD_BOOLEAN), |
|
|
|
DEFINE_FIELD( m_bHackedByAlyx, FIELD_BOOLEAN), |
|
DEFINE_FIELD( m_vecLoiterPosition, FIELD_POSITION_VECTOR), |
|
DEFINE_FIELD( m_fTimeNextLoiterPulse, FIELD_TIME), |
|
|
|
DEFINE_FIELD( m_flBumpSuppressTime, FIELD_TIME ), |
|
|
|
DEFINE_FIELD( m_bBladesActive, FIELD_BOOLEAN), |
|
DEFINE_FIELD( m_flBladeSpeed, FIELD_FLOAT), |
|
DEFINE_KEYFIELD( m_bIgnoreClipbrushes, FIELD_BOOLEAN, "ignoreclipbrushes" ), |
|
DEFINE_FIELD( m_hSmokeTrail, FIELD_EHANDLE), |
|
|
|
// DEFINE_FIELD( m_pLightGlow, FIELD_CLASSPTR ), |
|
// DEFINE_FIELD( m_pEyeGlow, FIELD_CLASSPTR ), |
|
|
|
DEFINE_FIELD( m_iPanel1, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_iPanel2, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_iPanel3, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_iPanel4, FIELD_INTEGER ), |
|
|
|
DEFINE_FIELD( m_nLastWaterLevel, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_bDoSwarmBehavior, FIELD_BOOLEAN ), |
|
|
|
DEFINE_FIELD( m_nEnginePitch1, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_flEnginePitch1Time, FIELD_TIME ), |
|
DEFINE_FIELD( m_nEnginePitch2, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_flEnginePitch2Time, FIELD_TIME ), |
|
|
|
// Physics Influence |
|
DEFINE_FIELD( m_hPhysicsAttacker, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_flLastPhysicsInfluenceTime, FIELD_TIME ), |
|
|
|
DEFINE_FIELD( m_flBurstDuration, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_vecBurstDirection, FIELD_VECTOR ), |
|
DEFINE_FIELD( m_bShowingHostile, FIELD_BOOLEAN ), |
|
|
|
// Function Pointers |
|
DEFINE_INPUTFUNC( FIELD_VOID, "DisableSwarm", InputDisableSwarm ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "Unpack", InputUnpack ), |
|
|
|
DEFINE_ENTITYFUNC( CrashTouch ), |
|
|
|
DEFINE_BASENPCINTERACTABLE_DATADESC(), |
|
|
|
END_DATADESC() |
|
|
|
|
|
LINK_ENTITY_TO_CLASS( npc_manhack, CNPC_Manhack ); |
|
|
|
IMPLEMENT_SERVERCLASS_ST(CNPC_Manhack, DT_NPC_Manhack) |
|
SendPropIntWithMinusOneFlag (SENDINFO(m_nEnginePitch1), 8 ), |
|
SendPropFloat(SENDINFO(m_flEnginePitch1Time), 0, SPROP_NOSCALE), |
|
SendPropIntWithMinusOneFlag(SENDINFO(m_nEnginePitch2), 8 ) |
|
END_SEND_TABLE() |
|
|
|
|
|
|
|
//------------------------------------------------------------------------------ |
|
// Purpose : |
|
// Input : |
|
// Output : |
|
//------------------------------------------------------------------------------ |
|
CNPC_Manhack::CNPC_Manhack() |
|
{ |
|
#ifdef _DEBUG |
|
m_vForceMoveTarget.Init(); |
|
m_vSwarmMoveTarget.Init(); |
|
m_vTargetBanking.Init(); |
|
m_vForceVelocity.Init(); |
|
#endif |
|
m_bDirtyPitch = true; |
|
m_nLastWaterLevel = 0; |
|
m_nEnginePitch1 = -1; |
|
m_nEnginePitch2 = -1; |
|
m_flEnginePitch1Time = 0; |
|
m_flEnginePitch1Time = 0; |
|
m_bDoSwarmBehavior = true; |
|
m_flBumpSuppressTime = 0; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Purpose: |
|
//------------------------------------------------------------------------------ |
|
CNPC_Manhack::~CNPC_Manhack() |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Indicates this NPC's place in the relationship table. |
|
//----------------------------------------------------------------------------- |
|
Class_T CNPC_Manhack::Classify(void) |
|
{ |
|
return (m_bHeld||m_bHackedByAlyx) ? CLASS_PLAYER_ALLY : CLASS_MANHACK; |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Turns the manhack into a physics corpse when dying. |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::Event_Dying(void) |
|
{ |
|
DestroySmokeTrail(); |
|
SetHullSizeNormal(); |
|
BaseClass::Event_Dying(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::GatherConditions() |
|
{ |
|
BaseClass::GatherConditions(); |
|
|
|
if( IsLoitering() && GetEnemy() ) |
|
{ |
|
StopLoitering(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::PrescheduleThink( void ) |
|
{ |
|
BaseClass::PrescheduleThink(); |
|
|
|
UpdatePanels(); |
|
|
|
if( m_flWaterSuspendTime > gpGlobals->curtime ) |
|
{ |
|
// Stuck in water! |
|
|
|
// Reduce engine power so that the manhack lifts out of the water slowly. |
|
m_fEnginePowerScale = 0.75; |
|
} |
|
|
|
// ---------------------------------------- |
|
// Am I in water? |
|
// ---------------------------------------- |
|
if ( GetWaterLevel() > 0 ) |
|
{ |
|
if( m_nLastWaterLevel == 0 ) |
|
{ |
|
Splash( WorldSpaceCenter() ); |
|
} |
|
|
|
if( IsAlive() ) |
|
{ |
|
// If I've been out of water for 2 seconds or more, I'm eligible to be stuck in water again. |
|
if( gpGlobals->curtime - m_flWaterSuspendTime > 2.0 ) |
|
{ |
|
m_flWaterSuspendTime = gpGlobals->curtime + 1.0; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if( m_nLastWaterLevel != 0 ) |
|
{ |
|
Splash( WorldSpaceCenter() ); |
|
} |
|
} |
|
|
|
m_nLastWaterLevel = GetWaterLevel(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator ) |
|
{ |
|
g_vecAttackDir = vecDir; |
|
|
|
if ( info.GetDamageType() & DMG_BULLET) |
|
{ |
|
g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal); |
|
} |
|
|
|
if ( info.GetDamageType() & DMG_CLUB ) |
|
{ |
|
// Clubbed! |
|
// UTIL_Smoke(GetAbsOrigin(), random->RandomInt(10, 15), 10); |
|
g_pEffects->Sparks( ptr->endpos, 1, 1, &ptr->plane.normal ); |
|
} |
|
|
|
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::DeathSound( const CTakeDamageInfo &info ) |
|
{ |
|
StopSound("NPC_Manhack.Stunned"); |
|
CPASAttenuationFilter filter2( this, "NPC_Manhack.Die" ); |
|
EmitSound( filter2, entindex(), "NPC_Manhack.Die" ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CNPC_Manhack::ShouldGib( const CTakeDamageInfo &info ) |
|
{ |
|
return ( m_bGib ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::Event_Killed( const CTakeDamageInfo &info ) |
|
{ |
|
// turn off the blur! |
|
SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF ); |
|
|
|
// Sparks |
|
for (int i = 0; i < 3; i++) |
|
{ |
|
Vector sparkPos = GetAbsOrigin(); |
|
sparkPos.x += random->RandomFloat(-12,12); |
|
sparkPos.y += random->RandomFloat(-12,12); |
|
sparkPos.z += random->RandomFloat(-12,12); |
|
g_pEffects->Sparks( sparkPos, 2 ); |
|
} |
|
|
|
// Light |
|
CBroadcastRecipientFilter filter; |
|
te->DynamicLight( filter, 0.0, &GetAbsOrigin(), 255, 180, 100, 0, 100, 0.1, 0 ); |
|
|
|
if ( m_nEnginePitch1 < 0 ) |
|
{ |
|
// Probably this manhack was killed immediately after spawning. Turn the sound |
|
// on right now so that we can pitch it up for the crash! |
|
SoundInit(); |
|
} |
|
|
|
// Always gib when clubbed or blasted or crushed, or just randomly |
|
if ( ( info.GetDamageType() & (DMG_CLUB|DMG_CRUSH|DMG_BLAST) ) || ( random->RandomInt( 0, 1 ) ) ) |
|
{ |
|
m_bGib = true; |
|
} |
|
else |
|
{ |
|
m_bGib = false; |
|
|
|
//FIXME: These don't stay with the ragdolls currently -- jdw |
|
// Long fadeout on the sprites!! |
|
KillSprites( 0.0f ); |
|
} |
|
|
|
BaseClass::Event_Killed( info ); |
|
} |
|
|
|
void CNPC_Manhack::HitPhysicsObject( CBaseEntity *pOther ) |
|
{ |
|
IPhysicsObject *pOtherPhysics = pOther->VPhysicsGetObject(); |
|
Vector pos, posOther; |
|
// Put the force on the line between the manhack origin and hit object origin |
|
VPhysicsGetObject()->GetPosition( &pos, NULL ); |
|
pOtherPhysics->GetPosition( &posOther, NULL ); |
|
Vector dir = posOther - pos; |
|
VectorNormalize(dir); |
|
// size/2 is approx radius |
|
pos += dir * WorldAlignSize().x * 0.5; |
|
Vector cross; |
|
|
|
// UNDONE: Use actual manhack up vector so the fake blade is |
|
// in the right plane? |
|
// Get a vector in the x/y plane in the direction of blade spin (clockwise) |
|
CrossProduct( dir, Vector(0,0,1), cross ); |
|
VectorNormalize( cross ); |
|
// force is a 30kg object going 100 in/s |
|
pOtherPhysics->ApplyForceOffset( cross * 30 * 100, pos ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Take damage from being thrown by a physcannon |
|
//----------------------------------------------------------------------------- |
|
#define MANHACK_SMASH_SPEED 500.0 // How fast a manhack must slam into something to take full damage |
|
void CNPC_Manhack::TakeDamageFromPhyscannon( CBasePlayer *pPlayer ) |
|
{ |
|
CTakeDamageInfo info; |
|
info.SetDamageType( DMG_GENERIC ); |
|
info.SetInflictor( this ); |
|
info.SetAttacker( pPlayer ); |
|
info.SetDamagePosition( GetAbsOrigin() ); |
|
info.SetDamageForce( Vector( 1.0, 1.0, 1.0 ) ); |
|
|
|
// Convert velocity into damage. |
|
Vector vel; |
|
VPhysicsGetObject()->GetVelocity( &vel, NULL ); |
|
float flSpeed = vel.Length(); |
|
|
|
float flFactor = flSpeed / MANHACK_SMASH_SPEED; |
|
|
|
// Clamp. Don't inflict negative damage or massive damage! |
|
flFactor = clamp( flFactor, 0.0f, 2.0f ); |
|
float flDamage = m_iMaxHealth * flFactor; |
|
|
|
#if 0 |
|
Msg("Doing %f damage for %f speed!\n", flDamage, flSpeed ); |
|
#endif |
|
|
|
info.SetDamage( flDamage ); |
|
TakeDamage( info ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Take damage from a vehicle; it's like a really big crowbar |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::TakeDamageFromVehicle( int index, gamevcollisionevent_t *pEvent ) |
|
{ |
|
// Use the vehicle velocity to determine the damage |
|
int otherIndex = !index; |
|
CBaseEntity *pOther = pEvent->pEntities[otherIndex]; |
|
|
|
float flSpeed = pEvent->preVelocity[ otherIndex ].Length(); |
|
flSpeed = clamp( flSpeed, 300.0f, 600.0f ); |
|
float flDamage = SimpleSplineRemapVal( flSpeed, 300.0f, 600.0f, 0.0f, 1.0f ); |
|
if ( flDamage == 0.0f ) |
|
return; |
|
|
|
flDamage *= 20.0f; |
|
|
|
Vector damagePos; |
|
pEvent->pInternalData->GetContactPoint( damagePos ); |
|
|
|
Vector damageForce = 2.0f * pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass(); |
|
if ( damageForce == vec3_origin ) |
|
{ |
|
// This can happen if this entity is a func_breakable, and can't move. |
|
// Use the velocity of the entity that hit us instead. |
|
damageForce = 2.0f * pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass(); |
|
} |
|
Assert( damageForce != vec3_origin ); |
|
CTakeDamageInfo dmgInfo( pOther, pOther, damageForce, damagePos, flDamage, DMG_CRUSH ); |
|
TakeDamage( dmgInfo ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Take damage from combine ball |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::TakeDamageFromPhysicsImpact( int index, gamevcollisionevent_t *pEvent ) |
|
{ |
|
CBaseEntity *pHitEntity = pEvent->pEntities[!index]; |
|
|
|
// NOTE: Bypass the normal impact energy scale here. |
|
float flDamageScale = PlayerHasMegaPhysCannon() ? 10.0f : 1.0f; |
|
int damageType = 0; |
|
float damage = CalculateDefaultPhysicsDamage( index, pEvent, flDamageScale, true, damageType ); |
|
if ( damage == 0 ) |
|
return; |
|
|
|
Vector damagePos; |
|
pEvent->pInternalData->GetContactPoint( damagePos ); |
|
Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass(); |
|
if ( damageForce == vec3_origin ) |
|
{ |
|
// This can happen if this entity is motion disabled, and can't move. |
|
// Use the velocity of the entity that hit us instead. |
|
damageForce = pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass(); |
|
} |
|
|
|
// FIXME: this doesn't pass in who is responsible if some other entity "caused" this collision |
|
PhysCallbackDamage( this, CTakeDamageInfo( pHitEntity, pHitEntity, damageForce, damagePos, damage, damageType ), *pEvent, index ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
#define MANHACK_SMASH_TIME 0.35 // How long after being thrown from a physcannon that a manhack is eligible to die from impact |
|
void CNPC_Manhack::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) |
|
{ |
|
BaseClass::VPhysicsCollision( index, pEvent ); |
|
|
|
// Take no impact damage while being carried. |
|
if ( IsHeldByPhyscannon() ) |
|
return; |
|
|
|
// Wake us up |
|
if ( m_spawnflags & SF_MANHACK_PACKED_UP ) |
|
{ |
|
SetCondition( COND_LIGHT_DAMAGE ); |
|
} |
|
|
|
int otherIndex = !index; |
|
CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex]; |
|
|
|
CBasePlayer *pPlayer = HasPhysicsAttacker( MANHACK_SMASH_TIME ); |
|
if( pPlayer ) |
|
{ |
|
if (!pHitEntity) |
|
{ |
|
TakeDamageFromPhyscannon( pPlayer ); |
|
StopBurst( true ); |
|
return; |
|
} |
|
|
|
// Don't take damage from NPCs or server ragdolls killed by the manhack |
|
CRagdollProp *pRagdollProp = dynamic_cast<CRagdollProp*>(pHitEntity); |
|
if (!pHitEntity->IsNPC() && (!pRagdollProp || pRagdollProp->GetKiller() != this)) |
|
{ |
|
TakeDamageFromPhyscannon( pPlayer ); |
|
StopBurst( true ); |
|
return; |
|
} |
|
} |
|
|
|
if ( pHitEntity ) |
|
{ |
|
// It can take physics damage if it rams into a vehicle |
|
if ( pHitEntity->GetServerVehicle() ) |
|
{ |
|
TakeDamageFromVehicle( index, pEvent ); |
|
} |
|
else if ( pHitEntity->HasPhysicsAttacker( 0.5f ) ) |
|
{ |
|
// It also can take physics damage from things thrown by the player. |
|
TakeDamageFromPhysicsImpact( index, pEvent ); |
|
} |
|
else if ( FClassnameIs( pHitEntity, "prop_combine_ball" ) ) |
|
{ |
|
// It also can take physics damage from a combine ball. |
|
TakeDamageFromPhysicsImpact( index, pEvent ); |
|
} |
|
else if ( m_iHealth <= 0 ) |
|
{ |
|
TakeDamageFromPhysicsImpact( index, pEvent ); |
|
} |
|
|
|
StopBurst( true ); |
|
} |
|
} |
|
|
|
|
|
void CNPC_Manhack::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent ) |
|
{ |
|
int otherIndex = !index; |
|
CBaseEntity *pOther = pEvent->pEntities[otherIndex]; |
|
|
|
if ( pOther->GetMoveType() == MOVETYPE_VPHYSICS ) |
|
{ |
|
HitPhysicsObject( pOther ); |
|
} |
|
BaseClass::VPhysicsShadowCollision( index, pEvent ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Manhack is out of control! (dying) Just explode as soon as you touch anything! |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::CrashTouch( CBaseEntity *pOther ) |
|
{ |
|
CTakeDamageInfo info( GetWorldEntity(), GetWorldEntity(), 25, DMG_CRUSH ); |
|
|
|
CorpseGib( info ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Create smoke trail! |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::CreateSmokeTrail() |
|
{ |
|
if ( HasSpawnFlags( SF_MANHACK_NO_DAMAGE_EFFECTS ) ) |
|
return; |
|
|
|
if ( m_hSmokeTrail != NULL ) |
|
return; |
|
|
|
SmokeTrail *pSmokeTrail = SmokeTrail::CreateSmokeTrail(); |
|
if( !pSmokeTrail ) |
|
return; |
|
|
|
pSmokeTrail->m_SpawnRate = 20; |
|
pSmokeTrail->m_ParticleLifetime = 0.5f; |
|
pSmokeTrail->m_StartSize = 8; |
|
pSmokeTrail->m_EndSize = 32; |
|
pSmokeTrail->m_SpawnRadius = 5; |
|
pSmokeTrail->m_MinSpeed = 15; |
|
pSmokeTrail->m_MaxSpeed = 25; |
|
|
|
pSmokeTrail->m_StartColor.Init( 0.4f, 0.4f, 0.4f ); |
|
pSmokeTrail->m_EndColor.Init( 0, 0, 0 ); |
|
|
|
pSmokeTrail->SetLifetime(-1); |
|
pSmokeTrail->FollowEntity(this); |
|
|
|
m_hSmokeTrail = pSmokeTrail; |
|
} |
|
|
|
void CNPC_Manhack::DestroySmokeTrail() |
|
{ |
|
if ( m_hSmokeTrail.Get() ) |
|
{ |
|
UTIL_Remove( m_hSmokeTrail ); |
|
m_hSmokeTrail = NULL; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
int CNPC_Manhack::OnTakeDamage_Alive( const CTakeDamageInfo &info ) |
|
{ |
|
// Hafta make a copy of info cause we might need to scale damage.(sjb) |
|
CTakeDamageInfo tdInfo = info; |
|
|
|
if( tdInfo.GetAmmoType() == GetAmmoDef()->Index("SniperRound") ) |
|
{ |
|
// Unfortunately, this is the easiest way to stop the sniper killing manhacks in one shot. |
|
tdInfo.SetDamage( m_iMaxHealth>>1 ); |
|
} |
|
|
|
if (info.GetDamageType() & DMG_PHYSGUN ) |
|
{ |
|
m_flBladeSpeed = 20.0; |
|
|
|
// respond to physics |
|
// FIXME: shouldn't this happen in a base class? Anyway to prevent it from happening twice? |
|
VPhysicsTakeDamage( info ); |
|
|
|
// reduce damage to nothing |
|
tdInfo.SetDamage( 1.0 ); |
|
|
|
StopBurst( true ); |
|
} |
|
else if ( info.GetDamageType() & DMG_AIRBOAT ) |
|
{ |
|
// Airboat gun kills me instantly. |
|
tdInfo.SetDamage( GetHealth() ); |
|
} |
|
else if (info.GetDamageType() & DMG_CLUB) |
|
{ |
|
// Being hit by a club means a couple of things: |
|
// |
|
// -I'm going to be knocked away from the person that clubbed me. |
|
// if fudging this vector a little bit could help me slam into a physics object, |
|
// then make that adjustment. This is a simple heuristic. The manhack will be |
|
// directed towards the physics object that is closest to g_vecAttackDir |
|
// |
|
|
|
// -Take 150% damage from club attacks. This makes crowbar duels take two hits. |
|
|
|
tdInfo.ScaleDamage( 1.50 ); |
|
|
|
#define MANHACK_PHYS_SEARCH_SIZE 64 |
|
#define MANHACK_PHYSICS_SEARCH_RADIUS 128 |
|
|
|
CBaseEntity *pList[ MANHACK_PHYS_SEARCH_SIZE ]; |
|
|
|
Vector attackDir = info.GetDamageForce(); |
|
VectorNormalize( attackDir ); |
|
|
|
Vector testCenter = GetAbsOrigin() + ( attackDir * MANHACK_PHYSICS_SEARCH_RADIUS ); |
|
Vector vecDelta( MANHACK_PHYSICS_SEARCH_RADIUS, MANHACK_PHYSICS_SEARCH_RADIUS, MANHACK_PHYSICS_SEARCH_RADIUS ); |
|
|
|
int count = UTIL_EntitiesInBox( pList, MANHACK_PHYS_SEARCH_SIZE, testCenter - vecDelta, testCenter + vecDelta, 0 ); |
|
|
|
Vector vecBestDir = g_vecAttackDir; |
|
float flBestDot = 0.90; |
|
IPhysicsObject *pPhysObj; |
|
|
|
int i; |
|
for( i = 0 ; i < count ; i++ ) |
|
{ |
|
pPhysObj = pList[ i ]->VPhysicsGetObject(); |
|
|
|
if( !pPhysObj || pPhysObj->GetMass() > 200 ) |
|
{ |
|
// Not physics. |
|
continue; |
|
} |
|
|
|
Vector center = pList[ i ]->WorldSpaceCenter(); |
|
|
|
Vector vecDirToObject; |
|
VectorSubtract( center, WorldSpaceCenter(), vecDirToObject ); |
|
VectorNormalize( vecDirToObject ); |
|
|
|
float flDot; |
|
|
|
flDot = DotProduct( g_vecAttackDir, vecDirToObject ); |
|
|
|
|
|
if( flDot > flBestDot ) |
|
{ |
|
flBestDot = flDot; |
|
vecBestDir = vecDirToObject; |
|
} |
|
} |
|
|
|
tdInfo.SetDamageForce( vecBestDir * info.GetDamage() * 200 ); |
|
|
|
// FIXME: shouldn't this happen in a base class? Anyway to prevent it from happening twice? |
|
VPhysicsTakeDamage( tdInfo ); |
|
|
|
// Force us away (no more residual speed hits!) |
|
m_vForceVelocity = vecBestDir * info.GetDamage() * 0.5f; |
|
m_flBladeSpeed = 10.0; |
|
|
|
EmitSound( "NPC_Manhack.Bat" ); |
|
|
|
// tdInfo.SetDamage( 1.0 ); |
|
|
|
m_flEngineStallTime = gpGlobals->curtime + 0.5f; |
|
StopBurst( true ); |
|
} |
|
else |
|
{ |
|
m_flBladeSpeed = 20.0; |
|
|
|
Vector vecDamageDir = tdInfo.GetDamageForce(); |
|
VectorNormalize( vecDamageDir ); |
|
|
|
m_flEngineStallTime = gpGlobals->curtime + 0.25f; |
|
m_vForceVelocity = vecDamageDir * info.GetDamage() * 20.0f; |
|
|
|
tdInfo.SetDamageForce( tdInfo.GetDamageForce() * 20 ); |
|
|
|
VPhysicsTakeDamage( info ); |
|
} |
|
|
|
int nRetVal = BaseClass::OnTakeDamage_Alive( tdInfo ); |
|
if ( nRetVal ) |
|
{ |
|
if ( m_iHealth > 0 ) |
|
{ |
|
if ( info.GetDamageType() & DMG_CLUB ) |
|
{ |
|
SetEyeState( MANHACK_EYE_STATE_STUNNED ); |
|
} |
|
|
|
if ( m_iHealth <= ( m_iMaxHealth / 2 ) ) |
|
{ |
|
CreateSmokeTrail(); |
|
} |
|
} |
|
else |
|
{ |
|
DestroySmokeTrail(); |
|
} |
|
} |
|
|
|
return nRetVal; |
|
} |
|
|
|
|
|
//------------------------------------------------------------------------------ |
|
// Purpose: |
|
//------------------------------------------------------------------------------ |
|
bool CNPC_Manhack::CorpseGib( const CTakeDamageInfo &info ) |
|
{ |
|
Vector vecGibVelocity; |
|
AngularImpulse vecGibAVelocity; |
|
|
|
if( info.GetDamageType() & DMG_CLUB ) |
|
{ |
|
// If clubbed to death, break apart before the attacker's eyes! |
|
vecGibVelocity = g_vecAttackDir * -150; |
|
|
|
vecGibAVelocity.x = random->RandomFloat( -2000, 2000 ); |
|
vecGibAVelocity.y = random->RandomFloat( -2000, 2000 ); |
|
vecGibAVelocity.z = random->RandomFloat( -2000, 2000 ); |
|
} |
|
else |
|
{ |
|
// Shower the pieces with my velocity. |
|
vecGibVelocity = GetCurrentVelocity(); |
|
|
|
vecGibAVelocity.x = random->RandomFloat( -500, 500 ); |
|
vecGibAVelocity.y = random->RandomFloat( -500, 500 ); |
|
vecGibAVelocity.z = random->RandomFloat( -500, 500 ); |
|
} |
|
|
|
PropBreakableCreateAll( GetModelIndex(), NULL, GetAbsOrigin(), GetAbsAngles(), vecGibVelocity, vecGibAVelocity, 1.0, 60, COLLISION_GROUP_DEBRIS ); |
|
|
|
RemoveDeferred(); |
|
|
|
KillSprites( 0.0f ); |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Explode the manhack if it's damaged while crashing |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
int CNPC_Manhack::OnTakeDamage_Dying( const CTakeDamageInfo &info ) |
|
{ |
|
// Ignore damage for the first 1 second of crashing behavior. |
|
// If we don't do this, manhacks always just explode under |
|
// sustained fire. |
|
VPhysicsTakeDamage( info ); |
|
|
|
return 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Turn on the engine sound if we're gagged! |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::OnStateChange( NPC_STATE OldState, NPC_STATE NewState ) |
|
{ |
|
if( m_vNoiseMod.z == MANHACK_NOISEMOD_HIDE && !(m_spawnflags & SF_NPC_WAIT_FOR_SCRIPT) && !(m_spawnflags & SF_MANHACK_PACKED_UP) ) |
|
{ |
|
// This manhack should get a normal noisemod now. |
|
float flNoiseMod = random->RandomFloat( 1.7, 2.3 ); |
|
|
|
// Just bob up and down. |
|
SetNoiseMod( 0, 0, flNoiseMod ); |
|
} |
|
|
|
if( NewState != NPC_STATE_IDLE && (m_spawnflags & SF_NPC_GAG) && (m_nEnginePitch1 < 0) ) |
|
{ |
|
m_spawnflags &= ~SF_NPC_GAG; |
|
SoundInit(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : Type - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::HandleAnimEvent( animevent_t *pEvent ) |
|
{ |
|
Vector vecNewVelocity; |
|
switch( pEvent->event ) |
|
{ |
|
case MANHACK_AE_START_ENGINE: |
|
StartEye(); |
|
StartEngine( true ); |
|
m_spawnflags &= ~SF_MANHACK_PACKED_UP; |
|
|
|
// No bursts until fully unpacked! |
|
m_flNextBurstTime = gpGlobals->curtime + FLT_MAX; |
|
break; |
|
|
|
case MANHACK_AE_DONE_UNPACKING: |
|
m_flNextBurstTime = gpGlobals->curtime + 2.0; |
|
break; |
|
|
|
case MANHACK_AE_OPEN_BLADE: |
|
m_bBladesActive = true; |
|
break; |
|
|
|
default: |
|
BaseClass::HandleAnimEvent( pEvent ); |
|
break; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns whether or not the given activity would translate to flying. |
|
//----------------------------------------------------------------------------- |
|
bool CNPC_Manhack::IsFlyingActivity( Activity baseAct ) |
|
{ |
|
return ((baseAct == ACT_FLY || baseAct == ACT_IDLE || baseAct == ACT_RUN || baseAct == ACT_WALK) && m_bBladesActive); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : Type - |
|
//----------------------------------------------------------------------------- |
|
Activity CNPC_Manhack::NPC_TranslateActivity( Activity baseAct ) |
|
{ |
|
if (IsFlyingActivity( baseAct )) |
|
{ |
|
return (Activity)ACT_FLY; |
|
} |
|
|
|
return BaseClass::NPC_TranslateActivity( baseAct ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : Type - |
|
//----------------------------------------------------------------------------- |
|
int CNPC_Manhack::TranslateSchedule( int scheduleType ) |
|
{ |
|
// Fail-safe for deployment if packed up and interrupted |
|
if ( m_spawnflags & SF_MANHACK_PACKED_UP ) |
|
{ |
|
if ( scheduleType != SCHED_WAIT_FOR_SCRIPT ) |
|
return SCHED_MANHACK_DEPLOY; |
|
} |
|
|
|
switch ( scheduleType ) |
|
{ |
|
case SCHED_MELEE_ATTACK1: |
|
{ |
|
return SCHED_MANHACK_ATTACK_HOVER; |
|
break; |
|
} |
|
case SCHED_BACK_AWAY_FROM_ENEMY: |
|
{ |
|
return SCHED_MANHACK_REGROUP; |
|
break; |
|
} |
|
case SCHED_CHASE_ENEMY: |
|
{ |
|
// If we're waiting for our next attack opportunity, just swarm |
|
if ( m_flNextBurstTime > gpGlobals->curtime ) |
|
{ |
|
return SCHED_MANHACK_SWARM; |
|
} |
|
|
|
if ( !m_bDoSwarmBehavior || OccupyStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) ) |
|
{ |
|
return SCHED_CHASE_ENEMY; |
|
} |
|
else |
|
{ |
|
return SCHED_MANHACK_SWARM; |
|
} |
|
} |
|
case SCHED_COMBAT_FACE: |
|
{ |
|
// Don't care about facing enemy, handled automatically |
|
return TranslateSchedule( SCHED_CHASE_ENEMY ); |
|
break; |
|
} |
|
case SCHED_WAKE_ANGRY: |
|
{ |
|
if( m_spawnflags & SF_MANHACK_PACKED_UP ) |
|
{ |
|
return SCHED_MANHACK_DEPLOY; |
|
} |
|
else |
|
{ |
|
return TranslateSchedule( SCHED_CHASE_ENEMY ); |
|
} |
|
break; |
|
} |
|
|
|
case SCHED_IDLE_STAND: |
|
case SCHED_ALERT_STAND: |
|
case SCHED_ALERT_FACE: |
|
{ |
|
if ( m_pSquad && m_bDoSwarmBehavior ) |
|
{ |
|
return SCHED_MANHACK_SWARM_IDLE; |
|
} |
|
else |
|
{ |
|
return BaseClass::TranslateSchedule(scheduleType); |
|
} |
|
} |
|
|
|
case SCHED_CHASE_ENEMY_FAILED: |
|
{ |
|
// Relentless bastard! Doesn't fail (fail not valid anyway) |
|
return TranslateSchedule( SCHED_CHASE_ENEMY ); |
|
break; |
|
} |
|
|
|
} |
|
return BaseClass::TranslateSchedule(scheduleType); |
|
} |
|
|
|
#define MAX_LOITER_DIST_SQR 144 // (12 inches sqr) |
|
void CNPC_Manhack::Loiter() |
|
{ |
|
//NDebugOverlay::Line( GetAbsOrigin(), m_vecLoiterPosition, 255, 255, 255, false, 0.1 ); |
|
|
|
// Friendly manhack is loitering. |
|
if( !m_bHeld ) |
|
{ |
|
float distSqr = m_vecLoiterPosition.DistToSqr(GetAbsOrigin()); |
|
|
|
if( distSqr > MAX_LOITER_DIST_SQR ) |
|
{ |
|
Vector vecDir = m_vecLoiterPosition - GetAbsOrigin(); |
|
VectorNormalize( vecDir ); |
|
|
|
// Move back to our loiter position. |
|
if( gpGlobals->curtime > m_fTimeNextLoiterPulse ) |
|
{ |
|
// Apply a pulse of force if allowed right now. |
|
if( distSqr > MAX_LOITER_DIST_SQR * 4.0f ) |
|
{ |
|
//Msg("Big Pulse\n"); |
|
m_vForceVelocity = vecDir * 12.0f; |
|
} |
|
else |
|
{ |
|
//Msg("Small Pulse\n"); |
|
m_vForceVelocity = vecDir * 6.0f; |
|
} |
|
|
|
m_fTimeNextLoiterPulse = gpGlobals->curtime + 1.0f; |
|
} |
|
else |
|
{ |
|
m_vForceVelocity = vec3_origin; |
|
} |
|
} |
|
else |
|
{ |
|
// Counteract velocity to slow down. |
|
Vector velocity = GetCurrentVelocity(); |
|
m_vForceVelocity = velocity * -0.5; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::MaintainGroundHeight( void ) |
|
{ |
|
float zSpeed = GetCurrentVelocity().z; |
|
|
|
if ( zSpeed > 32.0f ) |
|
return; |
|
|
|
const float minGroundHeight = 52.0f; |
|
|
|
trace_t tr; |
|
AI_TraceHull( GetAbsOrigin(), |
|
GetAbsOrigin() - Vector( 0, 0, minGroundHeight ), |
|
GetHullMins(), |
|
GetHullMaxs(), |
|
(MASK_NPCSOLID_BRUSHONLY), |
|
this, |
|
COLLISION_GROUP_NONE, |
|
&tr ); |
|
|
|
if ( tr.fraction != 1.0f ) |
|
{ |
|
float speedAdj = MAX( 16, (-zSpeed*0.5f) ); |
|
|
|
m_vForceVelocity += Vector(0,0,1) * ( speedAdj * ( 1.0f - tr.fraction ) ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handles movement towards the last move target. |
|
// Input : flInterval - |
|
//----------------------------------------------------------------------------- |
|
bool CNPC_Manhack::OverrideMove( float flInterval ) |
|
{ |
|
SpinBlades( flInterval ); |
|
|
|
// Don't execute any move code if packed up. |
|
if( HasSpawnFlags(SF_MANHACK_PACKED_UP|SF_MANHACK_CARRIED) ) |
|
return true; |
|
|
|
if( IsLoitering() ) |
|
{ |
|
Loiter(); |
|
} |
|
else |
|
{ |
|
MaintainGroundHeight(); |
|
} |
|
|
|
// So cops, etc. will try to avoid them |
|
if ( !HasSpawnFlags( SF_MANHACK_NO_DANGER_SOUNDS ) && !m_bHeld ) |
|
{ |
|
CSoundEnt::InsertSound( SOUND_DANGER, GetAbsOrigin(), 75, flInterval, this ); |
|
} |
|
|
|
// ----------------------------------------------------------------- |
|
// If I'm being forced to move somewhere |
|
// ------------------------------------------------------------------ |
|
if (m_fForceMoveTime > gpGlobals->curtime) |
|
{ |
|
MoveToTarget(flInterval, m_vForceMoveTarget); |
|
} |
|
// ----------------------------------------------------------------- |
|
// If I have a route, keep it updated and move toward target |
|
// ------------------------------------------------------------------ |
|
else if (GetNavigator()->IsGoalActive()) |
|
{ |
|
bool bReducible = GetNavigator()->GetPath()->GetCurWaypoint()->IsReducible(); |
|
const float strictTolerance = 64.0; |
|
//NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, 10 ), 255, 0, 0, true, 0.1); |
|
if ( ProgressFlyPath( flInterval, GetEnemy(), MoveCollisionMask(), bReducible, strictTolerance ) == AINPP_COMPLETE ) |
|
return true; |
|
} |
|
// ----------------------------------------------------------------- |
|
// If I'm supposed to swarm somewhere, try to go there |
|
// ------------------------------------------------------------------ |
|
else if (m_fSwarmMoveTime > gpGlobals->curtime) |
|
{ |
|
MoveToTarget(flInterval, m_vSwarmMoveTarget); |
|
} |
|
// ----------------------------------------------------------------- |
|
// If I don't have anything better to do, just decelerate |
|
// -------------------------------------------------------------- ---- |
|
else |
|
{ |
|
float myDecay = 9.5; |
|
Decelerate( flInterval, myDecay ); |
|
|
|
m_vTargetBanking = vec3_origin; |
|
|
|
// ------------------------------------- |
|
// If I have an enemy turn to face him |
|
// ------------------------------------- |
|
if (GetEnemy()) |
|
{ |
|
TurnHeadToTarget(flInterval, GetEnemy()->EyePosition() ); |
|
} |
|
} |
|
|
|
if ( m_iHealth <= 0 ) |
|
{ |
|
// Crashing!! |
|
MoveExecute_Dead(flInterval); |
|
} |
|
else |
|
{ |
|
// Alive! |
|
MoveExecute_Alive(flInterval); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::TurnHeadRandomly(float flInterval ) |
|
{ |
|
float desYaw = random->RandomFloat(0,360); |
|
|
|
float iRate = 0.8; |
|
// Make frame rate independent |
|
float timeToUse = flInterval; |
|
while (timeToUse > 0) |
|
{ |
|
m_fHeadYaw = (iRate * m_fHeadYaw) + (1-iRate)*desYaw; |
|
timeToUse = -0.1; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::MoveToTarget(float flInterval, const Vector &vMoveTarget) |
|
{ |
|
if (flInterval <= 0) |
|
{ |
|
return; |
|
} |
|
|
|
// ----------------------------------------- |
|
// Don't steer if engine's have stalled |
|
// ----------------------------------------- |
|
if ( gpGlobals->curtime < m_flEngineStallTime || m_iHealth <= 0 ) |
|
return; |
|
|
|
if ( GetEnemy() != NULL ) |
|
{ |
|
TurnHeadToTarget( flInterval, GetEnemy()->EyePosition() ); |
|
} |
|
else |
|
{ |
|
TurnHeadToTarget( flInterval, vMoveTarget ); |
|
} |
|
|
|
// ------------------------------------- |
|
// Move towards our target |
|
// ------------------------------------- |
|
float myAccel; |
|
float myZAccel = 300.0f; |
|
float myDecay = 0.3f; |
|
|
|
Vector targetDir; |
|
float flDist; |
|
|
|
// If we're bursting, just head straight |
|
if ( m_flBurstDuration > gpGlobals->curtime ) |
|
{ |
|
float zDist = 500; |
|
|
|
// Steer towards our enemy if we're able to |
|
if ( GetEnemy() != NULL ) |
|
{ |
|
Vector steerDir = ( GetEnemy()->EyePosition() - GetAbsOrigin() ); |
|
zDist = fabs( steerDir.z ); |
|
VectorNormalize( steerDir ); |
|
|
|
float useTime = flInterval; |
|
while ( useTime > 0.0f ) |
|
{ |
|
m_vecBurstDirection += ( steerDir * 4.0f ); |
|
useTime -= 0.1f; |
|
} |
|
|
|
m_vecBurstDirection.z = steerDir.z; |
|
|
|
VectorNormalize( m_vecBurstDirection ); |
|
} |
|
|
|
// Debug visualizations |
|
/* |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( targetDir * 64.0f ), 255, 0, 0, true, 2.1f ); |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( steerDir * 64.0f ), 0, 255, 0, true, 2.1f ); |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( m_vecBurstDirection * 64.0f ), 0, 0, 255, true, 2.1f ); |
|
NDebugOverlay::Cross3D( GetAbsOrigin() , -Vector(8,8,8), Vector(8,8,8), 255, 0, 0, true, 2.1f ); |
|
*/ |
|
|
|
targetDir = m_vecBurstDirection; |
|
|
|
flDist = FLT_MAX; |
|
myDecay = 0.3f; |
|
#ifdef _XBOX |
|
myAccel = 500; |
|
#else |
|
myAccel = 400; |
|
#endif // _XBOX |
|
myZAccel = MIN( 500, zDist / flInterval ); |
|
} |
|
else |
|
{ |
|
Vector vecCurrentDir = GetCurrentVelocity(); |
|
VectorNormalize( vecCurrentDir ); |
|
|
|
targetDir = vMoveTarget - GetAbsOrigin(); |
|
flDist = VectorNormalize( targetDir ); |
|
|
|
float flDot = DotProduct( targetDir, vecCurrentDir ); |
|
|
|
// Otherwise we should steer towards our goal |
|
if( flDot > 0.25 ) |
|
{ |
|
// If my target is in front of me, my flight model is a bit more accurate. |
|
myAccel = 300; |
|
} |
|
else |
|
{ |
|
// Have a harder time correcting my course if I'm currently flying away from my target. |
|
myAccel = 200; |
|
} |
|
} |
|
|
|
// Clamp lateral acceleration |
|
if ( myAccel > ( flDist / flInterval ) ) |
|
{ |
|
myAccel = flDist / flInterval; |
|
} |
|
|
|
/* |
|
// Boost vertical movement |
|
if ( targetDir.z > 0 ) |
|
{ |
|
// Z acceleration is faster when we thrust upwards. |
|
// This is to help keep manhacks out of water. |
|
myZAccel *= 5.0; |
|
} |
|
*/ |
|
|
|
// Clamp vertical movement |
|
if ( myZAccel > flDist / flInterval ) |
|
{ |
|
myZAccel = flDist / flInterval; |
|
} |
|
|
|
// Scale by our engine force |
|
myAccel *= m_fEnginePowerScale; |
|
myZAccel *= m_fEnginePowerScale; |
|
|
|
MoveInDirection( flInterval, targetDir, myAccel, myZAccel, myDecay ); |
|
|
|
// calc relative banking targets |
|
Vector forward, right; |
|
GetVectors( &forward, &right, NULL ); |
|
m_vTargetBanking.x = 40 * DotProduct( forward, targetDir ); |
|
m_vTargetBanking.z = 40 * DotProduct( right, targetDir ); |
|
m_vTargetBanking.y = 0.0; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Ignore water if I'm close to my enemy |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
int CNPC_Manhack::MoveCollisionMask(void) |
|
{ |
|
return MASK_NPCSOLID; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Make a splash effect |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::Splash( const Vector &vecSplashPos ) |
|
{ |
|
CEffectData data; |
|
|
|
data.m_fFlags = 0; |
|
data.m_vOrigin = vecSplashPos; |
|
data.m_vNormal = Vector( 0, 0, 1 ); |
|
|
|
data.m_flScale = 8.0f; |
|
|
|
int contents = GetWaterType(); |
|
|
|
// Verify we have valid contents |
|
if ( !( contents & (CONTENTS_SLIME|CONTENTS_WATER))) |
|
{ |
|
// We're leaving the water so we have to reverify what it was |
|
trace_t tr; |
|
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 256 ), (CONTENTS_WATER|CONTENTS_SLIME), this, COLLISION_GROUP_NONE, &tr ); |
|
|
|
// Re-validate this |
|
if ( !(tr.contents&(CONTENTS_WATER|CONTENTS_SLIME)) ) |
|
{ |
|
//NOTENOTE: We called a splash but we don't seem to be near water? |
|
Assert( 0 ); |
|
return; |
|
} |
|
|
|
contents = tr.contents; |
|
} |
|
|
|
// Mark us if we're in slime |
|
if ( contents & CONTENTS_SLIME ) |
|
{ |
|
data.m_fFlags |= FX_WATER_IN_SLIME; |
|
} |
|
|
|
DispatchEffect( "watersplash", data ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the slice bounce velocity |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::ComputeSliceBounceVelocity( CBaseEntity *pHitEntity, trace_t &tr ) |
|
{ |
|
if( pHitEntity->IsAlive() && FClassnameIs( pHitEntity, "func_breakable_surf" ) ) |
|
{ |
|
// We want to see if the manhack hits a breakable pane of glass. To keep from checking |
|
// The classname of the HitEntity on each impact, we only do this check if we hit |
|
// something that's alive. Anyway, prevent the manhack bouncing off the pane of glass, |
|
// since this impact will shatter the glass and let the manhack through. |
|
return; |
|
} |
|
|
|
Vector vecDir; |
|
|
|
// If the manhack isn't bouncing away from whatever he sliced, force it. |
|
VectorSubtract( WorldSpaceCenter(), pHitEntity->WorldSpaceCenter(), vecDir ); |
|
VectorNormalize( vecDir ); |
|
vecDir *= 200; |
|
vecDir[2] = 0.0f; |
|
|
|
// Knock it away from us |
|
if ( VPhysicsGetObject() != NULL ) |
|
{ |
|
VPhysicsGetObject()->ApplyForceOffset( vecDir * 4, GetAbsOrigin() ); |
|
} |
|
|
|
// Also set our velocity |
|
SetCurrentVelocity( vecDir ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Is the manhack being held? |
|
//----------------------------------------------------------------------------- |
|
bool CNPC_Manhack::IsHeldByPhyscannon( ) |
|
{ |
|
return VPhysicsGetObject() && (VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: We've touched something that we can hurt. Slice it! |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::Slice( CBaseEntity *pHitEntity, float flInterval, trace_t &tr ) |
|
{ |
|
// Don't hurt the player if I'm in water |
|
if( GetWaterLevel() > 0 && pHitEntity->IsPlayer() ) |
|
return; |
|
|
|
// Can't slice players holding it with the phys cannon |
|
if ( IsHeldByPhyscannon() ) |
|
{ |
|
if ( pHitEntity && (pHitEntity == HasPhysicsAttacker( FLT_MAX )) ) |
|
return; |
|
} |
|
|
|
if ( pHitEntity->m_takedamage == DAMAGE_NO ) |
|
return; |
|
|
|
// Damage must be scaled by flInterval so framerate independent |
|
float flDamage = sk_manhack_melee_dmg.GetFloat() * flInterval; |
|
|
|
if ( pHitEntity->IsPlayer() ) |
|
{ |
|
flDamage *= 2.0f; |
|
} |
|
|
|
// Held manhacks do more damage |
|
if ( IsHeldByPhyscannon() ) |
|
{ |
|
// Deal 100 damage/sec |
|
flDamage = 100.0f * flInterval; |
|
} |
|
else if ( pHitEntity->IsNPC() && HasPhysicsAttacker( MANHACK_SMASH_TIME ) ) |
|
{ |
|
extern ConVar sk_combine_guard_health; |
|
// NOTE: The else here is essential. |
|
// The physics attacker *will* be set even when the manhack is held |
|
flDamage = sk_combine_guard_health.GetFloat(); // the highest healthed fleshy enemy |
|
} |
|
else if ( dynamic_cast<CBaseProp*>(pHitEntity) || dynamic_cast<CBreakable*>(pHitEntity) ) |
|
{ |
|
// If we hit a prop, we want it to break immediately |
|
flDamage = pHitEntity->GetHealth(); |
|
} |
|
else if ( pHitEntity->IsNPC() && IRelationType( pHitEntity ) == D_HT && FClassnameIs( pHitEntity, "npc_combine_s" ) ) |
|
{ |
|
flDamage *= 6.0f; |
|
} |
|
|
|
if (flDamage < 1.0f) |
|
{ |
|
flDamage = 1.0f; |
|
} |
|
|
|
CTakeDamageInfo info( this, this, flDamage, DMG_SLASH ); |
|
|
|
// check for actual "ownership" of damage |
|
CBasePlayer *pPlayer = HasPhysicsAttacker( MANHACK_SMASH_TIME ); |
|
if (pPlayer) |
|
{ |
|
info.SetAttacker( pPlayer ); |
|
} |
|
|
|
Vector dir = (tr.endpos - tr.startpos); |
|
if ( dir == vec3_origin ) |
|
{ |
|
dir = tr.m_pEnt->GetAbsOrigin() - GetAbsOrigin(); |
|
} |
|
CalculateMeleeDamageForce( &info, dir, tr.endpos ); |
|
pHitEntity->TakeDamage( info ); |
|
|
|
// Spawn some extra blood where we hit |
|
if ( pHitEntity->BloodColor() == DONT_BLEED ) |
|
{ |
|
CEffectData data; |
|
Vector velocity = GetCurrentVelocity(); |
|
|
|
data.m_vOrigin = tr.endpos; |
|
data.m_vAngles = GetAbsAngles(); |
|
|
|
VectorNormalize( velocity ); |
|
|
|
data.m_vNormal = ( tr.plane.normal + velocity ) * 0.5;; |
|
|
|
DispatchEffect( "ManhackSparks", data ); |
|
|
|
EmitSound( "NPC_Manhack.Grind" ); |
|
|
|
//TODO: What we really want to do is get a material reference and emit the proper sprayage! - jdw |
|
} |
|
else |
|
{ |
|
SpawnBlood(tr.endpos, g_vecAttackDir, pHitEntity->BloodColor(), 6 ); |
|
EmitSound( "NPC_Manhack.Slice" ); |
|
} |
|
|
|
// Pop back a little bit after hitting the player |
|
ComputeSliceBounceVelocity( pHitEntity, tr ); |
|
|
|
// Save off when we last hit something |
|
m_flLastDamageTime = gpGlobals->curtime; |
|
|
|
// Reset our state and give the player time to react |
|
StopBurst( true ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: We've touched something solid. Just bump it. |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::Bump( CBaseEntity *pHitEntity, float flInterval, trace_t &tr ) |
|
{ |
|
if ( !VPhysicsGetObject() ) |
|
return; |
|
|
|
// Surpressing this behavior |
|
if ( m_flBumpSuppressTime > gpGlobals->curtime ) |
|
return; |
|
|
|
if ( pHitEntity->GetMoveType() == MOVETYPE_VPHYSICS && pHitEntity->Classify()!=CLASS_MANHACK ) |
|
{ |
|
HitPhysicsObject( pHitEntity ); |
|
} |
|
|
|
// We've hit something so deflect our velocity based on the surface |
|
// norm of what we've hit |
|
if (flInterval > 0) |
|
{ |
|
float moveLen = ( (GetCurrentVelocity() * flInterval) * (1.0 - tr.fraction) ).Length(); |
|
|
|
Vector moveVec = moveLen*tr.plane.normal/flInterval; |
|
|
|
// If I'm totally dead, don't bounce me up |
|
if (m_iHealth <=0 && moveVec.z > 0) |
|
{ |
|
moveVec.z = 0; |
|
} |
|
|
|
// If I'm right over the ground don't push down |
|
if (moveVec.z < 0) |
|
{ |
|
float floorZ = GetFloorZ(GetAbsOrigin()); |
|
if (abs(GetAbsOrigin().z - floorZ) < 36) |
|
{ |
|
moveVec.z = 0; |
|
} |
|
} |
|
|
|
Vector myUp; |
|
VPhysicsGetObject()->LocalToWorldVector( &myUp, Vector( 0.0, 0.0, 1.0 ) ); |
|
|
|
// plane must be something that could hit the blades |
|
if (fabs( DotProduct( myUp, tr.plane.normal ) ) < 0.25 ) |
|
{ |
|
CEffectData data; |
|
Vector velocity = GetCurrentVelocity(); |
|
|
|
data.m_vOrigin = tr.endpos; |
|
data.m_vAngles = GetAbsAngles(); |
|
|
|
VectorNormalize( velocity ); |
|
|
|
data.m_vNormal = ( tr.plane.normal + velocity ) * 0.5;; |
|
|
|
DispatchEffect( "ManhackSparks", data ); |
|
|
|
CBroadcastRecipientFilter filter; |
|
|
|
te->DynamicLight( filter, 0.0, &GetAbsOrigin(), 255, 180, 100, 0, 50, 0.3, 150 ); |
|
|
|
// add some spin, but only if we're not already going fast.. |
|
Vector vecVelocity; |
|
AngularImpulse vecAngVelocity; |
|
VPhysicsGetObject()->GetVelocity( &vecVelocity, &vecAngVelocity ); |
|
float flDot = DotProduct( myUp, vecAngVelocity ); |
|
if ( fabs(flDot) < 100 ) |
|
{ |
|
//AngularImpulse torque = myUp * (1000 - flDot * 10); |
|
AngularImpulse torque = myUp * (1000 - flDot * 2); |
|
VPhysicsGetObject()->ApplyTorqueCenter( torque ); |
|
} |
|
|
|
if (!(m_spawnflags & SF_NPC_GAG)) |
|
{ |
|
EmitSound( "NPC_Manhack.Grind" ); |
|
} |
|
|
|
// For decals and sparks we must trace a line in the direction of the surface norm |
|
// that we hit. |
|
trace_t decalTrace; |
|
AI_TraceLine( GetAbsOrigin(), GetAbsOrigin() - (tr.plane.normal * 24),MASK_SOLID, this, COLLISION_GROUP_NONE, &decalTrace ); |
|
|
|
if ( decalTrace.fraction != 1.0 ) |
|
{ |
|
// Leave decal only if colliding horizontally |
|
if ((DotProduct(Vector(0,0,1),decalTrace.plane.normal)<0.5) && (DotProduct(Vector(0,0,-1),decalTrace.plane.normal)<0.5)) |
|
{ |
|
UTIL_DecalTrace( &decalTrace, "ManhackCut" ); |
|
} |
|
} |
|
} |
|
|
|
// See if we will not have a valid surface |
|
if ( tr.allsolid || tr.startsolid ) |
|
{ |
|
// Build a fake reflection back along our current velocity because we can't know how to reflect off |
|
// a non-existant surface! -- jdw |
|
|
|
Vector vecRandomDir = RandomVector( -1.0f, 1.0f ); |
|
SetCurrentVelocity( vecRandomDir * 50.0f ); |
|
m_flBumpSuppressTime = gpGlobals->curtime + 0.5f; |
|
} |
|
else |
|
{ |
|
// This is a valid hit and we can deflect properly |
|
|
|
VectorNormalize( moveVec ); |
|
float hitAngle = -DotProduct( tr.plane.normal, -moveVec ); |
|
|
|
Vector vReflection = 2.0 * tr.plane.normal * hitAngle + -moveVec; |
|
|
|
float flSpeed = GetCurrentVelocity().Length(); |
|
SetCurrentVelocity( GetCurrentVelocity() + vReflection * flSpeed * 0.5f ); |
|
} |
|
} |
|
|
|
// ------------------------------------------------------------- |
|
// If I'm on a path check LOS to my next node, and fail on path |
|
// if I don't have LOS. Note this is the only place I do this, |
|
// so the manhack has to collide before failing on a path |
|
// ------------------------------------------------------------- |
|
if (GetNavigator()->IsGoalActive() && !(GetNavigator()->GetPath()->CurWaypointFlags() & bits_WP_TO_PATHCORNER) ) |
|
{ |
|
AIMoveTrace_t moveTrace; |
|
GetMoveProbe()->MoveLimit( NAV_GROUND, GetAbsOrigin(), GetNavigator()->GetCurWaypointPos(), |
|
MoveCollisionMask(), GetEnemy(), &moveTrace ); |
|
|
|
if (IsMoveBlocked( moveTrace ) && |
|
!moveTrace.pObstruction->ClassMatches( GetClassname() )) |
|
{ |
|
TaskFail(FAIL_NO_ROUTE); |
|
GetNavigator()->ClearGoal(); |
|
return; |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::CheckCollisions(float flInterval) |
|
{ |
|
// Trace forward to see if I hit anything. But trace forward along the |
|
// owner's view direction if you're being carried. |
|
Vector vecTraceDir, vecCheckPos; |
|
VPhysicsGetObject()->GetVelocity( &vecTraceDir, NULL ); |
|
vecTraceDir *= flInterval; |
|
if ( IsHeldByPhyscannon() ) |
|
{ |
|
CBasePlayer *pCarrier = HasPhysicsAttacker( FLT_MAX ); |
|
if ( pCarrier ) |
|
{ |
|
if ( pCarrier->CollisionProp()->CalcDistanceFromPoint( WorldSpaceCenter() ) < 30 ) |
|
{ |
|
AngleVectors( pCarrier->EyeAngles(), &vecTraceDir, NULL, NULL ); |
|
vecTraceDir *= 40.0f; |
|
} |
|
} |
|
} |
|
|
|
VectorAdd( GetAbsOrigin(), vecTraceDir, vecCheckPos ); |
|
|
|
trace_t tr; |
|
CBaseEntity* pHitEntity = NULL; |
|
|
|
AI_TraceHull( GetAbsOrigin(), |
|
vecCheckPos, |
|
GetHullMins(), |
|
GetHullMaxs(), |
|
MoveCollisionMask(), |
|
this, |
|
COLLISION_GROUP_NONE, |
|
&tr ); |
|
|
|
if ( (tr.fraction != 1.0 || tr.startsolid) && tr.m_pEnt) |
|
{ |
|
PhysicsMarkEntitiesAsTouching( tr.m_pEnt, tr ); |
|
pHitEntity = tr.m_pEnt; |
|
|
|
if( m_bHeld && tr.m_pEnt->MyNPCPointer() && tr.m_pEnt->MyNPCPointer()->IsPlayerAlly() ) |
|
{ |
|
// Don't slice Alyx when she approaches to hack. We need a better solution for this!! |
|
//Msg("Ignoring!\n"); |
|
return; |
|
} |
|
|
|
if ( pHitEntity != NULL && |
|
pHitEntity->m_takedamage == DAMAGE_YES && |
|
pHitEntity->Classify() != CLASS_MANHACK && |
|
gpGlobals->curtime > m_flWaterSuspendTime ) |
|
{ |
|
// Slice this thing |
|
Slice( pHitEntity, flInterval, tr ); |
|
m_flBladeSpeed = 20.0; |
|
} |
|
else |
|
{ |
|
// Just bump into this thing. |
|
Bump( pHitEntity, flInterval, tr ); |
|
m_flBladeSpeed = 20.0; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
#define tempTIME_STEP = 0.5; |
|
void CNPC_Manhack::PlayFlySound(void) |
|
{ |
|
float flEnemyDist; |
|
|
|
if( GetEnemy() ) |
|
{ |
|
flEnemyDist = (GetAbsOrigin() - GetEnemy()->GetAbsOrigin()).Length(); |
|
} |
|
else |
|
{ |
|
flEnemyDist = FLT_MAX; |
|
} |
|
|
|
if( m_spawnflags & SF_NPC_GAG ) |
|
{ |
|
// Quiet! |
|
return; |
|
} |
|
|
|
if( m_flWaterSuspendTime > gpGlobals->curtime ) |
|
{ |
|
// Just went in water. Slow the motor!! |
|
if( m_bDirtyPitch ) |
|
{ |
|
m_nEnginePitch1 = MANHACK_WATER_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.5f; |
|
m_nEnginePitch2 = MANHACK_WATER_PITCH2; |
|
m_flEnginePitch2Time = gpGlobals->curtime + 0.5f; |
|
m_bDirtyPitch = false; |
|
} |
|
} |
|
// Spin sound based on distance from enemy (unless we're crashing) |
|
else if (GetEnemy() && IsAlive() ) |
|
{ |
|
if( flEnemyDist < MANHACK_PITCH_DIST1 ) |
|
{ |
|
// recalculate pitch. |
|
int iPitch1, iPitch2; |
|
float flDistFactor; |
|
|
|
flDistFactor = MIN( 1.0, 1 - flEnemyDist / MANHACK_PITCH_DIST1 ); |
|
iPitch1 = MANHACK_MIN_PITCH1 + ( ( MANHACK_MAX_PITCH1 - MANHACK_MIN_PITCH1 ) * flDistFactor); |
|
|
|
// NOTE: MANHACK_PITCH_DIST2 must be < MANHACK_PITCH_DIST1 |
|
flDistFactor = MIN( 1.0, 1 - flEnemyDist / MANHACK_PITCH_DIST2 ); |
|
iPitch2 = MANHACK_MIN_PITCH2 + ( ( MANHACK_MAX_PITCH2 - MANHACK_MIN_PITCH2 ) * flDistFactor); |
|
|
|
m_nEnginePitch1 = iPitch1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.1f; |
|
m_nEnginePitch2 = iPitch2; |
|
m_flEnginePitch2Time = gpGlobals->curtime + 0.1f; |
|
|
|
m_bDirtyPitch = true; |
|
} |
|
else if( m_bDirtyPitch ) |
|
{ |
|
m_nEnginePitch1 = MANHACK_MIN_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.1f; |
|
m_nEnginePitch2 = MANHACK_MIN_PITCH2; |
|
m_flEnginePitch2Time = gpGlobals->curtime + 0.2f; |
|
m_bDirtyPitch = false; |
|
} |
|
} |
|
// If no enemy just play low sound |
|
else if( IsAlive() && m_bDirtyPitch ) |
|
{ |
|
m_nEnginePitch1 = MANHACK_MIN_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.1f; |
|
m_nEnginePitch2 = MANHACK_MIN_PITCH2; |
|
m_flEnginePitch2Time = gpGlobals->curtime + 0.2f; |
|
|
|
m_bDirtyPitch = false; |
|
} |
|
|
|
// Play special engine every once in a while |
|
if (gpGlobals->curtime > m_flNextEngineSoundTime && flEnemyDist < 48) |
|
{ |
|
m_flNextEngineSoundTime = gpGlobals->curtime + random->RandomFloat( 3.0, 10.0 ); |
|
|
|
EmitSound( "NPC_Manhack.EngineNoise" ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::MoveExecute_Alive(float flInterval) |
|
{ |
|
PhysicsCheckWaterTransition(); |
|
|
|
Vector vCurrentVelocity = GetCurrentVelocity(); |
|
|
|
// FIXME: move this |
|
VPhysicsGetObject()->Wake(); |
|
|
|
if( m_fEnginePowerScale < GetMaxEnginePower() && gpGlobals->curtime > m_flWaterSuspendTime ) |
|
{ |
|
// Power is low, and we're no longer stuck in water, so bring power up. |
|
m_fEnginePowerScale += 0.05; |
|
} |
|
|
|
// ---------------------------------------------------------------------------------------- |
|
// Add time-coherent noise to the current velocity so that it never looks bolted in place. |
|
// ---------------------------------------------------------------------------------------- |
|
float noiseScale = 7.0f; |
|
|
|
if ( (CBaseEntity*)GetEnemy() ) |
|
{ |
|
float flDist = (GetAbsOrigin() - GetEnemy()->GetAbsOrigin()).Length2D(); |
|
|
|
if( flDist < MANHACK_CHARGE_MIN_DIST ) |
|
{ |
|
// Less noise up close. |
|
noiseScale = 2.0; |
|
} |
|
|
|
if ( IsInEffectiveTargetZone( GetEnemy() ) && flDist < MANHACK_CHARGE_MIN_DIST && gpGlobals->curtime > m_flNextBurstTime ) |
|
{ |
|
Vector vecCurrentDir = GetCurrentVelocity(); |
|
VectorNormalize( vecCurrentDir ); |
|
|
|
Vector vecToEnemy = ( GetEnemy()->EyePosition() - WorldSpaceCenter() ); |
|
VectorNormalize( vecToEnemy ); |
|
|
|
float flDot = DotProduct( vecCurrentDir, vecToEnemy ); |
|
|
|
if ( flDot > 0.75 ) |
|
{ |
|
Vector offsetDir = ( vecToEnemy - vecCurrentDir ); |
|
VectorNormalize( offsetDir ); |
|
|
|
Vector offsetSpeed = GetCurrentVelocity() * flDot; |
|
|
|
//FIXME: This code sucks -- jdw |
|
|
|
offsetDir.z = 0.0f; |
|
m_vForceVelocity += ( offsetDir * ( offsetSpeed.Length2D() * 0.25f ) ); |
|
|
|
// Commit to the attack- no steering for about a second |
|
StartBurst( vecToEnemy ); |
|
SetEyeState( MANHACK_EYE_STATE_CHARGE ); |
|
} |
|
} |
|
|
|
if ( gpGlobals->curtime > m_flBurstDuration ) |
|
{ |
|
ShowHostile( false ); |
|
} |
|
} |
|
|
|
// ---------------------------------------------------------------------------------------- |
|
// Add in any forced velocity |
|
// ---------------------------------------------------------------------------------------- |
|
SetCurrentVelocity( vCurrentVelocity + m_vForceVelocity ); |
|
m_vForceVelocity = vec3_origin; |
|
|
|
if( !m_bHackedByAlyx || GetEnemy() ) |
|
{ |
|
// If hacked and no enemy, don't drift! |
|
AddNoiseToVelocity( noiseScale ); |
|
} |
|
|
|
LimitSpeed( 200, ManhackMaxSpeed() ); |
|
|
|
if( m_flWaterSuspendTime > gpGlobals->curtime ) |
|
{ |
|
if( UTIL_PointContents( GetAbsOrigin() ) & (CONTENTS_WATER|CONTENTS_SLIME) ) |
|
{ |
|
// Ooops, we're submerged somehow. Move upwards until our origin is out of the water. |
|
m_vCurrentVelocity.z = 20.0; |
|
} |
|
else |
|
{ |
|
// Skimming the surface. Forbid any movement on Z |
|
m_vCurrentVelocity.z = 0.0; |
|
} |
|
} |
|
else if( GetWaterLevel() > 0 ) |
|
{ |
|
// Allow the manhack to lift off, but not to go deeper. |
|
m_vCurrentVelocity.z = MAX( m_vCurrentVelocity.z, 0 ); |
|
} |
|
|
|
CheckCollisions(flInterval); |
|
|
|
// Blend out desired velocity when launched by the physcannon |
|
if ( HasPhysicsAttacker( MANHACK_SMASH_TIME ) && (!IsHeldByPhyscannon()) && VPhysicsGetObject() ) |
|
{ |
|
Vector vecCurrentVelocity; |
|
VPhysicsGetObject()->GetVelocity( &vecCurrentVelocity, NULL ); |
|
float flLerpFactor = (gpGlobals->curtime - m_flLastPhysicsInfluenceTime) / MANHACK_SMASH_TIME; |
|
flLerpFactor = clamp( flLerpFactor, 0.0f, 1.0f ); |
|
flLerpFactor = SimpleSplineRemapVal( flLerpFactor, 0.0f, 1.0f, 0.0f, 1.0f ); |
|
VectorLerp( vecCurrentVelocity, m_vCurrentVelocity, flLerpFactor, m_vCurrentVelocity ); |
|
} |
|
|
|
QAngle angles = GetLocalAngles(); |
|
|
|
// ------------------------------------------ |
|
// Stalling |
|
// ------------------------------------------ |
|
if (gpGlobals->curtime < m_flEngineStallTime) |
|
{ |
|
/* |
|
// If I'm stalled add random noise |
|
angles.x += -20+(random->RandomInt(-10,10)); |
|
angles.z += -20+(random->RandomInt(0,40)); |
|
|
|
TurnHeadRandomly(flInterval); |
|
*/ |
|
} |
|
else |
|
{ |
|
// Make frame rate independent |
|
float iRate = 0.5; |
|
float timeToUse = flInterval; |
|
while (timeToUse > 0) |
|
{ |
|
m_vCurrentBanking.x = (iRate * m_vCurrentBanking.x) + (1 - iRate)*(m_vTargetBanking.x); |
|
m_vCurrentBanking.z = (iRate * m_vCurrentBanking.z) + (1 - iRate)*(m_vTargetBanking.z); |
|
timeToUse = -0.1; |
|
} |
|
angles.x = m_vCurrentBanking.x; |
|
angles.z = m_vCurrentBanking.z; |
|
angles.y = 0; |
|
|
|
#if 0 |
|
// Using our steering if we're not otherwise affecting our panels |
|
if ( m_flEngineStallTime < gpGlobals->curtime && m_flBurstDuration < gpGlobals->curtime ) |
|
{ |
|
Vector delta( 10 * AngleDiff( m_vTargetBanking.x, m_vCurrentBanking.x ), -10 * AngleDiff( m_vTargetBanking.z, m_vCurrentBanking.z ), 0 ); |
|
//Vector delta( 3 * AngleNormalize( m_vCurrentBanking.x ), -4 * AngleNormalize( m_vCurrentBanking.z ), 0 ); |
|
VectorYawRotate( delta, -m_fHeadYaw, delta ); |
|
|
|
// DevMsg("%.0f %.0f\n", delta.x, delta.y ); |
|
|
|
SetPoseParameter( m_iPanel1, -delta.x - delta.y * 2); |
|
SetPoseParameter( m_iPanel2, -delta.x + delta.y * 2); |
|
SetPoseParameter( m_iPanel3, delta.x + delta.y * 2); |
|
SetPoseParameter( m_iPanel4, delta.x - delta.y * 2); |
|
|
|
//SetPoseParameter( m_iPanel1, -delta.x ); |
|
//SetPoseParameter( m_iPanel2, -delta.x ); |
|
//SetPoseParameter( m_iPanel3, delta.x ); |
|
//SetPoseParameter( m_iPanel4, delta.x ); |
|
} |
|
#endif |
|
} |
|
|
|
// SetLocalAngles( angles ); |
|
|
|
if( m_lifeState != LIFE_DEAD ) |
|
{ |
|
PlayFlySound(); |
|
// SpinBlades( flInterval ); |
|
// WalkMove( GetCurrentVelocity() * flInterval, MASK_NPCSOLID ); |
|
} |
|
|
|
// NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, -10 ), 0, 255, 0, true, 0.1); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::SpinBlades(float flInterval) |
|
{ |
|
if (!m_bBladesActive) |
|
{ |
|
SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_OFF ); |
|
SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF ); |
|
m_flBladeSpeed = 0.0; |
|
m_flPlaybackRate = 1.0; |
|
return; |
|
} |
|
|
|
if ( IsFlyingActivity( GetActivity() ) ) |
|
{ |
|
// Blades may only ramp up while the engine is running |
|
if ( m_flEngineStallTime < gpGlobals->curtime ) |
|
{ |
|
if (m_flBladeSpeed < 10) |
|
{ |
|
m_flBladeSpeed = m_flBladeSpeed * 2 + 1; |
|
} |
|
else |
|
{ |
|
// accelerate engine |
|
m_flBladeSpeed = m_flBladeSpeed + 80 * flInterval; |
|
} |
|
} |
|
|
|
if (m_flBladeSpeed > 100) |
|
{ |
|
m_flBladeSpeed = 100; |
|
} |
|
|
|
// blend through blades, blades+blur, blur |
|
if (m_flBladeSpeed < 20) |
|
{ |
|
SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_ON ); |
|
SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF ); |
|
} |
|
else if (m_flBladeSpeed < 40) |
|
{ |
|
SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_ON ); |
|
SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_ON ); |
|
} |
|
else |
|
{ |
|
SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_OFF ); |
|
SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_ON ); |
|
} |
|
|
|
m_flPlaybackRate = m_flBladeSpeed / 100.0; |
|
} |
|
else |
|
{ |
|
m_flBladeSpeed = 0.0; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Smokes and sparks, exploding periodically. Eventually it goes away. |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::MoveExecute_Dead(float flInterval) |
|
{ |
|
if( GetWaterLevel() > 0 ) |
|
{ |
|
// No movement if sinking in water. |
|
return; |
|
} |
|
|
|
// Periodically emit smoke. |
|
if (gpGlobals->curtime > m_fSmokeTime && GetWaterLevel() == 0) |
|
{ |
|
// UTIL_Smoke(GetAbsOrigin(), random->RandomInt(10, 15), 10); |
|
m_fSmokeTime = gpGlobals->curtime + random->RandomFloat( 0.1, 0.3); |
|
} |
|
|
|
// Periodically emit sparks. |
|
if (gpGlobals->curtime > m_fSparkTime) |
|
{ |
|
g_pEffects->Sparks( GetAbsOrigin() ); |
|
m_fSparkTime = gpGlobals->curtime + random->RandomFloat(0.1, 0.3); |
|
} |
|
|
|
Vector newVelocity = GetCurrentVelocity(); |
|
|
|
// accelerate faster and faster when dying |
|
newVelocity = newVelocity + (newVelocity * 1.5 * flInterval ); |
|
|
|
// Lose lift |
|
newVelocity.z -= 0.02*flInterval*(GetCurrentGravity()); |
|
|
|
// ---------------------------------------------------------------------------------------- |
|
// Add in any forced velocity |
|
// ---------------------------------------------------------------------------------------- |
|
newVelocity += m_vForceVelocity; |
|
SetCurrentVelocity( newVelocity ); |
|
m_vForceVelocity = vec3_origin; |
|
|
|
|
|
// Lots of noise!! Out of control! |
|
AddNoiseToVelocity( 5.0 ); |
|
|
|
|
|
// ---------------------- |
|
// Limit overall speed |
|
// ---------------------- |
|
LimitSpeed( -1, MANHACK_MAX_SPEED * 2.0 ); |
|
|
|
QAngle angles = GetLocalAngles(); |
|
|
|
// ------------------------------------------ |
|
// If I'm dying, add random banking noise |
|
// ------------------------------------------ |
|
angles.x += -20+(random->RandomInt(0,40)); |
|
angles.z += -20+(random->RandomInt(0,40)); |
|
|
|
CheckCollisions(flInterval); |
|
PlayFlySound(); |
|
|
|
// SetLocalAngles( angles ); |
|
|
|
WalkMove( GetCurrentVelocity() * flInterval,MASK_NPCSOLID ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::Precache(void) |
|
{ |
|
// |
|
// Model. |
|
// |
|
PrecacheModel("models/manhack.mdl"); |
|
PrecacheModel( MANHACK_GLOW_SPRITE ); |
|
PropBreakablePrecacheAll( MAKE_STRING("models/manhack.mdl") ); |
|
|
|
PrecacheScriptSound( "NPC_Manhack.Die" ); |
|
PrecacheScriptSound( "NPC_Manhack.Bat" ); |
|
PrecacheScriptSound( "NPC_Manhack.Grind" ); |
|
PrecacheScriptSound( "NPC_Manhack.Slice" ); |
|
PrecacheScriptSound( "NPC_Manhack.EngineNoise" ); |
|
PrecacheScriptSound( "NPC_Manhack.Unpack" ); |
|
PrecacheScriptSound( "NPC_Manhack.ChargeAnnounce" ); |
|
PrecacheScriptSound( "NPC_Manhack.ChargeEnd" ); |
|
PrecacheScriptSound( "NPC_Manhack.Stunned" ); |
|
|
|
// Sounds used on Client: |
|
PrecacheScriptSound( "NPC_Manhack.EngineSound1" ); |
|
PrecacheScriptSound( "NPC_Manhack.EngineSound2" ); |
|
PrecacheScriptSound( "NPC_Manhack.BladeSound" ); |
|
|
|
BaseClass::Precache(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::GatherEnemyConditions( CBaseEntity *pEnemy ) |
|
{ |
|
// The Manhack "regroups" when its in attack range but to |
|
// far above or below its enemy. Set the start attack |
|
// condition if we are far enough away from the enemy |
|
// or at the correct height |
|
|
|
// Don't bother with Z if the enemy is in a vehicle |
|
float fl2DDist = 60.0f; |
|
float flZDist = 12.0f; |
|
|
|
if ( GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle() ) |
|
{ |
|
flZDist = 24.0f; |
|
} |
|
|
|
if ((GetAbsOrigin() - pEnemy->GetAbsOrigin()).Length2D() > fl2DDist) |
|
{ |
|
SetCondition(COND_MANHACK_START_ATTACK); |
|
} |
|
else |
|
{ |
|
float targetZ = pEnemy->EyePosition().z; |
|
if (fabs(GetAbsOrigin().z - targetZ) < flZDist) |
|
{ |
|
SetCondition(COND_MANHACK_START_ATTACK); |
|
} |
|
} |
|
BaseClass::GatherEnemyConditions(pEnemy); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: For innate melee attack |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
int CNPC_Manhack::MeleeAttack1Conditions( float flDot, float flDist ) |
|
{ |
|
if ( GetEnemy() == NULL ) |
|
return COND_NONE; |
|
|
|
//TODO: We could also decide if we want to back up here |
|
if ( m_flNextBurstTime > gpGlobals->curtime ) |
|
return COND_NONE; |
|
|
|
float flMaxDist = 45; |
|
float flMinDist = 24; |
|
bool bEnemyInVehicle = GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle(); |
|
if ( GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle() ) |
|
{ |
|
flMinDist = 0; |
|
flMaxDist = 200.0f; |
|
} |
|
|
|
if (flDist > flMaxDist) |
|
{ |
|
return COND_TOO_FAR_TO_ATTACK; |
|
} |
|
|
|
if (flDist < flMinDist) |
|
{ |
|
return COND_TOO_CLOSE_TO_ATTACK; |
|
} |
|
|
|
// Check our current velocity and speed, if it's too far off, we need to settle |
|
|
|
// Don't bother with Z if the enemy is in a vehicle |
|
if ( bEnemyInVehicle ) |
|
{ |
|
return COND_CAN_MELEE_ATTACK1; |
|
} |
|
|
|
// Assume the this check is in regards to my current enemy |
|
// for the Manhacks spetial condition |
|
float deltaZ = GetAbsOrigin().z - GetEnemy()->EyePosition().z; |
|
if ( (deltaZ > 12.0f) || (deltaZ < -24.0f) ) |
|
{ |
|
return COND_TOO_CLOSE_TO_ATTACK; |
|
} |
|
|
|
return COND_CAN_MELEE_ATTACK1; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pTask - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::RunTask( const Task_t *pTask ) |
|
{ |
|
switch ( pTask->iTask ) |
|
{ |
|
// Override this task so we go for the enemy at eye level |
|
case TASK_MANHACK_HOVER: |
|
{ |
|
break; |
|
} |
|
|
|
// If my enemy has moved significantly, update my path |
|
case TASK_WAIT_FOR_MOVEMENT: |
|
{ |
|
CBaseEntity *pEnemy = GetEnemy(); |
|
if (pEnemy && |
|
(GetCurSchedule()->GetId() == SCHED_CHASE_ENEMY) && |
|
GetNavigator()->IsGoalActive() ) |
|
{ |
|
Vector vecEnemyPosition; |
|
vecEnemyPosition = pEnemy->EyePosition(); |
|
if ( GetNavigator()->GetGoalPos().DistToSqr(vecEnemyPosition) > 40 * 40 ) |
|
{ |
|
GetNavigator()->UpdateGoalPos( vecEnemyPosition ); |
|
} |
|
} |
|
BaseClass::RunTask(pTask); |
|
break; |
|
} |
|
|
|
case TASK_MANHACK_MOVEAT_SAVEPOSITION: |
|
{ |
|
// do the movement thingy |
|
|
|
// NDebugOverlay::Line( GetAbsOrigin(), m_vSavePosition, 0, 255, 0, true, 0.1); |
|
|
|
Vector dir = (m_vSavePosition - GetAbsOrigin()); |
|
float dist = VectorNormalize( dir ); |
|
float t = m_fSwarmMoveTime - gpGlobals->curtime; |
|
|
|
if (t < 0.1) |
|
{ |
|
if (dist > 256) |
|
{ |
|
TaskFail( FAIL_NO_ROUTE ); |
|
} |
|
else |
|
{ |
|
TaskComplete(); |
|
} |
|
} |
|
else if (dist < 64) |
|
{ |
|
m_vSwarmMoveTarget = GetAbsOrigin() - Vector( -dir.y, dir.x, 0 ) * 4; |
|
} |
|
else |
|
{ |
|
m_vSwarmMoveTarget = GetAbsOrigin() + dir * 10; |
|
} |
|
break; |
|
} |
|
|
|
default: |
|
{ |
|
BaseClass::RunTask(pTask); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::Spawn(void) |
|
{ |
|
Precache(); |
|
|
|
#ifdef _XBOX |
|
// Always fade the corpse |
|
AddSpawnFlags( SF_NPC_FADE_CORPSE ); |
|
#endif // _XBOX |
|
|
|
SetModel( "models/manhack.mdl" ); |
|
SetHullType(HULL_TINY_CENTERED); |
|
SetHullSizeNormal(); |
|
|
|
SetSolid( SOLID_BBOX ); |
|
AddSolidFlags( FSOLID_NOT_STANDABLE ); |
|
|
|
if ( HasSpawnFlags( SF_MANHACK_CARRIED ) ) |
|
{ |
|
AddSolidFlags( FSOLID_NOT_SOLID ); |
|
SetMoveType( MOVETYPE_NONE ); |
|
} |
|
else |
|
{ |
|
SetMoveType( MOVETYPE_VPHYSICS ); |
|
} |
|
|
|
m_iHealth = sk_manhack_health.GetFloat(); |
|
SetViewOffset( Vector(0, 0, 10) ); // Position of the eyes relative to NPC's origin. |
|
m_flFieldOfView = VIEW_FIELD_FULL; |
|
m_NPCState = NPC_STATE_NONE; |
|
|
|
if ( m_spawnflags & SF_MANHACK_USE_AIR_NODES) |
|
{ |
|
SetNavType(NAV_FLY); |
|
} |
|
else |
|
{ |
|
SetNavType(NAV_GROUND); |
|
} |
|
|
|
AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL ); |
|
AddEffects( EF_NOSHADOW ); |
|
|
|
SetBloodColor( DONT_BLEED ); |
|
SetCurrentVelocity( vec3_origin ); |
|
m_vForceVelocity.Init(); |
|
m_vCurrentBanking.Init(); |
|
m_vTargetBanking.Init(); |
|
|
|
m_flNextBurstTime = gpGlobals->curtime; |
|
|
|
CapabilitiesAdd( bits_CAP_INNATE_MELEE_ATTACK1 | bits_CAP_MOVE_FLY | bits_CAP_SQUAD ); |
|
|
|
m_flNextEngineSoundTime = gpGlobals->curtime; |
|
m_flWaterSuspendTime = gpGlobals->curtime; |
|
m_flEngineStallTime = gpGlobals->curtime; |
|
m_fForceMoveTime = gpGlobals->curtime; |
|
m_vForceMoveTarget = vec3_origin; |
|
m_fSwarmMoveTime = gpGlobals->curtime; |
|
m_vSwarmMoveTarget = vec3_origin; |
|
m_nLastSpinSound = -1; |
|
|
|
m_fSmokeTime = 0; |
|
m_fSparkTime = 0; |
|
|
|
// Set the noise mod to huge numbers right now, in case this manhack starts out waiting for a script |
|
// for instance, we don't want him to bob whilst he's waiting for a script. This allows designers |
|
// to 'hide' manhacks in small places. (sjb) |
|
SetNoiseMod( MANHACK_NOISEMOD_HIDE, MANHACK_NOISEMOD_HIDE, MANHACK_NOISEMOD_HIDE ); |
|
|
|
// Start out with full power! |
|
m_fEnginePowerScale = GetMaxEnginePower(); |
|
|
|
// find panels |
|
m_iPanel1 = LookupPoseParameter( "Panel1" ); |
|
m_iPanel2 = LookupPoseParameter( "Panel2" ); |
|
m_iPanel3 = LookupPoseParameter( "Panel3" ); |
|
m_iPanel4 = LookupPoseParameter( "Panel4" ); |
|
|
|
m_fHeadYaw = 0; |
|
|
|
NPCInit(); |
|
|
|
// Manhacks are designed to slam into things, so don't take much damage from it! |
|
SetImpactEnergyScale( 0.001 ); |
|
|
|
// Manhacks get 30 seconds worth of free knowledge. |
|
GetEnemies()->SetFreeKnowledgeDuration( 30.0 ); |
|
|
|
// don't be an NPC, we want to collide with debris stuff |
|
SetCollisionGroup( COLLISION_GROUP_NONE ); |
|
|
|
m_bHeld = false; |
|
m_bHackedByAlyx = false; |
|
StopLoitering(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::StartEye( void ) |
|
{ |
|
//Create our Eye sprite |
|
if ( m_pEyeGlow == NULL ) |
|
{ |
|
m_pEyeGlow = CSprite::SpriteCreate( MANHACK_GLOW_SPRITE, GetLocalOrigin(), false ); |
|
m_pEyeGlow->SetAttachment( this, LookupAttachment( "Eye" ) ); |
|
|
|
if( m_bHackedByAlyx ) |
|
{ |
|
m_pEyeGlow->SetTransparency( kRenderTransAdd, 0, 255, 0, 128, kRenderFxNoDissipation ); |
|
m_pEyeGlow->SetColor( 0, 255, 0 ); |
|
} |
|
else |
|
{ |
|
m_pEyeGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation ); |
|
m_pEyeGlow->SetColor( 255, 0, 0 ); |
|
} |
|
|
|
m_pEyeGlow->SetBrightness( 164, 0.1f ); |
|
m_pEyeGlow->SetScale( 0.25f, 0.1f ); |
|
m_pEyeGlow->SetAsTemporary(); |
|
} |
|
|
|
//Create our light sprite |
|
if ( m_pLightGlow == NULL ) |
|
{ |
|
m_pLightGlow = CSprite::SpriteCreate( MANHACK_GLOW_SPRITE, GetLocalOrigin(), false ); |
|
m_pLightGlow->SetAttachment( this, LookupAttachment( "Light" ) ); |
|
|
|
if( m_bHackedByAlyx ) |
|
{ |
|
m_pLightGlow->SetTransparency( kRenderTransAdd, 0, 255, 0, 128, kRenderFxNoDissipation ); |
|
m_pLightGlow->SetColor( 0, 255, 0 ); |
|
} |
|
else |
|
{ |
|
m_pLightGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation ); |
|
m_pLightGlow->SetColor( 255, 0, 0 ); |
|
} |
|
|
|
m_pLightGlow->SetBrightness( 164, 0.1f ); |
|
m_pLightGlow->SetScale( 0.25f, 0.1f ); |
|
m_pLightGlow->SetAsTemporary(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CNPC_Manhack::Activate() |
|
{ |
|
BaseClass::Activate(); |
|
|
|
if ( IsAlive() ) |
|
{ |
|
StartEye(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the engine sound started. Unless we're not supposed to have it on yet! |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::PostNPCInit( void ) |
|
{ |
|
// SetAbsVelocity( vec3_origin ); |
|
m_bBladesActive = (m_spawnflags & (SF_MANHACK_PACKED_UP|SF_MANHACK_CARRIED)) ? false : true; |
|
BladesInit(); |
|
} |
|
|
|
void CNPC_Manhack::BladesInit() |
|
{ |
|
if( !m_bBladesActive ) |
|
{ |
|
// manhack is packed up, so has no power of its own. |
|
// don't start the engine sounds. |
|
// make us fall a little slower than we should, for visual's sake |
|
SetGravity( UTIL_ScaleForGravity( 400 ) ); |
|
|
|
SetActivity( ACT_IDLE ); |
|
} |
|
else |
|
{ |
|
bool engineSound = (m_spawnflags & SF_NPC_GAG) ? false : true; |
|
StartEngine( engineSound ); |
|
SetActivity( ACT_FLY ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Crank up the engine! |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::StartEngine( bool fStartSound ) |
|
{ |
|
if( fStartSound ) |
|
{ |
|
SoundInit(); |
|
} |
|
|
|
// Make the blade appear. |
|
SetBodygroup( 1, 1 ); |
|
|
|
// Pop up a little if falling fast! |
|
Vector vecVelocity; |
|
GetVelocity( &vecVelocity, NULL ); |
|
if( ( m_spawnflags & SF_MANHACK_PACKED_UP ) && vecVelocity.z < 0 ) |
|
{ |
|
// DevMsg(" POP UP \n" ); |
|
// ApplyAbsVelocityImpulse( Vector(0,0,-vecVelocity.z*0.75) ); |
|
} |
|
|
|
// Under powered flight now. |
|
// SetMoveType( MOVETYPE_STEP ); |
|
// SetGravity( MANHACK_GRAVITY ); |
|
AddFlag( FL_FLY ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Start the manhack's engine sound. |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::SoundInit( void ) |
|
{ |
|
m_nEnginePitch1 = MANHACK_MIN_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime; |
|
m_nEnginePitch2 = MANHACK_MIN_PITCH2; |
|
m_flEnginePitch2Time = gpGlobals->curtime; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::StopLoopingSounds(void) |
|
{ |
|
BaseClass::StopLoopingSounds(); |
|
m_nEnginePitch1 = -1; |
|
m_flEnginePitch1Time = gpGlobals->curtime; |
|
m_nEnginePitch2 = -1; |
|
m_flEnginePitch2Time = gpGlobals->curtime; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : pTask - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::StartTask( const Task_t *pTask ) |
|
{ |
|
switch (pTask->iTask) |
|
{ |
|
case TASK_MANHACK_UNPACK: |
|
{ |
|
// Just play a sound for now. |
|
EmitSound( "NPC_Manhack.Unpack" ); |
|
|
|
TaskComplete(); |
|
} |
|
break; |
|
|
|
case TASK_MANHACK_HOVER: |
|
break; |
|
|
|
case TASK_MOVE_TO_TARGET_RANGE: |
|
case TASK_GET_PATH_TO_GOAL: |
|
case TASK_GET_PATH_TO_ENEMY_LKP: |
|
case TASK_GET_PATH_TO_PLAYER: |
|
{ |
|
BaseClass::StartTask( pTask ); |
|
/* |
|
// FIXME: why were these tasks considered bad? |
|
_asm |
|
{ |
|
int 3; |
|
int 5; |
|
} |
|
*/ |
|
} |
|
break; |
|
|
|
case TASK_FACE_IDEAL: |
|
{ |
|
// this shouldn't ever happen, but if it does, don't choke |
|
TaskComplete(); |
|
} |
|
break; |
|
|
|
case TASK_GET_PATH_TO_ENEMY: |
|
{ |
|
if (IsUnreachable(GetEnemy())) |
|
{ |
|
TaskFail(FAIL_NO_ROUTE); |
|
return; |
|
} |
|
|
|
CBaseEntity *pEnemy = GetEnemy(); |
|
|
|
if ( pEnemy == NULL ) |
|
{ |
|
TaskFail(FAIL_NO_ENEMY); |
|
return; |
|
} |
|
|
|
if ( GetNavigator()->SetGoal( GOALTYPE_ENEMY ) ) |
|
{ |
|
TaskComplete(); |
|
} |
|
else |
|
{ |
|
// no way to get there =( |
|
DevWarning( 2, "GetPathToEnemy failed!!\n" ); |
|
RememberUnreachable(GetEnemy()); |
|
TaskFail(FAIL_NO_ROUTE); |
|
} |
|
break; |
|
} |
|
break; |
|
|
|
case TASK_GET_PATH_TO_TARGET: |
|
// DevMsg("TARGET\n"); |
|
BaseClass::StartTask( pTask ); |
|
break; |
|
|
|
case TASK_MANHACK_FIND_SQUAD_CENTER: |
|
{ |
|
if (!m_pSquad) |
|
{ |
|
m_vSavePosition = GetAbsOrigin(); |
|
TaskComplete(); |
|
break; |
|
} |
|
|
|
// calc center of squad |
|
int count = 0; |
|
m_vSavePosition = Vector( 0, 0, 0 ); |
|
|
|
// give attacking members more influence |
|
AISquadIter_t iter; |
|
for (CAI_BaseNPC *pSquadMember = m_pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = m_pSquad->GetNextMember( &iter ) ) |
|
{ |
|
if (pSquadMember->HasStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 )) |
|
{ |
|
m_vSavePosition += pSquadMember->GetAbsOrigin() * 10; |
|
count += 10; |
|
} |
|
else |
|
{ |
|
m_vSavePosition += pSquadMember->GetAbsOrigin(); |
|
count++; |
|
} |
|
} |
|
|
|
// pull towards enemy |
|
if (GetEnemy() != NULL) |
|
{ |
|
m_vSavePosition += GetEnemyLKP() * 4; |
|
count += 4; |
|
} |
|
|
|
Assert( count != 0 ); |
|
m_vSavePosition = m_vSavePosition * (1.0 / count); |
|
|
|
TaskComplete(); |
|
} |
|
break; |
|
|
|
case TASK_MANHACK_FIND_SQUAD_MEMBER: |
|
{ |
|
if (m_pSquad) |
|
{ |
|
CAI_BaseNPC *pSquadMember = m_pSquad->GetAnyMember(); |
|
m_vSavePosition = pSquadMember->GetAbsOrigin(); |
|
|
|
// find attacking members |
|
AISquadIter_t iter; |
|
for (pSquadMember = m_pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = m_pSquad->GetNextMember( &iter ) ) |
|
{ |
|
// are they attacking? |
|
if (pSquadMember->HasStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 )) |
|
{ |
|
m_vSavePosition = pSquadMember->GetAbsOrigin(); |
|
break; |
|
} |
|
// do they have a goal? |
|
if (pSquadMember->GetNavigator()->IsGoalActive()) |
|
{ |
|
m_vSavePosition = pSquadMember->GetAbsOrigin(); |
|
break; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
m_vSavePosition = GetAbsOrigin(); |
|
} |
|
|
|
TaskComplete(); |
|
} |
|
break; |
|
|
|
case TASK_MANHACK_MOVEAT_SAVEPOSITION: |
|
{ |
|
trace_t tr; |
|
AI_TraceLine( GetAbsOrigin(), m_vSavePosition, MASK_NPCWORLDSTATIC, this, COLLISION_GROUP_NONE, &tr ); |
|
if (tr.DidHitWorld()) |
|
{ |
|
TaskFail( FAIL_NO_ROUTE ); |
|
} |
|
else |
|
{ |
|
m_fSwarmMoveTime = gpGlobals->curtime + RandomFloat( pTask->flTaskData * 0.8, pTask->flTaskData * 1.2 ); |
|
} |
|
} |
|
break; |
|
|
|
default: |
|
BaseClass::StartTask(pTask); |
|
break; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::UpdateOnRemove( void ) |
|
{ |
|
DestroySmokeTrail(); |
|
KillSprites( 0.0 ); |
|
BaseClass::UpdateOnRemove(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: This is a generic function (to be implemented by sub-classes) to |
|
// handle specific interactions between different types of characters |
|
// (For example the barnacle grabbing an NPC) |
|
// Input : Constant for the type of interaction |
|
// Output : true - if sub-class has a response for the interaction |
|
// false - if sub-class has no response |
|
//----------------------------------------------------------------------------- |
|
bool CNPC_Manhack::HandleInteraction(int interactionType, void* data, CBaseCombatCharacter* sourceEnt) |
|
{ |
|
if (interactionType == g_interactionVortigauntClaw) |
|
{ |
|
// Freeze so vortigaunt and hit me easier |
|
|
|
m_vForceMoveTarget.x = ((Vector *)data)->x; |
|
m_vForceMoveTarget.y = ((Vector *)data)->y; |
|
m_vForceMoveTarget.z = ((Vector *)data)->z; |
|
m_fForceMoveTime = gpGlobals->curtime + 2.0; |
|
return false; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : float |
|
//----------------------------------------------------------------------------- |
|
float CNPC_Manhack::ManhackMaxSpeed( void ) |
|
{ |
|
if( m_flWaterSuspendTime > gpGlobals->curtime ) |
|
{ |
|
// Slower in water! |
|
return MANHACK_MAX_SPEED * 0.1; |
|
} |
|
|
|
if ( HasPhysicsAttacker( MANHACK_SMASH_TIME ) ) |
|
{ |
|
return MANHACK_NPC_BURST_SPEED; |
|
} |
|
|
|
return MANHACK_MAX_SPEED; |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::ClampMotorForces( Vector &linear, AngularImpulse &angular ) |
|
{ |
|
float scale = m_flBladeSpeed / 100.0; |
|
|
|
// Msg("%.0f %.0f %.0f\n", linear.x, linear.y, linear.z ); |
|
|
|
float fscale = 3000 * scale; |
|
|
|
if ( m_flEngineStallTime > gpGlobals->curtime ) |
|
{ |
|
linear.x = 0.0f; |
|
linear.y = 0.0f; |
|
linear.z = clamp( linear.z, -fscale, fscale < 1200 ? 1200 : fscale ); |
|
} |
|
else |
|
{ |
|
// limit reaction forces |
|
linear.x = clamp( linear.x, -fscale, fscale ); |
|
linear.y = clamp( linear.y, -fscale, fscale ); |
|
linear.z = clamp( linear.z, -fscale, fscale < 1200 ? 1200 : fscale ); |
|
} |
|
|
|
angular.x *= scale; |
|
angular.y *= scale; |
|
angular.z *= scale; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::KillSprites( float flDelay ) |
|
{ |
|
if( m_pEyeGlow ) |
|
{ |
|
m_pEyeGlow->FadeAndDie( flDelay ); |
|
m_pEyeGlow = NULL; |
|
} |
|
|
|
if( m_pLightGlow ) |
|
{ |
|
m_pLightGlow->FadeAndDie( flDelay ); |
|
m_pLightGlow = NULL; |
|
} |
|
|
|
// Re-enable for light trails |
|
/* |
|
if ( m_hLightTrail ) |
|
{ |
|
m_hLightTrail->FadeAndDie( flDelay ); |
|
m_hLightTrail = NULL; |
|
} |
|
*/ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Tests whether we're above the target's feet but also below their top |
|
// Input : *pTarget - who we're testing against |
|
//----------------------------------------------------------------------------- |
|
bool CNPC_Manhack::IsInEffectiveTargetZone( CBaseEntity *pTarget ) |
|
{ |
|
Vector vecMaxPos, vecMinPos; |
|
float ourHeight = WorldSpaceCenter().z; |
|
|
|
// If the enemy is in a vehicle, we need to get those bounds |
|
if ( pTarget && pTarget->IsPlayer() && assert_cast< CBasePlayer * >(pTarget)->IsInAVehicle() ) |
|
{ |
|
CBaseEntity *pVehicle = assert_cast< CBasePlayer * >(pTarget)->GetVehicleEntity(); |
|
pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,1.0f), &vecMaxPos ); |
|
pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.0f), &vecMinPos ); |
|
|
|
if ( ourHeight > vecMinPos.z && ourHeight < vecMaxPos.z ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
// Get the enemies top and bottom point |
|
pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,1.0f), &vecMaxPos ); |
|
#ifdef _XBOX |
|
pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.5f), &vecMinPos ); // Only half the body is valid |
|
#else |
|
pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.0f), &vecMinPos ); |
|
#endif // _XBOX |
|
// See if we're within that range |
|
if ( ourHeight > vecMinPos.z && ourHeight < vecMaxPos.z ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pEnemy - |
|
// &chasePosition - |
|
// &tolerance - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::TranslateNavGoal( CBaseEntity *pEnemy, Vector &chasePosition ) |
|
{ |
|
if ( pEnemy && pEnemy->IsPlayer() && assert_cast< CBasePlayer * >(pEnemy)->IsInAVehicle() ) |
|
{ |
|
Vector vecNewPos; |
|
CBaseEntity *pVehicle = assert_cast< CBasePlayer * >(pEnemy)->GetVehicleEntity(); |
|
pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.5,0.5,0.5f), &vecNewPos ); |
|
chasePosition.z = vecNewPos.z; |
|
} |
|
else |
|
{ |
|
Vector vecTarget; |
|
pEnemy->CollisionProp()->NormalizedToCollisionSpace( Vector(0,0,0.75f), &vecTarget ); |
|
chasePosition.z += vecTarget.z; |
|
} |
|
} |
|
|
|
float CNPC_Manhack::GetDefaultNavGoalTolerance() |
|
{ |
|
return GetHullWidth(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input that disables the manhack's swarm behavior |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::InputDisableSwarm( inputdata_t &inputdata ) |
|
{ |
|
m_bDoSwarmBehavior = false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : &inputdata - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::InputUnpack( inputdata_t &inputdata ) |
|
{ |
|
if ( HasSpawnFlags( SF_MANHACK_PACKED_UP ) == false ) |
|
return; |
|
|
|
SetCondition( COND_LIGHT_DAMAGE ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pPhysGunUser - |
|
// reason - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason ) |
|
{ |
|
m_hPhysicsAttacker = pPhysGunUser; |
|
m_flLastPhysicsInfluenceTime = gpGlobals->curtime; |
|
|
|
if ( reason == PUNTED_BY_CANNON ) |
|
{ |
|
StopLoitering(); |
|
|
|
m_bHeld = false; |
|
|
|
// There's about to be a massive change in velocity. |
|
// Think immediately so we can do our slice traces, etc. |
|
SetNextThink( gpGlobals->curtime + 0.01f ); |
|
|
|
// Stall our engine for awhile |
|
m_flEngineStallTime = gpGlobals->curtime + 2.0f; |
|
SetEyeState( MANHACK_EYE_STATE_STUNNED ); |
|
} |
|
else |
|
{ |
|
m_pPrevOwner.Set( GetOwnerEntity() ); |
|
|
|
// Suppress collisions between the manhack and the player; we're currently bumping |
|
// almost certainly because it's not purely a physics object. |
|
SetOwnerEntity( pPhysGunUser ); |
|
m_bHeld = true; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pPhysGunUser - |
|
// Reason - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason ) |
|
{ |
|
SetOwnerEntity( m_pPrevOwner.Get() ); |
|
|
|
// Stop suppressing collisions between the manhack and the player |
|
m_pPrevOwner.Set( NULL ); |
|
|
|
m_bHeld = false; |
|
|
|
if ( Reason == LAUNCHED_BY_CANNON ) |
|
{ |
|
m_hPhysicsAttacker = pPhysGunUser; |
|
m_flLastPhysicsInfluenceTime = gpGlobals->curtime; |
|
|
|
// There's about to be a massive change in velocity. |
|
// Think immediately so we can do our slice traces, etc. |
|
SetNextThink( gpGlobals->curtime + 0.01f ); |
|
|
|
// Stall our engine for awhile |
|
m_flEngineStallTime = gpGlobals->curtime + 2.0f; |
|
SetEyeState( MANHACK_EYE_STATE_STUNNED ); |
|
} |
|
else |
|
{ |
|
if( m_bHackedByAlyx && !GetEnemy() ) |
|
{ |
|
// If a hacked manhack is released in peaceable conditions, |
|
// just loiter, don't zip off. |
|
StartLoitering( GetAbsOrigin() ); |
|
} |
|
|
|
m_hPhysicsAttacker = NULL; |
|
m_flLastPhysicsInfluenceTime = 0; |
|
} |
|
} |
|
|
|
void CNPC_Manhack::StartLoitering( const Vector &vecLoiterPosition ) |
|
{ |
|
//Msg("Start Loitering\n"); |
|
|
|
m_vTargetBanking = vec3_origin; |
|
m_vecLoiterPosition = GetAbsOrigin(); |
|
m_vForceVelocity = vec3_origin; |
|
SetCurrentVelocity( vec3_origin ); |
|
} |
|
|
|
CBasePlayer *CNPC_Manhack::HasPhysicsAttacker( float dt ) |
|
{ |
|
// If the player is holding me now, or I've been recently thrown |
|
// then return a pointer to that player |
|
if ( IsHeldByPhyscannon() || (gpGlobals->curtime - dt <= m_flLastPhysicsInfluenceTime) ) |
|
{ |
|
return m_hPhysicsAttacker; |
|
} |
|
return NULL; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Manhacks that have been hacked by Alyx get more engine power (fly faster) |
|
//----------------------------------------------------------------------------- |
|
float CNPC_Manhack::GetMaxEnginePower() |
|
{ |
|
if( m_bHackedByAlyx ) |
|
{ |
|
return 2.0f; |
|
} |
|
|
|
return 1.0f; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::UpdatePanels( void ) |
|
{ |
|
if ( m_flEngineStallTime > gpGlobals->curtime ) |
|
{ |
|
SetPoseParameter( m_iPanel1, random->RandomFloat( 0.0f, 90.0f ) ); |
|
SetPoseParameter( m_iPanel2, random->RandomFloat( 0.0f, 90.0f ) ); |
|
SetPoseParameter( m_iPanel3, random->RandomFloat( 0.0f, 90.0f ) ); |
|
SetPoseParameter( m_iPanel4, random->RandomFloat( 0.0f, 90.0f ) ); |
|
return; |
|
} |
|
|
|
float panelPosition = GetPoseParameter( m_iPanel1 ); |
|
|
|
if ( m_bShowingHostile ) |
|
{ |
|
panelPosition = 90.0f;//UTIL_Approach( 90.0f, panelPosition, 90.0f ); |
|
} |
|
else |
|
{ |
|
panelPosition = UTIL_Approach( 0.0f, panelPosition, 25.0f ); |
|
} |
|
|
|
//FIXME: If we're going to have all these be equal, there's no need for 4 poses.. |
|
SetPoseParameter( m_iPanel1, panelPosition ); |
|
SetPoseParameter( m_iPanel2, panelPosition ); |
|
SetPoseParameter( m_iPanel3, panelPosition ); |
|
SetPoseParameter( m_iPanel4, panelPosition ); |
|
|
|
//TODO: Make these waver randomly? |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : hostile - |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::ShowHostile( bool hostile /*= true*/) |
|
{ |
|
if ( m_bShowingHostile == hostile ) |
|
return; |
|
|
|
//TODO: Open the manhack panels or close them, depending on the state |
|
m_bShowingHostile = hostile; |
|
|
|
if ( hostile ) |
|
{ |
|
EmitSound( "NPC_Manhack.ChargeAnnounce" ); |
|
} |
|
else |
|
{ |
|
EmitSound( "NPC_Manhack.ChargeEnd" ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::StartBurst( const Vector &vecDirection ) |
|
{ |
|
if ( m_flBurstDuration > gpGlobals->curtime ) |
|
return; |
|
|
|
ShowHostile(); |
|
|
|
// Don't burst attack again for a couple seconds |
|
m_flNextBurstTime = gpGlobals->curtime + 2.0; |
|
m_flBurstDuration = gpGlobals->curtime + 1.0; |
|
|
|
// Save off where we were going towards and for how long |
|
m_vecBurstDirection = vecDirection; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::StopBurst( bool bInterruptSchedule /*= false*/ ) |
|
{ |
|
if ( m_flBurstDuration < gpGlobals->curtime ) |
|
return; |
|
|
|
ShowHostile( false ); |
|
|
|
// Stop our burst timers |
|
m_flNextBurstTime = gpGlobals->curtime + 2.0f; //FIXME: Skill level based |
|
m_flBurstDuration = gpGlobals->curtime - 0.1f; |
|
|
|
if ( bInterruptSchedule ) |
|
{ |
|
// We need to rethink our current schedule |
|
ClearSchedule( "Stopping burst" ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CNPC_Manhack::SetEyeState( int state ) |
|
{ |
|
// Make sure we're active |
|
StartEye(); |
|
|
|
switch( state ) |
|
{ |
|
case MANHACK_EYE_STATE_STUNNED: |
|
{ |
|
if ( m_pEyeGlow ) |
|
{ |
|
//Toggle our state |
|
m_pEyeGlow->SetColor( 255, 128, 0 ); |
|
m_pEyeGlow->SetScale( 0.15f, 0.1f ); |
|
m_pEyeGlow->SetBrightness( 164, 0.1f ); |
|
m_pEyeGlow->m_nRenderFX = kRenderFxStrobeFast; |
|
} |
|
|
|
if ( m_pLightGlow ) |
|
{ |
|
m_pLightGlow->SetColor( 255, 128, 0 ); |
|
m_pLightGlow->SetScale( 0.15f, 0.1f ); |
|
m_pLightGlow->SetBrightness( 164, 0.1f ); |
|
m_pLightGlow->m_nRenderFX = kRenderFxStrobeFast; |
|
} |
|
|
|
EmitSound("NPC_Manhack.Stunned"); |
|
|
|
break; |
|
} |
|
|
|
case MANHACK_EYE_STATE_CHARGE: |
|
{ |
|
if ( m_pEyeGlow ) |
|
{ |
|
//Toggle our state |
|
if( m_bHackedByAlyx ) |
|
{ |
|
m_pEyeGlow->SetColor( 0, 255, 0 ); |
|
} |
|
else |
|
{ |
|
m_pEyeGlow->SetColor( 255, 0, 0 ); |
|
} |
|
|
|
m_pEyeGlow->SetScale( 0.25f, 0.5f ); |
|
m_pEyeGlow->SetBrightness( 164, 0.1f ); |
|
m_pEyeGlow->m_nRenderFX = kRenderFxNone; |
|
} |
|
|
|
if ( m_pLightGlow ) |
|
{ |
|
if( m_bHackedByAlyx ) |
|
{ |
|
m_pLightGlow->SetColor( 0, 255, 0 ); |
|
} |
|
else |
|
{ |
|
m_pLightGlow->SetColor( 255, 0, 0 ); |
|
} |
|
|
|
m_pLightGlow->SetScale( 0.25f, 0.5f ); |
|
m_pLightGlow->SetBrightness( 164, 0.1f ); |
|
m_pLightGlow->m_nRenderFX = kRenderFxNone; |
|
} |
|
|
|
break; |
|
} |
|
|
|
default: |
|
if ( m_pEyeGlow ) |
|
m_pEyeGlow->m_nRenderFX = kRenderFxNone; |
|
break; |
|
} |
|
} |
|
|
|
|
|
unsigned int CNPC_Manhack::PhysicsSolidMaskForEntity( void ) const |
|
{ |
|
unsigned int mask = BaseClass::PhysicsSolidMaskForEntity(); |
|
if ( m_bIgnoreClipbrushes ) |
|
{ |
|
mask &= ~CONTENTS_MONSTERCLIP; |
|
} |
|
return mask; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CNPC_Manhack::CreateVPhysics( void ) |
|
{ |
|
if ( HasSpawnFlags( SF_MANHACK_CARRIED ) ) |
|
return false; |
|
|
|
return BaseClass::CreateVPhysics(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Schedules |
|
// |
|
//----------------------------------------------------------------------------- |
|
AI_BEGIN_CUSTOM_NPC( npc_manhack, CNPC_Manhack ) |
|
|
|
DECLARE_TASK( TASK_MANHACK_HOVER ); |
|
DECLARE_TASK( TASK_MANHACK_UNPACK ); |
|
DECLARE_TASK( TASK_MANHACK_FIND_SQUAD_CENTER ); |
|
DECLARE_TASK( TASK_MANHACK_FIND_SQUAD_MEMBER ); |
|
DECLARE_TASK( TASK_MANHACK_MOVEAT_SAVEPOSITION ); |
|
|
|
DECLARE_CONDITION( COND_MANHACK_START_ATTACK ); |
|
|
|
DECLARE_ACTIVITY( ACT_MANHACK_UNPACK ); |
|
|
|
//========================================================= |
|
// > SCHED_MANHACK_ATTACK_HOVER |
|
//========================================================= |
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_MANHACK_ATTACK_HOVER, |
|
|
|
" Tasks" |
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_FLY" |
|
" TASK_MANHACK_HOVER 0" |
|
" " |
|
" Interrupts" |
|
" COND_TOO_FAR_TO_ATTACK" |
|
" COND_TOO_CLOSE_TO_ATTACK" |
|
" COND_NEW_ENEMY" |
|
" COND_ENEMY_DEAD" |
|
" COND_LIGHT_DAMAGE" |
|
" COND_HEAVY_DAMAGE" |
|
" COND_ENEMY_OCCLUDED" |
|
); |
|
|
|
|
|
//========================================================= |
|
// > SCHED_MANHACK_ATTACK_HOVER |
|
//========================================================= |
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_MANHACK_DEPLOY, |
|
|
|
" Tasks" |
|
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_MANHACK_UNPACK" |
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_FLY" |
|
" " |
|
// " Interrupts" |
|
); |
|
|
|
//========================================================= |
|
// > SCHED_MANHACK_REGROUP |
|
//========================================================= |
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_MANHACK_REGROUP, |
|
|
|
" Tasks" |
|
" TASK_STOP_MOVING 0" |
|
" TASK_SET_TOLERANCE_DISTANCE 24" |
|
" TASK_STORE_ENEMY_POSITION_IN_SAVEPOSITION 0" |
|
" TASK_FIND_BACKAWAY_FROM_SAVEPOSITION 0" |
|
" TASK_RUN_PATH 0" |
|
" TASK_WAIT_FOR_MOVEMENT 0" |
|
" " |
|
" Interrupts" |
|
" COND_MANHACK_START_ATTACK" |
|
" COND_NEW_ENEMY" |
|
" COND_CAN_MELEE_ATTACK1" |
|
); |
|
|
|
|
|
|
|
//========================================================= |
|
// > SCHED_MANHACK_SWARN |
|
//========================================================= |
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_MANHACK_SWARM_IDLE, |
|
|
|
" Tasks" |
|
" TASK_STOP_MOVING 0" |
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_MANHACK_SWARM_FAILURE" |
|
" TASK_MANHACK_FIND_SQUAD_CENTER 0" |
|
" TASK_MANHACK_MOVEAT_SAVEPOSITION 5" |
|
" " |
|
" Interrupts" |
|
" COND_NEW_ENEMY" |
|
" COND_SEE_ENEMY" |
|
" COND_SEE_FEAR" |
|
" COND_LIGHT_DAMAGE" |
|
" COND_HEAVY_DAMAGE" |
|
" COND_SMELL" |
|
" COND_PROVOKED" |
|
" COND_GIVE_WAY" |
|
" COND_HEAR_PLAYER" |
|
" COND_HEAR_DANGER" |
|
" COND_HEAR_COMBAT" |
|
" COND_HEAR_BULLET_IMPACT" |
|
); |
|
|
|
|
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_MANHACK_SWARM, |
|
|
|
" Tasks" |
|
" TASK_STOP_MOVING 0" |
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_MANHACK_SWARM_FAILURE" |
|
" TASK_MANHACK_FIND_SQUAD_CENTER 0" |
|
" TASK_MANHACK_MOVEAT_SAVEPOSITION 1" |
|
" " |
|
" Interrupts" |
|
" COND_NEW_ENEMY" |
|
" COND_CAN_MELEE_ATTACK1" |
|
" COND_LIGHT_DAMAGE" |
|
" COND_HEAVY_DAMAGE" |
|
); |
|
|
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_MANHACK_SWARM_FAILURE, |
|
|
|
" Tasks" |
|
" TASK_STOP_MOVING 0" |
|
" TASK_WAIT 2" |
|
" TASK_WAIT_RANDOM 2" |
|
" TASK_MANHACK_FIND_SQUAD_MEMBER 0" |
|
" TASK_GET_PATH_TO_SAVEPOSITION 0" |
|
" TASK_WAIT_FOR_MOVEMENT 0" |
|
" " |
|
" Interrupts" |
|
" COND_SEE_ENEMY" |
|
" COND_NEW_ENEMY" |
|
); |
|
|
|
AI_END_CUSTOM_NPC()
|
|
|