etqw-sdk/source/game/botai/BotAI_Main.h

// Copyright (C) 2007 Id Software, Inc.
//

#ifndef __BOTAI_H__
#define __BOTAI_H__

#include "aas/AAS.h"
#include "aas/ObstacleAvoidance.h"
#include "BotAI_Routes.h"
#include "BotAI_VNodes.h"
#include "../ContentMask.h"

#define AAS_PLAYER				0
#define AAS_VEHICLE				1

#define MEDIC_RANGE				1500.0f		//mal: how far a medic's "awareness" of hurt/dead mates extends by default
#define MEDIC_RANGE_BUSY		800.0f		//mal: how far a medic's "awareness" of hurt/dead mates extends when busy (escorting, already healing, carrying obj, etc).
#define MEDIC_RANGE_CARRIER		500.0f		//mal: how far a medic's "awareness" of hurt/dead mates extends when carrier
#define MEDIC_RANGE_REQUEST		3000.0f

#define FOLLOW_RANGE			2000.0f		//mal: how far we'll follow a teammate

#define FDA_AUTO_GRAB_DIST		2500.0f

#define MAX_PATROL_DELIVER_CLIENTS	1
#define PATROL_DELIVER_TEST_DIST	350.0f

#define	IGNORE_ITEM_TIME		15000

#define	ITEM_PACK_OFFSET		24.0f

#define FLYER_WORRY_ABOUT_ROCKETS_MAX_DIST	2500.0f

#define MEDIC_ACK_MIN_DIST		150.0f

#define TOO_CLOSE_TO_GOAL_TO_FOLLOW_DIST	1000.0f

#define TOO_CLOSE_TO_DELIVER_TO_FOLLOW_DIST 1500.0f

#define FLYER_AVOID_DANGER_TIME	2500

#define IGNORE_PLANTED_CHARGE_TIME	10000

#define IGNORE_PATH_NODE_TIME	5000

#define BOT_WILL_ATTACK_TURRETS_IN_COMBAT_DIST 1500.0f

#define	MAX_FRAMES_BLOCKED_BY_OBSTACLE_ON_FOOT				50
#define MAX_FRAMES_BLOCKED_BY_OBSTACLE_IN_VEHICLE			50

#define EASY_MODE_CHANCE_WILL_BUILD_DEPLOYABLE_OR_USE_VEHICLE 40

#define RANDOMLY_LOOK_AROUND_WHILE_VEHICLE_GUNNER_CHANCE	95

#define	MAX_MOVE_ATTEMPTS	10

#define GUNNER_ATTACK_DEPLOYABLE_DIST 8192.0f

#define	IGNORE_CLASS_GOALS_TIME	7000

#define IGNORE_IF_JUST_LEFT_VEHICLE_TIME	5000

#define REPAIR_DRONE_RANGE		625.0f

#define MIN_NUM_INVESTIGATE_CLIENTS	3

#define MAX_NUM_DEFEND_CHARGE_CLIENTS	3

#define MAX_REPAIR_DIST			450.0f

#define	SUPPLY_CRATE_DELAY_TIME 20000

#define MAX_CONSIDER_HUMAN_FOR_RIDE_DIST 900.0f

#define MIN_CLASS_CHANGE_DELAY	15000
#define MIN_WEAPON_CHANGE_DELAY 180000

#define TAKE_SPAWN_IN_DEMO_MODE_CHANCE 25

#define CLOSE_ENOUGH_TO_INVESTIGATE_GOAL_RANGE 75.0f

#define CRITICAL_ENEMY_CLOSE_TO_GOAL_RANGE	350.0f

#define MAX_DEPLOYABLE_FLANK_POINTS 6

#define TRAINING_MODE_RANGE_ADDITION	2000.0f

#define KILLING_SPREE			4

#define MAX_ATTACK_GRIEFER_RANGE 8192.0f

#define IGNORE_NEW_ENEMIES_TIME 5000 //mal: ignore new enemies for 5 seconds when find an important one!

#define MAX_AI_NODE_SWITCH		25

#define MAX_MOVE_ERRORS			5

#define SHIELD_CONSIDER_RANGE	900.0f

#define SHIELD_FIRING_RANGE		250.0f

#define SHEILD_FIRE_CONSIDER_RANGE 1500.0f

#define SMOKE_CONSIDER_RANGE	1500.0f

#define MAX_OWN_VEHICLE_TIME	20000	//mal: time enough for the human to jump out and repair, or look around for a bit, before jumping back in.

#define BACKSTAB_DIST			145.0f

#define DEPLOYABLE_PAUSE_TIME	1500

#define THIRD_EYE_SAFE_RANGE	700.0f

#define TANK_MINIGUN_RANGE		3000.0f

#define MINIMUM_VEHICLE_IGNORE_TIME	3000.0f

#define COS_TURRET_ANGLE_ARC	0.38f

#define DRONE_REPAIR_TIME		60000

#define MIN_TELEPORTER_RANGE	2500.0f
#define MAX_TELEPORTER_RANGE	5000.0f

#define MAX_NUM_OF_FRIENDS_OF_VICTIM 1

#define SPAWNHOST_DESTROY_ORDER_RANGE 5000.0f

#define AIRCRAFT_ATTACK_DIST	10000.0f

#define SPAWN_CONSIDER_TIME		7000

#define MEDIC_IGNORE_TIME		15000		//mal: medics ignore unreachable clients 
#define ENEMY_IGNORE_TIME		7000		//mal: enemies are ignored for 7 seconds
#define BODY_IGNORE_TIME		15000		//mal: bodies are ignored for 15 seconds
#define CLIENT_IGNORE_TIME		15000		//mal: regular clients are ignored for 15 seconds
#define ACTION_IGNORE_TIME		7000		//mal: actions are ignored for 7 seconds.
#define DEPLOYABLE_IGNORE_TIME	30000

#define ENEMY_SIGHT_DIST			3000.0f		//2500.0f		//mal: how far a bot will by default see an enemy, can be overriden by script	   //mal_TODO: good value?
#define ENEMY_SIGHT_BUSY_DIST		2500.0f		//mal: how far a bot will see when busy with another enemy		//mal_TODO: good value?
#define ENEMY_VEHICLE_SIGHT_DIST	8000.0f

#define COVERT_SIGHT_DIST		512.0f

#define MAX_PATH_FAILED_COUNT	12

#define GOAL_ORIGIN_DIST		150.0f

const int BOT_VISIBILITY_TRACE_MASK = MASK_SHOT_BOUNDINGBOX | MASK_VEHICLESOLID | CONTENTS_FORCEFIELD | CONTENTS_MONSTER | MASK_SHOT_RENDERMODEL;

#define SNIPER_HEARING_DIST		4096.0f
#define VEHICLE_HEARING_DIST	6000.0f
#define PLAYER_HEARING_DIST		1200.0f

#define DEFENSE_CAMP_MATE_RANGE	150.0f

#define WARMUP_ACTION_TIME		2500

#define PLASMA_CANNON_RANGE		8000.0f

#define FLYER_HIVE_SIGHT_DIST		1500.0f
#define FLYER_HIVE_ATTACK_DIST		125.0f
#define FLYER_HIVE_HEIGHT_OFFSET	82.0f

#define MEDIC_REQUEST_CONSIDER_TIME	10000

#define SLIPGATE_ORIGIN			idVec3( -9627.0f, 9098.0f, 1627.0f )

#define	NULL_AREANUM				0

#define DEPLOYABLE_ORIGIN_OFFSET	32.0f
#define DEPLOYABLE_PATH_ORIGIN_OFFSET	16.0f

#define VEHICLE_PATH_ORIGIN_OFFSET	16.0f

#define TK_REVIVE_CHAT_TIME		10000

#define HUMAN_OWN_VEHICLE_DIST	350.0f

#define CLOSE_TO_GOAL_RANGE		3000.0f

#define MAX_RIDE_DIST			6000.0f

#define MAX_MINE_CHECK_DIST		2048.0f

#define VEHICLE_NODE_TIMEOUT	10000

#define MAX_MOVE_FAILED_TIME	5000
#define MAX_MOVE_FAILED_COUNT	150

#define DEFAULT_DEPLOYABLE_COVERAGE_RANGE 6192.0f

#define AVT_NEAR_MCP_CONSIDER_RANGE 1900.0f

#define LIGHTNING_GUN_DIST		1900.0f	//mal: a little shorter then the actual range - so the bots always hit the target.

#define ACTION_CHECK_TEAMMATE_DIST	512.0f

#define TRAVEL_TIME_MULTIPLY	4

#define SAFE_PLAYER_BODY_WIDTH  65.0f

#define MAX_SHOT_BLOCKED_COUNT	30

#define BOT_ATTACK_DEPLOYABLE_RANGE 1700.0f

#define ARTY_LOCKON_TIME		900 //1200

#define THIRD_EYE_RANGE			2048.0f

#define MAX_LANDMINE_DIST		256.0f

#define GRENADE_IGNORE_TIME		7000

#define ESCORT_RANGE			3000.0f

#define REQUEST_CONSIDER_TIME	5000

#define SPAWNHOST_RELEVANT_DIST 6000.0f

#define GRENADE_THROW_MAXDIST	1200.0f
#define GRENADE_THROW_MINDIST	1000.0f
#define GRENADE_ATTACK_DIST		1700.0f

#define SHOTGUN_DIST			1500.0f

#define BOT_AWARENESS_DIST		1500.0f

#define OBJ_AWARENESS_DIST		3500.0f

#define SPAWNHOST_RANGE			1500.0f

#define	TACTICAL_PAUSE_ACTION	9999999

#define	FIX_DEPLOYABLE_DIST		1900.0f	

#define BASE_ANTI_MISSILE_RANGE	3000.0f

#define ANTI_MISSILE_RANGE		7000.0f

#define GAME_PLAY_RANGE			8192.0f

#define CLOSE_MINE_DIST			700.0f

#define INFANTRY_ATTACK_HEAVY_DIST	1200.0f

#define CLIENT_HAS_NO_VEHICLE	-1

#define DEPLOYABLE_GOAL_DIST	8000.0f

#define MG_REPAIR_MAX_DIST		5000.0f

#define DEPLOYABLE_DISABLED_PERCENT			1.5f

