mirror of
https://github.com/dhewm/dhewm3-sdk.git
synced 2024-11-21 20:21:19 +00:00
afebd7e1e5
Don't include the lazy precompiled.h everywhere, only what's required for the compilation unit. platform.h needs to be included instead to provide all essential defines and types. All includes use the relative path to the neo or the game specific root. Move all idlib related includes from idlib/Lib.h to precompiled.h. precompiled.h still exists for the MFC stuff in tools/. Add some missing header guards.
698 lines
24 KiB
C++
698 lines
24 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#ifndef __AI_H__
|
|
#define __AI_H__
|
|
|
|
#include "physics/Physics_Monster.h"
|
|
#include "Entity.h"
|
|
#include "Actor.h"
|
|
#include "Projectile.h"
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAI
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
const float SQUARE_ROOT_OF_2 = 1.414213562f;
|
|
const float AI_TURN_PREDICTION = 0.2f;
|
|
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 int DEFAULT_FLY_OFFSET = 68;
|
|
|
|
#define ATTACK_IGNORE 0
|
|
#define ATTACK_ON_DAMAGE 1
|
|
#define ATTACK_ON_ACTIVATE 2
|
|
#define ATTACK_ON_SIGHT 4
|
|
|
|
// defined in script/ai_base.script. please keep them up to date.
|
|
typedef enum {
|
|
MOVETYPE_DEAD,
|
|
MOVETYPE_ANIM,
|
|
MOVETYPE_SLIDE,
|
|
MOVETYPE_FLY,
|
|
MOVETYPE_STATIC,
|
|
NUM_MOVETYPES
|
|
} moveType_t;
|
|
|
|
typedef enum {
|
|
MOVE_NONE,
|
|
MOVE_FACE_ENEMY,
|
|
MOVE_FACE_ENTITY,
|
|
|
|
// commands < NUM_NONMOVING_COMMANDS don't cause a change in position
|
|
NUM_NONMOVING_COMMANDS,
|
|
|
|
MOVE_TO_ENEMY = NUM_NONMOVING_COMMANDS,
|
|
MOVE_TO_ENEMYHEIGHT,
|
|
MOVE_TO_ENTITY,
|
|
MOVE_OUT_OF_RANGE,
|
|
MOVE_TO_ATTACK_POSITION,
|
|
MOVE_TO_COVER,
|
|
MOVE_TO_POSITION,
|
|
MOVE_TO_POSITION_DIRECT,
|
|
MOVE_SLIDE_TO_POSITION,
|
|
MOVE_WANDER,
|
|
NUM_MOVE_COMMANDS
|
|
} moveCommand_t;
|
|
|
|
typedef enum {
|
|
TALK_NEVER,
|
|
TALK_DEAD,
|
|
TALK_OK,
|
|
TALK_BUSY,
|
|
NUM_TALK_STATES
|
|
} talkState_t;
|
|
|
|
//
|
|
// status results from move commands
|
|
// make sure to change script/doom_defs.script if you add any, or change their order
|
|
//
|
|
typedef enum {
|
|
MOVE_STATUS_DONE,
|
|
MOVE_STATUS_MOVING,
|
|
MOVE_STATUS_WAITING,
|
|
MOVE_STATUS_DEST_NOT_FOUND,
|
|
MOVE_STATUS_DEST_UNREACHABLE,
|
|
MOVE_STATUS_BLOCKED_BY_WALL,
|
|
MOVE_STATUS_BLOCKED_BY_OBJECT,
|
|
MOVE_STATUS_BLOCKED_BY_ENEMY,
|
|
MOVE_STATUS_BLOCKED_BY_MONSTER
|
|
} moveStatus_t;
|
|
|
|
#define DI_NODIR -1
|
|
|
|
// obstacle avoidance
|
|
typedef struct obstaclePath_s {
|
|
idVec3 seekPos; // seek position avoiding obstacles
|
|
idEntity * firstObstacle; // if != NULL the first obstacle along the path
|
|
idVec3 startPosOutsideObstacles; // start position outside obstacles
|
|
idEntity * startPosObstacle; // if != NULL the obstacle containing the start position
|
|
idVec3 seekPosOutsideObstacles; // seek position outside obstacles
|
|
idEntity * seekPosObstacle; // if != NULL the obstacle containing the seek position
|
|
} obstaclePath_t;
|
|
|
|
// path prediction
|
|
typedef enum {
|
|
SE_BLOCKED = BIT(0),
|
|
SE_ENTER_LEDGE_AREA = BIT(1),
|
|
SE_ENTER_OBSTACLE = BIT(2),
|
|
SE_FALL = BIT(3),
|
|
SE_LAND = BIT(4)
|
|
} stopEvent_t;
|
|
|
|
typedef struct predictedPath_s {
|
|
idVec3 endPos; // final position
|
|
idVec3 endVelocity; // velocity at end position
|
|
idVec3 endNormal; // normal of blocking surface
|
|
int endTime; // time predicted
|
|
int endEvent; // event that stopped the prediction
|
|
const idEntity * blockingEntity; // entity that blocks the movement
|
|
} predictedPath_t;
|
|
|
|
//
|
|
// events
|
|
//
|
|
extern const idEventDef AI_BeginAttack;
|
|
extern const idEventDef AI_EndAttack;
|
|
extern const idEventDef AI_MuzzleFlash;
|
|
extern const idEventDef AI_CreateMissile;
|
|
extern const idEventDef AI_AttackMissile;
|
|
extern const idEventDef AI_FireMissileAtTarget;
|
|
extern const idEventDef AI_AttackMelee;
|
|
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_TriggerParticles;
|
|
extern const idEventDef AI_RandomPath;
|
|
|
|
class idPathCorner;
|
|
|
|
typedef struct particleEmitter_s {
|
|
particleEmitter_s() {
|
|
particle = NULL;
|
|
time = 0;
|
|
joint = INVALID_JOINT;
|
|
};
|
|
const idDeclParticle *particle;
|
|
int time;
|
|
jointHandle_t joint;
|
|
} particleEmitter_t;
|
|
|
|
class idMoveState {
|
|
public:
|
|
idMoveState();
|
|
|
|
void Save( idSaveGame *savefile ) const;
|
|
void Restore( idRestoreGame *savefile );
|
|
|
|
moveType_t moveType;
|
|
moveCommand_t moveCommand;
|
|
moveStatus_t moveStatus;
|
|
idVec3 moveDest;
|
|
idVec3 moveDir; // used for wandering and slide moves
|
|
idEntityPtr<idEntity> goalEntity;
|
|
idVec3 goalEntityOrigin; // move to entity uses this to avoid checking the floor position every frame
|
|
int toAreaNum;
|
|
int startTime;
|
|
int duration;
|
|
float speed; // only used by flying creatures
|
|
float range;
|
|
float wanderYaw;
|
|
int nextWanderTime;
|
|
int blockTime;
|
|
idEntityPtr<idEntity> obstacle;
|
|
idVec3 lastMoveOrigin;
|
|
int lastMoveTime;
|
|
int anim;
|
|
};
|
|
|
|
class idAASFindCover : public idAASCallback {
|
|
public:
|
|
idAASFindCover( const idVec3 &hideFromPos );
|
|
~idAASFindCover();
|
|
|
|
virtual bool TestArea( const idAAS *aas, int areaNum );
|
|
|
|
private:
|
|
pvsHandle_t hidePVS;
|
|
int PVSAreas[ idEntity::MAX_PVS_AREAS ];
|
|
};
|
|
|
|
class idAASFindAreaOutOfRange : public idAASCallback {
|
|
public:
|
|
idAASFindAreaOutOfRange( const idVec3 &targetPos, float maxDist );
|
|
|
|
virtual bool TestArea( const idAAS *aas, int areaNum );
|
|
|
|
private:
|
|
idVec3 targetPos;
|
|
float maxDistSqr;
|
|
};
|
|
|
|
class idAI;
|
|
|
|
class idAASFindAttackPosition : public idAASCallback {
|
|
public:
|
|
idAASFindAttackPosition( const idAI *self, const idMat3 &gravityAxis, idEntity *target, const idVec3 &targetPos, const idVec3 &fireOffset );
|
|
~idAASFindAttackPosition();
|
|
|
|
virtual bool TestArea( const idAAS *aas, int areaNum );
|
|
|
|
private:
|
|
const idAI *self;
|
|
idEntity *target;
|
|
idBounds excludeBounds;
|
|
idVec3 targetPos;
|
|
idVec3 fireOffset;
|
|
idMat3 gravityAxis;
|
|
pvsHandle_t targetPVS;
|
|
int PVSAreas[ idEntity::MAX_PVS_AREAS ];
|
|
};
|
|
|
|
class idAI : public idActor {
|
|
public:
|
|
CLASS_PROTOTYPE( idAI );
|
|
|
|
idAI();
|
|
~idAI();
|
|
|
|
void Save( idSaveGame *savefile ) const;
|
|
void Restore( idRestoreGame *savefile );
|
|
|
|
void Spawn( void );
|
|
void HeardSound( idEntity *ent, const char *action );
|
|
idActor *GetEnemy( void ) const;
|
|
void TalkTo( idActor *actor );
|
|
talkState_t GetTalkState( void ) const;
|
|
|
|
bool GetAimDir( const idVec3 &firePos, idEntity *aimAtEnt, const idEntity *ignore, idVec3 &aimDir ) const;
|
|
|
|
void TouchedByFlashlight( idActor *flashlight_owner );
|
|
|
|
// Outputs a list of all monsters to the console.
|
|
static void List_f( const idCmdArgs &args );
|
|
|
|
// 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 );
|
|
// 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 );
|
|
|
|
protected:
|
|
// navigation
|
|
idAAS * aas;
|
|
int travelFlags;
|
|
|
|
idMoveState move;
|
|
idMoveState savedMove;
|
|
|
|
float kickForce;
|
|
bool ignore_obstacles;
|
|
float blockedRadius;
|
|
int blockedMoveTime;
|
|
int blockedAttackTime;
|
|
|
|
// turning
|
|
float ideal_yaw;
|
|
float current_yaw;
|
|
float turnRate;
|
|
float turnVel;
|
|
float anim_turn_yaw;
|
|
float anim_turn_amount;
|
|
float anim_turn_angles;
|
|
|
|
// physics
|
|
idPhysics_Monster physicsObj;
|
|
|
|
// flying
|
|
jointHandle_t flyTiltJoint;
|
|
float fly_speed;
|
|
float fly_bob_strength;
|
|
float fly_bob_vert;
|
|
float fly_bob_horz;
|
|
int fly_offset; // prefered offset from player's view
|
|
float fly_seek_scale;
|
|
float fly_roll_scale;
|
|
float fly_roll_max;
|
|
float fly_roll;
|
|
float fly_pitch_scale;
|
|
float fly_pitch_max;
|
|
float fly_pitch;
|
|
|
|
bool allowMove; // disables any animation movement
|
|
bool allowHiddenMovement; // allows character to still move around while hidden
|
|
bool disableGravity; // disables gravity and allows vertical movement by the animation
|
|
bool af_push_moveables; // allow the articulated figure to push moveable objects
|
|
|
|
// weapon/attack vars
|
|
bool lastHitCheckResult;
|
|
int lastHitCheckTime;
|
|
int lastAttackTime;
|
|
float melee_range;
|
|
float projectile_height_to_distance_ratio; // calculates the maximum height a projectile can be thrown
|
|
idList<idVec3> missileLaunchOffset;
|
|
|
|
const idDict * projectileDef;
|
|
mutable idClipModel *projectileClipModel;
|
|
float projectileRadius;
|
|
float projectileSpeed;
|
|
idVec3 projectileVelocity;
|
|
idVec3 projectileGravity;
|
|
idEntityPtr<idProjectile> projectile;
|
|
idStr attack;
|
|
|
|
// chatter/talking
|
|
const idSoundShader *chat_snd;
|
|
int chat_min;
|
|
int chat_max;
|
|
int chat_time;
|
|
talkState_t talk_state;
|
|
idEntityPtr<idActor> talkTarget;
|
|
|
|
// cinematics
|
|
int num_cinematics;
|
|
int current_cinematic;
|
|
|
|
bool allowJointMod;
|
|
idEntityPtr<idEntity> focusEntity;
|
|
idVec3 currentFocusPos;
|
|
int focusTime;
|
|
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 eyeFocusRate;
|
|
float headFocusRate;
|
|
int focusAlignTime;
|
|
|
|
// special fx
|
|
float shrivel_rate;
|
|
int shrivel_start;
|
|
|
|
bool restartParticles; // should smoke emissions restart
|
|
bool useBoneAxis; // use the bone vs the model axis
|
|
idList<particleEmitter_t> particles; // particle data
|
|
|
|
renderLight_t worldMuzzleFlash; // positioned on world weapon bone
|
|
int worldMuzzleFlashHandle;
|
|
jointHandle_t flashJointWorld;
|
|
int muzzleFlashEnd;
|
|
int flashTime;
|
|
|
|
// joint controllers
|
|
idAngles eyeMin;
|
|
idAngles eyeMax;
|
|
jointHandle_t focusJoint;
|
|
jointHandle_t orientationJoint;
|
|
|
|
// enemy variables
|
|
idEntityPtr<idActor> enemy;
|
|
idVec3 lastVisibleEnemyPos;
|
|
idVec3 lastVisibleEnemyEyeOffset;
|
|
idVec3 lastVisibleReachableEnemyPos;
|
|
idVec3 lastReachableEnemyPos;
|
|
bool wakeOnFlashlight;
|
|
|
|
// script variables
|
|
idScriptBool AI_TALK;
|
|
idScriptBool AI_DAMAGE;
|
|
idScriptBool AI_PAIN;
|
|
idScriptFloat AI_SPECIAL_DAMAGE;
|
|
idScriptBool AI_DEAD;
|
|
idScriptBool AI_ENEMY_VISIBLE;
|
|
idScriptBool AI_ENEMY_IN_FOV;
|
|
idScriptBool AI_ENEMY_DEAD;
|
|
idScriptBool AI_MOVE_DONE;
|
|
idScriptBool AI_ONGROUND;
|
|
idScriptBool AI_ACTIVATED;
|
|
idScriptBool AI_FORWARD;
|
|
idScriptBool AI_JUMP;
|
|
idScriptBool AI_ENEMY_REACHABLE;
|
|
idScriptBool AI_BLOCKED;
|
|
idScriptBool AI_OBSTACLE_IN_PATH;
|
|
idScriptBool AI_DEST_UNREACHABLE;
|
|
idScriptBool AI_HIT_ENEMY;
|
|
idScriptBool AI_PUSHED;
|
|
|
|
//
|
|
// 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
|
|
void Think( void );
|
|
void Activate( idEntity *activator );
|
|
int ReactionTo( const idEntity *ent );
|
|
bool CheckForEnemy( void );
|
|
void EnemyDead( void );
|
|
virtual bool CanPlayChatterSounds( void ) const;
|
|
void SetChatSound( void );
|
|
void PlayChatter( void );
|
|
virtual void Hide( void );
|
|
virtual void Show( void );
|
|
idVec3 FirstVisiblePointOnPath( const idVec3 origin, const idVec3 &target, int travelFlags ) const;
|
|
void CalculateAttackOffsets( void );
|
|
void PlayCinematic( void );
|
|
|
|
// movement
|
|
virtual void ApplyImpulse( idEntity *ent, int id, const idVec3 &point, const idVec3 &impulse );
|
|
void GetMoveDelta( const idMat3 &oldaxis, const idMat3 &axis, idVec3 &delta );
|
|
void CheckObstacleAvoidance( const idVec3 &goalPos, idVec3 &newPos );
|
|
void DeadMove( void );
|
|
void AnimMove( void );
|
|
void SlideMove( void );
|
|
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 );
|
|
void FlyMove( void );
|
|
void StaticMove( void );
|
|
|
|
// 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 );
|
|
|
|
// navigation
|
|
void KickObstacles( const idVec3 &dir, float force, idEntity *alwaysKick );
|
|
bool ReachedPos( const idVec3 &pos, const moveCommand_t moveCommand ) const;
|
|
float TravelDistance( const idVec3 &start, const idVec3 &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 DrawRoute( void ) const;
|
|
bool GetMovePos( idVec3 &seekPos );
|
|
bool MoveDone( void ) const;
|
|
bool EntityCanSeePos( idActor *actor, const idVec3 &actorOrigin, const idVec3 &pos );
|
|
void BlockedFailSafe( void );
|
|
|
|
// movement control
|
|
void StopMove( moveStatus_t status );
|
|
bool FaceEnemy( void );
|
|
bool FaceEntity( idEntity *ent );
|
|
bool DirectMoveToPosition( const idVec3 &pos );
|
|
bool MoveToEnemyHeight( void );
|
|
bool MoveOutOfRange( idEntity *entity, float range );
|
|
bool MoveToAttackPosition( idEntity *ent, int attack_anim );
|
|
bool MoveToEnemy( void );
|
|
bool MoveToEntity( idEntity *ent );
|
|
bool MoveToPosition( const idVec3 &pos );
|
|
bool MoveToCover( idEntity *entity, const idVec3 &pos );
|
|
bool SlideToPosition( const idVec3 &pos, float time );
|
|
bool WanderAround( void );
|
|
bool StepDirection( float dir );
|
|
bool NewWanderDir( const idVec3 &dest );
|
|
|
|
// effects
|
|
const idDeclParticle *SpawnParticlesOnJoint( particleEmitter_t &pe, const char *particleName, const char *jointName );
|
|
void SpawnParticles( const char *keyName );
|
|
bool ParticlesActive( void );
|
|
|
|
// turning
|
|
bool FacingIdeal( void );
|
|
void Turn( void );
|
|
bool TurnToward( float yaw );
|
|
bool TurnToward( const idVec3 &pos );
|
|
|
|
// enemy management
|
|
void ClearEnemy( void );
|
|
bool EnemyPositionValid( void ) const;
|
|
void SetEnemyPosition( void );
|
|
void UpdateEnemyPosition( void );
|
|
void SetEnemy( idActor *newEnemy );
|
|
|
|
// attacks
|
|
void CreateProjectileClipModel( void ) const;
|
|
idProjectile *CreateProjectile( const idVec3 &pos, const idVec3 &dir );
|
|
void RemoveProjectile( void );
|
|
idProjectile *LaunchProjectile( const char *jointname, idEntity *target, bool clampToAttackCone );
|
|
virtual void DamageFeedback( idEntity *victim, idEntity *inflictor, int &damage );
|
|
void DirectDamage( const char *meleeDefName, idEntity *ent );
|
|
bool TestMelee( void ) const;
|
|
bool AttackMelee( const char *meleeDefName );
|
|
void BeginAttack( const char *name );
|
|
void EndAttack( void );
|
|
void PushWithAF( void );
|
|
|
|
// special effects
|
|
void GetMuzzle( const char *jointname, idVec3 &muzzle, idMat3 &axis );
|
|
void InitMuzzleFlash( void );
|
|
void TriggerWeaponEffects( const idVec3 &muzzle );
|
|
void UpdateMuzzleFlash( void );
|
|
virtual bool UpdateAnimationControllers( void );
|
|
void UpdateParticles( void );
|
|
void TriggerParticles( const char *jointName );
|
|
|
|
// AI script state management
|
|
void LinkScriptVariables( void );
|
|
void UpdateAIScript( void );
|
|
|
|
//
|
|
// ai/ai_events.cpp
|
|
//
|
|
void Event_Activate( idEntity *activator );
|
|
void Event_Touch( idEntity *other, trace_t *trace );
|
|
void Event_FindEnemy( int useFOV );
|
|
void Event_FindEnemyAI( int useFOV );
|
|
void Event_FindEnemyInCombatNodes( void );
|
|
void Event_ClosestReachableEnemyOfEntity( idEntity *team_mate );
|
|
void Event_HeardSound( int ignore_team );
|
|
void Event_SetEnemy( idEntity *ent );
|
|
void Event_ClearEnemy( void );
|
|
void Event_MuzzleFlash( const char *jointname );
|
|
void Event_CreateMissile( const char *jointname );
|
|
void Event_AttackMissile( const char *jointname );
|
|
void Event_FireMissileAtTarget( const char *jointname, const char *targetname );
|
|
void Event_LaunchMissile( const idVec3 &muzzle, const idAngles &ang );
|
|
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_BeginAttack( const char *name );
|
|
void Event_EndAttack( void );
|
|
void Event_MeleeAttackToJoint( const char *jointname, const char *meleeDefName );
|
|
void Event_RandomPath( void );
|
|
void Event_CanBecomeSolid( void );
|
|
void Event_BecomeSolid( void );
|
|
void Event_BecomeNonSolid( void );
|
|
void Event_BecomeRagdoll( void );
|
|
void Event_StopRagdoll( void );
|
|
void Event_SetHealth( float newHealth );
|
|
void Event_GetHealth( void );
|
|
void Event_AllowDamage( void );
|
|
void Event_IgnoreDamage( void );
|
|
void Event_GetCurrentYaw( void );
|
|
void Event_TurnTo( float angle );
|
|
void Event_TurnToPos( const idVec3 &pos );
|
|
void Event_TurnToEntity( idEntity *ent );
|
|
void Event_MoveStatus( void );
|
|
void Event_StopMove( void );
|
|
void Event_MoveToCover( void );
|
|
void Event_MoveToEnemy( void );
|
|
void Event_MoveToEnemyHeight( void );
|
|
void Event_MoveOutOfRange( idEntity *entity, float range );
|
|
void Event_MoveToAttackPosition( idEntity *entity, const char *attack_anim );
|
|
void Event_MoveToEntity( idEntity *ent );
|
|
void Event_MoveToPosition( const idVec3 &pos );
|
|
void Event_SlideTo( const idVec3 &pos, float time );
|
|
void Event_Wander( void );
|
|
void Event_FacingIdeal( void );
|
|
void Event_FaceEnemy( void );
|
|
void Event_FaceEntity( idEntity *ent );
|
|
void Event_WaitAction( const char *waitForState );
|
|
void Event_GetCombatNode( void );
|
|
void Event_EnemyInCombatCone( idEntity *ent, int use_current_enemy_location );
|
|
void Event_WaitMove( void );
|
|
void Event_GetJumpVelocity( const idVec3 &pos, float speed, float max_height );
|
|
void Event_EntityInAttackCone( idEntity *ent );
|
|
void Event_CanSeeEntity( idEntity *ent );
|
|
void Event_SetTalkTarget( idEntity *target );
|
|
void Event_GetTalkTarget( void );
|
|
void Event_SetTalkState( int state );
|
|
void Event_EnemyRange( void );
|
|
void Event_EnemyRange2D( void );
|
|
void Event_GetEnemy( void );
|
|
void Event_GetEnemyPos( void );
|
|
void Event_GetEnemyEyePos( void );
|
|
void Event_PredictEnemyPos( float time );
|
|
void Event_CanHitEnemy( void );
|
|
void Event_CanHitEnemyFromAnim( const char *animname );
|
|
void Event_CanHitEnemyFromJoint( const char *jointname );
|
|
void Event_EnemyPositionValid( void );
|
|
void Event_ChargeAttack( const char *damageDef );
|
|
void Event_TestChargeAttack( void );
|
|
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_Shrivel( float shirvel_time );
|
|
void Event_Burn( void );
|
|
void Event_PreBurn( void );
|
|
void Event_ClearBurn( void );
|
|
void Event_SetSmokeVisibility( int num, int on );
|
|
void Event_NumSmokeEmitters( void );
|
|
void Event_StopThinking( void );
|
|
void Event_GetTurnDelta( void );
|
|
void Event_GetMoveType( void );
|
|
void Event_SetMoveType( int moveType );
|
|
void Event_SaveMove( void );
|
|
void Event_RestoreMove( void );
|
|
void Event_AllowMovement( float flag );
|
|
void Event_JumpFrame( void );
|
|
void Event_EnableClip( void );
|
|
void Event_DisableClip( void );
|
|
void Event_EnableGravity( void );
|
|
void Event_DisableGravity( void );
|
|
void Event_EnableAFPush( void );
|
|
void Event_DisableAFPush( void );
|
|
void Event_SetFlySpeed( float speed );
|
|
void Event_SetFlyOffset( int offset );
|
|
void Event_ClearFlyOffset( void );
|
|
void Event_GetClosestHiddenTarget( const char *type );
|
|
void Event_GetRandomTarget( const char *type );
|
|
void Event_TravelDistanceToPoint( const idVec3 &pos );
|
|
void Event_TravelDistanceToEntity( idEntity *ent );
|
|
void Event_TravelDistanceBetweenPoints( const idVec3 &source, const idVec3 &dest );
|
|
void Event_TravelDistanceBetweenEntities( idEntity *source, idEntity *dest );
|
|
void Event_LookAtEntity( idEntity *ent, float duration );
|
|
void Event_LookAtEnemy( float duration );
|
|
void Event_SetJointMod( int allowJointMod );
|
|
void Event_ThrowMoveable( void );
|
|
void Event_ThrowAF( void );
|
|
void Event_SetAngles( idAngles const &ang );
|
|
void Event_GetAngles( void );
|
|
void Event_RealKill( void );
|
|
void Event_Kill( void );
|
|
void Event_WakeOnFlashlight( int enable );
|
|
void Event_LocateEnemy( void );
|
|
void Event_KickObstacles( idEntity *kickEnt, float force );
|
|
void Event_GetObstacle( void );
|
|
void Event_PushPointIntoAAS( const idVec3 &pos );
|
|
void Event_GetTurnRate( void );
|
|
void Event_SetTurnRate( float rate );
|
|
void Event_AnimTurn( float angles );
|
|
void Event_AllowHiddenMovement( int enable );
|
|
void Event_TriggerParticles( const char *jointName );
|
|
void Event_FindActorsInBounds( const idVec3 &mins, const idVec3 &maxs );
|
|
void Event_CanReachPosition( const idVec3 &pos );
|
|
void Event_CanReachEntity( idEntity *ent );
|
|
void Event_CanReachEnemy( void );
|
|
void Event_GetReachableEntityPosition( idEntity *ent );
|
|
};
|
|
|
|
class idCombatNode : public idEntity {
|
|
public:
|
|
CLASS_PROTOTYPE( idCombatNode );
|
|
|
|
idCombatNode();
|
|
|
|
void Save( idSaveGame *savefile ) const;
|
|
void Restore( idRestoreGame *savefile );
|
|
|
|
void Spawn( void );
|
|
bool IsDisabled( void ) const;
|
|
bool EntityInView( idActor *actor, const idVec3 &pos );
|
|
static void DrawDebugInfo( void );
|
|
|
|
private:
|
|
float min_dist;
|
|
float max_dist;
|
|
float cone_dist;
|
|
float min_height;
|
|
float max_height;
|
|
idVec3 cone_left;
|
|
idVec3 cone_right;
|
|
idVec3 offset;
|
|
bool disabled;
|
|
|
|
void Event_Activate( idEntity *activator );
|
|
void Event_MarkUsed( void );
|
|
};
|
|
|
|
#endif /* !__AI_H__ */
|