yapb-noob-edition/include/yapb.h

//
// Yet Another POD-Bot, based on PODBot by Markus Klinge ("CountFloyd").
// Copyright (c) YaPB Development Team.
//
// This software is licensed under the BSD-style license.
// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
//     https://yapb.ru/license
//

#pragma once

#include <extdll.h>
#include <memory.h>
#include <stdio.h>
#include <meta_api.h>

using namespace cr::types;
using namespace cr::classes;

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>

#include <compress.h>
#include <resource.h>

// defines bots tasks
enum TaskID : int {
   TASK_NORMAL,
   TASK_PAUSE,
   TASK_MOVETOPOSITION,
   TASK_FOLLOWUSER,
   TASK_PICKUPITEM,
   TASK_CAMP,
   TASK_PLANTBOMB,
   TASK_DEFUSEBOMB,
   TASK_ATTACK,
   TASK_HUNTENEMY,
   TASK_SEEKCOVER,
   TASK_THROWHEGRENADE,
   TASK_THROWFLASHBANG,
   TASK_THROWSMOKE,
   TASK_DOUBLEJUMP,
   TASK_ESCAPEFROMBOMB,
   TASK_SHOOTBREAKABLE,
   TASK_HIDE,
   TASK_BLINDED,
   TASK_SPRAY,
   TASK_MAX
};

// bot menu ids
enum MenuId : int {
   BOT_MENU_INVALID = 0,
   BOT_MENU_MAIN,
   BOT_MENU_FEATURES,
   BOT_MENU_CONTROL,
   BOT_MENU_WEAPON_MODE,
   BOT_MENU_PERSONALITY,
   BOT_MENU_DIFFICULTY,
   BOT_MENU_TEAM_SELECT,
   BOT_MENU_TERRORIST_SELECT,
   BOT_MENU_CT_SELECT,
   BOT_MENU_COMMANDS,
   BOT_MENU_WAYPOINT_MAIN_PAGE1,
   BOT_MENU_WAYPOINT_MAIN_PAGE2,
   BOT_MENU_WAYPOINT_RADIUS,
   BOT_MENU_WAYPOINT_TYPE,
   BOT_MENU_WAYPOINT_FLAG,
   BOT_MENU_WAYPOINT_AUTOPATH,
   BOT_MENU_WAYPOINT_PATH,
   BOT_MENU_KICK_PAGE_1,
   BOT_MENU_KICK_PAGE_2,
   BOT_MENU_KICK_PAGE_3,
   BOT_MENU_KICK_PAGE_4,
   BOT_MENU_TOTAL_MENUS
};

// bomb say string
enum BombSayStr : int {
   BSS_NEED_TO_FIND_CHAT = cr::bit (1),
   BSS_NEED_TO_FIND_CHATTER = cr::bit (2)
};

// log levels
enum LogLevel : int {
   LL_DEFAULT = cr::bit (0), // default log message
   LL_WARNING = cr::bit (1), // warning log message
   LL_ERROR = cr::bit (2), // error log message
   LL_IGNORE = cr::bit (3), // additional flag
   LL_FATAL = cr::bit (4) // fatal error log message (terminate the game!)
};

// chat types id's
enum ChatType : int {
   CHAT_KILLING = 0, // id to kill chat array
   CHAT_DEAD, // id to dead chat array
   CHAT_BOMBPLANT, // id to bomb chat array
   CHAT_TEAMATTACK, // id to team-attack chat array
   CHAT_TEAMKILL, // id to team-kill chat array
   CHAT_WELCOME, // id to welcome chat array
   CHAT_NOKW, // id to no keyword chat array
   CHAT_TOTAL // number for array
};

// personalities defines
enum Personality : int {
   PERSONALITY_NORMAL = 0,
   PERSONALITY_RUSHER,
   PERSONALITY_CAREFUL
};

// bot difficulties
enum Difficulty : int {
   DIFFICULTY_VERY_EASY,
   DIFFICULTY_EASY,
   DIFFICULTY_NORMAL,
   DIFFICULTY_HARD,
   DIFFICULTY_VERY_HARD
};

// collision states
enum CollisionState : int {
   COLLISION_NOTDECICED,
   COLLISION_PROBING,
   COLLISION_NOMOVE,
   COLLISION_JUMP,
   COLLISION_DUCK,
   COLLISION_STRAFELEFT,
   COLLISION_STRAFERIGHT
};

// counter-strike team id's
enum Team : int {
   TEAM_TERRORIST = 0,
   TEAM_COUNTER,
   TEAM_SPECTATOR,
   TEAM_UNASSIGNED
};

// client flags
enum ClientFlags : int {
   CF_USED = cr::bit (0),
   CF_ALIVE = cr::bit (1),
   CF_ADMIN = cr::bit (2),
   CF_ICON = cr::bit (3)
};

// bot create status
enum BotCreationResult : int {
   BOT_RESULT_CREATED,
   BOT_RESULT_MAX_PLAYERS_REACHED,
   BOT_RESULT_NAV_ERROR,
   BOT_RESULT_TEAM_STACKED
};

// radio messages
enum RadioMessage : int {
   RADIO_COVER_ME = 1,
   RADIO_YOU_TAKE_THE_POINT = 2,
   RADIO_HOLD_THIS_POSITION = 3,
   RADIO_REGROUP_TEAM = 4,
   RADIO_FOLLOW_ME = 5,
   RADIO_TAKING_FIRE = 6,
   RADIO_GO_GO_GO = 11,
   RADIO_TEAM_FALLBACK = 12,
   RADIO_STICK_TOGETHER_TEAM = 13,
   RADIO_GET_IN_POSITION = 14,
   RADIO_STORM_THE_FRONT = 15,
   RADIO_REPORT_TEAM = 16,
   RADIO_AFFIRMATIVE = 21,
   RADIO_ENEMY_SPOTTED = 22,
   RADIO_NEED_BACKUP = 23,
   RADIO_SECTOR_CLEAR = 24,
   RADIO_IN_POSITION = 25,
   RADIO_REPORTING_IN = 26,
   RADIO_SHES_GONNA_BLOW = 27,
   RADIO_NEGATIVE = 28,
   RADIO_ENEMY_DOWN = 29
};

// chatter system (extending enum above, messages 30-39 is reserved)
enum ChatterMessage : int {
   CHATTER_SPOT_THE_BOMBER = 40,
   CHATTER_FRIENDLY_FIRE,
   CHATTER_PAIN_DIED,
   CHATTER_BLINDED,
   CHATTER_GOING_TO_PLANT_BOMB,
   CHATTER_RESCUING_HOSTAGES,
   CHATTER_GOING_TO_CAMP,
   CHATTER_HEARD_NOISE,
   CHATTER_TEAM_ATTACK,
   CHATTER_REPORTING_IN,
   CHATTER_GUARDING_DROPPED_BOMB,
   CHATTER_CAMP,
   CHATTER_PLANTING_BOMB,
   CHATTER_DEFUSING_BOMB,
   CHATTER_IN_COMBAT,
   CHATTER_SEEK_ENEMY,
   CHATTER_NOTHING,
   CHATTER_ENEMY_DOWN,
   CHATTER_USING_HOSTAGES,
   CHATTER_FOUND_BOMB,
   CHATTER_WON_THE_ROUND,
   CHATTER_SCARED_EMOTE,
   CHATTER_HEARD_ENEMY,
   CHATTER_SNIPER_WARNING,
   CHATTER_SNIPER_KILLED,
   CHATTER_VIP_SPOTTED,
   CHATTER_GUARDING_VIP_SAFETY,
   CHATTER_GOING_TO_GUARD_VIP_SAFETY,
   CHATTER_QUICK_WON_ROUND,
   CHATTER_ONE_ENEMY_LEFT,
   CHATTER_TWO_ENEMIES_LEFT,
   CHATTER_THREE_ENEMIES_LEFT,
   CHATTER_NO_ENEMIES_LEFT,
   CHATTER_FOUND_BOMB_PLACE,
   CHATTER_WHERE_IS_THE_BOMB,
   CHATTER_DEFENDING_BOMBSITE,
   CHATTER_BARELY_DEFUSED,
   CHATTER_NICESHOT_COMMANDER,
   CHATTER_NICESHOT_PALL,
   CHATTER_GOING_TO_GUARD_HOSTAGES,
   CHATTER_GOING_TO_GUARD_DROPPED_BOMB,
   CHATTER_ON_MY_WAY,
   CHATTER_LEAD_ON_SIR,
   CHATTER_PINNED_DOWN,
   CHATTER_GOTTA_FIND_BOMB,
   CHATTER_YOU_HEARD_THE_MAN,
   CHATTER_LOST_COMMANDER,
   CHATTER_NEW_ROUND,
   CHATTER_COVER_ME,
   CHATTER_BEHIND_SMOKE,
   CHATTER_BOMB_SITE_SECURED,
   CHATTER_MAX
};