#define ATTACK_APT_DIST			1700.0f
#define HIVE_ATTACK_APT_DIST	3000.0f

#define MINE_TOO_FAR_DIST		512.0f
#define MINE_TOO_CLOSE_DIST		300.0f

#define LOOK_AT_GOAL_DIST		350.0f

#define ATTACK_MCP_DIST			1200.0f

#define VEHICLE_PAUSE_TIME		50

#define ENEMY_CHASE_DIST		1500.0f		//mal: max dist bot will chase you					//mal_TODO: good value?

#define FOOTSTEP_DIST			500.0f		//mal: how far your footsteps sound					//mal_TODO: is this accurate?

#define FOLLOW_MATE_TIMELIMIT	120000		//mal: default is follow this teammate for a 2 minutes.
#define DEFAULT_LTG_TIME		120000		//mal: default timelimit for doing an ltg - 2 minutes.

#define TACTICAL_ACTION_TIME	5000		//mal: how long to execute a tactical action
#define TACTICAL_HIVE_TIME		30000		//mal: we do the flyer hive for longer.

#define BOT_INFINITY			99999999	//mal: something to do for a long time.

#define MAX_IGNORE_ENTITIES		8			//mal: how many enemies/clients/bodies a bot can ignore at a time.

#define TIME_BEFORE_CHARGE_BLOWS_AWARENESS_TIME		4

#define IGNORE_ICARUS_TIME		15000

#define PLIERS_RANGE			125.0f

#define ITEM_RANGE				900.0f

#define HORNET_SLOWDOWN_DIST	1700.0f //mal: ugly hacks.
#define HORNET_TOOFAST_SPEED	1500.0f

#define	BOT_RECOVER_OBJ_RANGE	4500.0f
#define BOT_INVESTIGATE_RANGE	3500.0f

#define MAX_HIVE_RANGE			8192.0f

#define MAX_DELAYED_CHATS		4
#define MAX_DANGERS				8

#define	SLIPGATE_DIVIDING_PLANE_X_VALUE -3120.0f //mal: HACK

#define BODY_IGNORE_RANGE		2500.0f

#define MAX_MCP_ATTRACT_DIST	2500.0f

//mal: rough approximations
#define WALKING_SPEED			78.0f
#define RUNNING_SPEED			250.0f
#define SPRINTING_SPEED			350.0f

#define BASE_VEHICLE_SPEED		512.0f

#define TK_REVIVE_HEALTH		20

#define WEAPON_LOCK_DIST		8192.0f

#define MAX_SNIPER_VIEW_DIST	12000.0f	//mal: test to see if this works
#define MAX_SNIPER_CROSSHAIR_DANGER_DIST 700.0f

#define MCP_PARKED_DIST			150.0f

//mal: what kind of charge should we look for?
#define ARM						true 
#define DISARM					false

#define PACKS_HAVE_NO_NADES		//mal: put in for a last minute change to the gameplay behavior

#ifdef _XENON
	#define STROGG_INSTANT_REVIVE	//mal: on the console, strogg have instant revives.
#endif

enum bot_LTG_Types_t {
	NO_LTG = -1,
	FOLLOW_TEAMMATE,
	ROAM_GOAL,
	CAMP_GOAL,
	BUILD_GOAL,
	HACK_GOAL,
	HUNT_GOAL,					// the AI has a client it wants to kill for some reason.
	PLANT_GOAL,
	DEFUSE_GOAL,
	FIRESUPPORT_CAMP_GOAL,
	MINE_GOAL,
	SNIPE_GOAL,
	INVESTIGATE_ACTION,
	ENTER_VEHICLE,
	FIX_MCP,
	DRIVE_MCP,
	MINOR_BUILD_GOAL,
	FDA_GOAL,
	STEAL_SPAWN_GOAL,
	STEAL_GOAL,
	DELIVER_GOAL,
	RECOVER_GOAL,
	DROP_DEPLOYABLE_GOAL,
	DESTROY_DEPLOYABLE_GOAL,
	HACK_DEPLOYABLE_GOAL,
	GRAB_VEHICLE_GOAL,
	DEFENSE_CAMP_GOAL,
	ENTER_HEAVY_VEHICLE,
	MINOR_BUILD_MG,
	MG_CAMP_GOAL,
	FLYER_HIVE_GOAL,
	MG_REPAIR_GOAL,
	DROP_PRIORITY_DEPLOYABLE_GOAL,
	PRIORITY_MINE_GOAL,
	FOLLOW_TEAMMATE_BY_REQUEST,
	ENTER_VEHICLE_GOAL,
	ACTOR_GOAL,
	LAST_ACTOR_GOAL,
	THIRD_EYE_GOAL,
	PROTECT_CHARGE,
	PATROL_DELIVER_GOAL
	
//mal_TODO: add more here as you add them in the AI network

};


enum bot_Vehicle_LTG_Types_t {
	NO_VEHICLE_LTG = -1,
	V_ROAM_GOAL,		//mal: this is vehicle specific
	V_CAMP_GOAL,
	V_GOTO_REVIVE_MATE,
	V_TRAVEL_GOAL,
	V_FOLLOW_TEAMMATE,
	V_STOP_VEHICLE,
	V_DRIVE_MCP,
	V_DESTROY_DEPLOYABLE,
	V_ORIGIN_GOAL,
	V_DRIVE_MCP_ROUTE,
	V_HUNT_GOAL
};

enum bot_NBG_Types_t {
	NO_NBG = -1,
	REVIVE_TEAMMATE,
	TK_REVIVE_TEAMMATE,	
	SUPPLY_TEAMMATE,
	CREATE_SPAWNHOST,
	HAZE_ENEMY,
	CAMP,
	BUILD,
	PLANT_MINE,
	PLANT_BOMB,
	HACK,
	STEAL_UNIFORM,
	STALK_VICTIM,
	DEFUSE_BOMB,
	GRAB_SUPPLIES,
	BUG_FOR_SUPPLIES,
	AVOID_DANGER,
	SNIPE,
	DESTROY_DANGER,
	FIX_VEHICLE,
	DESTROY_MCP,
	DESTORY_SPAWNHOST,
	GRAB_SPAWN,
	FIX_DEPLOYABLE,
	DROP_DEPLOYABLE,
	DESTROY_DEPLOYABLE,
	GRAB_SPAWNHOST,
	HACK_DEPLOYABLE,
	DEFENSE_CAMP,
	MG_CAMP,
	FLYER_HIVE_ATTACK,
	FIX_GUN,
	PAUSE,
	ENG_ATTACK_AVT,
	FIXING_MCP,
	DROPPING_SHIELD,
	INVESTIGATE_CAMP,
	DROPPING_SMOKE_FOR_MATE

//mal_TODO: add more here as you add them in the AI network

};

enum bombStates_t {
	BOMB_NULL,		// the bot has no bomb out there, or its not armed yet.
	BOMB_ARMED		// the bot's bomb is hot!
};

enum entityTypes_t {
	ENTITY_NULL,
	ENTITY_PLAYER,
	ENTITY_DEPLOYABLE,
	ENTITY_VEHICLE
};

struct dangerList_t {
	int						num;
	int						time;
	int						ownerNum;
	dangerTypes_t			type;
	idVec3					origin;
	idMat3					dir;		//mal: only airstrikes need this.
};

struct genericNumTimeList_t {
	int						num;
	int						time;
};

struct plantedChargeInfo_t {	//mal: tracks the player's HE/Plasma charges
	bool					checkedAreaNum;
	bool					isOnObjective;
	int						entNum;
	int						areaNum;
	int						spawnID;
	int						explodeTime;				//mal: when this charge will explode
	int						ownerSpawnID;
	int						ownerEntNum;
	bombStates_t			state;						//mal: 0 = not deployed, 1 = deployed, 2 = armed.
	playerTeamTypes_t		team;
	idVec3					origin;
	idBounds				bbox;
};

struct plantedMineInfo_t {	//mal: tracks the player's landmines
	bool					spotted;
	bool					selfArming;
	int						entNum;
	int						spawnID;
	float					xySpeed;
	bombStates_t			state;						//mal: 0 = not deployed, 1 = deployed, 2 = armed.
	idBounds				bbox;
	idVec3					origin;
};

struct grenadeInfo_t {			//mal: tracks the player's EMP/Shrap grenades
	int						entNum;
	int						spawnID;
	float					xySpeed;
	idVec3					origin;
};

struct airstrikeInfo_t {			//mal: tracks the player's airstrikes
	int						entNum;
	int						spawnID;
	int						timeTilStrike;
	int						oldEntNum;
	float					xySpeed;
	idVec3					origin;
	idMat3					dir;
};

struct botChats_t {
	bool					forceChat;
	int						delayTime;
	botChatTypes_t			chat;
};

struct deployableFlankPoints_t {
	bool					checked;
	idVec3					flankPoint;
};

struct deployableInfo_t {
	bool					inPlace;					//mal: will be false if its being dropped in still
	bool					disabled;					//mal: will be true if health < 50%, or is emped.
	int						ownerClientNum;
	int						health;
	int						type;
	int						enemyEntNum;				//mal: who our current enemy is. Could be a player or a vehicle.
	int						areaNum;
	int						areaNumVehicle;
	int						entNum;
	int						spawnID;
	int						maxHealth;
	float					maxAttackRange;				//mal: how far this deployable can reach.
	float					minAttackRange;				//mal: if your closer then this, it wont attack you.
	playerTeamTypes_t		team;
	deployableFlankPoints_t flankPoints[ MAX_DEPLOYABLE_FLANK_POINTS ];
	idVec3					origin;
	idMat3					axis;
	idBounds				bbox;
	idBox					dangerAreaBox;
};

