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.
3363 lines
88 KiB
3363 lines
88 KiB
#include "cbase.h" |
|
#include "soundenvelope.h" |
|
#include "asw_buzzer.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 "func_break.h" |
|
#include "physics_impact_damage.h" |
|
#include "weapon_physcannon.h" |
|
#include "physics_prop_ragdoll.h" |
|
#include "soundent.h" |
|
#include "ammodef.h" |
|
#include "asw_fx_shared.h" |
|
#include "asw_spawner.h" |
|
#include "asw_ai_senses.h" |
|
#include "asw_util_shared.h" |
|
#include "asw_gamerules.h" |
|
#include "EntityFlame.h" |
|
#include "asw_burning.h" |
|
#include "asw_marine.h" |
|
#include "asw_gamestats.h" |
|
#include "asw_director.h" |
|
#include "asw_weapon.h" |
|
#include "asw_game_resource.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
// When the engine is running and the buzzer is operating under power |
|
// we don't let gravity affect him. |
|
#define ASW_BUZZER_GRAVITY 0.000 |
|
|
|
//#define ASW_BUZZER_MODEL "models/manhack.mdl" |
|
#define ASW_BUZZER_MODEL "models/aliens/buzzer/buzzer.mdl" |
|
|
|
#define ASW_BUZZER_GIB_COUNT 5 |
|
#define ASW_BUZZER_INGORE_WATER_DIST 384 |
|
|
|
// Sound stuff |
|
#define ASW_BUZZER_PITCH_DIST1 512 |
|
#define ASW_BUZZER_MIN_PITCH1 (100) |
|
#define ASW_BUZZER_MAX_PITCH1 (160) |
|
#define ASW_BUZZER_WATER_PITCH1 (85) |
|
#define ASW_BUZZER_VOLUME1 0.55 |
|
|
|
#define ASW_BUZZER_PITCH_DIST2 400 |
|
#define ASW_BUZZER_MIN_PITCH2 (85) |
|
#define ASW_BUZZER_MAX_PITCH2 (190) |
|
#define ASW_BUZZER_WATER_PITCH2 (90) |
|
|
|
#define ASW_BUZZER_NOISEMOD_HIDE 5000 |
|
|
|
#define ASW_BUZZER_BODYGROUP_BLADE 1 |
|
#define ASW_BUZZER_BODYGROUP_BLUR 2 |
|
#define ASW_BUZZER_BODYGROUP_OFF 0 |
|
#define ASW_BUZZER_BODYGROUP_ON 1 |
|
|
|
#define ASW_BUZZER_CHARGE_MIN_DIST 200 |
|
|
|
ConVar sk_asw_buzzer_health( "sk_asw_buzzer_health","30", FCVAR_CHEAT, "Health of the buzzer"); |
|
ConVar sk_asw_buzzer_melee_dmg( "sk_asw_buzzer_melee_dmg","15", FCVAR_CHEAT, "Damage caused by buzzer"); |
|
ConVar sk_asw_buzzer_melee_interval( "sk_asw_buzzer_melee_interval", "1.5", FCVAR_CHEAT, "Min time between causing damage to marines"); |
|
ConVar sk_asw_buzzer_v2( "sk_asw_buzzer_v2","1", FCVAR_CHEAT, ""); |
|
ConVar asw_buzzer_poison_duration("asw_buzzer_poison_duration", "0.6f", FCVAR_CHEAT, "Base buzzer poison blur duration. This scales up to double the value based on mission difficulty."); |
|
extern ConVar showhitlocation; |
|
extern ConVar asw_debug_alien_damage; |
|
extern ConVar asw_alien_speed_scale_easy; |
|
extern ConVar asw_alien_speed_scale_normal; |
|
extern ConVar asw_alien_speed_scale_hard; |
|
extern ConVar asw_alien_speed_scale_insane; |
|
extern ConVar asw_stun_grenade_time; |
|
|
|
extern void SpawnBlood(Vector vecSpot, const Vector &vAttackDir, int bloodColor, float flDamage); |
|
extern float GetFloorZ(const Vector &origin); |
|
|
|
envelopePoint_t envBuzzerMoanIgnited[] = |
|
{ |
|
{ 1.0f, 1.0f, |
|
0.5f, 1.0f, |
|
}, |
|
{ 1.0f, 1.0f, |
|
30.0f, 30.0f, |
|
}, |
|
{ 0.0f, 0.0f, |
|
0.5f, 1.0f, |
|
}, |
|
}; |
|
|
|
envelopePoint_t envDefaultBuzzerMoanVolumeFast[] = |
|
{ |
|
{ 1.0f, 1.0f, |
|
0.1f, 0.1f, |
|
}, |
|
{ 0.0f, 0.0f, |
|
0.2f, 0.3f, |
|
}, |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Manhack schedules. |
|
//----------------------------------------------------------------------------- |
|
enum BuzzerSchedules |
|
{ |
|
SCHED_ASW_BUZZER_ATTACK_HOVER = LAST_SHARED_SCHEDULE, |
|
SCHED_ASW_BUZZER_REGROUP, |
|
SCHED_ASW_BUZZER_SWARM_IDLE, |
|
SCHED_ASW_BUZZER_SWARM, |
|
SCHED_ASW_BUZZER_SWARM_FAILURE, |
|
SCHED_ASW_BUZZER_ORDER_MOVE, |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Manhack tasks. |
|
//----------------------------------------------------------------------------- |
|
enum BuzzerTasks |
|
{ |
|
TASK_ASW_BUZZER_HOVER = LAST_SHARED_TASK, |
|
TASK_ASW_BUZZER_FIND_SQUAD_CENTER, |
|
TASK_ASW_BUZZER_FIND_SQUAD_MEMBER, |
|
TASK_ASW_BUZZER_MOVEAT_SAVEPOSITION, |
|
TASK_ASW_BUZZER_BUILD_PATH_TO_ORDER, |
|
}; |
|
|
|
BEGIN_DATADESC( CASW_Buzzer ) |
|
|
|
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), |
|
|
|
// Death |
|
|
|
DEFINE_FIELD( m_bDirtyPitch, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( m_bGib, FIELD_BOOLEAN), |
|
DEFINE_FIELD( m_bHeld, FIELD_BOOLEAN), |
|
DEFINE_FIELD( m_vecLoiterPosition, FIELD_POSITION_VECTOR), |
|
DEFINE_FIELD( m_fSuicideTime, FIELD_TIME), |
|
|
|
DEFINE_FIELD( m_flWingFlapSpeed, FIELD_FLOAT), |
|
|
|
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 ), |
|
|
|
// 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 ), |
|
|
|
DEFINE_FIELD( m_hSpawner, FIELD_EHANDLE ), |
|
|
|
DEFINE_FIELD(m_fNextPainSound, FIELD_FLOAT), |
|
DEFINE_SOUNDPATCH( m_pMoanSound ), |
|
DEFINE_FIELD( m_flMoanPitch, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_flNextMoanSound, FIELD_TIME ), |
|
DEFINE_FIELD( m_bOnFire, FIELD_BOOLEAN ), |
|
DEFINE_FIELD(m_fHurtSlowMoveTime, FIELD_TIME), |
|
DEFINE_FIELD(m_flElectroStunSlowMoveTime, FIELD_TIME), |
|
DEFINE_FIELD(m_bElectroStunned, FIELD_BOOLEAN), |
|
DEFINE_FIELD( m_bHoldoutAlien, FIELD_BOOLEAN ), |
|
|
|
// Function Pointers |
|
DEFINE_INPUTFUNC( FIELD_VOID, "DisableSwarm", InputDisableSwarm ), |
|
|
|
END_DATADESC() |
|
|
|
|
|
LINK_ENTITY_TO_CLASS( asw_buzzer, CASW_Buzzer ); |
|
|
|
IMPLEMENT_SERVERCLASS_ST(CASW_Buzzer, DT_ASW_Buzzer) |
|
SendPropIntWithMinusOneFlag (SENDINFO(m_nEnginePitch1), 8 ), |
|
SendPropFloat(SENDINFO(m_flEnginePitch1Time), 0, SPROP_NOSCALE), |
|
SendPropBool(SENDINFO(m_bOnFire)), |
|
SendPropBool(SENDINFO(m_bElectroStunned)), |
|
END_SEND_TABLE() |
|
|
|
CASW_Buzzer::CASW_Buzzer() |
|
{ |
|
#ifdef _DEBUG |
|
m_vForceMoveTarget.Init(); |
|
m_vSwarmMoveTarget.Init(); |
|
m_vTargetBanking.Init(); |
|
m_vForceVelocity.Init(); |
|
#endif |
|
m_bDirtyPitch = true; |
|
m_nLastWaterLevel = 0; |
|
m_nEnginePitch1 = 0; |
|
m_flEnginePitch1Time = 0; |
|
m_flEnginePitch1Time = 0; |
|
m_bDoSwarmBehavior = true; |
|
m_fNextPainSound = 0; |
|
m_bHoldoutAlien = false; |
|
m_flLastDamageTime = 0; |
|
} |
|
|
|
CASW_Buzzer::~CASW_Buzzer() |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Turns the buzzer into a physics corpse when dying. |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::Event_Dying(void) |
|
{ |
|
SetHullSizeNormal(); |
|
BaseClass::Event_Dying(); |
|
} |
|
|
|
void CASW_Buzzer::OnRestore() |
|
{ |
|
BaseClass::OnRestore(); |
|
m_LagCompensation.Init(this); |
|
} |
|
|
|
void CASW_Buzzer::PrescheduleThink( void ) |
|
{ |
|
BaseClass::PrescheduleThink(); |
|
|
|
if( m_flWaterSuspendTime > gpGlobals->curtime ) |
|
{ |
|
// Stuck in water! |
|
|
|
// Reduce engine power so that the buzzer 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(); |
|
} |
|
|
|
void CASW_Buzzer::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr ) |
|
{ |
|
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 ); |
|
} |
|
UTIL_ASW_DroneBleed( ptr->endpos + m_LagCompensation.GetLagCompensationOffset(), vecDir, 4 ); |
|
|
|
//BaseClass::TraceAttack( info, vecDir, ptr ); |
|
|
|
m_fNoDamageDecal = false; |
|
if ( m_takedamage == DAMAGE_NO ) |
|
return; |
|
|
|
CTakeDamageInfo subInfo = info; |
|
|
|
SetLastHitGroup( ptr->hitgroup ); |
|
m_nForceBone = ptr->physicsbone; // save this bone for physics forces |
|
|
|
Assert( m_nForceBone > -255 && m_nForceBone < 256 ); |
|
|
|
bool bDebug = showhitlocation.GetBool(); |
|
|
|
switch ( ptr->hitgroup ) |
|
{ |
|
case HITGROUP_GENERIC: |
|
if( bDebug ) DevMsg("Hit Location: Generic\n"); |
|
break; |
|
|
|
// hit gear, react but don't bleed |
|
case HITGROUP_GEAR: |
|
subInfo.SetDamage( 0.01 ); |
|
ptr->hitgroup = HITGROUP_GENERIC; |
|
if( bDebug ) DevMsg("Hit Location: Gear\n"); |
|
break; |
|
|
|
case HITGROUP_HEAD: |
|
subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); |
|
if( bDebug ) DevMsg("Hit Location: Head\n"); |
|
break; |
|
|
|
case HITGROUP_CHEST: |
|
subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); |
|
if( bDebug ) DevMsg("Hit Location: Chest\n"); |
|
break; |
|
|
|
case HITGROUP_STOMACH: |
|
subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); |
|
if( bDebug ) DevMsg("Hit Location: Stomach\n"); |
|
break; |
|
|
|
case HITGROUP_LEFTARM: |
|
case HITGROUP_RIGHTARM: |
|
subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); |
|
if( bDebug ) DevMsg("Hit Location: Left/Right Arm\n"); |
|
break |
|
; |
|
case HITGROUP_LEFTLEG: |
|
case HITGROUP_RIGHTLEG: |
|
subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); |
|
if( bDebug ) DevMsg("Hit Location: Left/Right Leg\n"); |
|
break; |
|
|
|
default: |
|
if( bDebug ) DevMsg("Hit Location: UNKNOWN\n"); |
|
break; |
|
} |
|
|
|
if ( subInfo.GetDamage() >= 1.0 && !(subInfo.GetDamageType() & DMG_SHOCK ) ) |
|
{ |
|
if( !IsPlayer() || ( IsPlayer() && gpGlobals->maxClients > 1 ) ) |
|
{ |
|
// NPC's always bleed. Players only bleed in multiplayer. |
|
SpawnBlood( ptr->endpos, vecDir, BloodColor(), subInfo.GetDamage() );// a little surface blood. |
|
} |
|
|
|
ASWTraceBleed( subInfo.GetDamage(), vecDir, ptr, subInfo.GetDamageType() ); |
|
|
|
if ( ptr->hitgroup == HITGROUP_HEAD && m_iHealth - subInfo.GetDamage() > 0 ) |
|
{ |
|
m_fNoDamageDecal = true; |
|
} |
|
} |
|
|
|
// Airboat gun will impart major force if it's about to kill him.... |
|
if ( info.GetDamageType() & DMG_AIRBOAT ) |
|
{ |
|
if ( subInfo.GetDamage() >= GetHealth() ) |
|
{ |
|
float flMagnitude = subInfo.GetDamageForce().Length(); |
|
if ( (flMagnitude != 0.0f) && (flMagnitude < 400.0f * 65.0f) ) |
|
{ |
|
subInfo.ScaleDamageForce( 400.0f * 65.0f / flMagnitude ); |
|
} |
|
} |
|
} |
|
|
|
if( info.GetInflictor() ) |
|
{ |
|
subInfo.SetInflictor( info.GetInflictor() ); |
|
} |
|
else |
|
{ |
|
subInfo.SetInflictor( info.GetAttacker() ); |
|
} |
|
|
|
AddMultiDamage( subInfo, this ); |
|
} |
|
|
|
void CASW_Buzzer::ASWTraceBleed( float flDamage, const Vector &vecDir, trace_t *ptr, int bitsDamageType ) |
|
{ |
|
if ((BloodColor() == DONT_BLEED) || (BloodColor() == BLOOD_COLOR_MECH)) |
|
{ |
|
return; |
|
} |
|
|
|
if (flDamage == 0) |
|
return; |
|
|
|
if (! (bitsDamageType & (DMG_CRUSH | DMG_BULLET | DMG_SLASH | DMG_BLAST | DMG_CLUB | DMG_AIRBOAT))) |
|
return; |
|
|
|
// make blood decal on the wall! |
|
trace_t Bloodtr; |
|
Vector vecTraceDir; |
|
float flNoise; |
|
int cCount; |
|
int i; |
|
|
|
#ifdef GAME_DLL |
|
if ( !IsAlive() ) |
|
{ |
|
// dealing with a dead npc. |
|
if ( GetMaxHealth() <= 0 ) |
|
{ |
|
// no blood decal for a npc that has already decalled its limit. |
|
return; |
|
} |
|
else |
|
{ |
|
m_iMaxHealth -= 1; |
|
} |
|
} |
|
#endif |
|
|
|
if (flDamage < 10) |
|
{ |
|
flNoise = 0.1; |
|
cCount = 1; |
|
} |
|
else if (flDamage < 25) |
|
{ |
|
flNoise = 0.2; |
|
cCount = 2; |
|
} |
|
else |
|
{ |
|
flNoise = 0.3; |
|
cCount = 4; |
|
} |
|
|
|
float flTraceDist = (bitsDamageType & DMG_AIRBOAT) ? 384 : 172; |
|
for ( i = 0 ; i < cCount ; i++ ) |
|
{ |
|
vecTraceDir = vecDir * -1;// trace in the opposite direction the shot came from (the direction the shot is going) |
|
|
|
vecTraceDir.x += random->RandomFloat( -flNoise, flNoise ); |
|
vecTraceDir.y += random->RandomFloat( -flNoise, flNoise ); |
|
vecTraceDir.z += random->RandomFloat( -flNoise, flNoise ); |
|
|
|
// Don't bleed on grates. |
|
Vector vecEndPos = ptr->endpos + m_LagCompensation.GetLagCompensationOffset(); |
|
AI_TraceLine( vecEndPos, vecEndPos + vecTraceDir * -flTraceDist, MASK_SOLID_BRUSHONLY & ~CONTENTS_GRATE, this, COLLISION_GROUP_NONE, &Bloodtr); |
|
|
|
if ( Bloodtr.fraction != 1.0 ) |
|
{ |
|
UTIL_BloodDecalTrace( &Bloodtr, BloodColor() ); |
|
} |
|
} |
|
} |
|
|
|
void CASW_Buzzer::DeathSound( const CTakeDamageInfo &info ) |
|
{ |
|
CPASAttenuationFilter filter2( this, "ASW_Buzzer.Death" ); |
|
EmitSound( filter2, entindex(), "ASW_Buzzer.Death" ); |
|
} |
|
|
|
void CASW_Buzzer::PainSound( const CTakeDamageInfo &info ) |
|
{ |
|
// no pain sound on burning |
|
if (info.GetDamageType() & DMG_BURN) |
|
return; |
|
|
|
if (gpGlobals->curtime > m_fNextPainSound) |
|
{ |
|
CPASAttenuationFilter filter2( this, "ASW_Buzzer.Pain" ); |
|
EmitSound( filter2, entindex(), "ASW_Buzzer.Pain" ); |
|
m_fNextPainSound = gpGlobals->curtime + 0.5f; |
|
} |
|
} |
|
|
|
bool CASW_Buzzer::ShouldGib( const CTakeDamageInfo &info ) |
|
{ |
|
return true; // always gib buzzers |
|
//return ( m_bGib ); |
|
} |
|
|
|
void CASW_Buzzer::Event_Killed( const CTakeDamageInfo &info ) |
|
{ |
|
if (ASWGameRules()) |
|
{ |
|
ASWGameRules()->AlienKilled(this, info); |
|
} |
|
|
|
CASW_GameStats.Event_AlienKilled( this, info ); |
|
|
|
if ( ASWDirector() ) |
|
ASWDirector()->Event_AlienKilled( this, info ); |
|
|
|
// notify our spawner, so it can spit out more buzzers if need be |
|
if (m_hSpawner.Get()) |
|
m_hSpawner->AlienKilled(this); |
|
|
|
// turn off the blur! |
|
SetBodygroup( ASW_BUZZER_BODYGROUP_BLUR, ASW_BUZZER_BODYGROUP_OFF ); |
|
|
|
UTIL_ASW_BuzzerDeath( GetAbsOrigin() ); |
|
|
|
if ( m_nEnginePitch1 <= 0 ) |
|
{ |
|
// Probably this buzzer 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; |
|
} |
|
|
|
BaseClass::Event_Killed( info ); |
|
|
|
UTIL_Remove( this ); |
|
} |
|
|
|
void CASW_Buzzer::HitPhysicsObject( CBaseEntity *pOther ) |
|
{ |
|
IPhysicsObject *pOtherPhysics = pOther->VPhysicsGetObject(); |
|
Vector pos, posOther; |
|
// Put the force on the line between the buzzer 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 buzzer 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 a vehicle; it's like a really big crowbar |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::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 CASW_Buzzer::TakeDamageFromPhysicsImpact( int index, gamevcollisionevent_t *pEvent ) |
|
{ |
|
CBaseEntity *pHitEntity = pEvent->pEntities[!index]; |
|
|
|
// NOTE: Bypass the normal impact energy scale here. |
|
float flDamageScale = 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 ); |
|
} |
|
|
|
|
|
#define ASW_BUZZER_SMASH_TIME 0.35 // How long after being thrown from a physcannon that a buzzer is eligible to die from impact |
|
void CASW_Buzzer::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) |
|
{ |
|
BaseClass::VPhysicsCollision( index, pEvent ); |
|
|
|
int otherIndex = !index; |
|
CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex]; |
|
|
|
if ( pHitEntity ) |
|
{ |
|
// It can take physics damage if it rams into a vehicle |
|
if ( pHitEntity->GetServerVehicle() ) |
|
{ |
|
TakeDamageFromVehicle( index, pEvent ); |
|
} |
|
else if ( m_iHealth <= 0 ) |
|
{ |
|
TakeDamageFromPhysicsImpact( index, pEvent ); |
|
} |
|
|
|
StopBurst( true ); |
|
} |
|
} |
|
|
|
|
|
void CASW_Buzzer::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 ); |
|
} |
|
|
|
int CASW_Buzzer::OnTakeDamage_Alive( const CTakeDamageInfo &info ) |
|
{ |
|
// Hafta make a copy of info cause we might need to scale damage.(sjb) |
|
CTakeDamageInfo tdInfo = info; |
|
|
|
// undo lag compensation if we're getting hurt - TODO: this is incorrect if multiple rounds were meant to hit us within this player command - would happen with the shotguns if they were hitscan? |
|
m_LagCompensation.UndoLaggedPosition(); |
|
|
|
// scale damage based on weapons that specifically shoot flyers |
|
if ( info.GetAttacker() && info.GetAttacker()->Classify() == CLASS_ASW_MARINE ) |
|
{ |
|
CASW_Marine *pMarine = dynamic_cast<CASW_Marine*>( info.GetAttacker() ); |
|
if ( pMarine ) |
|
{ |
|
CASW_Weapon *pWeapon = pMarine->GetActiveASWWeapon(); |
|
if ( pWeapon ) |
|
{ |
|
float damage = tdInfo.GetDamage(); |
|
//CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, damage, mod_damage_flyers ); |
|
tdInfo.SetDamage( damage ); |
|
} |
|
} |
|
} |
|
|
|
|
|
m_flWingFlapSpeed = 20.0; |
|
|
|
Vector vecDamageDir = tdInfo.GetDamageForce(); |
|
VectorNormalize( vecDamageDir ); |
|
|
|
|
|
// no being knocked back by shots |
|
m_vForceVelocity = vec3_origin; //vecDamageDir * info.GetDamage() * 20.0f; |
|
|
|
tdInfo.SetDamageForce( vecDamageDir ); //tdInfo.GetDamageForce() * 20 ); |
|
|
|
// come to a complete stop if hurt |
|
//SetCurrentVelocity( vec3_origin ); |
|
if (m_fHurtSlowMoveTime < gpGlobals->curtime + 0.4f) |
|
m_fHurtSlowMoveTime = gpGlobals->curtime + 0.4f; |
|
|
|
//VPhysicsTakeDamage( info ); |
|
|
|
if (asw_debug_alien_damage.GetBool()) |
|
{ |
|
Msg("%d %s hurt by %f dmg\n", entindex(), GetClassname(), info.GetDamage()); |
|
} |
|
|
|
int nRetVal = BaseClass::OnTakeDamage_Alive( tdInfo ); |
|
if ( nRetVal ) |
|
{ |
|
// if we take fire or blast damage, catch on fire |
|
if (nRetVal > 0 && |
|
( (info.GetDamageType() & DMG_BURN) || (info.GetDamageType() & DMG_BLAST) ) |
|
) |
|
ASW_Ignite(30.0f, 0, info.GetAttacker(), info.GetWeapon() ); |
|
} |
|
|
|
// make the alien move slower for 0.5 seconds |
|
if (info.GetDamageType() & DMG_SHOCK) |
|
{ |
|
ElectroStun( asw_stun_grenade_time.GetFloat() ); |
|
} |
|
|
|
CASW_Marine* pMarine = dynamic_cast<CASW_Marine*>(info.GetAttacker()); |
|
if (pMarine) |
|
pMarine->HurtAlien(this, info); |
|
|
|
return nRetVal; |
|
} |
|
|
|
bool CASW_Buzzer::CorpseGib( const CTakeDamageInfo &info ) |
|
{ |
|
Vector vecGibVelocity; |
|
AngularImpulse vecGibAVelocity; |
|
|
|
m_LagCompensation.UndoLaggedPosition(); |
|
|
|
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(); |
|
|
|
return true; |
|
} |
|
|
|
|
|
// Purpose: Explode the buzzer if it's damaged while crashing |
|
int CASW_Buzzer::OnTakeDamage_Dying( const CTakeDamageInfo &info ) |
|
{ |
|
// Ignore damage for the first 1 second of crashing behavior. |
|
// If we don't do this, buzzers always just explode under |
|
// sustained fire. |
|
VPhysicsTakeDamage( info ); |
|
|
|
return 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Turn on the engine sound if we're gagged! |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::OnStateChange( NPC_STATE OldState, NPC_STATE NewState ) |
|
{ |
|
if( m_vNoiseMod.z == ASW_BUZZER_NOISEMOD_HIDE && !(m_spawnflags & SF_NPC_WAIT_FOR_SCRIPT) ) |
|
{ |
|
// This buzzer 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: Returns whether or not the given activity would translate to flying. |
|
//----------------------------------------------------------------------------- |
|
bool CASW_Buzzer::IsFlyingActivity( Activity baseAct ) |
|
{ |
|
return ((baseAct == ACT_FLY || baseAct == ACT_IDLE || baseAct == ACT_RUN || baseAct == ACT_WALK)); |
|
} |
|
|
|
Activity CASW_Buzzer::NPC_TranslateActivity( Activity baseAct ) |
|
{ |
|
if (IsFlyingActivity( baseAct )) |
|
{ |
|
return (Activity)ACT_FLY; |
|
} |
|
|
|
return BaseClass::NPC_TranslateActivity( baseAct ); |
|
} |
|
|
|
int CASW_Buzzer::TranslateSchedule( int scheduleType ) |
|
{ |
|
switch ( scheduleType ) |
|
{ |
|
case SCHED_MELEE_ATTACK1: |
|
{ |
|
return SCHED_ASW_BUZZER_ATTACK_HOVER; |
|
break; |
|
} |
|
case SCHED_BACK_AWAY_FROM_ENEMY: |
|
{ |
|
return SCHED_ASW_BUZZER_REGROUP; |
|
break; |
|
} |
|
case SCHED_CHASE_ENEMY: |
|
{ |
|
// If we're waiting for our next attack opportunity, just swarm |
|
if ( m_flNextBurstTime > gpGlobals->curtime ) |
|
{ |
|
return SCHED_ASW_BUZZER_SWARM; |
|
} |
|
|
|
if ( !m_bDoSwarmBehavior || OccupyStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) ) |
|
{ |
|
return SCHED_CHASE_ENEMY; |
|
} |
|
else |
|
{ |
|
return SCHED_ASW_BUZZER_SWARM; |
|
} |
|
} |
|
case SCHED_COMBAT_FACE: |
|
{ |
|
// Don't care about facing enemy, handled automatically |
|
return TranslateSchedule( SCHED_CHASE_ENEMY ); |
|
break; |
|
} |
|
case SCHED_WAKE_ANGRY: |
|
{ |
|
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_ASW_BUZZER_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 CASW_Buzzer::Loiter() |
|
{ |
|
//NDebugOverlay::Line( GetAbsOrigin(), m_vecLoiterPosition, 255, 255, 255, false, 0.1 ); |
|
|
|
// Friendly buzzer 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; |
|
} |
|
} |
|
} |
|
|
|
void CASW_Buzzer::MaintainGroundHeight( void ) |
|
{ |
|
float zSpeed = GetCurrentVelocity().z; |
|
|
|
if ( m_NPCState != NPC_STATE_IDLE && zSpeed > 32.0f ) |
|
{ |
|
//Msg("[X] "); |
|
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) ); |
|
//Msg("[%f] ", speedAdj); |
|
m_vForceVelocity += Vector(0,0,1) * ( speedAdj * ( 1.0f - tr.fraction ) ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handles movement towards the last move target. |
|
// Input : flInterval - |
|
//----------------------------------------------------------------------------- |
|
bool CASW_Buzzer::OverrideMove( float flInterval ) |
|
{ |
|
FlapWings( flInterval ); |
|
if( IsLoitering() ) |
|
{ |
|
//Msg("Loitering "); |
|
Loiter(); |
|
} |
|
else |
|
{ |
|
//Msg("Maint. "); |
|
MaintainGroundHeight(); |
|
} |
|
|
|
// So cops, etc. will try to avoid them |
|
if ( !HasSpawnFlags( SF_ASW_BUZZER_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) |
|
{ |
|
//Msg("MoveToTarget "); |
|
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); |
|
//Msg("ProgressFlyPath "); |
|
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) |
|
{ |
|
//Msg("MoveToTarget Sw "); |
|
MoveToTarget(flInterval, m_vSwarmMoveTarget); |
|
} |
|
// ----------------------------------------------------------------- |
|
// If I don't have anything better to do, just decelerate |
|
// -------------------------------------------------------------- ---- |
|
else |
|
{ |
|
//Msg("Decelerate "); |
|
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()->GetAbsOrigin() ); |
|
} |
|
} |
|
|
|
// asw temp |
|
m_vForceVelocity = vec3_origin; |
|
|
|
if ( m_iHealth <= 0 ) |
|
{ |
|
//Msg("MED\n"); |
|
// Crashing!! |
|
MoveExecute_Dead(flInterval); |
|
} |
|
else |
|
{ |
|
//Msg("MEA\n"); |
|
// Alive! |
|
MoveExecute_Alive(flInterval); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::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 CASW_Buzzer::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()->WorldSpaceCenter() - 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; |
|
myAccel = 500; |
|
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 buzzers 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; |
|
} |
|
|
|
void CASW_Buzzer::TurnHeadToTarget( float flInterval, const Vector &moveTarget ) |
|
{ |
|
if ( m_iHealth <= 0 ) |
|
return; |
|
|
|
BaseClass::TurnHeadToTarget( flInterval, moveTarget ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Ignore water if I'm close to my enemy |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
int CASW_Buzzer::MoveCollisionMask(void) |
|
{ |
|
return MASK_NPCSOLID; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Make a splash effect |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::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 CASW_Buzzer::ComputeSliceBounceVelocity( CBaseEntity *pHitEntity, trace_t &tr ) |
|
{ |
|
if( pHitEntity->IsAlive() && FClassnameIs( pHitEntity, "func_breakable_surf" ) ) |
|
{ |
|
// We want to see if the buzzer 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 buzzer bouncing off the pane of glass, |
|
// since this impact will shatter the glass and let the buzzer through. |
|
return; |
|
} |
|
|
|
Vector vecDir; |
|
|
|
// If the buzzer 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 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: We've touched something that we can hurt. Slice it! |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::Slice( CBaseEntity *pHitEntity, float flInterval, trace_t &tr ) |
|
{ |
|
// Don't hurt the player if I'm in water |
|
if( GetWaterLevel() > 0 && pHitEntity->IsPlayer() ) |
|
return; |
|
|
|
if ( pHitEntity->m_takedamage == DAMAGE_NO ) |
|
return; |
|
|
|
// don't damage marines again so soon |
|
if ( pHitEntity && pHitEntity->Classify() == CLASS_ASW_MARINE ) |
|
{ |
|
if ( ( gpGlobals->curtime - m_flLastDamageTime ) < sk_asw_buzzer_melee_interval.GetFloat() ) |
|
return; |
|
} |
|
|
|
// Damage must be scaled by flInterval so framerate independent |
|
float flDamage = ASWGameRules()->ModifyAlienDamageBySkillLevel(sk_asw_buzzer_melee_dmg.GetFloat()) * flInterval; |
|
|
|
// cap it somewhat |
|
if (flDamage > 30) |
|
{ |
|
flDamage = 30; |
|
} |
|
|
|
//if ( pHitEntity->IsPlayer() ) |
|
//{ |
|
//flDamage *= 2.0f; |
|
//} |
|
|
|
|
|
//else if ( pHitEntity->IsNPC() && HasPhysicsAttacker( ASW_BUZZER_SMASH_TIME ) ) |
|
//{ |
|
// NOTE: The else here is essential. |
|
// The physics attacker *will* be set even when the buzzer is held |
|
//flDamage = pHitEntity->GetHealth(); |
|
//} |
|
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 | DMG_BLURPOISON ); |
|
|
|
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( "ASW_Buzzer.Attack" ); |
|
|
|
//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( "ASW_Buzzer.Attack" ); |
|
} |
|
|
|
// 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 CASW_Buzzer::Bump( CBaseEntity *pHitEntity, float flInterval, trace_t &tr ) |
|
{ |
|
if ( !VPhysicsGetObject() ) |
|
return; |
|
|
|
if ( pHitEntity->GetMoveType() == MOVETYPE_VPHYSICS && pHitEntity->Classify()!=CLASS_ASW_BUZZER ) |
|
{ |
|
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 ) |
|
{ |
|
// 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); |
|
|
|
// don't want buzzers to spin! |
|
//VPhysicsGetObject()->ApplyTorqueCenter( torque ); |
|
} |
|
|
|
if (!(m_spawnflags & SF_NPC_GAG)) |
|
{ |
|
EmitSound( "ASW_Buzzer.Attack" ); |
|
} |
|
} |
|
|
|
VectorNormalize( moveVec ); |
|
float hitAngle = -DotProduct( tr.plane.normal, -moveVec ); |
|
|
|
Vector vReflection = 2.0 * tr.plane.normal * hitAngle + -moveVec; |
|
|
|
float deflectSpeed = clamp( GetCurrentVelocity().Length(), 100, 400 ); |
|
|
|
SetCurrentVelocity( GetCurrentVelocity() + vReflection * deflectSpeed ); |
|
} |
|
|
|
// ------------------------------------------------------------- |
|
// 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 buzzer 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 CASW_Buzzer::CheckCollisions(float flInterval) |
|
{ |
|
if ( !VPhysicsGetObject() ) |
|
return; |
|
|
|
// Trace forward to see if I hit anything. |
|
Vector vecTraceDir, vecCheckPos; |
|
VPhysicsGetObject()->GetVelocity( &vecTraceDir, NULL ); |
|
vecTraceDir *= flInterval; |
|
|
|
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 ( pHitEntity != NULL && |
|
pHitEntity->m_takedamage == DAMAGE_YES && |
|
pHitEntity->Classify() != CLASS_ASW_BUZZER && |
|
gpGlobals->curtime > m_flWaterSuspendTime ) |
|
{ |
|
// Slice this thing |
|
Slice( pHitEntity, flInterval, tr ); |
|
m_flWingFlapSpeed = 20.0; |
|
} |
|
else |
|
{ |
|
// Just bump into this thing. |
|
Bump( pHitEntity, flInterval, tr ); |
|
m_flWingFlapSpeed = 20.0; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
#define tempTIME_STEP = 0.5; |
|
void CASW_Buzzer::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 = ASW_BUZZER_WATER_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.5f; |
|
m_bDirtyPitch = false; |
|
} |
|
} |
|
// Spin sound based on distance from enemy (unless we're crashing) |
|
else if (GetEnemy() && IsAlive() ) |
|
{ |
|
if( flEnemyDist < ASW_BUZZER_PITCH_DIST1 ) |
|
{ |
|
// recalculate pitch. |
|
int iPitch1, iPitch2; |
|
float flDistFactor; |
|
|
|
flDistFactor = MIN( 1.0, 1 - flEnemyDist / ASW_BUZZER_PITCH_DIST1 ); |
|
iPitch1 = ASW_BUZZER_MIN_PITCH1 + ( ( ASW_BUZZER_MAX_PITCH1 - ASW_BUZZER_MIN_PITCH1 ) * flDistFactor); |
|
|
|
// NOTE: ASW_BUZZER_PITCH_DIST2 must be < ASW_BUZZER_PITCH_DIST1 |
|
flDistFactor = MIN( 1.0, 1 - flEnemyDist / ASW_BUZZER_PITCH_DIST2 ); |
|
iPitch2 = ASW_BUZZER_MIN_PITCH2 + ( ( ASW_BUZZER_MAX_PITCH2 - ASW_BUZZER_MIN_PITCH2 ) * flDistFactor); |
|
|
|
m_nEnginePitch1 = iPitch1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.1f; |
|
|
|
m_bDirtyPitch = true; |
|
} |
|
else if( m_bDirtyPitch ) |
|
{ |
|
m_nEnginePitch1 = ASW_BUZZER_MIN_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.1f; |
|
m_bDirtyPitch = false; |
|
} |
|
} |
|
// If no enemy just play low sound |
|
else if( IsAlive() && m_bDirtyPitch ) |
|
{ |
|
m_nEnginePitch1 = ASW_BUZZER_MIN_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime + 0.1f; |
|
|
|
m_bDirtyPitch = false; |
|
} |
|
|
|
if (IsOnFire()) |
|
m_nEnginePitch1 = ASW_BUZZER_MAX_PITCH1; |
|
|
|
// 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 CASW_Buzzer::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 < ASW_BUZZER_CHARGE_MIN_DIST ) |
|
{ |
|
// Less noise up close. |
|
noiseScale = 2.0; |
|
} |
|
|
|
if ( IsInEffectiveTargetZone( GetEnemy() ) && flDist < ASW_BUZZER_CHARGE_MIN_DIST && gpGlobals->curtime > m_flNextBurstTime ) |
|
{ |
|
Vector vecCurrentDir = GetCurrentVelocity(); |
|
VectorNormalize( vecCurrentDir ); |
|
|
|
Vector vecToEnemy = ( GetEnemy()->WorldSpaceCenter() - 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 ); |
|
} |
|
} |
|
|
|
if ( gpGlobals->curtime > m_flBurstDuration ) |
|
{ |
|
ShowHostile( false ); |
|
} |
|
} |
|
|
|
// ---------------------------------------------------------------------------------------- |
|
// Add in any forced velocity |
|
// ---------------------------------------------------------------------------------------- |
|
SetCurrentVelocity( vCurrentVelocity + m_vForceVelocity ); |
|
m_vForceVelocity = vec3_origin; |
|
|
|
if( 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) ) & (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 buzzer to lift off, but not to go deeper. |
|
m_vCurrentVelocity.z = MAX( m_vCurrentVelocity.z, 0 ); |
|
} |
|
|
|
CheckCollisions(flInterval); |
|
|
|
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 ) |
|
} |
|
#endif |
|
} |
|
|
|
// SetLocalAngles( angles ); |
|
|
|
if( m_lifeState != LIFE_DEAD ) |
|
{ |
|
PlayFlySound(); |
|
// WalkMove( GetCurrentVelocity() * flInterval, MASK_NPCSOLID ); |
|
} |
|
|
|
// NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, -10 ), 0, 255, 0, true, 0.1); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::FlapWings(float flInterval) |
|
{ |
|
if ( IsFlyingActivity( GetActivity() ) ) |
|
{ |
|
// Blades may only ramp up while the engine is running |
|
if ( m_flEngineStallTime < gpGlobals->curtime ) |
|
{ |
|
if (m_flWingFlapSpeed < 10) |
|
{ |
|
m_flWingFlapSpeed = m_flWingFlapSpeed * 2 + 1; |
|
} |
|
else |
|
{ |
|
// accelerate engine |
|
m_flWingFlapSpeed = m_flWingFlapSpeed + 80 * flInterval; |
|
} |
|
} |
|
|
|
if (m_flWingFlapSpeed > 100) |
|
{ |
|
m_flWingFlapSpeed = 100; |
|
} |
|
|
|
// blend through blades, blades+blur, blur |
|
if (m_flWingFlapSpeed < 20) |
|
{ |
|
SetBodygroup( ASW_BUZZER_BODYGROUP_BLADE, ASW_BUZZER_BODYGROUP_ON ); |
|
SetBodygroup( ASW_BUZZER_BODYGROUP_BLUR, ASW_BUZZER_BODYGROUP_OFF ); |
|
} |
|
else if (m_flWingFlapSpeed < 40) |
|
{ |
|
SetBodygroup( ASW_BUZZER_BODYGROUP_BLADE, ASW_BUZZER_BODYGROUP_ON ); |
|
SetBodygroup( ASW_BUZZER_BODYGROUP_BLUR, ASW_BUZZER_BODYGROUP_ON ); |
|
} |
|
else |
|
{ |
|
SetBodygroup( ASW_BUZZER_BODYGROUP_BLADE, ASW_BUZZER_BODYGROUP_OFF ); |
|
SetBodygroup( ASW_BUZZER_BODYGROUP_BLUR, ASW_BUZZER_BODYGROUP_ON ); |
|
} |
|
|
|
m_flPlaybackRate = m_flWingFlapSpeed / 100.0; |
|
} |
|
else |
|
{ |
|
m_flWingFlapSpeed = 0.0; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Smokes and sparks, exploding periodically. Eventually it goes away. |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::MoveExecute_Dead(float flInterval) |
|
{ |
|
if ( m_fSuicideTime == 0.0f ) |
|
{ |
|
m_fSuicideTime = gpGlobals->curtime + 1.5; |
|
} |
|
else if ( gpGlobals->curtime > m_fSuicideTime ) |
|
{ |
|
CTakeDamageInfo info( NULL, NULL, Vector(0,0,0), GetAbsOrigin(), GetHealth() * 2, DMG_ACID ); |
|
Event_Killed( info ); |
|
} |
|
|
|
if( GetWaterLevel() > 0 ) |
|
{ |
|
// No movement if sinking in water. |
|
return; |
|
} |
|
|
|
Vector newVelocity = GetCurrentVelocity(); |
|
|
|
// accelerate faster and faster when dying |
|
newVelocity = newVelocity + (newVelocity * 1.5 * flInterval ); |
|
|
|
// Lose lift |
|
newVelocity.z -= 0.2*flInterval*(sv_gravity.GetFloat()); |
|
|
|
// ---------------------------------------------------------------------------------------- |
|
// 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, ASW_BUZZER_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 CASW_Buzzer::Precache(void) |
|
{ |
|
// |
|
// Model. |
|
// |
|
PrecacheModel( ASW_BUZZER_MODEL ); |
|
PropBreakablePrecacheAll( MAKE_STRING(ASW_BUZZER_MODEL) ); |
|
|
|
PrecacheScriptSound( "ASW_Buzzer.Attack" ); |
|
PrecacheScriptSound( "ASW_Buzzer.Death" ); |
|
PrecacheScriptSound( "ASW_Buzzer.Pain" ); |
|
PrecacheScriptSound( "ASW_Buzzer.Idle" ); |
|
PrecacheScriptSound( "ASW_Buzzer.OnFire" ); |
|
|
|
PrecacheParticleSystem( "buzzer_trail" ); |
|
PrecacheParticleSystem( "buzzer_death" ); |
|
|
|
// Sounds used on Client: |
|
//PrecacheScriptSound( "NPC_Manhack.EngineSound1" ); |
|
//PrecacheScriptSound( "NPC_Manhack.EngineSound2" ); |
|
//PrecacheScriptSound( "NPC_Manhack.BladeSound" ); |
|
|
|
BaseClass::Precache(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::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_ASW_BUZZER_START_ATTACK); |
|
} |
|
else |
|
{ |
|
float targetZ = pEnemy->EyePosition().z; |
|
if (fabs(GetAbsOrigin().z - targetZ) < flZDist) |
|
{ |
|
SetCondition(COND_ASW_BUZZER_START_ATTACK); |
|
} |
|
} |
|
BaseClass::GatherEnemyConditions(pEnemy); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: For innate melee attack |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
int CASW_Buzzer::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 CASW_Buzzer::RunTask( const Task_t *pTask ) |
|
{ |
|
switch ( pTask->iTask ) |
|
{ |
|
// Override this task so we go for the enemy at eye level |
|
case TASK_ASW_BUZZER_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_ASW_BUZZER_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 CASW_Buzzer::Spawn(void) |
|
{ |
|
Precache(); |
|
|
|
SetModel( ASW_BUZZER_MODEL ); |
|
SetHullType(HULL_TINY_CENTERED); |
|
SetHullSizeNormal(); |
|
|
|
SetSolid( SOLID_BBOX ); |
|
AddSolidFlags( FSOLID_NOT_STANDABLE ); |
|
|
|
SetMoveType( MOVETYPE_VPHYSICS ); |
|
|
|
SetHealthByDifficultyLevel(); |
|
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_ASW_BUZZER_USE_AIR_NODES) |
|
{ |
|
SetNavType(NAV_FLY); |
|
} |
|
else |
|
{ |
|
SetNavType(NAV_GROUND); |
|
} |
|
|
|
ChangeFaction( FACTION_ALIENS ); |
|
|
|
AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL ); |
|
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; |
|
|
|
// Set the noise mod to huge numbers right now, in case this buzzer 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' buzzers in small places. (sjb) |
|
SetNoiseMod( ASW_BUZZER_NOISEMOD_HIDE, ASW_BUZZER_NOISEMOD_HIDE, ASW_BUZZER_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; |
|
m_pMoanSound = NULL; |
|
|
|
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 ); |
|
|
|
// makes us collide with everything, but the player can walk through us (needed since the player has no vphys shadow to stop us going into him) |
|
SetCollisionGroup( ASW_COLLISION_GROUP_BUZZER ); |
|
|
|
m_bHeld = false; |
|
StopLoitering(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::StartEye( void ) |
|
{ |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CASW_Buzzer::Activate() |
|
{ |
|
BaseClass::Activate(); |
|
|
|
if ( IsAlive() ) |
|
{ |
|
StartEye(); |
|
} |
|
} |
|
|
|
void CASW_Buzzer::NPCInit() |
|
{ |
|
BaseClass::NPCInit(); |
|
|
|
// set default alien swarm sight/sense distances |
|
SetDistSwarmSense(576.0f); |
|
SetDistLook( 768.0f ); |
|
m_flDistTooFar = 1500.0f; // seems this is used as an early out for checking attack conditions or not, also for LOS? |
|
|
|
// if flagged, alien can see twice as far |
|
if ( HasSpawnFlags( SF_NPC_LONG_RANGE ) ) |
|
{ |
|
SetDistSwarmSense(1152.0f); |
|
SetDistLook( 1536.0f ); |
|
m_flDistTooFar = 2000.0f; |
|
} |
|
|
|
CASW_GameStats.Event_AlienSpawned( this ); |
|
|
|
m_LagCompensation.Init(this); |
|
SetDistSwarmSense(576.0f); |
|
} |
|
|
|
void CASW_Buzzer::NPCThink( void ) |
|
{ |
|
BaseClass::NPCThink(); |
|
|
|
// stop electro stunning if we're slowed |
|
if (m_bElectroStunned && m_flElectroStunSlowMoveTime < gpGlobals->curtime) |
|
m_bElectroStunned = false; |
|
|
|
if (gpGlobals->maxClients > 1) |
|
m_LagCompensation.StorePositionHistory(); |
|
} |
|
|
|
void CASW_Buzzer::SetDistSwarmSense( float flDistSense ) |
|
{ |
|
if (!GetASWSenses()) |
|
return; |
|
GetASWSenses()->SetDistSwarmSense( flDistSense ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the engine sound started. Unless we're not supposed to have it on yet! |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::PostNPCInit( void ) |
|
{ |
|
// SetAbsVelocity( vec3_origin ); |
|
BladesInit(); |
|
} |
|
|
|
void CASW_Buzzer::BladesInit() |
|
{ |
|
bool engineSound = (m_spawnflags & SF_NPC_GAG) ? false : true; |
|
StartEngine( engineSound ); |
|
SetActivity( ACT_FLY ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Crank up the engine! |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::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 ); |
|
|
|
// Under powered flight now. |
|
// SetMoveType( MOVETYPE_STEP ); |
|
// SetGravity( ASW_BUZZER_GRAVITY ); |
|
AddFlag( FL_FLY ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Start the buzzer's engine sound. |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::SoundInit( void ) |
|
{ |
|
m_nEnginePitch1 = ASW_BUZZER_MIN_PITCH1; |
|
m_flEnginePitch1Time = gpGlobals->curtime; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::StopLoopingSounds(void) |
|
{ |
|
BaseClass::StopLoopingSounds(); |
|
m_nEnginePitch1 = 0; |
|
m_flEnginePitch1Time = gpGlobals->curtime; |
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pMoanSound ); |
|
m_pMoanSound = NULL; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : pTask - |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::StartTask( const Task_t *pTask ) |
|
{ |
|
switch (pTask->iTask) |
|
{ |
|
case TASK_ASW_BUZZER_HOVER: |
|
break; |
|
case TASK_ASW_BUZZER_BUILD_PATH_TO_ORDER: |
|
{ |
|
CBaseEntity *pGoalEnt = m_AlienOrderObject; |
|
m_bFailedMoveTo = false; |
|
if (pGoalEnt) |
|
{ |
|
// if our target is a path corner, do normal AI following of that route |
|
bool bIsFlying = (GetMoveType() == MOVETYPE_FLY) || (GetMoveType() == MOVETYPE_FLYGRAVITY); |
|
if (pGoalEnt->ClassMatches("path_corner")) |
|
{ |
|
SetGoalEnt(pGoalEnt); |
|
|
|
AI_NavGoal_t goal( GOALTYPE_PATHCORNER, pGoalEnt->GetAbsOrigin(), |
|
bIsFlying ? ACT_FLY : ACT_WALK, |
|
AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST); |
|
|
|
SetState( NPC_STATE_IDLE ); |
|
if ( !GetNavigator()->SetGoal( goal ) ) |
|
{ |
|
DevWarning( 2, "Can't Create Route!\n" ); |
|
m_bFailedMoveTo = true; |
|
} |
|
else |
|
{ |
|
TaskComplete(); |
|
} |
|
} |
|
else |
|
{ |
|
// HACKHACK: Call through TranslateNavGoal to fixup this goal position |
|
// UNDONE: Remove this and have NPCs that need this functionality fix up paths in the |
|
// movement system instead of when they are specified. |
|
AI_NavGoal_t goal(pGoalEnt->GetAbsOrigin(), bIsFlying ? ACT_FLY : ACT_WALK, AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST); |
|
TranslateNavGoal( pGoalEnt, goal.dest ); |
|
|
|
if (!GetNavigator()->SetGoal( goal )) |
|
{ |
|
DevWarning( 2, "Can't Create Route!\n" ); |
|
m_bFailedMoveTo = true; |
|
} |
|
else |
|
{ |
|
TaskComplete(); |
|
} |
|
} |
|
} |
|
if (!pGoalEnt || m_bFailedMoveTo) |
|
{ |
|
//m_AlienOrders = AOT_SpreadThenHibernate; // make sure our orders are set correctly for this action (may be incorrect if a MoveTo order fails) |
|
if (pTask->flTaskData <= 0) // check the taskdata to see if we should do a short spread movement when failing to build a path |
|
{ |
|
// random nearby position |
|
if ( GetNavigator()->SetWanderGoal( 90, 200 ) ) |
|
{ |
|
TaskComplete(); |
|
} |
|
else |
|
{ |
|
// if we couldn't go for a full path |
|
if ( GetNavigator()->SetRandomGoal( 150.0f ) ) |
|
{ |
|
TaskComplete(); |
|
} |
|
TaskFail(FAIL_NO_ROUTE); |
|
} |
|
} |
|
else |
|
{ |
|
TaskFail(FAIL_NO_ROUTE); |
|
} |
|
} |
|
} |
|
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_ASW_BUZZER_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_ASW_BUZZER_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_ASW_BUZZER_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: 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 CASW_Buzzer::HandleInteraction(int interactionType, void* data, CBaseCombatCharacter* sourceEnt) |
|
{ |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : float |
|
//----------------------------------------------------------------------------- |
|
float CASW_Buzzer::ManhackMaxSpeed( void ) |
|
{ |
|
if( m_flWaterSuspendTime > gpGlobals->curtime |
|
|| m_flElectroStunSlowMoveTime > gpGlobals->curtime ) |
|
{ |
|
// Slower in water! |
|
return ASW_BUZZER_MAX_SPEED * 0.1f; |
|
} |
|
|
|
if( m_fHurtSlowMoveTime > gpGlobals->curtime ) |
|
{ |
|
return ASW_BUZZER_MAX_SPEED * 0.5f; |
|
} |
|
|
|
return ASW_BUZZER_MAX_SPEED; |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::ClampMotorForces( Vector &linear, AngularImpulse &angular ) |
|
{ |
|
float scale = m_flWingFlapSpeed / 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: Tests whether we're above the target's feet but also below their top |
|
// Input : *pTarget - who we're testing against |
|
//----------------------------------------------------------------------------- |
|
bool CASW_Buzzer::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 ); |
|
pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.0f), &vecMinPos ); |
|
|
|
// See if we're within that range |
|
if ( ourHeight > vecMinPos.z && ourHeight < vecMaxPos.z ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pEnemy - |
|
// &chasePosition - |
|
// &tolerance - |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::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 CASW_Buzzer::GetDefaultNavGoalTolerance() |
|
{ |
|
return GetHullWidth(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Freezes this NPC in place for a period of time. |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::Freeze( float flFreezeAmount, CBaseEntity *pFreezer, Ray_t *pFreezeRay ) |
|
{ |
|
BaseClass::Freeze( flFreezeAmount, pFreezer, pFreezeRay ); |
|
|
|
if ( GetMoveType() != MOVETYPE_NONE && GetFrozenAmount() > 0.0f ) |
|
{ |
|
// Freeze makes us hate life! |
|
m_flFrozen = 1.0f; |
|
m_flFrozenThawRate = 0.0f; |
|
|
|
m_iHealth = 0; |
|
} |
|
} |
|
|
|
bool CASW_Buzzer::ShouldBecomeStatue( void ) |
|
{ |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input that disables the buzzer's swarm behavior |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::InputDisableSwarm( inputdata_t &inputdata ) |
|
{ |
|
m_bDoSwarmBehavior = false; |
|
} |
|
|
|
|
|
void CASW_Buzzer::StartLoitering( const Vector &vecLoiterPosition ) |
|
{ |
|
//Msg("Start Loitering\n"); |
|
|
|
m_vTargetBanking = vec3_origin; |
|
m_vecLoiterPosition = GetAbsOrigin(); |
|
m_vForceVelocity = vec3_origin; |
|
SetCurrentVelocity( vec3_origin ); |
|
} |
|
|
|
// buzzers have better acceleration on harder difficulty levels |
|
float CASW_Buzzer::GetMaxEnginePower() |
|
{ |
|
if (m_bElectroStunned) |
|
return 0.5f; |
|
|
|
if (ASWGameRules()) |
|
{ |
|
int nSkillLevel = ASWGameRules()->GetSkillLevel(); |
|
nSkillLevel = clamp<int>( nSkillLevel, 1, 4 ); |
|
return nSkillLevel + 0.1f; |
|
} |
|
return 2.0f; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : hostile - |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::ShowHostile( bool hostile /*= true*/) |
|
{ |
|
if ( m_bShowingHostile == hostile ) |
|
return; |
|
|
|
m_bShowingHostile = hostile; |
|
|
|
if ( hostile ) |
|
{ |
|
EmitSound( "ASW_Buzzer.Attack" ); |
|
} |
|
else |
|
{ |
|
//EmitSound( "NPC_Manhack.ChargeEnd" ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CASW_Buzzer::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 CASW_Buzzer::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: |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CASW_Buzzer::CreateVPhysics( void ) |
|
{ |
|
return BaseClass::CreateVPhysics(); |
|
} |
|
|
|
|
|
void CASW_Buzzer::SetSpawner(CASW_Base_Spawner* spawner) |
|
{ |
|
m_hSpawner = spawner; |
|
} |
|
|
|
// Updates our memory about the enemies we Swarm Sensed |
|
// todo: add various swarm sense conditions? |
|
void CASW_Buzzer::OnSwarmSensed(int iDistance) |
|
{ |
|
// DON'T let visibility information from last frame sit around! |
|
//static int conditionsToClear[] = |
|
//{ |
|
//COND_SEE_HATE, |
|
//COND_SEE_DISLIKE, |
|
//COND_SEE_ENEMY, |
|
//COND_SEE_FEAR, |
|
//COND_SEE_NEMESIS, |
|
//COND_SEE_PLAYER, |
|
//}; |
|
|
|
//ClearConditions( conditionsToClear, ARRAYSIZE( conditionsToClear ) ); |
|
|
|
AISightIter_t iter; |
|
CBaseEntity *pSenseEnt; |
|
|
|
pSenseEnt = GetASWSenses()->GetFirstSwarmSenseEntity( &iter ); |
|
|
|
while( pSenseEnt ) |
|
{ |
|
if ( pSenseEnt->IsPlayer() ) |
|
{ |
|
// if we see a client, remember that (mostly for scripted AI) |
|
//SetCondition(COND_SEE_PLAYER); |
|
} |
|
|
|
Disposition_t relation = IRelationType( pSenseEnt ); |
|
|
|
// the looker will want to consider this entity |
|
// don't check anything else about an entity that can't be seen, or an entity that you don't care about. |
|
if ( relation != D_NU ) |
|
{ |
|
if ( pSenseEnt == GetEnemy() ) |
|
{ |
|
// we know this ent is visible, so if it also happens to be our enemy, store that now. |
|
//SetCondition(COND_SEE_ENEMY); |
|
} |
|
|
|
// don't add the Enemy's relationship to the conditions. We only want to worry about conditions when |
|
// we see npcs other than the Enemy. |
|
switch ( relation ) |
|
{ |
|
case D_HT: |
|
{ |
|
int priority = IRelationPriority( pSenseEnt ); |
|
if (priority < 0) |
|
{ |
|
//SetCondition(COND_SEE_DISLIKE); |
|
} |
|
else if (priority > 10) |
|
{ |
|
//SetCondition(COND_SEE_NEMESIS); |
|
} |
|
else |
|
{ |
|
//SetCondition(COND_SEE_HATE); |
|
} |
|
UpdateEnemyMemory(pSenseEnt,pSenseEnt->GetAbsOrigin()); |
|
break; |
|
|
|
} |
|
case D_FR: |
|
UpdateEnemyMemory(pSenseEnt,pSenseEnt->GetAbsOrigin()); |
|
//SetCondition(COND_SEE_FEAR); |
|
break; |
|
case D_LI: |
|
case D_NU: |
|
break; |
|
default: |
|
DevWarning( 2, "%s can't assess %s\n", GetClassname(), pSenseEnt->GetClassname() ); |
|
break; |
|
} |
|
} |
|
|
|
pSenseEnt = GetASWSenses()->GetNextSwarmSenseEntity( &iter ); |
|
} |
|
} |
|
|
|
// create our custom senses class |
|
CAI_Senses* CASW_Buzzer::CreateSenses() |
|
{ |
|
CAI_Senses *pSenses = new CASW_AI_Senses; |
|
pSenses->SetOuter( this ); |
|
return pSenses; |
|
} |
|
|
|
CASW_AI_Senses* CASW_Buzzer::GetASWSenses() |
|
{ |
|
return dynamic_cast<CASW_AI_Senses*>(GetSenses()); |
|
} |
|
|
|
// set orders for our alien |
|
// select schedule should activate the appropriate orders |
|
void CASW_Buzzer::SetAlienOrders(AlienOrder_t Orders, Vector vecOrderSpot, CBaseEntity* pOrderObject) |
|
{ |
|
m_AlienOrders = Orders; |
|
m_vecAlienOrderSpot = vecOrderSpot; // unused currently |
|
m_AlienOrderObject = pOrderObject; |
|
|
|
if (Orders == AOT_None) |
|
{ |
|
ClearAlienOrders(); |
|
return; |
|
} |
|
|
|
ForceDecisionThink(); // todo: stagger the decision time if at start of mission? |
|
|
|
//Msg("Buzzer recieved orders\n"); |
|
} |
|
|
|
AlienOrder_t CASW_Buzzer::GetAlienOrders() |
|
{ |
|
return m_AlienOrders; |
|
} |
|
|
|
void CASW_Buzzer::ClearAlienOrders() |
|
{ |
|
//Msg("Buzzer orders cleared\n"); |
|
m_AlienOrders = AOT_None; |
|
m_vecAlienOrderSpot = vec3_origin; |
|
m_AlienOrderObject = NULL; |
|
m_bIgnoreMarines = false; |
|
m_bFailedMoveTo = false; |
|
} |
|
|
|
void CASW_Buzzer::GatherConditions() |
|
{ |
|
BaseClass::GatherConditions(); |
|
|
|
if( IsLoitering() && GetEnemy() ) |
|
{ |
|
StopLoitering(); |
|
} |
|
|
|
if (m_bIgnoreMarines) // todo: 'proper' way to ignore conditions? (using SetIgnoreConditions on receiving orders doesn't work) |
|
{ |
|
ClearCondition(COND_CAN_MELEE_ATTACK1); |
|
ClearCondition(COND_CAN_MELEE_ATTACK2); |
|
ClearCondition(COND_CAN_RANGE_ATTACK1); |
|
ClearCondition(COND_CAN_RANGE_ATTACK2); |
|
ClearCondition(COND_ENEMY_DEAD); |
|
ClearCondition(COND_HEAR_BULLET_IMPACT); |
|
ClearCondition(COND_HEAR_COMBAT); |
|
ClearCondition(COND_HEAR_DANGER); |
|
ClearCondition(COND_HEAR_PHYSICS_DANGER); |
|
ClearCondition(COND_NEW_ENEMY); |
|
ClearCondition(COND_PROVOKED); |
|
ClearCondition(COND_SEE_ENEMY); |
|
ClearCondition(COND_SEE_FEAR); |
|
ClearCondition(COND_SMELL); |
|
ClearCondition(COND_HEAVY_DAMAGE); |
|
ClearCondition(COND_LIGHT_DAMAGE); |
|
ClearCondition(COND_RECEIVED_ORDERS); |
|
} |
|
|
|
if (HasCondition(COND_NEW_ENEMY) |
|
&& m_AlienOrders != AOT_MoveToIgnoringMarines) // if we're not ignoring marines, finish our orders once we spot an enemy |
|
ClearAlienOrders(); |
|
} |
|
|
|
// if we arrive at our destination, clear our orders |
|
void CASW_Buzzer::OnMovementComplete() |
|
{ |
|
bool bClearOrders = true; |
|
if (m_AlienOrders != AOT_None) |
|
{ |
|
//Msg("Buzzer orders complete\n"); |
|
if (m_AlienOrders == AOT_SpreadThenHibernate && m_bFailedMoveTo) |
|
{ |
|
// should try to repath? |
|
// or go to a schedule where we wait X seconds, then try to repath? |
|
} |
|
// check if we finished trying to chase a marine, but don't have an enemy yet |
|
// this means the marine probably moved somewhere else and we need to chase after him again |
|
if (m_AlienOrders == AOT_MoveToNearestMarine && !GetEnemy()) |
|
{ |
|
float marine_distance; |
|
CBaseEntity *pMarine = UTIL_ASW_NearestMarine(GetAbsOrigin(), marine_distance); |
|
if (pMarine) |
|
{ |
|
// don't clear orders, this'll make the alien's selectschedule do the marine chase again |
|
bClearOrders = false; |
|
} |
|
} |
|
} |
|
|
|
if (bClearOrders) |
|
ClearAlienOrders(); |
|
|
|
|
|
BaseClass::OnMovementComplete(); |
|
} |
|
|
|
void CASW_Buzzer::IgnoreMarines(bool bIgnoreMarines) |
|
{ |
|
static int g_GeneralConditions[] = |
|
{ |
|
COND_CAN_MELEE_ATTACK1, |
|
COND_CAN_MELEE_ATTACK2, |
|
COND_CAN_RANGE_ATTACK1, |
|
COND_CAN_RANGE_ATTACK2, |
|
COND_ENEMY_DEAD, |
|
COND_HEAR_BULLET_IMPACT, |
|
COND_HEAR_COMBAT, |
|
COND_HEAR_DANGER, |
|
COND_HEAR_PHYSICS_DANGER, |
|
COND_NEW_ENEMY, |
|
COND_PROVOKED, |
|
COND_SEE_ENEMY, |
|
COND_SEE_FEAR, |
|
COND_SMELL, |
|
}; |
|
|
|
static int g_DamageConditions[] = |
|
{ |
|
COND_HEAVY_DAMAGE, |
|
COND_LIGHT_DAMAGE, |
|
COND_RECEIVED_ORDERS, |
|
}; |
|
|
|
ClearIgnoreConditions( g_GeneralConditions, ARRAYSIZE(g_GeneralConditions) ); |
|
ClearIgnoreConditions( g_DamageConditions, ARRAYSIZE(g_DamageConditions) ); |
|
|
|
if (bIgnoreMarines) |
|
{ |
|
SetIgnoreConditions( g_GeneralConditions, ARRAYSIZE(g_GeneralConditions) ); |
|
SetIgnoreConditions( g_DamageConditions, ARRAYSIZE(g_DamageConditions) ); |
|
m_bIgnoreMarines = true; |
|
} |
|
} |
|
|
|
int CASW_Buzzer::SelectAlienOrdersSchedule() |
|
{ |
|
int schedule = 0; |
|
// check if we have any alien orders to follow |
|
switch (m_AlienOrders) |
|
{ |
|
case AOT_MoveToIgnoringMarines: |
|
{ |
|
IgnoreMarines(true); |
|
schedule = SCHED_ASW_BUZZER_ORDER_MOVE; |
|
} |
|
break; |
|
case AOT_SpreadThenHibernate: |
|
case AOT_MoveTo: |
|
{ |
|
IgnoreMarines(false); |
|
schedule = SCHED_ASW_BUZZER_ORDER_MOVE; |
|
} |
|
break; |
|
case AOT_MoveToNearestMarine: |
|
{ |
|
float marine_distance; |
|
// refresh our order target, in case the one passed in by the orders is no longer the nearest |
|
m_AlienOrderObject = UTIL_ASW_NearestMarine( GetAbsOrigin(), marine_distance ); |
|
IgnoreMarines(false); |
|
schedule = SCHED_ASW_BUZZER_ORDER_MOVE; |
|
} |
|
break; |
|
case AOT_None: |
|
default: |
|
{ |
|
// nothing |
|
} |
|
} |
|
return schedule; |
|
} |
|
|
|
int CASW_Buzzer::SelectSchedule( void ) |
|
{ |
|
// see if our alien orders want to schedule something |
|
int order_schedule = SelectAlienOrdersSchedule(); |
|
if (order_schedule > 0) |
|
{ |
|
//Msg("SelectSchedule picked alien orders\n"); |
|
return order_schedule; |
|
} |
|
|
|
return BaseClass::SelectSchedule(); |
|
} |
|
|
|
void CASW_Buzzer::Ignite( float flFlameLifetime, bool bNPCOnly, float flSize, bool bCalledByLevelDesigner ) |
|
{ |
|
return; // use ASW_Ignite instead |
|
} |
|
void CASW_Buzzer::ASW_Ignite( float flFlameLifetime, float flSize, CBaseEntity *pAttacker, CBaseEntity *pDamagingWeapon /*= NULL */ ) |
|
{ |
|
if (AllowedToIgnite()) |
|
{ |
|
if( IsOnFire() ) |
|
return; |
|
|
|
AddFlag( FL_ONFIRE ); |
|
m_bOnFire = true; |
|
if (ASWBurning()) |
|
ASWBurning()->BurnEntity(this, pAttacker, flFlameLifetime, 0.4f, 5.0f * 0.4f, pDamagingWeapon ); // 5 dps, applied every 0.4 seconds |
|
|
|
m_OnIgnite.FireOutput( this, this ); |
|
|
|
RemoveSpawnFlags( SF_NPC_GAG ); |
|
|
|
MoanSound( envBuzzerMoanIgnited, ARRAYSIZE( envBuzzerMoanIgnited ) ); |
|
|
|
if( m_pMoanSound ) |
|
{ |
|
CSoundEnvelopeController::GetController().SoundChangePitch( m_pMoanSound, 120, 1.0 ); |
|
CSoundEnvelopeController::GetController().SoundChangeVolume( m_pMoanSound, 1, 1.0 ); |
|
} |
|
} |
|
} |
|
|
|
void CASW_Buzzer::Extinguish() |
|
{ |
|
m_bOnFire = false; |
|
if( m_pMoanSound ) |
|
{ |
|
CSoundEnvelopeController::GetController().SoundChangeVolume( m_pMoanSound, 0, 2.0 ); |
|
CSoundEnvelopeController::GetController().SoundChangePitch( m_pMoanSound, 100, 2.0 ); |
|
} |
|
|
|
if (ASWBurning()) |
|
ASWBurning()->Extinguish(this); |
|
RemoveFlag( FL_ONFIRE ); |
|
} |
|
|
|
void CASW_Buzzer::MoanSound( envelopePoint_t *pEnvelope, int iEnvelopeSize ) |
|
{ |
|
if( HasSpawnFlags( SF_NPC_GAG ) ) |
|
{ |
|
// Not yet! |
|
return; |
|
} |
|
|
|
if( !m_pMoanSound ) |
|
{ |
|
// Don't set this up until the code calls for it. |
|
const char *pszSound = "ASW_Buzzer.OnFire"; //GetMoanSound( m_iMoanSound ); |
|
m_flMoanPitch = random->RandomInt( 95, 105 ); |
|
|
|
CPASAttenuationFilter filter( this ); |
|
m_pMoanSound = CSoundEnvelopeController::GetController().SoundCreate( filter, entindex(), CHAN_STATIC, pszSound, ATTN_NORM ); |
|
|
|
CSoundEnvelopeController::GetController().Play( m_pMoanSound, 1.0, m_flMoanPitch ); |
|
} |
|
|
|
envDefaultBuzzerMoanVolumeFast[ 1 ].durationMin = 0.1f; |
|
envDefaultBuzzerMoanVolumeFast[ 1 ].durationMax = 0.4f; |
|
|
|
if( random->RandomInt( 1, 2 ) == 1 ) |
|
{ |
|
IdleSound(); |
|
} |
|
|
|
float duration = CSoundEnvelopeController::GetController().SoundPlayEnvelope( m_pMoanSound, SOUNDCTRL_CHANGE_VOLUME, pEnvelope, iEnvelopeSize ); |
|
|
|
//float flPitch = random->RandomInt( m_flMoanPitch + 0, m_flMoanPitch ); |
|
float flPitch = m_flMoanPitch; |
|
CSoundEnvelopeController::GetController().SoundChangePitch( m_pMoanSound, flPitch, 0.3 ); |
|
|
|
m_flNextMoanSound = gpGlobals->curtime + duration + 9999; |
|
} |
|
|
|
|
|
void CASW_Buzzer::SetHealthByDifficultyLevel() |
|
{ |
|
SetHealth(ASWGameRules()->ModifyAlienHealthBySkillLevel(sk_asw_buzzer_health.GetFloat())); |
|
} |
|
|
|
void CASW_Buzzer::ElectroStun( float flStunTime ) |
|
{ |
|
if (m_flElectroStunSlowMoveTime < gpGlobals->curtime + flStunTime) |
|
m_flElectroStunSlowMoveTime = gpGlobals->curtime + flStunTime; |
|
|
|
m_bElectroStunned = true; |
|
|
|
if ( ASWGameResource() ) |
|
{ |
|
ASWGameResource()->m_iElectroStunnedAliens++; |
|
} |
|
|
|
// can't jump after being elecrostunned |
|
CapabilitiesRemove( bits_CAP_MOVE_JUMP ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Schedules |
|
// |
|
//----------------------------------------------------------------------------- |
|
AI_BEGIN_CUSTOM_NPC( npc_buzzer, CASW_Buzzer ) |
|
|
|
DECLARE_TASK( TASK_ASW_BUZZER_HOVER ); |
|
DECLARE_TASK( TASK_ASW_BUZZER_FIND_SQUAD_CENTER ); |
|
DECLARE_TASK( TASK_ASW_BUZZER_FIND_SQUAD_MEMBER ); |
|
DECLARE_TASK( TASK_ASW_BUZZER_MOVEAT_SAVEPOSITION ); |
|
DECLARE_TASK(TASK_ASW_BUZZER_BUILD_PATH_TO_ORDER); |
|
|
|
DECLARE_CONDITION( COND_ASW_BUZZER_START_ATTACK ); |
|
|
|
//========================================================= |
|
// > SCHED_ASW_BUZZER_ATTACK_HOVER |
|
//========================================================= |
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_ASW_BUZZER_ATTACK_HOVER, |
|
|
|
" Tasks" |
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_FLY" |
|
" TASK_ASW_BUZZER_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_ASW_BUZZER_REGROUP |
|
//========================================================= |
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_ASW_BUZZER_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_ASW_BUZZER_START_ATTACK" |
|
" COND_NEW_ENEMY" |
|
" COND_CAN_MELEE_ATTACK1" |
|
); |
|
|
|
|
|
|
|
//========================================================= |
|
// > SCHED_ASW_BUZZER_SWARM_IDLE |
|
//========================================================= |
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_ASW_BUZZER_SWARM_IDLE, |
|
|
|
" Tasks" |
|
" TASK_STOP_MOVING 0" |
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ASW_BUZZER_SWARM_FAILURE" |
|
" TASK_ASW_BUZZER_FIND_SQUAD_CENTER 0" |
|
" TASK_ASW_BUZZER_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_ASW_BUZZER_SWARM, |
|
|
|
" Tasks" |
|
" TASK_STOP_MOVING 0" |
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ASW_BUZZER_SWARM_FAILURE" |
|
" TASK_ASW_BUZZER_FIND_SQUAD_CENTER 0" |
|
" TASK_ASW_BUZZER_MOVEAT_SAVEPOSITION 1" |
|
" " |
|
" Interrupts" |
|
" COND_NEW_ENEMY" |
|
" COND_CAN_MELEE_ATTACK1" |
|
" COND_LIGHT_DAMAGE" |
|
" COND_HEAVY_DAMAGE" |
|
); |
|
|
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_ASW_BUZZER_SWARM_FAILURE, |
|
|
|
" Tasks" |
|
" TASK_STOP_MOVING 0" |
|
" TASK_WAIT 2" |
|
" TASK_WAIT_RANDOM 2" |
|
" TASK_ASW_BUZZER_FIND_SQUAD_MEMBER 0" |
|
" TASK_GET_PATH_TO_SAVEPOSITION 0" |
|
" TASK_WAIT_FOR_MOVEMENT 0" |
|
" " |
|
" Interrupts" |
|
" COND_SEE_ENEMY" |
|
" COND_NEW_ENEMY" |
|
); |
|
|
|
DEFINE_SCHEDULE |
|
( |
|
SCHED_ASW_BUZZER_ORDER_MOVE, |
|
|
|
" Tasks" |
|
" TASK_ASW_BUZZER_BUILD_PATH_TO_ORDER 0" |
|
" TASK_WALK_PATH 9999" |
|
" TASK_WAIT_FOR_MOVEMENT 0" // 0 is spread if fail to build path |
|
" TASK_WAIT_PVS 0" |
|
"" |
|
" Interrupts" |
|
" COND_NEW_ENEMY" |
|
" COND_SEE_ENEMY" // in deference to scripted schedule where the enemy was slammed, thus no COND_NEW_ENEMY |
|
" COND_LIGHT_DAMAGE" |
|
" COND_HEAVY_DAMAGE" |
|
" COND_SMELL" |
|
" COND_PROVOKED" |
|
" COND_HEAR_COMBAT" |
|
" COND_HEAR_BULLET_IMPACT" |
|
) |
|
|
|
AI_END_CUSTOM_NPC() |
|
|
|
|
|
|