// counter-strike weapon id's
enum Weapon : int {
   WEAPON_P228 = 1,
   WEAPON_SHIELD = 2,
   WEAPON_SCOUT = 3,
   WEAPON_EXPLOSIVE = 4,
   WEAPON_XM1014 = 5,
   WEAPON_C4 = 6,
   WEAPON_MAC10 = 7,
   WEAPON_AUG = 8,
   WEAPON_SMOKE = 9,
   WEAPON_ELITE = 10,
   WEAPON_FIVESEVEN = 11,
   WEAPON_UMP45 = 12,
   WEAPON_SG550 = 13,
   WEAPON_GALIL = 14,
   WEAPON_FAMAS = 15,
   WEAPON_USP = 16,
   WEAPON_GLOCK = 17,
   WEAPON_AWP = 18,
   WEAPON_MP5 = 19,
   WEAPON_M249 = 20,
   WEAPON_M3 = 21,
   WEAPON_M4A1 = 22,
   WEAPON_TMP = 23,
   WEAPON_G3SG1 = 24,
   WEAPON_FLASHBANG = 25,
   WEAPON_DEAGLE = 26,
   WEAPON_SG552 = 27,
   WEAPON_AK47 = 28,
   WEAPON_KNIFE = 29,
   WEAPON_P90 = 30,
   WEAPON_ARMOR = 31,
   WEAPON_ARMORHELM = 32,
   WEAPON_DEFUSER = 33
};

// buy counts
enum BuyState : int {
   BUYSTATE_PRIMARY_WEAPON = 0,
   BUYSTATE_ARMOR_VESTHELM,
   BUYSTATE_SECONDARY_WEAPON,
   BUYSTATE_GRENADES,
   BUYSTATE_DEFUSER,
   BUYSTATE_AMMO,
   BUYSTATE_NIGHTVISION,
   BUYSTATE_FINISHED
};

// economics limits
enum EconomyLimit : int {
   ECO_PRIMARY_GT = 0,
   ECO_SMG_GT_CT,
   ECO_SMG_GT_TE,
   ECO_SHOTGUN_GT,
   ECO_SHOTGUN_LT,
   ECO_HEAVY_GT,
   ECO_HEAVY_LT,
   ECO_PROSTOCK_NORMAL,
   ECO_PROSTOCK_RUSHER,
   ECO_PROSTOCK_CAREFUL,
   ECO_SHIELDGUN_GT
};

// defines for pickup items
enum PickupType : int {
   PICKUP_NONE,
   PICKUP_WEAPON,
   PICKUP_DROPPED_C4,
   PICKUP_PLANTED_C4,
   PICKUP_HOSTAGE,
   PICKUP_BUTTON,
   PICKUP_SHIELD,
   PICKUP_DEFUSEKIT
};

// fight style type
enum FightStyle : int {
   FIGHT_NONE,
   FIGHT_STRAFE,
   FIGHT_STAY
};

// dodge type
enum StrafeDir : int {
   STRAFE_DIR_NONE,
   STRAFE_DIR_LEFT,
   STRAFE_DIR_RIGHT
};

// reload state
enum ReloadState : int {
   RELOAD_NONE = 0, // no reload state currently
   RELOAD_PRIMARY = 1, // primary weapon reload state
   RELOAD_SECONDARY = 2  // secondary weapon reload state
};

// collision probes
enum CollisionProbe : int {
   PROBE_JUMP = cr::bit (0), // probe jump when colliding
   PROBE_DUCK = cr::bit (1), // probe duck when colliding
   PROBE_STRAFE = cr::bit (2) // probe strafing when colliding
};

// vgui menus (since latest steam updates is obsolete, but left for old cs)
enum VGuiMenu : int {
   VMS_TEAM = 2, // menu select team
   VMS_TF = 26, // terrorist select menu
   VMS_CT = 27  // ct select menu
};

// lift usage states
enum LiftState : int {
   LIFT_NO_NEARBY = 0,
   LIFT_LOOKING_BUTTON_OUTSIDE,
   LIFT_WAITING_FOR,
   LIFT_ENTERING_IN,
   LIFT_WAIT_FOR_TEAMMATES,
   LIFT_LOOKING_BUTTON_INSIDE,
   LIFT_TRAVELING_BY,
   LIFT_LEAVING
};

// wayponit auto-downloader
enum WaypointDownloadError : int {
   WDE_SOCKET_ERROR,
   WDE_CONNECT_ERROR,
   WDE_NOTFOUND_ERROR,
   WDE_NOERROR
};

// game start messages for counter-strike...
enum GameMessage : int {
   GAME_MSG_NONE = 1,
   GAME_MSG_TEAM_SELECT = 2,
   GAME_MSG_CLASS_SELECT = 3,
   GAME_MSG_PURCHASE = 100,
   GAME_MSG_RADIO = 200,
   GAME_MSG_SAY_CMD = 10000,
   GAME_MSG_SAY_TEAM_MSG = 10001
};

// sensing states
enum SensingState : int {
   STATE_SEEING_ENEMY = cr::bit (0), // seeing an enemy
   STATE_HEARING_ENEMY = cr::bit (1), // hearing an enemy
   STATE_SUSPECT_ENEMY = cr::bit (2), // suspect enemy behind obstacle
   STATE_PICKUP_ITEM = cr::bit (3), // pickup item nearby
   STATE_THROW_HE = cr::bit (4), // could throw he grenade
   STATE_THROW_FB = cr::bit (5), // could throw flashbang
   STATE_THROW_SG = cr::bit (6) // could throw smokegrenade
};

// positions to aim at
enum AimPosition : int {
   AIM_NAVPOINT = cr::bit (0), // aim at nav point
   AIM_CAMP = cr::bit (1), // aim at camp vector
   AIM_PREDICT_PATH = cr::bit (2), // aim at predicted path
   AIM_LAST_ENEMY = cr::bit (3), // aim at last enemy
   AIM_ENTITY = cr::bit (4), // aim at entity like buttons, hostages
   AIM_ENEMY = cr::bit (5), // aim at enemy
   AIM_GRENADE = cr::bit (6), // aim for grenade throw
   AIM_OVERRIDE = cr::bit (7) // overrides all others (blinded)
};

// famas/glock burst mode status + m4a1/usp silencer
enum BurstMode : int {
   BURST_ON = cr::bit (0),
   BURST_OFF = cr::bit (1)
};

// visibility flags
enum Visibility : int {
   VISIBLE_HEAD = cr::bit (1),
   VISIBLE_BODY = cr::bit (2),
   VISIBLE_OTHER = cr::bit (3)
};

// command handler status
enum BotCommandStatus : int {
   CMD_STATUS_HANDLED = 0, // command successfully handled 
   CMD_STATUS_LISTENSERV, // command is only avaialble on listen server
   CMD_STATUS_BADFORMAT // wrong params
};

// defines for waypoint flags field (32 bits are available)
enum WaypointFlag : int32 {
   FLAG_LIFT = cr::bit (1), // wait for lift to be down before approaching this waypoint
   FLAG_CROUCH = cr::bit (2), // must crouch to reach this waypoint
   FLAG_CROSSING = cr::bit (3), // a target waypoint
   FLAG_GOAL = cr::bit (4), // mission goal point (bomb, hostage etc.)
   FLAG_LADDER = cr::bit (5), // waypoint is on ladder
   FLAG_RESCUE = cr::bit (6), // waypoint is a hostage rescue point
   FLAG_CAMP = cr::bit (7), // waypoint is a camping point
   FLAG_NOHOSTAGE = cr::bit (8), // only use this waypoint if no hostage
   FLAG_DOUBLEJUMP = cr::bit (9), // bot help's another bot (requster) to get somewhere (using djump)
   FLAG_SNIPER = cr::bit (28), // it's a specific sniper point
   FLAG_TF_ONLY = cr::bit (29), // it's a specific terrorist point
   FLAG_CF_ONLY = cr::bit (30),  // it's a specific ct point
};

// defines for waypoint connection flags field (16 bits are available)
enum PathFlag : int {
   PATHFLAG_JUMP = cr::bit (0) // must jump for this connection
};

// enum pathfind search type
enum SearchPathType : int {
   SEARCH_PATH_FASTEST = 0,
   SEARCH_PATH_SAFEST_FASTER,
   SEARCH_PATH_SAFEST
};

// defines waypoint connection types
enum PathConnection : int {
   CONNECTION_OUTGOING = 0,
   CONNECTION_INCOMING,
   CONNECTION_BOTHWAYS
};

// a* route state
enum RouteState : int {
   ROUTE_OPEN = 0,
   ROUTE_CLOSED,
   ROUTE_NEW
};

// waypoint edit states
enum WaypointEditState : int {
   WS_EDIT_ENABLED = cr::bit (1),
   WS_EDIT_NOCLIP = cr::bit (2),
   WS_EDIT_AUTO = cr::bit (3)
};

// bot known file headers
constexpr char FH_WAYPOINT[8] = "PODWAY!";
constexpr char FH_EXPERIENCE[8] = "SKYEXP!";
constexpr char FH_VISTABLE[8] = "SKYVIS!";
constexpr char FH_MATRIX[8] = "SKYPMX!";