struct proxyInfo_t { //mal_TODO: keep adding more info for vehicles, as its needed
	bool					isEmpty;
	bool					isDeployed;
	bool					isEMPed;
	bool					isOwned;
	bool					neverDriven;
	bool					isFlipped;
	bool					isAmphibious;
	bool					isAirborneVehicle;
	bool					isAirborneAttackVehicle;
	bool					isImmobilized;
	bool					inWater;
	bool					inPlayZone;
	bool					inSiegeMode;
	bool					hasGroundContact;
	bool					hasFreeSeat;	//mal: does this vehicle have a seat open?
	bool					isCareening;	//mal: this vehicle is out of control!
	bool					canRotateInPlace;
	bool					isBoobyTrapped;
	int						damagedPartsCount;		//mal: this will only be true if the vehicle has missing wheels/legs/whatever that affect its ability to drive properly, NOT health.
	int						entNum;
	int						spawnID;
	int						ownerNum;
	int						health;
	int						maxHealth;
	int						areaNum;
	int						areaNumVehicle;
	int						driverEntNum;
	int						flags;
	int						actionRouteNumber;
	float					xyspeed;
	float					forwardSpeed;
	float					wheelsAreOnGround;
	playerTeamTypes_t		team;
	playerVehicleTypes_t	type;
	idBounds				bbox;
	idVec3					origin;
	idVec3					aasOrigin;
	idVec3					aasVehicleOrigin;
	idMat3					axis;
};

struct supplyPackInfo_t {
	bool					checkedAreaNum;
	bool					inPlayZone;
	bool					available;
	bool					inWater;
	int						entNum;
	int						spawnID;
	int						areaNum;
	float					xySpeed; //mal: want to make sure the pack isn't moving!
	playerTeamTypes_t		team; //mal: team that my owner was in when I was born ( in case he changes ).
	idVec3					origin;	//mal: my current origin - this will be actively tracked while I'm alive ( in case I move for some reason ).
	idBounds				bbox;	//mal: only supply crates really need this.
};

struct killedPlayersInfo_t {
	int						clientNum; //mal: client we killed last.
	idVec3					ourOrigin; //mal: where we were when client died.
};


enum bot_COMBAT_Types_t {
	NO_COMBAT_TYPE = -1,
	COMBAT_REVIVE_MATE,
	COMBAT_GRAB_VEHICLE,
	COMBAT_ATTACK_TURRET

//mal_TODO: add more here as you add them in the AI network





};

enum weaponBankTypes_t {
	RESET_WEAPON = -2,	//mal: if the bot needs to reset the weapon for some purpose.
	NO_WEAPON = -1, // when the bot doesn't want to switch weapons
	MELEE, // 0: KNIFE, blade, fists, whatever.
	SIDEARM, // 1:
	GUN, // 2:
	NADE, // 3:
	SPECIAL1, // 4: defrib, pliers, tools, deploy tools
	SPECIAL2, // 5: health pack, HE charge, landmine, aircan
	GUN_ALT, // 6: the alt fire mode of the main gun (nade launcher, homing missle, etc).
	SPECIAL1_ALT // 7: deploy tools
};

enum bot_AI_States_t {
	LTG,
	NBG,
	COMBAT,
	VLTG,
	VCOMBAT
};

enum targetTypes_t {
	NOTYPE = -1,
	CLIENT,
	BODY,
	LOCATION,
	HEAL,
	REARM,
	HEAL_REQUESTED,
	REARM_REQUESTED,
	LANDMINE_DANGER,
	DEPLOYABLE_DANGER,
	STROGG_HIVE_DANGER,
	GDF_CAM_DANGER,
	VEHICLE,
	DEPLOYABLE,
	SUPPLY_CRATE,
	MCP_DANGER,
	MCP_GOAL,
	REARM_REVIVE
};

enum botTurnTypes_t {
    INSTANT_TURN,
	SMOOTH_TURN,
	AIM_TURN,
	FAST_TURN		// a bit inbetween INSTANT and SMOOTH
};

enum botViewTypes_t {
	VIEW_ANGLES,	// look at a specific angle
	VIEW_ORIGIN,	// look at a specific point
	VIEW_ENTITY,	// look at a specific entity
	VIEW_MOVEMENT,	// look in the direction we're moving
	VIEW_RANDOM,	// look at a random point - gets us off a ladder we may be stuck on.
	VIEW_REVERSE
};

enum botMoveTypes_t {
    NULLMOVETYPE = -1,
    RANDOM_JUMP, // straight jump, doesn't veer off move direction
	QUICK_JUMP,	 // straight jump, MUCH faster then a random jump
	LOCATION_JUMP, //mal: theres a certain spot we need to jump at, so bot will need to know to look for the goal spot we're jumping to.
	LOCATION_BARRIERJUMP,
	LOCATION_WALKOFFLEDGE,
	STRAFE_RIGHT,
	STRAFE_LEFT,
	RANDOM_JUMP_RIGHT,
	RANDOM_JUMP_LEFT,
	HAND_BRAKE,
	AIR_BRAKE, //mal: for planes
	FULL_STOP, //mal: stop NOW!
	LAND,	   //mal: for planes - land this craft!
	LEAN_LEFT,
	LEAN_RIGHT,
	TAUNT_MOVE,
	AIR_COAST,
	SLOWMOVE,
	REVERSEMOVE,
	RANDOM_DIR_JUMP,
	ICARUS_BOOST,
	IGNORE_ALTITUDE,
	BACKSTEP,
	SKIP_MOVE
};

enum botAttackMoveTypes_t {
	COMBAT_MOVE_NULL = -1,
	KNIFE_ATTACK,		//movements we do with a knife
    RUN_N_GUN_ATTACK, // bascially run towards the enemy, blasting them as we go.
	CROUCH_ATTACK, // will crouch down and fire.
	PRONE_ATTACK, // usually snipers/campers use this
	HAL_STRAFE_ATTACK, // various strafes....
	SIDE_STRAFE_ATTACK,
	CIRCLE_STRAFE_ATTACK,
	CRAZY_JUMP_ATTACK, // jump around wildly, to make yourself a harder to hit target. Usually used by guys with knifes, but also in close quarters when reloading
	STAND_GROUND_ATTACK, // stands there and fights
	GRENADE_ATTACK,
	AVOID_DANGER_ATTACK,
	NULL_MOVE_ATTACK,
	MOVETO_SHIELD_ATTACK,
	REVIVE_MATE_ATTACK,

//mal: vehicle based combat movements
	VEHICLE_STAND_GROUND,
	VEHICLE_NULL_MOVEMENT, // used mostly by gunners in a vehicle.
	VEHICLE_RANDOM_MOVEMENT,
	VEHICLE_RAM_ATTACK_MOVEMENT,
	VEHICLE_CHASE_MOVEMENT,
	VEHICLE_AIR_MOVEMENT
};

struct clientInfo_t;
struct botAIOutput_t;
struct sharedWorldState_t;

class idBotAI {
public:
							idBotAI();
							~idBotAI();

	void					Think();

	void					VThink(); //mal: vehicle specific think function.

	void					Spawn( int playerClass, int playerTeam );

	void					SetBotClientNum( int clientNum ) { botNum = clientNum; }

	void					UpdateAAS();

	const bot_AI_States_t	GetAIState() { return aiState; }
	const bot_LTG_Types_t	GetLTGType() { return ltgType; }
	const bool						GetLTGUseVehicle() { return ltgUseVehicle; }
	const bot_NBG_Types_t	GetNBGType() { return nbgType; }
	const int				GetLTGTarget() { return ltgTarget; }
	const int				GetNBGTarget() { return nbgTarget; }
	const bot_Vehicle_LTG_Types_t	GetVehicleLTGType() { return vLTGType; }
	const int						GetVehicleLTGTarget() { return vLTGTarget; }
	const int				GetEnemyNum() { return enemy; }
	const int						GetActionNum() { return actionNum; }
	const int						GetVehicleSurrenderTime() { return vehicleSurrenderTime; }
	const int						GetVehicleSurrenderClient() { return vehicleSurrenderClient; }

	void					ResetLastActionNum() { lastActionNum = ACTION_NULL; }

