//========= 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()