constexpr int FV_WAYPOINT = 7;
constexpr int FV_EXPERIENCE = 5;
constexpr int FV_VISTABLE = 4;
constexpr int FV_MATRIX = 4;

// some hardcoded desire defines used to override calculated ones
constexpr float TASKPRI_NORMAL = 35.0f;
constexpr float TASKPRI_PAUSE = 36.0f;
constexpr float TASKPRI_CAMP = 37.0f;
constexpr float TASKPRI_SPRAYLOGO = 38.0f;
constexpr float TASKPRI_FOLLOWUSER = 39.0f;
constexpr float TASKPRI_MOVETOPOSITION = 50.0f;
constexpr float TASKPRI_DEFUSEBOMB = 89.0f;
constexpr float TASKPRI_PLANTBOMB = 89.0f;
constexpr float TASKPRI_ATTACK = 90.0f;
constexpr float TASKPRI_SEEKCOVER = 91.0f;
constexpr float TASKPRI_HIDE = 92.0f;
constexpr float TASKPRI_THROWGRENADE = 99.0f;
constexpr float TASKPRI_DOUBLEJUMP = 99.0f;
constexpr float TASKPRI_BLINDED = 100.0f;
constexpr float TASKPRI_SHOOTBREAKABLE = 100.0f;
constexpr float TASKPRI_ESCAPEFROMBOMB = 100.0f;

constexpr float MAX_GRENADE_TIMER = 2.15f;
constexpr float MAX_SPRAY_DISTANCE = 260.0f;
constexpr float MAX_SPRAY_DISTANCE_X2 = MAX_SPRAY_DISTANCE * 2;
constexpr float MAX_CHATTER_REPEAT = 99.0f;

constexpr int MAX_PATH_INDEX = 8;
constexpr int MAX_DAMAGE_VALUE = 2040;
constexpr int MAX_GOAL_VALUE = 2040;
constexpr int MAX_WAYPOINTS = 2048;
constexpr int MAX_ROUTE_LENGTH = MAX_WAYPOINTS / 2;
constexpr int MAX_WEAPONS = 32;
constexpr int NUM_WEAPONS = 26;
constexpr int MAX_COLLIDE_MOVES = 3;
constexpr int MAX_ENGINE_PLAYERS = 32;
constexpr int MAX_PRINT_BUFFER = 1024;
constexpr int MAX_TEAM_COUNT = 2;
constexpr int INVALID_WAYPOINT_INDEX = -1;

constexpr int MAX_WAYPOINT_BUCKET_SIZE = static_cast <int> (MAX_WAYPOINTS * 0.65);
constexpr int MAX_WAYPOINT_BUCKET_MAX = MAX_WAYPOINTS * 8 / MAX_WAYPOINT_BUCKET_SIZE + 1;
constexpr int MAX_WAYPOINT_BUCKET_WPTS = MAX_WAYPOINT_BUCKET_SIZE / MAX_WAYPOINT_BUCKET_MAX;

// weapon masks
constexpr int WEAPON_PRIMARY = ((1 << WEAPON_XM1014) | (1 << WEAPON_M3) | (1 << WEAPON_MAC10) | (1 << WEAPON_UMP45) | (1 << WEAPON_MP5) | (1 << WEAPON_TMP) | (1 << WEAPON_P90) | (1 << WEAPON_AUG) | (1 << WEAPON_M4A1) | (1 << WEAPON_SG552) | (1 << WEAPON_AK47) | (1 << WEAPON_SCOUT) | (1 << WEAPON_SG550) | (1 << WEAPON_AWP) | (1 << WEAPON_G3SG1) | (1 << WEAPON_M249) | (1 << WEAPON_FAMAS) | (1 << WEAPON_GALIL));
constexpr int WEAPON_SECONDARY = ((1 << WEAPON_P228) | (1 << WEAPON_ELITE) | (1 << WEAPON_USP) | (1 << WEAPON_GLOCK) | (1 << WEAPON_DEAGLE) | (1 << WEAPON_FIVESEVEN));

// a* route
struct Route {
   float g, f;
   int parent;
   RouteState state;
};

// links keywords and replies together
struct Keywords {
   StringArray keywords;
   StringArray replies;
   StringArray usedReplies;
};

// tasks definition
struct Task {
   TaskID id; // major task/action carried out
   float desire; // desire (filled in) for this task
   int data; // additional data (waypoint index)
   float time; // time task expires
   bool resume; // if task can be continued if interrupted
};

// botname structure definition
struct BotName {
   String steamId;
   String name;
   int usedBy;
};

// voice config structure definition
struct ChatterItem {
   String name;
   float repeat;
   float duration;
};

// weapon properties structure
struct WeaponProp {
   char classname[64];
   int ammo1; // ammo index for primary ammo
   int ammo1Max; // max primary ammo
   int slot; // HUD slot (0 based)
   int pos; // slot position
   int id; // weapon ID
   int flags; // flags???
};

// weapon info structure
struct WeaponInfo {
   int id; // the weapon id value
   const char *name; // name of the weapon when selecting it
   const char *model; // model name to separate cs weapons
   int price; // price when buying
   int minPrimaryAmmo; // minimum primary ammo
   int teamStandard; // used by team (number) (standard map)
   int teamAS; // used by team (as map)
   int buyGroup; // group in buy menu (standard map)
   int buySelect; // select item in buy menu (standard map)
   int newBuySelectT; // for counter-strike v1.6
   int newBuySelectCT; // for counter-strike v1.6
   int penetratePower; // penetrate power
   int maxClip; // max ammo in clip
   bool primaryFireHold; // hold down primary fire button to use?
};

// array of clients struct
struct Client {
   edict_t *ent; // pointer to actual edict
   Vector origin; // position in the world
   Vector sound; // position sound was played
   int team; // bot team
   int team2; // real bot team in free for all mode (csdm)
   int flags; // client flags
   int radio; // radio orders
   int menu; // identifier to openen menu
   float hearingDistance; // distance this sound is heared
   float timeSoundLasting; // time sound is played/heared
   int iconFlags[MAX_ENGINE_PLAYERS]; // flag holding chatter icons
   float iconTimestamp[MAX_ENGINE_PLAYERS]; // timers for chatter icons
};

// experience data hold in memory while playing
struct Experience {
   int damage[MAX_TEAM_COUNT];
   int index[MAX_TEAM_COUNT];
   int value[MAX_TEAM_COUNT];
};

// bot creation tab
struct CreateQueue {
   bool manual;
   int difficulty;
   int team;
   int member;
   int personality;
   String name;
};

// define chatting collection structure
struct ChatCollection {
   int chatProbability;
   float chatDelay;
   float timeNextChat;
   int entityIndex;
   String sayText;
   StringArray lastUsedSentences;
};

// general waypoint header information structure
struct WaypointHeader {
   char header[8];
   int32 fileVersion;
   int32 pointNumber;
   char mapName[32];
   char author[32];
};

// general experience & vistable header information structure
struct ExtHeader {
   char header[8];
   int32 fileVersion;
   int32 pointNumber;
   int32 compressed;
   int32 uncompressed;
};

// floyd-warshall matrices
struct FloydMatrix {
   int dist;
   int index;
};

// define general waypoint structure
struct Path {
   int32 pathNumber;
   int32 flags;
   Vector origin;
   float radius;

   float campStartX;
   float campStartY;
   float campEndX;
   float campEndY;

   int16 index[MAX_PATH_INDEX];
   uint16 connectionFlags[MAX_PATH_INDEX];
   Vector connectionVelocity[MAX_PATH_INDEX];
   int32 distances[MAX_PATH_INDEX];

   struct Vis {
      uint16 stand, crouch;
   } vis;
};

// this structure links waypoints returned from pathfinder
class PathWalk : public IntArray {
public:
   PathWalk (void) {
      reserve (MAX_ROUTE_LENGTH);
      clear ();
   }

   ~PathWalk (void) = default;
public:
   inline int &next (void) {
      return at (1);
   }

   inline int &first (void) {
      return at (0);
   }

   inline bool hasNext (void) const {
      if (empty ()) {
         return false;
      }
      return length () > 1;
   }
};

// main bot class
class Bot final {
   friend class BotManager;

private:
   uint32 m_states; // sensing bitstates
   uint32 m_collideMoves[MAX_COLLIDE_MOVES]; // sorted array of movements
   uint32 m_collisionProbeBits; // bits of possible collision moves
   uint32 m_collStateIndex; // index into collide moves
   uint32 m_aimFlags; // aiming conditions
   uint32 m_currentTravelFlags; // connection flags like jumping