	void					ClearBotUcmd( int clientNum );

//mal: major AI nodes
	bool 					Run_LTG_Node();
	bool					Run_NBG_Node();
	bool					Run_Combat_Node();
	bool					Enter_Run_Dead_Node();
	bool					Run_Dead_Node();
	bool					Run_Intermission_Node();
	bool					Run_Warmup_Node();

//mal: major vehicle AI nodes
	bool					Run_VLTG_Node(); //mal: vehicle specific LTG node.
	bool					Run_VCombat_Node(); //mal: vehicle specific Combat node.

//mal: LTG nodes....
	bool					Enter_LTG_FollowMate();
	bool					LTG_FollowMate();
	bool					Enter_LTG_RoamGoal();
	bool					LTG_RoamGoal();
	bool					Enter_LTG_CampGoal();
	bool					LTG_CampGoal();
	bool					Enter_LTG_BuildGoal();
	bool					LTG_BuildGoal();
	bool					LTG_ErrorThink();				//mal: a special node to think when the bot has nothing to think about ( i.e. no goals on map ).
	bool					Enter_LTG_PlantGoal();
	bool					LTG_PlantGoal();
	bool					Enter_LTG_HackGoal();
	bool					LTG_HackGoal();
	bool					Enter_LTG_DefuseGoal();
	bool					LTG_DefuseGoal();
	bool					Enter_LTG_HuntGoal();
	bool					LTG_HuntGoal();
	bool					Enter_LTG_MineGoal();
	bool					LTG_MineGoal();
	bool					Enter_LTG_SnipeGoal();
	bool					LTG_SnipeGoal();
	bool					Enter_LTG_InvestigateGoal();
	bool					LTG_InvestigateGoal();
	bool					Enter_LTG_UseVehicle();
	bool					LTG_UseVehicle();
	bool					Enter_LTG_FixMCP();
	bool					LTG_FixMCP();
	bool					Enter_LTG_SpawnPointGoal();
	bool					LTG_SpawnPointGoal();
	bool					Enter_LTG_DeliverGoal();
	bool					LTG_DeliverGoal();
	bool					Enter_LTG_StealGoal();
	bool					LTG_StealGoal();
	bool					Enter_LTG_RecoverDroppedGoal();
	bool					LTG_RecoverDroppedGoal();
	bool					Enter_LTG_DeployableGoal();
	bool					LTG_DeployableGoal();
	bool					Enter_LTG_DestroyDeployable();
	bool					LTG_DestroyDeployable();
	bool					Enter_LTG_FireSupportGoal();
	bool					LTG_FireSupportGoal();
	bool					Enter_LTG_HackDeployableGoal();
	bool					LTG_HackDeployableGoal();
	bool					Enter_LTG_MG_CampGoal();
	bool					LTG_MG_CampGoal();
	bool					Enter_LTG_FlyerHiveGoal();
	bool					LTG_FlyerHiveGoal();
	bool					Enter_LTG_RepairGunGoal();
	bool					LTG_RepairGunGoal();
	bool					Enter_LTG_EnterVehicleGoal();
	bool					LTG_EnterVehicleGoal();
	bool					Enter_LTG_ActorEscortPlayerToGoal();
	bool					LTG_ActorEscortPlayerToGoal();
	bool					Enter_LTG_ActorGiveFinalBriefingToPlayer();
	bool					LTG_ActorGiveFinalBriefingToPlayer();
	bool					Enter_LTG_ThirdEyeCameraGoal();
	bool					LTG_ThirdEyeCameraGoal();
	bool					Enter_LTG_ProtectCharge();
	bool					LTG_ProtectCharge();
	bool					Enter_LTG_PatrolDeliverGoal();
	bool					LTG_PatrolDeliverGoal();

//mal: vehicle LTG nodes...
    bool					Enter_VLTG_RoamGoal();
	bool					VLTG_RoamGoal();
	bool					Enter_VLTG_GotoReviveMate();
	bool					VLTG_GotoReviveMate();
	bool					Enter_VLTG_TravelGoal();
	bool					VLTG_TravelGoal();
	bool					Enter_VLTG_RideWithMate();
	bool					VLTG_RideWithMate();
	bool					Enter_VLTG_StopVehicle();
	bool					VLTG_StopVehicle();
	bool					Enter_VLTG_CampGoal();
	bool					VLTG_CampGoal();
	bool					Enter_VLTG_DriveMCPToGoal();
	bool					VLTG_DriveMCPToGoal();
	bool					Enter_VLTG_GroundVehicleDestroyDeployable();
	bool					VLTG_GroundVehicleDestroyDeployable();
	bool					Enter_VLTG_AircraftDestroyDeployable();
	bool					VLTG_AircraftDestroyDeployable();
	bool					Enter_VLTG_TravelToGoalOrigin();
	bool					VLTG_TravelToGoalOrigin();
	bool					Enter_VLTG_DriveMCPToRouteGoal();
	bool					VLTG_DriveMCPToRouteGoal();
	bool					Enter_VLTG_HuntGoal();
	bool					VLTG_HuntGoal();

//mal: some NBG nodes...
	bool					Enter_NBG_SupplyTeammate();
	bool					NBG_SupplyTeammate();
	bool					Enter_NBG_ReviveTeammate();
	bool					NBG_ReviveTeammate();
	bool					Enter_NBG_TKReviveTeammate();
	bool					NBG_TKReviveTeammate();
	bool					Enter_NBG_CreateSpawnHost();
	bool					NBG_CreateSpawnHost();
	bool					Enter_NBG_HumiliateEnemy();
	bool					NBG_HumiliateEnemy();
	bool					Enter_NBG_Camp();
	bool					NBG_Camp();
	bool					Enter_NBG_Build();
	bool					NBG_Build();
	bool					Enter_NBG_PlantBomb();
	bool					NBG_PlantBomb();
	bool					Enter_NBG_Hack();
	bool					NBG_Hack();
	bool					Enter_NBG_StealUniform();
	bool					NBG_StealUniform();
	bool					Enter_NBG_HuntVictim();
	bool					NBG_HuntVictim();
	bool					Enter_NBG_DefuseBomb();
	bool					NBG_DefuseBomb();
	bool					Enter_NBG_GetSupplies();
	bool					NBG_GetSupplies();
	bool					Enter_NBG_BugForSupplies();
	bool					NBG_BugForSupplies();
	bool					Enter_NBG_AvoidDanger();
	bool					NBG_AvoidDanger();
	bool					Enter_NBG_PlantMine();
	bool					NBG_PlantMine();
	bool					Enter_NBG_Snipe();
	bool					NBG_Snipe();
	bool					Enter_NBG_DestroyDanger();
	bool					NBG_DestroyDanger();
	bool					Enter_NBG_FixProxyEntity();
	bool					NBG_FixProxyEntity();
	bool					Enter_NBG_DestroyMCP();
	bool					NBG_DestroyMCP();
	bool					Enter_NBG_DestroySpawnHost();
	bool					NBG_DestroySpawnHost();
	bool					Enter_NBG_GrabSpawnPoint();
	bool					NBG_GrabSpawnPoint();
	bool					Enter_NBG_FixDeployable();
	bool					NBG_FixDeployable();
	bool					Enter_NBG_PlaceDeployable();
	bool					NBG_PlaceDeployable();
	bool					Enter_NBG_DestroyAPTDanger();
	bool					NBG_DestroyAPTDanger();
	bool					Enter_NBG_GrabSpawnHost();
	bool					NBG_GrabSpawnHost();
	bool					Enter_NBG_HackDeployable();
	bool					NBG_HackDeployable();
	bool					Enter_NBG_MG_Camp();
	bool					NBG_MG_Camp();
	bool					Enter_NBG_FlyerHive();
	bool					NBG_FlyerHive();
	bool					Enter_NBG_FixGun();
	bool					NBG_FixGun();
	bool					Enter_NBG_Pause();
	bool					NBG_Pause();
	bool					Enter_NBG_EngAttackAVTNearMCP();
	bool					NBG_EngAttackAVTNearMCP();
	bool					Enter_NBG_ShieldTeammate();
	bool					NBG_ShieldTeammate();
	bool					Enter_NBG_SmokeTeammate();
	bool					NBG_SmokeTeammate();


//mal: some COMBAT nodes
	bool					Enter_COMBAT_Foot_AttackEnemy();
	bool					COMBAT_Foot_AttackEnemy();
	bool					Enter_COMBAT_Foot_ChaseEnemy();
	bool					COMBAT_Foot_ChaseEnemy();
	bool					Enter_COMBAT_Foot_RetreatFromEnemy();
	bool					COMBAT_Foot_RetreatFromEnemy();
	bool					Enter_COMBAT_Foot_EvadeEnemy();
	bool					COMBAT_Foot_EvadeEnemy();
	bool					Enter_COMBAT_Foot_LostEnemyInSmoke();
	bool					COMBAT_Foot_LostEnemyInSmoke();
	bool					Enter_COMBAT_Foot_ReviveTeammate();
	bool					COMBAT_Foot_ReviveTeammate();
	bool					Enter_COMBAT_Foot_ChaseEnemy_Grenade();
	bool					COMBAT_Foot_ChaseEnemy_Grenade();
	bool					Enter_COMBAT_Foot_ChaseEnemy_Aircan();
	bool					COMBAT_Foot_ChaseEnemy_Aircan();
	bool					Enter_COMBAT_Foot_Hide();
	bool					COMBAT_Foot_Hide();
	bool					Enter_COMBAT_Foot_ChaseUnseenEnemy();
	bool					COMBAT_Foot_ChaseUnseenEnemy();
	bool					Enter_COMBAT_Foot_GrabVehicle();
	bool					COMBAT_Foot_GrabVehicle();
	bool					Enter_COMBAT_Foot_AttackTurret();
	bool					COMBAT_Foot_AttackTurret();

	// vehicle combat nodes

	bool					Enter_COMBAT_Vehicle_EvadeEnemy();
	bool					COMBAT_Vehicle_EvadeEnemy();
	bool					Enter_COMBAT_Vehicle_AttackEnemy();
	bool					COMBAT_Vehicle_AttackEnemy();
	bool					Enter_COMBAT_Vehicle_ChaseEnemy();
	bool					COMBAT_Vehicle_ChaseEnemy();


//mal: some COMBAT movement nodes
	bool					Enter_Run_And_Gun_Movement();
	bool					Run_And_Gun_Movement();
	bool					Enter_Knife_Attack_Movement();
	bool					Knife_Attack_Movement();
	bool					Enter_Stand_Ground_Attack_Movement();
	bool					Stand_Ground_Attack_Movement();
	bool					Enter_Hal_Strafe_Attack_Movement();
	bool					Hal_Strafe_Attak_Movement();
	bool					Enter_Crazy_Jump_Attack_Movement();
	bool					Crazy_Jump_Attack_Movement();
	bool					Enter_Side_Strafe_Attack_Movement();
	bool					Side_Strafe_Attack_Movement();
	bool					Enter_Crouch_Attack_Movement();
	bool					Enter_Prone_Attack_Movement();
	bool					Prone_Attack_Movement();
	bool					Crouch_Attack_Movement();
	bool					Enter_Circle_Strafe_Attack_Movement();
	bool					Circle_Strafe_Attack_Movement();
	bool					Enter_Grenade_Attack_Movement();
	bool					Grenade_Attack_Movement();
	bool					Enter_Avoid_Danger_Movement();
	bool					Avoid_Danger_Movement();
	bool					Enter_Null_Move_Attack();
	bool					Null_Move_Attack();
	bool					Enter_MoveTo_Shield_Attack_Movement();
	bool					MoveTo_Shield_Attack_Movement();

//mal: some vehicle COMBAT movement nodes

	bool					Enter_Vehicle_Stand_Ground_Movement();
	bool					Vehicle_Stand_Ground_Movement();
	bool					Enter_Vehicle_NULL_Movement();					//mal: only used by bots who are gunners/passengers in someone else's ride.
	bool					Vehicle_NULL_Movement();
	bool					Enter_Vehicle_Ram_Attack_Movement();
	bool					Vehicle_Ram_Attack_Movement();
	bool					Enter_Vehicle_Chase_Movement();
	bool					Vehicle_Chase_Movement();
	bool					Enter_Vehicle_Random_Movement();
	bool					Vehicle_Random_Movement();
	bool					Enter_Vehicle_Air_Movement();
	bool					Vehicle_Air_To_Air_Movement();
	bool					Vehicle_Air_To_Ground_Movement();
	bool					Buffalo_Air_To_Air_Movement();
	bool					Buffalo_Air_To_Ground_Movement();

