raven/quake4-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
quake4-sdk/source/game/ai/AI.h

1374 lines
49 KiB
C
Raw Permalink Normal View History

as released 2007-06-15
2007-06-15 00:00:00 +00:00
/*
================
AI.h
================
*/
#ifndef __AI_H__
#define __AI_H__
// moved all motion related code to AI_Move.h
#ifndef __AI_MOVE_H__
#include "AI_Move.h"
#endif
#ifndef __AAS_TACTICAL_H__
#include "AAS_tactical.h"
#endif
typedef enum {
AITACTICAL_NONE,
AITACTICAL_MELEE, // Rush towards the enemy and perform melee attacks when within range
AITACTICAL_MOVE_FOLLOW, // Move towards leader, stop when within range
AITACTICAL_MOVE_TETHER, // Move within tether, stop when within tether
AITACTICAL_MOVE_PLAYERPUSH, // Move away when the player pushes us (or another ai entity pushes us that was pushe by player)
AITACTICAL_COVER, // Move to cover and perform attacks from that cover position
AITACTICAL_COVER_FLANK,
AITACTICAL_COVER_ADVANCE,
AITACTICAL_COVER_RETREAT,
AITACTICAL_COVER_AMBUSH,
AITACTICAL_RANGED, // Move to position in which the enemy can be attacked from range, stop when there and attack enemy
AITACTICAL_TURRET, // Stay in current position and attack enemy
AITACTICAL_HIDE, // Move to a position where we cannot be seen by our enemy
AITACTICAL_PASSIVE, // Stay in current position with multiple idles, twitch animations, and conversations
AITACTICAL_MAX
} aiTactical_t;
typedef enum {
AICTRESULT_OK,
AICTRESULT_SKIP,
AICTRESULT_NOMOVE,
} aiCTResult_t;
const int AITACTICAL_NONE_BIT = BIT(AITACTICAL_NONE);
const int AITACTICAL_MELEE_BIT = BIT(AITACTICAL_MELEE);
const int AITACTICAL_MOVE_FOLLOW_BIT = BIT(AITACTICAL_MOVE_FOLLOW);
const int AITACTICAL_MOVE_TETHER_BIT = BIT(AITACTICAL_MOVE_TETHER);
const int AITACTICAL_MOVE_PLAYERPUSH_BIT = BIT(AITACTICAL_MOVE_PLAYERPUSH);
const int AITACTICAL_COVER_BIT = BIT(AITACTICAL_COVER);
const int AITACTICAL_COVER_FLANK_BIT = BIT(AITACTICAL_COVER_FLANK);
const int AITACTICAL_COVER_ADVANCE_BIT = BIT(AITACTICAL_COVER_ADVANCE);
const int AITACTICAL_COVER_RETREAT_BIT = BIT(AITACTICAL_COVER_RETREAT);
const int AITACTICAL_COVER_AMBUSH_BIT = BIT(AITACTICAL_COVER_AMBUSH);
const int AITACTICAL_RANGED_BIT = BIT(AITACTICAL_RANGED);
const int AITACTICAL_TURRET_BIT = BIT(AITACTICAL_TURRET);
const int AITACTICAL_HIDE_BIT = BIT(AITACTICAL_HIDE);
const int AITACTICAL_PASSIVE_BIT = BIT(AITACTICAL_PASSIVE);
const int AITACTICAL_COVER_BITS = (AITACTICAL_COVER_BIT|AITACTICAL_COVER_FLANK_BIT|AITACTICAL_COVER_ADVANCE_BIT|AITACTICAL_COVER_RETREAT_BIT|AITACTICAL_COVER_AMBUSH_BIT);
const int AITACTICAL_RANGED_BITS = (AITACTICAL_RANGED_BIT);
const int AITACTICAL_NONMOVING_BITS = (AITACTICAL_NONE_BIT|AITACTICAL_TURRET_BIT|AITACTICAL_PASSIVE_BIT);
typedef enum {
TALKMSG_NONE,
TALKMSG_PRIMARY,
TALKMSG_SECONDARY,
TALKMSG_LOOP,
} talkMessage_t;
typedef enum {
AIFLAGOVERRIDE_DAMAGE,
AIFLAGOVERRIDE_DISABLEPAIN,
AIFLAGOVERRIDE_NOTURN,
AIFLAGOVERRIDE_NOGRAVITY
} aiFlagOverride_t;
typedef enum {
TALK_NEVER, // Never talk to the player
TALK_DEAD, // Cant talk due to being dead
TALK_OK, // Can talk
TALK_FOLLOW, // Talking to will cause a follow
TALK_BUSY, // Cant talk right now, is busy
TALK_WAIT, // Wait a bit - he's probably in the middle of a conversation (this is so you can still see their names but they won't talk to you when clicked on)
NUM_TALK_STATES
} talkState_t;
//chance that AI will make an announcement when they have the option (0 - 1.0f)
#define AISPEAK_CHANCE 0.2f
typedef enum {
AIFOCUS_NONE,
AIFOCUS_LEADER,
AIFOCUS_TARGET,
AIFOCUS_TALK,
AIFOCUS_PLAYER,
AIFOCUS_USE_DIRECTIONAL_MOVE,
AIFOCUS_ENEMY = AIFOCUS_USE_DIRECTIONAL_MOVE,
AIFOCUS_COVER,
AIFOCUS_COVERLOOK,
AIFOCUS_HELPER,
AIFOCUS_TETHER,
AIFOCUS_MAX
} aiFocus_t;
typedef enum {
AIMOVESPEED_DEFAULT, // Choose run/walk depending on situation
AIMOVESPEED_RUN, // Always run
AIMOVESPEED_WALK, // alwasy walk
} aiMoveSpeed_t;
typedef struct rvAIFuncs_s {
rvScriptFuncUtility first_sight; // script to run when an enemy is first sighted
rvScriptFuncUtility sight; // script to run every time an enemy is sighted
rvScriptFuncUtility pain; // script to run when the AI takes pain
rvScriptFuncUtility damage; // script to run when the AI takes damage
rvScriptFuncUtility death; // script to run when the AI dies
rvScriptFuncUtility attack; // script to run when attacking an enemy
rvScriptFuncUtility init; // script to run on initialization
rvScriptFuncUtility onclick; // script to run when a friendly AI is clicked on
rvScriptFuncUtility launch_projectile; // script to run when a projectile is launched
rvScriptFuncUtility footstep; // script to run on a footstep
} rvAIFuncs_t;
typedef struct rvAICombat_s{
struct combatFlags_s {
bool ignoreEnemies :1;
bool alert :1;
bool aware :1;
bool tetherNoBreak :1; // Set to true to prevent enemies from breaking tethers
bool tetherAutoBreak :1; // Set to true to automatically break tethers when within range
bool tetherOutOfRange :1; // Set to true when we are out of range of our curren tether
bool seenEnemyDirectly :1; // Has directly seen an enemy (as opposed to having heard or been told about him)
bool noChatter :1; // No combat announcements
bool crouchViewClear :1; // Can I crouch at the position that I stopped at?
} fl;
float max_chasing_turn;
float shotAtTime;
float shotAtAngle;
idVec2 hideRange;
idVec2 attackRange;
int attackSightDelay;
float meleeRange;
float aggressiveRange; // Range to become more aggressive
float aggressiveScale; // Scale to use when altering numbers due to aggression
int investigateTime;
float visStandHeight; // Height to check enemy visibiliy while standing
float visCrouchHeight; // Height to check enemy visiblity while crouching
float visRange; // Maximum distance to check enemy visibility
float earRange; // Maximum distance to check hearing an enemy from
float awareRange; // Distance to become automatically aware of an enemy
int tacticalMaskAvailable; // Currently available tactical states
int tacticalMaskUpdate; // states currently being evaluated
aiTactical_t tacticalCurrent; // Current tactical state
int tacticalUpdateTime; // Last time the tacitcal state was updated (for delaying updating)
int tacticalPainTaken; // Amount of damage taken in the current tactical state
int tacticalPainThreshold; // Threshold of pain before invalidating the current tactical state
int tacticalFlinches; // Number of flinches that have occured at the current tactical state
float threatBase; // Base amount of threat generated by AI
float threatCurrent; // Current amount of threat generatd by AI based on current state
int maxLostVisTime;
int coverValidTime;
int maxInvalidCoverTime;
} rvAICombat_t;
typedef struct rvAIPain_s {
float threshold;
float takenThisFrame;
int lastTakenTime;
int loopEndTime;
idStr loopType;
} rvAIPain_t;
typedef struct rvAIEnemy_s {
struct flags_s {
bool lockOrigin :1; // Stop tracking enemy origin until state changes
bool dead :1; // Enemy is dead
bool inFov :1; // Enemy is currently in fov
bool sighted :1; // Enemy was sighted at least once
bool visible :1; // Enemy is visible?
} fl;
idEntityPtr<idEntity> ent;
int lastVisibleChangeTime; // last time the visible state of the enemy changed
idVec3 lastVisibleFromEyePosition; // Origin used in last successfull visibility check
idVec3 lastVisibleEyePosition; // Origin of last known visible eye position
idVec3 lastVisibleChestPosition; // Origin of last known visible chest position
int lastVisibleTime; // Time we last saw and enemy
idVec3 smoothedLinearVelocity;
idVec3 smoothedPushedVelocity;
float smoothVelocityRate;
idVec3 lastKnownPosition; // last place the enemy was known to be (does not mean visiblity)
float range; // range to enemy
float range2d; // 2d range to enemy
int changeTime; // Time enemy was last changed
int checkTime; // Time we last checked for a new enemy
} rvAIEnemy_t;
typedef struct rvAIPassive_s {
struct flags_s {
bool disabled :1; // No advanced passive state
bool multipleIdles :1; // Has multiple idle animations to play
bool fidget :1; // Has fidget animations
} fl;
idStr animIdlePrefix;
idStr animFidgetPrefix;
idStr animTalkPrefix;
//idStr talkPrefix;
idStr prefix;
idStr idleAnim;
int idleAnimChangeTime;
int fidgetTime;
int talkTime;
} rvAIPassive_t;
typedef struct rvAIAttackAnimInfo_s {
idVec3 attackOffset;
idVec3 eyeOffset;
} rvAIAttackAnimInfo_t;
#define AIACTIONF_ATTACK BIT(0)
#define AIACTIONF_MELEE BIT(1)
class rvAIActionTimer {
public:
rvAIActionTimer ( void );
bool Init ( const idDict& args, const char* name );
void Save ( idSaveGame *savefile ) const;
void Restore ( idRestoreGame *savefile );
void Clear ( int currentTime );
void Reset ( int currentTime, float diversity = 0.0f, float scale = 1.0f );
void Add ( int _time, float diversity = 0.0f );
bool IsDone ( int currentTime ) const;
int GetTime ( void ) const;
int GetRate ( void ) const;
protected:
int time;
int rate;
};
ID_INLINE bool rvAIActionTimer::IsDone ( int currentTime ) const {
return currentTime >= time;
}
ID_INLINE int rvAIActionTimer::GetTime ( void ) const {
return time;
}
ID_INLINE int rvAIActionTimer::GetRate ( void ) const {
return rate;
}
class rvAIAction {
public:
rvAIAction ( void );
bool Init ( const idDict& args, const char* name, const char* defaultState, int flags );
void Save ( idSaveGame *savefile ) const;
void Restore ( idRestoreGame *savefile );
enum EStatus {
STATUS_UNUSED,
STATUS_OK, // action was performed
STATUS_FAIL_DISABLED, // action is current disabled
STATUS_FAIL_TIMER, // actions timer has not finished
STATUS_FAIL_EXTERNALTIMER, // external timer passed in to PerformAction has not finished
STATUS_FAIL_MINRANGE, // enemy is not within minimum range
STATUS_FAIL_MAXRANGE, // enemy is out of maximum range
STATUS_FAIL_CHANCE, // action chance check failed
STATUS_FAIL_ANIM, // bad animation
STATUS_FAIL_CONDITION, // condition given to PerformAction failed
STATUS_FAIL_NOENEMY, // enemy cant be attacked
STATUS_MAX
};
struct flags_s {
bool disabled :1; // action disabled?
bool noPain :1; // no pain during action
bool noTurn :1; // no turning during action
bool isAttack :1; // attack?
bool isMelee :1; // melee?
bool overrideLegs :1; // override legs on this action?
bool noSimpleThink :1; // dont use simple think logic for this action
} fl;
idStrList anims;
idStr state;
rvAIActionTimer timer;
int blendFrames;
int failRate;
float minRange;
float maxRange;
float minRange2d;
float maxRange2d;
float chance;
float diversity;
EStatus status;
};
typedef bool (idAI::*checkAction_t)(rvAIAction*,int);
class rvPlaybackDriver
{
public:
rvPlaybackDriver( void ) { mPlaybackDecl = NULL; mOldPlaybackDecl = NULL; }
bool Start( const char *playback, idEntity *owner, int flags, int numFrames );
bool UpdateFrame( idEntity *ent, rvDeclPlaybackData &out );
void EndFrame( void );
bool IsActive( void ) { return( !!mPlaybackDecl || !!mOldPlaybackDecl ); }
const char *GetDestination( void );
// cnicholson: Begin Added save/restore functionality
void Save ( idSaveGame *savefile ) const;
void Restore ( idRestoreGame *savefile );
// cnicholson: End Added save/restore functionality
private:
int mLastTime;
int mTransitionTime;
int mStartTime;
int mFlags;
const rvDeclPlayback *mPlaybackDecl;
idVec3 mOffset;
int mOldStartTime;
int mOldFlags;
const rvDeclPlayback *mOldPlaybackDecl;
idVec3 mOldOffset;
};
/*
===============================================================================
idAI
===============================================================================
*/
const float AI_TURN_SCALE = 60.0f;
const float AI_SEEK_PREDICTION = 0.3f;
const float AI_FLY_DAMPENING = 0.15f;
const float AI_HEARING_RANGE = 2048.0f;
const float AI_COVER_MINRANGE = 4.0f;
const float AI_PAIN_LOOP_DELAY = 200;
const int DEFAULT_FLY_OFFSET = 68.0f;
#define ATTACK_IGNORE 0
#define ATTACK_ON_DAMAGE BIT(0)
#define ATTACK_ON_ACTIVATE BIT(1)
#define ATTACK_ON_SIGHT BIT(2)
// defined in script/ai_base.script. please keep them up to date.
#define DI_NODIR -1
//
// events
//
extern const idEventDef AI_DirectDamage;
extern const idEventDef AI_JumpFrame;
extern const idEventDef AI_EnableClip;
extern const idEventDef AI_DisableClip;
extern const idEventDef AI_EnableGravity;
extern const idEventDef AI_DisableGravity;
extern const idEventDef AI_EnablePain;
extern const idEventDef AI_DisablePain;
extern const idEventDef AI_EnableTarget;
extern const idEventDef AI_DisableTarget;
extern const idEventDef AI_EnableMovement;
extern const idEventDef AI_DisableMovement;
extern const idEventDef AI_Vagary_ChooseObjectToThrow;
extern const idEventDef AI_Speak;
extern const idEventDef AI_SpeakRandom;
extern const idEventDef AI_Attack;
extern const idEventDef AI_AttackMelee;
extern const idEventDef AI_WaitMove;
extern const idEventDef AI_EnableDamage;
extern const idEventDef AI_DisableDamage;
extern const idEventDef AI_LockEnemyOrigin;
extern const idEventDef AI_SetEnemy;
extern const idEventDef AI_ScriptedAnim;
extern const idEventDef AI_ScriptedDone;
extern const idEventDef AI_ScriptedStop;
extern const idEventDef AI_SetScript;
extern const idEventDef AI_BecomeSolid;
extern const idEventDef AI_BecomePassive;
extern const idEventDef AI_BecomeAggressive;
extern const idEventDef AI_SetHealth;
extern const idEventDef AI_TakeDamage;
extern const idEventDef AI_EnableBlink;
extern const idEventDef AI_DisableBlink;
extern const idEventDef AI_EnableAutoBlink;
extern const idEventDef AI_DisableAutoBlink;
class idPathCorner;
class idProjectile;
class rvSpawner;
class rvAIHelper;
class rvAITether;
class idAI : public idActor {
friend class rvAIManager;
friend class idAASFindAttackPosition;
public:
CLASS_PROTOTYPE( idAI );
idAI();
~idAI();
void Save ( idSaveGame *savefile ) const;
void Restore ( idRestoreGame *savefile );
void Spawn ( void );
virtual void TalkTo ( idActor *actor );
idEntity* GetEnemy ( void ) const;
idEntity* GetGoalEntity ( void ) const;
talkState_t GetTalkState ( void ) const;
const idVec2& GetAttackRange ( void ) const;
const idVec2& GetFollowRange ( void ) const;
int GetTravelFlags ( void ) const;
void TouchedByFlashlight ( idActor *flashlight_owner );
idEntity * FindEnemy ( bool inFov, bool forceNearest, float maxDistSqr = 0.0f );
void SetSpawner ( rvSpawner* _spawner );
rvSpawner* GetSpawner ( void );
idActor* GetLeader ( void ) const;
// Outputs a list of all monsters to the console.
static void List_f( const idCmdArgs &args );
// Add some dynamic externals for debugging
virtual void GetDebugInfo ( debugInfoProc_t proc, void* userData );
bool IsEnemyVisible ( void ) const;
bool InCoverMode ( void ) const;
bool InCrouchCoverMode ( void ) const;
bool LookAtCoverTall ( void ) const;
bool InLookAtCoverMode ( void ) const;
bool IsBehindCover ( void ) const;
bool IsLipSyncing ( void ) const;
bool IsSpeaking ( void ) const;
bool IsFacingEnt ( idEntity* targetEnt );
bool IsCoverValid ( void ) const;
virtual bool IsCrouching ( void ) const;
public:
idLinkList<idAI> simpleThinkNode;
// navigation
idAAS* aas;
idAASCallback* aasFind;
// movement
idMoveState move;
idMoveState savedMove;
// physics
idPhysics_Monster physicsObj;
// weapon/attack vars
bool lastHitCheckResult;
int lastHitCheckTime;
int lastAttackTime;
float projectile_height_to_distance_ratio; // calculates the maximum height a projectile can be thrown
idList<rvAIAttackAnimInfo_t> attackAnimInfo;
mutable idClipModel* projectileClipModel;
idEntityPtr<idProjectile> projectile;
// chatter/talking
int chatterTime;
int chatterRateCombat;
int chatterRateIdle;
talkState_t talkState;
idEntityPtr<idActor> talkTarget;
talkMessage_t talkMessage;
int talkBusyCount;
int speakTime;
// Focus
idEntityPtr<idEntity> lookTarget;
aiFocus_t focusType;
idEntityPtr<idEntity> focusEntity;
float focusRange;
int focusAlignTime;
int focusTime;
idVec3 currentFocusPos;
// Looking
bool allowJointMod;
int alignHeadTime;
int forceAlignHeadTime;
idAngles eyeAng;
idAngles lookAng;
idAngles destLookAng;
idAngles lookMin;
idAngles lookMax;
idList<jointHandle_t> lookJoints;
idList<idAngles> lookJointAngles;
float eyeVerticalOffset;
float eyeHorizontalOffset;
float headFocusRate;
float eyeFocusRate;
// joint controllers
idAngles eyeMin;
idAngles eyeMax;
jointHandle_t orientationJoint;
idEntityPtr<idEntity> pusher;
idEntityPtr<idEntity> scriptedActionEnt;
// script variables
struct aiFlags_s {
bool awake :1; // set to false until state_wakeup is called.
bool damage :1;
bool pain :1;
bool dead :1;
bool activated :1;
bool jump :1;
bool hitEnemy :1;
bool pushed :1;
bool disableAttacks :1;
bool scriptedEndWithIdle :1;
bool scriptedNeverDormant :1; // Prevent going dormant while in scripted sequence
bool scripted :1;
bool simpleThink :1;
bool ignoreFlashlight :1;
bool action :1;
bool lookAtPlayer :1;
bool disableLook :1;
bool undying :1;
bool tetherMover :1; // Currently using a dynamic tether to a mover
bool meleeSuperhero :1;
bool killerGuard :1; // Do 100 points of damage with each hit
} aifl;
//
// ai/ai.cpp
//
void SetAAS ( void );
virtual void DormantBegin ( void ); // called when entity becomes dormant
virtual void DormantEnd ( void ); // called when entity wakes from being dormant
virtual void Think ( void );
void Activate ( idEntity *activator );
virtual void Hide ( void );
virtual void Show ( void );
virtual void AdjustHealthByDamage ( int inDamage );
void CalculateAttackOffsets ( void );
void InitNonPersistentSpawnArgs ( void );
/*
===============================================================================
Speaking & Chatter
===============================================================================
*/
public:
bool Speak ( const char *speechDecl, bool random = false );
void StopSpeaking ( bool stopAnims );
virtual void CheckBlink ( void );
protected:
virtual bool CanPlayChatterSounds ( void ) const;
void UpdateChatter ( void );
/*
===============================================================================
Movement
===============================================================================
*/
// static helper functions
public:
// Finds a path around dynamic obstacles.
static bool FindPathAroundObstacles ( const idPhysics *physics, const idAAS *aas, const idEntity *ignore, const idVec3 &startPos, const idVec3 &seekPos, obstaclePath_t &path );
// Frees any nodes used for the dynamic obstacle avoidance.
static void FreeObstacleAvoidanceNodes ( void );
// Predicts movement, returns true if a stop event was triggered.
static bool PredictPath ( const idEntity *ent, const idAAS *aas, const idVec3 &start, const idVec3 &velocity, int totalTime, int frameTime, int stopEvent, predictedPath_t &path, const idEntity *ignore = NULL );
// Return true if the trajectory of the clip model is collision free.
static bool TestTrajectory ( const idVec3 &start, const idVec3 &end, float zVel, float gravity, float time, float max_height, const idClipModel *clip, int clipmask, const idEntity *ignore, const idEntity *targetEntity, int drawtime );
// Finds the best collision free trajectory for a clip model.
static bool PredictTrajectory ( const idVec3 &firePos, const idVec3 &target, float projectileSpeed, const idVec3 &projGravity, const idClipModel *clip, int clipmask, float max_height, const idEntity *ignore, const idEntity *targetEntity, int drawtime, idVec3 &aimDir );
// special flying code
void AdjustFlyingAngles ( void );
void AddFlyBob ( idVec3 &vel );
void AdjustFlyHeight ( idVec3 &vel, const idVec3 &goalPos );
void FlySeekGoal ( idVec3 &vel, idVec3 &goalPos );
void AdjustFlySpeed ( idVec3 &vel );
void FlyTurn ( void );
// movement types
void Move ( void );
virtual void DeadMove ( void );
void AnimMove ( void );
void SlideMove ( void );
void PlaybackMove ( void );
void FlyMove ( void );
void StaticMove ( void );
void RVMasterMove ( void );
void SetMoveType ( moveType_t moveType );
//twhitaker: added custom move type
virtual void CustomMove ( void );
// movement actions
void KickObstacles ( const idVec3 &dir, float force, idEntity *alwaysKick );
// steering
virtual void ApplyImpulse ( idEntity *ent, int id, const idVec3 &point, const idVec3 &impulse, bool splash = false );
void GetAnimMoveDelta ( const idMat3 &oldaxis, const idMat3 &axis, idVec3 &delta );
void CheckObstacleAvoidance ( const idVec3 &goalPos, idVec3 &newPos, idReachability* goalReach=0 );
bool GetMovePos ( idVec3 &seekPos, idReachability** seekReach=0 );
// navigation
float TravelDistance ( const idVec3 &end ) const;
float TravelDistance ( const idVec3 &start, const idVec3 &end ) const;
float TravelDistance ( idEntity* ent ) const;
float TravelDistance ( idEntity* start, idEntity* end ) const;
int PointReachableAreaNum ( const idVec3 &pos, const float boundsScale = 2.0f ) const;
bool PathToGoal ( aasPath_t &path, int areaNum, const idVec3 &origin, int goalAreaNum, const idVec3 &goalOrigin ) const;
void BlockedFailSafe ( void );
// turning
void Turn ( void );
bool TurnToward ( float yaw );
bool TurnToward ( const idVec3 &pos );
bool TurnTowardLeader ( bool faceLeaderByDefault=false );
bool FacingIdeal ( void );
bool DirectionalTurnToward ( const idVec3 &pos );
// movement control
bool FaceEnemy ( void );
bool FaceEntity ( idEntity *ent );
bool SlideToPosition ( const idVec3 &pos, float time );
bool WanderAround ( void );
bool StepDirection ( float dir );
bool NewWanderDir ( const idVec3 &dest );
/*
===============================================================================
Reactions
===============================================================================
*/
void ReactToShotAt ( idEntity* attacker, const idVec3 &origOrigin, const idVec3 &origDir );
void ReactToPain ( idEntity* attacker, int damage );
/*
===============================================================================
AI helpers
===============================================================================
*/
public:
void UpdateHelper ( void );
rvAIHelper* GetActiveHelper ( void );
/*
===============================================================================
Sensory Perception
===============================================================================
*/
public:
const idVec3& LastKnownPosition ( const idEntity *ent );
const idVec3& LastKnownFacing ( const idEntity *ent );
idEntity * HeardSound ( int ignore_team );
int ReactionTo ( const idEntity *ent );
void SetLastVisibleEnemyTime ( int time=-1/* DEFAULT IS CURRENT TIME*/ );
bool IsEnemyRecentlyVisible ( float maxLostVisTimeScale = 1.0f ) const;
/*
===============================================================================
Passive
===============================================================================
*/
public:
void SetTalkState ( talkState_t state );
void SetPassivePrefix ( const char* prefix );
protected:
bool GetPassiveAnimPrefix ( const char* animName, idStr& animPrefix );
/*
===============================================================================
Combat
===============================================================================
*/
public:
// enemy managment
bool SetEnemy ( idEntity *newEnemy );
void ClearEnemy ( bool dead = false );
void UpdateEnemy ( void );
void UpdateEnemyPosition ( bool force = true );
void UpdateEnemyVisibility ( void );
// Attack direction
bool GetAimDir ( const idVec3& source, const idEntity* aimAtEnt, const idDict* projectileDict, idEntity *ignore, idVec3 &aimDir, float aimOffset, float predict ) const;
void GetPredictedAimDirOffset ( const idVec3& source, const idVec3& target, float projectileSpeed, const idVec3& targetVelocity, idVec3& offset ) const;
// damage
virtual bool Pain ( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location );
virtual void Killed ( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location );
bool CheckDeathCausesMissionFailure ( void );
// attacks
virtual bool Attack ( const char* attackName, jointHandle_t joint, idEntity* target, const idVec3& pushVelocity = vec3_origin );
virtual idProjectile* AttackRanged ( const char* attackName, const idDict* attackDict, jointHandle_t joint, idEntity* target, const idVec3& pushVelocity = vec3_origin );
virtual idProjectile* AttackProjectile ( const idDict* projectileDict, const idVec3 &org, const idAngles &ang );
virtual bool AttackMelee ( const char* attackName, const idDict* meleeDict );
void CreateProjectileClipModel ( void ) const;
idProjectile* CreateProjectile ( const idDict* projectileDict, const idVec3 &pos, const idVec3 &dir );
void RemoveProjectile ( void );
virtual void DamageFeedback ( idEntity *victim, idEntity *inflictor, int &damage );
void DirectDamage ( const char *meleeDefName, idEntity *ent );
bool TestMelee ( void ) const;
void PushWithAF ( void );
bool IsMeleeNeeded ( void );
// special effects
void GetMuzzle ( jointHandle_t joint, idVec3 &muzzle, idMat3 &axis );
void LerpLookAngles ( idAngles &curAngles, idAngles newAngles, float orientationJointYaw, float focusRate );
virtual bool UpdateAnimationControllers ( void );
// AI script state management
void UpdateStates ( void );
void UpdateFocus ( const idMat3& orientationAxis );
void SetFocus ( aiFocus_t focus, int time );
// event?
virtual void FootStep ( void );
void CreateMissile ( jointHandle_t joint );
void RadiusDamageFromJoint ( const char *jointname, const char *damageDefName );
void BecomeSolid ( void );
void BecomeNonSolid ( void );
const char * ChooseAnim ( int channel, const char *animname );
//
// ai/ai_events.cpp
//
public:
virtual bool CanTakeDamage ( void ) const;
virtual bool CanTakePain ( void ) const;
virtual bool CanTurn ( void ) const;
virtual bool CanMove ( void ) const;
virtual bool CanAnnounce ( float chance ) const;
virtual bool SkipCurrentDestination ( void ) const;
// ----------------------------- Functions ------------------------------------
virtual bool DoDormantTests ( void );
void OverrideFlag ( aiFlagOverride_t flag, bool value );
void RestoreFlag ( aiFlagOverride_t flag );
virtual bool SkipImpulse ( idEntity *ent, int id );
virtual const char* GetIdleAnimName ( void );
bool RespondToFlashlight ( void ) { return !aifl.ignoreFlashlight;}
bool ForceFaceEnemy ( void ) { return ( move.moveCommand == MOVE_TO_ENEMY ); }
bool CanBecomeSolid ( void );
bool CanHitEnemyFromAnim ( int animNum, idVec3 offset = vec3_origin );
bool CanHitEnemy ( void );
bool CanHitEnemyFromJoint ( const char *jointname );
float GetTurnDelta ( void );
int TestTrajectory ( const idVec3 &firePos, const idVec3 &target, const char *projectileName );
bool TestAnimMove ( int animNum, idEntity *ignore = NULL, idVec3 *pMoveVec = NULL );
void ExecScriptFunction ( rvScriptFuncUtility& func, idEntity* parm = NULL );
void SetLeader ( idEntity *newLeader );
int CheckMelee ( bool disableAttack );
bool CheckForEnemy ( bool useFov, bool force = false );
bool CheckForCloserEnemy ( void );
bool CheckForReplaceEnemy ( idEntity* replacement );
bool CheckForTeammateEnemy ( void );
void DrawSuspicion ( void );
float RateSuspiciousness ( idActor* shady, bool rateSound = false );
void RateSuspicionLevel ( void );
void UpdatePlayback ( idVec3 &goalPos, idVec3 &delta, idVec3 &oldorigin, idMat3 &oldaxis );
void LookAtEntity ( idEntity *ent, float duration );
// ----------------------------- Variables ------------------------------------
int actionAnimNum; // Index of animation to use for the upcoming action
int actionTime; // Time line for actions (time is stopped when an action is running)
int actionSkipTime; // Time to use if an action is skipped by another
int flagOverrides;
float announceRate; // How often (0 - 1.0f) the AI will make certain announcements.
rvAICombat_t combat; // Members related to combat state
rvAIPassive_t passive; // Members related to passive state
rvAIEnemy_t enemy; // Members related to tracking enemies
rvAIPain_t pain;
rvAIFuncs_t funcs;
rvPlaybackDriver mPlayback;
rvPlaybackDriver mLookPlayback;
rvAASTacticalSensor* aasSensor;
idEntityPtr<rvAITether> tether;
idEntityPtr<rvAIHelper> helperCurrent;
idEntityPtr<rvAIHelper> helperIdeal;
idEntityPtr<idActor> leader;
idEntityPtr<rvSpawner> spawner;
bool ValidateCover ( void );
virtual bool UpdateRunStatus ( void );
bool UpdateTactical ( int delay = 0 );
void ForceTacticalUpdate ( void );
bool UpdateTactical_r ( void );
virtual int FilterTactical ( int availableTactical );
void WakeUpTargets ( void );
virtual aiCTResult_t CheckTactical ( aiTactical_t tactical );
void Begin ( void );
void WakeUp ( void );
virtual void Prethink ( void );
virtual void Postthink ( void );
/*
===============================================================================
Threat Management
===============================================================================
*/
protected:
virtual void UpdateThreat ( void );
virtual float CalculateEnemyThreat ( idEntity* enemy );
/*
===============================================================================
Tethers
===============================================================================
*/
public:
virtual bool IsTethered ( void ) const;
bool IsWithinTether ( void ) const;
rvAITether* GetTether ( void );
virtual void SetTether ( rvAITether* newTether );
/*
===============================================================================
Scripting
===============================================================================
*/
public:
void ScriptedMove ( idEntity* destEnt, float minDist, bool endWithIdle );
void ScriptedFace ( idEntity* faceEnt, bool endWithIdle );
void ScriptedAnim ( const char* animname, int blendFrames, bool loop, bool endWithIdle );
void ScriptedPlaybackMove ( const char* playback, int flags, int numFrames );
void ScriptedPlaybackAim ( const char* playback, int flags, int numFrames );
void ScriptedAction ( idEntity* actionEnt, bool endWithIdle );
void ScriptedStop ( void );
void SetScript ( const char* scriptName, const char* funcName );
private:
bool ScriptedBegin ( bool endWithIdle, bool allowDormant = false );
void ScriptedEnd ( void );
/*
===============================================================================
Handlers
===============================================================================
*/
protected:
virtual void OnDeath ( void );
virtual void OnStateChange ( int channel );
virtual void OnUpdatePlayback ( const rvDeclPlaybackData& pbd );
virtual void OnEnemyChange ( idEntity* oldEnemy );
virtual void OnLeaderChange ( idEntity* oldLeader );
virtual void OnStartMoving ( void );
virtual void OnStopMoving ( aiMoveCommand_t oldMoveCommand );
virtual void OnTacticalChange ( aiTactical_t oldTactical );
virtual void OnFriendlyFire ( idActor* attacker );
virtual void OnWakeUp ( void );
virtual void OnTouch ( idEntity *other, trace_t *trace );
virtual void OnCoverInvalidated ( void );
virtual void OnCoverNotFacingEnemy ( void );
virtual void OnEnemyVisiblityChange ( bool oldVisible );
virtual void OnStartAction ( void );
virtual void OnStopAction ( void );
virtual void OnSetKey ( const char* key, const char* value );
/*
===============================================================================
Movement / Turning
===============================================================================
*/
protected:
bool StartMove ( aiMoveCommand_t command, const idVec3& goalOrigin, int goalArea, idEntity* goalEntity, aasFeature_t* feature, float range );
void StopMove ( moveStatus_t status );
bool MoveTo ( const idVec3 &pos, float range = 0.0f );
bool MoveToAttack ( idEntity *ent, int attack_anim );
bool MoveToTether ( rvAITether* tether );
virtual bool MoveToEnemy ( void );
bool MoveToEntity ( idEntity *ent, float range = 0.0f );
bool MoveToCover ( float minRange, float maxRange, aiTactical_t coverType );
bool MoveToHide ( void );
bool MoveOutOfRange ( idEntity *entity, float range, float minRange=0.0f );
void AnimTurn ( float angles, bool force );
bool ReachedPos ( const idVec3 &pos, const aiMoveCommand_t moveCommand, float range = 0.0f ) const;
/*
===============================================================================
Debug
===============================================================================
*/
public:
void DrawRoute ( void ) const;
void DrawTactical ( void );
/*
===============================================================================
Announcements
===============================================================================
*/
public:
bool ActorIsBehindActor ( idActor* ambusher, idActor* victim );
void AnnounceNewEnemy ( void );
void AnnounceKill ( idActor *victim );
void AnnounceTactical ( aiTactical_t newTactical );
void AnnounceSuppressed ( idActor *suppressor );
void AnnounceSuppressing ( void );
void AnnounceFlinch ( idEntity *attacker );
void AnnounceInjured ( void );
void AnnounceFriendlyFire ( idActor* attacker );
void AnnounceGrenade ( void );
void AnnounceGrenadeThrow ( void );
/*
===============================================================================
Actions
===============================================================================
*/
protected:
rvAIActionTimer actionTimerRangedAttack;
rvAIActionTimer actionTimerEvade;
rvAIActionTimer actionTimerSpecialAttack;
rvAIActionTimer actionTimerPain;
rvAIAction actionEvadeLeft;
rvAIAction actionEvadeRight;
rvAIAction actionRangedAttack;
rvAIAction actionMeleeAttack;
rvAIAction actionLeapAttack;
rvAIAction actionJumpBack;
bool UpdateAction ( void );
virtual bool CheckActions ( void );
virtual bool CheckPainActions ( void );
bool PerformAction ( rvAIAction* action, bool (idAI::*)(rvAIAction*,int), rvAIActionTimer* timer = NULL );
void PerformAction ( const char* stateName, int blendFrames = 0, bool noPain = false );
// RAVEN BEGIN
// twhitaker: needed this for difficulty settings
virtual void Event_PostSpawn ( void );
// RAVEN END
public:
virtual bool CheckAction_EvadeLeft ( rvAIAction* action, int animNum );
virtual bool CheckAction_EvadeRight ( rvAIAction* action, int animNum );
virtual bool CheckAction_RangedAttack ( rvAIAction* action, int animNum );
virtual bool CheckAction_MeleeAttack ( rvAIAction* action, int animNum );
bool CheckAction_LeapAttack ( rvAIAction* action, int animNum );
virtual bool CheckAction_JumpBack ( rvAIAction* action, int animNum );
/*
===============================================================================
Events
===============================================================================
*/
private:
// Orphaned events
void Event_ClosestReachableEnemyOfEntity ( idEntity *team_mate );
void Event_GetReachableEntityPosition ( idEntity *ent );
void Event_EntityInAttackCone ( idEntity *ent );
void Event_TestAnimMoveTowardEnemy ( const char *animname );
void Event_TestAnimMove ( const char *animname );
void Event_TestMoveToPosition ( const idVec3 &position );
void Event_TestMeleeAttack ( void );
void Event_TestAnimAttack ( const char *animname );
void Event_SaveMove ( void );
void Event_RestoreMove ( void );
void Event_ThrowMoveable ( void );
void Event_ThrowAF ( void );
void Event_PredictEnemyPos ( float time );
void Event_FindActorsInBounds ( const idVec3 &mins, const idVec3 &maxs );
void Event_Activate ( idEntity *activator );
void Event_Touch ( idEntity *other, trace_t *trace );
void Event_LookAt ( idEntity* lookAt );
void Event_SetAngles ( idAngles const &ang );
void Event_SetEnemy ( idEntity *ent );
void Event_SetHealth ( float newHealth );
void Event_SetTalkTarget ( idEntity *target );
void Event_SetTalkState ( int state );
void Event_SetLeader ( idEntity *newLeader );
void Event_SetScript ( const char* scriptName, const char* funcName );
void Event_SetMoveSpeed ( int speed );
void Event_SetPassivePrefix ( const char* prefix );
void Event_GetAngles ( void );
void Event_GetEnemy ( void );
void Event_GetLeader ( void );
void Event_Attack ( const char* attackName, const char* jointName );
void Event_AttackMelee ( const char *meleeDefName );
void Event_DirectDamage ( idEntity *damageTarget, const char *damageDefName );
void Event_RadiusDamageFromJoint ( const char *jointname, const char *damageDefName );
void Event_CanBecomeSolid ( void );
void Event_BecomeSolid ( void );
void Event_BecomeNonSolid ( void );
void Event_BecomeRagdoll ( void );
void Event_StopRagdoll ( void );
void Event_FaceEnemy ( void );
void Event_FaceEntity ( idEntity *ent );
void Event_WaitMove ( void );
void Event_BecomePassive ( int ignoreEnemies );
void Event_BecomeAggressive ( void );
void Event_EnableDamage ( void );
void Event_EnableClip ( void );
void Event_EnableGravity ( void );
void Event_EnableAFPush ( void );
void Event_EnablePain ( void );
void Event_DisableDamage ( void );
void Event_DisableClip ( void );
void Event_DisableGravity ( void );
void Event_DisableAFPush ( void );
void Event_DisablePain ( void );
void Event_EnableTarget ( void );
void Event_DisableTarget ( void );
void Event_TakeDamage ( float takeDamage );
void Event_SetUndying ( float setUndying );
void Event_EnableAutoBlink ( void );
void Event_DisableAutoBlink ( void );
void Event_LockEnemyOrigin ( void );
void Event_StopThinking ( void );
void Event_JumpFrame ( void );
void Event_RealKill ( void );
void Event_Kill ( void );
void Event_RemoveUpdateSpawner ( void );
void Event_AllowHiddenMovement ( int enable );
void Event_CanReachPosition ( const idVec3 &pos );
void Event_CanReachEntity ( idEntity *ent );
void Event_CanReachEnemy ( void );
void Event_IsSpeaking ( void );
void Event_IsTethered ( void );
void Event_IsWithinTether ( void );
void Event_IsMoving ( void );
void Event_Speak ( const char *speechDecl );
void Event_SpeakRandom ( const char *speechDecl );
void Event_ScriptedMove ( idEntity* destEnt, float minDist, bool endWithIdle );
void Event_ScriptedFace ( idEntity* faceEnt, bool endWithIdle );
void Event_ScriptedAnim ( const char* animname, int blendFrames, bool loop, bool endWithIdle );
void Event_ScriptedPlaybackMove ( const char* playback, int flags, int numFrames );
void Event_ScriptedPlaybackAim ( const char* playback, int flags, int numFrames );
void Event_ScriptedAction ( idEntity* actionEnt, bool endWithIdle );
void Event_ScriptedDone ( void );
void Event_ScriptedStop ( void );
void Event_ScriptedJumpDown ( float yaw );
void Event_FindEnemy ( float distSquare );
void Event_SetKey ( const char *key, const char *value );
/*
===============================================================================
States
===============================================================================
*/
protected:
// Wait states
stateResult_t State_Wait_Activated ( const stateParms_t& parms );
stateResult_t State_Wait_ScriptedDone ( const stateParms_t& parms );
stateResult_t State_Wait_Action ( const stateParms_t& parms );
stateResult_t State_Wait_ActionNoPain ( const stateParms_t& parms );
// Global states
stateResult_t State_WakeUp ( const stateParms_t& parms );
stateResult_t State_TriggerAnim ( const stateParms_t& parms );
stateResult_t State_Wander ( const stateParms_t& parms );
stateResult_t State_Killed ( const stateParms_t& parms );
stateResult_t State_Dead ( const stateParms_t& parms );
stateResult_t State_LightningDeath ( const stateParms_t& parms );
stateResult_t State_Burn ( const stateParms_t& parms );
stateResult_t State_Remove ( const stateParms_t& parms );
stateResult_t State_Passive ( const stateParms_t& parms );
stateResult_t State_Combat ( const stateParms_t& parms );
stateResult_t State_CombatCover ( const stateParms_t& parms );
stateResult_t State_CombatMelee ( const stateParms_t& parms );
stateResult_t State_CombatRanged ( const stateParms_t& parms );
stateResult_t State_CombatTurret ( const stateParms_t& parms );
virtual stateResult_t State_CombatHide ( const stateParms_t& parms );
stateResult_t State_MovePlayerPush ( const stateParms_t& parms );
stateResult_t State_MoveTether ( const stateParms_t& parms );
stateResult_t State_MoveFollow ( const stateParms_t& parms );
stateResult_t State_ScriptedMove ( const stateParms_t& parms );
stateResult_t State_ScriptedFace ( const stateParms_t& parms );
stateResult_t State_ScriptedStop ( const stateParms_t& parms );
stateResult_t State_ScriptedPlaybackMove ( const stateParms_t& parms );
stateResult_t State_ScriptedPlaybackAim ( const stateParms_t& parms );
stateResult_t State_ScriptedJumpDown ( const stateParms_t& parms );
// Torso States
stateResult_t State_Torso_Idle ( const stateParms_t& parms );
stateResult_t State_Torso_Sight ( const stateParms_t& parms );
stateResult_t State_Torso_CustomCycle ( const stateParms_t& parms );
stateResult_t State_Torso_Action ( const stateParms_t& parms );
stateResult_t State_Torso_FinishAction ( const stateParms_t& parms );
stateResult_t State_Torso_Pain ( const stateParms_t& parms );
stateResult_t State_Torso_ScriptedAnim ( const stateParms_t& parms );
stateResult_t State_Torso_PassiveIdle ( const stateParms_t& parms );
stateResult_t State_Torso_PassiveFidget ( const stateParms_t& parms );
// Leg States
stateResult_t State_Legs_Idle ( const stateParms_t& parms );
stateResult_t State_Legs_TurnLeft ( const stateParms_t& parms );
stateResult_t State_Legs_TurnRight ( const stateParms_t& parms );
stateResult_t State_Legs_Move ( const stateParms_t& parms );
stateResult_t State_Legs_MoveThink ( const stateParms_t& parms );
stateResult_t State_Legs_ChangeDirection ( const stateParms_t& parms );
// Head states
stateResult_t State_Head_Idle ( const stateParms_t& parms );
CLASS_STATES_PROTOTYPE ( idAI );
};
/*
===============================================================================
idAI Inlines
===============================================================================
*/
ID_INLINE int DelayTime( int min, int range ) {
return min + gameLocal.random.RandomInt ( range + 1 );
}
ID_INLINE const idVec2& idAI::GetAttackRange ( void ) const {
return combat.attackRange;
}
ID_INLINE const idVec2& idAI::GetFollowRange ( void ) const {
return move.followRange;
}
ID_INLINE int idAI::GetTravelFlags ( void ) const {
return move.travelFlags;
}
ID_INLINE bool idAI::IsEnemyVisible ( void ) const {
return enemy.ent && enemy.fl.visible;
}
ID_INLINE bool idAI::IsEnemyRecentlyVisible( float maxLostVisTimeScale ) const {
return (enemy.ent
&& combat.fl.seenEnemyDirectly
&& (enemy.lastVisibleTime && gameLocal.time-enemy.lastVisibleTime < (combat.maxLostVisTime * maxLostVisTimeScale)));
}
ID_INLINE bool idAI::LookAtCoverTall( void ) const {
return ( aasSensor->Look()
&& (aasSensor->Look()->flags&FEATURE_LOOK_OVER)
&& aasSensor->Look()->height > 40.0f );
}
ID_INLINE bool idAI::InLookAtCoverMode ( void ) const {
return (!IsBehindCover()
&& !aifl.action
&& move.fl.moving
&& (combat.fl.alert || combat.fl.aware)
&& aasSensor->Look()
&& combat.tacticalCurrent != AITACTICAL_MELEE
&& combat.tacticalCurrent != AITACTICAL_HIDE
&& !IsEnemyRecentlyVisible(0.2f));
}
ID_INLINE bool idAI::InCoverMode ( void ) const {
return ( (1<<combat.tacticalCurrent) & AITACTICAL_COVER_BITS ) && aasSensor->Reserved ( );
}
ID_INLINE bool idAI::InCrouchCoverMode ( void ) const {
return ( InCoverMode() && (aasSensor->Reserved()->flags&FEATURE_LOOK_OVER) );
}
ID_INLINE bool idAI::IsBehindCover ( void ) const {
return ( InCoverMode() && move.fl.done && (aifl.action || DistanceTo2d ( aasSensor->ReservedOrigin() ) < AI_COVER_MINRANGE) );
}
ID_INLINE bool idAI::IsSpeaking ( void ) const {
return speakTime && gameLocal.time < speakTime;
}
ID_INLINE bool idAI::IsFacingEnt ( idEntity* targetEnt ) {
return( move.moveCommand == MOVE_FACE_ENTITY && move.goalEntity == targetEnt && FacingIdeal() );
}
ID_INLINE bool idAI::IsCoverValid ( ) const {
return combat.coverValidTime && (gameLocal.time - combat.coverValidTime < combat.maxInvalidCoverTime);
}
ID_INLINE idActor* idAI::GetLeader ( void ) const {
return leader;
}
ID_INLINE idEntity* idAI::GetGoalEntity ( void ) const {
return move.goalEntity;
}
ID_INLINE bool idAI::CanTakeDamage( void ) const {
return idActor::CanTakeDamage( );
}
ID_INLINE bool idAI::CanTakePain ( void ) const {
return !disablePain;
}
ID_INLINE bool idAI::CanTurn ( void ) const {
return move.turnRate && !move.fl.noTurn && !move.fl.disabled;
}
ID_INLINE bool idAI::CanMove ( void ) const {
return !move.fl.disabled && !move.fl.blocked && gameLocal.GetTime()>move.blockTime;
}
ID_INLINE bool idAI::CanAnnounce ( float chance ) const {
return !aifl.dead && !IsSpeaking ( ) && !af.IsActive ( ) && !combat.fl.noChatter && ( gameLocal.random.RandomFloat() < chance );
}
ID_INLINE void idAI::SetFocus ( aiFocus_t focus, int time ) {
focusType = focus;
focusTime = gameLocal.time + time;
}
ID_INLINE idEntity *idAI::GetEnemy( void ) const {
return enemy.ent;
}
ID_INLINE void idAI::ForceTacticalUpdate ( void ) {
combat.tacticalUpdateTime = 0;
combat.tacticalMaskUpdate = 0;
delete aasFind;
aasFind = NULL;
}
/*
===============================================================================
externs
===============================================================================
*/
extern const char* aiActionStatusString [ rvAIAction::STATUS_MAX ];
extern const char* aiTalkMessageString [ ];
extern const char* aiTacticalString [ AITACTICAL_MAX ];
extern const char* aiMoveCommandString [ NUM_MOVE_COMMANDS ];
extern const char* aiFocusString [ AIFOCUS_MAX ];
#endif /* !__AI_H__ */
Reference in a new issue Copy permalink