4264 lines
124 KiB
C++
4264 lines
124 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: The downtrodden citizens of City 17.
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
|
|
#include "npc_citizen17.h"
|
|
|
|
#include "ammodef.h"
|
|
#include "globalstate.h"
|
|
#include "soundent.h"
|
|
#include "BasePropDoor.h"
|
|
#include "weapon_rpg.h"
|
|
#include "hl2_player.h"
|
|
#include "items.h"
|
|
|
|
|
|
#ifdef HL2MP
|
|
#include "hl2mp/weapon_crowbar.h"
|
|
#else
|
|
#include "weapon_crowbar.h"
|
|
#endif
|
|
|
|
#include "eventqueue.h"
|
|
|
|
#include "ai_squad.h"
|
|
#include "ai_pathfinder.h"
|
|
#include "ai_route.h"
|
|
#include "ai_hint.h"
|
|
#include "ai_interactions.h"
|
|
#include "ai_looktarget.h"
|
|
#include "sceneentity.h"
|
|
#include "tier0/icommandline.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#define INSIGNIA_MODEL "models/chefhat.mdl"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define CIT_INSPECTED_DELAY_TIME 120 //How often I'm allowed to be inspected
|
|
|
|
extern ConVar sk_healthkit;
|
|
extern ConVar sk_healthvial;
|
|
|
|
const int MAX_PLAYER_SQUAD = 4;
|
|
|
|
ConVar sk_citizen_health ( "sk_citizen_health", "0");
|
|
ConVar sk_citizen_heal_player ( "sk_citizen_heal_player", "25");
|
|
ConVar sk_citizen_heal_player_delay ( "sk_citizen_heal_player_delay", "25");
|
|
ConVar sk_citizen_giveammo_player_delay( "sk_citizen_giveammo_player_delay", "10");
|
|
ConVar sk_citizen_heal_player_min_pct ( "sk_citizen_heal_player_min_pct", "0.60");
|
|
ConVar sk_citizen_heal_player_min_forced( "sk_citizen_heal_player_min_forced", "10.0");
|
|
ConVar sk_citizen_heal_ally ( "sk_citizen_heal_ally", "30");
|
|
ConVar sk_citizen_heal_ally_delay ( "sk_citizen_heal_ally_delay", "20");
|
|
ConVar sk_citizen_heal_ally_min_pct ( "sk_citizen_heal_ally_min_pct", "0.90");
|
|
ConVar sk_citizen_player_stare_time ( "sk_citizen_player_stare_time", "1.0" );
|
|
ConVar sk_citizen_player_stare_dist ( "sk_citizen_player_stare_dist", "72" );
|
|
ConVar sk_citizen_stare_heal_time ( "sk_citizen_stare_heal_time", "5" );
|
|
|
|
ConVar g_ai_citizen_show_enemy( "g_ai_citizen_show_enemy", "0" );
|
|
|
|
ConVar npc_citizen_insignia( "npc_citizen_insignia", "0" );
|
|
ConVar npc_citizen_squad_marker( "npc_citizen_squad_marker", "0" );
|
|
ConVar npc_citizen_explosive_resist( "npc_citizen_explosive_resist", "0" );
|
|
ConVar npc_citizen_auto_player_squad( "npc_citizen_auto_player_squad", "1" );
|
|
ConVar npc_citizen_auto_player_squad_allow_use( "npc_citizen_auto_player_squad_allow_use", "0" );
|
|
|
|
|
|
ConVar npc_citizen_dont_precache_all( "npc_citizen_dont_precache_all", "0" );
|
|
|
|
|
|
ConVar npc_citizen_medic_emit_sound("npc_citizen_medic_emit_sound", "1" );
|
|
#ifdef HL2_EPISODIC
|
|
// todo: bake these into pound constants (for now they're not just for tuning purposes)
|
|
ConVar npc_citizen_heal_chuck_medkit("npc_citizen_heal_chuck_medkit" , "1" , FCVAR_ARCHIVE, "Set to 1 to use new experimental healthkit-throwing medic.");
|
|
ConVar npc_citizen_medic_throw_style( "npc_citizen_medic_throw_style", "1", FCVAR_ARCHIVE, "Set to 0 for a lobbier trajectory" );
|
|
ConVar npc_citizen_medic_throw_speed( "npc_citizen_medic_throw_speed", "650" );
|
|
ConVar sk_citizen_heal_toss_player_delay("sk_citizen_heal_toss_player_delay", "26", FCVAR_NONE, "how long between throwing healthkits" );
|
|
|
|
|
|
#define MEDIC_THROW_SPEED npc_citizen_medic_throw_speed.GetFloat()
|
|
#define USE_EXPERIMENTAL_MEDIC_CODE() (npc_citizen_heal_chuck_medkit.GetBool() && NameMatches("griggs"))
|
|
#endif
|
|
|
|
ConVar player_squad_autosummon_time( "player_squad_autosummon_time", "5" );
|
|
ConVar player_squad_autosummon_move_tolerance( "player_squad_autosummon_move_tolerance", "20" );
|
|
ConVar player_squad_autosummon_player_tolerance( "player_squad_autosummon_player_tolerance", "10" );
|
|
ConVar player_squad_autosummon_time_after_combat( "player_squad_autosummon_time_after_combat", "8" );
|
|
ConVar player_squad_autosummon_debug( "player_squad_autosummon_debug", "0" );
|
|
|
|
#define ShouldAutosquad() (npc_citizen_auto_player_squad.GetBool())
|
|
|
|
enum SquadSlot_T
|
|
{
|
|
SQUAD_SLOT_CITIZEN_RPG1 = LAST_SHARED_SQUADSLOT,
|
|
SQUAD_SLOT_CITIZEN_RPG2,
|
|
};
|
|
|
|
const float HEAL_MOVE_RANGE = 30*12;
|
|
const float HEAL_TARGET_RANGE = 120; // 10 feet
|
|
#ifdef HL2_EPISODIC
|
|
const float HEAL_TOSS_TARGET_RANGE = 480; // 40 feet when we are throwing medkits
|
|
const float HEAL_TARGET_RANGE_Z = 72; // a second check that Gordon isn't too far above us -- 6 feet
|
|
#endif
|
|
|
|
// player must be at least this distance away from an enemy before we fire an RPG at him
|
|
const float RPG_SAFE_DISTANCE = CMissile::EXPLOSION_RADIUS + 64.0;
|
|
|
|
// Animation events
|
|
int AE_CITIZEN_GET_PACKAGE;
|
|
int AE_CITIZEN_HEAL;
|
|
|
|
//-------------------------------------
|
|
//-------------------------------------
|
|
|
|
ConVar ai_follow_move_commands( "ai_follow_move_commands", "1" );
|
|
ConVar ai_citizen_debug_commander( "ai_citizen_debug_commander", "1" );
|
|
#define DebuggingCommanderMode() (ai_citizen_debug_commander.GetBool() && (m_debugOverlays & OVERLAY_NPC_SELECTED_BIT))
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Citizen expressions for the citizen expression types
|
|
//-----------------------------------------------------------------------------
|
|
#define STATES_WITH_EXPRESSIONS 3 // Idle, Alert, Combat
|
|
#define EXPRESSIONS_PER_STATE 1
|
|
|
|
char *szExpressionTypes[CIT_EXP_LAST_TYPE] =
|
|
{
|
|
"Unassigned",
|
|
"Scared",
|
|
"Normal",
|
|
"Angry"
|
|
};
|
|
|
|
struct citizen_expression_list_t
|
|
{
|
|
char *szExpressions[EXPRESSIONS_PER_STATE];
|
|
};
|
|
// Scared
|
|
citizen_expression_list_t ScaredExpressions[STATES_WITH_EXPRESSIONS] =
|
|
{
|
|
{ { "scenes/Expressions/citizen_scared_idle_01.vcd" } },
|
|
{ { "scenes/Expressions/citizen_scared_alert_01.vcd" } },
|
|
{ { "scenes/Expressions/citizen_scared_combat_01.vcd" } },
|
|
};
|
|
// Normal
|
|
citizen_expression_list_t NormalExpressions[STATES_WITH_EXPRESSIONS] =
|
|
{
|
|
{ { "scenes/Expressions/citizen_normal_idle_01.vcd" } },
|
|
{ { "scenes/Expressions/citizen_normal_alert_01.vcd" } },
|
|
{ { "scenes/Expressions/citizen_normal_combat_01.vcd" } },
|
|
};
|
|
// Angry
|
|
citizen_expression_list_t AngryExpressions[STATES_WITH_EXPRESSIONS] =
|
|
{
|
|
{ { "scenes/Expressions/citizen_angry_idle_01.vcd" } },
|
|
{ { "scenes/Expressions/citizen_angry_alert_01.vcd" } },
|
|
{ { "scenes/Expressions/citizen_angry_combat_01.vcd" } },
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define COMMAND_POINT_CLASSNAME "info_target_command_point"
|
|
|
|
class CCommandPoint : public CPointEntity
|
|
{
|
|
DECLARE_CLASS( CCommandPoint, CPointEntity );
|
|
public:
|
|
CCommandPoint()
|
|
: m_bNotInTransition(false)
|
|
{
|
|
if ( ++gm_nCommandPoints > 1 )
|
|
DevMsg( "WARNING: More than one citizen command point present\n" );
|
|
}
|
|
|
|
~CCommandPoint()
|
|
{
|
|
--gm_nCommandPoints;
|
|
}
|
|
|
|
int ObjectCaps()
|
|
{
|
|
int caps = ( BaseClass::ObjectCaps() | FCAP_NOTIFY_ON_TRANSITION );
|
|
|
|
if ( m_bNotInTransition )
|
|
caps |= FCAP_DONT_SAVE;
|
|
|
|
return caps;
|
|
}
|
|
|
|
void InputOutsideTransition( inputdata_t &inputdata )
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return;
|
|
|
|
m_bNotInTransition = true;
|
|
|
|
CAI_Squad *pPlayerAISquad = g_AI_SquadManager.FindSquad(AllocPooledString(PLAYER_SQUADNAME));
|
|
|
|
if ( pPlayerAISquad )
|
|
{
|
|
AISquadIter_t iter;
|
|
for ( CAI_BaseNPC *pAllyNpc = pPlayerAISquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = pPlayerAISquad->GetNextMember(&iter) )
|
|
{
|
|
if ( pAllyNpc->GetCommandGoal() != vec3_invalid )
|
|
{
|
|
bool bHadGag = pAllyNpc->HasSpawnFlags(SF_NPC_GAG);
|
|
|
|
pAllyNpc->AddSpawnFlags(SF_NPC_GAG);
|
|
pAllyNpc->TargetOrder( UTIL_GetLocalPlayer(), &pAllyNpc, 1 );
|
|
if ( !bHadGag )
|
|
pAllyNpc->RemoveSpawnFlags(SF_NPC_GAG);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DECLARE_DATADESC();
|
|
|
|
private:
|
|
bool m_bNotInTransition; // does not need to be saved. If this is ever not default, the object is not being saved.
|
|
static int gm_nCommandPoints;
|
|
};
|
|
|
|
int CCommandPoint::gm_nCommandPoints;
|
|
|
|
LINK_ENTITY_TO_CLASS( info_target_command_point, CCommandPoint );
|
|
BEGIN_DATADESC( CCommandPoint )
|
|
|
|
// DEFINE_FIELD( m_bNotInTransition, FIELD_BOOLEAN ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "OutsideTransition", InputOutsideTransition ),
|
|
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CMattsPipe : public CWeaponCrowbar
|
|
{
|
|
DECLARE_CLASS( CMattsPipe, CWeaponCrowbar );
|
|
|
|
const char *GetWorldModel() const { return "models/props_canal/mattpipe.mdl"; }
|
|
void SetPickupTouch( void ) { /* do nothing */ }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------
|
|
// Citizen models
|
|
//---------------------------------------------------------
|
|
|
|
static const char *g_ppszRandomHeads[] =
|
|
{
|
|
"male_01.mdl",
|
|
"male_02.mdl",
|
|
"female_01.mdl",
|
|
"male_03.mdl",
|
|
"female_02.mdl",
|
|
"male_04.mdl",
|
|
"female_03.mdl",
|
|
"male_05.mdl",
|
|
"female_04.mdl",
|
|
"male_06.mdl",
|
|
"female_06.mdl",
|
|
"male_07.mdl",
|
|
"female_07.mdl",
|
|
"male_08.mdl",
|
|
"male_09.mdl",
|
|
};
|
|
|
|
static const char *g_ppszModelLocs[] =
|
|
{
|
|
"Group01",
|
|
"Group01",
|
|
"Group02",
|
|
"Group03%s",
|
|
};
|
|
|
|
#define IsExcludedHead( type, bMedic, iHead) false // see XBox codeline for an implementation
|
|
|
|
|
|
//---------------------------------------------------------
|
|
// Citizen activities
|
|
//---------------------------------------------------------
|
|
|
|
int ACT_CIT_HANDSUP;
|
|
int ACT_CIT_BLINDED; // Blinded by scanner photo
|
|
int ACT_CIT_SHOWARMBAND;
|
|
int ACT_CIT_HEAL;
|
|
int ACT_CIT_STARTLED; // Startled by sneaky scanner
|
|
|
|
//---------------------------------------------------------
|
|
|
|
LINK_ENTITY_TO_CLASS( npc_citizen, CNPC_Citizen );
|
|
|
|
//---------------------------------------------------------
|
|
|
|
BEGIN_DATADESC( CNPC_Citizen )
|
|
|
|
DEFINE_CUSTOM_FIELD( m_nInspectActivity, ActivityDataOps() ),
|
|
DEFINE_FIELD( m_flNextFearSoundTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flStopManhackFlinch, FIELD_TIME ),
|
|
DEFINE_FIELD( m_fNextInspectTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flPlayerHealTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flNextHealthSearchTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flAllyHealTime, FIELD_TIME ),
|
|
// gm_PlayerSquadEvaluateTimer
|
|
// m_AssaultBehavior
|
|
// m_FollowBehavior
|
|
// m_StandoffBehavior
|
|
// m_LeadBehavior
|
|
// m_FuncTankBehavior
|
|
DEFINE_FIELD( m_flPlayerGiveAmmoTime, FIELD_TIME ),
|
|
DEFINE_KEYFIELD( m_iszAmmoSupply, FIELD_STRING, "ammosupply" ),
|
|
DEFINE_KEYFIELD( m_iAmmoAmount, FIELD_INTEGER, "ammoamount" ),
|
|
DEFINE_FIELD( m_bRPGAvoidPlayer, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bShouldPatrol, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_iszOriginalSquad, FIELD_STRING ),
|
|
DEFINE_FIELD( m_flTimeJoinedPlayerSquad, FIELD_TIME ),
|
|
DEFINE_FIELD( m_bWasInPlayerSquad, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_flTimeLastCloseToPlayer, FIELD_TIME ),
|
|
DEFINE_EMBEDDED( m_AutoSummonTimer ),
|
|
DEFINE_FIELD( m_vAutoSummonAnchor, FIELD_POSITION_VECTOR ),
|
|
DEFINE_KEYFIELD( m_Type, FIELD_INTEGER, "citizentype" ),
|
|
DEFINE_KEYFIELD( m_ExpressionType, FIELD_INTEGER, "expressiontype" ),
|
|
DEFINE_FIELD( m_iHead, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_flTimePlayerStare, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flTimeNextHealStare, FIELD_TIME ),
|
|
DEFINE_FIELD( m_hSavedFollowGoalEnt, FIELD_EHANDLE ),
|
|
DEFINE_KEYFIELD( m_bNotifyNavFailBlocked, FIELD_BOOLEAN, "notifynavfailblocked" ),
|
|
DEFINE_KEYFIELD( m_bNeverLeavePlayerSquad, FIELD_BOOLEAN, "neverleaveplayersquad" ),
|
|
DEFINE_KEYFIELD( m_iszDenyCommandConcept, FIELD_STRING, "denycommandconcept" ),
|
|
|
|
DEFINE_OUTPUT( m_OnJoinedPlayerSquad, "OnJoinedPlayerSquad" ),
|
|
DEFINE_OUTPUT( m_OnLeftPlayerSquad, "OnLeftPlayerSquad" ),
|
|
DEFINE_OUTPUT( m_OnFollowOrder, "OnFollowOrder" ),
|
|
DEFINE_OUTPUT( m_OnStationOrder, "OnStationOrder" ),
|
|
DEFINE_OUTPUT( m_OnPlayerUse, "OnPlayerUse" ),
|
|
DEFINE_OUTPUT( m_OnNavFailBlocked, "OnNavFailBlocked" ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "RemoveFromPlayerSquad", InputRemoveFromPlayerSquad ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "StartPatrolling", InputStartPatrolling ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "StopPatrolling", InputStopPatrolling ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "SetCommandable", InputSetCommandable ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "SetMedicOn", InputSetMedicOn ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "SetMedicOff", InputSetMedicOff ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "SetAmmoResupplierOn", InputSetAmmoResupplierOn ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "SetAmmoResupplierOff", InputSetAmmoResupplierOff ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "SpeakIdleResponse", InputSpeakIdleResponse ),
|
|
|
|
#if HL2_EPISODIC
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "ThrowHealthKit", InputForceHealthKitToss ),
|
|
#endif
|
|
|
|
DEFINE_USEFUNC( CommanderUse ),
|
|
DEFINE_USEFUNC( SimpleUse ),
|
|
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CSimpleSimTimer CNPC_Citizen::gm_PlayerSquadEvaluateTimer;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CNPC_Citizen::CreateBehaviors()
|
|
{
|
|
BaseClass::CreateBehaviors();
|
|
AddBehavior( &m_FuncTankBehavior );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::Precache()
|
|
{
|
|
SelectModel();
|
|
SelectExpressionType();
|
|
|
|
if ( !npc_citizen_dont_precache_all.GetBool() )
|
|
PrecacheAllOfType( m_Type );
|
|
else
|
|
PrecacheModel( STRING( GetModelName() ) );
|
|
|
|
if ( NameMatches( "matt" ) )
|
|
PrecacheModel( "models/props_canal/mattpipe.mdl" );
|
|
|
|
PrecacheModel( INSIGNIA_MODEL );
|
|
|
|
PrecacheScriptSound( "NPC_Citizen.FootstepLeft" );
|
|
PrecacheScriptSound( "NPC_Citizen.FootstepRight" );
|
|
PrecacheScriptSound( "NPC_Citizen.Die" );
|
|
|
|
PrecacheInstancedScene( "scenes/Expressions/CitizenIdle.vcd" );
|
|
PrecacheInstancedScene( "scenes/Expressions/CitizenAlert_loop.vcd" );
|
|
PrecacheInstancedScene( "scenes/Expressions/CitizenCombat_loop.vcd" );
|
|
|
|
for ( int i = 0; i < STATES_WITH_EXPRESSIONS; i++ )
|
|
{
|
|
for ( int j = 0; j < ARRAYSIZE(ScaredExpressions[i].szExpressions); j++ )
|
|
{
|
|
PrecacheInstancedScene( ScaredExpressions[i].szExpressions[j] );
|
|
}
|
|
for ( int j = 0; j < ARRAYSIZE(NormalExpressions[i].szExpressions); j++ )
|
|
{
|
|
PrecacheInstancedScene( NormalExpressions[i].szExpressions[j] );
|
|
}
|
|
for ( int j = 0; j < ARRAYSIZE(AngryExpressions[i].szExpressions); j++ )
|
|
{
|
|
PrecacheInstancedScene( AngryExpressions[i].szExpressions[j] );
|
|
}
|
|
}
|
|
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::PrecacheAllOfType( CitizenType_t type )
|
|
{
|
|
if ( m_Type == CT_UNIQUE )
|
|
return;
|
|
|
|
int nHeads = ARRAYSIZE( g_ppszRandomHeads );
|
|
int i;
|
|
for ( i = 0; i < nHeads; ++i )
|
|
{
|
|
if ( !IsExcludedHead( type, false, i ) )
|
|
{
|
|
PrecacheModel( CFmtStr( "models/Humans/%s/%s", (const char *)(CFmtStr(g_ppszModelLocs[m_Type], "")), g_ppszRandomHeads[i] ) );
|
|
}
|
|
}
|
|
|
|
if ( m_Type == CT_REBEL )
|
|
{
|
|
for ( i = 0; i < nHeads; ++i )
|
|
{
|
|
if ( !IsExcludedHead( type, true, i ) )
|
|
{
|
|
PrecacheModel( CFmtStr( "models/Humans/%s/%s", (const char *)(CFmtStr(g_ppszModelLocs[m_Type], "m")), g_ppszRandomHeads[i] ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::Spawn()
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
#ifdef _XBOX
|
|
// Always fade the corpse
|
|
AddSpawnFlags( SF_NPC_FADE_CORPSE );
|
|
#endif // _XBOX
|
|
|
|
if ( ShouldAutosquad() )
|
|
{
|
|
if ( m_SquadName == GetPlayerSquadName() )
|
|
{
|
|
CAI_Squad *pPlayerSquad = g_AI_SquadManager.FindSquad( GetPlayerSquadName() );
|
|
if ( pPlayerSquad && pPlayerSquad->NumMembers() >= MAX_PLAYER_SQUAD )
|
|
m_SquadName = NULL_STRING;
|
|
}
|
|
gm_PlayerSquadEvaluateTimer.Force();
|
|
}
|
|
|
|
if ( IsAmmoResupplier() )
|
|
m_nSkin = 2;
|
|
|
|
m_bRPGAvoidPlayer = false;
|
|
|
|
m_bShouldPatrol = false;
|
|
m_iHealth = sk_citizen_health.GetFloat();
|
|
|
|
// Are we on a train? Used in trainstation to have NPCs on trains.
|
|
if ( GetMoveParent() && FClassnameIs( GetMoveParent(), "func_tracktrain" ) )
|
|
{
|
|
CapabilitiesRemove( bits_CAP_MOVE_GROUND );
|
|
SetMoveType( MOVETYPE_NONE );
|
|
if ( NameMatches("citizen_train_2") )
|
|
{
|
|
SetSequenceByName( "d1_t01_TrainRide_Sit_Idle" );
|
|
SetIdealActivity( ACT_DO_NOT_DISTURB );
|
|
}
|
|
else
|
|
{
|
|
SetSequenceByName( "d1_t01_TrainRide_Stand" );
|
|
SetIdealActivity( ACT_DO_NOT_DISTURB );
|
|
}
|
|
}
|
|
|
|
m_flStopManhackFlinch = -1;
|
|
|
|
m_iszIdleExpression = MAKE_STRING("scenes/expressions/citizenidle.vcd");
|
|
m_iszAlertExpression = MAKE_STRING("scenes/expressions/citizenalert_loop.vcd");
|
|
m_iszCombatExpression = MAKE_STRING("scenes/expressions/citizencombat_loop.vcd");
|
|
|
|
m_iszOriginalSquad = m_SquadName;
|
|
|
|
m_flNextHealthSearchTime = gpGlobals->curtime;
|
|
|
|
CWeaponRPG *pRPG = dynamic_cast<CWeaponRPG*>(GetActiveWeapon());
|
|
if ( pRPG )
|
|
{
|
|
CapabilitiesRemove( bits_CAP_USE_SHOT_REGULATOR );
|
|
pRPG->StopGuiding();
|
|
}
|
|
|
|
m_flTimePlayerStare = FLT_MAX;
|
|
|
|
AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL | EFL_NO_PHYSCANNON_INTERACTION );
|
|
|
|
NPCInit();
|
|
|
|
SetUse( &CNPC_Citizen::CommanderUse );
|
|
Assert( !ShouldAutosquad() || !IsInPlayerSquad() );
|
|
|
|
m_bWasInPlayerSquad = IsInPlayerSquad();
|
|
|
|
// Use render bounds instead of human hull for guys sitting in chairs, etc.
|
|
m_ActBusyBehavior.SetUseRenderBounds( HasSpawnFlags( SF_CITIZEN_USE_RENDER_BOUNDS ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::PostNPCInit()
|
|
{
|
|
if ( !gEntList.FindEntityByClassname( NULL, COMMAND_POINT_CLASSNAME ) )
|
|
{
|
|
CreateEntityByName( COMMAND_POINT_CLASSNAME );
|
|
}
|
|
|
|
if ( IsInPlayerSquad() )
|
|
{
|
|
if ( m_pSquad->NumMembers() > MAX_PLAYER_SQUAD )
|
|
DevMsg( "Error: Spawning citizen in player squad but exceeds squad limit of %d members\n", MAX_PLAYER_SQUAD );
|
|
|
|
FixupPlayerSquad();
|
|
}
|
|
else
|
|
{
|
|
if ( ( m_spawnflags & SF_CITIZEN_FOLLOW ) && AI_IsSinglePlayer() )
|
|
{
|
|
m_FollowBehavior.SetFollowTarget( UTIL_GetLocalPlayer() );
|
|
m_FollowBehavior.SetParameters( AIF_SIMPLE );
|
|
}
|
|
}
|
|
|
|
BaseClass::PostNPCInit();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
struct HeadCandidate_t
|
|
{
|
|
int iHead;
|
|
int nHeads;
|
|
|
|
static int __cdecl Sort( const HeadCandidate_t *pLeft, const HeadCandidate_t *pRight )
|
|
{
|
|
return ( pLeft->nHeads - pRight->nHeads );
|
|
}
|
|
};
|
|
|
|
void CNPC_Citizen::SelectModel()
|
|
{
|
|
// If making reslists, precache everything!!!
|
|
static bool madereslists = false;
|
|
|
|
if ( CommandLine()->CheckParm("-makereslists") && !madereslists )
|
|
{
|
|
madereslists = true;
|
|
|
|
PrecacheAllOfType( CT_DOWNTRODDEN );
|
|
PrecacheAllOfType( CT_REFUGEE );
|
|
PrecacheAllOfType( CT_REBEL );
|
|
}
|
|
|
|
const char *pszModelName = NULL;
|
|
|
|
if ( m_Type == CT_DEFAULT )
|
|
{
|
|
struct CitizenTypeMapping
|
|
{
|
|
const char *pszMapTag;
|
|
CitizenType_t type;
|
|
};
|
|
|
|
static CitizenTypeMapping CitizenTypeMappings[] =
|
|
{
|
|
{ "trainstation", CT_DOWNTRODDEN },
|
|
{ "canals", CT_REFUGEE },
|
|
{ "town", CT_REFUGEE },
|
|
{ "coast", CT_REFUGEE },
|
|
{ "prison", CT_DOWNTRODDEN },
|
|
{ "c17", CT_REBEL },
|
|
{ "citadel", CT_DOWNTRODDEN },
|
|
};
|
|
|
|
char szMapName[256];
|
|
Q_strncpy(szMapName, STRING(gpGlobals->mapname), sizeof(szMapName) );
|
|
Q_strlower(szMapName);
|
|
|
|
for ( int i = 0; i < ARRAYSIZE(CitizenTypeMappings); i++ )
|
|
{
|
|
if ( Q_stristr( szMapName, CitizenTypeMappings[i].pszMapTag ) )
|
|
{
|
|
m_Type = CitizenTypeMappings[i].type;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( m_Type == CT_DEFAULT )
|
|
m_Type = CT_DOWNTRODDEN;
|
|
}
|
|
|
|
if( HasSpawnFlags( SF_CITIZEN_RANDOM_HEAD | SF_CITIZEN_RANDOM_HEAD_MALE | SF_CITIZEN_RANDOM_HEAD_FEMALE ) || GetModelName() == NULL_STRING )
|
|
{
|
|
Assert( m_iHead == -1 );
|
|
char gender = ( HasSpawnFlags( SF_CITIZEN_RANDOM_HEAD_MALE ) ) ? 'm' :
|
|
( HasSpawnFlags( SF_CITIZEN_RANDOM_HEAD_FEMALE ) ) ? 'f' : 0;
|
|
|
|
RemoveSpawnFlags( SF_CITIZEN_RANDOM_HEAD | SF_CITIZEN_RANDOM_HEAD_MALE | SF_CITIZEN_RANDOM_HEAD_FEMALE );
|
|
if( HasSpawnFlags( SF_NPC_START_EFFICIENT ) )
|
|
{
|
|
SetModelName( AllocPooledString("models/humans/male_cheaple.mdl" ) );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// Count the heads
|
|
int headCounts[ARRAYSIZE(g_ppszRandomHeads)] = { 0 };
|
|
int i;
|
|
|
|
for ( i = 0; i < g_AI_Manager.NumAIs(); i++ )
|
|
{
|
|
CNPC_Citizen *pCitizen = dynamic_cast<CNPC_Citizen *>(g_AI_Manager.AccessAIs()[i]);
|
|
if ( pCitizen && pCitizen != this && pCitizen->m_iHead >= 0 && pCitizen->m_iHead < ARRAYSIZE(g_ppszRandomHeads) )
|
|
{
|
|
headCounts[pCitizen->m_iHead]++;
|
|
}
|
|
}
|
|
|
|
// Find all candidates
|
|
CUtlVectorFixed<HeadCandidate_t, ARRAYSIZE(g_ppszRandomHeads)> candidates;
|
|
|
|
for ( i = 0; i < ARRAYSIZE(g_ppszRandomHeads); i++ )
|
|
{
|
|
if ( !gender || g_ppszRandomHeads[i][0] == gender )
|
|
{
|
|
if ( !IsExcludedHead( m_Type, IsMedic(), i ) )
|
|
{
|
|
HeadCandidate_t candidate = { i, headCounts[i] };
|
|
candidates.AddToTail( candidate );
|
|
}
|
|
}
|
|
}
|
|
|
|
Assert( candidates.Count() );
|
|
candidates.Sort( &HeadCandidate_t::Sort );
|
|
|
|
int iSmallestCount = candidates[0].nHeads;
|
|
int iLimit;
|
|
|
|
for ( iLimit = 0; iLimit < candidates.Count(); iLimit++ )
|
|
{
|
|
if ( candidates[iLimit].nHeads > iSmallestCount )
|
|
break;
|
|
}
|
|
|
|
m_iHead = candidates[random->RandomInt( 0, iLimit - 1 )].iHead;
|
|
pszModelName = g_ppszRandomHeads[m_iHead];
|
|
SetModelName(NULL_STRING);
|
|
}
|
|
}
|
|
|
|
Assert( pszModelName || GetModelName() != NULL_STRING );
|
|
|
|
if ( !pszModelName )
|
|
{
|
|
if ( GetModelName() == NULL_STRING )
|
|
return;
|
|
pszModelName = strrchr(STRING(GetModelName()), '/' );
|
|
if ( !pszModelName )
|
|
pszModelName = STRING(GetModelName());
|
|
else
|
|
{
|
|
pszModelName++;
|
|
if ( m_iHead == -1 )
|
|
{
|
|
for ( int i = 0; i < ARRAYSIZE(g_ppszRandomHeads); i++ )
|
|
{
|
|
if ( Q_stricmp( g_ppszRandomHeads[i], pszModelName ) == 0 )
|
|
{
|
|
m_iHead = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( !*pszModelName )
|
|
return;
|
|
}
|
|
|
|
// Unique citizen models are left alone
|
|
if ( m_Type != CT_UNIQUE )
|
|
{
|
|
SetModelName( AllocPooledString( CFmtStr( "models/Humans/%s/%s", (const char *)(CFmtStr(g_ppszModelLocs[ m_Type ], ( IsMedic() ) ? "m" : "" )), pszModelName ) ) );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::SelectExpressionType()
|
|
{
|
|
// If we've got a mapmaker assigned type, leave it alone
|
|
if ( m_ExpressionType != CIT_EXP_UNASSIGNED )
|
|
return;
|
|
|
|
switch ( m_Type )
|
|
{
|
|
case CT_DOWNTRODDEN:
|
|
m_ExpressionType = (CitizenExpressionTypes_t)RandomInt( CIT_EXP_SCARED, CIT_EXP_NORMAL );
|
|
break;
|
|
case CT_REFUGEE:
|
|
m_ExpressionType = (CitizenExpressionTypes_t)RandomInt( CIT_EXP_SCARED, CIT_EXP_NORMAL );
|
|
break;
|
|
case CT_REBEL:
|
|
m_ExpressionType = (CitizenExpressionTypes_t)RandomInt( CIT_EXP_SCARED, CIT_EXP_ANGRY );
|
|
break;
|
|
|
|
case CT_DEFAULT:
|
|
case CT_UNIQUE:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::FixupMattWeapon()
|
|
{
|
|
CBaseCombatWeapon *pWeapon = GetActiveWeapon();
|
|
if ( pWeapon && pWeapon->ClassMatches( "weapon_crowbar" ) && NameMatches( "matt" ) )
|
|
{
|
|
Weapon_Drop( pWeapon );
|
|
UTIL_Remove( pWeapon );
|
|
pWeapon = (CBaseCombatWeapon *)CREATE_UNSAVED_ENTITY( CMattsPipe, "weapon_crowbar" );
|
|
pWeapon->SetName( AllocPooledString( "matt_weapon" ) );
|
|
DispatchSpawn( pWeapon );
|
|
|
|
#ifdef DEBUG
|
|
extern bool g_bReceivedChainedActivate;
|
|
g_bReceivedChainedActivate = false;
|
|
#endif
|
|
pWeapon->Activate();
|
|
Weapon_Equip( pWeapon );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CNPC_Citizen::Activate()
|
|
{
|
|
BaseClass::Activate();
|
|
FixupMattWeapon();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::OnRestore()
|
|
{
|
|
gm_PlayerSquadEvaluateTimer.Force();
|
|
|
|
BaseClass::OnRestore();
|
|
|
|
if ( !gEntList.FindEntityByClassname( NULL, COMMAND_POINT_CLASSNAME ) )
|
|
{
|
|
CreateEntityByName( COMMAND_POINT_CLASSNAME );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
string_t CNPC_Citizen::GetModelName() const
|
|
{
|
|
string_t iszModelName = BaseClass::GetModelName();
|
|
|
|
//
|
|
// If the model refers to an obsolete model, pretend it was blank
|
|
// so that we pick the new default model.
|
|
//
|
|
if (!Q_strnicmp(STRING(iszModelName), "models/c17_", 11) ||
|
|
!Q_strnicmp(STRING(iszModelName), "models/male", 11) ||
|
|
!Q_strnicmp(STRING(iszModelName), "models/female", 13) ||
|
|
!Q_strnicmp(STRING(iszModelName), "models/citizen", 14))
|
|
{
|
|
return NULL_STRING;
|
|
}
|
|
|
|
return iszModelName;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Overridden to switch our behavior between passive and rebel. We
|
|
// become combative after Gordon becomes a criminal.
|
|
//-----------------------------------------------------------------------------
|
|
Class_T CNPC_Citizen::Classify()
|
|
{
|
|
if (GlobalEntity_GetState("gordon_precriminal") == GLOBAL_ON)
|
|
return CLASS_CITIZEN_PASSIVE;
|
|
|
|
if (GlobalEntity_GetState("citizens_passive") == GLOBAL_ON)
|
|
return CLASS_CITIZEN_PASSIVE;
|
|
|
|
return CLASS_PLAYER_ALLY;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldAlwaysThink()
|
|
{
|
|
return ( BaseClass::ShouldAlwaysThink() || IsInPlayerSquad() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
#define CITIZEN_FOLLOWER_DESERT_FUNCTANK_DIST 45.0f*12.0f
|
|
bool CNPC_Citizen::ShouldBehaviorSelectSchedule( CAI_BehaviorBase *pBehavior )
|
|
{
|
|
if( pBehavior == &m_FollowBehavior )
|
|
{
|
|
// Suppress follow behavior if I have a func_tank and the func tank is near
|
|
// what I'm supposed to be following.
|
|
if( m_FuncTankBehavior.CanSelectSchedule() )
|
|
{
|
|
// Is the tank close to the follow target?
|
|
Vector vecTank = m_FuncTankBehavior.GetFuncTank()->WorldSpaceCenter();
|
|
Vector vecFollowGoal = m_FollowBehavior.GetFollowGoalInfo().position;
|
|
|
|
float flTankDistSqr = (vecTank - vecFollowGoal).LengthSqr();
|
|
float flAllowDist = m_FollowBehavior.GetFollowGoalInfo().followPointTolerance * 2.0f;
|
|
float flAllowDistSqr = flAllowDist * flAllowDist;
|
|
if( flTankDistSqr < flAllowDistSqr )
|
|
{
|
|
// Deny follow behavior so the tank can go.
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else if( IsInPlayerSquad() && pBehavior == &m_FuncTankBehavior && m_FuncTankBehavior.IsMounted() )
|
|
{
|
|
if( m_FollowBehavior.GetFollowTarget() )
|
|
{
|
|
Vector vecFollowGoal = m_FollowBehavior.GetFollowTarget()->GetAbsOrigin();
|
|
if( vecFollowGoal.DistToSqr( GetAbsOrigin() ) > Square(CITIZEN_FOLLOWER_DESERT_FUNCTANK_DIST) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return BaseClass::ShouldBehaviorSelectSchedule( pBehavior );
|
|
}
|
|
|
|
void CNPC_Citizen::OnChangeRunningBehavior( CAI_BehaviorBase *pOldBehavior, CAI_BehaviorBase *pNewBehavior )
|
|
{
|
|
if ( pNewBehavior == &m_FuncTankBehavior )
|
|
{
|
|
m_bReadinessCapable = false;
|
|
}
|
|
else if ( pOldBehavior == &m_FuncTankBehavior )
|
|
{
|
|
m_bReadinessCapable = IsReadinessCapable();
|
|
}
|
|
|
|
BaseClass::OnChangeRunningBehavior( pOldBehavior, pNewBehavior );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::GatherConditions()
|
|
{
|
|
BaseClass::GatherConditions();
|
|
|
|
if( IsInPlayerSquad() && hl2_episodic.GetBool() )
|
|
{
|
|
// Leave the player squad if someone has made me neutral to player.
|
|
if( IRelationType(UTIL_GetLocalPlayer()) == D_NU )
|
|
{
|
|
RemoveFromPlayerSquad();
|
|
}
|
|
}
|
|
|
|
if ( !SpokeConcept( TLK_JOINPLAYER ) && IsRunningScriptedSceneWithSpeech( this, true ) )
|
|
{
|
|
SetSpokeConcept( TLK_JOINPLAYER, NULL );
|
|
for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )
|
|
{
|
|
CAI_BaseNPC *pNpc = g_AI_Manager.AccessAIs()[i];
|
|
if ( pNpc != this && pNpc->GetClassname() == GetClassname() && pNpc->GetAbsOrigin().DistToSqr( GetAbsOrigin() ) < Square( 15*12 ) && FVisible( pNpc ) )
|
|
{
|
|
(assert_cast<CNPC_Citizen *>(pNpc))->SetSpokeConcept( TLK_JOINPLAYER, NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ShouldLookForHealthItem() )
|
|
{
|
|
if( FindHealthItem( GetAbsOrigin(), Vector( 240, 240, 240 ) ) )
|
|
SetCondition( COND_HEALTH_ITEM_AVAILABLE );
|
|
else
|
|
ClearCondition( COND_HEALTH_ITEM_AVAILABLE );
|
|
|
|
m_flNextHealthSearchTime = gpGlobals->curtime + 4.0;
|
|
}
|
|
|
|
// If the player is standing near a medic and can see the medic,
|
|
// assume the player is 'staring' and wants health.
|
|
if( CanHeal() )
|
|
{
|
|
CBasePlayer *pPlayer = AI_GetSinglePlayer();
|
|
|
|
if ( !pPlayer )
|
|
{
|
|
m_flTimePlayerStare = FLT_MAX;
|
|
return;
|
|
}
|
|
|
|
float flDistSqr = ( GetAbsOrigin() - pPlayer->GetAbsOrigin() ).Length2DSqr();
|
|
float flStareDist = sk_citizen_player_stare_dist.GetFloat();
|
|
float flPlayerDamage = pPlayer->GetMaxHealth() - pPlayer->GetHealth();
|
|
|
|
if( pPlayer->IsAlive() && flPlayerDamage > 0 && (flDistSqr <= flStareDist * flStareDist) && pPlayer->FInViewCone( this ) && pPlayer->FVisible( this ) )
|
|
{
|
|
if( m_flTimePlayerStare == FLT_MAX )
|
|
{
|
|
// Player wasn't looking at me at last think. He started staring now.
|
|
m_flTimePlayerStare = gpGlobals->curtime;
|
|
}
|
|
|
|
// Heal if it's been long enough since last time I healed a staring player.
|
|
if( gpGlobals->curtime - m_flTimePlayerStare >= sk_citizen_player_stare_time.GetFloat() && gpGlobals->curtime > m_flTimeNextHealStare && !IsCurSchedule( SCHED_CITIZEN_HEAL ) )
|
|
{
|
|
if ( ShouldHealTarget( pPlayer, true ) )
|
|
{
|
|
SetCondition( COND_CIT_PLAYERHEALREQUEST );
|
|
}
|
|
else
|
|
{
|
|
m_flTimeNextHealStare = gpGlobals->curtime + sk_citizen_stare_heal_time.GetFloat() * .5f;
|
|
ClearCondition( COND_CIT_PLAYERHEALREQUEST );
|
|
}
|
|
}
|
|
|
|
#ifdef HL2_EPISODIC
|
|
// Heal if I'm on an assault. The player hasn't had time to stare at me.
|
|
if( m_AssaultBehavior.IsRunning() && IsMoving() )
|
|
{
|
|
SetCondition( COND_CIT_PLAYERHEALREQUEST );
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
m_flTimePlayerStare = FLT_MAX;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::PredictPlayerPush()
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return;
|
|
|
|
if ( HasCondition( COND_CIT_PLAYERHEALREQUEST ) )
|
|
return;
|
|
|
|
bool bHadPlayerPush = HasCondition( COND_PLAYER_PUSHING );
|
|
|
|
BaseClass::PredictPlayerPush();
|
|
|
|
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
|
|
if ( !bHadPlayerPush && HasCondition( COND_PLAYER_PUSHING ) &&
|
|
pPlayer->FInViewCone( this ) && CanHeal() )
|
|
{
|
|
if ( ShouldHealTarget( pPlayer, true ) )
|
|
{
|
|
ClearCondition( COND_PLAYER_PUSHING );
|
|
SetCondition( COND_CIT_PLAYERHEALREQUEST );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::PrescheduleThink()
|
|
{
|
|
BaseClass::PrescheduleThink();
|
|
|
|
UpdatePlayerSquad();
|
|
UpdateFollowCommandPoint();
|
|
|
|
if ( !npc_citizen_insignia.GetBool() && npc_citizen_squad_marker.GetBool() && IsInPlayerSquad() )
|
|
{
|
|
Vector mins = WorldAlignMins() * .5 + GetAbsOrigin();
|
|
Vector maxs = WorldAlignMaxs() * .5 + GetAbsOrigin();
|
|
|
|
float rMax = 255;
|
|
float gMax = 255;
|
|
float bMax = 255;
|
|
|
|
float rMin = 255;
|
|
float gMin = 128;
|
|
float bMin = 0;
|
|
|
|
const float TIME_FADE = 1.0;
|
|
float timeInSquad = gpGlobals->curtime - m_flTimeJoinedPlayerSquad;
|
|
timeInSquad = MIN( TIME_FADE, MAX( timeInSquad, 0 ) );
|
|
|
|
float fade = ( 1.0 - timeInSquad / TIME_FADE );
|
|
|
|
float r = rMin + ( rMax - rMin ) * fade;
|
|
float g = gMin + ( gMax - gMin ) * fade;
|
|
float b = bMin + ( bMax - bMin ) * fade;
|
|
|
|
// THIS IS A PLACEHOLDER UNTIL WE HAVE A REAL DESIGN & ART -- DO NOT REMOVE
|
|
NDebugOverlay::Line( Vector( mins.x, GetAbsOrigin().y, GetAbsOrigin().z+1 ), Vector( maxs.x, GetAbsOrigin().y, GetAbsOrigin().z+1 ), r, g, b, false, .11 );
|
|
NDebugOverlay::Line( Vector( GetAbsOrigin().x, mins.y, GetAbsOrigin().z+1 ), Vector( GetAbsOrigin().x, maxs.y, GetAbsOrigin().z+1 ), r, g, b, false, .11 );
|
|
}
|
|
if( GetEnemy() && g_ai_citizen_show_enemy.GetBool() )
|
|
{
|
|
NDebugOverlay::Line( EyePosition(), GetEnemy()->EyePosition(), 255, 0, 0, false, .1 );
|
|
}
|
|
|
|
if ( DebuggingCommanderMode() )
|
|
{
|
|
if ( HaveCommandGoal() )
|
|
{
|
|
CBaseEntity *pCommandPoint = gEntList.FindEntityByClassname( NULL, COMMAND_POINT_CLASSNAME );
|
|
|
|
if ( pCommandPoint )
|
|
{
|
|
NDebugOverlay::Cross3D(pCommandPoint->GetAbsOrigin(), 16, 0, 255, 255, false, 0.1 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Allows for modification of the interrupt mask for the current schedule.
|
|
// In the most cases the base implementation should be called first.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::BuildScheduleTestBits()
|
|
{
|
|
BaseClass::BuildScheduleTestBits();
|
|
|
|
if ( IsCurSchedule( SCHED_IDLE_STAND ) || IsCurSchedule( SCHED_ALERT_STAND ) )
|
|
{
|
|
SetCustomInterruptCondition( COND_CIT_START_INSPECTION );
|
|
}
|
|
|
|
if ( IsMedic() && IsCustomInterruptConditionSet( COND_HEAR_MOVE_AWAY ) )
|
|
{
|
|
if( !IsCurSchedule(SCHED_RELOAD, false) )
|
|
{
|
|
// Since schedule selection code prioritizes reloading over requests to heal
|
|
// the player, we must prevent this condition from breaking the reload schedule.
|
|
SetCustomInterruptCondition( COND_CIT_PLAYERHEALREQUEST );
|
|
}
|
|
|
|
SetCustomInterruptCondition( COND_CIT_COMMANDHEAL );
|
|
}
|
|
|
|
if( !IsCurSchedule( SCHED_NEW_WEAPON ) )
|
|
{
|
|
SetCustomInterruptCondition( COND_RECEIVED_ORDERS );
|
|
}
|
|
|
|
if( GetCurSchedule()->HasInterrupt( COND_IDLE_INTERRUPT ) )
|
|
{
|
|
SetCustomInterruptCondition( COND_BETTER_WEAPON_AVAILABLE );
|
|
}
|
|
|
|
#ifdef HL2_EPISODIC
|
|
if( IsMedic() && m_AssaultBehavior.IsRunning() )
|
|
{
|
|
if( !IsCurSchedule(SCHED_RELOAD, false) )
|
|
{
|
|
SetCustomInterruptCondition( COND_CIT_PLAYERHEALREQUEST );
|
|
}
|
|
|
|
SetCustomInterruptCondition( COND_CIT_COMMANDHEAL );
|
|
}
|
|
#else
|
|
if( IsMedic() && m_AssaultBehavior.IsRunning() && !IsMoving() )
|
|
{
|
|
if( !IsCurSchedule(SCHED_RELOAD, false) )
|
|
{
|
|
SetCustomInterruptCondition( COND_CIT_PLAYERHEALREQUEST );
|
|
}
|
|
|
|
SetCustomInterruptCondition( COND_CIT_COMMANDHEAL );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::FInViewCone( CBaseEntity *pEntity )
|
|
{
|
|
#if 0
|
|
if ( IsMortar( pEntity ) )
|
|
{
|
|
// @TODO (toml 11-20-03): do this only if have heard mortar shell recently and it's active
|
|
return true;
|
|
}
|
|
#endif
|
|
return BaseClass::FInViewCone( pEntity );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode )
|
|
{
|
|
switch( failedSchedule )
|
|
{
|
|
case SCHED_NEW_WEAPON:
|
|
// If failed trying to pick up a weapon, try again in one second. This is because other AI code
|
|
// has put this off for 10 seconds under the assumption that the citizen would be able to
|
|
// pick up the weapon that they found.
|
|
m_flNextWeaponSearchTime = gpGlobals->curtime + 1.0f;
|
|
break;
|
|
|
|
case SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK:
|
|
case SCHED_MOVE_TO_WEAPON_RANGE:
|
|
if( !IsMortar( GetEnemy() ) )
|
|
{
|
|
if ( GetActiveWeapon() && ( GetActiveWeapon()->CapabilitiesGet() & bits_CAP_WEAPON_RANGE_ATTACK1 ) && random->RandomInt( 0, 1 ) && HasCondition(COND_SEE_ENEMY) && !HasCondition ( COND_NO_PRIMARY_AMMO ) )
|
|
return TranslateSchedule( SCHED_RANGE_ATTACK1 );
|
|
|
|
return SCHED_STANDOFF;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return BaseClass::SelectFailSchedule( failedSchedule, failedTask, taskFailCode );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectSchedule()
|
|
{
|
|
// If we can't move, we're on a train, and should be sitting.
|
|
if ( GetMoveType() == MOVETYPE_NONE )
|
|
{
|
|
// For now, we're only ever parented to trains. If you hit this assert, you've parented a citizen
|
|
// to something else, and now we need to figure out a better system.
|
|
Assert( GetMoveParent() && FClassnameIs( GetMoveParent(), "func_tracktrain" ) );
|
|
return SCHED_CITIZEN_SIT_ON_TRAIN;
|
|
}
|
|
|
|
CWeaponRPG *pRPG = dynamic_cast<CWeaponRPG*>(GetActiveWeapon());
|
|
if ( pRPG && pRPG->IsGuiding() )
|
|
{
|
|
DevMsg( "Citizen in select schedule but RPG is guiding?\n");
|
|
pRPG->StopGuiding();
|
|
}
|
|
|
|
return BaseClass::SelectSchedule();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectSchedulePriorityAction()
|
|
{
|
|
int schedule = SelectScheduleHeal();
|
|
if ( schedule != SCHED_NONE )
|
|
return schedule;
|
|
|
|
schedule = BaseClass::SelectSchedulePriorityAction();
|
|
if ( schedule != SCHED_NONE )
|
|
return schedule;
|
|
|
|
schedule = SelectScheduleRetrieveItem();
|
|
if ( schedule != SCHED_NONE )
|
|
return schedule;
|
|
|
|
return SCHED_NONE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Determine if citizen should perform heal action.
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectScheduleHeal()
|
|
{
|
|
// episodic medics may toss the healthkits rather than poke you with them
|
|
#if HL2_EPISODIC
|
|
|
|
if ( CanHeal() )
|
|
{
|
|
CBaseEntity *pEntity = PlayerInRange( GetLocalOrigin(), HEAL_TOSS_TARGET_RANGE );
|
|
if ( pEntity )
|
|
{
|
|
if ( USE_EXPERIMENTAL_MEDIC_CODE() && IsMedic() )
|
|
{
|
|
// use the new heal toss algorithm
|
|
if ( ShouldHealTossTarget( pEntity, HasCondition( COND_CIT_PLAYERHEALREQUEST ) ) )
|
|
{
|
|
SetTarget( pEntity );
|
|
return SCHED_CITIZEN_HEAL_TOSS;
|
|
}
|
|
}
|
|
else if ( PlayerInRange( GetLocalOrigin(), HEAL_MOVE_RANGE ) )
|
|
{
|
|
// use old mechanism for ammo
|
|
if ( ShouldHealTarget( pEntity, HasCondition( COND_CIT_PLAYERHEALREQUEST ) ) )
|
|
{
|
|
SetTarget( pEntity );
|
|
return SCHED_CITIZEN_HEAL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if ( m_pSquad )
|
|
{
|
|
pEntity = NULL;
|
|
float distClosestSq = HEAL_MOVE_RANGE*HEAL_MOVE_RANGE;
|
|
float distCurSq;
|
|
|
|
AISquadIter_t iter;
|
|
CAI_BaseNPC *pSquadmate = m_pSquad->GetFirstMember( &iter );
|
|
while ( pSquadmate )
|
|
{
|
|
if ( pSquadmate != this )
|
|
{
|
|
distCurSq = ( GetAbsOrigin() - pSquadmate->GetAbsOrigin() ).LengthSqr();
|
|
if ( distCurSq < distClosestSq && ShouldHealTarget( pSquadmate ) )
|
|
{
|
|
distClosestSq = distCurSq;
|
|
pEntity = pSquadmate;
|
|
}
|
|
}
|
|
|
|
pSquadmate = m_pSquad->GetNextMember( &iter );
|
|
}
|
|
|
|
if ( pEntity )
|
|
{
|
|
SetTarget( pEntity );
|
|
return SCHED_CITIZEN_HEAL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( HasCondition( COND_CIT_PLAYERHEALREQUEST ) )
|
|
DevMsg( "Would say: sorry, need to recharge\n" );
|
|
}
|
|
|
|
return SCHED_NONE;
|
|
|
|
#else
|
|
|
|
if ( CanHeal() )
|
|
{
|
|
CBaseEntity *pEntity = PlayerInRange( GetLocalOrigin(), HEAL_MOVE_RANGE );
|
|
if ( pEntity && ShouldHealTarget( pEntity, HasCondition( COND_CIT_PLAYERHEALREQUEST ) ) )
|
|
{
|
|
SetTarget( pEntity );
|
|
return SCHED_CITIZEN_HEAL;
|
|
}
|
|
|
|
if ( m_pSquad )
|
|
{
|
|
pEntity = NULL;
|
|
float distClosestSq = HEAL_MOVE_RANGE*HEAL_MOVE_RANGE;
|
|
float distCurSq;
|
|
|
|
AISquadIter_t iter;
|
|
CAI_BaseNPC *pSquadmate = m_pSquad->GetFirstMember( &iter );
|
|
while ( pSquadmate )
|
|
{
|
|
if ( pSquadmate != this )
|
|
{
|
|
distCurSq = ( GetAbsOrigin() - pSquadmate->GetAbsOrigin() ).LengthSqr();
|
|
if ( distCurSq < distClosestSq && ShouldHealTarget( pSquadmate ) )
|
|
{
|
|
distClosestSq = distCurSq;
|
|
pEntity = pSquadmate;
|
|
}
|
|
}
|
|
|
|
pSquadmate = m_pSquad->GetNextMember( &iter );
|
|
}
|
|
|
|
if ( pEntity )
|
|
{
|
|
SetTarget( pEntity );
|
|
return SCHED_CITIZEN_HEAL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( HasCondition( COND_CIT_PLAYERHEALREQUEST ) )
|
|
DevMsg( "Would say: sorry, need to recharge\n" );
|
|
}
|
|
|
|
return SCHED_NONE;
|
|
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectScheduleRetrieveItem()
|
|
{
|
|
if ( HasCondition(COND_BETTER_WEAPON_AVAILABLE) )
|
|
{
|
|
CBaseHLCombatWeapon *pWeapon = dynamic_cast<CBaseHLCombatWeapon *>(Weapon_FindUsable( WEAPON_SEARCH_DELTA ));
|
|
if ( pWeapon )
|
|
{
|
|
m_flNextWeaponSearchTime = gpGlobals->curtime + 10.0;
|
|
// Now lock the weapon for several seconds while we go to pick it up.
|
|
pWeapon->Lock( 10.0, this );
|
|
SetTarget( pWeapon );
|
|
return SCHED_NEW_WEAPON;
|
|
}
|
|
}
|
|
|
|
if( HasCondition(COND_HEALTH_ITEM_AVAILABLE) )
|
|
{
|
|
if( !IsInPlayerSquad() )
|
|
{
|
|
// Been kicked out of the player squad since the time I located the health.
|
|
ClearCondition( COND_HEALTH_ITEM_AVAILABLE );
|
|
}
|
|
else
|
|
{
|
|
CBaseEntity *pBase = FindHealthItem(m_FollowBehavior.GetFollowTarget()->GetAbsOrigin(), Vector( 120, 120, 120 ) );
|
|
CItem *pItem = dynamic_cast<CItem *>(pBase);
|
|
|
|
if( pItem )
|
|
{
|
|
SetTarget( pItem );
|
|
return SCHED_GET_HEALTHKIT;
|
|
}
|
|
}
|
|
}
|
|
return SCHED_NONE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectScheduleNonCombat()
|
|
{
|
|
if ( m_NPCState == NPC_STATE_IDLE )
|
|
{
|
|
// Handle being inspected by the scanner
|
|
if ( HasCondition( COND_CIT_START_INSPECTION ) )
|
|
{
|
|
ClearCondition( COND_CIT_START_INSPECTION );
|
|
return SCHED_CITIZEN_PLAY_INSPECT_ACTIVITY;
|
|
}
|
|
}
|
|
|
|
ClearCondition( COND_CIT_START_INSPECTION );
|
|
|
|
if ( m_bShouldPatrol )
|
|
return SCHED_CITIZEN_PATROL;
|
|
|
|
return SCHED_NONE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectScheduleManhackCombat()
|
|
{
|
|
if ( m_NPCState == NPC_STATE_COMBAT && IsManhackMeleeCombatant() )
|
|
{
|
|
if ( !HasCondition( COND_CAN_MELEE_ATTACK1 ) )
|
|
{
|
|
float distSqEnemy = ( GetEnemy()->GetAbsOrigin() - EyePosition() ).LengthSqr();
|
|
if ( distSqEnemy < 48.0*48.0 &&
|
|
( ( GetEnemy()->GetAbsOrigin() + GetEnemy()->GetSmoothedVelocity() * .1 ) - EyePosition() ).LengthSqr() < distSqEnemy )
|
|
return SCHED_COWER;
|
|
|
|
int iRoll = random->RandomInt( 1, 4 );
|
|
if ( iRoll == 1 )
|
|
return SCHED_BACK_AWAY_FROM_ENEMY;
|
|
else if ( iRoll == 2 )
|
|
return SCHED_CHASE_ENEMY;
|
|
}
|
|
}
|
|
|
|
return SCHED_NONE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::SelectScheduleCombat()
|
|
{
|
|
int schedule = SelectScheduleManhackCombat();
|
|
if ( schedule != SCHED_NONE )
|
|
return schedule;
|
|
|
|
return BaseClass::SelectScheduleCombat();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldDeferToFollowBehavior()
|
|
{
|
|
#if 0
|
|
if ( HaveCommandGoal() )
|
|
return false;
|
|
#endif
|
|
|
|
return BaseClass::ShouldDeferToFollowBehavior();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::TranslateSchedule( int scheduleType )
|
|
{
|
|
CBasePlayer *pLocalPlayer = AI_GetSinglePlayer();
|
|
|
|
switch( scheduleType )
|
|
{
|
|
case SCHED_IDLE_STAND:
|
|
case SCHED_ALERT_STAND:
|
|
if( m_NPCState != NPC_STATE_COMBAT && pLocalPlayer && !pLocalPlayer->IsAlive() && CanJoinPlayerSquad() )
|
|
{
|
|
// Player is dead!
|
|
float flDist;
|
|
flDist = ( pLocalPlayer->GetAbsOrigin() - GetAbsOrigin() ).Length();
|
|
|
|
if( flDist < 50 * 12 )
|
|
{
|
|
AddSpawnFlags( SF_CITIZEN_NOT_COMMANDABLE );
|
|
return SCHED_CITIZEN_MOURN_PLAYER;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SCHED_ESTABLISH_LINE_OF_FIRE:
|
|
case SCHED_MOVE_TO_WEAPON_RANGE:
|
|
if( !IsMortar( GetEnemy() ) && HaveCommandGoal() )
|
|
{
|
|
if ( GetActiveWeapon() && ( GetActiveWeapon()->CapabilitiesGet() & bits_CAP_WEAPON_RANGE_ATTACK1 ) && random->RandomInt( 0, 1 ) && HasCondition(COND_SEE_ENEMY) && !HasCondition ( COND_NO_PRIMARY_AMMO ) )
|
|
return TranslateSchedule( SCHED_RANGE_ATTACK1 );
|
|
|
|
return SCHED_STANDOFF;
|
|
}
|
|
break;
|
|
|
|
case SCHED_CHASE_ENEMY:
|
|
if( !IsMortar( GetEnemy() ) && HaveCommandGoal() )
|
|
{
|
|
return SCHED_STANDOFF;
|
|
}
|
|
break;
|
|
|
|
case SCHED_RANGE_ATTACK1:
|
|
// If we have an RPG, we use a custom schedule for it
|
|
if ( !IsMortar( GetEnemy() ) && GetActiveWeapon() && FClassnameIs( GetActiveWeapon(), "weapon_rpg" ) )
|
|
{
|
|
if ( GetEnemy() && GetEnemy()->ClassMatches( "npc_strider" ) )
|
|
{
|
|
if (OccupyStrategySlotRange( SQUAD_SLOT_CITIZEN_RPG1, SQUAD_SLOT_CITIZEN_RPG2 ) )
|
|
{
|
|
return SCHED_CITIZEN_STRIDER_RANGE_ATTACK1_RPG;
|
|
}
|
|
else
|
|
{
|
|
return SCHED_STANDOFF;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CBasePlayer *pPlayer = AI_GetSinglePlayer();
|
|
if ( pPlayer && GetEnemy() && ( ( GetEnemy()->GetAbsOrigin() -
|
|
pPlayer->GetAbsOrigin() ).LengthSqr() < RPG_SAFE_DISTANCE * RPG_SAFE_DISTANCE ) )
|
|
{
|
|
// Don't fire our RPG at an enemy too close to the player
|
|
return SCHED_STANDOFF;
|
|
}
|
|
else
|
|
{
|
|
return SCHED_CITIZEN_RANGE_ATTACK1_RPG;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return BaseClass::TranslateSchedule( scheduleType );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldAcceptGoal( CAI_BehaviorBase *pBehavior, CAI_GoalEntity *pGoal )
|
|
{
|
|
if ( BaseClass::ShouldAcceptGoal( pBehavior, pGoal ) )
|
|
{
|
|
CAI_FollowBehavior *pFollowBehavior = dynamic_cast<CAI_FollowBehavior *>(pBehavior );
|
|
if ( pFollowBehavior )
|
|
{
|
|
if ( IsInPlayerSquad() )
|
|
{
|
|
m_hSavedFollowGoalEnt = (CAI_FollowGoal *)pGoal;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::OnClearGoal( CAI_BehaviorBase *pBehavior, CAI_GoalEntity *pGoal )
|
|
{
|
|
if ( m_hSavedFollowGoalEnt == pGoal )
|
|
m_hSavedFollowGoalEnt = NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::StartTask( const Task_t *pTask )
|
|
{
|
|
switch( pTask->iTask )
|
|
{
|
|
case TASK_CIT_PLAY_INSPECT_SEQUENCE:
|
|
SetIdealActivity( (Activity) m_nInspectActivity );
|
|
break;
|
|
|
|
case TASK_CIT_SIT_ON_TRAIN:
|
|
if ( NameMatches("citizen_train_2") )
|
|
{
|
|
SetSequenceByName( "d1_t01_TrainRide_Sit_Idle" );
|
|
SetIdealActivity( ACT_DO_NOT_DISTURB );
|
|
}
|
|
else
|
|
{
|
|
SetSequenceByName( "d1_t01_TrainRide_Stand" );
|
|
SetIdealActivity( ACT_DO_NOT_DISTURB );
|
|
}
|
|
break;
|
|
|
|
case TASK_CIT_LEAVE_TRAIN:
|
|
if ( NameMatches("citizen_train_2") )
|
|
{
|
|
SetSequenceByName( "d1_t01_TrainRide_Sit_Exit" );
|
|
SetIdealActivity( ACT_DO_NOT_DISTURB );
|
|
}
|
|
else
|
|
{
|
|
SetSequenceByName( "d1_t01_TrainRide_Stand_Exit" );
|
|
SetIdealActivity( ACT_DO_NOT_DISTURB );
|
|
}
|
|
break;
|
|
|
|
case TASK_CIT_HEAL:
|
|
#if HL2_EPISODIC
|
|
case TASK_CIT_HEAL_TOSS:
|
|
#endif
|
|
if ( IsMedic() )
|
|
{
|
|
if ( GetTarget() && GetTarget()->IsPlayer() && GetTarget()->m_iMaxHealth == GetTarget()->m_iHealth )
|
|
{
|
|
// Doesn't need us anymore
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
Speak( TLK_HEAL );
|
|
}
|
|
else if ( IsAmmoResupplier() )
|
|
{
|
|
Speak( TLK_GIVEAMMO );
|
|
}
|
|
SetIdealActivity( (Activity)ACT_CIT_HEAL );
|
|
break;
|
|
|
|
case TASK_CIT_RPG_AUGER:
|
|
m_bRPGAvoidPlayer = false;
|
|
SetWait( 15.0 ); // maximum time auger before giving up
|
|
break;
|
|
|
|
case TASK_CIT_SPEAK_MOURNING:
|
|
if ( !IsSpeaking() && CanSpeakAfterMyself() )
|
|
{
|
|
//CAI_AllySpeechManager *pSpeechManager = GetAllySpeechManager();
|
|
|
|
//if ( pSpeechManager-> )
|
|
|
|
Speak(TLK_PLDEAD);
|
|
}
|
|
TaskComplete();
|
|
break;
|
|
|
|
default:
|
|
BaseClass::StartTask( pTask );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::RunTask( const Task_t *pTask )
|
|
{
|
|
switch( pTask->iTask )
|
|
{
|
|
case TASK_WAIT_FOR_MOVEMENT:
|
|
{
|
|
if ( IsManhackMeleeCombatant() )
|
|
{
|
|
AddFacingTarget( GetEnemy(), 1.0, 0.5 );
|
|
}
|
|
|
|
BaseClass::RunTask( pTask );
|
|
break;
|
|
}
|
|
|
|
case TASK_MOVE_TO_TARGET_RANGE:
|
|
{
|
|
// If we're moving to heal a target, and the target dies, stop
|
|
if ( IsCurSchedule( SCHED_CITIZEN_HEAL ) && (!GetTarget() || !GetTarget()->IsAlive()) )
|
|
{
|
|
TaskFail(FAIL_NO_TARGET);
|
|
return;
|
|
}
|
|
|
|
BaseClass::RunTask( pTask );
|
|
break;
|
|
}
|
|
|
|
case TASK_CIT_PLAY_INSPECT_SEQUENCE:
|
|
{
|
|
AutoMovement();
|
|
|
|
if ( IsSequenceFinished() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
}
|
|
case TASK_CIT_SIT_ON_TRAIN:
|
|
{
|
|
// If we were on a train, but we're not anymore, enable movement
|
|
if ( !GetMoveParent() )
|
|
{
|
|
SetMoveType( MOVETYPE_STEP );
|
|
CapabilitiesAdd( bits_CAP_MOVE_GROUND );
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_CIT_LEAVE_TRAIN:
|
|
{
|
|
if ( IsSequenceFinished() )
|
|
{
|
|
SetupVPhysicsHull();
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_CIT_HEAL:
|
|
if ( IsSequenceFinished() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
else if (!GetTarget())
|
|
{
|
|
// Our heal target was killed or deleted somehow.
|
|
TaskFail(FAIL_NO_TARGET);
|
|
}
|
|
else
|
|
{
|
|
if ( ( GetTarget()->GetAbsOrigin() - GetAbsOrigin() ).Length2D() > HEAL_MOVE_RANGE/2 )
|
|
TaskComplete();
|
|
|
|
GetMotor()->SetIdealYawToTargetAndUpdate( GetTarget()->GetAbsOrigin() );
|
|
}
|
|
break;
|
|
|
|
|
|
#if HL2_EPISODIC
|
|
case TASK_CIT_HEAL_TOSS:
|
|
if ( IsSequenceFinished() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
else if (!GetTarget())
|
|
{
|
|
// Our heal target was killed or deleted somehow.
|
|
TaskFail(FAIL_NO_TARGET);
|
|
}
|
|
else
|
|
{
|
|
GetMotor()->SetIdealYawToTargetAndUpdate( GetTarget()->GetAbsOrigin() );
|
|
}
|
|
break;
|
|
|
|
#endif
|
|
|
|
case TASK_CIT_RPG_AUGER:
|
|
{
|
|
// Keep augering until the RPG has been destroyed
|
|
CWeaponRPG *pRPG = dynamic_cast<CWeaponRPG*>(GetActiveWeapon());
|
|
if ( !pRPG )
|
|
{
|
|
TaskFail( FAIL_ITEM_NO_FIND );
|
|
return;
|
|
}
|
|
|
|
// Has the RPG detonated?
|
|
if ( !pRPG->GetMissile() )
|
|
{
|
|
pRPG->StopGuiding();
|
|
TaskComplete();
|
|
return;
|
|
}
|
|
|
|
Vector vecLaserPos = pRPG->GetNPCLaserPosition();
|
|
|
|
if ( !m_bRPGAvoidPlayer )
|
|
{
|
|
// Abort if we've lost our enemy
|
|
if ( !GetEnemy() )
|
|
{
|
|
pRPG->StopGuiding();
|
|
TaskFail( FAIL_NO_ENEMY );
|
|
return;
|
|
}
|
|
|
|
// Is our enemy occluded?
|
|
if ( HasCondition( COND_ENEMY_OCCLUDED ) )
|
|
{
|
|
// Turn off the laserdot, but don't stop augering
|
|
pRPG->StopGuiding();
|
|
return;
|
|
}
|
|
else if ( pRPG->IsGuiding() == false )
|
|
{
|
|
pRPG->StartGuiding();
|
|
}
|
|
|
|
Vector vecEnemyPos = GetEnemy()->BodyTarget(GetAbsOrigin(), false);
|
|
CBasePlayer *pPlayer = AI_GetSinglePlayer();
|
|
if ( pPlayer && ( ( vecEnemyPos - pPlayer->GetAbsOrigin() ).LengthSqr() < RPG_SAFE_DISTANCE * RPG_SAFE_DISTANCE ) )
|
|
{
|
|
m_bRPGAvoidPlayer = true;
|
|
Speak( TLK_WATCHOUT );
|
|
}
|
|
else
|
|
{
|
|
// Pull the laserdot towards the target
|
|
Vector vecToTarget = (vecEnemyPos - vecLaserPos);
|
|
float distToMove = VectorNormalize( vecToTarget );
|
|
if ( distToMove > 90 )
|
|
distToMove = 90;
|
|
vecLaserPos += vecToTarget * distToMove;
|
|
}
|
|
}
|
|
|
|
if ( m_bRPGAvoidPlayer )
|
|
{
|
|
// Pull the laserdot up
|
|
vecLaserPos.z += 90;
|
|
}
|
|
|
|
if ( IsWaitFinished() )
|
|
{
|
|
pRPG->StopGuiding();
|
|
TaskFail( FAIL_NO_SHOOT );
|
|
return;
|
|
}
|
|
// Add imprecision to avoid obvious robotic perfection stationary targets
|
|
float imprecision = 18*sin(gpGlobals->curtime);
|
|
vecLaserPos.x += imprecision;
|
|
vecLaserPos.y += imprecision;
|
|
vecLaserPos.z += imprecision;
|
|
pRPG->UpdateNPCLaserPosition( vecLaserPos );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
BaseClass::RunTask( pTask );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : code -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::TaskFail( AI_TaskFailureCode_t code )
|
|
{
|
|
// If our heal task has failed, push out the heal time
|
|
if ( IsCurSchedule( SCHED_CITIZEN_HEAL ) )
|
|
{
|
|
m_flPlayerHealTime = gpGlobals->curtime + sk_citizen_heal_ally_delay.GetFloat();
|
|
}
|
|
|
|
if( code == FAIL_NO_ROUTE_BLOCKED && m_bNotifyNavFailBlocked )
|
|
{
|
|
m_OnNavFailBlocked.FireOutput( this, this );
|
|
}
|
|
|
|
BaseClass::TaskFail( code );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Override base class activiites
|
|
//-----------------------------------------------------------------------------
|
|
Activity CNPC_Citizen::NPC_TranslateActivity( Activity activity )
|
|
{
|
|
if ( activity == ACT_MELEE_ATTACK1 )
|
|
{
|
|
return ACT_MELEE_ATTACK_SWING;
|
|
}
|
|
|
|
// !!!HACK - Citizens don't have the required animations for shotguns,
|
|
// so trick them into using the rifle counterparts for now (sjb)
|
|
if ( activity == ACT_RUN_AIM_SHOTGUN )
|
|
return ACT_RUN_AIM_RIFLE;
|
|
if ( activity == ACT_WALK_AIM_SHOTGUN )
|
|
return ACT_WALK_AIM_RIFLE;
|
|
if ( activity == ACT_IDLE_ANGRY_SHOTGUN )
|
|
return ACT_IDLE_ANGRY_SMG1;
|
|
if ( activity == ACT_RANGE_ATTACK_SHOTGUN_LOW )
|
|
return ACT_RANGE_ATTACK_SMG1_LOW;
|
|
|
|
return BaseClass::NPC_TranslateActivity( activity );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void CNPC_Citizen::HandleAnimEvent( animevent_t *pEvent )
|
|
{
|
|
if ( pEvent->event == AE_CITIZEN_GET_PACKAGE )
|
|
{
|
|
// Give the citizen a package
|
|
CBaseCombatWeapon *pWeapon = Weapon_Create( "weapon_citizenpackage" );
|
|
if ( pWeapon )
|
|
{
|
|
// If I have a name, make my weapon match it with "_weapon" appended
|
|
if ( GetEntityName() != NULL_STRING )
|
|
{
|
|
pWeapon->SetName( AllocPooledString(UTIL_VarArgs("%s_weapon", STRING(GetEntityName()) )) );
|
|
}
|
|
Weapon_Equip( pWeapon );
|
|
}
|
|
return;
|
|
}
|
|
else if ( pEvent->event == AE_CITIZEN_HEAL )
|
|
{
|
|
// Heal my target (if within range)
|
|
#if HL2_EPISODIC
|
|
if ( USE_EXPERIMENTAL_MEDIC_CODE() && IsMedic() )
|
|
{
|
|
CBaseCombatCharacter *pTarget = dynamic_cast<CBaseCombatCharacter *>( GetTarget() );
|
|
Assert(pTarget);
|
|
if ( pTarget )
|
|
{
|
|
m_flPlayerHealTime = gpGlobals->curtime + sk_citizen_heal_toss_player_delay.GetFloat();;
|
|
TossHealthKit( pTarget, Vector(48.0f, 0.0f, 0.0f) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Heal();
|
|
}
|
|
#else
|
|
Heal();
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
switch( pEvent->event )
|
|
{
|
|
case NPC_EVENT_LEFTFOOT:
|
|
{
|
|
EmitSound( "NPC_Citizen.FootstepLeft", pEvent->eventtime );
|
|
}
|
|
break;
|
|
|
|
case NPC_EVENT_RIGHTFOOT:
|
|
{
|
|
EmitSound( "NPC_Citizen.FootstepRight", pEvent->eventtime );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
BaseClass::HandleAnimEvent( pEvent );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void CNPC_Citizen::PickupItem( CBaseEntity *pItem )
|
|
{
|
|
Assert( pItem != NULL );
|
|
if( FClassnameIs( pItem, "item_healthkit" ) )
|
|
{
|
|
if ( TakeHealth( sk_healthkit.GetFloat(), DMG_GENERIC ) )
|
|
{
|
|
RemoveAllDecals();
|
|
UTIL_Remove( pItem );
|
|
}
|
|
}
|
|
else if( FClassnameIs( pItem, "item_healthvial" ) )
|
|
{
|
|
if ( TakeHealth( sk_healthvial.GetFloat(), DMG_GENERIC ) )
|
|
{
|
|
RemoveAllDecals();
|
|
UTIL_Remove( pItem );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DevMsg("Citizen doesn't know how to pick up %s!\n", pItem->GetClassname() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::IgnorePlayerPushing( void )
|
|
{
|
|
// If the NPC's on a func_tank that the player cannot man, ignore player pushing
|
|
if ( m_FuncTankBehavior.IsMounted() )
|
|
{
|
|
CFuncTank *pTank = m_FuncTankBehavior.GetFuncTank();
|
|
if ( pTank && !pTank->IsControllable() )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return a random expression for the specified state to play over
|
|
// the state's expression loop.
|
|
//-----------------------------------------------------------------------------
|
|
const char *CNPC_Citizen::SelectRandomExpressionForState( NPC_STATE state )
|
|
{
|
|
// Hacky remap of NPC states to expression states that we care about
|
|
int iExpressionState = 0;
|
|
switch ( state )
|
|
{
|
|
case NPC_STATE_IDLE:
|
|
iExpressionState = 0;
|
|
break;
|
|
|
|
case NPC_STATE_ALERT:
|
|
iExpressionState = 1;
|
|
break;
|
|
|
|
case NPC_STATE_COMBAT:
|
|
iExpressionState = 2;
|
|
break;
|
|
|
|
default:
|
|
// An NPC state we don't have expressions for
|
|
return NULL;
|
|
}
|
|
|
|
// Now pick the right one for our expression type
|
|
switch ( m_ExpressionType )
|
|
{
|
|
case CIT_EXP_SCARED:
|
|
{
|
|
int iRandom = RandomInt( 0, ARRAYSIZE(ScaredExpressions[iExpressionState].szExpressions)-1 );
|
|
return ScaredExpressions[iExpressionState].szExpressions[iRandom];
|
|
}
|
|
|
|
case CIT_EXP_NORMAL:
|
|
{
|
|
int iRandom = RandomInt( 0, ARRAYSIZE(NormalExpressions[iExpressionState].szExpressions)-1 );
|
|
return NormalExpressions[iExpressionState].szExpressions[iRandom];
|
|
}
|
|
|
|
case CIT_EXP_ANGRY:
|
|
{
|
|
int iRandom = RandomInt( 0, ARRAYSIZE(AngryExpressions[iExpressionState].szExpressions)-1 );
|
|
return AngryExpressions[iExpressionState].szExpressions[iRandom];
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::SimpleUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
|
{
|
|
// Under these conditions, citizens will refuse to go with the player.
|
|
// Robin: NPCs should always respond to +USE even if someone else has the semaphore.
|
|
m_bDontUseSemaphore = true;
|
|
|
|
// First, try to speak the +USE concept
|
|
if ( !SelectPlayerUseSpeech() )
|
|
{
|
|
if ( HasSpawnFlags(SF_CITIZEN_NOT_COMMANDABLE) || IRelationType( pActivator ) == D_NU )
|
|
{
|
|
// If I'm denying commander mode because a level designer has made that decision,
|
|
// then fire this output in case they've hooked it to an event.
|
|
m_OnDenyCommanderUse.FireOutput( this, this );
|
|
}
|
|
}
|
|
|
|
m_bDontUseSemaphore = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::OnBeginMoveAndShoot()
|
|
{
|
|
if ( BaseClass::OnBeginMoveAndShoot() )
|
|
{
|
|
if( m_iMySquadSlot == SQUAD_SLOT_ATTACK1 || m_iMySquadSlot == SQUAD_SLOT_ATTACK2 )
|
|
return true; // already have the slot I need
|
|
|
|
if( m_iMySquadSlot == SQUAD_SLOT_NONE && OccupyStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::OnEndMoveAndShoot()
|
|
{
|
|
VacateStrategySlot();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::LocateEnemySound()
|
|
{
|
|
#if 0
|
|
if ( !GetEnemy() )
|
|
return;
|
|
|
|
float flZDiff = GetLocalOrigin().z - GetEnemy()->GetLocalOrigin().z;
|
|
|
|
if( flZDiff < -128 )
|
|
{
|
|
EmitSound( "NPC_Citizen.UpThere" );
|
|
}
|
|
else if( flZDiff > 128 )
|
|
{
|
|
EmitSound( "NPC_Citizen.DownThere" );
|
|
}
|
|
else
|
|
{
|
|
EmitSound( "NPC_Citizen.OverHere" );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::IsManhackMeleeCombatant()
|
|
{
|
|
CBaseCombatWeapon *pWeapon = GetActiveWeapon();
|
|
CBaseEntity *pEnemy = GetEnemy();
|
|
return ( pEnemy && pWeapon && pEnemy->Classify() == CLASS_MANHACK && pWeapon->ClassMatches( "weapon_crowbar" ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the actual position the NPC wants to fire at when it's trying
|
|
// to hit it's current enemy.
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Citizen::GetActualShootPosition( const Vector &shootOrigin )
|
|
{
|
|
Vector vecTarget = BaseClass::GetActualShootPosition( shootOrigin );
|
|
|
|
CWeaponRPG *pRPG = dynamic_cast<CWeaponRPG*>(GetActiveWeapon());
|
|
// If we're firing an RPG at a gunship, aim off to it's side, because we'll auger towards it.
|
|
if ( pRPG && GetEnemy() )
|
|
{
|
|
if ( FClassnameIs( GetEnemy(), "npc_combinegunship" ) )
|
|
{
|
|
Vector vecRight;
|
|
GetVectors( NULL, &vecRight, NULL );
|
|
// Random height
|
|
vecRight.z = 0;
|
|
|
|
// Find a clear shot by checking for clear shots around it
|
|
float flShotOffsets[] =
|
|
{
|
|
512,
|
|
-512,
|
|
128,
|
|
-128
|
|
};
|
|
for ( int i = 0; i < ARRAYSIZE(flShotOffsets); i++ )
|
|
{
|
|
Vector vecTest = vecTarget + (vecRight * flShotOffsets[i]);
|
|
// Add some random height to it
|
|
vecTest.z += RandomFloat( -512, 512 );
|
|
trace_t tr;
|
|
AI_TraceLine( shootOrigin, vecTest, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
|
|
|
|
// If we can see the point, it's a clear shot
|
|
if ( tr.fraction == 1.0 && tr.m_pEnt != GetEnemy() )
|
|
{
|
|
pRPG->SetNPCLaserPosition( vecTest );
|
|
return vecTest;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pRPG->SetNPCLaserPosition( vecTarget );
|
|
}
|
|
|
|
}
|
|
|
|
return vecTarget;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::OnChangeActiveWeapon( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon )
|
|
{
|
|
if ( pNewWeapon )
|
|
{
|
|
GetShotRegulator()->SetParameters( pNewWeapon->GetMinBurst(), pNewWeapon->GetMaxBurst(), pNewWeapon->GetMinRestTime(), pNewWeapon->GetMaxRestTime() );
|
|
}
|
|
BaseClass::OnChangeActiveWeapon( pOldWeapon, pNewWeapon );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
#define SHOTGUN_DEFER_SEARCH_TIME 20.0f
|
|
#define OTHER_DEFER_SEARCH_TIME FLT_MAX
|
|
bool CNPC_Citizen::ShouldLookForBetterWeapon()
|
|
{
|
|
if ( BaseClass::ShouldLookForBetterWeapon() )
|
|
{
|
|
if ( IsInPlayerSquad() && (GetActiveWeapon()&&IsMoving()) && ( m_FollowBehavior.GetFollowTarget() && m_FollowBehavior.GetFollowTarget()->IsPlayer() ) )
|
|
{
|
|
// For citizens in the player squad, you must be unarmed, or standing still (if armed) in order to
|
|
// divert attention to looking for a new weapon.
|
|
return false;
|
|
}
|
|
|
|
if ( GetActiveWeapon() && IsMoving() )
|
|
return false;
|
|
|
|
if ( GlobalEntity_GetState("gordon_precriminal") == GLOBAL_ON )
|
|
{
|
|
// This stops the NPC looking altogether.
|
|
m_flNextWeaponSearchTime = FLT_MAX;
|
|
return false;
|
|
}
|
|
|
|
#ifdef DBGFLAG_ASSERT
|
|
// Cached off to make sure you change this if you ask the code to defer.
|
|
float flOldWeaponSearchTime = m_flNextWeaponSearchTime;
|
|
#endif
|
|
|
|
CBaseCombatWeapon *pWeapon = GetActiveWeapon();
|
|
if( pWeapon )
|
|
{
|
|
bool bDefer = false;
|
|
|
|
if( FClassnameIs( pWeapon, "weapon_ar2" ) )
|
|
{
|
|
// Content to keep this weapon forever
|
|
m_flNextWeaponSearchTime = OTHER_DEFER_SEARCH_TIME;
|
|
bDefer = true;
|
|
}
|
|
else if( FClassnameIs( pWeapon, "weapon_rpg" ) )
|
|
{
|
|
// Content to keep this weapon forever
|
|
m_flNextWeaponSearchTime = OTHER_DEFER_SEARCH_TIME;
|
|
bDefer = true;
|
|
}
|
|
else if( FClassnameIs( pWeapon, "weapon_shotgun" ) )
|
|
{
|
|
// Shotgunners do not defer their weapon search indefinitely.
|
|
// If more than one citizen in the squad has a shotgun, we force
|
|
// some of them to trade for another weapon.
|
|
if( NumWeaponsInSquad("weapon_shotgun") > 1 )
|
|
{
|
|
// Check for another weapon now. If I don't find one, this code will
|
|
// retry in 2 seconds or so.
|
|
bDefer = false;
|
|
}
|
|
else
|
|
{
|
|
// I'm the only shotgunner in the group right now, so I'll check
|
|
// again in 3 0seconds or so. This code attempts to distribute
|
|
// the desire to reduce shotguns amongst squadmates so that all
|
|
// shotgunners do not discard their weapons when they suddenly realize
|
|
// the squad has too many.
|
|
if( random->RandomInt( 0, 1 ) == 0 )
|
|
{
|
|
m_flNextWeaponSearchTime = gpGlobals->curtime + SHOTGUN_DEFER_SEARCH_TIME;
|
|
}
|
|
else
|
|
{
|
|
m_flNextWeaponSearchTime = gpGlobals->curtime + SHOTGUN_DEFER_SEARCH_TIME + 10.0f;
|
|
}
|
|
|
|
bDefer = true;
|
|
}
|
|
}
|
|
|
|
if( bDefer )
|
|
{
|
|
// I'm happy with my current weapon. Don't search now.
|
|
// If you ask the code to defer, you must have set m_flNextWeaponSearchTime to when
|
|
// you next want to try to search.
|
|
Assert( m_flNextWeaponSearchTime != flOldWeaponSearchTime );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::OnTakeDamage_Alive( const CTakeDamageInfo &info )
|
|
{
|
|
if( (info.GetDamageType() & DMG_BURN) && (info.GetDamageType() & DMG_DIRECT) )
|
|
{
|
|
#define CITIZEN_SCORCH_RATE 6
|
|
#define CITIZEN_SCORCH_FLOOR 75
|
|
|
|
Scorch( CITIZEN_SCORCH_RATE, CITIZEN_SCORCH_FLOOR );
|
|
}
|
|
|
|
CTakeDamageInfo newInfo = info;
|
|
|
|
if( IsInSquad() && (info.GetDamageType() & DMG_BLAST) && info.GetInflictor() )
|
|
{
|
|
if( npc_citizen_explosive_resist.GetBool() )
|
|
{
|
|
// Blast damage. If this kills a squad member, give the
|
|
// remaining citizens a resistance bonus to this inflictor
|
|
// to try to avoid having the entire squad wiped out by a
|
|
// single explosion.
|
|
if( m_pSquad->IsSquadInflictor( info.GetInflictor() ) )
|
|
{
|
|
newInfo.ScaleDamage( 0.5 );
|
|
}
|
|
else
|
|
{
|
|
// If this blast is going to kill me, designate the inflictor
|
|
// so that the rest of the squad can enjoy a damage resist.
|
|
if( info.GetDamage() >= GetHealth() )
|
|
{
|
|
m_pSquad->SetSquadInflictor( info.GetInflictor() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return BaseClass::OnTakeDamage_Alive( newInfo );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::IsCommandable()
|
|
{
|
|
return ( !HasSpawnFlags(SF_CITIZEN_NOT_COMMANDABLE) && IsInPlayerSquad() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::IsPlayerAlly( CBasePlayer *pPlayer )
|
|
{
|
|
if ( Classify() == CLASS_CITIZEN_PASSIVE && GlobalEntity_GetState("gordon_precriminal") == GLOBAL_ON )
|
|
{
|
|
// Robin: Citizens use friendly speech semaphore in trainstation
|
|
return true;
|
|
}
|
|
|
|
return BaseClass::IsPlayerAlly( pPlayer );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::CanJoinPlayerSquad()
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return false;
|
|
|
|
if ( m_NPCState == NPC_STATE_SCRIPT || m_NPCState == NPC_STATE_PRONE )
|
|
return false;
|
|
|
|
if ( HasSpawnFlags(SF_CITIZEN_NOT_COMMANDABLE) )
|
|
return false;
|
|
|
|
if ( IsInAScript() )
|
|
return false;
|
|
|
|
// Don't bother people who don't want to be bothered
|
|
if ( !CanBeUsedAsAFriend() )
|
|
return false;
|
|
|
|
if ( IRelationType( UTIL_GetLocalPlayer() ) != D_LI )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::WasInPlayerSquad()
|
|
{
|
|
return m_bWasInPlayerSquad;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::HaveCommandGoal() const
|
|
{
|
|
if (GetCommandGoal() != vec3_invalid)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::IsCommandMoving()
|
|
{
|
|
if ( AI_IsSinglePlayer() && IsInPlayerSquad() )
|
|
{
|
|
if ( m_FollowBehavior.GetFollowTarget() == UTIL_GetLocalPlayer() ||
|
|
IsFollowingCommandPoint() )
|
|
{
|
|
return ( m_FollowBehavior.IsMovingToFollowTarget() );
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldAutoSummon()
|
|
{
|
|
if ( !AI_IsSinglePlayer() || !IsFollowingCommandPoint() || !IsInPlayerSquad() )
|
|
return false;
|
|
|
|
CHL2_Player *pPlayer = (CHL2_Player *)UTIL_GetLocalPlayer();
|
|
|
|
float distMovedSq = ( pPlayer->GetAbsOrigin() - m_vAutoSummonAnchor ).LengthSqr();
|
|
float moveTolerance = player_squad_autosummon_move_tolerance.GetFloat() * 12;
|
|
const Vector &vCommandGoal = GetCommandGoal();
|
|
|
|
if ( distMovedSq < Square(moveTolerance * 10) && (GetAbsOrigin() - vCommandGoal).LengthSqr() > Square(10*12) && IsCommandMoving() )
|
|
{
|
|
m_AutoSummonTimer.Set( player_squad_autosummon_time.GetFloat() );
|
|
if ( player_squad_autosummon_debug.GetBool() )
|
|
DevMsg( "Waiting for arrival before initiating autosummon logic\n");
|
|
}
|
|
else if ( m_AutoSummonTimer.Expired() )
|
|
{
|
|
bool bSetFollow = false;
|
|
bool bTestEnemies = true;
|
|
|
|
// Auto summon unconditionally if a significant amount of time has passed
|
|
if ( gpGlobals->curtime - m_AutoSummonTimer.GetNext() > player_squad_autosummon_time.GetFloat() * 2 )
|
|
{
|
|
bSetFollow = true;
|
|
if ( player_squad_autosummon_debug.GetBool() )
|
|
DevMsg( "Auto summoning squad: long time (%f)\n", ( gpGlobals->curtime - m_AutoSummonTimer.GetNext() ) + player_squad_autosummon_time.GetFloat() );
|
|
}
|
|
|
|
// Player must move for autosummon
|
|
if ( distMovedSq > Square(12) )
|
|
{
|
|
bool bCommandPointIsVisible = pPlayer->FVisible( vCommandGoal + pPlayer->GetViewOffset() );
|
|
|
|
// Auto summon if the player is close by the command point
|
|
if ( !bSetFollow && bCommandPointIsVisible && distMovedSq > Square(24) )
|
|
{
|
|
float closenessTolerance = player_squad_autosummon_player_tolerance.GetFloat() * 12;
|
|
if ( (pPlayer->GetAbsOrigin() - vCommandGoal).LengthSqr() < Square( closenessTolerance ) &&
|
|
((m_vAutoSummonAnchor - vCommandGoal).LengthSqr() > Square( closenessTolerance )) )
|
|
{
|
|
bSetFollow = true;
|
|
if ( player_squad_autosummon_debug.GetBool() )
|
|
DevMsg( "Auto summoning squad: player close to command point (%f)\n", (GetAbsOrigin() - vCommandGoal).Length() );
|
|
}
|
|
}
|
|
|
|
// Auto summon if moved a moderate distance and can't see command point, or moved a great distance
|
|
if ( !bSetFollow )
|
|
{
|
|
if ( distMovedSq > Square( moveTolerance * 2 ) )
|
|
{
|
|
bSetFollow = true;
|
|
bTestEnemies = ( distMovedSq < Square( moveTolerance * 10 ) );
|
|
if ( player_squad_autosummon_debug.GetBool() )
|
|
DevMsg( "Auto summoning squad: player very far from anchor (%f)\n", sqrt(distMovedSq) );
|
|
}
|
|
else if ( distMovedSq > Square( moveTolerance ) )
|
|
{
|
|
if ( !bCommandPointIsVisible )
|
|
{
|
|
bSetFollow = true;
|
|
if ( player_squad_autosummon_debug.GetBool() )
|
|
DevMsg( "Auto summoning squad: player far from anchor (%f)\n", sqrt(distMovedSq) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Auto summon only if there are no readily apparent enemies
|
|
if ( bSetFollow && bTestEnemies )
|
|
{
|
|
for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )
|
|
{
|
|
CAI_BaseNPC *pNpc = g_AI_Manager.AccessAIs()[i];
|
|
float timeSinceCombatTolerance = player_squad_autosummon_time_after_combat.GetFloat();
|
|
|
|
if ( pNpc->IsInPlayerSquad() )
|
|
{
|
|
if ( gpGlobals->curtime - pNpc->GetLastAttackTime() > timeSinceCombatTolerance ||
|
|
gpGlobals->curtime - pNpc->GetLastDamageTime() > timeSinceCombatTolerance )
|
|
continue;
|
|
}
|
|
else if ( pNpc->GetEnemy() )
|
|
{
|
|
CBaseEntity *pNpcEnemy = pNpc->GetEnemy();
|
|
if ( !IsSniper( pNpc ) && ( gpGlobals->curtime - pNpc->GetEnemyLastTimeSeen() ) > timeSinceCombatTolerance )
|
|
continue;
|
|
|
|
if ( pNpcEnemy == pPlayer )
|
|
{
|
|
if ( pNpc->CanBeAnEnemyOf( pPlayer ) )
|
|
{
|
|
bSetFollow = false;
|
|
break;
|
|
}
|
|
}
|
|
else if ( pNpcEnemy->IsNPC() && ( pNpcEnemy->MyNPCPointer()->GetSquad() == GetSquad() || pNpcEnemy->Classify() == CLASS_PLAYER_ALLY_VITAL ) )
|
|
{
|
|
if ( pNpc->CanBeAnEnemyOf( this ) )
|
|
{
|
|
bSetFollow = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( !bSetFollow && player_squad_autosummon_debug.GetBool() )
|
|
DevMsg( "Auto summon REVOKED: Combat recent \n");
|
|
}
|
|
|
|
return bSetFollow;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is this entity something that the citizen should interact with (return true)
|
|
// or something that he should try to get close to (return false)
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::IsValidCommandTarget( CBaseEntity *pTarget )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::SpeakCommandResponse( AIConcept_t concept, const char *modifiers )
|
|
{
|
|
return SpeakIfAllowed( concept,
|
|
CFmtStr( "numselected:%d,"
|
|
"useradio:%d%s",
|
|
( GetSquad() ) ? GetSquad()->NumMembers() : 1,
|
|
ShouldSpeakRadio( AI_GetSinglePlayer() ),
|
|
( modifiers ) ? CFmtStr(",%s", modifiers).operator const char *() : "" ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: return TRUE if the commander mode should try to give this order
|
|
// to more people. return FALSE otherwise. For instance, we don't
|
|
// try to send all 3 selectedcitizens to pick up the same gun.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::TargetOrder( CBaseEntity *pTarget, CAI_BaseNPC **Allies, int numAllies )
|
|
{
|
|
if ( pTarget->IsPlayer() )
|
|
{
|
|
// I'm the target! Toggle follow!
|
|
if( m_FollowBehavior.GetFollowTarget() != pTarget )
|
|
{
|
|
ClearFollowTarget();
|
|
SetCommandGoal( vec3_invalid );
|
|
|
|
// Turn follow on!
|
|
m_AssaultBehavior.Disable();
|
|
m_FollowBehavior.SetFollowTarget( pTarget );
|
|
m_FollowBehavior.SetParameters( AIF_SIMPLE );
|
|
SpeakCommandResponse( TLK_STARTFOLLOW );
|
|
|
|
m_OnFollowOrder.FireOutput( this, this );
|
|
}
|
|
else if ( m_FollowBehavior.GetFollowTarget() == pTarget )
|
|
{
|
|
// Stop following.
|
|
m_FollowBehavior.SetFollowTarget( NULL );
|
|
SpeakCommandResponse( TLK_STOPFOLLOW );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Turn off following before processing a move order.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::MoveOrder( const Vector &vecDest, CAI_BaseNPC **Allies, int numAllies )
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return;
|
|
|
|
if( hl2_episodic.GetBool() && m_iszDenyCommandConcept != NULL_STRING )
|
|
{
|
|
SpeakCommandResponse( STRING(m_iszDenyCommandConcept) );
|
|
return;
|
|
}
|
|
|
|
CHL2_Player *pPlayer = (CHL2_Player *)UTIL_GetLocalPlayer();
|
|
|
|
m_AutoSummonTimer.Set( player_squad_autosummon_time.GetFloat() );
|
|
m_vAutoSummonAnchor = pPlayer->GetAbsOrigin();
|
|
|
|
if( m_StandoffBehavior.IsRunning() )
|
|
{
|
|
m_StandoffBehavior.SetStandoffGoalPosition( vecDest );
|
|
}
|
|
|
|
// If in assault, cancel and move.
|
|
if( m_AssaultBehavior.HasHitRallyPoint() && !m_AssaultBehavior.HasHitAssaultPoint() )
|
|
{
|
|
m_AssaultBehavior.Disable();
|
|
ClearSchedule( "Moving from rally point to assault point" );
|
|
}
|
|
|
|
bool spoke = false;
|
|
|
|
CAI_BaseNPC *pClosest = NULL;
|
|
float closestDistSq = FLT_MAX;
|
|
|
|
for( int i = 0 ; i < numAllies ; i++ )
|
|
{
|
|
if( Allies[i]->IsInPlayerSquad() )
|
|
{
|
|
Assert( Allies[i]->IsCommandable() );
|
|
float distSq = ( pPlayer->GetAbsOrigin() - Allies[i]->GetAbsOrigin() ).LengthSqr();
|
|
if( distSq < closestDistSq )
|
|
{
|
|
pClosest = Allies[i];
|
|
closestDistSq = distSq;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_FollowBehavior.GetFollowTarget() && !IsFollowingCommandPoint() )
|
|
{
|
|
ClearFollowTarget();
|
|
#if 0
|
|
if ( ( pPlayer->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr() < Square( 180 ) &&
|
|
( ( vecDest - pPlayer->GetAbsOrigin() ).LengthSqr() < Square( 120 ) ||
|
|
( vecDest - GetAbsOrigin() ).LengthSqr() < Square( 120 ) ) )
|
|
{
|
|
if ( pClosest == this )
|
|
SpeakIfAllowed( TLK_STOPFOLLOW );
|
|
spoke = true;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if ( !spoke && pClosest == this )
|
|
{
|
|
float destDistToPlayer = ( vecDest - pPlayer->GetAbsOrigin() ).Length();
|
|
float destDistToClosest = ( vecDest - GetAbsOrigin() ).Length();
|
|
CFmtStr modifiers( "commandpoint_dist_to_player:%.0f,"
|
|
"commandpoint_dist_to_npc:%.0f",
|
|
destDistToPlayer,
|
|
destDistToClosest );
|
|
|
|
SpeakCommandResponse( TLK_COMMANDED, modifiers );
|
|
}
|
|
|
|
m_OnStationOrder.FireOutput( this, this );
|
|
|
|
BaseClass::MoveOrder( vecDest, Allies, numAllies );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::OnMoveOrder()
|
|
{
|
|
SetReadinessLevel( AIRL_STIMULATED, false, false );
|
|
BaseClass::OnMoveOrder();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::CommanderUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
|
{
|
|
m_OnPlayerUse.FireOutput( pActivator, pCaller );
|
|
|
|
// Under these conditions, citizens will refuse to go with the player.
|
|
// Robin: NPCs should always respond to +USE even if someone else has the semaphore.
|
|
if ( !AI_IsSinglePlayer() || !CanJoinPlayerSquad() )
|
|
{
|
|
SimpleUse( pActivator, pCaller, useType, value );
|
|
return;
|
|
}
|
|
|
|
if ( pActivator == UTIL_GetLocalPlayer() )
|
|
{
|
|
// Don't say hi after you've been addressed by the player
|
|
SetSpokeConcept( TLK_HELLO, NULL );
|
|
|
|
if ( npc_citizen_auto_player_squad_allow_use.GetBool() )
|
|
{
|
|
if ( !ShouldAutosquad() )
|
|
TogglePlayerSquadState();
|
|
else if ( !IsInPlayerSquad() && npc_citizen_auto_player_squad_allow_use.GetBool() )
|
|
AddToPlayerSquad();
|
|
}
|
|
else if ( GetCurSchedule() && ConditionInterruptsCurSchedule( COND_IDLE_INTERRUPT ) )
|
|
{
|
|
if ( SpeakIfAllowed( TLK_QUESTION, NULL, true ) )
|
|
{
|
|
if ( random->RandomInt( 1, 4 ) < 4 )
|
|
{
|
|
CBaseEntity *pRespondant = FindSpeechTarget( AIST_NPCS );
|
|
if ( pRespondant )
|
|
{
|
|
g_EventQueue.AddEvent( pRespondant, "SpeakIdleResponse", ( GetTimeSpeechComplete() - gpGlobals->curtime ) + .2, this, this );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldSpeakRadio( CBaseEntity *pListener )
|
|
{
|
|
if ( !pListener )
|
|
return false;
|
|
|
|
const float radioRange = 384 * 384;
|
|
Vector vecDiff;
|
|
|
|
vecDiff = WorldSpaceCenter() - pListener->WorldSpaceCenter();
|
|
|
|
if( vecDiff.LengthSqr() > radioRange )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::OnMoveToCommandGoalFailed()
|
|
{
|
|
// Clear the goal.
|
|
SetCommandGoal( vec3_invalid );
|
|
|
|
// Announce failure.
|
|
SpeakCommandResponse( TLK_COMMAND_FAILED );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::AddToPlayerSquad()
|
|
{
|
|
Assert( !IsInPlayerSquad() );
|
|
|
|
AddToSquad( AllocPooledString(PLAYER_SQUADNAME) );
|
|
m_hSavedFollowGoalEnt = m_FollowBehavior.GetFollowGoal();
|
|
m_FollowBehavior.SetFollowGoalDirect( NULL );
|
|
|
|
FixupPlayerSquad();
|
|
|
|
SetCondition( COND_PLAYER_ADDED_TO_SQUAD );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::RemoveFromPlayerSquad()
|
|
{
|
|
Assert( IsInPlayerSquad() );
|
|
|
|
ClearFollowTarget();
|
|
ClearCommandGoal();
|
|
if ( m_iszOriginalSquad != NULL_STRING && strcmp( STRING( m_iszOriginalSquad ), PLAYER_SQUADNAME ) != 0 )
|
|
AddToSquad( m_iszOriginalSquad );
|
|
else
|
|
RemoveFromSquad();
|
|
|
|
if ( m_hSavedFollowGoalEnt )
|
|
m_FollowBehavior.SetFollowGoal( m_hSavedFollowGoalEnt );
|
|
|
|
SetCondition( COND_PLAYER_REMOVED_FROM_SQUAD );
|
|
|
|
// Don't evaluate the player squad for 2 seconds.
|
|
gm_PlayerSquadEvaluateTimer.Set( 2.0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::TogglePlayerSquadState()
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return;
|
|
|
|
if ( !IsInPlayerSquad() )
|
|
{
|
|
AddToPlayerSquad();
|
|
|
|
if ( HaveCommandGoal() )
|
|
{
|
|
SpeakCommandResponse( TLK_COMMANDED );
|
|
}
|
|
else if ( m_FollowBehavior.GetFollowTarget() == UTIL_GetLocalPlayer() )
|
|
{
|
|
SpeakCommandResponse( TLK_STARTFOLLOW );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SpeakCommandResponse( TLK_STOPFOLLOW );
|
|
RemoveFromPlayerSquad();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
struct SquadCandidate_t
|
|
{
|
|
CNPC_Citizen *pCitizen;
|
|
bool bIsInSquad;
|
|
float distSq;
|
|
int iSquadIndex;
|
|
};
|
|
|
|
void CNPC_Citizen::UpdatePlayerSquad()
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return;
|
|
|
|
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
|
|
if ( ( pPlayer->GetAbsOrigin().AsVector2D() - GetAbsOrigin().AsVector2D() ).LengthSqr() < Square(20*12) )
|
|
m_flTimeLastCloseToPlayer = gpGlobals->curtime;
|
|
|
|
if ( !gm_PlayerSquadEvaluateTimer.Expired() )
|
|
return;
|
|
|
|
gm_PlayerSquadEvaluateTimer.Set( 2.0 );
|
|
|
|
// Remove stragglers
|
|
CAI_Squad *pPlayerSquad = g_AI_SquadManager.FindSquad( MAKE_STRING( PLAYER_SQUADNAME ) );
|
|
if ( pPlayerSquad )
|
|
{
|
|
CUtlVectorFixed<CNPC_Citizen *, MAX_PLAYER_SQUAD> squadMembersToRemove;
|
|
AISquadIter_t iter;
|
|
|
|
for ( CAI_BaseNPC *pPlayerSquadMember = pPlayerSquad->GetFirstMember(&iter); pPlayerSquadMember; pPlayerSquadMember = pPlayerSquad->GetNextMember(&iter) )
|
|
{
|
|
if ( pPlayerSquadMember->GetClassname() != GetClassname() )
|
|
continue;
|
|
|
|
CNPC_Citizen *pCitizen = assert_cast<CNPC_Citizen *>(pPlayerSquadMember);
|
|
|
|
if ( !pCitizen->m_bNeverLeavePlayerSquad &&
|
|
pCitizen->m_FollowBehavior.GetFollowTarget() &&
|
|
!pCitizen->m_FollowBehavior.FollowTargetVisible() &&
|
|
pCitizen->m_FollowBehavior.GetNumFailedFollowAttempts() > 0 &&
|
|
gpGlobals->curtime - pCitizen->m_FollowBehavior.GetTimeFailFollowStarted() > 20 &&
|
|
( fabsf(( pCitizen->m_FollowBehavior.GetFollowTarget()->GetAbsOrigin().z - pCitizen->GetAbsOrigin().z )) > 196 ||
|
|
( pCitizen->m_FollowBehavior.GetFollowTarget()->GetAbsOrigin().AsVector2D() - pCitizen->GetAbsOrigin().AsVector2D() ).LengthSqr() > Square(50*12) ) )
|
|
{
|
|
if ( DebuggingCommanderMode() )
|
|
{
|
|
DevMsg( "Player follower is lost (%d, %f, %d)\n",
|
|
pCitizen->m_FollowBehavior.GetNumFailedFollowAttempts(),
|
|
gpGlobals->curtime - pCitizen->m_FollowBehavior.GetTimeFailFollowStarted(),
|
|
(int)((pCitizen->m_FollowBehavior.GetFollowTarget()->GetAbsOrigin().AsVector2D() - pCitizen->GetAbsOrigin().AsVector2D() ).Length()) );
|
|
}
|
|
|
|
squadMembersToRemove.AddToTail( pCitizen );
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < squadMembersToRemove.Count(); i++ )
|
|
{
|
|
squadMembersToRemove[i]->RemoveFromPlayerSquad();
|
|
}
|
|
}
|
|
|
|
// Autosquadding
|
|
const float JOIN_PLAYER_XY_TOLERANCE_SQ = Square(36*12);
|
|
const float UNCONDITIONAL_JOIN_PLAYER_XY_TOLERANCE_SQ = Square(12*12);
|
|
const float UNCONDITIONAL_JOIN_PLAYER_Z_TOLERANCE = 5*12;
|
|
const float SECOND_TIER_JOIN_DIST_SQ = Square(48*12);
|
|
if ( pPlayer && ShouldAutosquad() && !(pPlayer->GetFlags() & FL_NOTARGET ) && pPlayer->IsAlive() )
|
|
{
|
|
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
|
|
CUtlVector<SquadCandidate_t> candidates;
|
|
const Vector &vPlayerPos = pPlayer->GetAbsOrigin();
|
|
bool bFoundNewGuy = false;
|
|
int i;
|
|
|
|
for ( i = 0; i < g_AI_Manager.NumAIs(); i++ )
|
|
{
|
|
if ( ppAIs[i]->GetState() == NPC_STATE_DEAD )
|
|
continue;
|
|
|
|
if ( ppAIs[i]->GetClassname() != GetClassname() )
|
|
continue;
|
|
|
|
CNPC_Citizen *pCitizen = assert_cast<CNPC_Citizen *>(ppAIs[i]);
|
|
int iNew;
|
|
|
|
if ( pCitizen->IsInPlayerSquad() )
|
|
{
|
|
iNew = candidates.AddToTail();
|
|
candidates[iNew].pCitizen = pCitizen;
|
|
candidates[iNew].bIsInSquad = true;
|
|
candidates[iNew].distSq = 0;
|
|
candidates[iNew].iSquadIndex = pCitizen->GetSquad()->GetSquadIndex( pCitizen );
|
|
}
|
|
else
|
|
{
|
|
float distSq = (vPlayerPos.AsVector2D() - pCitizen->GetAbsOrigin().AsVector2D()).LengthSqr();
|
|
if ( distSq > JOIN_PLAYER_XY_TOLERANCE_SQ &&
|
|
( pCitizen->m_flTimeJoinedPlayerSquad == 0 || gpGlobals->curtime - pCitizen->m_flTimeJoinedPlayerSquad > 60.0 ) &&
|
|
( pCitizen->m_flTimeLastCloseToPlayer == 0 || gpGlobals->curtime - pCitizen->m_flTimeLastCloseToPlayer > 15.0 ) )
|
|
continue;
|
|
|
|
if ( !pCitizen->CanJoinPlayerSquad() )
|
|
continue;
|
|
|
|
bool bShouldAdd = false;
|
|
|
|
if ( pCitizen->HasCondition( COND_SEE_PLAYER ) )
|
|
bShouldAdd = true;
|
|
else
|
|
{
|
|
bool bPlayerVisible = pCitizen->FVisible( pPlayer );
|
|
if ( bPlayerVisible )
|
|
{
|
|
if ( pCitizen->HasCondition( COND_HEAR_PLAYER ) )
|
|
bShouldAdd = true;
|
|
else if ( distSq < UNCONDITIONAL_JOIN_PLAYER_XY_TOLERANCE_SQ && fabsf(vPlayerPos.z - pCitizen->GetAbsOrigin().z) < UNCONDITIONAL_JOIN_PLAYER_Z_TOLERANCE )
|
|
bShouldAdd = true;
|
|
}
|
|
}
|
|
|
|
if ( bShouldAdd )
|
|
{
|
|
// @TODO (toml 05-25-04): probably everyone in a squad should be a candidate if one of them sees the player
|
|
AI_Waypoint_t *pPathToPlayer = pCitizen->GetPathfinder()->BuildRoute( pCitizen->GetAbsOrigin(), vPlayerPos, pPlayer, 5*12, NAV_NONE, true );
|
|
GetPathfinder()->UnlockRouteNodes( pPathToPlayer );
|
|
|
|
if ( !pPathToPlayer )
|
|
continue;
|
|
|
|
CAI_Path tempPath;
|
|
tempPath.SetWaypoints( pPathToPlayer ); // path object will delete waypoints
|
|
|
|
iNew = candidates.AddToTail();
|
|
candidates[iNew].pCitizen = pCitizen;
|
|
candidates[iNew].bIsInSquad = false;
|
|
candidates[iNew].distSq = distSq;
|
|
candidates[iNew].iSquadIndex = -1;
|
|
|
|
bFoundNewGuy = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bFoundNewGuy )
|
|
{
|
|
// Look for second order guys
|
|
int initialCount = candidates.Count();
|
|
for ( i = 0; i < initialCount; i++ )
|
|
candidates[i].pCitizen->AddSpawnFlags( SF_CITIZEN_NOT_COMMANDABLE ); // Prevents double-add
|
|
for ( i = 0; i < initialCount; i++ )
|
|
{
|
|
if ( candidates[i].iSquadIndex == -1 )
|
|
{
|
|
for ( int j = 0; j < g_AI_Manager.NumAIs(); j++ )
|
|
{
|
|
if ( ppAIs[j]->GetState() == NPC_STATE_DEAD )
|
|
continue;
|
|
|
|
if ( ppAIs[j]->GetClassname() != GetClassname() )
|
|
continue;
|
|
|
|
if ( ppAIs[j]->HasSpawnFlags( SF_CITIZEN_NOT_COMMANDABLE ) )
|
|
continue;
|
|
|
|
CNPC_Citizen *pCitizen = assert_cast<CNPC_Citizen *>(ppAIs[j]);
|
|
|
|
float distSq = (vPlayerPos - pCitizen->GetAbsOrigin()).Length2DSqr();
|
|
if ( distSq > JOIN_PLAYER_XY_TOLERANCE_SQ )
|
|
continue;
|
|
|
|
distSq = (candidates[i].pCitizen->GetAbsOrigin() - pCitizen->GetAbsOrigin()).Length2DSqr();
|
|
if ( distSq > SECOND_TIER_JOIN_DIST_SQ )
|
|
continue;
|
|
|
|
if ( !pCitizen->CanJoinPlayerSquad() )
|
|
continue;
|
|
|
|
if ( !pCitizen->FVisible( pPlayer ) )
|
|
continue;
|
|
|
|
int iNew = candidates.AddToTail();
|
|
candidates[iNew].pCitizen = pCitizen;
|
|
candidates[iNew].bIsInSquad = false;
|
|
candidates[iNew].distSq = distSq;
|
|
candidates[iNew].iSquadIndex = -1;
|
|
pCitizen->AddSpawnFlags( SF_CITIZEN_NOT_COMMANDABLE ); // Prevents double-add
|
|
}
|
|
}
|
|
}
|
|
for ( i = 0; i < candidates.Count(); i++ )
|
|
candidates[i].pCitizen->RemoveSpawnFlags( SF_CITIZEN_NOT_COMMANDABLE );
|
|
|
|
if ( candidates.Count() > MAX_PLAYER_SQUAD )
|
|
{
|
|
candidates.Sort( PlayerSquadCandidateSortFunc );
|
|
|
|
for ( i = MAX_PLAYER_SQUAD; i < candidates.Count(); i++ )
|
|
{
|
|
if ( candidates[i].pCitizen->IsInPlayerSquad() )
|
|
{
|
|
candidates[i].pCitizen->RemoveFromPlayerSquad();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( candidates.Count() )
|
|
{
|
|
CNPC_Citizen *pClosest = NULL;
|
|
float closestDistSq = FLT_MAX;
|
|
int nJoined = 0;
|
|
|
|
for ( i = 0; i < candidates.Count() && i < MAX_PLAYER_SQUAD; i++ )
|
|
{
|
|
if ( !candidates[i].pCitizen->IsInPlayerSquad() )
|
|
{
|
|
candidates[i].pCitizen->AddToPlayerSquad();
|
|
nJoined++;
|
|
|
|
if ( candidates[i].distSq < closestDistSq )
|
|
{
|
|
pClosest = candidates[i].pCitizen;
|
|
closestDistSq = candidates[i].distSq;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pClosest )
|
|
{
|
|
if ( !pClosest->SpokeConcept( TLK_JOINPLAYER ) )
|
|
{
|
|
pClosest->SpeakCommandResponse( TLK_JOINPLAYER, CFmtStr( "numjoining:%d", nJoined ) );
|
|
}
|
|
else
|
|
{
|
|
pClosest->SpeakCommandResponse( TLK_STARTFOLLOW );
|
|
}
|
|
|
|
for ( i = 0; i < candidates.Count() && i < MAX_PLAYER_SQUAD; i++ )
|
|
{
|
|
candidates[i].pCitizen->SetSpokeConcept( TLK_JOINPLAYER, NULL );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::PlayerSquadCandidateSortFunc( const SquadCandidate_t *pLeft, const SquadCandidate_t *pRight )
|
|
{
|
|
// "Bigger" means less approprate
|
|
CNPC_Citizen *pLeftCitizen = pLeft->pCitizen;
|
|
CNPC_Citizen *pRightCitizen = pRight->pCitizen;
|
|
|
|
// Medics are better than anyone
|
|
if ( pLeftCitizen->IsMedic() && !pRightCitizen->IsMedic() )
|
|
return -1;
|
|
|
|
if ( !pLeftCitizen->IsMedic() && pRightCitizen->IsMedic() )
|
|
return 1;
|
|
|
|
CBaseCombatWeapon *pLeftWeapon = pLeftCitizen->GetActiveWeapon();
|
|
CBaseCombatWeapon *pRightWeapon = pRightCitizen->GetActiveWeapon();
|
|
|
|
// People with weapons are better than those without
|
|
if ( pLeftWeapon && !pRightWeapon )
|
|
return -1;
|
|
|
|
if ( !pLeftWeapon && pRightWeapon )
|
|
return 1;
|
|
|
|
// Existing squad members are better than non-members
|
|
if ( pLeft->bIsInSquad && !pRight->bIsInSquad )
|
|
return -1;
|
|
|
|
if ( !pLeft->bIsInSquad && pRight->bIsInSquad )
|
|
return 1;
|
|
|
|
// New squad members are better than older ones
|
|
if ( pLeft->bIsInSquad && pRight->bIsInSquad )
|
|
return pRight->iSquadIndex - pLeft->iSquadIndex;
|
|
|
|
// Finally, just take the closer
|
|
return (int)(pRight->distSq - pLeft->distSq);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::FixupPlayerSquad()
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return;
|
|
|
|
m_flTimeJoinedPlayerSquad = gpGlobals->curtime;
|
|
m_bWasInPlayerSquad = true;
|
|
if ( m_pSquad->NumMembers() > MAX_PLAYER_SQUAD )
|
|
{
|
|
CAI_BaseNPC *pFirstMember = m_pSquad->GetFirstMember(NULL);
|
|
m_pSquad->RemoveFromSquad( pFirstMember );
|
|
pFirstMember->ClearCommandGoal();
|
|
|
|
CNPC_Citizen *pFirstMemberCitizen = dynamic_cast< CNPC_Citizen * >( pFirstMember );
|
|
if ( pFirstMemberCitizen )
|
|
{
|
|
pFirstMemberCitizen->ClearFollowTarget();
|
|
}
|
|
else
|
|
{
|
|
CAI_FollowBehavior *pOldMemberFollowBehavior;
|
|
if ( pFirstMember->GetBehavior( &pOldMemberFollowBehavior ) )
|
|
{
|
|
pOldMemberFollowBehavior->SetFollowTarget( NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
ClearFollowTarget();
|
|
|
|
CAI_BaseNPC *pLeader = NULL;
|
|
AISquadIter_t iter;
|
|
for ( CAI_BaseNPC *pAllyNpc = m_pSquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = m_pSquad->GetNextMember(&iter) )
|
|
{
|
|
if ( pAllyNpc->IsCommandable() )
|
|
{
|
|
pLeader = pAllyNpc;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( pLeader && pLeader != this )
|
|
{
|
|
const Vector &commandGoal = pLeader->GetCommandGoal();
|
|
if ( commandGoal != vec3_invalid )
|
|
{
|
|
SetCommandGoal( commandGoal );
|
|
SetCondition( COND_RECEIVED_ORDERS );
|
|
OnMoveOrder();
|
|
}
|
|
else
|
|
{
|
|
CAI_FollowBehavior *pLeaderFollowBehavior;
|
|
if ( pLeader->GetBehavior( &pLeaderFollowBehavior ) )
|
|
{
|
|
m_FollowBehavior.SetFollowTarget( pLeaderFollowBehavior->GetFollowTarget() );
|
|
m_FollowBehavior.SetParameters( m_FollowBehavior.GetFormation() );
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_FollowBehavior.SetFollowTarget( UTIL_GetLocalPlayer() );
|
|
m_FollowBehavior.SetParameters( AIF_SIMPLE );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::ClearFollowTarget()
|
|
{
|
|
m_FollowBehavior.SetFollowTarget( NULL );
|
|
m_FollowBehavior.SetParameters( AIF_SIMPLE );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::UpdateFollowCommandPoint()
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return;
|
|
|
|
if ( IsInPlayerSquad() )
|
|
{
|
|
if ( HaveCommandGoal() )
|
|
{
|
|
CBaseEntity *pFollowTarget = m_FollowBehavior.GetFollowTarget();
|
|
CBaseEntity *pCommandPoint = gEntList.FindEntityByClassname( NULL, COMMAND_POINT_CLASSNAME );
|
|
|
|
if( !pCommandPoint )
|
|
{
|
|
DevMsg("**\nVERY BAD THING\nCommand point vanished! Creating a new one\n**\n");
|
|
pCommandPoint = CreateEntityByName( COMMAND_POINT_CLASSNAME );
|
|
}
|
|
|
|
if ( pFollowTarget != pCommandPoint )
|
|
{
|
|
pFollowTarget = pCommandPoint;
|
|
m_FollowBehavior.SetFollowTarget( pFollowTarget );
|
|
m_FollowBehavior.SetParameters( AIF_COMMANDER );
|
|
}
|
|
|
|
if ( ( pCommandPoint->GetAbsOrigin() - GetCommandGoal() ).LengthSqr() > 0.01 )
|
|
{
|
|
UTIL_SetOrigin( pCommandPoint, GetCommandGoal(), false );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( IsFollowingCommandPoint() )
|
|
ClearFollowTarget();
|
|
if ( m_FollowBehavior.GetFollowTarget() != UTIL_GetLocalPlayer() )
|
|
{
|
|
DevMsg( "Expected to be following player, but not\n" );
|
|
m_FollowBehavior.SetFollowTarget( UTIL_GetLocalPlayer() );
|
|
m_FollowBehavior.SetParameters( AIF_SIMPLE );
|
|
}
|
|
}
|
|
}
|
|
else if ( IsFollowingCommandPoint() )
|
|
ClearFollowTarget();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::IsFollowingCommandPoint()
|
|
{
|
|
CBaseEntity *pFollowTarget = m_FollowBehavior.GetFollowTarget();
|
|
if ( pFollowTarget )
|
|
return FClassnameIs( pFollowTarget, COMMAND_POINT_CLASSNAME );
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
struct SquadMemberInfo_t
|
|
{
|
|
CNPC_Citizen * pMember;
|
|
bool bSeesPlayer;
|
|
float distSq;
|
|
};
|
|
|
|
int __cdecl SquadSortFunc( const SquadMemberInfo_t *pLeft, const SquadMemberInfo_t *pRight )
|
|
{
|
|
if ( pLeft->bSeesPlayer && !pRight->bSeesPlayer )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ( !pLeft->bSeesPlayer && pRight->bSeesPlayer )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return ( pLeft->distSq - pRight->distSq );
|
|
}
|
|
|
|
CAI_BaseNPC *CNPC_Citizen::GetSquadCommandRepresentative()
|
|
{
|
|
if ( !AI_IsSinglePlayer() )
|
|
return NULL;
|
|
|
|
if ( IsInPlayerSquad() )
|
|
{
|
|
static float lastTime;
|
|
static AIHANDLE hCurrent;
|
|
|
|
if ( gpGlobals->curtime - lastTime > 2.0 || !hCurrent || !hCurrent->IsInPlayerSquad() ) // hCurrent will be NULL after level change
|
|
{
|
|
lastTime = gpGlobals->curtime;
|
|
hCurrent = NULL;
|
|
|
|
CUtlVectorFixed<SquadMemberInfo_t, MAX_SQUAD_MEMBERS> candidates;
|
|
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
|
|
|
|
if ( pPlayer )
|
|
{
|
|
AISquadIter_t iter;
|
|
for ( CAI_BaseNPC *pAllyNpc = m_pSquad->GetFirstMember(&iter); pAllyNpc; pAllyNpc = m_pSquad->GetNextMember(&iter) )
|
|
{
|
|
if ( pAllyNpc->IsCommandable() && dynamic_cast<CNPC_Citizen *>(pAllyNpc) )
|
|
{
|
|
int i = candidates.AddToTail();
|
|
candidates[i].pMember = (CNPC_Citizen *)(pAllyNpc);
|
|
candidates[i].bSeesPlayer = pAllyNpc->HasCondition( COND_SEE_PLAYER );
|
|
candidates[i].distSq = ( pAllyNpc->GetAbsOrigin() - pPlayer->GetAbsOrigin() ).LengthSqr();
|
|
}
|
|
}
|
|
|
|
if ( candidates.Count() > 0 )
|
|
{
|
|
candidates.Sort( SquadSortFunc );
|
|
hCurrent = candidates[0].pMember;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( hCurrent != NULL )
|
|
{
|
|
Assert( dynamic_cast<CNPC_Citizen *>(hCurrent.Get()) && hCurrent->IsInPlayerSquad() );
|
|
return hCurrent;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::SetSquad( CAI_Squad *pSquad )
|
|
{
|
|
bool bWasInPlayerSquad = IsInPlayerSquad();
|
|
|
|
BaseClass::SetSquad( pSquad );
|
|
|
|
if( IsInPlayerSquad() && !bWasInPlayerSquad )
|
|
{
|
|
m_OnJoinedPlayerSquad.FireOutput(this, this);
|
|
if ( npc_citizen_insignia.GetBool() )
|
|
AddInsignia();
|
|
}
|
|
else if ( !IsInPlayerSquad() && bWasInPlayerSquad )
|
|
{
|
|
if ( npc_citizen_insignia.GetBool() )
|
|
RemoveInsignia();
|
|
m_OnLeftPlayerSquad.FireOutput(this, this);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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_Citizen::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter* sourceEnt)
|
|
{
|
|
// TODO: As citizen gets more complex, we will have to only allow
|
|
// these interruptions to happen from certain schedules
|
|
if (interactionType == g_interactionScannerInspect)
|
|
{
|
|
if ( gpGlobals->curtime > m_fNextInspectTime )
|
|
{
|
|
//SetLookTarget(sourceEnt);
|
|
|
|
// Don't let anyone else pick me for a couple seconds
|
|
SetNextScannerInspectTime( gpGlobals->curtime + 5.0 );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
else if (interactionType == g_interactionScannerInspectBegin)
|
|
{
|
|
// Don't inspect me again for a while
|
|
SetNextScannerInspectTime( gpGlobals->curtime + CIT_INSPECTED_DELAY_TIME );
|
|
|
|
Vector targetDir = ( sourceEnt->WorldSpaceCenter() - WorldSpaceCenter() );
|
|
VectorNormalize( targetDir );
|
|
|
|
// If we're hit from behind, startle
|
|
if ( DotProduct( targetDir, BodyDirection3D() ) < 0 )
|
|
{
|
|
m_nInspectActivity = ACT_CIT_STARTLED;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise we're blinded by the flash
|
|
m_nInspectActivity = ACT_CIT_BLINDED;
|
|
}
|
|
|
|
SetCondition( COND_CIT_START_INSPECTION );
|
|
return true;
|
|
}
|
|
else if (interactionType == g_interactionScannerInspectHandsUp)
|
|
{
|
|
m_nInspectActivity = ACT_CIT_HANDSUP;
|
|
SetSchedule(SCHED_CITIZEN_PLAY_INSPECT_ACTIVITY);
|
|
return true;
|
|
}
|
|
else if (interactionType == g_interactionScannerInspectShowArmband)
|
|
{
|
|
m_nInspectActivity = ACT_CIT_SHOWARMBAND;
|
|
SetSchedule(SCHED_CITIZEN_PLAY_INSPECT_ACTIVITY);
|
|
return true;
|
|
}
|
|
else if (interactionType == g_interactionScannerInspectDone)
|
|
{
|
|
SetSchedule(SCHED_IDLE_WANDER);
|
|
return true;
|
|
}
|
|
else if (interactionType == g_interactionHitByPlayerThrownPhysObj )
|
|
{
|
|
if ( IsOkToSpeakInResponseToPlayer() )
|
|
{
|
|
Speak( TLK_PLYR_PHYSATK );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return BaseClass::HandleInteraction( interactionType, data, sourceEnt );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::FValidateHintType( CAI_Hint *pHint )
|
|
{
|
|
switch( pHint->HintType() )
|
|
{
|
|
case HINT_WORLD_VISUALLY_INTERESTING:
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return BaseClass::FValidateHintType( pHint );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::CanHeal()
|
|
{
|
|
if ( !IsMedic() && !IsAmmoResupplier() )
|
|
return false;
|
|
|
|
if( !hl2_episodic.GetBool() )
|
|
{
|
|
// If I'm not armed, my priority should be to arm myself.
|
|
if ( IsMedic() && !GetActiveWeapon() )
|
|
return false;
|
|
}
|
|
|
|
if ( IsInAScript() || (m_NPCState == NPC_STATE_SCRIPT) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldHealTarget( CBaseEntity *pTarget, bool bActiveUse )
|
|
{
|
|
Disposition_t disposition;
|
|
|
|
if ( !pTarget && ( ( disposition = IRelationType( pTarget ) ) != D_LI && disposition != D_NU ) )
|
|
return false;
|
|
|
|
// Don't heal if I'm in the middle of talking
|
|
if ( IsSpeaking() )
|
|
return false;
|
|
|
|
bool bTargetIsPlayer = pTarget->IsPlayer();
|
|
|
|
// Don't heal or give ammo to targets in vehicles
|
|
CBaseCombatCharacter *pCCTarget = pTarget->MyCombatCharacterPointer();
|
|
if ( pCCTarget != NULL && pCCTarget->IsInAVehicle() )
|
|
return false;
|
|
|
|
if ( IsMedic() )
|
|
{
|
|
Vector toPlayer = ( pTarget->GetAbsOrigin() - GetAbsOrigin() );
|
|
if (( bActiveUse || !HaveCommandGoal() || toPlayer.Length() < HEAL_TARGET_RANGE)
|
|
#ifdef HL2_EPISODIC
|
|
&& fabs(toPlayer.z) < HEAL_TARGET_RANGE_Z
|
|
#endif
|
|
)
|
|
{
|
|
if ( pTarget->m_iHealth > 0 )
|
|
{
|
|
if ( bActiveUse )
|
|
{
|
|
// Ignore heal requests if we're going to heal a tiny amount
|
|
float timeFullHeal = m_flPlayerHealTime;
|
|
float timeRecharge = sk_citizen_heal_player_delay.GetFloat();
|
|
float maximumHealAmount = sk_citizen_heal_player.GetFloat();
|
|
float healAmt = ( maximumHealAmount * ( 1.0 - ( timeFullHeal - gpGlobals->curtime ) / timeRecharge ) );
|
|
if ( healAmt > pTarget->m_iMaxHealth - pTarget->m_iHealth )
|
|
healAmt = pTarget->m_iMaxHealth - pTarget->m_iHealth;
|
|
if ( healAmt < sk_citizen_heal_player_min_forced.GetFloat() )
|
|
return false;
|
|
|
|
return ( pTarget->m_iMaxHealth > pTarget->m_iHealth );
|
|
}
|
|
|
|
// Are we ready to heal again?
|
|
bool bReadyToHeal = ( ( bTargetIsPlayer && m_flPlayerHealTime <= gpGlobals->curtime ) ||
|
|
( !bTargetIsPlayer && m_flAllyHealTime <= gpGlobals->curtime ) );
|
|
|
|
// Only heal if we're ready
|
|
if ( bReadyToHeal )
|
|
{
|
|
int requiredHealth;
|
|
|
|
if ( bTargetIsPlayer )
|
|
requiredHealth = pTarget->GetMaxHealth() - sk_citizen_heal_player.GetFloat();
|
|
else
|
|
requiredHealth = pTarget->GetMaxHealth() * sk_citizen_heal_player_min_pct.GetFloat();
|
|
|
|
if ( ( pTarget->m_iHealth <= requiredHealth ) && IRelationType( pTarget ) == D_LI )
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Only players need ammo
|
|
if ( IsAmmoResupplier() && bTargetIsPlayer )
|
|
{
|
|
if ( m_flPlayerGiveAmmoTime <= gpGlobals->curtime )
|
|
{
|
|
int iAmmoType = GetAmmoDef()->Index( STRING(m_iszAmmoSupply) );
|
|
if ( iAmmoType == -1 )
|
|
{
|
|
DevMsg("ERROR: Citizen attempting to give unknown ammo type (%s)\n", STRING(m_iszAmmoSupply) );
|
|
}
|
|
else
|
|
{
|
|
// Does the player need the ammo we can give him?
|
|
int iMax = GetAmmoDef()->MaxCarry(iAmmoType);
|
|
int iCount = ((CBasePlayer*)pTarget)->GetAmmoCount(iAmmoType);
|
|
if ( !iCount || ((iMax - iCount) >= m_iAmmoAmount) )
|
|
{
|
|
// Only give the player ammo if he has a weapon that uses it
|
|
if ( ((CBasePlayer*)pTarget)->Weapon_GetWpnForAmmo( iAmmoType ) )
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#ifdef HL2_EPISODIC
|
|
//-----------------------------------------------------------------------------
|
|
// Determine if the citizen is in a position to be throwing medkits
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldHealTossTarget( CBaseEntity *pTarget, bool bActiveUse )
|
|
{
|
|
Disposition_t disposition;
|
|
|
|
Assert( IsMedic() );
|
|
if ( !IsMedic() )
|
|
return false;
|
|
|
|
if ( !pTarget && ( ( disposition = IRelationType( pTarget ) ) != D_LI && disposition != D_NU ) )
|
|
return false;
|
|
|
|
// Don't heal if I'm in the middle of talking
|
|
if ( IsSpeaking() )
|
|
return false;
|
|
|
|
bool bTargetIsPlayer = pTarget->IsPlayer();
|
|
|
|
// Don't heal or give ammo to targets in vehicles
|
|
CBaseCombatCharacter *pCCTarget = pTarget->MyCombatCharacterPointer();
|
|
if ( pCCTarget != NULL && pCCTarget->IsInAVehicle() )
|
|
return false;
|
|
|
|
Vector toPlayer = ( pTarget->GetAbsOrigin() - GetAbsOrigin() );
|
|
if ( bActiveUse || !HaveCommandGoal() || toPlayer.Length() < HEAL_TOSS_TARGET_RANGE )
|
|
{
|
|
if ( pTarget->m_iHealth > 0 )
|
|
{
|
|
if ( bActiveUse )
|
|
{
|
|
// Ignore heal requests if we're going to heal a tiny amount
|
|
float timeFullHeal = m_flPlayerHealTime;
|
|
float timeRecharge = sk_citizen_heal_player_delay.GetFloat();
|
|
float maximumHealAmount = sk_citizen_heal_player.GetFloat();
|
|
float healAmt = ( maximumHealAmount * ( 1.0 - ( timeFullHeal - gpGlobals->curtime ) / timeRecharge ) );
|
|
if ( healAmt > pTarget->m_iMaxHealth - pTarget->m_iHealth )
|
|
healAmt = pTarget->m_iMaxHealth - pTarget->m_iHealth;
|
|
if ( healAmt < sk_citizen_heal_player_min_forced.GetFloat() )
|
|
return false;
|
|
|
|
return ( pTarget->m_iMaxHealth > pTarget->m_iHealth );
|
|
}
|
|
|
|
// Are we ready to heal again?
|
|
bool bReadyToHeal = ( ( bTargetIsPlayer && m_flPlayerHealTime <= gpGlobals->curtime ) ||
|
|
( !bTargetIsPlayer && m_flAllyHealTime <= gpGlobals->curtime ) );
|
|
|
|
// Only heal if we're ready
|
|
if ( bReadyToHeal )
|
|
{
|
|
int requiredHealth;
|
|
|
|
if ( bTargetIsPlayer )
|
|
requiredHealth = pTarget->GetMaxHealth() - sk_citizen_heal_player.GetFloat();
|
|
else
|
|
requiredHealth = pTarget->GetMaxHealth() * sk_citizen_heal_player_min_pct.GetFloat();
|
|
|
|
if ( ( pTarget->m_iHealth <= requiredHealth ) && IRelationType( pTarget ) == D_LI )
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::Heal()
|
|
{
|
|
if ( !CanHeal() )
|
|
return;
|
|
|
|
CBaseEntity *pTarget = GetTarget();
|
|
|
|
Vector target = pTarget->GetAbsOrigin() - GetAbsOrigin();
|
|
if ( target.Length() > HEAL_TARGET_RANGE * 2 )
|
|
return;
|
|
|
|
// Don't heal a player that's staring at you until a few seconds have passed.
|
|
m_flTimeNextHealStare = gpGlobals->curtime + sk_citizen_stare_heal_time.GetFloat();
|
|
|
|
if ( IsMedic() )
|
|
{
|
|
float timeFullHeal;
|
|
float timeRecharge;
|
|
float maximumHealAmount;
|
|
if ( pTarget->IsPlayer() )
|
|
{
|
|
timeFullHeal = m_flPlayerHealTime;
|
|
timeRecharge = sk_citizen_heal_player_delay.GetFloat();
|
|
maximumHealAmount = sk_citizen_heal_player.GetFloat();
|
|
m_flPlayerHealTime = gpGlobals->curtime + timeRecharge;
|
|
}
|
|
else
|
|
{
|
|
timeFullHeal = m_flAllyHealTime;
|
|
timeRecharge = sk_citizen_heal_ally_delay.GetFloat();
|
|
maximumHealAmount = sk_citizen_heal_ally.GetFloat();
|
|
m_flAllyHealTime = gpGlobals->curtime + timeRecharge;
|
|
}
|
|
|
|
float healAmt = ( maximumHealAmount * ( 1.0 - ( timeFullHeal - gpGlobals->curtime ) / timeRecharge ) );
|
|
|
|
if ( healAmt > maximumHealAmount )
|
|
healAmt = maximumHealAmount;
|
|
else
|
|
healAmt = RoundFloatToInt( healAmt );
|
|
|
|
if ( healAmt > 0 )
|
|
{
|
|
if ( pTarget->IsPlayer() && npc_citizen_medic_emit_sound.GetBool() )
|
|
{
|
|
CPASAttenuationFilter filter( pTarget, "HealthKit.Touch" );
|
|
EmitSound( filter, pTarget->entindex(), "HealthKit.Touch" );
|
|
}
|
|
|
|
pTarget->TakeHealth( healAmt, DMG_GENERIC );
|
|
pTarget->RemoveAllDecals();
|
|
}
|
|
}
|
|
|
|
if ( IsAmmoResupplier() )
|
|
{
|
|
// Non-players don't use ammo
|
|
if ( pTarget->IsPlayer() )
|
|
{
|
|
int iAmmoType = GetAmmoDef()->Index( STRING(m_iszAmmoSupply) );
|
|
if ( iAmmoType == -1 )
|
|
{
|
|
DevMsg("ERROR: Citizen attempting to give unknown ammo type (%s)\n", STRING(m_iszAmmoSupply) );
|
|
}
|
|
else
|
|
{
|
|
((CBasePlayer*)pTarget)->GiveAmmo( m_iAmmoAmount, iAmmoType, false );
|
|
}
|
|
|
|
m_flPlayerGiveAmmoTime = gpGlobals->curtime + sk_citizen_giveammo_player_delay.GetFloat();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#if HL2_EPISODIC
|
|
//-----------------------------------------------------------------------------
|
|
// Like Heal(), but tosses a healthkit in front of the player rather than just juicing him up.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::TossHealthKit(CBaseCombatCharacter *pThrowAt, const Vector &offset)
|
|
{
|
|
Assert( pThrowAt );
|
|
|
|
Vector forward, right, up;
|
|
GetVectors( &forward, &right, &up );
|
|
Vector medKitOriginPoint = WorldSpaceCenter() + ( forward * 20.0f );
|
|
Vector destinationPoint;
|
|
// this doesn't work without a moveparent: pThrowAt->ComputeAbsPosition( offset, &destinationPoint );
|
|
VectorTransform( offset, pThrowAt->EntityToWorldTransform(), destinationPoint );
|
|
// flatten out any z change due to player looking up/down
|
|
destinationPoint.z = pThrowAt->EyePosition().z;
|
|
|
|
Vector tossVelocity;
|
|
|
|
if (npc_citizen_medic_throw_style.GetInt() == 0)
|
|
{
|
|
CTraceFilterSkipTwoEntities tracefilter( this, pThrowAt, COLLISION_GROUP_NONE );
|
|
tossVelocity = VecCheckToss( this, &tracefilter, medKitOriginPoint, destinationPoint, 0.233f, 1.0f, false );
|
|
}
|
|
else
|
|
{
|
|
tossVelocity = VecCheckThrow( this, medKitOriginPoint, destinationPoint, MEDIC_THROW_SPEED, 1.0f );
|
|
|
|
if (vec3_origin == tossVelocity)
|
|
{
|
|
// if out of range, just throw it as close as I can
|
|
tossVelocity = destinationPoint - medKitOriginPoint;
|
|
|
|
// rotate upwards against gravity
|
|
float len = VectorLength(tossVelocity);
|
|
tossVelocity *= (MEDIC_THROW_SPEED / len);
|
|
tossVelocity.z += 0.57735026918962576450914878050196 * MEDIC_THROW_SPEED;
|
|
}
|
|
}
|
|
|
|
// create a healthkit and toss it into the world
|
|
CBaseEntity *pHealthKit = CreateEntityByName( "item_healthkit" );
|
|
Assert(pHealthKit);
|
|
if (pHealthKit)
|
|
{
|
|
pHealthKit->SetAbsOrigin( medKitOriginPoint );
|
|
pHealthKit->SetOwnerEntity( this );
|
|
// pHealthKit->SetAbsVelocity( tossVelocity );
|
|
DispatchSpawn( pHealthKit );
|
|
|
|
{
|
|
IPhysicsObject *pPhysicsObject = pHealthKit->VPhysicsGetObject();
|
|
Assert( pPhysicsObject );
|
|
if ( pPhysicsObject )
|
|
{
|
|
unsigned int cointoss = random->RandomInt(0,0xFF); // int bits used for bools
|
|
|
|
// some random precession
|
|
Vector angDummy(random->RandomFloat(-200,200), random->RandomFloat(-200,200),
|
|
cointoss & 0x01 ? random->RandomFloat(200,600) : -1.0f * random->RandomFloat(200,600));
|
|
pPhysicsObject->SetVelocity( &tossVelocity, &angDummy );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Warning("Citizen tried to heal but could not spawn item_healthkit!\n");
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// cause an immediate call to TossHealthKit with some default numbers
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputForceHealthKitToss( inputdata_t &inputdata )
|
|
{
|
|
TossHealthKit( UTIL_GetLocalPlayer(), Vector(48.0f, 0.0f, 0.0f) );
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::ShouldLookForHealthItem()
|
|
{
|
|
// Definitely do not take health if not in the player's squad.
|
|
if( !IsInPlayerSquad() )
|
|
return false;
|
|
|
|
if( gpGlobals->curtime < m_flNextHealthSearchTime )
|
|
return false;
|
|
|
|
// I'm fully healthy.
|
|
if( GetHealth() >= GetMaxHealth() )
|
|
return false;
|
|
|
|
// Player is hurt, don't steal his health.
|
|
if( AI_IsSinglePlayer() && UTIL_GetLocalPlayer()->GetHealth() <= UTIL_GetLocalPlayer()->GetHealth() * 0.75f )
|
|
return false;
|
|
|
|
// Wait till you're standing still.
|
|
if( IsMoving() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputStartPatrolling( inputdata_t &inputdata )
|
|
{
|
|
m_bShouldPatrol = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputStopPatrolling( inputdata_t &inputdata )
|
|
{
|
|
m_bShouldPatrol = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void CNPC_Citizen::OnGivenWeapon( CBaseCombatWeapon *pNewWeapon )
|
|
{
|
|
FixupMattWeapon();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputSetCommandable( inputdata_t &inputdata )
|
|
{
|
|
RemoveSpawnFlags( SF_CITIZEN_NOT_COMMANDABLE );
|
|
gm_PlayerSquadEvaluateTimer.Force();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &inputdata -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputSetMedicOn( inputdata_t &inputdata )
|
|
{
|
|
AddSpawnFlags( SF_CITIZEN_MEDIC );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &inputdata -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputSetMedicOff( inputdata_t &inputdata )
|
|
{
|
|
RemoveSpawnFlags( SF_CITIZEN_MEDIC );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &inputdata -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputSetAmmoResupplierOn( inputdata_t &inputdata )
|
|
{
|
|
AddSpawnFlags( SF_CITIZEN_AMMORESUPPLIER );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &inputdata -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputSetAmmoResupplierOff( inputdata_t &inputdata )
|
|
{
|
|
RemoveSpawnFlags( SF_CITIZEN_AMMORESUPPLIER );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void CNPC_Citizen::InputSpeakIdleResponse( inputdata_t &inputdata )
|
|
{
|
|
SpeakIfAllowed( TLK_ANSWER, NULL, true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Citizen::DeathSound( const CTakeDamageInfo &info )
|
|
{
|
|
// Sentences don't play on dead NPCs
|
|
SentenceStop();
|
|
|
|
EmitSound( "NPC_Citizen.Die" );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void CNPC_Citizen::FearSound( void )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Citizen::UseSemaphore( void )
|
|
{
|
|
// Ignore semaphore if we're told to work outside it
|
|
if ( HasSpawnFlags(SF_CITIZEN_IGNORE_SEMAPHORE) )
|
|
return false;
|
|
|
|
return BaseClass::UseSemaphore();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Schedules
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
AI_BEGIN_CUSTOM_NPC( npc_citizen, CNPC_Citizen )
|
|
|
|
DECLARE_TASK( TASK_CIT_HEAL )
|
|
DECLARE_TASK( TASK_CIT_RPG_AUGER )
|
|
DECLARE_TASK( TASK_CIT_PLAY_INSPECT_SEQUENCE )
|
|
DECLARE_TASK( TASK_CIT_SIT_ON_TRAIN )
|
|
DECLARE_TASK( TASK_CIT_LEAVE_TRAIN )
|
|
DECLARE_TASK( TASK_CIT_SPEAK_MOURNING )
|
|
#if HL2_EPISODIC
|
|
DECLARE_TASK( TASK_CIT_HEAL_TOSS )
|
|
#endif
|
|
|
|
DECLARE_ACTIVITY( ACT_CIT_HANDSUP )
|
|
DECLARE_ACTIVITY( ACT_CIT_BLINDED )
|
|
DECLARE_ACTIVITY( ACT_CIT_SHOWARMBAND )
|
|
DECLARE_ACTIVITY( ACT_CIT_HEAL )
|
|
DECLARE_ACTIVITY( ACT_CIT_STARTLED )
|
|
|
|
DECLARE_CONDITION( COND_CIT_PLAYERHEALREQUEST )
|
|
DECLARE_CONDITION( COND_CIT_COMMANDHEAL )
|
|
DECLARE_CONDITION( COND_CIT_START_INSPECTION )
|
|
|
|
//Events
|
|
DECLARE_ANIMEVENT( AE_CITIZEN_GET_PACKAGE )
|
|
DECLARE_ANIMEVENT( AE_CITIZEN_HEAL )
|
|
|
|
//=========================================================
|
|
// > SCHED_SCI_HEAL
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_HEAL,
|
|
|
|
" Tasks"
|
|
" TASK_GET_PATH_TO_TARGET 0"
|
|
" TASK_MOVE_TO_TARGET_RANGE 50"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_IDEAL 0"
|
|
// " TASK_SAY_HEAL 0"
|
|
// " TASK_PLAY_SEQUENCE_FACE_TARGET ACTIVITY:ACT_ARM"
|
|
" TASK_CIT_HEAL 0"
|
|
// " TASK_PLAY_SEQUENCE_FACE_TARGET ACTIVITY:ACT_DISARM"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
#if HL2_EPISODIC
|
|
//=========================================================
|
|
// > SCHED_CITIZEN_HEAL_TOSS
|
|
// this is for the episodic behavior where the citizen hurls the medkit
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_HEAL_TOSS,
|
|
|
|
" Tasks"
|
|
// " TASK_GET_PATH_TO_TARGET 0"
|
|
// " TASK_MOVE_TO_TARGET_RANGE 50"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_IDEAL 0"
|
|
// " TASK_SAY_HEAL 0"
|
|
// " TASK_PLAY_SEQUENCE_FACE_TARGET ACTIVITY:ACT_ARM"
|
|
" TASK_CIT_HEAL_TOSS 0"
|
|
// " TASK_PLAY_SEQUENCE_FACE_TARGET ACTIVITY:ACT_DISARM"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
#endif
|
|
|
|
//=========================================================
|
|
// > SCHED_CITIZEN_RANGE_ATTACK1_RPG
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_RANGE_ATTACK1_RPG,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
|
|
" TASK_RANGE_ATTACK1 0"
|
|
" TASK_CIT_RPG_AUGER 1"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
// > SCHED_CITIZEN_RANGE_ATTACK1_RPG
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_STRIDER_RANGE_ATTACK1_RPG,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
|
|
" TASK_WAIT 1"
|
|
" TASK_RANGE_ATTACK1 0"
|
|
" TASK_CIT_RPG_AUGER 1"
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_TAKE_COVER_FROM_ENEMY"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
|
|
//=========================================================
|
|
// > SCHED_CITIZEN_PATROL
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_PATROL,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_WANDER 901024" // 90 to 1024 units
|
|
" TASK_WALK_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_WAIT 3"
|
|
" TASK_WAIT_RANDOM 3"
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_CITIZEN_PATROL" // keep doing it
|
|
""
|
|
" Interrupts"
|
|
" COND_ENEMY_DEAD"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_NEW_ENEMY"
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_MOURN_PLAYER,
|
|
|
|
" Tasks"
|
|
" TASK_GET_PATH_TO_PLAYER 0"
|
|
" TASK_RUN_PATH_WITHIN_DIST 180"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_TARGET_PLAYER 0"
|
|
" TASK_FACE_TARGET 0"
|
|
" TASK_CIT_SPEAK_MOURNING 0"
|
|
" TASK_SUGGEST_STATE STATE:IDLE"
|
|
""
|
|
" Interrupts"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_NEW_ENEMY"
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_PLAY_INSPECT_ACTIVITY,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_CIT_PLAY_INSPECT_SEQUENCE 0" // Play the sequence the scanner requires
|
|
" TASK_WAIT 2"
|
|
""
|
|
" Interrupts"
|
|
" "
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_CITIZEN_SIT_ON_TRAIN,
|
|
|
|
" Tasks"
|
|
" TASK_CIT_SIT_ON_TRAIN 0"
|
|
" TASK_WAIT_RANDOM 1"
|
|
" TASK_CIT_LEAVE_TRAIN 0"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
AI_END_CUSTOM_NPC()
|
|
|
|
|
|
|
|
//==================================================================================================================
|
|
// CITIZEN PLAYER-RESPONSE SYSTEM
|
|
//
|
|
// NOTE: This system is obsolete, and left here for legacy support.
|
|
// It has been superseded by the ai_eventresponse system.
|
|
//
|
|
//==================================================================================================================
|
|
CHandle<CCitizenResponseSystem> g_pCitizenResponseSystem = NULL;
|
|
|
|
CCitizenResponseSystem *GetCitizenResponse()
|
|
{
|
|
return g_pCitizenResponseSystem;
|
|
}
|
|
|
|
char *CitizenResponseConcepts[MAX_CITIZEN_RESPONSES] =
|
|
{
|
|
"TLK_CITIZEN_RESPONSE_SHOT_GUNSHIP",
|
|
"TLK_CITIZEN_RESPONSE_KILLED_GUNSHIP",
|
|
"TLK_VITALNPC_DIED",
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS( ai_citizen_response_system, CCitizenResponseSystem );
|
|
|
|
BEGIN_DATADESC( CCitizenResponseSystem )
|
|
DEFINE_ARRAY( m_flResponseAddedTime, FIELD_FLOAT, MAX_CITIZEN_RESPONSES ),
|
|
DEFINE_FIELD( m_flNextResponseTime, FIELD_FLOAT ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "ResponseVitalNPC", InputResponseVitalNPC ),
|
|
|
|
DEFINE_THINKFUNC( ResponseThink ),
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CCitizenResponseSystem::Spawn()
|
|
{
|
|
if ( g_pCitizenResponseSystem )
|
|
{
|
|
Warning("Multiple citizen response systems in level.\n");
|
|
UTIL_Remove( this );
|
|
return;
|
|
}
|
|
g_pCitizenResponseSystem = this;
|
|
|
|
// Invisible, non solid.
|
|
AddSolidFlags( FSOLID_NOT_SOLID );
|
|
AddEffects( EF_NODRAW );
|
|
SetThink( &CCitizenResponseSystem::ResponseThink );
|
|
|
|
m_flNextResponseTime = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CCitizenResponseSystem::OnRestore()
|
|
{
|
|
BaseClass::OnRestore();
|
|
|
|
g_pCitizenResponseSystem = this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CCitizenResponseSystem::AddResponseTrigger( citizenresponses_t iTrigger )
|
|
{
|
|
m_flResponseAddedTime[ iTrigger ] = gpGlobals->curtime;
|
|
|
|
SetNextThink( gpGlobals->curtime + 0.1 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CCitizenResponseSystem::InputResponseVitalNPC( inputdata_t &inputdata )
|
|
{
|
|
AddResponseTrigger( CR_VITALNPC_DIED );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CCitizenResponseSystem::ResponseThink()
|
|
{
|
|
bool bStayActive = false;
|
|
if ( AI_IsSinglePlayer() )
|
|
{
|
|
for ( int i = 0; i < MAX_CITIZEN_RESPONSES; i++ )
|
|
{
|
|
if ( m_flResponseAddedTime[i] )
|
|
{
|
|
// Should it have expired by now?
|
|
if ( (m_flResponseAddedTime[i] + CITIZEN_RESPONSE_GIVEUP_TIME) < gpGlobals->curtime )
|
|
{
|
|
m_flResponseAddedTime[i] = 0;
|
|
}
|
|
else if ( m_flNextResponseTime < gpGlobals->curtime )
|
|
{
|
|
// Try and find the nearest citizen to the player
|
|
float flNearestDist = (CITIZEN_RESPONSE_DISTANCE * CITIZEN_RESPONSE_DISTANCE);
|
|
CBaseEntity *pNearestCitizen = NULL;
|
|
CBaseEntity *pCitizen = NULL;
|
|
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
|
|
while ( (pCitizen = gEntList.FindEntityByClassname( pCitizen, "npc_citizen" ) ) != NULL)
|
|
{
|
|
float flDistToPlayer = (pPlayer->WorldSpaceCenter() - pCitizen->WorldSpaceCenter()).LengthSqr();
|
|
if ( flDistToPlayer < flNearestDist )
|
|
{
|
|
flNearestDist = flDistToPlayer;
|
|
pNearestCitizen = pCitizen;
|
|
}
|
|
}
|
|
|
|
// Found one?
|
|
if ( pNearestCitizen && ((CNPC_Citizen*)pNearestCitizen)->RespondedTo( CitizenResponseConcepts[i], false, false ) )
|
|
{
|
|
m_flResponseAddedTime[i] = 0;
|
|
m_flNextResponseTime = gpGlobals->curtime + CITIZEN_RESPONSE_REFIRE_TIME;
|
|
|
|
// Don't issue multiple responses
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bStayActive = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Do we need to keep thinking?
|
|
if ( bStayActive )
|
|
{
|
|
SetNextThink( gpGlobals->curtime + 0.1 );
|
|
}
|
|
}
|
|
|
|
void CNPC_Citizen::AddInsignia()
|
|
{
|
|
CBaseEntity *pMark = CreateEntityByName( "squadinsignia" );
|
|
pMark->SetOwnerEntity( this );
|
|
pMark->Spawn();
|
|
}
|
|
|
|
void CNPC_Citizen::RemoveInsignia()
|
|
{
|
|
CBaseEntity *pEntity = gEntList.FirstEnt();
|
|
|
|
while( pEntity )
|
|
{
|
|
if( pEntity->GetOwnerEntity() == this )
|
|
{
|
|
// Is this my insignia?
|
|
CSquadInsignia *pInsignia = dynamic_cast<CSquadInsignia *>(pEntity);
|
|
|
|
if( pInsignia )
|
|
{
|
|
UTIL_Remove( pInsignia );
|
|
return;
|
|
}
|
|
}
|
|
|
|
pEntity = gEntList.NextEnt( pEntity );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
LINK_ENTITY_TO_CLASS( squadinsignia, CSquadInsignia );
|
|
|
|
void CSquadInsignia::Spawn()
|
|
{
|
|
CAI_BaseNPC *pOwner = ( GetOwnerEntity() ) ? GetOwnerEntity()->MyNPCPointer() : NULL;
|
|
|
|
if ( pOwner )
|
|
{
|
|
int attachment = pOwner->LookupAttachment( "eyes" );
|
|
if ( attachment )
|
|
{
|
|
SetAbsAngles( GetOwnerEntity()->GetAbsAngles() );
|
|
SetParent( GetOwnerEntity(), attachment );
|
|
|
|
Vector vecPosition;
|
|
vecPosition.Init( -2.5, 0, 3.9 );
|
|
SetLocalOrigin( vecPosition );
|
|
}
|
|
}
|
|
|
|
SetModel( INSIGNIA_MODEL );
|
|
SetSolid( SOLID_NONE );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw any debug text overlays
|
|
// Input :
|
|
// Output : Current text offset from the top
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Citizen::DrawDebugTextOverlays( void )
|
|
{
|
|
int text_offset = BaseClass::DrawDebugTextOverlays();
|
|
|
|
if (m_debugOverlays & OVERLAY_TEXT_BIT)
|
|
{
|
|
char tempstr[512];
|
|
|
|
Q_snprintf(tempstr,sizeof(tempstr),"Expression type: %s", szExpressionTypes[m_ExpressionType]);
|
|
EntityText(text_offset,tempstr,0);
|
|
text_offset++;
|
|
}
|
|
return text_offset;
|
|
}
|