   int m_messageQueue[32]; // stack for messages
   int m_oldButtons; // our old buttons
   int m_reloadState; // current reload state
   int m_voicePitch; // bot voice pitch
   int m_rechoiceGoalCount; // multiple failed goals?
   int m_loosedBombWptIndex; // nearest to loosed bomb waypoint
   int m_plantedBombWptIndex; // nearest to planted bomb waypoint
   int m_currentWaypointIndex; // current waypoint index
   int m_travelStartIndex; // travel start index to double jump action
   int m_prevWptIndex[5]; // previous waypoint indices from waypoint find
   int m_waypointFlags; // current waypoint flags
   int m_needAvoidGrenade; // which direction to strafe away
   int m_campDirection; // camp Facing direction
   int m_campButtons; // buttons to press while camping
   int m_tryOpenDoor; // attempt's to open the door
   int m_liftState; // state of lift handling
   int m_radioSelect; // radio entry
   int m_pingOffset[2];
   int m_ping[3]; // bots pings in scoreboard

   float m_headedTime;
   float m_prevTime; // time previously checked movement speed
   float m_prevSpeed; // speed some frames before
   float m_timeDoorOpen; // time to next door open check
   float m_lastChatTime; // time bot last chatted
   float m_timeLogoSpray; // time bot last spray logo
   float m_knifeAttackTime; // time to rush with knife (at the beginning of the round)
   float m_duckDefuseCheckTime; // time to check for ducking for defuse
   float m_frameInterval; // bot's frame interval
   float m_lastCommandTime; // time bot last thinked
   float m_reloadCheckTime; // time to check reloading
   float m_zoomCheckTime; // time to check zoom again
   float m_shieldCheckTime; // time to check shiled drawing again
   float m_grenadeCheckTime; // time to check grenade usage
   float m_sniperStopTime; // bot switched to other weapon?
   float m_lastEquipTime; // last time we equipped in buyzone
   float m_duckTime; // time to duck
   float m_jumpTime; // time last jump happened
   float m_soundUpdateTime; // time to update the sound
   float m_heardSoundTime; // last time noise is heard
   float m_buttonPushTime; // time to push the button
   float m_liftUsageTime; // time to use lift
   float m_askCheckTime; // time to ask team
   float m_collideTime; // time last collision
   float m_firstCollideTime; // time of first collision
   float m_probeTime; // time of probing different moves
   float m_lastCollTime; // time until next collision check
   float m_jumpStateTimer; // timer for jumping collision check
   float m_lookYawVel; // look yaw velocity
   float m_lookPitchVel; // look pitch velocity
   float m_lookUpdateTime; // lookangles update time
   float m_aimErrorTime; // time to update error vector
   float m_nextCampDirTime; // time next camp direction change
   float m_lastFightStyleCheck; // time checked style
   float m_strafeSetTime; // time strafe direction was set
   float m_randomizeAnglesTime; // time last randomized location
   float m_playerTargetTime; // time last targeting
   float m_timeCamping; // time to camp
   float m_timeWaypointMove; // last time bot followed waypoints
   float m_shootAtDeadTime; // time to shoot at dying players
   float m_followWaitTime; // wait to follow time
   float m_chatterTimes[CHATTER_MAX]; // chatter command timers
   float m_navTimeset; // time waypoint chosen by Bot
   float m_moveSpeed; // current speed forward/backward
   float m_strafeSpeed; // current speed sideways
   float m_minSpeed; // minimum speed in normal mode
   float m_oldCombatDesire; // holds old desire for filtering
   float m_avoidTime; // time to avoid players around
   float m_itemCheckTime; // time next search for items needs to be done

   bool m_moveToGoal; // bot currently moving to goal??
   bool m_isStuck; // bot is stuck
   bool m_isReloading; // bot is reloading a gun
   bool m_forceRadio; // should bot use radio anyway?
   bool m_defendedBomb; // defend action issued
   bool m_defendHostage; // defend action issued
   bool m_duckDefuse; // should or not bot duck to defuse bomb
   bool m_checkKnifeSwitch; // is time to check switch to knife action
   bool m_checkWeaponSwitch; // is time to check weapon switch
   bool m_isUsingGrenade; // bot currently using grenade??
   bool m_bombSearchOverridden; // use normal waypoint if applicable when near the bomb
   bool m_wantsToFire; // bot needs consider firing
   bool m_jumpFinished; // has bot finished jumping
   bool m_isLeader; // bot is leader of his team
   bool m_checkTerrain; // check for terrain
   bool m_moveToC4; // ct is moving to bomb
   bool m_grenadeRequested; // bot requested change to grenade

   PickupType m_pickupType; // type of entity which needs to be used/picked up
   PathWalk m_path; // pointer to current node from path
   StrafeDir m_combatStrafeDir; // direction to strafe
   FightStyle m_fightStyle; // combat style to use
   CollisionState m_collisionState; // collision State
   SearchPathType m_pathType; // which pathfinder to use
   uint8 m_visibility; // visibility flags

   edict_t *m_pickupItem; // pointer to entity of item to use/pickup
   edict_t *m_itemIgnore; // pointer to entity to ignore for pickup
   edict_t *m_liftEntity; // pointer to lift entity
   edict_t *m_breakableEntity; // pointer to breakable entity
   edict_t *m_targetEntity; // the entity that the bot is trying to reach
   edict_t *m_avoidGrenade; // pointer to grenade entity to avoid
   edict_t *m_avoid; // avoid players on our way

   Vector m_liftTravelPos; // lift travel position
   Vector m_moveAngles; // bot move angles
   Vector m_idealAngles; // angle wanted
   Vector m_randomizedIdealAngles; // angle wanted with noise
   Vector m_angularDeviation; // angular deviation from current to ideal angles
   Vector m_aimSpeed; // aim speed calculated
   Vector m_aimLastError; // last calculated aim error
   Vector m_prevOrigin; // origin some frames before
   Vector m_lookAt; // vector bot should look at
   Vector m_throw; // origin of waypoint to throw grenades
   Vector m_enemyOrigin; // target origin chosen for shooting
   Vector m_grenade; // calculated vector for grenades
   Vector m_entity; // origin of entities like buttons etc.
   Vector m_camp; // aiming vector when camping.
   Vector m_desiredVelocity; // desired velocity for jump waypoints
   Vector m_breakableOrigin; // origin of breakable

   Array <edict_t *> m_hostages; // pointer to used hostage entities
   Array <Route> m_routes; // pointer

   BinaryHeap <int, float, MAX_ROUTE_LENGTH> m_routeQue;
   Path *m_currentPath; // pointer to the current path waypoint
   String m_chatBuffer; // space for strings (say text...)

private:
   int pickBestWeapon (int *vec, int count, int moneySave);
   int getBombPoint (void);
   int getCoverPoint (float maxDistance);
   int getDefendPoint (const Vector &origin);
   int searchGoal (void);
   int getGoalProcess (int tactic, IntArray *defensive, IntArray *offsensive);
   int getMsgQueue (void);
   int bestPrimaryCarried (void);
   int bestSecondaryCarried (void);
   int bestGrenadeCarried (void);
   int bestWeaponCarried (void);
   int changePointIndex (int index);
   int getNearestPoint (void);
   int numEnemiesNear (const Vector &origin, float radius);
   int numFriendsNear (const Vector &origin, float radius);
   int searchCampDir (void);
   int searchAimingPoint (const Vector &to);

   float getBombTimeleft (void);
   float getReachTime (void);
   float isInFOV (const Vector &dest);
   float getShiftSpeed (void);
   float getEnemyBodyOffsetCorrection (float distance);

   bool canReplaceWeapon (void);
   bool canDuckUnder (const Vector &normal);
   bool canJumpUp (const Vector &normal);
   bool doneCanJumpUp (const Vector &normal);
   bool cantMoveForward (const Vector &normal, TraceResult *tr);
   bool canStrafeLeft (TraceResult *tr);
   bool canStrafeRight (TraceResult *tr);
   bool isBlockedLeft (void);
   bool isBlockedRight (void);
   bool checkWallOnLeft (void);
   bool checkWallOnRight (void);
   bool updateNavigation (void);
   bool isEnemyThreat (void);
   bool isWeaponRestricted (int weaponIndex);
   bool isWeaponRestrictedAMX (int weaponIndex);
   bool isInViewCone (const Vector &origin);
   bool checkBodyParts (edict_t *target, Vector *origin, uint8 *bodyPart);
   bool seesEnemy (edict_t *player, bool ignoreFOV = false);
   bool doPlayerAvoidance (const Vector &normal);
   bool hasActiveGoal (void);
   bool advanceMovement (void);
   bool isBombDefusing (const Vector &bombOrigin);
   bool isOccupiedPoint (int index);
   bool seesItem (const Vector &dest, const char *itemName);
   bool lastEnemyShootable (void);
   bool isShootableBreakable (edict_t *ent);
   bool rateGroundWeapon (edict_t *ent);
   bool reactOnEnemy (void);
   bool getNextBestPoint (void);
   bool hasAnyWeapons (void);
   bool isDeadlyMove (const Vector &to);
   bool isOutOfBombTimer (void);
   bool isWeaponBadAtDistance (int weaponIndex, float distance);
   bool needToPauseFiring (float distance);
   bool lookupEnemies (void);
   bool isEnemyHidden (edict_t *enemy);
   bool isFriendInLineOfFire (float distance);
   bool isGroupOfEnemies (const Vector &location, int numEnemies = 1, float radius = 256.0f);
   bool isPenetrableObstacle (const Vector &dest);
   bool isPenetrableObstacle2 (const Vector &dest);
   bool isEnemyBehindShield (edict_t *enemy);
   bool checkChatKeywords (String &reply);
   bool isReplyingToChat (void);