	// ram, stand and fight, chase, random move, etc.





//mal: combat utility functions
	bool					Bot_FindEnemy ( int ignoreClientNum );
	bool					Bot_FindBetterEnemy ();
	bool					ClientIsVisibleToBot ( int clientNum, bool useFOV, bool saveEnt );
	bool					ClientIsAudibleToBot ( int clientNum );
	bool					ClientObscuredBySmokeToBot ( int clientNum );
	void					Bot_SetAttackTimeDelay ( bool inFront ); //mal: this sets a delay on how long the bot should take to see enemy, based on bot's state.
	void					Bot_FindBestCombatMovement();
	bool					BotLeftEnemysSight();		//mal: did the bot move out of the enemies sight, or vice-versa?
	void					Bot_ResetEnemy();
	void					Bot_PickBestWeapon( bool useNades );
	bool					Bot_PickPostCombatGoal();
	bool					ClassWeaponCharged( const playerWeaponTypes_t weaponNum ); //mal: does weaponNum have enough charge to be fired this frame?
	void					UpdateEnemyInfo(); //mal: updates the enemy visibility info.
	void					UpdateNonVisEnemyInfo(); //mal: updates the enemy visibility info.
	bool					Bot_ThrowGrenade( const idVec3 &origin, bool fastNade );
	void					Bot_CheckCurrentStateForCombat();
	bool					Bot_ShouldChaseHiddenEnemy( bool chase );
	bool					Bot_CheckShouldUseGrenade( bool targetVisible );
	bool					Bot_CheckShouldUseAircan( bool targetVisible );
	void					Bot_UseCannister( const playerWeaponTypes_t weapType, const idVec3 &origin );
	bool					EnemyValid();
	void					Bot_CheckAttack(); //mal: is it OK to fire our weapon now?
	int						CheckClientAttacker( int clientNum, int checkTimeInSeconds ); // returns which client is attacking the client in question.
	bool					Bot_CanBackStabClient( int clientNum, float backStabDist = BACKSTAB_DIST );
	bool					ClientHasAttackedTeammate( int clientNum, bool criticalOnly, int time );
	bool					DisguisedKillerInArea();
	bool					EnemyIsIgnored( int clientNum );
	void					Bot_IgnoreEnemy( int clientNum, int time );
	bool					VehicleIsIgnored( int vehicleNum );
	void					Bot_IgnoreVehicle( int vehicleNum, int time );
	bool					ClientIsDefusingOurTeamCharge( int clientNum );
	void					Bot_PickChaseType();
	int						Bot_ShouldInvestigateNoise( int clientNum );
	void					Bot_SetTimeOnTarget( bool inVehicle );
	void					Bot_CheckForNearbyVehicleToGrab();
	bool					Bot_CheckEnemyHasLockOn( int clientNum, bool ignoreTargetIfRangeIsGreat = false );
	bool					Client_HasMultipleAttackers( int clientNum );
	bool					Bot_IsNearTeamGoalUnderAttack();
	bool					Bot_IsNearForwardSpawnToGrab();
	bool					DisguisedClientIsActingOdd( int clientNum );
	bool					ClientHasNadeInWorld( int clientNum );
	bool					ClientHasFireSupportInWorld( int clientNum );
	bool					ClientIsDangerous( int clientNum );
	bool					Bot_EnemyAITInArea( const idVec3& org );
	bool					ClientIsMarkedForDeath( int clientNum, bool clearRequest );
	bool					DeployableIsMarkedForDeath( int entNum, bool clearRequest );
	bool					Bot_CheckCovertToolState();
	int						Flyer_FindEnemy( float range );
	bool					Bot_IsUnderAttackFromUnknownEnemy();
	bool					Bot_CanAttackVehicles();
	bool					Bot_HasEnemySniperInArea( float range );
	bool					Bot_IsUnderAttackByAPT( idVec3& turretLocation );
	bool					Bot_TeammateHasClientAsEnemy( int clientNum, int& attackingClient );
	bool					ClientHasAttackedActorsMate( int clientNum, int time );
	bool					Bot_ShouldIgnoreEnemies();
	bool					Bot_CheckIfEnemyHasUsInTheirSightsWhenInAirVehicle();

//mal: vehicle combat/misc utility functions
	int						FindClosestVehicle( float range, const idVec3& org, const playerVehicleTypes_t vehicleType, int vehicleFlags, int vehicleIgnoreFlags, bool emptyOnly );
	void					GetVehicleInfo( int entNum, proxyInfo_t& vehicleInfo ) const;
	const proxyInfo_t *		GetBotVehicleInfo( int entNum ) const;
	void					Bot_FindDeadWhileInVehicle();
	bool					Bot_ShouldUseVehicleForAction( int actionNumber, bool ignoreArmor = false );
	bool					Bot_MeetsVehicleRequirementsForAction( int actionNumber );
	bool					Bot_GetIntoVehicle( int vehicleNum );
	void					Bot_ExitVehicle( bool ignoreMCP = true );
	bool					Bot_VehicleFindEnemy();
	bool					Bot_FindParkingSpotAoundLocaction( idVec3 &loc ); //mal: finds a parking spot near location - something the bot can move toward, without running over its goal.
	bool					VehicleIsValid( int entNum, bool skipSpeedCheck = false, bool addDriverCheck = false );
	bool					VehicleHasGunnerSeatOpen( int entNum );
	bool					InFrontOfVehicle( int vehicleNum, const idVec3 &org, bool precise = false, float preciseValue = 0.60f );
	void					Bot_CheckCurrentStateForVehicleCombat();
	bool					Bot_VehicleCanAttackEnemy( int clientNum );
	void					Bot_PickBestVehicleWeapon();
	void					Bot_PickBestVehiclePosition();
	void					Bot_CheckVehicleAttack();
	bool					Bot_VehicleFindBetterEnemy();
	bool					Bot_ShouldVehicleChaseHiddenEnemy();
	bool					Bot_FindBestVehicleCombatMovement();
	bool					Bot_VehicleCanRamClient( int clientNum );
	void					Bot_PickVehicleChaseType();
	void					Bot_ExitVehicleAINode( bool resetStack );
	bool					Bot_VehicleCanMove( const moveDirections_t direction, float gUnits, bool copyEndPos );
	bool					InAirVehicleGunSights( int vehicleNum, const idVec3 &org );
	bool					Bot_CheckMoveIsClear( idVec3& goalOrigin );
	bool					Bot_CheckVehicleNodePath( const idVec3& goalOrigin, idVec3& pathPoint, bool& resetGoal );
	bool					FindEntityByEntNum( int entNum, idVec3& origin, idBox& bbox );
	bool					Bot_IsInHeavyAttackVehicle( bool ignoreGroundVehicles = false );
	int						Bot_VehicleIsUnderAVTAttack();
	bool					Bot_CheckHumanRequestingTransport();
	bool					Bot_CheckIfClientHasRideWaiting( int clientNum );
	void					IcarusCombatMove();
	bool					ClientIsAudibleToVehicle( int clientNum );
	bool					HumanVehicleOwnerNearby( const playerTeamTypes_t playerTeam, const idVec3 &loc, float range, int vehicleSpawnID );
	bool					Bot_CheckFriendlyEngineerIsNearbyOurVehicle();
	bool					Bot_CheckForHumanNearByWhoMayWantRide();
	int						Bot_GetVehicleGunnerClientNum( int vehicleEntNum );
	bool					VehicleGoalsExistForVehicle( const proxyInfo_t& vehicleInfo );
	bool					Bot_WithObjShouldLeaveVehicle();
	int						Bot_CheckForDeployableTargetsWhileVehicleGunner();
	void					Bot_AttackDeployableTargetsWhileVehicleGunner( int deployableTargetToKill );
	bool					Bot_WhoIsCriticalForCurrentObjShouldLeaveVehicle();


//mal: misc utility functions
	void					UpdateBotsInformation( const playerClassTypes_t playerClass, const playerTeamTypes_t playerTeam, bool botInit );
	void					BotAI_ResetUcmd();
	bool					BotAI_CheckThinkState();
	void					ClearBotState();
	void					Bot_ResetState( bool resetEnemy, bool resetStack );
	void					InitAAS(); //mal: setup the aas for this bot
	void					Bot_IgnoreClient( int clientNum, int time );
	void					Bot_IgnoreAction( int actionNumber, int time );
	bool					Bot_RandomLook( idVec3 &position, bool ignoreDelay = false ); //mal: picks a random position for the bot to look towards
	void					Bot_ExitAINode();
	bool					Bot_NBGIsAvailable( int clientNum, int actionNumber, const bot_NBG_Types_t goalType, int &busyClient );
	bool					Bot_LTGIsAvailable( int clientNum, int actionNumber, const bot_LTG_Types_t goalType, int minNumClients );
	int						Bot_NumClientsDoingLTGGoal( int clientNum, int actionNumber, const bot_LTG_Types_t goalType, idList< int >& busyClients );
	void					Bot_Input(); //mal: sends the bots current user cmds to the game thread.
	void					Bot_LookAtLocation( const idVec3 &spot, const botTurnTypes_t turnType, bool useOriginOnly = false ); // where the bot wants to look
	void					Bot_LookAtEntity( int entityNum, const botTurnTypes_t turnType ); // what the bot wants to look at
	void					Bot_LookAtNothing( const botTurnTypes_t turnType); // just look straight ahead
	int						ClientsInArea( int ignoreClientNum, const idVec3 &org, float range, int team, const playerClassTypes_t clientClass, bool inFront, bool vis2Sky, bool ignoreInvulnerable, bool ignoreDisguised, bool ignoreInVehicle, bool humanOnly = false ); //looks for clients of a specific team, possibly infront of client[ clientNum ].
	int						VehiclesInArea( int ignoreClientNum, const idVec3 &org, float range, int team, bool vis2Sky, int ignoreVehicleNum, bool humanOnly = false ); //looks for vehicles in an area
	bool					InFrontOfClient( int clientNum, const idVec3 &origin, bool precise = false, float preciseValue = 0.80f ); //mal: is this location infront of the bot?
	void					Bot_ClearAngleMods();
	void					CheckBotStuckState();
	void					ResetRandomLook() { randomLookRange = 900.0f; randomLookOrg = vec3_zero; randomLookDelay = 0; }
	void					Bot_CheckWeapon();
	void					BotAI_UpdateStateInfo();
	bool					Bot_CheckHasVisibleMedicNearby();
	bool					LocationVis2Sky( const idVec3 &loc );
	void					ResetBotsAI( bool critical );
	bool					ClientIsValid( int clientNum, int spawnID );
	bool					ClientIsIgnored( int clientNum );
	bool					BodyIsIgnored( int bodyNum );
	bool					SpawnHostIsIgnored( int bodyNum );
	void					Bot_IgnoreBody( int bodyNum, int time );
	void					Bot_IgnoreSpawnHost( int bodyNum, int time );
	bool					ActionIsIgnored( int actionNumber );
	bool					ItemIsIgnored( int itemNumber );
	void					Bot_IgnoreItem( int itemNumber, int time );
	bool					ClientHasChargeInWorld( int clientNum, bool armedOnly, int actionNumber, bool unArmedOnly = false );
	bool					FindChargeInWorld( int actionNumber, plantedChargeInfo_t &bombInfo, bool chargeState, bool ignoreZCheck = false );
	bool					CheckItemPackIsValid( int entNum, idVec3 &packOrg, idBounds &entBounds, int& spawnID );
	void					Bot_AddDelayedChat( int botClientNum, const botChatTypes_t chatType, int delayTimeInSecs, bool forceChat = false );
	void					Bot_CheckDelayedChats();
	bool					Client_IsCriticalForCurrentObj( int clientNum, float range );
	int						FindBodyOfClient( int clientNum, bool stealUniform, const idVec3 &org );
	float					LocationDistFromCurrentObj( const playerTeamTypes_t team, const idVec3 &org );
	bool					Bot_IsAwareOfDanger( int entNum, const idVec3 &org, const idMat3& dir );
	int						AddDangerToAwareList( int entNum, const idVec3 &org, const dangerTypes_t dangerType, int time, int ownerClientNum, const idMat3& dir = mat3_identity );
	void					Bot_CheckForDangers( bool inCombat );
	void					FindMineInWorld( plantedMineInfo_t &mineInfo );
	int						NumPlayerMines();
	bool					DangerStillExists( int entNum, int ownerClientNum );
	bool					Bot_HasExplosives( bool inCombat, bool makeSureSoldierWeaponReady = false );
	void					Bot_RunTacticalAction();
	bool					TeamHasHuman( const playerTeamTypes_t playerTeam );
	bool					NeedsReload();
	int						FindClosestDangerIndex();
	void					ClearDangerFromDangerList( int dangerIndex, bool isEntNum );
	bool					TeamHumanNearLocation( const playerTeamTypes_t playerTeam, const idVec3 &loc, float range, bool ignorePlayersInVehicle = true, const playerClassTypes_t playerClass = NOCLASS, bool ignoreDeadMates = true, bool ignoreIfJustLeftAVehicle = false );
	bool					ClientHasVehicleInWorld( int clientNum, float range );
	bool					BodyIsObstructed( int entNum, bool isCorpse, bool isSpawnHost = false );
	int						Bot_ApproxTravelTimeToLocation( const idVec3 & from, const idVec3 &to, bool inVehicle ) const;
	bool					ClientIsDead( int clientNum );
	bool					ClientCanBeTKRevived( int clientNum );
	bool					DeployableIsIgnored( int deployableNum );
	void					Bot_IgnoreDeployable( int deployableNum, int time );
	bool					GetDeployableInfo( bool selfDeployable, int entNum, deployableInfo_t& deployableInfo );
	bool					DeployableAtAction( int actionNumber, bool checkOwnDeployable );
	bool					Bot_HasWorkingDeployable( bool allowDisabledDeployables = false, int deployableType = NULL_DEPLOYABLE );
	bool					FindMCPStartAction( idVec3& origin );
	int						Bot_GetDeployableTypeForAction( int actionNumber );
	bool					Bot_CheckTeamHasDeployableTypeNearAction( const playerTeamTypes_t playerTeam, int deployableType, int actionNumber, float dist );
	bool					Bot_CheckTeamHasDeployableTypeNearLocation( const playerTeamTypes_t playerTeam, int deployableType, const idVec3& location, float dist );
	bool					PointIsClearOfTeammates( const idVec3& point );
	bool					EntityIsClient( int entNum, bool enemyOnly );
	bool					EntityIsVehicle( int entNum, bool enemyOnly, bool occupiedOnly );
	bool					EntityIsDeployable( int entNum, bool enemyOnly );
	bool					SpawnHostIsUsed( int entNum );
	bool					TeamMineInArea( const idVec3& org, float range );
	bool					Bot_CheckActionIsValid( int actionNumber );	
	const entityTypes_t		FindEntityType( int entNum, int spawnID );
	bool					VehicleIsMarkedForRepair( int entNum, bool clearRequest );
	bool					DeployableIsMarkedForRepair( int entNum, bool clearRequest );
	bool					Bot_CheckAdrenaline( const idVec3& goalOrigin );
	void					Flyer_LookAtLocation( const idVec3 &spot );
	bool					CurrentActionIsLinkedToAction( int curActionNum, int testActionNum );
	void					FindLinkedActionsForAction( int testActionNum, idList< int >& testActionList, idList< int >& linkedActionList );
	bool					Bot_CheckLocationIsOnSameSideOfSlipGate( const idVec3& origin );
	bool					Bot_CheckLocationIsVisible( const idVec3& location, int scanEntityNum = -1, int ignoreEntNum = -1, bool scanFromCrouch = false );
	bool					Bot_CheckHasUnArmedMineNearby();
	void					Bot_CheckMountedGPMGState();
	bool					Bot_CheckIfClientHasChargeAsGoal( int chargeEntNum );
	bool					Bot_IsClearOfObstacle( const idBox& box, const float bboxHeight, const idVec3& botOrigin );
	bool					OtherBotsWantVehicle( const proxyInfo_t& vehicle );
	idVec3					GetPlayerViewPosition( int clientNum );
	float					Bot_GetDeployableOffSet( int deployableType );
	int						Bot_FindNearbySafeActionToMoveToward( const idVec3& origin, float minAvoidDist, bool pickRandom = false );
	bool					ClientHasShieldInWorld( int clientNum, float considerRange );
	float					Bot_DistSqrToClosestForceShield( idVec3& shieldOrg );
	bool					Bot_UseTeleporter();
	bool					Bot_UseRepairDrone( int entNum, const idVec3& entOrg );
	int						Bot_FindClosestAVTDanger( const idVec3& location, float range, bool useAngleCheck = false );
	bool					SpawnHostIsMarkedForDeath( int spawnHostSpawnID );
	int						Bot_GetRequestedEscortClient();
	bool					Bot_CheckForHumanInteractingWithEntity( int entNum );
	int						Bot_HasTeammateWhoCouldUseShieldCoverNearby();
	bool					ClientHasCloseShieldNearby( int clientNum, float considerRange );
	const playerClassTypes_t	TeamCriticalClass( const playerTeamTypes_t playerTeam );
	int						FindHumanOnTeam( const playerTeamTypes_t playerTeam );
	void					Bot_CheckHealthCrateState();
	bool					Bot_CheckIfHealthCrateInArea( float range );
	bool					FindChargeBySpawnID( int spawnID, plantedChargeInfo_t& bombInfo );
	int						Bot_NumShieldsInWorld();
	bool					Bot_CheckChargeExistsOnObjInWorld();
	bool					GetDeployableAtAction( int actionNum, deployableInfo_t& deployable );

//mal: movement utilities
	void					Bot_MoveToGoal( const idVec3 &spot1, const idVec3 &spot2, const botMoveFlags_t moveFlag, const botMoveTypes_t moveType );
	bool					Run_OnFoot_Movement();
	bool					Bot_CanMove( const moveDirections_t direction, float gUnits, bool copyEndPos, bool endPosMustBeOutside = false ); //mal: checks "direction" out the number of "units" to see if a move is possible
	void					Bot_SetupMove( const idVec3 &org, int clientNum, int actionNumber, int areaNum = 0 );
	void					Bot_SetupVehicleMove( const idVec3 &org, int clientNum, int actionNumber, bool ignoreNodes = false );
	bool					Bot_CanProne( int clientNum );	//mal: checks to see if bot can prone in its current location, and still be able to see clientNum.
	bool					Bot_CanCrouch( int clientNum ); //mal: checks to see if bot can crouch in currect loc, and still see clientNum
	const botMoveFlags_t	Bot_ShouldStrafeJump( const idVec3 &targetOrigin );
	bool					MoveIsInvalid();
	int						Bot_CheckBlockingOtherClients( int ignoreClient, float avoidDist = 50.0f );
	void					Bot_MoveAwayFromClient( int clientNum, bool randomStrafe = false );
	bool					AddGroundObstacles( bool largePlayerBBox, bool inVehicle );
	bool					AddGroundAndAirObstacles( bool largePlayerBBox, bool inVehicle, bool inAirVehicle );
	bool					BuildObstacleList( bool largePlayerBBox, bool inVehicle );
	void					Bot_SetupQuickMove( const idVec3 &org, bool largePlayerBBox );
	void					Bot_SetupVehicleQuickMove( const idVec3 &org, bool largePlayerBBox );
	const botMoveFlags_t	Bot_FindStanceForLocation( const idVec3 &org, bool allowProne );
	void					Bot_FindRouteToCurrentGoal();
	void					Bot_FindNextRouteToGoal();
	bool					Bot_ReachedCurrentRouteNode();
	void					Bot_MoveAlongPath( botMoveFlags_t defaultMoveFlags );	// helper function used by all the LTG nodes
	const moveDirections_t	Bot_DirectionToLocation( const idVec3& location, bool precise );
	bool					LocationHasHeadRoom( const idVec3 &loc );
	bool					Bot_LocationIsReachable( bool inVehicle, const idVec3& loc, int& travelTime );
	void					Bot_SetupIcarusMove( const idVec3 &org, int clientNum, int actionNumber );
	void					Bot_SetupFlyerMove( idVec3& goalOrigin, int areaNum );
	void					FlyerHive_BuildPlayerObstacleList();
	int						TravelFlagForTeam() const;
	int						TravelFlagWalkForTeam() const;
	int						TravelFlagInvalidForTeam() const;
	bool					LocationIsReachable( bool inVehicle, const idVec3& loc1, const idVec3& loc2, int& travelTime );
	bool					Bot_CheckIfObstacleInArea( float minAvoidDist );


//mal: goal related utilities
	int						Bot_MedicCheckForWoundedMate( int healClientNum, int escortClientNum, float range, int mateHealth );
	int						Bot_MedicCheckForDeadMate( int reviveClientNum, int escortClientNum, float range );
	int						Bot_StroggCheckForGDFBodies( float range );
	bool					Bot_CheckCombatExceptions();
	int						Bot_MedicCheckForDeadMateDuringCombat( const idVec3 &dangerOrg, float range );
	bool					Bot_MedicCheckNBGState_InCombat();
	bool					Bot_MedicCheckNBGState_InLTG();
	bool					Bot_MedicCheckNBGState_InNBG();
	bool					Bot_CovertOpsCheckNBGState();
	bool					Bot_Check_NBG_Goals();
	void					Bot_FindLongTermGoal(); //mal: finds the bot a LTG in life - called on every spawn/revive/completion of previous goal.
	bool					Bot_CheckSelfState();
	void					Bot_CheckClassState();
	bool					Bot_CheckSelfSupply();
	bool					Bot_IsBusy(); //mal: lets me quickly know if bot is running important LTG/NBG and cant be buggered!
	bool					PopAINodeOffStack();
	void					Bot_ClearVehicleOffAIStack();
	void					PushAINodeOntoStack( int clientNum, int entNum, int actionNumber, int timeLimit, bool isPriority, bool useVehicle, bool useRoute = false );
	void					Bot_ClearAIStack(); //mal: clears the AI stack
	bool					Bot_CheckForTeamGoals();
	bool					Bot_CheckMapScripts();
	bool					Bot_CheckForFallBackGoals();
	bool					Bot_CheckForVehicleFallBackGoals();
	bool					ClientHasObj( int clientNum );
	int						Bot_CovertCheckForUniforms( float range );
	int						Bot_CovertCheckForVictims( float range );
	bool					Bot_FindCloseSupplyPack( bool healthOnly, bool grenadesOnly );
	bool					Bot_FindCloseSupplyTeammate( bool buggerForHealth );
	bool					Bot_FopsCheckNBGState();
	int						Bot_CheckForNeedyTeammates( float range );
	bool					Bot_CheckForSoldierGoals();
	bool					Bot_CheckForEngineerGoals();
	bool					Bot_CheckForCovertGoals();
	bool					Bot_CheckForEscortGoals();
	bool					Bot_CheckForFieldOpsGoals();
	int						Bot_CheckForTacticalAction();
	int						Bot_CheckForNeedyVehicles( float range, bool& chatRequest );
	bool					Bot_EngCheckNBGState();
	int						Bot_CheckForSpawnHostsToDestroy( float range, bool& useChat );
	bool					ObjIsOnGround();
	bool					Bot_CheckForDroppedObjGoals();
	int						Bot_CheckForNeedyDeployables( float range );
	bool					Bot_CheckForSpawnHostToGrab();
	bool					Bot_HasTeamWoundedInArea( bool deadOnly, float medicRange = MEDIC_RANGE );
	bool					Bot_CheckForHumanWantingEscort();
	int						Bot_HasDeployableTargetGoals( bool hackDeployable );
	bool					ClientsNearObj( const playerTeamTypes_t& playerTeam );
	bool					CriticalEnemyClientNearUs( const playerClassTypes_t& playerClass );
	bool					Bot_CheckNeedClientsOnDefense();
	bool					Bot_IsInvestigatingTeamObj();
	bool					Bot_VehicleLTGIsAvailable( int clientNum, int actionNumber, const bot_Vehicle_LTG_Types_t goalType, int minNumClients );
	bool					Bot_IsAttackingDeployables();
	bool					Bot_CheckMCPGoals();
	bool					Bot_IsNearDroppedObj();
	bool					Bot_WantsVehicle();
	bool					ClientIsCloseToDeliverObj( int clientNum, float desiredRange = -1.0f );
	int						Bot_CheckForGrieferTargetGoals();
	bool					ActionIsActiveForTrainingMode( int actionNumber, int numSecondsToDelay );
	bool					TeamHumanMissionIsObjective();
	int						Bot_CheckForNearbyTeammateWhoCouldUseSmoke();
	bool					Bot_CheckThereIsHeavyVehicleInUseAlready();
	bool					Bot_HasShieldInWorldNearLocation( const idVec3& checkOrg, float checkDist );
	bool					CarrierInWorld();
	bool					Bot_IsDefendingTeamCharge();

//mal: debug utilities
	void					SetupDebugHud();
	void					RunDebugChecks();

