You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
499 lines
14 KiB
499 lines
14 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
//=============================================================================// |
|
|
|
|
|
#include "cbase.h" |
|
|
|
#include "game.h" |
|
#include "ndebugoverlay.h" |
|
|
|
#include "ai_basenpc.h" |
|
#include "ai_hull.h" |
|
#include "ai_node.h" |
|
#include "ai_motor.h" |
|
#include "ai_navigator.h" |
|
#include "ai_hint.h" |
|
#include "scripted.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
//============================================================================= |
|
// PATHING & HIGHER LEVEL MOVEMENT |
|
//----------------------------------------------------------------------------- |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Static debug function to force all selected npcs to go to the |
|
// given node |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CAI_BaseNPC::ForceSelectedGo(CBaseEntity *pPlayer, const Vector &targetPos, const Vector &traceDir, bool bRun) |
|
{ |
|
CAI_BaseNPC *npc = gEntList.NextEntByClass( (CAI_BaseNPC *)NULL ); |
|
|
|
while (npc) |
|
{ |
|
if (npc->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT) |
|
{ |
|
Vector chasePosition = targetPos; |
|
npc->TranslateNavGoal( pPlayer, chasePosition ); |
|
// It it legal to drop me here |
|
Vector vUpBit = chasePosition; |
|
vUpBit.z += 1; |
|
|
|
trace_t tr; |
|
AI_TraceHull( chasePosition, vUpBit, npc->GetHullMins(), |
|
npc->GetHullMaxs(), MASK_NPCSOLID, npc, COLLISION_GROUP_NONE, &tr ); |
|
if (tr.startsolid || tr.fraction != 1.0 ) |
|
{ |
|
NDebugOverlay::BoxAngles(chasePosition, npc->GetHullMins(), |
|
npc->GetHullMaxs(), npc->GetAbsAngles(), 255,0,0,20,0.5); |
|
} |
|
|
|
npc->m_vecLastPosition = chasePosition; |
|
|
|
if (npc->m_hCine != NULL) |
|
{ |
|
npc->ExitScriptedSequence(); |
|
} |
|
|
|
if ( bRun ) |
|
npc->SetSchedule( SCHED_FORCED_GO_RUN ); |
|
else |
|
npc->SetSchedule( SCHED_FORCED_GO ); |
|
npc->m_flMoveWaitFinished = gpGlobals->curtime; |
|
} |
|
npc = gEntList.NextEntByClass(npc); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Static debug function to make all selected npcs run around |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CAI_BaseNPC::ForceSelectedGoRandom(void) |
|
{ |
|
CAI_BaseNPC *npc = gEntList.NextEntByClass( (CAI_BaseNPC *)NULL ); |
|
|
|
while (npc) |
|
{ |
|
if (npc->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT) |
|
{ |
|
npc->SetSchedule( SCHED_RUN_RANDOM ); |
|
npc->GetNavigator()->SetMovementActivity(ACT_RUN); |
|
} |
|
npc = gEntList.NextEntByClass(npc); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity ) |
|
{ |
|
if ( m_NPCState == NPC_STATE_NONE ) |
|
{ |
|
// More than likely being grabbed before first think. Set ideal state to prevent schedule stomp |
|
m_NPCState = m_IdealNPCState; |
|
} |
|
|
|
SetSchedule( scheduleType ); |
|
|
|
SetGoalEnt( pGoalEntity ); |
|
|
|
// HACKHACK: Call through TranslateNavGoal to fixup this goal position |
|
// UNDONE: Remove this and have NPCs that need this functionality fix up paths in the |
|
// movement system instead of when they are specified. |
|
AI_NavGoal_t goal(pGoalEntity->GetAbsOrigin(), movementActivity, AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST); |
|
|
|
TranslateNavGoal( pGoalEntity, goal.dest ); |
|
|
|
return GetNavigator()->SetGoal( goal ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::ScheduledFollowPath( int scheduleType, CBaseEntity *pPathStart, Activity movementActivity ) |
|
{ |
|
if ( m_NPCState == NPC_STATE_NONE ) |
|
{ |
|
// More than likely being grabbed before first think. Set ideal state to prevent schedule stomp |
|
m_NPCState = m_IdealNPCState; |
|
} |
|
|
|
SetSchedule( scheduleType ); |
|
|
|
SetGoalEnt( pPathStart ); |
|
|
|
// HACKHACK: Call through TranslateNavGoal to fixup this goal position |
|
AI_NavGoal_t goal(GOALTYPE_PATHCORNER, pPathStart->GetLocalOrigin(), movementActivity, AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST); |
|
|
|
TranslateNavGoal( pPathStart, goal.dest ); |
|
|
|
return GetNavigator()->SetGoal( goal ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::IsMoving( void ) |
|
{ |
|
return GetNavigator()->IsGoalSet(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
bool CAI_BaseNPC::IsCurTaskContinuousMove() |
|
{ |
|
const Task_t* pTask = GetTask(); |
|
|
|
// This bit of logic strikes me funny, but the case does exist. (sjb) |
|
if( !pTask ) |
|
return true; |
|
|
|
switch( pTask->iTask ) |
|
{ |
|
case TASK_WAIT_FOR_MOVEMENT: |
|
case TASK_MOVE_TO_TARGET_RANGE: |
|
case TASK_MOVE_TO_GOAL_RANGE: |
|
case TASK_WEAPON_RUN_PATH: |
|
case TASK_PLAY_SCENE: |
|
case TASK_RUN_PATH_TIMED: |
|
case TASK_WALK_PATH_TIMED: |
|
case TASK_RUN_PATH_FOR_UNITS: |
|
case TASK_WALK_PATH_FOR_UNITS: |
|
case TASK_RUN_PATH_FLEE: |
|
case TASK_WALK_PATH_WITHIN_DIST: |
|
case TASK_RUN_PATH_WITHIN_DIST: |
|
return true; |
|
break; |
|
|
|
default: |
|
return false; |
|
break; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Used to specify that the NPC has a reason not to use the a navigation node |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::IsUnusableNode(int iNodeID, CAI_Hint *pHint) |
|
{ |
|
if ( m_bHintGroupNavLimiting && m_strHintGroup != NULL_STRING && STRING(m_strHintGroup)[0] != 0 ) |
|
{ |
|
if (!pHint || pHint->GetGroup() != GetHintGroup()) |
|
{ |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Checks the validity of the given route's goaltype |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::ValidateNavGoal() |
|
{ |
|
if (GetNavigator()->GetGoalType() == GOALTYPE_COVER) |
|
{ |
|
// Check if this location will block my enemy's line of sight to me |
|
if (GetEnemy()) |
|
{ |
|
Activity nCoverActivity = GetCoverActivity( GetHintNode() ); |
|
Vector vCoverLocation = GetNavigator()->GetGoalPos(); |
|
|
|
|
|
// For now we have to drop the node to the floor so we can |
|
// get an accurate postion of the NPC. Should change once Ken checks in |
|
float floorZ = GetFloorZ(vCoverLocation); |
|
vCoverLocation.z = floorZ; |
|
|
|
|
|
Vector vEyePos = vCoverLocation + EyeOffset(nCoverActivity); |
|
|
|
if (!IsCoverPosition( GetEnemy()->EyePosition(), vEyePos ) ) |
|
{ |
|
TaskFail(FAIL_BAD_PATH_GOAL); |
|
return false; |
|
} |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
float CAI_BaseNPC::OpenDoorAndWait( CBaseEntity *pDoor ) |
|
{ |
|
float flTravelTime = 0; |
|
|
|
//DevMsg( 2, "A door. "); |
|
if (pDoor && !pDoor->IsLockedByMaster()) |
|
{ |
|
pDoor->Use(this, this, USE_ON, 0.0); |
|
flTravelTime = pDoor->GetMoveDoneTime(); |
|
if ( pDoor->GetEntityName() != NULL_STRING ) |
|
{ |
|
CBaseEntity *pTarget = NULL; |
|
for (;;) |
|
{ |
|
pTarget = gEntList.FindEntityByName( pTarget, pDoor->GetEntityName() ); |
|
|
|
if ( pTarget != pDoor ) |
|
{ |
|
if ( !pTarget ) |
|
break; |
|
|
|
if ( FClassnameIs( pTarget, pDoor->GetClassname() ) ) |
|
{ |
|
pTarget->Use(this, this, USE_ON, 0.0); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return gpGlobals->curtime + flTravelTime; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
bool CAI_BaseNPC::CanStandOn( CBaseEntity *pSurface ) const |
|
{ |
|
if ( !pSurface->IsAIWalkable() ) |
|
{ |
|
return false; |
|
} |
|
|
|
CAI_Navigator *pNavigator = const_cast<CAI_Navigator *>(GetNavigator()); |
|
|
|
if ( pNavigator->IsGoalActive() && |
|
pSurface == pNavigator->GetGoalTarget() ) |
|
return false; |
|
|
|
return BaseClass::CanStandOn( pSurface ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
bool CAI_BaseNPC::IsJumpLegal( const Vector &startPos, const Vector &apex, const Vector &endPos, |
|
float maxUp, float maxDown, float maxDist ) const |
|
{ |
|
if ((endPos.z - startPos.z) > maxUp + 0.1) |
|
return false; |
|
if ((startPos.z - endPos.z) > maxDown + 0.1) |
|
return false; |
|
|
|
if ((apex.z - startPos.z) > maxUp * 1.25 ) |
|
return false; |
|
|
|
float dist = (startPos - endPos).Length(); |
|
if ( dist > maxDist + 0.1) |
|
return false; |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns true if a reasonable jumping distance |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::IsJumpLegal( const Vector &startPos, const Vector &apex, const Vector &endPos ) const |
|
{ |
|
const float MAX_JUMP_RISE = 80.0f; |
|
const float MAX_JUMP_DISTANCE = 250.0f; |
|
const float MAX_JUMP_DROP = 192.0f; |
|
|
|
return IsJumpLegal( startPos, apex, endPos, MAX_JUMP_RISE, MAX_JUMP_DROP, MAX_JUMP_DISTANCE ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns a throw velocity from start to end position |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
Vector CAI_BaseNPC::CalcThrowVelocity(const Vector &startPos, const Vector &endPos, float fGravity, float fArcSize) |
|
{ |
|
// Get the height I have to throw to get to the target |
|
float stepHeight = endPos.z - startPos.z; |
|
float throwHeight = 0; |
|
|
|
// ----------------------------------------------------------------- |
|
// Now calcluate the distance to a point halfway between our current |
|
// and target position. (the apex of our throwing arc) |
|
// ----------------------------------------------------------------- |
|
Vector targetDir2D = endPos - startPos; |
|
targetDir2D.z = 0; |
|
|
|
float distance = VectorNormalize(targetDir2D); |
|
|
|
|
|
// If jumping up we want to throw a bit higher than the height diff |
|
if (stepHeight > 0) |
|
{ |
|
throwHeight = stepHeight + fArcSize; |
|
} |
|
else |
|
{ |
|
throwHeight = fArcSize; |
|
} |
|
// Make sure that I at least catch some air |
|
if (throwHeight < fArcSize) |
|
{ |
|
throwHeight = fArcSize; |
|
} |
|
|
|
|
|
// ------------------------------------------------------------- |
|
// calculate the vertical and horizontal launch velocities |
|
// ------------------------------------------------------------- |
|
float velVert = (float)sqrt(2.0f*fGravity*throwHeight); |
|
|
|
float divisor = velVert; |
|
divisor += (float)sqrt((2.0f*(-fGravity)*(stepHeight-throwHeight))); |
|
|
|
float velHorz = (distance * fGravity)/divisor; |
|
|
|
// ----------------------------------------------------------- |
|
// Make the horizontal throw vector and add vertical component |
|
// ----------------------------------------------------------- |
|
Vector throwVel = targetDir2D * velHorz; |
|
throwVel.z = velVert; |
|
|
|
return throwVel; |
|
} |
|
|
|
bool CAI_BaseNPC::ShouldMoveWait() |
|
{ |
|
return (m_flMoveWaitFinished > gpGlobals->curtime); |
|
} |
|
|
|
float CAI_BaseNPC::GetStepDownMultiplier() const |
|
{ |
|
return m_pNavigator->GetStepDownMultiplier(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: execute any movement this sequence may have |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::AutoMovement( CBaseEntity *pTarget, AIMoveTrace_t *pTraceResult ) |
|
{ |
|
return AutoMovement( GetAnimTimeInterval(), pTarget, pTraceResult ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : flInterval - |
|
// - |
|
// *pTraceResult - |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CAI_BaseNPC::AutoMovement( float flInterval, CBaseEntity *pTarget, AIMoveTrace_t *pTraceResult ) |
|
{ |
|
bool ignored; |
|
Vector newPos; |
|
QAngle newAngles; |
|
|
|
if (flInterval <= 0.0) |
|
return true; |
|
|
|
m_ScheduleState.bTaskRanAutomovement = true; |
|
|
|
if (GetIntervalMovement( flInterval, ignored, newPos, newAngles )) |
|
{ |
|
// DevMsg( "%.2f : (%.1f) %.1f %.1f %.1f\n", gpGlobals->curtime, (newPos - GetLocalOrigin()).Length(), newPos.x, newPos.y, newAngles.y ); |
|
|
|
if ( m_hCine ) |
|
{ |
|
m_hCine->ModifyScriptedAutoMovement( &newPos ); |
|
} |
|
|
|
if (GetMoveType() == MOVETYPE_STEP) |
|
{ |
|
if (!(GetFlags() & FL_FLY)) |
|
{ |
|
if ( !pTarget ) |
|
{ |
|
pTarget = GetNavTargetEntity(); |
|
} |
|
|
|
return ( GetMotor()->MoveGroundStep( newPos, pTarget, newAngles.y, false, true, pTraceResult ) == AIM_SUCCESS ); |
|
} |
|
else |
|
{ |
|
// FIXME: here's no direct interface to a fly motor, plus this needs to support a state where going through the world is okay. |
|
// FIXME: add callbacks into the script system for validation |
|
// FIXME: add function on scripts to force only legal movements |
|
// FIXME: GetIntervalMovement deals in Local space, nor global. Currently now way to communicate that through these interfaces. |
|
SetLocalOrigin( newPos ); |
|
SetLocalAngles( newAngles ); |
|
return true; |
|
} |
|
} |
|
else if (GetMoveType() == MOVETYPE_FLY) |
|
{ |
|
Vector dist = newPos - GetLocalOrigin(); |
|
|
|
VectorScale( dist, 1.0 / flInterval, dist ); |
|
|
|
SetLocalVelocity( dist ); |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: return max 1/10 second rate of turning |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
|
|
float CAI_BaseNPC::MaxYawSpeed( void ) |
|
{ |
|
return 45; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the estimate in seconds before we reach our nav goal. |
|
// -1 means we don't know / haven't calculated it yet. |
|
//----------------------------------------------------------------------------- |
|
float CAI_BaseNPC::GetTimeToNavGoal() |
|
{ |
|
float flDist = GetNavigator()->BuildAndGetPathDistToGoal(); |
|
if ( flDist < 0 ) |
|
{ |
|
return -1.0f; |
|
} |
|
|
|
float flSpeed = GetIdealSpeed(); |
|
|
|
// FIXME: needs to consider stopping time! |
|
if (flSpeed > 0 && flDist > 0) |
|
{ |
|
return flDist / flSpeed; |
|
} |
|
return 0.0; |
|
} |
|
|
|
//=============================================================================
|
|
|