1600 lines
38 KiB
C++
1600 lines
38 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Crows. Simple ambient birds that fly away when they hear gunfire or
|
|
// when anything gets too close to them.
|
|
//
|
|
// TODO: landing
|
|
// TODO: death
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "game.h"
|
|
#include "ai_basenpc.h"
|
|
#include "ai_schedule.h"
|
|
#include "ai_hull.h"
|
|
#include "ai_hint.h"
|
|
#include "ai_motor.h"
|
|
#include "ai_navigator.h"
|
|
#include "hl2_shareddefs.h"
|
|
#include "ai_route.h"
|
|
#include "npcevent.h"
|
|
#include "gib.h"
|
|
#include "ai_interactions.h"
|
|
#include "ndebugoverlay.h"
|
|
#include "soundent.h"
|
|
#include "vstdlib/random.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "movevars_shared.h"
|
|
#include "npc_crow.h"
|
|
#include "ai_moveprobe.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//
|
|
// Custom activities.
|
|
//
|
|
static int ACT_CROW_TAKEOFF;
|
|
static int ACT_CROW_SOAR;
|
|
static int ACT_CROW_LAND;
|
|
|
|
//
|
|
// Animation events.
|
|
//
|
|
static int AE_CROW_TAKEOFF;
|
|
static int AE_CROW_FLY;
|
|
static int AE_CROW_HOP;
|
|
|
|
//
|
|
// Skill settings.
|
|
//
|
|
ConVar sk_crow_health( "sk_crow_health","1");
|
|
ConVar sk_crow_melee_dmg( "sk_crow_melee_dmg","0");
|
|
|
|
LINK_ENTITY_TO_CLASS( npc_crow, CNPC_Crow );
|
|
LINK_ENTITY_TO_CLASS( npc_seagull, CNPC_Seagull );
|
|
LINK_ENTITY_TO_CLASS( npc_pigeon, CNPC_Pigeon );
|
|
|
|
BEGIN_DATADESC( CNPC_Crow )
|
|
|
|
DEFINE_FIELD( m_flGroundIdleMoveTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_bOnJeep, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_flEnemyDist, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_nMorale, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_bReachedMoveGoal, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_flHopStartZ, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_vDesiredTarget, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_vCurrentTarget, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_flSoarTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_bSoar, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bPlayedLoopingSound, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_iBirdType, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_vLastStoredOrigin, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_flLastStuckCheck, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flDangerSoundTime, FIELD_TIME ),
|
|
DEFINE_KEYFIELD( m_bIsDeaf, FIELD_BOOLEAN, "deaf" ),
|
|
|
|
// Inputs
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "FlyAway", InputFlyAway ),
|
|
|
|
END_DATADESC()
|
|
|
|
static ConVar birds_debug( "birds_debug", "0" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::Spawn( void )
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
#ifdef _XBOX
|
|
// Always fade the corpse
|
|
AddSpawnFlags( SF_NPC_FADE_CORPSE );
|
|
#endif // _XBOX
|
|
|
|
char *szModel = (char *)STRING( GetModelName() );
|
|
if (!szModel || !*szModel)
|
|
{
|
|
szModel = "models/crow.mdl";
|
|
SetModelName( AllocPooledString(szModel) );
|
|
}
|
|
|
|
Precache();
|
|
SetModel( szModel );
|
|
|
|
m_iHealth = sk_crow_health.GetFloat();
|
|
|
|
SetHullType(HULL_TINY);
|
|
SetHullSizeNormal();
|
|
|
|
SetSolid( SOLID_BBOX );
|
|
SetMoveType( MOVETYPE_STEP );
|
|
|
|
m_flFieldOfView = VIEW_FIELD_FULL;
|
|
SetViewOffset( Vector(6, 0, 11) ); // Position of the eyes relative to NPC's origin.
|
|
|
|
m_flGroundIdleMoveTime = gpGlobals->curtime + random->RandomFloat( 0.0f, 5.0f );
|
|
|
|
SetBloodColor( BLOOD_COLOR_RED );
|
|
m_NPCState = NPC_STATE_NONE;
|
|
|
|
m_nMorale = random->RandomInt( 0, 12 );
|
|
|
|
SetCollisionGroup( HL2COLLISION_GROUP_CROW );
|
|
|
|
CapabilitiesClear();
|
|
|
|
bool bFlying = ( ( m_spawnflags & SF_CROW_FLYING ) != 0 );
|
|
SetFlyingState( bFlying ? FlyState_Flying : FlyState_Walking );
|
|
|
|
// We don't mind zombies so much. They smell good!
|
|
AddClassRelationship( CLASS_ZOMBIE, D_NU, 0 );
|
|
|
|
m_bSoar = false;
|
|
m_bOnJeep = false;
|
|
m_flSoarTime = gpGlobals->curtime;
|
|
|
|
NPCInit();
|
|
|
|
m_iBirdType = BIRDTYPE_CROW;
|
|
|
|
m_vLastStoredOrigin = vec3_origin;
|
|
m_flLastStuckCheck = gpGlobals->curtime;
|
|
|
|
m_flDangerSoundTime = gpGlobals->curtime;
|
|
|
|
SetGoalEnt( NULL );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns this monster's classification in the relationship table.
|
|
//-----------------------------------------------------------------------------
|
|
Class_T CNPC_Crow::Classify( void )
|
|
{
|
|
return( CLASS_EARTH_FAUNA );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pEnemy -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::GatherEnemyConditions( CBaseEntity *pEnemy )
|
|
{
|
|
m_flEnemyDist = (GetLocalOrigin() - pEnemy->GetLocalOrigin()).Length();
|
|
|
|
if ( m_flEnemyDist < 512 )
|
|
{
|
|
SetCondition( COND_CROW_ENEMY_WAY_TOO_CLOSE );
|
|
}
|
|
|
|
if ( m_flEnemyDist < 1024 )
|
|
{
|
|
SetCondition( COND_CROW_ENEMY_TOO_CLOSE );
|
|
}
|
|
|
|
BaseClass::GatherEnemyConditions(pEnemy);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : posSrc -
|
|
// Output : Vector
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Crow::BodyTarget( const Vector &posSrc, bool bNoisy )
|
|
{
|
|
Vector vecResult;
|
|
vecResult = GetAbsOrigin();
|
|
vecResult.z += 6;
|
|
return vecResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::StopLoopingSounds( void )
|
|
{
|
|
//
|
|
// Stop whatever flap sound might be playing.
|
|
//
|
|
if ( m_bPlayedLoopingSound )
|
|
{
|
|
StopSound( "NPC_Crow.Flap" );
|
|
}
|
|
BaseClass::StopLoopingSounds();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Catches the monster-specific messages that occur when tagged
|
|
// animation frames are played.
|
|
// Input : pEvent -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::HandleAnimEvent( animevent_t *pEvent )
|
|
{
|
|
if ( pEvent->event == AE_CROW_TAKEOFF )
|
|
{
|
|
if ( GetNavigator()->GetPath()->GetCurWaypoint() )
|
|
{
|
|
Takeoff( GetNavigator()->GetCurWaypointPos() );
|
|
}
|
|
return;
|
|
}
|
|
|
|
if( pEvent->event == AE_CROW_HOP )
|
|
{
|
|
SetGroundEntity( NULL );
|
|
|
|
//
|
|
// Take him off ground so engine doesn't instantly reset FL_ONGROUND.
|
|
//
|
|
UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0 , 0 , 1 ));
|
|
|
|
//
|
|
// How fast does the crow need to travel to reach the hop goal given gravity?
|
|
//
|
|
float flHopDistance = ( m_vSavePosition - GetLocalOrigin() ).Length();
|
|
float gravity = GetCurrentGravity();
|
|
if ( gravity <= 1 )
|
|
{
|
|
gravity = 1;
|
|
}
|
|
|
|
float height = 0.25 * flHopDistance;
|
|
float speed = sqrt( 2 * gravity * height );
|
|
float time = speed / gravity;
|
|
|
|
//
|
|
// Scale the sideways velocity to get there at the right time
|
|
//
|
|
Vector vecJumpDir = m_vSavePosition - GetLocalOrigin();
|
|
vecJumpDir = vecJumpDir / time;
|
|
|
|
//
|
|
// Speed to offset gravity at the desired height.
|
|
//
|
|
vecJumpDir.z = speed;
|
|
|
|
//
|
|
// Don't jump too far/fast.
|
|
//
|
|
float distance = vecJumpDir.Length();
|
|
if ( distance > 650 )
|
|
{
|
|
vecJumpDir = vecJumpDir * ( 650.0 / distance );
|
|
}
|
|
|
|
m_nMorale -= random->RandomInt( 1, 6 );
|
|
if ( m_nMorale <= 0 )
|
|
{
|
|
m_nMorale = 0;
|
|
}
|
|
|
|
// Play a hop flap sound.
|
|
EmitSound( "NPC_Crow.Hop" );
|
|
|
|
SetAbsVelocity( vecJumpDir );
|
|
return;
|
|
}
|
|
|
|
if( pEvent->event == AE_CROW_FLY )
|
|
{
|
|
//
|
|
// Start flying.
|
|
//
|
|
SetActivity( ACT_FLY );
|
|
|
|
m_bSoar = false;
|
|
m_flSoarTime = gpGlobals->curtime + random->RandomFloat( 3, 5 );
|
|
|
|
return;
|
|
}
|
|
|
|
CAI_BaseNPC::HandleAnimEvent( pEvent );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : eNewActivity -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::OnChangeActivity( Activity eNewActivity )
|
|
{
|
|
// if ( eNewActivity == ACT_FLY )
|
|
// {
|
|
// m_flGroundSpeed = CROW_AIRSPEED;
|
|
// }
|
|
//
|
|
bool fRandomize = false;
|
|
if ( eNewActivity == ACT_FLY )
|
|
{
|
|
fRandomize = true;
|
|
}
|
|
|
|
BaseClass::OnChangeActivity( eNewActivity );
|
|
if ( fRandomize )
|
|
{
|
|
SetCycle( random->RandomFloat( 0.0, 0.75 ) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Input handler that makes the crow fly away.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::InputFlyAway( inputdata_t &inputdata )
|
|
{
|
|
string_t sTarget = MAKE_STRING( inputdata.value.String() );
|
|
|
|
if ( sTarget != NULL_STRING )// this npc has a target
|
|
{
|
|
CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, sTarget );
|
|
|
|
if ( pEnt )
|
|
{
|
|
trace_t tr;
|
|
AI_TraceLine ( EyePosition(), pEnt->GetAbsOrigin(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction != 1.0f )
|
|
return;
|
|
|
|
// Find the npc's initial target entity, stash it
|
|
SetGoalEnt( pEnt );
|
|
}
|
|
}
|
|
else
|
|
SetGoalEnt( NULL );
|
|
|
|
SetCondition( COND_CROW_FORCED_FLY );
|
|
SetCondition( COND_PROVOKED );
|
|
|
|
}
|
|
|
|
void CNPC_Crow::UpdateEfficiency( bool bInPVS )
|
|
{
|
|
if ( IsFlying() )
|
|
{
|
|
SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL );
|
|
SetMoveEfficiency( AIME_NORMAL );
|
|
return;
|
|
}
|
|
|
|
BaseClass::UpdateEfficiency( bInPVS );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Implements "deafness"
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Crow::QueryHearSound( CSound *pSound )
|
|
{
|
|
if( IsDeaf() )
|
|
return false;
|
|
|
|
return BaseClass::QueryHearSound( pSound );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles all flight movement because we don't ever build paths when
|
|
// when we are flying.
|
|
// Input : flInterval - Seconds to simulate.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Crow::OverrideMove( float flInterval )
|
|
{
|
|
if ( GetNavigator()->GetPath()->CurWaypointNavType() == NAV_FLY && GetNavigator()->GetNavType() != NAV_FLY )
|
|
{
|
|
SetNavType( NAV_FLY );
|
|
}
|
|
|
|
if ( IsFlying() )
|
|
{
|
|
if ( GetNavigator()->GetPath()->GetCurWaypoint() )
|
|
{
|
|
if ( m_flLastStuckCheck <= gpGlobals->curtime )
|
|
{
|
|
if ( m_vLastStoredOrigin == GetAbsOrigin() )
|
|
{
|
|
if ( GetAbsVelocity() == vec3_origin )
|
|
{
|
|
float flDamage = m_iHealth;
|
|
|
|
CTakeDamageInfo dmgInfo( this, this, flDamage, DMG_GENERIC );
|
|
GuessDamageForce( &dmgInfo, vec3_origin - Vector( 0, 0, 0.1 ), GetAbsOrigin() );
|
|
TakeDamage( dmgInfo );
|
|
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
m_vLastStoredOrigin = GetAbsOrigin();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_vLastStoredOrigin = GetAbsOrigin();
|
|
}
|
|
|
|
m_flLastStuckCheck = gpGlobals->curtime + 1.0f;
|
|
}
|
|
|
|
if (m_bReachedMoveGoal )
|
|
{
|
|
SetIdealActivity( (Activity)ACT_CROW_LAND );
|
|
SetFlyingState( FlyState_Landing );
|
|
TaskMovementComplete();
|
|
}
|
|
else
|
|
{
|
|
SetIdealActivity ( ACT_FLY );
|
|
MoveCrowFly( flInterval );
|
|
}
|
|
|
|
}
|
|
else if ( !GetTask() || GetTask()->iTask == TASK_WAIT_FOR_MOVEMENT )
|
|
{
|
|
SetSchedule( SCHED_CROW_IDLE_FLY );
|
|
SetFlyingState( FlyState_Flying );
|
|
SetIdealActivity ( ACT_FLY );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Activity CNPC_Crow::NPC_TranslateActivity( Activity eNewActivity )
|
|
{
|
|
if ( IsFlying() && eNewActivity == ACT_IDLE )
|
|
{
|
|
return ACT_FLY;
|
|
}
|
|
|
|
if ( eNewActivity == ACT_FLY )
|
|
{
|
|
if ( m_flSoarTime < gpGlobals->curtime )
|
|
{
|
|
//Adrian: This should be revisited.
|
|
if ( random->RandomInt( 0, 100 ) <= 50 && m_bSoar == false && GetAbsVelocity().z < 0 )
|
|
{
|
|
m_bSoar = true;
|
|
m_flSoarTime = gpGlobals->curtime + random->RandomFloat( 1, 4 );
|
|
}
|
|
else
|
|
{
|
|
m_bSoar = false;
|
|
m_flSoarTime = gpGlobals->curtime + random->RandomFloat( 3, 5 );
|
|
}
|
|
}
|
|
|
|
if ( m_bSoar == true )
|
|
{
|
|
return (Activity)ACT_CROW_SOAR;
|
|
}
|
|
else
|
|
return ACT_FLY;
|
|
}
|
|
|
|
return BaseClass::NPC_TranslateActivity( eNewActivity );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles all flight movement.
|
|
// Input : flInterval - Seconds to simulate.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::MoveCrowFly( float flInterval )
|
|
{
|
|
//
|
|
// Bound interval so we don't get ludicrous motion when debugging
|
|
// or when framerate drops catastrophically.
|
|
//
|
|
if (flInterval > 1.0)
|
|
{
|
|
flInterval = 1.0;
|
|
}
|
|
|
|
m_flDangerSoundTime = gpGlobals->curtime + 5.0f;
|
|
|
|
//
|
|
// Determine the goal of our movement.
|
|
//
|
|
Vector vecMoveGoal = GetAbsOrigin();
|
|
|
|
if ( GetNavigator()->IsGoalActive() )
|
|
{
|
|
vecMoveGoal = GetNavigator()->GetCurWaypointPos();
|
|
|
|
if ( GetNavigator()->CurWaypointIsGoal() == false )
|
|
{
|
|
AI_ProgressFlyPathParams_t params( MASK_NPCSOLID );
|
|
params.bTrySimplify = false;
|
|
|
|
GetNavigator()->ProgressFlyPath( params ); // ignore result, crow handles completion directly
|
|
|
|
// Fly towards the hint.
|
|
if ( GetNavigator()->GetPath()->GetCurWaypoint() )
|
|
{
|
|
vecMoveGoal = GetNavigator()->GetCurWaypointPos();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No movement goal.
|
|
vecMoveGoal = GetAbsOrigin();
|
|
SetAbsVelocity( vec3_origin );
|
|
return;
|
|
}
|
|
|
|
Vector vecMoveDir = ( vecMoveGoal - GetAbsOrigin() );
|
|
Vector vForward;
|
|
AngleVectors( GetAbsAngles(), &vForward );
|
|
|
|
//
|
|
// Fly towards the movement goal.
|
|
//
|
|
float flDistance = ( vecMoveGoal - GetAbsOrigin() ).Length();
|
|
|
|
if ( vecMoveGoal != m_vDesiredTarget )
|
|
{
|
|
m_vDesiredTarget = vecMoveGoal;
|
|
}
|
|
else
|
|
{
|
|
m_vCurrentTarget = ( m_vDesiredTarget - GetAbsOrigin() );
|
|
VectorNormalize( m_vCurrentTarget );
|
|
}
|
|
|
|
float flLerpMod = 0.25f;
|
|
|
|
if ( flDistance <= 256.0f )
|
|
{
|
|
flLerpMod = 1.0f - ( flDistance / 256.0f );
|
|
}
|
|
|
|
|
|
VectorLerp( vForward, m_vCurrentTarget, flLerpMod, vForward );
|
|
|
|
|
|
if ( flDistance < CROW_AIRSPEED * flInterval )
|
|
{
|
|
if ( GetNavigator()->IsGoalActive() )
|
|
{
|
|
if ( GetNavigator()->CurWaypointIsGoal() )
|
|
{
|
|
m_bReachedMoveGoal = true;
|
|
}
|
|
else
|
|
{
|
|
GetNavigator()->AdvancePath();
|
|
}
|
|
}
|
|
else
|
|
m_bReachedMoveGoal = true;
|
|
}
|
|
|
|
if ( GetHintNode() )
|
|
{
|
|
AIMoveTrace_t moveTrace;
|
|
GetMoveProbe()->MoveLimit( NAV_FLY, GetAbsOrigin(), GetNavigator()->GetCurWaypointPos(), MASK_NPCSOLID, GetNavTargetEntity(), &moveTrace );
|
|
|
|
//See if it succeeded
|
|
if ( IsMoveBlocked( moveTrace.fStatus ) )
|
|
{
|
|
Vector vNodePos = vecMoveGoal;
|
|
GetHintNode()->GetPosition(this, &vNodePos);
|
|
|
|
GetNavigator()->SetGoal( vNodePos );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Look to see if we are going to hit anything.
|
|
//
|
|
VectorNormalize( vForward );
|
|
Vector vecDeflect;
|
|
if ( Probe( vForward, CROW_AIRSPEED * flInterval, vecDeflect ) )
|
|
{
|
|
vForward = vecDeflect;
|
|
VectorNormalize( vForward );
|
|
}
|
|
|
|
SetAbsVelocity( vForward * CROW_AIRSPEED );
|
|
|
|
if ( GetAbsVelocity().Length() > 0 && GetNavigator()->CurWaypointIsGoal() && flDistance < CROW_AIRSPEED )
|
|
{
|
|
SetIdealActivity( (Activity)ACT_CROW_LAND );
|
|
}
|
|
|
|
|
|
//Bank and set angles.
|
|
Vector vRight;
|
|
QAngle vRollAngle;
|
|
|
|
VectorAngles( vForward, vRollAngle );
|
|
vRollAngle.z = 0;
|
|
|
|
AngleVectors( vRollAngle, NULL, &vRight, NULL );
|
|
|
|
float flRoll = DotProduct( vRight, vecMoveDir ) * 45;
|
|
flRoll = clamp( flRoll, -45, 45 );
|
|
|
|
vRollAngle[ROLL] = flRoll;
|
|
SetAbsAngles( vRollAngle );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Looks ahead to see if we are going to hit something. If we are, a
|
|
// recommended avoidance path is returned.
|
|
// Input : vecMoveDir -
|
|
// flSpeed -
|
|
// vecDeflect -
|
|
// Output : Returns true if we hit something and need to deflect our course,
|
|
// false if all is well.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Crow::Probe( const Vector &vecMoveDir, float flSpeed, Vector &vecDeflect )
|
|
{
|
|
//
|
|
// Look 1/2 second ahead.
|
|
//
|
|
trace_t tr;
|
|
AI_TraceHull( GetAbsOrigin(), GetAbsOrigin() + vecMoveDir * flSpeed, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, HL2COLLISION_GROUP_CROW, &tr );
|
|
if ( tr.fraction < 1.0f )
|
|
{
|
|
//
|
|
// If we hit something, deflect flight path parallel to surface hit.
|
|
//
|
|
Vector vecUp;
|
|
CrossProduct( vecMoveDir, tr.plane.normal, vecUp );
|
|
CrossProduct( tr.plane.normal, vecUp, vecDeflect );
|
|
VectorNormalize( vecDeflect );
|
|
return true;
|
|
}
|
|
|
|
vecDeflect = vec3_origin;
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Switches between flying mode and ground mode.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::SetFlyingState( FlyState_t eState )
|
|
{
|
|
if ( eState == FlyState_Flying )
|
|
{
|
|
// Flying
|
|
SetGroundEntity( NULL );
|
|
AddFlag( FL_FLY );
|
|
SetNavType( NAV_FLY );
|
|
CapabilitiesRemove( bits_CAP_MOVE_GROUND );
|
|
CapabilitiesAdd( bits_CAP_MOVE_FLY );
|
|
SetMoveType( MOVETYPE_STEP );
|
|
m_vLastStoredOrigin = GetAbsOrigin();
|
|
m_flLastStuckCheck = gpGlobals->curtime + 3.0f;
|
|
m_flGroundIdleMoveTime = gpGlobals->curtime + random->RandomFloat( 5.0f, 10.0f );
|
|
}
|
|
else if ( eState == FlyState_Walking )
|
|
{
|
|
// Walking
|
|
QAngle angles = GetAbsAngles();
|
|
angles[PITCH] = 0.0f;
|
|
angles[ROLL] = 0.0f;
|
|
SetAbsAngles( angles );
|
|
|
|
RemoveFlag( FL_FLY );
|
|
SetNavType( NAV_GROUND );
|
|
CapabilitiesRemove( bits_CAP_MOVE_FLY );
|
|
CapabilitiesAdd( bits_CAP_MOVE_GROUND );
|
|
SetMoveType( MOVETYPE_STEP );
|
|
m_vLastStoredOrigin = vec3_origin;
|
|
m_flGroundIdleMoveTime = gpGlobals->curtime + random->RandomFloat( 5.0f, 10.0f );
|
|
}
|
|
else
|
|
{
|
|
// Falling
|
|
RemoveFlag( FL_FLY );
|
|
SetNavType( NAV_GROUND );
|
|
CapabilitiesRemove( bits_CAP_MOVE_FLY );
|
|
CapabilitiesAdd( bits_CAP_MOVE_GROUND );
|
|
SetMoveType( MOVETYPE_STEP );
|
|
m_flGroundIdleMoveTime = gpGlobals->curtime + random->RandomFloat( 5.0f, 10.0f );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Performs a takeoff. Called via an animation event at the moment
|
|
// our feet leave the ground.
|
|
// Input : pGoalEnt - The entity that we are going to fly toward.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::Takeoff( const Vector &vGoal )
|
|
{
|
|
if ( vGoal != vec3_origin )
|
|
{
|
|
//
|
|
// Lift us off ground so engine doesn't instantly reset FL_ONGROUND.
|
|
//
|
|
UTIL_SetOrigin( this, GetAbsOrigin() + Vector( 0 , 0 , 1 ));
|
|
|
|
//
|
|
// Fly straight at the goal entity at our maximum airspeed.
|
|
//
|
|
Vector vecMoveDir = vGoal - GetAbsOrigin();
|
|
VectorNormalize( vecMoveDir );
|
|
|
|
// FIXME: pitch over time
|
|
|
|
SetFlyingState( FlyState_Flying );
|
|
|
|
QAngle angles;
|
|
VectorAngles( vecMoveDir, angles );
|
|
SetAbsAngles( angles );
|
|
|
|
SetAbsVelocity( vecMoveDir * CROW_TAKEOFF_SPEED );
|
|
}
|
|
}
|
|
|
|
void CNPC_Crow::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
|
|
{
|
|
CTakeDamageInfo newInfo = info;
|
|
|
|
if ( info.GetDamageType() & DMG_PHYSGUN )
|
|
{
|
|
Vector puntDir = ( info.GetDamageForce() * 5000.0f );
|
|
|
|
newInfo.SetDamage( m_iMaxHealth );
|
|
|
|
PainSound( newInfo );
|
|
newInfo.SetDamageForce( puntDir );
|
|
}
|
|
|
|
BaseClass::TraceAttack( newInfo, vecDir, ptr, pAccumulator );
|
|
}
|
|
|
|
|
|
void CNPC_Crow::StartTargetHandling( CBaseEntity *pTargetEnt )
|
|
{
|
|
AI_NavGoal_t goal( GOALTYPE_PATHCORNER, pTargetEnt->GetAbsOrigin(),
|
|
ACT_FLY,
|
|
AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST);
|
|
|
|
if ( !GetNavigator()->SetGoal( goal ) )
|
|
{
|
|
DevWarning( 2, "Can't Create Route!\n" );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pTask -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::StartTask( const Task_t *pTask )
|
|
{
|
|
switch ( pTask->iTask )
|
|
{
|
|
//
|
|
// This task enables us to build a path that requires flight.
|
|
//
|
|
// case TASK_CROW_PREPARE_TO_FLY:
|
|
// {
|
|
// SetFlyingState( FlyState_Flying );
|
|
// TaskComplete();
|
|
// break;
|
|
// }
|
|
|
|
case TASK_CROW_TAKEOFF:
|
|
{
|
|
if ( random->RandomInt( 1, 4 ) == 1 )
|
|
{
|
|
AlertSound();
|
|
}
|
|
|
|
FlapSound();
|
|
|
|
SetIdealActivity( ( Activity )ACT_CROW_TAKEOFF );
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_PICK_EVADE_GOAL:
|
|
{
|
|
if ( GetEnemy() != NULL )
|
|
{
|
|
//
|
|
// Get our enemy's position in x/y.
|
|
//
|
|
Vector vecEnemyOrigin = GetEnemy()->GetAbsOrigin();
|
|
vecEnemyOrigin.z = GetAbsOrigin().z;
|
|
|
|
//
|
|
// Pick a hop goal a random distance along a vector away from our enemy.
|
|
//
|
|
m_vSavePosition = GetAbsOrigin() - vecEnemyOrigin;
|
|
VectorNormalize( m_vSavePosition );
|
|
m_vSavePosition = GetAbsOrigin() + m_vSavePosition * ( 32 + random->RandomInt( 0, 32 ) );
|
|
|
|
GetMotor()->SetIdealYawToTarget( m_vSavePosition );
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
TaskFail( "No enemy" );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_FALL_TO_GROUND:
|
|
{
|
|
SetFlyingState( FlyState_Falling );
|
|
break;
|
|
}
|
|
|
|
case TASK_FIND_HINTNODE:
|
|
{
|
|
if ( GetGoalEnt() )
|
|
{
|
|
TaskComplete();
|
|
return;
|
|
}
|
|
// Overloaded because we search over a greater distance.
|
|
if ( !GetHintNode() )
|
|
{
|
|
SetHintNode(CAI_HintManager::FindHint( this, HINT_CROW_FLYTO_POINT, bits_HINT_NODE_NEAREST | bits_HINT_NODE_USE_GROUP, 10000 ));
|
|
}
|
|
|
|
if ( GetHintNode() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
TaskFail( FAIL_NO_HINT_NODE );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_GET_PATH_TO_HINTNODE:
|
|
{
|
|
//How did this happen?!
|
|
if ( GetGoalEnt() == this )
|
|
{
|
|
SetGoalEnt( NULL );
|
|
}
|
|
|
|
if ( GetGoalEnt() )
|
|
{
|
|
SetFlyingState( FlyState_Flying );
|
|
StartTargetHandling( GetGoalEnt() );
|
|
|
|
m_bReachedMoveGoal = false;
|
|
TaskComplete();
|
|
SetHintNode( NULL );
|
|
return;
|
|
}
|
|
|
|
if ( GetHintNode() )
|
|
{
|
|
Vector vHintPos;
|
|
GetHintNode()->GetPosition(this, &vHintPos);
|
|
|
|
SetNavType( NAV_FLY );
|
|
CapabilitiesAdd( bits_CAP_MOVE_FLY );
|
|
// @HACKHACK: Force allow triangulation. Too many HL2 maps were relying on this feature WRT fly nodes (toml 8/1/2007)
|
|
NPC_STATE state = GetState();
|
|
m_NPCState = NPC_STATE_SCRIPT;
|
|
bool bFoundPath = GetNavigator()->SetGoal( vHintPos );
|
|
m_NPCState = state;
|
|
if ( !bFoundPath )
|
|
{
|
|
GetHintNode()->DisableForSeconds( .3 );
|
|
SetHintNode(NULL);
|
|
}
|
|
CapabilitiesRemove( bits_CAP_MOVE_FLY );
|
|
}
|
|
|
|
if ( GetHintNode() )
|
|
{
|
|
m_bReachedMoveGoal = false;
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
TaskFail( FAIL_NO_ROUTE );
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// We have failed to fly normally. Pick a random "up" direction and fly that way.
|
|
//
|
|
case TASK_CROW_FLY:
|
|
{
|
|
float flYaw = UTIL_AngleMod( random->RandomInt( -180, 180 ) );
|
|
|
|
Vector vecNewVelocity( cos( DEG2RAD( flYaw ) ), sin( DEG2RAD( flYaw ) ), random->RandomFloat( 0.1f, 0.5f ) );
|
|
vecNewVelocity *= CROW_AIRSPEED;
|
|
SetAbsVelocity( vecNewVelocity );
|
|
|
|
SetIdealActivity( ACT_FLY );
|
|
|
|
m_bSoar = false;
|
|
m_flSoarTime = gpGlobals->curtime + random->RandomFloat( 2, 5 );
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_PICK_RANDOM_GOAL:
|
|
{
|
|
m_vSavePosition = GetLocalOrigin() + Vector( random->RandomFloat( -48.0f, 48.0f ), random->RandomFloat( -48.0f, 48.0f ), 0 );
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_HOP:
|
|
{
|
|
SetIdealActivity( ACT_HOP );
|
|
m_flHopStartZ = GetLocalOrigin().z;
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_WAIT_FOR_BARNACLE_KILL:
|
|
{
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
BaseClass::StartTask( pTask );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pTask -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::RunTask( const Task_t *pTask )
|
|
{
|
|
switch ( pTask->iTask )
|
|
{
|
|
case TASK_CROW_TAKEOFF:
|
|
{
|
|
if ( GetNavigator()->IsGoalActive() )
|
|
{
|
|
GetMotor()->SetIdealYawToTargetAndUpdate( GetAbsOrigin() + GetNavigator()->GetCurWaypointPos(), AI_KEEP_YAW_SPEED );
|
|
}
|
|
else
|
|
TaskFail( FAIL_NO_ROUTE );
|
|
|
|
if ( IsActivityFinished() )
|
|
{
|
|
TaskComplete();
|
|
SetIdealActivity( ACT_FLY );
|
|
|
|
m_bSoar = false;
|
|
m_flSoarTime = gpGlobals->curtime + random->RandomFloat( 2, 5 );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_HOP:
|
|
{
|
|
if ( IsActivityFinished() )
|
|
{
|
|
TaskComplete();
|
|
SetIdealActivity( ACT_IDLE );
|
|
}
|
|
|
|
if ( ( GetAbsOrigin().z < m_flHopStartZ ) && ( !( GetFlags() & FL_ONGROUND ) ) )
|
|
{
|
|
//
|
|
// We've hopped off of something! See if we're going to fall very far.
|
|
//
|
|
trace_t tr;
|
|
AI_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, -32 ), MASK_SOLID, this, HL2COLLISION_GROUP_CROW, &tr );
|
|
if ( tr.fraction == 1.0f )
|
|
{
|
|
//
|
|
// We're falling! Better fly away. SelectSchedule will check ONGROUND and do the right thing.
|
|
//
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We'll be okay. Don't check again unless what we're hopping onto moves
|
|
// out from under us.
|
|
//
|
|
m_flHopStartZ = GetAbsOrigin().z - ( 32 * tr.fraction );
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Face the direction we are flying.
|
|
//
|
|
case TASK_CROW_FLY:
|
|
{
|
|
GetMotor()->SetIdealYawToTargetAndUpdate( GetAbsOrigin() + GetAbsVelocity(), AI_KEEP_YAW_SPEED );
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_FALL_TO_GROUND:
|
|
{
|
|
if ( GetFlags() & FL_ONGROUND )
|
|
{
|
|
SetFlyingState( FlyState_Walking );
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_CROW_WAIT_FOR_BARNACLE_KILL:
|
|
{
|
|
if ( m_flNextFlinchTime < gpGlobals->curtime )
|
|
{
|
|
m_flNextFlinchTime = gpGlobals->curtime + random->RandomFloat( 0.5f, 2.0f );
|
|
// dvs: TODO: squirm
|
|
// dvs: TODO: spawn feathers
|
|
EmitSound( "NPC_Crow.Squawk" );
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
CAI_BaseNPC::RunTask( pTask );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose: Override to do crow specific gibs.
|
|
// Output : Returns true to gib, false to not gib.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Crow::CorpseGib( const CTakeDamageInfo &info )
|
|
{
|
|
EmitSound( "NPC_Crow.Gib" );
|
|
|
|
// TODO: crow gibs?
|
|
//CGib::SpawnSpecificGibs( this, CROW_GIB_COUNT, 300, 400, "models/gibs/crow_gibs.mdl");
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Don't allow ridiculous forces to be applied to the crow. It only weighs
|
|
// 1.5kg, so extreme forces will give it ridiculous velocity.
|
|
//-----------------------------------------------------------------------------
|
|
#define CROW_RAGDOLL_SPEED_LIMIT 1000.0f // Crow ragdoll speed limit in inches per second.
|
|
bool CNPC_Crow::BecomeRagdollOnClient( const Vector &force )
|
|
{
|
|
Vector newForce = force;
|
|
|
|
if( VPhysicsGetObject() )
|
|
{
|
|
float flMass = VPhysicsGetObject()->GetMass();
|
|
float speed = VectorNormalize( newForce );
|
|
speed = MIN( speed, (CROW_RAGDOLL_SPEED_LIMIT * flMass) );
|
|
newForce *= speed;
|
|
}
|
|
|
|
return BaseClass::BecomeRagdollOnClient( newForce );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Crow::FValidateHintType( CAI_Hint *pHint )
|
|
{
|
|
return( pHint->HintType() == HINT_CROW_FLYTO_POINT );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the activity for the given hint type.
|
|
// Input : sHintType -
|
|
//-----------------------------------------------------------------------------
|
|
Activity CNPC_Crow::GetHintActivity( short sHintType, Activity HintsActivity )
|
|
{
|
|
if ( sHintType == HINT_CROW_FLYTO_POINT )
|
|
{
|
|
return ACT_FLY;
|
|
}
|
|
|
|
return BaseClass::GetHintActivity( sHintType, HintsActivity );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pevInflictor -
|
|
// pevAttacker -
|
|
// flDamage -
|
|
// bitsDamageType -
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Crow::OnTakeDamage_Alive( const CTakeDamageInfo &info )
|
|
{
|
|
// TODO: spew a feather or two
|
|
return BaseClass::OnTakeDamage_Alive( info );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the best new schedule for this NPC based on current conditions.
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Crow::SelectSchedule( void )
|
|
{
|
|
if ( HasCondition( COND_CROW_BARNACLED ) )
|
|
{
|
|
// Caught by a barnacle!
|
|
return SCHED_CROW_BARNACLED;
|
|
}
|
|
|
|
//
|
|
// If we're flying, just find somewhere to fly to.
|
|
//
|
|
if ( IsFlying() )
|
|
{
|
|
return SCHED_CROW_IDLE_FLY;
|
|
}
|
|
|
|
//
|
|
// If we were told to fly away via our FlyAway input, do so ASAP.
|
|
//
|
|
if ( HasCondition( COND_CROW_FORCED_FLY ) )
|
|
{
|
|
ClearCondition( COND_CROW_FORCED_FLY );
|
|
return SCHED_CROW_FLY_AWAY;
|
|
}
|
|
|
|
//
|
|
// If we're not flying but we're not on the ground, start flying.
|
|
// Maybe we hopped off of something? Don't do this immediately upon
|
|
// because we may be falling to the ground on spawn.
|
|
//
|
|
if ( !( GetFlags() & FL_ONGROUND ) && ( gpGlobals->curtime > 2.0 ) && m_bOnJeep == false )
|
|
{
|
|
return SCHED_CROW_FLY_AWAY;
|
|
}
|
|
|
|
//
|
|
// If we heard a gunshot or have taken damage, fly away.
|
|
//
|
|
if ( HasCondition( COND_LIGHT_DAMAGE ) || HasCondition( COND_HEAVY_DAMAGE ) )
|
|
{
|
|
return SCHED_CROW_FLY_AWAY;
|
|
}
|
|
|
|
if ( m_flDangerSoundTime <= gpGlobals->curtime )
|
|
{
|
|
if ( HasCondition( COND_HEAR_DANGER ) || HasCondition( COND_HEAR_COMBAT ) )
|
|
{
|
|
m_flDangerSoundTime = gpGlobals->curtime + 10.0f;
|
|
return SCHED_CROW_FLY_AWAY;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If someone we hate is getting WAY too close for comfort, fly away.
|
|
//
|
|
if ( HasCondition( COND_CROW_ENEMY_WAY_TOO_CLOSE ) )
|
|
{
|
|
ClearCondition( COND_CROW_ENEMY_WAY_TOO_CLOSE );
|
|
|
|
m_nMorale = 0;
|
|
return SCHED_CROW_FLY_AWAY;
|
|
}
|
|
|
|
//
|
|
// If someone we hate is getting a little too close for comfort, avoid them.
|
|
//
|
|
if ( HasCondition( COND_CROW_ENEMY_TOO_CLOSE ) && m_flDangerSoundTime <= gpGlobals->curtime )
|
|
{
|
|
ClearCondition( COND_CROW_ENEMY_TOO_CLOSE );
|
|
|
|
if ( m_bOnJeep == true )
|
|
{
|
|
m_nMorale = 0;
|
|
return SCHED_CROW_FLY_AWAY;
|
|
}
|
|
|
|
if ( m_flEnemyDist > 400 )
|
|
{
|
|
return SCHED_CROW_WALK_AWAY;
|
|
}
|
|
else if ( m_flEnemyDist > 300 )
|
|
{
|
|
m_nMorale -= 1;
|
|
return SCHED_CROW_RUN_AWAY;
|
|
}
|
|
}
|
|
|
|
switch ( m_NPCState )
|
|
{
|
|
case NPC_STATE_IDLE:
|
|
case NPC_STATE_ALERT:
|
|
case NPC_STATE_COMBAT:
|
|
{
|
|
if ( !IsFlying() )
|
|
{
|
|
if ( m_bOnJeep == true )
|
|
return SCHED_IDLE_STAND;
|
|
|
|
//
|
|
// If we are hanging out on the ground, see if it is time to pick a new place to walk to.
|
|
//
|
|
if ( gpGlobals->curtime > m_flGroundIdleMoveTime )
|
|
{
|
|
m_flGroundIdleMoveTime = gpGlobals->curtime + random->RandomFloat( 10.0f, 20.0f );
|
|
return SCHED_CROW_IDLE_WALK;
|
|
}
|
|
|
|
return SCHED_IDLE_STAND;
|
|
}
|
|
|
|
// TODO: need idle flying behaviors!
|
|
}
|
|
}
|
|
|
|
return BaseClass::SelectSchedule();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::Precache( void )
|
|
{
|
|
BaseClass::Precache();
|
|
|
|
PrecacheModel( "models/crow.mdl" );
|
|
PrecacheModel( "models/pigeon.mdl" );
|
|
PrecacheModel( "models/seagull.mdl" );
|
|
|
|
//Crow
|
|
PrecacheScriptSound( "NPC_Crow.Hop" );
|
|
PrecacheScriptSound( "NPC_Crow.Squawk" );
|
|
PrecacheScriptSound( "NPC_Crow.Gib" );
|
|
PrecacheScriptSound( "NPC_Crow.Idle" );
|
|
PrecacheScriptSound( "NPC_Crow.Alert" );
|
|
PrecacheScriptSound( "NPC_Crow.Die" );
|
|
PrecacheScriptSound( "NPC_Crow.Pain" );
|
|
PrecacheScriptSound( "NPC_Crow.Flap" );
|
|
|
|
//Seagull
|
|
PrecacheScriptSound( "NPC_Seagull.Pain" );
|
|
PrecacheScriptSound( "NPC_Seagull.Idle" );
|
|
|
|
//Pigeon
|
|
PrecacheScriptSound( "NPC_Pigeon.Idle");
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sounds.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Crow::IdleSound( void )
|
|
{
|
|
if ( m_iBirdType != BIRDTYPE_CROW )
|
|
return;
|
|
|
|
EmitSound( "NPC_Crow.Idle" );
|
|
}
|
|
|
|
|
|
void CNPC_Crow::AlertSound( void )
|
|
{
|
|
if ( m_iBirdType != BIRDTYPE_CROW )
|
|
return;
|
|
|
|
EmitSound( "NPC_Crow.Alert" );
|
|
}
|
|
|
|
|
|
void CNPC_Crow::PainSound( const CTakeDamageInfo &info )
|
|
{
|
|
if ( m_iBirdType != BIRDTYPE_CROW )
|
|
return;
|
|
|
|
EmitSound( "NPC_Crow.Pain" );
|
|
}
|
|
|
|
|
|
void CNPC_Crow::DeathSound( const CTakeDamageInfo &info )
|
|
{
|
|
if ( m_iBirdType != BIRDTYPE_CROW )
|
|
return;
|
|
|
|
EmitSound( "NPC_Crow.Die" );
|
|
}
|
|
|
|
void CNPC_Crow::FlapSound( void )
|
|
{
|
|
EmitSound( "NPC_Crow.Flap" );
|
|
m_bPlayedLoopingSound = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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_Crow::HandleInteraction( int interactionType, void *data, CBaseCombatCharacter *sourceEnt )
|
|
{
|
|
if ( interactionType == g_interactionBarnacleVictimDangle )
|
|
{
|
|
// Die instantly
|
|
return false;
|
|
}
|
|
else if ( interactionType == g_interactionBarnacleVictimGrab )
|
|
{
|
|
if ( GetFlags() & FL_ONGROUND )
|
|
{
|
|
SetGroundEntity( NULL );
|
|
}
|
|
|
|
// return ideal grab position
|
|
if (data)
|
|
{
|
|
// FIXME: need a good way to ensure this contract
|
|
*((Vector *)data) = GetAbsOrigin() + Vector( 0, 0, 5 );
|
|
}
|
|
|
|
StopLoopingSounds();
|
|
|
|
SetThink( NULL );
|
|
return true;
|
|
}
|
|
|
|
return BaseClass::HandleInteraction( interactionType, data, sourceEnt );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Crow::DrawDebugTextOverlays( void )
|
|
{
|
|
int nOffset = BaseClass::DrawDebugTextOverlays();
|
|
|
|
if (m_debugOverlays & OVERLAY_TEXT_BIT)
|
|
{
|
|
char tempstr[512];
|
|
Q_snprintf( tempstr, sizeof( tempstr ), "morale: %d", m_nMorale );
|
|
EntityText( nOffset, tempstr, 0 );
|
|
nOffset++;
|
|
|
|
if ( GetEnemy() != NULL )
|
|
{
|
|
Q_snprintf( tempstr, sizeof( tempstr ), "enemy (dist): %s (%g)", GetEnemy()->GetClassname(), ( double )m_flEnemyDist );
|
|
EntityText( nOffset, tempstr, 0 );
|
|
nOffset++;
|
|
}
|
|
}
|
|
|
|
return nOffset;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines which sounds the crow cares about.
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Crow::GetSoundInterests( void )
|
|
{
|
|
return SOUND_WORLD | SOUND_COMBAT | SOUND_PLAYER | SOUND_DANGER;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Schedules
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
AI_BEGIN_CUSTOM_NPC( npc_crow, CNPC_Crow )
|
|
|
|
DECLARE_TASK( TASK_CROW_FIND_FLYTO_NODE )
|
|
//DECLARE_TASK( TASK_CROW_PREPARE_TO_FLY )
|
|
DECLARE_TASK( TASK_CROW_TAKEOFF )
|
|
DECLARE_TASK( TASK_CROW_FLY )
|
|
DECLARE_TASK( TASK_CROW_PICK_RANDOM_GOAL )
|
|
DECLARE_TASK( TASK_CROW_HOP )
|
|
DECLARE_TASK( TASK_CROW_PICK_EVADE_GOAL )
|
|
DECLARE_TASK( TASK_CROW_WAIT_FOR_BARNACLE_KILL )
|
|
|
|
// experiment
|
|
DECLARE_TASK( TASK_CROW_FALL_TO_GROUND )
|
|
DECLARE_TASK( TASK_CROW_PREPARE_TO_FLY_RANDOM )
|
|
|
|
DECLARE_ACTIVITY( ACT_CROW_TAKEOFF )
|
|
DECLARE_ACTIVITY( ACT_CROW_SOAR )
|
|
DECLARE_ACTIVITY( ACT_CROW_LAND )
|
|
|
|
DECLARE_ANIMEVENT( AE_CROW_HOP )
|
|
DECLARE_ANIMEVENT( AE_CROW_FLY )
|
|
DECLARE_ANIMEVENT( AE_CROW_TAKEOFF )
|
|
|
|
|
|
DECLARE_CONDITION( COND_CROW_ENEMY_TOO_CLOSE )
|
|
DECLARE_CONDITION( COND_CROW_ENEMY_WAY_TOO_CLOSE )
|
|
DECLARE_CONDITION( COND_CROW_FORCED_FLY )
|
|
DECLARE_CONDITION( COND_CROW_BARNACLED )
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_IDLE_WALK,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_IDLE_STAND"
|
|
" TASK_CROW_PICK_RANDOM_GOAL 0"
|
|
" TASK_GET_PATH_TO_SAVEPOSITION 0"
|
|
" TASK_WALK_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_WAIT_PVS 0"
|
|
" "
|
|
" Interrupts"
|
|
" COND_CROW_FORCED_FLY"
|
|
" COND_PROVOKED"
|
|
" COND_CROW_ENEMY_TOO_CLOSE"
|
|
" COND_NEW_ENEMY"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_WALK_AWAY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CROW_FLY_AWAY"
|
|
" TASK_CROW_PICK_EVADE_GOAL 0"
|
|
" TASK_GET_PATH_TO_SAVEPOSITION 0"
|
|
" TASK_WALK_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" "
|
|
" Interrupts"
|
|
" COND_CROW_FORCED_FLY"
|
|
" COND_CROW_ENEMY_WAY_TOO_CLOSE"
|
|
" COND_NEW_ENEMY"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_RUN_AWAY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CROW_FLY_AWAY"
|
|
" TASK_CROW_PICK_EVADE_GOAL 0"
|
|
" TASK_GET_PATH_TO_SAVEPOSITION 0"
|
|
" TASK_RUN_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" "
|
|
" Interrupts"
|
|
" COND_CROW_FORCED_FLY"
|
|
" COND_CROW_ENEMY_WAY_TOO_CLOSE"
|
|
" COND_NEW_ENEMY"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_HOP_AWAY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CROW_FLY_AWAY"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_CROW_PICK_EVADE_GOAL 0"
|
|
" TASK_FACE_IDEAL 0"
|
|
" TASK_CROW_HOP 0"
|
|
" "
|
|
" Interrupts"
|
|
" COND_CROW_FORCED_FLY"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_IDLE_FLY,
|
|
|
|
" Tasks"
|
|
" TASK_FIND_HINTNODE 0"
|
|
" TASK_GET_PATH_TO_HINTNODE 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_FLY_AWAY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CROW_FLY_FAIL"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FIND_HINTNODE 0"
|
|
" TASK_GET_PATH_TO_HINTNODE 0"
|
|
" TASK_CROW_TAKEOFF 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_FLY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CROW_FLY_FAIL"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_CROW_TAKEOFF 0"
|
|
" TASK_CROW_FLY 0"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_FLY_FAIL,
|
|
|
|
" Tasks"
|
|
" TASK_CROW_FALL_TO_GROUND 0"
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_CROW_IDLE_WALK"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
// Crow is in the clutches of a barnacle
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CROW_BARNACLED,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_HOP"
|
|
" TASK_CROW_WAIT_FOR_BARNACLE_KILL 0"
|
|
|
|
" Interrupts"
|
|
)
|
|
|
|
|
|
AI_END_CUSTOM_NPC()
|