	idBotAI *				nextRemoved;

	idObstacleAvoidance		obstacles;

private:

	const clientInfo_t *		botInfo;
	const sharedWorldState_t*	botWorld;
	const proxyInfo_t *			botVehicleInfo;
	botAIOutput_t *				botUcmd;

	bool					CallFuncPtr( bool ( idBotAI::*funcPtr )() )	{ assert( funcPtr != NULL ); return ( this->*funcPtr )(); }

	//mal: AI node pointers
	bool					( idBotAI::*LTG_CHECK_FOR_CLASS_NBG )();	//mal: this is class/team specific sub goal check, while in process of long term goal
	bool					( idBotAI::*NBG_CHECK_FOR_CLASS_NBG )();	//mal: is sub goal check while in process of short term goals
	bool					( idBotAI::*COMBAT_MOVEMENT_STATE )();	//mal: the current move state of the bot (on foot, in vehicle (and type), etc.
	bool					( idBotAI::*ROOT_AI_NODE )();
	bool					( idBotAI::*V_ROOT_AI_NODE )();
	bool					( idBotAI::*NBG_AI_SUB_NODE )();
	bool					( idBotAI::*LTG_AI_SUB_NODE )();
	bool					( idBotAI::*V_LTG_AI_SUB_NODE )();
	bool					( idBotAI::*COMBAT_AI_SUB_NODE )();
	bool					( idBotAI::*VEHICLE_COMBAT_AI_SUB_NODE )();
	bool					( idBotAI::*VEHICLE_COMBAT_MOVEMENT_STATE )();	//mal: the current move state of the bot (on foot, in vehicle (and type), etc.

