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