   void instantChatter (int type);
   void runAI (void);
   void runMovement (void);
   void checkSpawnConditions (void);
   void buyStuff (void);
   void changePitch (float speed);
   void changeYaw (float speed);
   void checkMsgQueue (void);
   void checkRadioQueue (void);
   void checkReload (void);
   void avoidGrenades (void);
   void checkGrenadesThrow (void);
   void checkBurstMode (float distance);
   void checkSilencer (void);
   void updateAimDir (void);
   void updateLookAngles (void);
   void updateBodyAngles (void);
   void updateLookAnglesNewbie (const Vector &direction, float delta);
   void setIdealReactionTimers (bool actual = false);
   void updateHearing (void);
   void postprocessGoals (const IntArray &goals, int *result);
   void processPickups (void);
   void checkTerrain (float movedDistance, const Vector &dirNormal);
   void checkDarkness (void);
   void checkParachute (void);
   void getCampDirection (Vector *dest);
   void collectGoalExperience (int damage);
   void collectDataExperience (edict_t *attacker, int damage);
   void searchShortestPath (int srcIndex, int destIndex);
   void searchPath (int srcIndex, int destIndex, SearchPathType pathType = SEARCH_PATH_FASTEST);
   void clearRoute (void);
   void sayDebug (const char *format, ...);
   void frame (void);
   void resetCollision (void);
   void ignoreCollision (void);
   void setConditions (void);
   void overrideConditions (void);
   void updateEmotions (void);
   void setStrafeSpeed (const Vector &moveDir, float strafeSpeed);
   void updateTeamJoin (void);
   void updateTeamCommands (void);
   void decideFollowUser (void);
   void attackMovement (void);
   void getValidPoint (void);
   void fireWeapons (void);
   void selectWeapons (float distance, int index, int id, int choosen);
   void focusEnemy (void);
   void selectBestWeapon (void);
   void selectSecondary (void);
   void selectWeaponByName (const char *name);
   void selectWeaponById (int num);
   void completeTask (void);
   void processTasks (void);

   void normal_ (void);
   void spraypaint_ (void);
   void huntEnemy_ (void);
   void seekCover_ (void);
   void attackEnemy_ (void);
   void pause_ (void);
   void blind_ (void);
   void camp_ (void);
   void hide_ (void);
   void moveToPos_ (void);
   void plantBomb_ (void);
   void bombDefuse_ (void);
   void followUser_ (void);
   void throwExplosive_ (void);
   void throwFlashbang_ (void);
   void throwSmoke_ (void);
   void doublejump_ (void);
   void escapeFromBomb_ (void);
   void pickupItem_ (void);
   void shootBreakable_ (void);

   edict_t *lookupButton (const char *targetName);
   edict_t *lookupBreakable (void);
   edict_t *correctGrenadeVelocity (const char *model);

   const Vector &getEnemyBodyOffset (void);
   Vector calcThrow (const Vector &start, const Vector &stop);
   Vector calcToss (const Vector &start, const Vector &stop);
   Vector isBombAudible (void);
   Vector getBodyOffsetError (float distance);

   uint8 computeMsec (void);

private:
   bool isOnLadder (void) const {
      return pev->movetype == MOVETYPE_FLY;
   }

   bool isOnFloor (void) const {
      return (pev->flags & (FL_ONGROUND | FL_PARTIALGROUND)) != 0;
   }

   bool isInWater (void) const {
      return pev->waterlevel >= 2;
   }

public:
   entvars_t *pev;

   int m_wantedTeam; // player team bot wants select
   int m_wantedClass; // player model bot wants to select
   int m_difficulty; // bots hard level
   int m_moneyAmount; // amount of money in bot's bank

   float m_spawnTime; // time this bot spawned
   float m_timeTeamOrder; // time of last radio command
   float m_slowFrameTimestamp; // time to per-second think
   float m_timeRepotingInDelay; // time to delay report-in
   float m_nextBuyTime; // next buy time
   float m_checkDarkTime; // check for darkness time
   float m_preventFlashing; // bot turned away from flashbang
   float m_flashLevel; // flashlight level
   float m_blindTime; // time when bot is blinded
   float m_blindMoveSpeed; // mad speeds when bot is blind
   float m_blindSidemoveSpeed; // mad side move speeds when bot is blind
   float m_fallDownTime; // time bot started to fall 
   float m_duckForJump; // is bot needed to duck for double jump
   float m_baseAgressionLevel; // base aggression level (on initializing)
   float m_baseFearLevel; // base fear level (on initializing)
   float m_agressionLevel; // dynamic aggression level (in game)
   float m_fearLevel; // dynamic fear level (in game)
   float m_nextEmotionUpdate; // next time to sanitize emotions
   float m_thinkFps; // skip some frames in bot thinking
   float m_thinkInterval; // interval between frames
   float m_goalValue; // ranking value for this waypoint
   float m_viewDistance; // current view distance
   float m_maxViewDistance; // maximum view distance
   float m_retreatTime; // time to retreat?
   float m_enemyUpdateTime; // time to check for new enemies
   float m_enemyReachableTimer; // time to recheck if enemy reachable
   float m_enemyIgnoreTimer; // ignore enemy for some time
   float m_seeEnemyTime; // time bot sees enemy
   float m_enemySurpriseTime; // time of surprise
   float m_idealReactionTime; // time of base reaction
   float m_actualReactionTime; // time of current reaction time
   float m_timeNextTracking; // time waypoint index for tracking player is recalculated
   float m_firePause; // time to pause firing
   float m_shootTime; // time to shoot
   float m_timeLastFired; // time to last firing

   int m_numEnemiesLeft; // number of enemies alive left on map
   int m_numFriendsLeft; // number of friend alive left on map
   int m_retryJoin; // retry count for chosing team/class
   int m_startAction; // team/class selection state
   int m_voteKickIndex; // index of player to vote against
   int m_lastVoteKick; // last index
   int m_voteMap; // number of map to vote for
   int m_logotypeIndex; // index for logotype
   int m_buyState; // current count in buying
   int m_blindButton; // buttons bot press, when blind
   int m_radioOrder; // actual command
   int m_actMessageIndex; // current processed message
   int m_pushMessageIndex; // offset for next pushed message
   int m_prevGoalIndex; // holds destination goal waypoint
   int m_chosenGoalIndex; // used for experience, same as above
   int m_lastDamageType; // stores last damage
   int m_team; // bot team
   int m_currentWeapon; // one current weapon for each bot
   int m_ammoInClip[MAX_WEAPONS]; // ammo in clip for each weapons
   int m_ammo[MAX_AMMO_SLOTS]; // total ammo amounts

   bool m_isVIP; // bot is vip?
   bool m_notKilled; // has the player been killed or has he just respawned
   bool m_notStarted; // team/class not chosen yet
   bool m_ignoreBuyDelay; // when reaching buyzone in the middle of the round don't do pauses
   bool m_inBombZone; // bot in the bomb zone or not
   bool m_inBuyZone; // bot currently in buy zone
   bool m_inVIPZone; // bot in the vip satefy zone
   bool m_buyingFinished; // done with buying
   bool m_buyPending; // bot buy is pending
   bool m_hasDefuser; // does bot has defuser
   bool m_hasNVG; // does bot has nightvision goggles
   bool m_usesNVG; // does nightvision goggles turned on
   bool m_hasC4; // does bot has c4 bomb
   bool m_hasProgressBar; // has progress bar on a HUD
   bool m_jumpReady; // is double jump ready
   bool m_canChooseAimDirection; // can choose aiming direction
   bool m_isEnemyReachable; // direct line to enemy

   edict_t *m_doubleJumpEntity; // pointer to entity that request double jump
   edict_t *m_radioEntity; // pointer to entity issuing a radio command
   edict_t *m_enemy; // pointer to enemy entity
   edict_t *m_lastEnemy; // pointer to last enemy entity
   edict_t *m_lastVictim; // pointer to killed entity
   edict_t *m_trackingEdict; // pointer to last tracked player when camping/hiding

   Vector m_waypointOrigin; // origin of waypoint
   Vector m_destOrigin; // origin of move destination
   Vector m_position; // position to move to in move to position task
   Vector m_doubleJumpOrigin; // origin of double jump
   Vector m_lastEnemyOrigin; // vector to last enemy origin
  