    struct botAAS_t {
		bool				hasPath;
		bool				hasClearPath;
		bool				hasReachedVehicleNodeGoal;
		bool				triedToMoveThisFrame;
		int					obstacleNum;
		int					aasType;
		int					blockedByObstacleCounterOnFoot;
		int					blockedByObstacleCounterInVehicle;
		idAASPath			path;
		idAAS *				aas;						// pointer to the AAS used by this AI
	};

	botAAS_t				botAAS;

	idList< idBotNode::botLink_t >	botVehiclePathList;

	botChats_t				delayedChats[ MAX_DELAYED_CHATS ];

	int						botNum; //mal: lets me track which client slot this bot has.

	int						botExitTime;

	genericNumTimeList_t	ignoreClients[ MAX_IGNORE_ENTITIES ];
	genericNumTimeList_t	ignoreVehicles[ MAX_IGNORE_ENTITIES ];
	genericNumTimeList_t	ignoreDeployables[ MAX_IGNORE_ENTITIES ];
	genericNumTimeList_t	ignoreEnemies[ MAX_IGNORE_ENTITIES ];
	genericNumTimeList_t	ignoreBodies[ MAX_IGNORE_ENTITIES ];
	genericNumTimeList_t	ignoreSpawnHosts[ MAX_IGNORE_ENTITIES ];
	genericNumTimeList_t	ignoreActions[ MAX_IGNORE_ENTITIES ];
	genericNumTimeList_t	ignoreItems[ MAX_IGNORE_ENTITIES ];

	dangerList_t			currentDangers[ MAX_DANGERS ];
	dangerList_t			currentArtyDanger;	//mal: only track one at a time.
	int						actionNumInsideDanger;
	int						ignoreDangersTime;

	bot_AI_States_t			aiState; //mal: a var to track the bots current overall AI State

	idVec3					botCanMoveGoal; //mal: a test location, set by Bot_CanMove - use if desired.

	idVec3					botBackStabMoveGoal; //mal: a test location, set by Bot_CanMove - use if desired.

