2052 lines
58 KiB
C++
2052 lines
58 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Advisors. Large sluglike aliens with creepy psychic powers!
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
#include "game.h"
|
|
#include "ai_basenpc.h"
|
|
#include "ai_schedule.h"
|
|
#include "ai_hull.h"
|
|
#include "ai_hint.h"
|
|
#include "ai_motor.h"
|
|
#include "ai_navigator.h"
|
|
#include "beam_shared.h"
|
|
#include "hl2_shareddefs.h"
|
|
#include "ai_route.h"
|
|
#include "npcevent.h"
|
|
#include "gib.h"
|
|
#include "ai_interactions.h"
|
|
#include "ndebugoverlay.h"
|
|
#include "physics_saverestore.h"
|
|
#include "saverestore_utlvector.h"
|
|
#include "soundent.h"
|
|
#include "vstdlib/random.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "movevars_shared.h"
|
|
#include "particle_parse.h"
|
|
#include "weapon_physcannon.h"
|
|
// #include "mathlib/noise.h"
|
|
|
|
// this file contains the definitions for the message ID constants (eg ADVISOR_MSG_START_BEAM etc)
|
|
#include "npc_advisor_shared.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//
|
|
// Custom activities.
|
|
//
|
|
|
|
//
|
|
// Skill settings.
|
|
//
|
|
ConVar sk_advisor_health( "sk_advisor_health", "0" );
|
|
ConVar advisor_use_impact_table("advisor_use_impact_table","1",FCVAR_NONE,"If true, advisor will use her custom impact damage table.");
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
ConVar advisor_throw_velocity( "advisor_throw_velocity", "1100" );
|
|
ConVar advisor_throw_rate( "advisor_throw_rate", "4" ); // Throw an object every 4 seconds.
|
|
ConVar advisor_throw_warn_time( "advisor_throw_warn_time", "1.0" ); // Warn players one second before throwing an object.
|
|
ConVar advisor_throw_lead_prefetch_time ( "advisor_throw_lead_prefetch_time", "0.66", FCVAR_NONE, "Save off the player's velocity this many seconds before throwing.");
|
|
ConVar advisor_throw_stage_distance("advisor_throw_stage_distance","180.0",FCVAR_NONE,"Advisor will try to hold an object this far in front of him just before throwing it at you. Small values will clobber the shield and be very bad.");
|
|
// ConVar advisor_staging_num("advisor_staging_num","1",FCVAR_NONE,"Advisor will queue up this many objects to throw at Gordon.");
|
|
ConVar advisor_throw_clearout_vel("advisor_throw_clearout_vel","200",FCVAR_NONE,"TEMP: velocity with which advisor clears things out of a throwable's way");
|
|
// ConVar advisor_staging_duration("
|
|
|
|
// how long it will take an object to get hauled to the staging point
|
|
#define STAGING_OBJECT_FALLOFF_TIME 0.15f
|
|
#endif
|
|
|
|
|
|
|
|
//
|
|
// Spawnflags.
|
|
//
|
|
|
|
//
|
|
// Animation events.
|
|
//
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
//
|
|
// Custom schedules.
|
|
//
|
|
enum
|
|
{
|
|
SCHED_ADVISOR_COMBAT = LAST_SHARED_SCHEDULE,
|
|
SCHED_ADVISOR_IDLE_STAND,
|
|
SCHED_ADVISOR_TOSS_PLAYER
|
|
};
|
|
|
|
|
|
//
|
|
// Custom tasks.
|
|
//
|
|
enum
|
|
{
|
|
TASK_ADVISOR_FIND_OBJECTS = LAST_SHARED_TASK,
|
|
TASK_ADVISOR_LEVITATE_OBJECTS,
|
|
TASK_ADVISOR_STAGE_OBJECTS,
|
|
TASK_ADVISOR_BARRAGE_OBJECTS,
|
|
|
|
TASK_ADVISOR_PIN_PLAYER,
|
|
};
|
|
|
|
//
|
|
// Custom conditions.
|
|
//
|
|
enum
|
|
{
|
|
COND_ADVISOR_PHASE_INTERRUPT = LAST_SHARED_CONDITION,
|
|
};
|
|
#endif
|
|
|
|
class CNPC_Advisor;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
class CAdvisorLevitate : public IMotionEvent
|
|
{
|
|
DECLARE_SIMPLE_DATADESC();
|
|
|
|
public:
|
|
|
|
// in the absence of goal entities, we float up before throwing and down after
|
|
inline bool OldStyle( void )
|
|
{
|
|
return !(m_vecGoalPos1.IsValid() && m_vecGoalPos2.IsValid());
|
|
}
|
|
|
|
virtual simresult_e Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular );
|
|
|
|
EHANDLE m_Advisor; ///< handle to the advisor.
|
|
|
|
Vector m_vecGoalPos1;
|
|
Vector m_vecGoalPos2;
|
|
|
|
float m_flFloat;
|
|
};
|
|
|
|
BEGIN_SIMPLE_DATADESC( CAdvisorLevitate )
|
|
DEFINE_FIELD( m_flFloat, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_vecGoalPos1, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_vecGoalPos2, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_Advisor, FIELD_EHANDLE ),
|
|
END_DATADESC()
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The advisor class.
|
|
//-----------------------------------------------------------------------------
|
|
class CNPC_Advisor : public CAI_BaseNPC
|
|
{
|
|
DECLARE_CLASS( CNPC_Advisor, CAI_BaseNPC );
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
DECLARE_SERVERCLASS();
|
|
#endif
|
|
|
|
public:
|
|
|
|
//
|
|
// CBaseEntity:
|
|
//
|
|
virtual void Activate();
|
|
virtual void Spawn();
|
|
virtual void Precache();
|
|
virtual void OnRestore();
|
|
virtual void UpdateOnRemove();
|
|
|
|
virtual int DrawDebugTextOverlays();
|
|
|
|
//
|
|
// CAI_BaseNPC:
|
|
//
|
|
virtual float MaxYawSpeed() { return 120.0f; }
|
|
|
|
virtual Class_T Classify();
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
virtual int GetSoundInterests();
|
|
virtual int SelectSchedule();
|
|
virtual void StartTask( const Task_t *pTask );
|
|
virtual void RunTask( const Task_t *pTask );
|
|
virtual void OnScheduleChange( void );
|
|
#endif
|
|
|
|
virtual void PainSound( const CTakeDamageInfo &info );
|
|
virtual void DeathSound( const CTakeDamageInfo &info );
|
|
virtual void IdleSound();
|
|
virtual void AlertSound();
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
virtual bool QueryHearSound( CSound *pSound );
|
|
virtual void GatherConditions( void );
|
|
|
|
/// true iff I recently threw the given object (not so fast)
|
|
bool DidThrow(const CBaseEntity *pEnt);
|
|
#else
|
|
inline bool DidThrow(const CBaseEntity *pEnt) { return false; }
|
|
#endif
|
|
|
|
virtual bool IsHeavyDamage( const CTakeDamageInfo &info );
|
|
virtual int OnTakeDamage( const CTakeDamageInfo &info );
|
|
|
|
virtual const impactdamagetable_t &GetPhysicsImpactDamageTable( void );
|
|
COutputInt m_OnHealthIsNow;
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
|
|
DEFINE_CUSTOM_AI;
|
|
|
|
void InputSetThrowRate( inputdata_t &inputdata );
|
|
void InputWrenchImmediate( inputdata_t &inputdata ); ///< immediately wrench an object into the air
|
|
void InputSetStagingNum( inputdata_t &inputdata );
|
|
void InputPinPlayer( inputdata_t &inputdata );
|
|
void InputTurnBeamOn( inputdata_t &inputdata );
|
|
void InputTurnBeamOff( inputdata_t &inputdata );
|
|
void InputElightOn( inputdata_t &inputdata );
|
|
void InputElightOff( inputdata_t &inputdata );
|
|
|
|
COutputEvent m_OnPickingThrowable, m_OnThrowWarn, m_OnThrow;
|
|
|
|
enum { kMaxThrownObjectsTracked = 4 };
|
|
#endif
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
protected:
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
Vector GetThrowFromPos( CBaseEntity *pEnt ); ///< Get the position in which we shall hold an object prior to throwing it
|
|
#endif
|
|
|
|
bool CanLevitateEntity( CBaseEntity *pEntity, int minMass, int maxMass );
|
|
void StartLevitatingObjects( void );
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
// void PurgeThrownObjects(); ///< clean out the recently thrown objects array
|
|
void AddToThrownObjects(CBaseEntity *pEnt); ///< add to the recently thrown objects array
|
|
|
|
void HurlObjectAtPlayer( CBaseEntity *pEnt, const Vector &leadVel );
|
|
void PullObjectToStaging( CBaseEntity *pEnt, const Vector &stagingPos );
|
|
CBaseEntity *ThrowObjectPrepare( void );
|
|
|
|
CBaseEntity *PickThrowable( bool bRequireInView ); ///< choose an object to throw at the player (so it can get stuffed in the handle array)
|
|
|
|
/// push everything out of the way between an object I'm about to throw and the player.
|
|
void PreHurlClearTheWay( CBaseEntity *pThrowable, const Vector &toPos );
|
|
#endif
|
|
|
|
CUtlVector<EHANDLE> m_physicsObjects;
|
|
IPhysicsMotionController *m_pLevitateController;
|
|
CAdvisorLevitate m_levitateCallback;
|
|
|
|
EHANDLE m_hLevitateGoal1;
|
|
EHANDLE m_hLevitateGoal2;
|
|
EHANDLE m_hLevitationArea;
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
// EHANDLE m_hThrowEnt;
|
|
CUtlVector<EHANDLE> m_hvStagedEnts;
|
|
CUtlVector<EHANDLE> m_hvStagingPositions;
|
|
// todo: write accessor functions for m_hvStagedEnts so that it doesn't have members added and removed willy nilly throughout
|
|
// code (will make the networking below more reliable)
|
|
|
|
void Write_BeamOn( CBaseEntity *pEnt ); ///< write a message turning a beam on
|
|
void Write_BeamOff( CBaseEntity *pEnt ); ///< write a message turning a beam off
|
|
void Write_AllBeamsOff( void ); ///< tell client to kill all beams
|
|
|
|
// for the pin-the-player-to-something behavior
|
|
EHANDLE m_hPlayerPinPos;
|
|
float m_playerPinFailsafeTime;
|
|
|
|
// keep track of up to four objects after we have thrown them, to prevent oscillation or levitation of recently thrown ammo.
|
|
EHANDLE m_haRecentlyThrownObjects[kMaxThrownObjectsTracked];
|
|
float m_flaRecentlyThrownObjectTimes[kMaxThrownObjectsTracked];
|
|
#endif
|
|
|
|
string_t m_iszLevitateGoal1;
|
|
string_t m_iszLevitateGoal2;
|
|
string_t m_iszLevitationArea;
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
string_t m_iszStagingEntities;
|
|
string_t m_iszPriorityEntityGroupName;
|
|
|
|
float m_flStagingEnd;
|
|
float m_flThrowPhysicsTime;
|
|
float m_flLastThrowTime;
|
|
float m_flLastPlayerAttackTime; ///< last time the player attacked something.
|
|
|
|
int m_iStagingNum; ///< number of objects advisor stages at once
|
|
bool m_bWasScripting;
|
|
|
|
// unsigned char m_pickFailures; // the number of times we have tried to pick a throwable and failed
|
|
|
|
Vector m_vSavedLeadVel; ///< save off player velocity for leading a bit before actually pelting them.
|
|
#endif
|
|
};
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( npc_advisor, CNPC_Advisor );
|
|
|
|
BEGIN_DATADESC( CNPC_Advisor )
|
|
|
|
DEFINE_KEYFIELD( m_iszLevitateGoal1, FIELD_STRING, "levitategoal_bottom" ),
|
|
DEFINE_KEYFIELD( m_iszLevitateGoal2, FIELD_STRING, "levitategoal_top" ),
|
|
DEFINE_KEYFIELD( m_iszLevitationArea, FIELD_STRING, "levitationarea"), ///< we will float all the objects in this volume
|
|
|
|
DEFINE_PHYSPTR( m_pLevitateController ),
|
|
DEFINE_EMBEDDED( m_levitateCallback ),
|
|
DEFINE_UTLVECTOR( m_physicsObjects, FIELD_EHANDLE ),
|
|
|
|
DEFINE_FIELD( m_hLevitateGoal1, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_hLevitateGoal2, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_hLevitationArea, FIELD_EHANDLE ),
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
DEFINE_KEYFIELD( m_iszStagingEntities, FIELD_STRING, "staging_ent_names"), ///< entities named this constitute the positions to which we stage objects to be thrown
|
|
DEFINE_KEYFIELD( m_iszPriorityEntityGroupName, FIELD_STRING, "priority_grab_name"),
|
|
|
|
DEFINE_UTLVECTOR( m_hvStagedEnts, FIELD_EHANDLE ),
|
|
DEFINE_UTLVECTOR( m_hvStagingPositions, FIELD_EHANDLE ),
|
|
DEFINE_ARRAY( m_haRecentlyThrownObjects, FIELD_EHANDLE, CNPC_Advisor::kMaxThrownObjectsTracked ),
|
|
DEFINE_ARRAY( m_flaRecentlyThrownObjectTimes, FIELD_TIME, CNPC_Advisor::kMaxThrownObjectsTracked ),
|
|
|
|
DEFINE_FIELD( m_hPlayerPinPos, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_playerPinFailsafeTime, FIELD_TIME ),
|
|
|
|
// DEFINE_FIELD( m_hThrowEnt, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_flThrowPhysicsTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flLastPlayerAttackTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flStagingEnd, FIELD_TIME ),
|
|
DEFINE_FIELD( m_iStagingNum, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_bWasScripting, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_flLastThrowTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_vSavedLeadVel, FIELD_VECTOR ),
|
|
|
|
DEFINE_OUTPUT( m_OnPickingThrowable, "OnPickingThrowable" ),
|
|
DEFINE_OUTPUT( m_OnThrowWarn, "OnThrowWarn" ),
|
|
DEFINE_OUTPUT( m_OnThrow, "OnThrow" ),
|
|
DEFINE_OUTPUT( m_OnHealthIsNow, "OnHealthIsNow" ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetThrowRate", InputSetThrowRate ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "WrenchImmediate", InputWrenchImmediate ),
|
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetStagingNum", InputSetStagingNum),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "PinPlayer", InputPinPlayer ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "BeamOn", InputTurnBeamOn ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "BeamOff", InputTurnBeamOff ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "ElightOn", InputElightOn ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "ElightOff", InputElightOff ),
|
|
#endif
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
IMPLEMENT_SERVERCLASS_ST(CNPC_Advisor, DT_NPC_Advisor)
|
|
|
|
END_SEND_TABLE()
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::Spawn()
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
#ifdef _XBOX
|
|
// Always fade the corpse
|
|
AddSpawnFlags( SF_NPC_FADE_CORPSE );
|
|
#endif // _XBOX
|
|
|
|
Precache();
|
|
|
|
SetModel( STRING( GetModelName() ) );
|
|
|
|
m_iHealth = sk_advisor_health.GetFloat();
|
|
m_takedamage = DAMAGE_NO;
|
|
|
|
SetHullType( HULL_LARGE_CENTERED );
|
|
SetHullSizeNormal();
|
|
|
|
SetSolid( SOLID_BBOX );
|
|
// AddSolidFlags( FSOLID_NOT_SOLID );
|
|
|
|
SetMoveType( MOVETYPE_FLY );
|
|
|
|
m_flFieldOfView = VIEW_FIELD_FULL;
|
|
SetViewOffset( Vector( 0, 0, 80 ) ); // Position of the eyes relative to NPC's origin.
|
|
|
|
SetBloodColor( BLOOD_COLOR_GREEN );
|
|
m_NPCState = NPC_STATE_NONE;
|
|
|
|
CapabilitiesClear();
|
|
|
|
NPCInit();
|
|
|
|
SetGoalEnt( NULL );
|
|
|
|
AddEFlags( EFL_NO_DISSOLVE );
|
|
}
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
//-----------------------------------------------------------------------------
|
|
// comparison function for qsort used below. Compares "StagingPriority" keyfield
|
|
//-----------------------------------------------------------------------------
|
|
int __cdecl AdvisorStagingComparator(const EHANDLE *pe1, const EHANDLE *pe2)
|
|
{
|
|
// bool ReadKeyField( const char *varName, variant_t *var );
|
|
|
|
variant_t var;
|
|
int val1 = 10, val2 = 10; // default priority is ten
|
|
|
|
// read field one
|
|
if ( pe1->Get()->ReadKeyField( "StagingPriority", &var ) )
|
|
{
|
|
val1 = var.Int();
|
|
}
|
|
|
|
// read field two
|
|
if ( pe2->Get()->ReadKeyField( "StagingPriority", &var ) )
|
|
{
|
|
val2 = var.Int();
|
|
}
|
|
|
|
// return comparison (< 0 if pe1<pe2)
|
|
return( val1 - val2 );
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4706)
|
|
|
|
void CNPC_Advisor::Activate()
|
|
{
|
|
BaseClass::Activate();
|
|
|
|
m_hLevitateGoal1 = gEntList.FindEntityGeneric( NULL, STRING( m_iszLevitateGoal1 ), this );
|
|
m_hLevitateGoal2 = gEntList.FindEntityGeneric( NULL, STRING( m_iszLevitateGoal2 ), this );
|
|
m_hLevitationArea = gEntList.FindEntityGeneric( NULL, STRING( m_iszLevitationArea ), this );
|
|
|
|
m_levitateCallback.m_Advisor = this;
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
// load the staging positions
|
|
CBaseEntity *pEnt = NULL;
|
|
m_hvStagingPositions.EnsureCapacity(6); // reserve six
|
|
|
|
// conditional assignment: find an entity by name and save it into pEnt. Bail out when none are left.
|
|
while ( pEnt = gEntList.FindEntityByName(pEnt,m_iszStagingEntities) )
|
|
{
|
|
m_hvStagingPositions.AddToTail(pEnt);
|
|
}
|
|
|
|
// sort the staging positions by their staging number.
|
|
m_hvStagingPositions.Sort( AdvisorStagingComparator );
|
|
|
|
// positions loaded, null out the m_hvStagedEnts array with exactly as many null spaces
|
|
m_hvStagedEnts.SetCount( m_hvStagingPositions.Count() );
|
|
|
|
m_iStagingNum = 1;
|
|
|
|
AssertMsg(m_hvStagingPositions.Count() > 0, "You did not specify any staging positions in the advisor's staging_ent_names !");
|
|
#endif
|
|
}
|
|
#pragma warning(pop)
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::UpdateOnRemove()
|
|
{
|
|
if ( m_pLevitateController )
|
|
{
|
|
physenv->DestroyMotionController( m_pLevitateController );
|
|
}
|
|
|
|
BaseClass::UpdateOnRemove();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::OnRestore()
|
|
{
|
|
BaseClass::OnRestore();
|
|
StartLevitatingObjects();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns this monster's classification in the relationship table.
|
|
//-----------------------------------------------------------------------------
|
|
Class_T CNPC_Advisor::Classify()
|
|
{
|
|
return CLASS_COMBINE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Advisor::IsHeavyDamage( const CTakeDamageInfo &info )
|
|
{
|
|
return (info.GetDamage() > 0);
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::StartLevitatingObjects()
|
|
{
|
|
if ( !m_pLevitateController )
|
|
{
|
|
m_pLevitateController = physenv->CreateMotionController( &m_levitateCallback );
|
|
}
|
|
|
|
m_pLevitateController->ClearObjects();
|
|
|
|
int nCount = m_physicsObjects.Count();
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
CBaseEntity *pEnt = m_physicsObjects.Element( i );
|
|
if ( !pEnt )
|
|
continue;
|
|
|
|
//NDebugOverlay::Box( pEnt->GetAbsOrigin(), pEnt->CollisionProp()->OBBMins(), pEnt->CollisionProp()->OBBMaxs(), 0, 255, 0, 1, 0.1 );
|
|
|
|
IPhysicsObject *pPhys = pEnt->VPhysicsGetObject();
|
|
if ( pPhys && pPhys->IsMoveable() )
|
|
{
|
|
m_pLevitateController->AttachObject( pPhys, false );
|
|
pPhys->Wake();
|
|
}
|
|
}
|
|
}
|
|
|
|
// This function is used by both version of the entity finder below
|
|
bool CNPC_Advisor::CanLevitateEntity( CBaseEntity *pEntity, int minMass, int maxMass )
|
|
{
|
|
if (!pEntity || pEntity->IsNPC())
|
|
return false;
|
|
|
|
IPhysicsObject *pPhys = pEntity->VPhysicsGetObject();
|
|
if (!pPhys)
|
|
return false;
|
|
|
|
float mass = pPhys->GetMass();
|
|
|
|
return ( mass >= minMass &&
|
|
mass <= maxMass &&
|
|
//pEntity->VPhysicsGetObject()->IsAsleep() &&
|
|
pPhys->IsMoveable() /* &&
|
|
!DidThrow(pEntity) */ );
|
|
}
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
// find an object to throw at the player and start the warning on it. Return object's
|
|
// pointer if we got something. Otherwise, return NULL if nothing left to throw. Will
|
|
// always leave the prepared object at the head of m_hvStagedEnts
|
|
CBaseEntity *CNPC_Advisor::ThrowObjectPrepare()
|
|
{
|
|
|
|
CBaseEntity *pThrowable = NULL;
|
|
while (m_hvStagedEnts.Count() > 0)
|
|
{
|
|
pThrowable = m_hvStagedEnts[0];
|
|
|
|
if (pThrowable)
|
|
{
|
|
IPhysicsObject *pPhys = pThrowable->VPhysicsGetObject();
|
|
if ( !pPhys )
|
|
{
|
|
// reject!
|
|
|
|
Write_BeamOff(m_hvStagedEnts[0]);
|
|
pThrowable = NULL;
|
|
}
|
|
}
|
|
|
|
// if we still have pThrowable...
|
|
if (pThrowable)
|
|
{
|
|
// we're good
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
m_hvStagedEnts.Remove(0);
|
|
}
|
|
}
|
|
|
|
if (pThrowable)
|
|
{
|
|
Assert( pThrowable->VPhysicsGetObject() );
|
|
|
|
// play the sound, attach the light, fire the trigger
|
|
EmitSound( "NPC_Advisor.ObjectChargeUp" );
|
|
|
|
m_OnThrowWarn.FireOutput(pThrowable,this);
|
|
m_flThrowPhysicsTime = gpGlobals->curtime + advisor_throw_warn_time.GetFloat();
|
|
|
|
if ( GetEnemy() )
|
|
{
|
|
PreHurlClearTheWay( pThrowable, GetEnemy()->EyePosition() );
|
|
}
|
|
|
|
return pThrowable;
|
|
}
|
|
else // we had nothing to throw
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::StartTask( const Task_t *pTask )
|
|
{
|
|
switch ( pTask->iTask )
|
|
{
|
|
// DVS: TODO: if this gets expensive we can start caching the results and doing it less often.
|
|
case TASK_ADVISOR_FIND_OBJECTS:
|
|
{
|
|
// if we have a trigger volume, use the contents of that. If not, use a hardcoded box (for debugging purposes)
|
|
// in both cases we validate the objects using the same helper funclet just above. When we can count on the
|
|
// trigger vol being there, we can elide the else{} clause here.
|
|
|
|
CBaseEntity *pVolume = m_hLevitationArea;
|
|
AssertMsg(pVolume, "Combine advisor needs 'levitationarea' key pointing to a trigger volume." );
|
|
|
|
if (!pVolume)
|
|
{
|
|
TaskFail( "No levitation area found!" );
|
|
break;
|
|
}
|
|
|
|
touchlink_t *touchroot = ( touchlink_t * )pVolume->GetDataObject( TOUCHLINK );
|
|
if ( touchroot )
|
|
{
|
|
|
|
m_physicsObjects.RemoveAll();
|
|
|
|
for ( touchlink_t *link = touchroot->nextLink; link != touchroot; link = link->nextLink )
|
|
{
|
|
CBaseEntity *pTouch = link->entityTouched;
|
|
if ( CanLevitateEntity( pTouch, 10, 220 ) )
|
|
{
|
|
if ( pTouch->GetMoveType() == MOVETYPE_VPHYSICS )
|
|
{
|
|
//Msg( " %d added %s\n", m_physicsObjects.Count(), STRING( list[i]->GetModelName() ) );
|
|
m_physicsObjects.AddToTail( pTouch );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
// this is the old mechanism, using a hardcoded box and an entity enumerator.
|
|
// since deprecated.
|
|
|
|
else
|
|
{
|
|
CBaseEntity *list[128];
|
|
|
|
m_physicsObjects.RemoveAll();
|
|
|
|
//NDebugOverlay::Box( GetAbsOrigin(), Vector( -408, -368, -188 ), Vector( 92, 208, 168 ), 255, 255, 0, 1, 5 );
|
|
|
|
// one-off class used to determine which entities we want from the UTIL_EntitiesInBox
|
|
class CAdvisorLevitateEntitiesEnum : public CFlaggedEntitiesEnum
|
|
{
|
|
public:
|
|
CAdvisorLevitateEntitiesEnum( CBaseEntity **pList, int listMax, int nMinMass, int nMaxMass )
|
|
: CFlaggedEntitiesEnum( pList, listMax, 0 ),
|
|
m_nMinMass( nMinMass ),
|
|
m_nMaxMass( nMaxMass )
|
|
{
|
|
}
|
|
|
|
virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity )
|
|
{
|
|
CBaseEntity *pEntity = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() );
|
|
if ( AdvisorCanLevitateEntity( pEntity, m_nMinMass, m_nMaxMass ) )
|
|
{
|
|
return CFlaggedEntitiesEnum::EnumElement( pHandleEntity );
|
|
}
|
|
return ITERATION_CONTINUE;
|
|
}
|
|
|
|
int m_nMinMass;
|
|
int m_nMaxMass;
|
|
};
|
|
|
|
CAdvisorLevitateEntitiesEnum levitateEnum( list, ARRAYSIZE( list ), 10, 220 );
|
|
|
|
int nCount = UTIL_EntitiesInBox( GetAbsOrigin() - Vector( 554, 368, 188 ), GetAbsOrigin() + Vector( 92, 208, 168 ), &levitateEnum );
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
//Msg( "%d found %s\n", m_physicsObjects.Count(), STRING( list[i]->GetModelName() ) );
|
|
if ( list[i]->GetMoveType() == MOVETYPE_VPHYSICS )
|
|
{
|
|
//Msg( " %d added %s\n", m_physicsObjects.Count(), STRING( list[i]->GetModelName() ) );
|
|
m_physicsObjects.AddToTail( list[i] );
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
if ( m_physicsObjects.Count() > 0 )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
TaskFail( "No physics objects found!" );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_ADVISOR_LEVITATE_OBJECTS:
|
|
{
|
|
StartLevitatingObjects();
|
|
|
|
m_flThrowPhysicsTime = gpGlobals->curtime + advisor_throw_rate.GetFloat();
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_ADVISOR_STAGE_OBJECTS:
|
|
{
|
|
// m_pickFailures = 0;
|
|
// clear out previously staged throwables
|
|
/*
|
|
for (int ii = m_hvStagedEnts.Count() - 1; ii >= 0 ; --ii)
|
|
{
|
|
m_hvStagedEnts[ii] = NULL;
|
|
}
|
|
*/
|
|
Write_AllBeamsOff();
|
|
m_hvStagedEnts.RemoveAll();
|
|
|
|
m_OnPickingThrowable.FireOutput(NULL,this);
|
|
m_flStagingEnd = gpGlobals->curtime + pTask->flTaskData;
|
|
|
|
break;
|
|
}
|
|
|
|
// we're about to pelt the player with everything. Start the warning effect on the first object.
|
|
case TASK_ADVISOR_BARRAGE_OBJECTS:
|
|
{
|
|
|
|
CBaseEntity *pThrowable = ThrowObjectPrepare();
|
|
|
|
if (!pThrowable || m_hvStagedEnts.Count() < 1)
|
|
{
|
|
TaskFail( "Nothing to throw!" );
|
|
return;
|
|
}
|
|
|
|
m_vSavedLeadVel.Invalidate();
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_ADVISOR_PIN_PLAYER:
|
|
{
|
|
|
|
// should never be here
|
|
/*
|
|
Assert( m_hPlayerPinPos.IsValid() );
|
|
m_playerPinFailsafeTime = gpGlobals->curtime + 10.0f;
|
|
|
|
break;
|
|
*/
|
|
}
|
|
|
|
default:
|
|
{
|
|
BaseClass::StartTask( pTask );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// todo: find a way to guarantee that objects are made pickupable again when bailing out of a task
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::RunTask( const Task_t *pTask )
|
|
{
|
|
|
|
switch ( pTask->iTask )
|
|
{
|
|
// Raise up the objects that we found and then hold them.
|
|
case TASK_ADVISOR_LEVITATE_OBJECTS:
|
|
{
|
|
float flTimeToThrow = m_flThrowPhysicsTime - gpGlobals->curtime;
|
|
if ( flTimeToThrow < 0 )
|
|
{
|
|
TaskComplete();
|
|
return;
|
|
}
|
|
|
|
// set the top and bottom on the levitation volume from the entities. If we don't have
|
|
// both, zero it out so that we can use the old-style simpler mechanism.
|
|
if ( m_hLevitateGoal1 && m_hLevitateGoal2 )
|
|
{
|
|
m_levitateCallback.m_vecGoalPos1 = m_hLevitateGoal1->GetAbsOrigin();
|
|
m_levitateCallback.m_vecGoalPos2 = m_hLevitateGoal2->GetAbsOrigin();
|
|
// swap them if necessary (1 must be the bottom)
|
|
if (m_levitateCallback.m_vecGoalPos1.z > m_levitateCallback.m_vecGoalPos2.z)
|
|
{
|
|
swap(m_levitateCallback.m_vecGoalPos1,m_levitateCallback.m_vecGoalPos2);
|
|
}
|
|
|
|
m_levitateCallback.m_flFloat = 0.06f; // this is an absolute accumulation upon gravity
|
|
}
|
|
else
|
|
{
|
|
m_levitateCallback.m_vecGoalPos1.Invalidate();
|
|
m_levitateCallback.m_vecGoalPos2.Invalidate();
|
|
|
|
// the below two stanzas are used for old-style floating, which is linked
|
|
// to float up before thrown and down after
|
|
if ( flTimeToThrow > 2.0f )
|
|
{
|
|
m_levitateCallback.m_flFloat = 1.06f;
|
|
}
|
|
else
|
|
{
|
|
m_levitateCallback.m_flFloat = 0.94f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
// Draw boxes around the objects we're levitating.
|
|
for ( int i = 0; i < m_physicsObjects.Count(); i++ )
|
|
{
|
|
CBaseEntity *pEnt = m_physicsObjects.Element( i );
|
|
if ( !pEnt )
|
|
continue; // The prop has been broken!
|
|
|
|
IPhysicsObject *pPhys = pEnt->VPhysicsGetObject();
|
|
if ( pPhys && pPhys->IsMoveable() )
|
|
{
|
|
NDebugOverlay::Box( pEnt->GetAbsOrigin(), pEnt->CollisionProp()->OBBMins(), pEnt->CollisionProp()->OBBMaxs(), 0, 255, 0, 1, 0.1 );
|
|
}
|
|
}*/
|
|
|
|
break;
|
|
}
|
|
|
|
// Pick a random object that we are levitating. If we have a clear LOS from that object
|
|
// to our enemy's eyes, choose that one to throw. Otherwise, keep looking.
|
|
case TASK_ADVISOR_STAGE_OBJECTS:
|
|
{
|
|
if (m_iStagingNum > m_hvStagingPositions.Count())
|
|
{
|
|
Warning( "Advisor tries to stage %d objects but only has %d positions named %s! Overriding.\n", m_iStagingNum, m_hvStagingPositions.Count(), m_iszStagingEntities );
|
|
m_iStagingNum = m_hvStagingPositions.Count() ;
|
|
}
|
|
|
|
|
|
// advisor_staging_num
|
|
|
|
// in the future i'll distribute the staging chronologically. For now, yank all the objects at once.
|
|
if (m_hvStagedEnts.Count() < m_iStagingNum)
|
|
{
|
|
// pull another object
|
|
bool bDesperate = m_flStagingEnd - gpGlobals->curtime < 0.50f; // less than one half second left
|
|
CBaseEntity *pThrowable = PickThrowable(!bDesperate);
|
|
if (pThrowable)
|
|
{
|
|
// don't let the player take it from me
|
|
IPhysicsObject *pPhys = pThrowable->VPhysicsGetObject();
|
|
if ( pPhys )
|
|
{
|
|
// no pickup!
|
|
pPhys->SetGameFlags(pPhys->GetGameFlags() | FVPHYSICS_NO_PLAYER_PICKUP );;
|
|
}
|
|
|
|
m_hvStagedEnts.AddToTail( pThrowable );
|
|
Write_BeamOn(pThrowable);
|
|
|
|
|
|
DispatchParticleEffect( "advisor_object_charge", PATTACH_ABSORIGIN_FOLLOW,
|
|
pThrowable, 0,
|
|
false );
|
|
}
|
|
}
|
|
|
|
|
|
Assert(m_hvStagedEnts.Count() <= m_hvStagingPositions.Count());
|
|
|
|
// yank all objects into place
|
|
for (int ii = m_hvStagedEnts.Count() - 1 ; ii >= 0 ; --ii)
|
|
{
|
|
|
|
// just ignore lost objects (if the player destroys one, that's fine, leave a hole)
|
|
CBaseEntity *pThrowable = m_hvStagedEnts[ii];
|
|
if (pThrowable)
|
|
{
|
|
PullObjectToStaging(pThrowable, m_hvStagingPositions[ii]->GetAbsOrigin());
|
|
}
|
|
}
|
|
|
|
// are we done yet?
|
|
if (gpGlobals->curtime > m_flStagingEnd)
|
|
{
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// Fling the object that we picked at our enemy's eyes!
|
|
case TASK_ADVISOR_BARRAGE_OBJECTS:
|
|
{
|
|
Assert(m_hvStagedEnts.Count() > 0);
|
|
|
|
// do I still have an enemy?
|
|
if ( !GetEnemy() )
|
|
{
|
|
// no? bail all the objects.
|
|
for (int ii = m_hvStagedEnts.Count() - 1 ; ii >=0 ; --ii)
|
|
{
|
|
|
|
IPhysicsObject *pPhys = m_hvStagedEnts[ii]->VPhysicsGetObject();
|
|
if ( pPhys )
|
|
{
|
|
pPhys->SetGameFlags(pPhys->GetGameFlags() & (~FVPHYSICS_NO_PLAYER_PICKUP) );
|
|
}
|
|
}
|
|
|
|
Write_AllBeamsOff();
|
|
m_hvStagedEnts.RemoveAll();
|
|
|
|
TaskFail( "Lost enemy" );
|
|
return;
|
|
}
|
|
|
|
// do I still have something to throw at the player?
|
|
CBaseEntity *pThrowable = m_hvStagedEnts[0];
|
|
while (!pThrowable)
|
|
{ // player has destroyed whatever I planned to hit him with, get something else
|
|
if (m_hvStagedEnts.Count() > 0)
|
|
{
|
|
pThrowable = ThrowObjectPrepare();
|
|
}
|
|
else
|
|
{
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we've gone NULL, then opt out
|
|
if ( pThrowable == NULL )
|
|
{
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
if ( (gpGlobals->curtime > m_flThrowPhysicsTime - advisor_throw_lead_prefetch_time.GetFloat()) &&
|
|
!m_vSavedLeadVel.IsValid() )
|
|
{
|
|
// save off the velocity we will use to lead the player a little early, so that if he jukes
|
|
// at the last moment he'll have a better shot of dodging the object.
|
|
m_vSavedLeadVel = GetEnemy()->GetAbsVelocity();
|
|
}
|
|
|
|
// if it's time to throw something, throw it and go on to the next one.
|
|
if (gpGlobals->curtime > m_flThrowPhysicsTime)
|
|
{
|
|
IPhysicsObject *pPhys = pThrowable->VPhysicsGetObject();
|
|
Assert(pPhys);
|
|
|
|
pPhys->SetGameFlags(pPhys->GetGameFlags() & (~FVPHYSICS_NO_PLAYER_PICKUP) );
|
|
HurlObjectAtPlayer(pThrowable,Vector(0,0,0)/*m_vSavedLeadVel*/);
|
|
m_flLastThrowTime = gpGlobals->curtime;
|
|
m_flThrowPhysicsTime = gpGlobals->curtime + 0.75f;
|
|
// invalidate saved lead for next time
|
|
m_vSavedLeadVel.Invalidate();
|
|
|
|
EmitSound( "NPC_Advisor.Blast" );
|
|
|
|
Write_BeamOff(m_hvStagedEnts[0]);
|
|
m_hvStagedEnts.Remove(0);
|
|
if (!ThrowObjectPrepare())
|
|
{
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// wait, bide time
|
|
// PullObjectToStaging(pThrowable, m_hvStagingPositions[ii]->GetAbsOrigin());
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_ADVISOR_PIN_PLAYER:
|
|
{
|
|
/*
|
|
// bail out if the pin entity went away.
|
|
CBaseEntity *pPinEnt = m_hPlayerPinPos;
|
|
if (!pPinEnt)
|
|
{
|
|
GetEnemy()->SetGravity(1.0f);
|
|
GetEnemy()->SetMoveType( MOVETYPE_WALK );
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
// failsafe: don't do this for more than ten seconds.
|
|
if ( gpGlobals->curtime > m_playerPinFailsafeTime )
|
|
{
|
|
GetEnemy()->SetGravity(1.0f);
|
|
GetEnemy()->SetMoveType( MOVETYPE_WALK );
|
|
Warning( "Advisor did not leave PIN PLAYER mode. Aborting due to ten second failsafe!\n" );
|
|
TaskFail("Advisor did not leave PIN PLAYER mode. Aborting due to ten second failsafe!\n");
|
|
break;
|
|
}
|
|
|
|
// if the player isn't the enemy, bail out.
|
|
if ( !GetEnemy()->IsPlayer() )
|
|
{
|
|
GetEnemy()->SetGravity(1.0f);
|
|
GetEnemy()->SetMoveType( MOVETYPE_WALK );
|
|
TaskFail( "Player is not the enemy?!" );
|
|
break;
|
|
}
|
|
|
|
GetEnemy()->SetMoveType( MOVETYPE_FLY );
|
|
GetEnemy()->SetGravity(0);
|
|
|
|
// use exponential falloff to peg the player to the pin point
|
|
const Vector &desiredPos = pPinEnt->GetAbsOrigin();
|
|
const Vector &playerPos = GetEnemy()->GetAbsOrigin();
|
|
|
|
Vector displacement = desiredPos - playerPos;
|
|
|
|
float desiredDisplacementLen = ExponentialDecay(0.250f,gpGlobals->frametime);// * sqrt(displacementLen);
|
|
|
|
Vector nuPos = playerPos + (displacement * (1.0f - desiredDisplacementLen));
|
|
|
|
GetEnemy()->SetAbsOrigin( nuPos );
|
|
|
|
break;
|
|
*/
|
|
}
|
|
|
|
default:
|
|
{
|
|
BaseClass::RunTask( pTask );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
// helper function for testing whether or not an avisor is allowed to grab an object
|
|
static bool AdvisorCanPickObject(CBasePlayer *pPlayer, CBaseEntity *pEnt)
|
|
{
|
|
Assert( pPlayer != NULL );
|
|
|
|
// Is the player carrying something?
|
|
CBaseEntity *pHeldObject = GetPlayerHeldEntity(pPlayer);
|
|
|
|
if( !pHeldObject )
|
|
{
|
|
pHeldObject = PhysCannonGetHeldEntity( pPlayer->GetActiveWeapon() );
|
|
}
|
|
|
|
if( pHeldObject == pEnt )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
//-----------------------------------------------------------------------------
|
|
// Choose an object to throw.
|
|
// param bRequireInView : if true, only accept objects that are in the player's fov.
|
|
//
|
|
// Can always return NULL.
|
|
// todo priority_grab_name
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CNPC_Advisor::PickThrowable( bool bRequireInView )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetEnemy() );
|
|
Assert(pPlayer);
|
|
if (!pPlayer)
|
|
return NULL;
|
|
|
|
const int numObjs = m_physicsObjects.Count(); ///< total number of physics objects in my system
|
|
if (numObjs < 1)
|
|
return NULL; // bail out if nothing available
|
|
|
|
|
|
// used for require-in-view
|
|
Vector eyeForward, eyeOrigin;
|
|
if (pPlayer)
|
|
{
|
|
eyeOrigin = pPlayer->EyePosition();
|
|
pPlayer->EyeVectors(&eyeForward);
|
|
}
|
|
else
|
|
{
|
|
bRequireInView = false;
|
|
}
|
|
|
|
// filter-and-choose algorithm:
|
|
// build a list of candidates
|
|
Assert(numObjs < 128); /// I'll come back and utlvector this shortly -- wanted easier debugging
|
|
unsigned int candidates[128];
|
|
unsigned int numCandidates = 0;
|
|
|
|
if (!!m_iszPriorityEntityGroupName) // if the string isn't null
|
|
{
|
|
// first look to see if we have any priority objects.
|
|
for (int ii = 0 ; ii < numObjs ; ++ii )
|
|
{
|
|
CBaseEntity *pThrowEnt = m_physicsObjects[ii];
|
|
// Assert(pThrowEnt);
|
|
if (!pThrowEnt)
|
|
continue;
|
|
|
|
if (!pThrowEnt->NameMatches(m_iszPriorityEntityGroupName)) // if this is not a priority object
|
|
continue;
|
|
|
|
bool bCanPick = AdvisorCanPickObject( pPlayer, pThrowEnt ) && !m_hvStagedEnts.HasElement( m_physicsObjects[ii] );
|
|
if (!bCanPick)
|
|
continue;
|
|
|
|
// bCanPick guaranteed true here
|
|
|
|
if ( bRequireInView )
|
|
{
|
|
bCanPick = (pThrowEnt->GetAbsOrigin() - eyeOrigin).Dot(eyeForward) > 0;
|
|
}
|
|
|
|
if ( bCanPick )
|
|
{
|
|
candidates[numCandidates++] = ii;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we found no priority objects (or don't have a priority), just grab whatever
|
|
if (numCandidates == 0)
|
|
{
|
|
for (int ii = 0 ; ii < numObjs ; ++ii )
|
|
{
|
|
CBaseEntity *pThrowEnt = m_physicsObjects[ii];
|
|
// Assert(pThrowEnt);
|
|
if (!pThrowEnt)
|
|
continue;
|
|
|
|
bool bCanPick = AdvisorCanPickObject( pPlayer, pThrowEnt ) && !m_hvStagedEnts.HasElement( m_physicsObjects[ii] );
|
|
if (!bCanPick)
|
|
continue;
|
|
|
|
// bCanPick guaranteed true here
|
|
|
|
if ( bRequireInView )
|
|
{
|
|
bCanPick = (pThrowEnt->GetAbsOrigin() - eyeOrigin).Dot(eyeForward) > 0;
|
|
}
|
|
|
|
if ( bCanPick )
|
|
{
|
|
candidates[numCandidates++] = ii;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( numCandidates == 0 )
|
|
return NULL; // must have at least one candidate
|
|
|
|
// pick a random candidate.
|
|
int nRandomIndex = random->RandomInt( 0, numCandidates - 1 );
|
|
return m_physicsObjects[candidates[nRandomIndex]];
|
|
|
|
}
|
|
|
|
/*! \TODO
|
|
Correct bug where Advisor seemed to be throwing stuff at people's feet.
|
|
This is because the object was falling slightly in between the staging
|
|
and when he threw it, and that downward velocity was getting accumulated
|
|
into the throw speed. This is temporarily fixed here by using SetVelocity
|
|
instead of AddVelocity, but the proper fix is to pin the object to its
|
|
staging point during the warn period. That will require maintaining a map
|
|
of throwables to their staging points during the throw task.
|
|
*/
|
|
//-----------------------------------------------------------------------------
|
|
// Impart necessary force on any entity to make it clobber Gordon.
|
|
// Also detaches from levitate controller.
|
|
// The optional lead velocity parameter is for cases when we pre-save off the
|
|
// player's speed, to make last-moment juking more effective
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::HurlObjectAtPlayer( CBaseEntity *pEnt, const Vector &leadVel )
|
|
{
|
|
IPhysicsObject *pPhys = pEnt->VPhysicsGetObject();
|
|
|
|
//
|
|
// Lead the target accurately. This encourages hiding behind cover
|
|
// and/or catching the thrown physics object!
|
|
//
|
|
Vector vecObjOrigin = pEnt->CollisionProp()->WorldSpaceCenter();
|
|
Vector vecEnemyPos = GetEnemy()->EyePosition();
|
|
// disabled -- no longer compensate for gravity: // vecEnemyPos.y += 12.0f;
|
|
|
|
// const Vector &leadVel = pLeadVelocity ? *pLeadVelocity : GetEnemy()->GetAbsVelocity();
|
|
|
|
Vector vecDelta = vecEnemyPos - vecObjOrigin;
|
|
float flDist = vecDelta.Length();
|
|
|
|
float flVelocity = advisor_throw_velocity.GetFloat();
|
|
|
|
if ( flVelocity == 0 )
|
|
{
|
|
flVelocity = 1000;
|
|
}
|
|
|
|
float flFlightTime = flDist / flVelocity;
|
|
|
|
Vector vecThrowAt = vecEnemyPos + flFlightTime * leadVel;
|
|
Vector vecThrowDir = vecThrowAt - vecObjOrigin;
|
|
VectorNormalize( vecThrowDir );
|
|
|
|
Vector vecVelocity = flVelocity * vecThrowDir;
|
|
pPhys->SetVelocity( &vecVelocity, NULL );
|
|
|
|
AddToThrownObjects(pEnt);
|
|
|
|
m_OnThrow.FireOutput(pEnt,this);
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// do a sweep from an object I'm about to throw, to the target, pushing aside
|
|
// anything floating in the way.
|
|
// TODO: this is probably a good profiling candidate.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::PreHurlClearTheWay( CBaseEntity *pThrowable, const Vector &toPos )
|
|
{
|
|
// look for objects in the way of chucking.
|
|
CBaseEntity *list[128];
|
|
Ray_t ray;
|
|
|
|
|
|
float boundingRadius = pThrowable->BoundingRadius();
|
|
|
|
ray.Init( pThrowable->GetAbsOrigin(), toPos,
|
|
Vector(-boundingRadius,-boundingRadius,-boundingRadius),
|
|
Vector( boundingRadius, boundingRadius, boundingRadius) );
|
|
|
|
int nFoundCt = UTIL_EntitiesAlongRay( list, 128, ray, 0 );
|
|
AssertMsg(nFoundCt < 128, "Found more than 128 obstructions between advisor and Gordon while throwing. (safe to continue)\n");
|
|
|
|
// for each thing in the way that I levitate, but is not something I'm staging
|
|
// or throwing, push it aside.
|
|
for (int i = 0 ; i < nFoundCt ; ++i )
|
|
{
|
|
CBaseEntity *obstruction = list[i];
|
|
if ( obstruction != pThrowable &&
|
|
m_physicsObjects.HasElement( obstruction ) && // if it's floating
|
|
!m_hvStagedEnts.HasElement( obstruction ) && // and I'm not staging it
|
|
!DidThrow( obstruction ) ) // and I didn't just throw it
|
|
{
|
|
IPhysicsObject *pPhys = obstruction->VPhysicsGetObject();
|
|
Assert(pPhys);
|
|
|
|
// this is an object we want to push out of the way. Compute a vector perpendicular
|
|
// to the path of the throwables's travel, and thrust the object along that vector.
|
|
Vector thrust;
|
|
CalcClosestPointOnLine( obstruction->GetAbsOrigin(),
|
|
pThrowable->GetAbsOrigin(),
|
|
toPos,
|
|
thrust );
|
|
// "thrust" is now the closest point on the line to the obstruction.
|
|
// compute the difference to get the direction of impulse
|
|
thrust = obstruction->GetAbsOrigin() - thrust;
|
|
|
|
// and renormalize it to equal a giant kick out of the way
|
|
// (which I'll say is about ten feet per second -- if we want to be
|
|
// more precise we could do some kind of interpolation based on how
|
|
// far away the object is)
|
|
float thrustLen = thrust.Length();
|
|
if (thrustLen > 0.0001f)
|
|
{
|
|
thrust *= advisor_throw_clearout_vel.GetFloat() / thrustLen;
|
|
}
|
|
|
|
// heave!
|
|
pPhys->AddVelocity( &thrust, NULL );
|
|
}
|
|
}
|
|
|
|
/*
|
|
|
|
// Otherwise only help out a little
|
|
Vector extents = Vector(256, 256, 256);
|
|
Ray_t ray;
|
|
ray.Init( vecStartPoint, vecStartPoint + 2048 * vecVelDir, -extents, extents );
|
|
int nCount = UTIL_EntitiesAlongRay( list, 1024, ray, FL_NPC | FL_CLIENT );
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
if ( !IsAttractiveTarget( list[i] ) )
|
|
continue;
|
|
|
|
VectorSubtract( list[i]->WorldSpaceCenter(), vecStartPoint, vecDelta );
|
|
distance = VectorNormalize( vecDelta );
|
|
flDot = DotProduct( vecDelta, vecVelDir );
|
|
|
|
if ( flDot > flMaxDot )
|
|
{
|
|
if ( distance < flBestDist )
|
|
{
|
|
pBestTarget = list[i];
|
|
flBestDist = distance;
|
|
}
|
|
}
|
|
}
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
/*
|
|
// commented out because unnecessary: we will do this during the DidThrow check
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// clean out the recently thrown objects array
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::PurgeThrownObjects()
|
|
{
|
|
float threeSecondsAgo = gpGlobals->curtime - 3.0f; // two seconds ago
|
|
|
|
for (int ii = 0 ; ii < kMaxThrownObjectsTracked ; ++ii)
|
|
{
|
|
if ( m_haRecentlyThrownObjects[ii].IsValid() &&
|
|
m_flaRecentlyThrownObjectTimes[ii] < threeSecondsAgo )
|
|
{
|
|
m_haRecentlyThrownObjects[ii].Set(NULL);
|
|
}
|
|
}
|
|
|
|
}
|
|
*/
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// true iff an advisor threw the object in the last three seconds
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Advisor::DidThrow(const CBaseEntity *pEnt)
|
|
{
|
|
// look through all my objects and see if they match this entity. Incidentally if
|
|
// they're more than three seconds old, purge them.
|
|
float threeSecondsAgo = gpGlobals->curtime - 3.0f;
|
|
|
|
for (int ii = 0 ; ii < kMaxThrownObjectsTracked ; ++ii)
|
|
{
|
|
// if object is old, skip it.
|
|
CBaseEntity *pTestEnt = m_haRecentlyThrownObjects[ii];
|
|
|
|
if ( pTestEnt )
|
|
{
|
|
if ( m_flaRecentlyThrownObjectTimes[ii] < threeSecondsAgo )
|
|
{
|
|
m_haRecentlyThrownObjects[ii].Set(NULL);
|
|
continue;
|
|
}
|
|
else if (pTestEnt == pEnt)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::AddToThrownObjects(CBaseEntity *pEnt)
|
|
{
|
|
Assert(pEnt);
|
|
|
|
// try to find an empty slot, or if none exists, the oldest object
|
|
int oldestThrownObject = 0;
|
|
for (int ii = 0 ; ii < kMaxThrownObjectsTracked ; ++ii)
|
|
{
|
|
if (m_haRecentlyThrownObjects[ii].IsValid())
|
|
{
|
|
if (m_flaRecentlyThrownObjectTimes[ii] < m_flaRecentlyThrownObjectTimes[oldestThrownObject])
|
|
{
|
|
oldestThrownObject = ii;
|
|
}
|
|
}
|
|
else
|
|
{ // just use this one
|
|
oldestThrownObject = ii;
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_haRecentlyThrownObjects[oldestThrownObject] = pEnt;
|
|
m_flaRecentlyThrownObjectTimes[oldestThrownObject] = gpGlobals->curtime;
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Drag a particular object towards its staging location.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::PullObjectToStaging( CBaseEntity *pEnt, const Vector &stagingPos )
|
|
{
|
|
IPhysicsObject *pPhys = pEnt->VPhysicsGetObject();
|
|
Assert(pPhys);
|
|
|
|
Vector curPos = pEnt->CollisionProp()->WorldSpaceCenter();
|
|
Vector displacement = stagingPos - curPos;
|
|
|
|
// quick and dirty -- use exponential decay to haul the object into place
|
|
// ( a better looking solution would be to use a spring system )
|
|
|
|
float desiredDisplacementLen = ExponentialDecay(STAGING_OBJECT_FALLOFF_TIME, gpGlobals->frametime);// * sqrt(displacementLen);
|
|
|
|
Vector vel; AngularImpulse angimp;
|
|
pPhys->GetVelocity(&vel,&angimp);
|
|
|
|
vel = (1.0f / gpGlobals->frametime)*(displacement * (1.0f - desiredDisplacementLen));
|
|
pPhys->SetVelocity(&vel,&angimp);
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
int CNPC_Advisor::OnTakeDamage( const CTakeDamageInfo &info )
|
|
{
|
|
// Clip our max
|
|
CTakeDamageInfo newInfo = info;
|
|
if ( newInfo.GetDamage() > 20.0f )
|
|
{
|
|
newInfo.SetDamage( 20.0f );
|
|
}
|
|
|
|
// Hack to make him constantly flinch
|
|
m_flNextFlinchTime = gpGlobals->curtime;
|
|
|
|
const float oldLastDamageTime = m_flLastDamageTime;
|
|
int retval = BaseClass::OnTakeDamage(newInfo);
|
|
|
|
// we have a special reporting output
|
|
if ( oldLastDamageTime != gpGlobals->curtime )
|
|
{
|
|
// only fire once per frame
|
|
|
|
m_OnHealthIsNow.Set( GetHealth(), newInfo.GetAttacker(), this);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the best new schedule for this NPC based on current conditions.
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Advisor::SelectSchedule()
|
|
{
|
|
if ( IsInAScript() )
|
|
return SCHED_ADVISOR_IDLE_STAND;
|
|
|
|
switch ( m_NPCState )
|
|
{
|
|
case NPC_STATE_IDLE:
|
|
case NPC_STATE_ALERT:
|
|
{
|
|
return SCHED_ADVISOR_IDLE_STAND;
|
|
}
|
|
|
|
case NPC_STATE_COMBAT:
|
|
{
|
|
if ( GetEnemy() && GetEnemy()->IsAlive() )
|
|
{
|
|
if ( false /* m_hPlayerPinPos.IsValid() */ )
|
|
return SCHED_ADVISOR_TOSS_PLAYER;
|
|
else
|
|
return SCHED_ADVISOR_COMBAT;
|
|
|
|
}
|
|
|
|
return SCHED_ADVISOR_IDLE_STAND;
|
|
}
|
|
}
|
|
|
|
return BaseClass::SelectSchedule();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// return the position where an object should be staged before throwing
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Advisor::GetThrowFromPos( CBaseEntity *pEnt )
|
|
{
|
|
Assert(pEnt);
|
|
Assert(pEnt->VPhysicsGetObject());
|
|
const CCollisionProperty *cProp = pEnt->CollisionProp();
|
|
Assert(cProp);
|
|
|
|
float effecRadius = cProp->BoundingRadius(); // radius of object (important for kickout)
|
|
float howFarInFront = advisor_throw_stage_distance.GetFloat() + effecRadius * 1.43f;// clamp(lenToPlayer - posDist + effecRadius,effecRadius*2,90.f + effecRadius);
|
|
|
|
Vector fwd;
|
|
GetVectors(&fwd,NULL,NULL);
|
|
|
|
return GetAbsOrigin() + fwd*howFarInFront;
|
|
}
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
|
|
PrecacheModel( STRING( GetModelName() ) );
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
PrecacheModel( "sprites/lgtning.vmt" );
|
|
#endif
|
|
|
|
PrecacheScriptSound( "NPC_Advisor.Blast" );
|
|
PrecacheScriptSound( "NPC_Advisor.Gib" );
|
|
PrecacheScriptSound( "NPC_Advisor.Idle" );
|
|
PrecacheScriptSound( "NPC_Advisor.Alert" );
|
|
PrecacheScriptSound( "NPC_Advisor.Die" );
|
|
PrecacheScriptSound( "NPC_Advisor.Pain" );
|
|
PrecacheScriptSound( "NPC_Advisor.ObjectChargeUp" );
|
|
PrecacheParticleSystem( "Advisor_Psychic_Beam" );
|
|
PrecacheParticleSystem( "advisor_object_charge" );
|
|
PrecacheModel("sprites/greenglow1.vmt");
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::IdleSound()
|
|
{
|
|
EmitSound( "NPC_Advisor.Idle" );
|
|
}
|
|
|
|
|
|
void CNPC_Advisor::AlertSound()
|
|
{
|
|
EmitSound( "NPC_Advisor.Alert" );
|
|
}
|
|
|
|
|
|
void CNPC_Advisor::PainSound( const CTakeDamageInfo &info )
|
|
{
|
|
EmitSound( "NPC_Advisor.Pain" );
|
|
}
|
|
|
|
|
|
void CNPC_Advisor::DeathSound( const CTakeDamageInfo &info )
|
|
{
|
|
EmitSound( "NPC_Advisor.Die" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Advisor::DrawDebugTextOverlays()
|
|
{
|
|
int nOffset = BaseClass::DrawDebugTextOverlays();
|
|
return nOffset;
|
|
}
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
//-----------------------------------------------------------------------------
|
|
// Determines which sounds the advisor cares about.
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Advisor::GetSoundInterests()
|
|
{
|
|
return SOUND_WORLD | SOUND_COMBAT | SOUND_PLAYER | SOUND_DANGER;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// record the last time we heard a combat sound
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Advisor::QueryHearSound( CSound *pSound )
|
|
{
|
|
// Disregard footsteps from our own class type
|
|
CBaseEntity *pOwner = pSound->m_hOwner;
|
|
if ( pOwner && pSound->IsSoundType( SOUND_COMBAT ) && pSound->SoundChannel() != SOUNDENT_CHANNEL_NPC_FOOTSTEP && pSound->m_hOwner.IsValid() && pOwner->IsPlayer() )
|
|
{
|
|
// Msg("Heard player combat.\n");
|
|
m_flLastPlayerAttackTime = gpGlobals->curtime;
|
|
}
|
|
|
|
return BaseClass::QueryHearSound(pSound);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// designer hook for setting throw rate
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::InputSetThrowRate( inputdata_t &inputdata )
|
|
{
|
|
advisor_throw_rate.SetValue(inputdata.value.Float());
|
|
}
|
|
|
|
void CNPC_Advisor::InputSetStagingNum( inputdata_t &inputdata )
|
|
{
|
|
m_iStagingNum = inputdata.value.Int();
|
|
}
|
|
|
|
//
|
|
// cause the player to be pinned to a point in space
|
|
//
|
|
void CNPC_Advisor::InputPinPlayer( inputdata_t &inputdata )
|
|
{
|
|
string_t targetname = inputdata.value.StringID();
|
|
|
|
// null string means designer is trying to unpin the player
|
|
if (!targetname)
|
|
{
|
|
m_hPlayerPinPos = NULL;
|
|
}
|
|
|
|
// otherwise try to look up the entity and make it a target.
|
|
CBaseEntity *pEnt = gEntList.FindEntityByName(NULL,targetname);
|
|
|
|
if (pEnt)
|
|
{
|
|
m_hPlayerPinPos = pEnt;
|
|
}
|
|
else
|
|
{
|
|
// if we couldn't find the target, just bail on the behavior.
|
|
Warning("Advisor tried to pin player to %s but that does not exist.\n", targetname.ToCStr());
|
|
m_hPlayerPinPos = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::OnScheduleChange( void )
|
|
{
|
|
Write_AllBeamsOff();
|
|
m_hvStagedEnts.RemoveAll();
|
|
BaseClass::OnScheduleChange();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::GatherConditions( void )
|
|
{
|
|
BaseClass::GatherConditions();
|
|
|
|
// Handle script state changes
|
|
bool bInScript = IsInAScript();
|
|
if ( ( m_bWasScripting && bInScript == false ) || ( m_bWasScripting == false && bInScript ) )
|
|
{
|
|
SetCondition( COND_ADVISOR_PHASE_INTERRUPT );
|
|
}
|
|
|
|
// Retain this
|
|
m_bWasScripting = bInScript;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// designer hook for yanking an object into the air right now
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::InputWrenchImmediate( inputdata_t &inputdata )
|
|
{
|
|
string_t groupname = inputdata.value.StringID();
|
|
|
|
Assert(!!groupname);
|
|
|
|
// for all entities with that name that aren't floating, punt them at me and add them to the levitation
|
|
|
|
CBaseEntity *pEnt = NULL;
|
|
|
|
const Vector &myPos = GetAbsOrigin() + Vector(0,36.0f,0);
|
|
|
|
// conditional assignment: find an entity by name and save it into pEnt. Bail out when none are left.
|
|
while ( ( pEnt = gEntList.FindEntityByName(pEnt,groupname) ) != NULL )
|
|
{
|
|
// if I'm not already levitating it, and if I didn't just throw it
|
|
if (!m_physicsObjects.HasElement(pEnt) )
|
|
{
|
|
// add to levitation
|
|
IPhysicsObject *pPhys = pEnt->VPhysicsGetObject();
|
|
if ( pPhys )
|
|
{
|
|
// if the object isn't moveable, make it so.
|
|
if ( !pPhys->IsMoveable() )
|
|
{
|
|
pPhys->EnableMotion( true );
|
|
}
|
|
|
|
// first, kick it at me
|
|
Vector objectToMe;
|
|
pPhys->GetPosition(&objectToMe,NULL);
|
|
objectToMe = myPos - objectToMe;
|
|
// compute a velocity that will get it here in about a second
|
|
objectToMe /= (1.5f * gpGlobals->frametime);
|
|
|
|
objectToMe *= random->RandomFloat(0.25f,1.0f);
|
|
|
|
pPhys->SetVelocity( &objectToMe, NULL );
|
|
|
|
// add it to tracked physics objects
|
|
m_physicsObjects.AddToTail( pEnt );
|
|
|
|
m_pLevitateController->AttachObject( pPhys, false );
|
|
pPhys->Wake();
|
|
}
|
|
else
|
|
{
|
|
Warning( "Advisor tried to wrench %s, but it is not moveable!", pEnt->GetEntityName().ToCStr());
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// write a message turning a beam on
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::Write_BeamOn( CBaseEntity *pEnt )
|
|
{
|
|
Assert( pEnt );
|
|
EntityMessageBegin( this, true );
|
|
WRITE_BYTE( ADVISOR_MSG_START_BEAM );
|
|
WRITE_LONG( pEnt->entindex() );
|
|
MessageEnd();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// write a message turning a beam off
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::Write_BeamOff( CBaseEntity *pEnt )
|
|
{
|
|
Assert( pEnt );
|
|
EntityMessageBegin( this, true );
|
|
WRITE_BYTE( ADVISOR_MSG_STOP_BEAM );
|
|
WRITE_LONG( pEnt->entindex() );
|
|
MessageEnd();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// tell client to kill all beams
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::Write_AllBeamsOff( void )
|
|
{
|
|
EntityMessageBegin( this, true );
|
|
WRITE_BYTE( ADVISOR_MSG_STOP_ALL_BEAMS );
|
|
MessageEnd();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// input wrapper around Write_BeamOn
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::InputTurnBeamOn( inputdata_t &inputdata )
|
|
{
|
|
// inputdata should specify a target
|
|
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, inputdata.value.StringID() );
|
|
if ( pTarget )
|
|
{
|
|
Write_BeamOn( pTarget );
|
|
}
|
|
else
|
|
{
|
|
Warning("InputTurnBeamOn could not find object %s", inputdata.value.String() );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// input wrapper around Write_BeamOff
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Advisor::InputTurnBeamOff( inputdata_t &inputdata )
|
|
{
|
|
// inputdata should specify a target
|
|
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, inputdata.value.StringID() );
|
|
if ( pTarget )
|
|
{
|
|
Write_BeamOff( pTarget );
|
|
}
|
|
else
|
|
{
|
|
Warning("InputTurnBeamOn could not find object %s", inputdata.value.String() );
|
|
}
|
|
}
|
|
|
|
|
|
void CNPC_Advisor::InputElightOn( inputdata_t &inputdata )
|
|
{
|
|
EntityMessageBegin( this, true );
|
|
WRITE_BYTE( ADVISOR_MSG_START_ELIGHT );
|
|
MessageEnd();
|
|
}
|
|
|
|
void CNPC_Advisor::InputElightOff( inputdata_t &inputdata )
|
|
{
|
|
EntityMessageBegin( this, true );
|
|
WRITE_BYTE( ADVISOR_MSG_STOP_ELIGHT );
|
|
MessageEnd();
|
|
}
|
|
#endif
|
|
|
|
|
|
//==============================================================================================
|
|
// MOTION CALLBACK
|
|
//==============================================================================================
|
|
CAdvisorLevitate::simresult_e CAdvisorLevitate::Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular )
|
|
{
|
|
// this function can be optimized to minimize branching if necessary (PPE branch prediction)
|
|
CNPC_Advisor *pAdvisor = static_cast<CNPC_Advisor *>(m_Advisor.Get());
|
|
Assert(pAdvisor);
|
|
|
|
if ( !OldStyle() )
|
|
{ // independent movement of all objects
|
|
// if an object was recently thrown, just zero out its gravity.
|
|
if (pAdvisor->DidThrow(static_cast<CBaseEntity *>(pObject->GetGameData())))
|
|
{
|
|
linear = Vector( 0, 0, GetCurrentGravity() );
|
|
|
|
return SIM_GLOBAL_ACCELERATION;
|
|
}
|
|
else
|
|
{
|
|
Vector vel; AngularImpulse angvel;
|
|
pObject->GetVelocity(&vel,&angvel);
|
|
Vector pos;
|
|
pObject->GetPosition(&pos,NULL);
|
|
bool bMovingUp = vel.z > 0;
|
|
|
|
// if above top limit and moving up, move down. if below bottom limit and moving down, move up.
|
|
if (bMovingUp)
|
|
{
|
|
if (pos.z > m_vecGoalPos2.z)
|
|
{
|
|
// turn around move down
|
|
linear = Vector( 0, 0, Square((1.0f - m_flFloat)) * GetCurrentGravity() );
|
|
angular = Vector( 0, -5, 0 );
|
|
}
|
|
else
|
|
{ // keep moving up
|
|
linear = Vector( 0, 0, (1.0f + m_flFloat) * GetCurrentGravity() );
|
|
angular = Vector( 0, 0, 10 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pos.z < m_vecGoalPos1.z)
|
|
{
|
|
// turn around move up
|
|
linear = Vector( 0, 0, Square((1.0f + m_flFloat)) * GetCurrentGravity() );
|
|
angular = Vector( 0, 5, 0 );
|
|
}
|
|
else
|
|
{ // keep moving down
|
|
linear = Vector( 0, 0, (1.0f - m_flFloat) * GetCurrentGravity() );
|
|
angular = Vector( 0, 0, 10 );
|
|
}
|
|
}
|
|
|
|
return SIM_GLOBAL_ACCELERATION;
|
|
}
|
|
|
|
//NDebugOverlay::Cross3D(pos,24.0f,255,255,0,true,0.04f);
|
|
|
|
}
|
|
else // old stateless technique
|
|
{
|
|
Warning("Advisor using old-style object movement!\n");
|
|
|
|
/* // obsolete
|
|
CBaseEntity *pEnt = (CBaseEntity *)pObject->GetGameData();
|
|
Vector vecDir1 = m_vecGoalPos1 - pEnt->GetAbsOrigin();
|
|
VectorNormalize( vecDir1 );
|
|
|
|
Vector vecDir2 = m_vecGoalPos2 - pEnt->GetAbsOrigin();
|
|
VectorNormalize( vecDir2 );
|
|
*/
|
|
|
|
linear = Vector( 0, 0, m_flFloat * GetCurrentGravity() );// + m_flFloat * 0.5 * ( vecDir1 + vecDir2 );
|
|
angular = Vector( 0, 0, 10 );
|
|
|
|
return SIM_GLOBAL_ACCELERATION;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//==============================================================================================
|
|
// ADVISOR PHYSICS DAMAGE TABLE
|
|
//==============================================================================================
|
|
static impactentry_t advisorLinearTable[] =
|
|
{
|
|
{ 100*100, 10 },
|
|
{ 250*250, 25 },
|
|
{ 350*350, 50 },
|
|
{ 500*500, 75 },
|
|
{ 1000*1000,100 },
|
|
};
|
|
|
|
static impactentry_t advisorAngularTable[] =
|
|
{
|
|
{ 50* 50, 10 },
|
|
{ 100*100, 25 },
|
|
{ 150*150, 50 },
|
|
{ 200*200, 75 },
|
|
};
|
|
|
|
static impactdamagetable_t gAdvisorImpactDamageTable =
|
|
{
|
|
advisorLinearTable,
|
|
advisorAngularTable,
|
|
|
|
ARRAYSIZE(advisorLinearTable),
|
|
ARRAYSIZE(advisorAngularTable),
|
|
|
|
200*200,// minimum linear speed squared
|
|
180*180,// minimum angular speed squared (360 deg/s to cause spin/slice damage)
|
|
15, // can't take damage from anything under 15kg
|
|
|
|
10, // anything less than 10kg is "small"
|
|
5, // never take more than 1 pt of damage from anything under 15kg
|
|
128*128,// <15kg objects must go faster than 36 in/s to do damage
|
|
|
|
45, // large mass in kg
|
|
2, // large mass scale (anything over 500kg does 4X as much energy to read from damage table)
|
|
1, // large mass falling scale
|
|
0, // my min velocity
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : const impactdamagetable_t
|
|
//-----------------------------------------------------------------------------
|
|
const impactdamagetable_t &CNPC_Advisor::GetPhysicsImpactDamageTable( void )
|
|
{
|
|
return advisor_use_impact_table.GetBool() ? gAdvisorImpactDamageTable : BaseClass::GetPhysicsImpactDamageTable();
|
|
}
|
|
|
|
|
|
|
|
#if NPC_ADVISOR_HAS_BEHAVIOR
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Schedules
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
AI_BEGIN_CUSTOM_NPC( npc_advisor, CNPC_Advisor )
|
|
|
|
DECLARE_TASK( TASK_ADVISOR_FIND_OBJECTS )
|
|
DECLARE_TASK( TASK_ADVISOR_LEVITATE_OBJECTS )
|
|
/*
|
|
DECLARE_TASK( TASK_ADVISOR_PICK_THROW_OBJECT )
|
|
DECLARE_TASK( TASK_ADVISOR_THROW_OBJECT )
|
|
*/
|
|
|
|
DECLARE_CONDITION( COND_ADVISOR_PHASE_INTERRUPT ) // A stage has interrupted us
|
|
|
|
DECLARE_TASK( TASK_ADVISOR_STAGE_OBJECTS ) // haul all the objects into the throw-from slots
|
|
DECLARE_TASK( TASK_ADVISOR_BARRAGE_OBJECTS ) // hurl all the objects in sequence
|
|
|
|
DECLARE_TASK( TASK_ADVISOR_PIN_PLAYER ) // pinion the player to a point in space
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_ADVISOR_COMBAT,
|
|
|
|
" Tasks"
|
|
" TASK_ADVISOR_FIND_OBJECTS 0"
|
|
" TASK_ADVISOR_LEVITATE_OBJECTS 0"
|
|
" TASK_ADVISOR_STAGE_OBJECTS 1"
|
|
" TASK_ADVISOR_BARRAGE_OBJECTS 0"
|
|
" "
|
|
" Interrupts"
|
|
" COND_ADVISOR_PHASE_INTERRUPT"
|
|
" COND_ENEMY_DEAD"
|
|
)
|
|
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_ADVISOR_IDLE_STAND,
|
|
|
|
" Tasks"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_WAIT 3"
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_SEE_FEAR"
|
|
" COND_ADVISOR_PHASE_INTERRUPT"
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_ADVISOR_TOSS_PLAYER,
|
|
|
|
" Tasks"
|
|
" TASK_ADVISOR_FIND_OBJECTS 0"
|
|
" TASK_ADVISOR_LEVITATE_OBJECTS 0"
|
|
" TASK_ADVISOR_PIN_PLAYER 0"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
AI_END_CUSTOM_NPC()
|
|
#endif
|