   ChatCollection m_sayTextBuffer; // holds the index & the actual message of the last unprocessed text message of a player
   BurstMode m_weaponBurstMode; // bot using burst mode? (famas/glock18, but also silencer mode)
   Personality m_personality; // bots type
   Array<Task> m_tasks;

public:
   Bot (edict_t *bot, int difficulty, int personality, int team, int member, const String &steamId);
   ~Bot (void);

public:
   void slowFrame (void); // the main function that decides intervals of running bot ai
   void fastFrame (void); /// the things that can be executed while skipping frames
   void processBlind (int alpha);
   void processDamage (edict_t *inflictor, int damage, int armor, int bits);
   void showDebugOverlay (void);
   void newRound (void);
   void processBuyzoneEntering (int buyState);
   void pushMsgQueue (int message);
   void prepareChatMessage (const String &message);
   void checkForChat (void);
   void showChaterIcon (bool show);
   void clearSearchNodes (void);
   void processBreakables (edict_t *touch);
   void avoidIncomingPlayers (edict_t *touch);
   void startTask (TaskID id, float desire, int data, float time, bool resume);
   void clearTask (TaskID id);
   void filterTasks (void);
   void clearTasks (void);
   void dropWeaponForUser (edict_t *user, bool discardC4);
   void say (const char *text);
   void sayTeam (const char *text);
   void pushChatMessage (int type, bool isTeamSay = false);
   void pushRadioMessage (int message);
   void pushChatterMessage (int message);
   void processChatterMessage (const char *tempMessage);
   void tryHeadTowardRadioMessage (void);
   void kill (void);
   void kick (void);
   void resetDoubleJump (void);
   void startDoubleJump (edict_t *ent);

   bool hasHostage (void);
   bool usesRifle (void);
   bool usesPistol (void);
   bool usesSniper (void);
   bool usesSubmachine (void);
   bool usesZoomableRifle (void);
   bool usesBadWeapon (void);
   bool usesCampGun (void);
   bool hasPrimaryWeapon (void);
   bool hasSecondaryWeapon (void);
   bool hasShield (void);
   bool isShieldDrawn (void);
   bool searchOptimalPoint (void);
   bool seesEntity (const Vector &dest, bool fromBody = false);

   int index (void);
   int getAmmo (void);
   int getNearestToPlantedBomb (void);

   float getFrameInterval (void);
   Task *getTask (void);

public:
   inline int getAmmoInClip (void) const {
      return m_ammoInClip[m_currentWeapon];
   }
   
   inline Vector getCenter (void) const {
      return (pev->absmax + pev->absmin) * 0.5;
   };

   inline Vector getEyesPos (void) const {
      return pev->origin + pev->view_ofs;
   };

   inline TaskID taskId (void)  {
      return getTask ()->id;
   }

   inline edict_t *ent (void) {
      return pev->pContainingEntity;
   };
};

// manager class
class BotManager final : public Singleton <BotManager> {
private:
   float m_timeRoundStart;
   float m_timeRoundEnd;
   float m_timeRoundMid;
   float m_maintainTime; // time to maintain bot creation
   float m_quotaMaintainTime; // time to maintain bot quota
   float m_grenadeUpdateTime; // time to update active grenades
   float m_entityUpdateTime; // time to update intresting entities
   float m_plantSearchUpdateTime; // time to update for searching planted bomb
   float m_lastChatTime; // global chat time timestamp
   float m_timeBombPlanted; // time the bomb were planted
   float m_lastRadioTime[MAX_TEAM_COUNT]; // global radio time

   int m_lastWinner; // the team who won previous round
   int m_lastDifficulty; // last bots difficulty
   int m_bombSayStatus; // some bot is issued whine about bomb
   int m_lastRadio[MAX_TEAM_COUNT];

   bool m_leaderChoosen[MAX_TEAM_COUNT]; // is team leader choose theese round
   bool m_economicsGood[MAX_TEAM_COUNT]; // is team able to buy anything
   bool m_deathMsgSent; // for fake ping
   bool m_bombPlanted;
   bool m_botsCanPause;
   bool m_roundEnded;

   Array <edict_t *> m_activeGrenades; // holds currently active grenades on the map
   Array <edict_t *> m_intrestingEntities;  // holds currently intresting entities on the map
   Array <CreateQueue> m_creationTab; // bot creation tab
   Array <Task> m_filters;

   Bot *m_bots[MAX_ENGINE_PLAYERS]; // all available bots
   edict_t *m_killerEntity; // killer entity for bots

protected:
   BotCreationResult create (const String &name, int difficulty, int personality, int team, int member);

public:
   BotManager (void);
   ~BotManager (void);

public:
   Bot *getBot (int index);
   Bot *getBot (edict_t *ent);
   Bot *getAliveBot (void);
   Bot *getHighfragBot (int team);

   int index (edict_t *ent);
   int getHumansCount (bool ignoreSpectators = false);
   int getAliveHumansCount (void);
   int getBotCount (void);

   void setBombPlanted (bool isPlanted);
   void countTeamPlayers (int &ts, int &cts);
   void slowFrame (void);
   void frame (void);
   void createKillerEntity (void);
   void destroyKillerEntity (void);
   void touchKillerEntity (Bot *bot);
   void destroy (void);
   void destroy (int index);
   void addbot (const String &name, int difficulty, int personality, int team, int member, bool manual);
   void addbot (const String &name, const String &difficulty, const String &personality, const String &team, const String &member, bool manual);
   void serverFill (int selection, int personality = PERSONALITY_NORMAL, int difficulty = -1, int numToAdd = -1);
   void kickEveryone (bool instant = false,  bool zeroQuota = true);
   bool kickRandom (bool decQuota = true, Team fromTeam = TEAM_UNASSIGNED);
   void kickBot (int index);
   void kickFromTeam (Team team, bool removeAll = false);
   void killAllBots (int team = -1);
   void maintainQuota (void);
   void initQuota (void);
   void initRound (void);
   void decrementQuota (int by = 1);
   void selectLeaders (int team, bool reset);
   void listBots (void);
   void setWeaponMode (int selection);
   void updateTeamEconomics (int team, bool setTrue = false);
   void updateBotDifficulties (void);
   void reset (void);
   void initFilters (void);
   void resetFilters (void);
   void updateActiveGrenade (void);
   void updateIntrestingEntities (void);
   void calculatePingOffsets (void);
   void sendPingOffsets (edict_t *to);
   void sendDeathMsgFix (void);
   void captureChatRadio (const char *cmd, const char *arg, edict_t *ent);
   void notifyBombDefuse (void);
   void execGameEntity (entvars_t *vars);

   bool isTeamStacked (int team);

public:
   Array <edict_t *> &searchActiveGrenades (void) {
      return m_activeGrenades;
   }

   Array <edict_t *> &searchIntrestingEntities (void) {
      return m_intrestingEntities;
   }

   bool hasActiveGrenades (void) const {
      return !m_activeGrenades.empty ();
   }

   bool hasIntrestingEntities (void) const {
      return !m_intrestingEntities.empty ();
   }

   bool checkTeamEco (int team) const {
      return m_economicsGood[team];
   }

   int getLastWinner (void) const {
      return m_lastWinner;
   }

   void setLastWinner (int winner) {
      m_lastWinner = winner;
   }

   // get the list of filters
   Array <Task> &getFilters (void) {
      return m_filters;
   }

   void createRandom (bool manual = false) {
      addbot ("", -1, -1, -1, -1, manual);
   }

   void updateDeathMsgState (bool sent) {
      m_deathMsgSent = sent;
   }

   bool isBombPlanted (void) const {
      return m_bombPlanted;
   }

   float getTimeBombPlanted (void) const {
      return m_timeBombPlanted;
   }

   float getRoundStartTime (void) const {
      return m_timeRoundStart;
   }

   float getRoundMidTime (void) const {
      return m_timeRoundMid;
   }

   float getRoundEndTime (void) const {
      return m_timeRoundEnd;
   }

   bool isRoundOver (void) const {
      return m_roundEnded;
   }

   void setRoundOver (const bool over) {
      m_roundEnded = over;
   }

   bool canPause (void) const {
      return m_botsCanPause;
   }

   void setCanPause (const bool pause) {
      m_botsCanPause = pause;
   }

   bool hasBombSay (int type) {
      return (m_bombSayStatus & type) == type;
   }

   void clearBombSay (int type) {
      m_bombSayStatus &= ~type;
   }

   void setPlantedBombSearchTimestamp (const float timestamp) {
      m_plantSearchUpdateTime = timestamp;
   }

   float getPlantedBombSearchTimestamp (void) const {
      return m_plantSearchUpdateTime;
   }

   void setLastRadioTimestamp (const int team, const float timestamp) {
      m_lastRadioTime[team] = timestamp;
   }

   float getLastRadioTimestamp (const int team) const {
      return m_lastRadioTime[team];
   }

   void setLastRadio (const int team, const int radio) {
      m_lastRadio[team] = radio;
   }

   int getLastRadio (const int team) const {
      return m_lastRadio[team];
   }

   void setLastChatTimestamp (const float timestamp) {
      m_lastChatTime = timestamp;
   }

   float getLastChatTimestamp (void) const {
      return m_lastChatTime;
   }