	int						actionNum; //mal: the action that is our current goal
	int						lastActionNum; //mal: the last action we were doing
	int						lastCheckActionTime; //mal: last time we checked an action for some event.
	int						tacticalActionNum;
	int						tacticalActionTime;
	int						tacticalActionTimer;
	int						tacticalActionTimer2;
	idVec3					tacticalActionOrigin;
	int						tacticalDeviceCharge;
	int						tacticalActionIgnoreTime;
	int						tacticalActionPauseTime;

// Long Term Goal Stuff
	bot_LTG_Types_t			ltgType; //mal: what kind of LTG....
	int						ltgTarget; //mal: the entity that is our LTG goal, if exists!
	int						ltgTargetSpawnID;
	int						ltgTime; //mal: how long we should persue this goal.
	bool					ltgReached; //mal: tracks goal progress
	bool					ltgReachedTarget;
	bool					ltgUseVehicle;
	bool					ltgChat;
	bool					ltgExit;
	int						ltgTimer;
	targetTypes_t			ltgTargetType; //mal: the type of target, for special cases.
	float					ltgDist;
	int						ltgPauseTime;
	botMoveFlags_t			ltgPosture;	//mal: some actions can have a random amount of postures, track which the bot picked here.
	idVec3					ltgOrigin;
	moveDirections_t		ltgMoveDir;
	int						ltgCounter;
	int						ltgMoveTime;
	int						ltgTryMoveCounter;
	bool					ltgUseShield;
	bool					ltgUseSmoke;
	bool					ltgUseMine;

// Vehicle Long Term Goal Stuff
	bot_Vehicle_LTG_Types_t	vLTGType; //mal: what kind of vehicle LTG....
	int						vLTGTarget; //mal: the entity that is our vehicle LTG goal, if exists!
	int						vLTGTargetSpawnID;
	int						vLTGTime; //mal: how long we should persue this goal.
	bool					vLTGReached; //mal: tracks goal progress
	bool					vLTGExit;
	int						vLTGTimer;
	int						vLTGMoveTimer;
	int						vLTGVisTimer;
	int						vLTGTimer2;
	targetTypes_t			vLTGTargetType; //mal: the type of target, for special cases.
	float					vLTGDist;
	float					vLTGMoveTooCloseRange;
	idVec3					vLTGOrigin;
	moveDirections_t		vLTGMoveDir;
	int						vLTGMoveTime;
	int						vLTGSightTime;
	int						vLTGDriveTime;
	int						vLTGPauseTime;
	int						vLTGMoveActionGoal;
	bool					vLTGChat;
	float					vLTGDistFoundDeployable;
	bool					vLTGUseAltAttackPointOnDeployable;
	int						vLTGAttackDeployableCounter;
	int						vLTGKeepMovingTime;
	int						vLTGDeployableTarget;
	int						vLTGDeployableTargetAttackTime;

// Short Term Goal Stuff
	bot_NBG_Types_t			nbgType; //mal: ... and NBG we have currently
	int						nbgTarget; //mal: the entity that is our NBG goal, if exists!
	int						nbgTargetSpawnID;
	int						nbgTime; //mal: how long we should do this goal.
	bool					nbgReached; //mal: tracks goal progress
	bool					nbgReachedTarget;
	bool					nbgExit;
	bool					nbgSwitch;
	int						nbgClientNum;
	int						nbgTimer; //mal: can be used to time certain things
	int						nbgTimer2;
	int						nbgMoveTimer;
	int						nbgTryMoveCounter;
	int						nbgMoveTime;
	targetTypes_t			nbgTargetType; //mal: what type of target this is, for special cases.
	float					nbgDist;
	idVec3					nbgOrigin;
	botMoveFlags_t			nbgPosture;	//mal: some actions can have a random amount of postures, track which the bot picked here.
	botMoveTypes_t			nbgMoveType;
	moveDirections_t		nbgMoveDir;
	bool					nbgChat;



// Combat Goal Stuff
	int						combatNBGTarget; //mal: the entity that is our NBG goal, if exists!
	int						combatNBGTime; //mal: how long we should do this goal.
	int						combatTryMoveCounter;
	int						combatTryMoveTime;
	bool					combatNBGReached; //mal: tracks goal progress
	bool					combatDangerExists;
	bot_COMBAT_Types_t		combatNBGType;
	botMoveFlags_t			combatMoveFlag;

	int						botIsBlocked;
	int						vehicleWheelsAreOffGroundCounter;
	int						botIsBlockedTime;

//mal: enemy stuff
	idVec3						bot_FS_Enemy_Pos;	// FS = First Seen - where the bot was when he first saw the enemy
	idVec3						bot_LS_Enemy_Pos;	// LS = Last Seen - where the bot was when he last saw the enemy
	int							numVisEnemies;		//mal: how many visible enemies FindEnemy found this frame - useful for tactical thinking
	int							enemy;				//mal: the entity that is the bot's current enemy.
	int							enemySpawnID;
	int							enemyAcquireTime;
	int							heardClient;		//mal: a client we're aware of because we heard them, but we haven't seen yet.

	moveDirections_t			combatMoveDir;
	botAttackMoveTypes_t		combatMoveType;
	int							combatMoveTime;			//mal: how long to move this direction
	int							combatMoveFailedCount;	//mal: how many times the bot has tried a move that failed.
	int							combatMoveActionGoal;
	float						combatMoveTooCloseRange;
	int							combatKeepMovingTime;


	int							gunTargetEntNum;			// the ent, if exists, thats in front of us ATM.

	int							shotIsBlockedCounter;

	bool						hammerVehicle;
	bool						hammerTime;
	idVec3						hammerLocation;
	int							hammerClient;
	bool						resetEnemy;

	bool						turretDangerExists;
	int							turretDangerEntNum;

	int							classAbilityDelay;	// how long we should wait before use class ability
	
	struct enemyInfo_t {
		bool					enemyVisible;
		bool					enemyFacingBot;
		bool					enemyInfont;
		int						enemyLastVisTime;	// when this enemy was last visible.
		int						enemyHeight;		// how far above/below the bot this enemy is.
		float					enemyDist;
		idVec3					enemy_FS_Pos;		// FS = First Seen - where the enemy was when the bot first saw him
		idVec3					enemy_LS_Pos;		// LS = Last Seen - where the enemy was when the bot last saw him
		idVec3					enemy_NS_Pos;		// NS = Not Seen - one location bot could use to chase enemies in complicated map areas
	};

	enemyInfo_t				enemyInfo;

	bool					ignoreWeapChange;
	bool					lefty;
	int						botTeleporterAttempts;

	idBotRoutes*			routeNode;
	idBotNode*				vehicleNode;

	playerWeaponTypes_t		botIdealWeapNum;		// the specific weapon the bot wants to use.
	weaponBankTypes_t		botIdealWeapSlot;		//mal: tracks which weapon bank the bot wants to switch to.

	int						lastGrenadeTime;
	bool					safeGrenade;
	bool					chaseEnemy;			// should the bot really chase this enemy around - otherwise will give up once reach place enemy last seen.
	int						timeTilAttackEnemy; //mal: allows me to set a delay in how long from when a bot sees and enemy, til he attacks.
	bool					useNadeOnEnemy;	// does this bot want to use a nade on its enemy?
	bool					useAircanOnEnemy;
	int						vehicleGunnerTime;
	int						vehicleDriverTime;
	int						vehicleUpdateTime;
	int						rocketTime;

	int						crateGoodTime;

	int						ignoreNewEnemiesTime;
	int						ignoreNewEnemiesWhileInVehicleTime;

	int						timeOnTarget;	// the time the bot should wait untill it attacks the target.

	int						weapSwitchTime;

	int						reachedPatrolPointTime;

	int						rocketLauncherLockFailedTime;

	int						lastVehicleSpawnID;
	int						lastVehicleTime;
	int						lastNearbySafeActionToMoveTowardActionNum;

	struct bot_AI_Stack_t {
		bool						( idBotAI::*STACK_AI_NODE )(); //mal: node to run when get back to stack
		bool						( idBotAI::*VEHICLE_STACK_AI_NODE )(); //mal: vehicle node to run when get back to stack
		bool						isPriority;					 //mal: if true - we should do a combat evade, if its combat that makes us stack our goal.
		bool						useVehicle;					 //mal: if true - bot will find a vehicle to reach this goal.
		int							stackClientNum;				 //mal: client to target, if exists
		int							stackClientSpawnID;			 //mal: make sure we grab the right client, incase he disconnected, etc.
		int							stackEntNum;				 //mal: entity to target, if exists
		int							stackTimeLimit;				 //mal: time to do target, if exists
		int							stackActionNum;				 //mal: the action the bot was doing, if exists.
		idBotRoutes*				routeNode;
		bot_Vehicle_LTG_Types_t		vehicleStackLTGType;
		bot_LTG_Types_t				stackLTGType;
	};

	int						framesStuck;
	int						noAASCounter;
	int						overallFramesStuck;
	int						vehicleFramesStuck;
	bool					enemyIsHuntGoal;

	struct vehicleAINodeSwitch_t {
		int						nodeSwitchCount;
		int						nodeSwitchTime;
	};

	vehicleAINodeSwitch_t	vehicleAINodeSwitch;

	struct moveErrorCounter_t {
		int						moveErrorCount;
		int						moveErrorTime;
	};

	moveErrorCounter_t		moveErrorCounter;

	int						ignoreSpyTime;

	int						framesVehicleStuck;

	int						blockingTeammateCounter;

	int						chaseEnemyTime;

	int						fdaUpdateTime;

	int						framesFlipped;

	int						bugForSuppliesDelay;

	int						ignorePlantedChargeTime;

	bool					vehicleEnemyWasInheritedFromFootCombat;

	bool					ignoreMCPRouteAction;

	bool					stayInPosition;

	bool					weaponLocked;

	bool					chasingEnemy;

	bool					hasGreetedServer;

	float					randomLookRange;

	int						botWantsVehicleBackTime;

	int						checkRoadKillTime;

	int						vehicleObstacleSpawnID;
	int						vehicleObstacleTime;

	bool					isStrafeJumping;
	bool					isBoosting;

	int						vehiclePauseTime;
	int						vehicleReverseTime;
	int						nextObjChargeCheckTime;

	int						vehicleSurrenderTime;
	bool					vehicleSurrenderChatSent;
	int						vehicleSurrenderClient;

	int						vehicleCheckForPossibleHumanPassengerChatTime;

	int						nextMissionUpdateTime;

	int						botPathFailedCounter;

	bool					fastAwareness;
	int						skipStrafeJumpTime; //mal: how long we should ignore the strafe jump check

	int						badMoveTime;

	bool					testFireShot;

	int						ignoreNadeTime;	//mal: sometimes the bot won't use his grenade in combat, just to mix it up a bit.

	int						supplySelfTime;		//mal: prevents the bots from trying to supply self, and stop doing it because it has no charge.

	int						randomLookDelay;	//mal: a minimum time to ignore randomLook calls, so that the bots dont swivel around like maniacs.

	int						pistolTime;	//mal: how long the bot should have the pistol out.

	idVec3					randomLookOrg; //mal: keep track of where we've been looking, in case we need to look somewhere else...

	idVec3					hopMoveGoal;
	int						stuckRandomMoveTime;

	bool					wantsVehicle;

	int						ignoreIcarusTime;

	int						selfShockTime;

	int						nodeTimeOut;
	int						newPathTime;

	int						strafeToAvoidDangerTime;
	moveDirections_t		strafeToAvoidDangerDir;

	int						warmupActionMoveGoal;
	int						warmupUseActionMoveGoalTime;

	struct ignoreNodeTimer_t {
		idBotNode*				ignorePathNode;
		int						ignorePathNodeTime;
		int						ignorePathNodeUpdateTime;
	};

	ignoreNodeTimer_t		pathNodeTimer;

	bot_AI_Stack_t			AIStack;	//mal: only important AI nodes will be put on the stack, so that the bots can resume them after doing a NBG/COMBAT
    
	char					*lastAINode;
	char					*lastMoveNode;

#ifdef _DEBUG
	int						debugVar1;
	int						debugVar2;
#endif
};

idEntity *GetGameEntity( int entityNumber );

#endif /* !__BOTAI_H__ */