   // some bots are online ?
   bool hasBotsOnline (void) {
      return getBotCount () > 0;
   }
};

// waypoint operation class
class Waypoint final : public Singleton <Waypoint> {
public:
   friend class Bot;

private:
   struct Bucket {
      int x, y, z;
   };

   int m_editFlags;
   int m_numWaypoints;
   int m_loadTries;
   int m_cacheWaypointIndex;
   int m_lastJumpWaypoint;
   int m_visibilityIndex;
   int m_findWPIndex;
   int m_facingAtIndex;
   int m_highestDamage[MAX_TEAM_COUNT];

   float m_timeJumpStarted;
   float m_autoPathDistance;
   float m_pathDisplayTime;
   float m_arrowDisplayTime;
   float m_waypointDisplayTime[MAX_WAYPOINTS];
   float m_waypointLightLevel[MAX_WAYPOINTS];

   bool m_waypointPaths;
   bool m_isOnLadder;
   bool m_endJumpPoint;
   bool m_learnJumpWaypoint;
   bool m_waypointsChanged;
   bool m_needsVisRebuild;

   Vector m_learnVelocity;
   Vector m_learnPosition;
   Vector m_bombPos;
   Vector m_lastWaypoint;

   IntArray m_terrorPoints;
   IntArray m_ctPoints;
   IntArray m_goalPoints;
   IntArray m_campPoints;
   IntArray m_sniperPoints;
   IntArray m_rescuePoints;
   IntArray m_visitedGoals;
   IntArray m_buckets[MAX_WAYPOINT_BUCKET_MAX][MAX_WAYPOINT_BUCKET_MAX][MAX_WAYPOINT_BUCKET_MAX];
   String m_tempInfo;

   FloydMatrix *m_matrix;
   Experience *m_experience;
   edict_t *m_editor;

   Path *m_paths[MAX_WAYPOINTS];
   uint8 m_visLUT[MAX_WAYPOINTS][MAX_WAYPOINTS / 4];

public:
   Waypoint (void);
   ~Waypoint (void);

public:

   int getFacingIndex (void);
   int getFarest (const Vector &origin, float maxDistance = 32.0);
   int getNearest (const Vector &origin, float minDistance = 9999.0f, int flags = -1);
   int getNearestNoBuckets (const Vector &origin, float minDistance = 9999.0f, int flags = -1);
   int getEditorNeareset (void);
   int getDangerIndex (int team, int start, int goal);
   int getDangerValue (int team, int start, int goal);
   int getDangerDamage (int team, int start, int goal);
   int getPathDist (int srcIndex, int destIndex);
   int clearConnections (int index);

   float calculateTravelTime (float maxSpeed, const Vector &src, const Vector &origin);

   bool load (void);
   bool isVisible (int srcIndex, int destIndex);
   bool isStandVisible (int srcIndex, int destIndex);
   bool isDuckVisible (int srcIndex, int destIndex);
   bool isConnected (int pointA, int pointB);
   bool isConnected (int index);
   bool isReachable (Bot *bot, int index);
   bool isNodeReacheable (const Vector &src, const Vector &destination);
   bool checkNodes (void);
   bool loadPathMatrix (void);
   bool saveExtFile (const char *ext, const char *type, const char *magic, int version, uint8 *data, int32 size);
   bool loadExtFile (const char *ext, const char *type, const char *magic, int version, uint8 *data);
   bool isVisited (int index);

   void save (void);
   void init (void);
   void frame (void);
   void loadExperience (void);
   void loadVisibility (void);
   void initTypes (void);
   void initLightLevels (void);
   void addPath (int addIndex, int pathIndex, float distance);
   void push (int flags, const Vector &waypointOrigin = Vector::null ());
   void erase (int target);
   void toggleFlags (int toggleFlag);
   void setRadius (int index, float radius);
   void rebuildVisibility (void);
   void pathCreate (char dir);
   void erasePath (void);
   void cachePoint (int index);
   void calculatePathRadius (int index);
   void cleanupPathMemory (void);
   void saveExperience (void);
   void saveVisibility (void);
   void addBasic (void);
   void eraseFromDisk (void);
   void initPathMatrix (void);
   void savePathMatrix (void);
   void setSearchIndex (int index);
   void startLearnJump (void);
   void setVisited (int index);
   void clearVisited (void);
   void initBuckets (void);
   void addToBucket (const Vector &pos, int index);
   void eraseFromBucket (const Vector &pos, int index);
   void setBombPos (bool reset = false, const Vector &pos = Vector::null ());
   void closeSocket (int sock);
   void updateGlobalExperience (void);

   const char *getDataDirectory (bool isMemoryFile = false);
   const char *getWaypointFilename (bool isMemoryFile = false);

   WaypointDownloadError downloadWaypoint (void);
   Bucket locateBucket (const Vector &pos);

   IntArray searchRadius (float radius, const Vector &origin, int maxCount = -1);
   IntArray &getWaypointsInBucket (const Vector &pos);

public:
   Experience *getRawExperience (void) {
      return m_experience;
   }

   int getHighestDamageForTeam (int team) const {
      return m_highestDamage[team];
   }

   void setHighestDamageForTeam (int team, int value) {
      m_highestDamage[team] = value;
   }

   const char *getAuthor (void) const {
      return m_tempInfo.chars ();
   }

   bool hasChanged (void) const {
      return m_waypointsChanged;
   }

   bool hasEditFlag (int flag) const {
      return !!(m_editFlags & flag);
   }

   void setEditFlag (int flag) {
      m_editFlags |= flag;
   }

   void clearEditFlag (int flag) {
      m_editFlags &= ~flag;
   }

   void setAutoPathDistance (const float distance) {
      m_autoPathDistance = distance;
   }

   const Vector &getBombPos (void) const {
      return m_bombPos;
   }

   // access paths
   Path &operator [] (int index) {
      return *m_paths[index];
   }

   // check waypoints range
   bool exists (int index) const {
      return index >= 0 && index < m_numWaypoints;
   }

   // get real waypoint num
   int length (void) const {
      return m_numWaypoints;
   }

   // get the light level of waypoint
   float getLightLevel (int id) const {
      return m_waypointLightLevel[id];
   }

   // check if has editor
   bool hasEditor (void) const {
      return !!m_editor;
   }

   // set's the waypoint editor
   void setEditor (edict_t *ent) {
      m_editor = ent;
   }

   // get the current waypoint editor
   edict_t *getEditor (void) {
      return m_editor;
   }
};

// mostly config stuff, and some stuff dealing with menus
class Config final : public Singleton <Config> {
private:
   Array <StringArray> m_chat;
   Array <Array <ChatterItem>> m_chatter;
   Array <BotName> m_botNames;
   Array <Keywords> m_replies;
   Array <WeaponInfo> m_weapons;

   // weapon info gathered through engine messages
   WeaponProp m_weaponProps[MAX_WEAPONS + 1];

   // default tables for personality weapon preferences, overridden by general.cfg
   int m_normalWeaponPrefs[NUM_WEAPONS] = { 0, 2, 1, 4, 5, 6, 3, 12, 10, 24, 25, 13, 11, 8, 7, 22, 23, 18, 21, 17, 19, 15, 17, 9, 14, 16 };
   int m_rusherWeaponPrefs[NUM_WEAPONS] = { 0, 2, 1, 4, 5, 6, 3, 24, 19, 22, 23, 20, 21, 10, 12, 13, 7, 8, 11, 9, 18, 17, 19, 25, 15, 16 };
   int m_carefulWeaponPrefs[NUM_WEAPONS] = { 0, 2, 1, 4, 25, 6, 3, 7, 8, 12, 10, 13, 11, 9, 24, 18, 14, 17, 16, 15, 19, 20, 21, 22, 23, 5 };
   int m_grenadeBuyPrecent[NUM_WEAPONS - 23] = { 95, 85, 60 };
   int m_botBuyEconomyTable[NUM_WEAPONS - 15] = { 1900, 2100, 2100, 4000, 6000, 7000, 16000, 1200, 800, 1000, 3000 };
   int *m_weaponPrefs[3] = { m_normalWeaponPrefs, m_rusherWeaponPrefs, m_carefulWeaponPrefs };

public:
   Config (void) = default;
   ~Config (void) = default;

public:

   // load the configuration files
   void load (bool onlyMain);

   // picks random bot name
   BotName *pickBotName (void);

   // remove bot name from used list
   void clearUsedName (Bot *bot);

   // initialize weapon info
   void initWeapons (void);

   // fix weapon prices (ie for elite)
   void adjustWeaponPrices (void);

   WeaponInfo &findWeaponById (int id);

public:

   // get the chat array
   Array <StringArray> &getChat (void) {
      return m_chat;
   }

   // get's the chatter array
   Array <Array <ChatterItem>> &getChatter (void) {
      return m_chatter;
   }

   // get's the replies array
   Array <Keywords> &getReplies (void) {
      return m_replies;
   }

   // get's the weapon info data
   Array <WeaponInfo> &getWeapons (void) {
      return m_weapons;
   }

   // get's raw weapon info
   WeaponInfo *getRawWeapons (void) {
      return m_weapons.begin ();
   }

   // set's the weapon properties
   void setWeaponProp (const WeaponProp &prop) {
      m_weaponProps[prop.id] = prop;
   }

   // get's the weapons prop
   const WeaponProp &getWeaponProp (int id) const {
      return m_weaponProps[id];
   }

   // get's weapon preferences for personality
   int *getWeaponPrefs (int personality) const {
      return m_weaponPrefs[personality];
   }

   // get economics value
   int *getEconLimit (void) {
      return m_botBuyEconomyTable;
   }

   // get's grenade buy percents
   bool chanceToBuyGrenade (const int grenadeType) const {
      return RandomSequence::ref ().chance (m_grenadeBuyPrecent[grenadeType]);
   }
};

class BotUtils final : public Singleton <BotUtils> {
private:
   bool m_needToSendWelcome;
   float m_welcomeReceiveTime;
   StringArray m_sentences;
   Array <Client> m_clients;
   Array <Pair <String, String>> m_tags;

public:
   BotUtils (void);
   ~BotUtils (void) = default;

public:
   // need to send welcome message ?
   void checkWelcome (void);

   // gets the weapon alias as hlsting, maybe move to config...
   int getWeaponAlias (bool needString, const char *weaponAlias, int weaponIndex = -1);

   // gets the build number of bot
   int buildNumber (void);

   // gets the shooting cone deviation
   float getShootingCone (edict_t *ent, const Vector &position);

   // check if origin is visible from the entity side
   bool isVisible (const Vector &origin, edict_t *ent);

   // check if entity is alive
   bool isAlive (edict_t *ent);

   // check if origin is inside view cone of entity
   bool isInViewCone (const Vector &origin, edict_t *ent);

   // checks if entitiy is fakeclient
   bool isFakeClient (edict_t *ent);

   // check if entitiy is a player
   bool isPlayer (edict_t *ent);

   // check if entity is a vip
   bool isPlayerVIP (edict_t *ent);

   // opens config helper
   bool openConfig (const char *fileName, const char *errorIfNotExists, MemFile *outFile, bool languageDependant = false);

   // nearest player search helper
   bool findNearestPlayer (void **holder, edict_t *to, float searchDistance = 4096.0, bool sameTeam = false, bool needBot = false, bool needAlive = false, bool needDrawn = false, bool needBotWithC4 = false);

   // simple loggerfor  bots
   void logEntry (bool outputToConsole, int logLevel, const char *format, ...);

   // tracing decals for bots spraying logos
   void traceDecals (entvars_t *pev, TraceResult *trace, int logotypeIndex);

   // attaches sound to client struct
   void attachSoundsToClients (edict_t *ent, const char *sample, float volume);

   // simulate sound for players
   void simulateSoundUpdates (int playerIndex);

   // simple format utility
   const char *format (const char *format, ...);

   // update stats on clients
   void updateClients (void);

   // chat helper to strip the clantags out of the string
   void stripTags (String &line);

   // chat helper to make player name more human-like
   void humanizePlayerName (String &playerName);

   // chat helper to add errors to the bot chat string
   void addChatErrors (String &line);

   // chat helper to find keywords for given string
   bool checkKeywords (const String &line, String &reply);

public:

   // re-show welcome after changelevel ?
   void setNeedForWelcome (bool need) {
      m_needToSendWelcome = need;
   }

   // get array of clients
   Array <Client> &getClients (void) {
      return m_clients;
   }

   // get clients as const-reference
   const Array <Client> &getClients (void) const {
      return m_clients;
   }

   // get single client as ref
   Client &getClient (const int index) {
      return m_clients[index];
   }

   // checks if string is not empty
   bool isEmptyStr (const char *input) const {
      if (input == nullptr) {
         return true;
      }
      return *input == '\0';
   }
};

// bot command manager
class BotControl final : public Singleton <BotControl> {
public:
   using Handler = int (BotControl::*) (void);
   using MenuHandler = int (BotControl::*) (int);

public:
   // generic bot command
   struct BotCmd {
      String name, format, help;
      Handler handler;
   };

   // single bot menu
   struct Menu {
      int ident, slots;
      String text;
      MenuHandler handler;
   };

private:
   StringArray m_args;
   Array <BotCmd> m_cmds;
   Array <Menu> m_menus;

   edict_t *m_ent;

   bool m_isFromConsole;
   bool m_isMenuFillCommand;
   int m_menuServerFillTeam;
   int m_interMenuData[4] = { 0, };

public:
   BotControl (void);
   ~BotControl (void) = default;

private:
   int cmdAddBot (void);
   int cmdKickBot (void);
   int cmdKickBots (void);
   int cmdKillBots (void);
   int cmdFill (void);
   int cmdVote (void);
   int cmdWeaponMode (void);
   int cmdVersion (void);
   int cmdWaypointMenu (void);
   int cmdMenu (void);
   int cmdList (void);
   int cmdWaypoint (void);
   int cmdWaypointOn (void);
   int cmdWaypointOff (void);
   int cmdWaypointAdd (void);
   int cmdWaypointAddBasic (void);
   int cmdWaypointSave (void);
   int cmdWaypointLoad (void);
   int cmdWaypointErase (void);
   int cmdWaypointDelete (void);
   int cmdWaypointCheck (void);
   int cmdWaypointCache (void);
   int cmdWaypointClean (void);
   int cmdWaypointSetRadius (void);
   int cmdWaypointSetFlags (void);
   int cmdWaypointTeleport (void);
   int cmdWaypointPathCreate (void);
   int cmdWaypointPathDelete (void);
   int cmdWaypointPathSetAutoDistance (void);
   int cmdWaypointAcquireEditor (void);
   int cmdWaypointReleaseEditor (void);

private:
   int menuMain (int item);
   int menuFeatures (int item);
   int menuControl (int item);
   int menuWeaponMode (int item);
   int menuPersonality (int item);
   int menuDifficulty (int item);
   int menuTeamSelect (int item);
   int menuClassSelect (int item);
   int menuCommands (int item);
   int menuWaypointPage1 (int item);
   int menuWaypointPage2 (int item);
   int menuWaypointRadius (int item);
   int menuWaypointType (int item);
   int menuWaypointFlag (int item);
   int menuWaypointPath (int item);
   int menuAutoPathDistance (int item);
   int menuKickPage1 (int item);
   int menuKickPage2 (int item);
   int menuKickPage3 (int item);
   int menuKickPage4 (int item);

private:
   void enableDrawModels (bool enable);
   void createMenus (void);

public:
   bool executeCommands (void);
   bool executeMenus (void);
   void showMenu (int id);
   void kickBotByMenu (int page);
   void msg (const char *fmt, ...);
   void assignAdminRights (edict_t *ent, char *infobuffer);
   void maintainAdminRights (void);

public:
   void setFromConsole (const bool console) {
      m_isFromConsole = console;
   }

   void setArgs (const StringArray &args) {
      m_args.assign (args);
   }

   void setIssuer (edict_t *ent) {
      m_ent = ent;
   }

   void fixMissingArgs (size_t num) {
      if (num < m_args.length ()) {
         return;
      }

      do {
         m_args.push ("");
      } while (num--);
   }

   int getInt (size_t arg) const {
      if (!hasArg (arg)) {
         return 0;
      }
      return m_args[arg].toInt32 ();
   }

   const String &getStr (size_t arg) {
      static String empty ("empty");

      if (!hasArg (arg) || m_args[arg].empty ()) {
         return empty;
      }
      return m_args[arg];
   }

   bool hasArg (size_t arg) const {
      return arg < m_args.length ();
   }

   StringArray collectArgs (void) {
      StringArray args;

      for (int i = 0; i < engfuncs.pfnCmd_Argc (); i++) {
         args.push (engfuncs.pfnCmd_Argv (i));
      }
      return args;
   }

public:

   // for the server commands
   static void handleEngineCommands (void);

   // for the client commands
   bool handleClientCommands (edict_t *ent);

   // for the client menu commands
   bool handleMenuCommands (edict_t *ent);
};

#include <engine.h>

// expose bot super-globals
static auto &waypoints = Waypoint::ref ();
static auto &bots = BotManager::ref ();
static auto &rng = RandomSequence::ref ();
static auto &conf = Config::ref ();
static auto &util = BotUtils::ref ();
static auto &ctrl = BotControl::ref ();
static auto &game = Game::ref ();
static auto &illum = LightMeasure::ref ();

// very global convars
extern ConVar yb_jasonmode;
extern ConVar yb_communication_type;
extern ConVar yb_ignore_enemies;
extern ConVar yb_chat;
extern ConVar yb_language;

inline int Bot::index (void) {
   return game.indexOfEntity (ent ());
}

inline int Game::getTeam (edict_t *ent) {
   if (game.isNullEntity (ent)) {
      return TEAM_UNASSIGNED;
   }
   return util.getClient (indexOfEntity (ent) - 1).team;
}