#include <common/weapons/_all.qh>
#include <common/stats.qh>
#include <common/physics/player.qh>

Include dependency graph for api.qh:

This graph shows which files directly or indirectly include this file:

Functions
bool	bot_aim (entity this,.entity weaponentity, float shotspeed, float shotspeedupward, float maxshottime, float applygravity)

void	bot_aim_reset (entity this)

void	bot_clientconnect (entity this)

void	bot_clientdisconnect (entity this)

void	bot_cmdhelp (string scmd)

void	bot_endgame ()

bool	bot_fixcount (bool multiple_per_frame)

void	bot_list_commands ()

void	bot_queuecommand (entity bot, string cmdstring)

void	bot_relinkplayerlist ()

void	bot_resetqueues ()

void	bot_serverframe ()

bool	bot_shouldattack (entity this, entity e)

void	bot_think (entity this)

entity	find_bot_by_name (string name)

entity	find_bot_by_number (float number)

	float (entity player, entity item) bot_pickupevalfunc

vector	get_closer_dest (entity ent, vector org)

void	havocbot_goalrating_enemyplayers (entity this, float ratingscale, vector org, float sradius)

bool	havocbot_goalrating_item_pickable_check_players (entity this, vector org, entity item, vector item_org)

void	havocbot_goalrating_items (entity this, float ratingscale, vector org, float sradius)

void	havocbot_goalrating_waypoints (entity this, float ratingscale, vector org, float sradius)

void	navigation_dynamicgoal_init (entity this, bool initially_static)

void	navigation_dynamicgoal_set (entity this, entity dropper)

void	navigation_dynamicgoal_unset (entity this)

entity	navigation_findnearestwaypoint (entity ent, float walkfromwp)

void	navigation_goalrating_end (entity this)

void	navigation_goalrating_start (entity this)

bool	navigation_goalrating_timeout (entity this)

bool	navigation_goalrating_timeout_can_be_anticipated (entity this)

void	navigation_goalrating_timeout_expire (entity this, float seconds)

void	navigation_goalrating_timeout_extend_if_needed (entity this, float seconds)

void	navigation_goalrating_timeout_force (entity this)

void	navigation_goalrating_timeout_set (entity this)

void	navigation_markroutes (entity this, entity fixed_source_waypoint)

void	navigation_markroutes_inverted (entity fixed_source_waypoint)

void	navigation_routerating (entity this, entity e, float f, float rangebias)

void	set_tracewalk_dest (entity ent, vector org, bool fix_player_dest)

vector	set_tracewalk_dest_2 (entity ent, vector org)

	STATIC_INIT (botapi)

bool	tracewalk (entity e, vector start, vector m1, vector m2, vector end, float end_height, float movemode)

	void (entity this) havocbot_role

void	waypoint_getSymmetricalAxis_cmd (entity caller, bool save, int arg_idx)

void	waypoint_getSymmetricalOrigin_cmd (entity caller, bool save, int arg_idx)

void	waypoint_lock (entity pl)

void	waypoint_remove (entity wp)

void	waypoint_remove_fromeditor (entity pl)

void	waypoint_saveall ()

void	waypoint_schedulerelink (entity wp)

void	waypoint_schedulerelinkall ()

entity	waypoint_spawn (vector m1, vector m2, float f)

void	waypoint_spawn_fromeditor (entity pl, bool at_crosshair, bool is_jump_wp, bool is_crouch_wp, bool is_support_wp)

void	waypoint_spawnforitem (entity e)

void	waypoint_spawnforitem_force (entity e, vector org)

void	waypoint_spawnforteleporter (entity e, vector destination, float timetaken, entity tracetest_ent)

void	waypoint_spawnforteleporter_wz (entity e, entity tracetest_ent)

void	waypoint_start_hardwiredlink (entity pl, bool at_crosshair)

void	waypoint_unreachable (entity pl)

Variables
bool	autocvar_g_waypoints_for_items

float	bot_attack

entity	bot_basewaypoint

float	bot_custom_weapon

float	bot_dodge

float	bot_dodgerating

float	bot_forced_team

float	bot_moveskill

float	bot_pickup

float	bot_tracewalk_time

bool	bot_waypoints_for_items

float	bot_weapons_close [REGISTRY_MAX(Weapons)]

float	bot_weapons_far [REGISTRY_MAX(Weapons)]

float	bot_weapons_mid [REGISTRY_MAX(Weapons)]

bool	bots_would_leave

string	cleanname

int	currentbots

IntrusiveList	g_bot_dodge

IntrusiveList	g_bot_targets

IntrusiveList	g_waypoints

float	goalentity_lock_timeout

vector	havocbot_middlepoint

float	havocbot_middlepoint_radius

float	havocbot_role_timeout

float	havocbot_symmetry_axis_m

float	havocbot_symmetry_axis_q

float	havocbot_symmetry_origin_order

entity	ignoregoal

float	ignoregoaltime

float	isbot

vector	lastteleport_origin

float	lastteleporttime

bool	navigation_dynamicgoal

float	navigation_hasgoals

entity	nearestwaypoint

float	nearestwaypointtimeout

int	player_count

float	skill

float	speed

const int	WAYPOINTFLAG_CROUCH = BIT(12)

const int	WAYPOINTFLAG_CUSTOM_JP = BIT(13)

const int	WAYPOINTFLAG_DEAD_END = BIT(16)

const int	WAYPOINTFLAG_GENERATED = BIT(23)

const int	WAYPOINTFLAG_ITEM = BIT(22)

const int	WAYPOINTFLAG_JUMP = BIT(14)

const int	WAYPOINTFLAG_LADDER = BIT(15)

const int	WAYPOINTFLAG_NORELINK__DEPRECATED = BIT(20)

const int	WAYPOINTFLAG_PERSONAL = BIT(19)

const int	WAYPOINTFLAG_PROTECTED = BIT(18)

const int	WAYPOINTFLAG_SUPPORT = BIT(11)

const int	WAYPOINTFLAG_TELEPORT = BIT(21)

const int	WAYPOINTFLAG_USEFUL = BIT(17)

entity	wp00

float	wp00mincost

entity	wp01

float	wp01mincost

entity	wp02

float	wp02mincost

entity	wp03

float	wp03mincost

entity	wp04

float	wp04mincost

entity	wp05

float	wp05mincost

entity	wp06

float	wp06mincost

entity	wp07

float	wp07mincost

entity	wp08

float	wp08mincost

entity	wp09

float	wp09mincost

entity	wp10

float	wp10mincost

entity	wp11

float	wp11mincost

entity	wp12

float	wp12mincost

entity	wp13

float	wp13mincost

entity	wp14

float	wp14mincost

entity	wp15

float	wp15mincost

entity	wp16

float	wp16mincost

entity	wp17

float	wp17mincost

entity	wp18

float	wp18mincost

entity	wp19

float	wp19mincost

entity	wp20

float	wp20mincost

entity	wp21

float	wp21mincost

entity	wp22

float	wp22mincost

entity	wp23

float	wp23mincost

entity	wp24

float	wp24mincost

entity	wp25

float	wp25mincost

entity	wp26

float	wp26mincost

entity	wp27

float	wp27mincost

entity	wp28

float	wp28mincost

entity	wp29

float	wp29mincost

entity	wp30

float	wp30mincost

entity	wp31

float	wp31mincost

float	wpconsidered

float	wpcost

const int	WPFLAGMASK_NORELINK = (WAYPOINTFLAG_TELEPORT \| WAYPOINTFLAG_LADDER \| WAYPOINTFLAG_JUMP \| WAYPOINTFLAG_CUSTOM_JP \| WAYPOINTFLAG_SUPPORT)

int	wpflags

entity	wphw00

entity	wphw01

entity	wphw02

entity	wphw03

entity	wphw04

entity	wphw05

entity	wphw06

entity	wphw07

Function Documentation

◆ bot_aim()

bool bot_aim	(	entity	this,
		.entity	weaponentity,
		float	shotspeed,
		float	shotspeedupward,
		float	maxshottime,
		float	applygravity
	)

◆ bot_aim_reset()

void bot_aim_reset ( entity this )

Definition at line 170 of file aim.qc.

Referenced by MUTATOR_HOOKFUNCTION(), ons_Teleport(), PutPlayerInServer(), TeleportPlayer(), and WarpZone_TeleportPlayer().

 {
     this.bot_mouseaim = this.v_angle;
     this.bot_olddesiredang = this.v_angle;
     this.bot_aimdir_executed = true;
     this.bot_badaimtime = 0;
     this.bot_aimthinktime = time;
     this.bot_prevaimtime = time;
     this.bot_1st_order_aimfilter = '0 0 0';
     this.bot_2nd_order_aimfilter = '0 0 0';
     this.bot_3th_order_aimfilter = '0 0 0';
     this.bot_4th_order_aimfilter = '0 0 0';
     this.bot_5th_order_aimfilter = '0 0 0';
     this.bot_firetimer = 0;
 }

Here is the caller graph for this function:

◆ bot_clientconnect()

void bot_clientconnect ( entity this )

Definition at line 426 of file bot.qc.

 {
     if (!IS_BOT_CLIENT(this)) return;
     this.bot_preferredcolors = this.clientcolors;
     this.bot_nextthink = time - random();
     this.lag_func = bot_lagfunc;
     this.isbot = true;
     this.createdtime = this.bot_nextthink;
 
     if(!this.bot_config_loaded) // This is needed so team overrider doesn't break between matches
     {
         bot_setnameandstuff(this);
         bot_setclientfields(this);
     }
 
     if (teamplay && Team_IsValidIndex(this.bot_forced_team))
     {
         SetPlayerTeam(this, this.bot_forced_team, TEAM_CHANGE_MANUAL);
     }
     else
     {
         this.bot_forced_team = 0;
         TeamBalance_JoinBestTeam(this);
     }
 
     havocbot_setupbot(this);
 }

◆ bot_clientdisconnect()

void bot_clientdisconnect ( entity this )

Definition at line 411 of file bot.qc.

 {
     if (!IS_BOT_CLIENT(this))
         return;
     bot_clearqueue(this);
     strfree(this.cleanname);
     strfree(this.netname_freeme);
     strfree(this.playermodel_freeme);
     strfree(this.playerskin_freeme);
     if(this.bot_cmd_current)
         delete(this.bot_cmd_current);
     if(bot_waypoint_queue_owner == this)
         bot_waypoint_queue_owner = NULL;
 }

◆ bot_cmdhelp()

void bot_cmdhelp ( string scmd )

Definition at line 331 of file scripting.qc.

Referenced by GameCommand_bot_cmd().

 {
     int i, ntype;
     string stype;
 
     if(!bot_cmds_initialized)
         bot_commands_init();
 
     for(i=1;i<BOT_CMD_COUNTER;++i)
     {
         if(bot_cmd_string[i]!=scmd)
             continue;
 
         ntype = bot_cmd_parm_type[i];
 
         switch(ntype)
         {
             case BOT_CMD_PARAMETER_FLOAT:
                 stype = "float";
                 break;
             case BOT_CMD_PARAMETER_STRING:
                 stype = "string";
                 break;
             case BOT_CMD_PARAMETER_VECTOR:
                 stype = "vector";
                 break;
             default:
                 stype = "none";
                 break;
         }
 
         string desc = "";
         switch(i)
         {
             case BOT_CMD_PAUSE:
                 desc = "Stops the bot completely. Any command other than 'continue' will be ignored.";
                 break;
             case BOT_CMD_CONTINUE:
                 desc = "Disable paused status";
                 break;
             case BOT_CMD_WAIT:
                 desc = "Pause command parsing and bot ai for N seconds. Pressed key will remain pressed";
                 break;
             case BOT_CMD_WAIT_UNTIL:
                 desc = "Pause command parsing and bot ai until time is N from the last barrier. Pressed key will remain pressed";
                 break;
             case BOT_CMD_BARRIER:
                 desc = "Waits till all bots that have a command queue reach this command. Pressed key will remain pressed";
                 break;
             case BOT_CMD_TURN:
                 desc = "Look to the right or left N degrees. For turning to the left use positive numbers.";
                 break;
             case BOT_CMD_MOVETO:
                 desc = "Walk to an specific coordinate on the map. Usage: moveto \'x y z\'";
                 break;
             case BOT_CMD_MOVETOTARGET:
                 desc = "Walk to the specific target on the map";
                 break;
             case BOT_CMD_RESETGOAL:
                 desc = "Resets the goal stack";
                 break;
             case BOT_CMD_CC:
                 desc = "Execute client command. Examples: cc \"say something\"; cc god; cc \"name newnickname\"; cc kill;";
                 break;
             case BOT_CMD_IF:
                 desc = "Perform simple conditional execution.\n"
                     "Syntax: \n"
                     "        sv_cmd .. if \"condition\"\n"
                     "        sv_cmd ..  <instruction if true>\n"
                     "        sv_cmd ..  <instruction if true>\n"
                     "        sv_cmd .. else\n"
                     "        sv_cmd ..  <instruction if false>\n"
                     "        sv_cmd ..  <instruction if false>\n"
                     "        sv_cmd .. fi\n"
                     "Conditions: a=b, a>b, a<b, a\t\t(spaces not allowed)\n"
                     "            Values in conditions can be numbers, cvars in the form cvar.cvar_string or special fields\n"
                     "Fields: health, speed, flagcarrier\n"
                     "Examples: if health>50; if health>cvar.g_balance_laser_primary_damage; if flagcarrier;";
                 break;
             case BOT_CMD_RESETAIM:
                 desc = "Points the aim to the coordinates x,y 0,0";
                 break;
             case BOT_CMD_AIM:
                 desc = "Move the aim x/y (horizontal/vertical) degrees relatives to the bot\n"
                     "There is a 3rd optional parameter telling in how many seconds the aim has to reach the new position\n"
                     "Examples: aim \"90 0\" // Turn 90 degrees inmediately (positive numbers move to the left/up)\n"
                     "          aim \"0 90 2\"   // Will gradually look to the sky in the next two seconds";
                 break;
             case BOT_CMD_AIMTARGET:
                 desc = "Points the aim to given target";
                 break;
             case BOT_CMD_PRESSKEY:
                 desc = "Press one of the following keys: forward, backward, left, right, jump, crouch, attack1, attack2, use"
                     "Multiple keys can be pressed at time (with many presskey calls) and it will remain pressed until the command \"releasekey\" is called"
                     "Note: The script will not return the control to the bot ai until all keys are released";
                 break;
             case BOT_CMD_RELEASEKEY:
                 desc = "Release previoulsy used keys. Use the parameter \"all\" to release all keys";
                 break;
             case BOT_CMD_SOUND:
                 desc = "play sound file at bot location";
                 break;
             case BOT_CMD_DEBUG_ASSERT_CANFIRE:
                 desc = "verify the state of the weapon entity";
                 break;
             default:
                 desc = "This command has no description yet.";
                 break;
         }
         LOG_HELP("Command: ", bot_cmd_string[i], "\nParameter: <", stype, ">", "\nDescription: ", desc);
     }
 }

Here is the caller graph for this function:

◆ bot_endgame()

void bot_endgame ( )

Definition at line 369 of file bot.qc.

Referenced by Shutdown().

 {
     bot_relinkplayerlist();
     entity e = bot_list;
     while (e)
     {
         setcolor(e, e.bot_preferredcolors);
         e = e.nextbot;
     }
     // if dynamic waypoints are ever implemented, save them here
 }

Here is the caller graph for this function:

◆ bot_fixcount()

bool bot_fixcount ( bool multiple_per_frame )

Definition at line 591 of file bot.qc.

Referenced by GameCommand_bot_cmd(), and GameCommand_setbots().

 {
     int activerealplayers = 0;
     int realplayers = 0;
     if (MUTATOR_CALLHOOK(Bot_FixCount, activerealplayers, realplayers)) {
         activerealplayers = M_ARGV(0, int);
         realplayers = M_ARGV(1, int);
     } else {
         FOREACH_CLIENT(IS_REAL_CLIENT(it), {
             if(IS_PLAYER(it))
                 ++activerealplayers;
             ++realplayers;
         });
     }
 
     int bots;
     // But don't remove bots immediately on level change, as the real players
     // usually haven't rejoined yet
     bots_would_leave = false;
     if (teamplay && autocvar_bot_vs_human && AvailableTeams() == 2)
         bots = min(ceil(fabs(autocvar_bot_vs_human) * activerealplayers), maxclients - realplayers);
     else if ((realplayers || autocvar_bot_join_empty || (currentbots > 0 && time < 5)))
     {
         int minplayers = max(0, floor(autocvar_minplayers));
         if (teamplay)
             minplayers = max(0, floor(autocvar_minplayers_per_team) * AvailableTeams());
         int minbots = max(0, floor(autocvar_bot_number));
 
         // add bots to reach minplayers if needed
         bots = max(minbots, minplayers - activerealplayers);
         // cap bots to the max players allowed by the server
         int player_limit = GetPlayerLimit();
         if(player_limit)
             bots = min(bots, max(player_limit - activerealplayers, 0));
         bots = min(bots, maxclients - realplayers);
 
         if(bots > minbots)
             bots_would_leave = true;
     }
     else
     {
         // if there are no players, remove bots
         bots = 0;
     }
 
     // only add one bot per frame to avoid utter chaos
     if(time > botframe_nextthink)
     {
         while (currentbots < bots)
         {
             if (bot_spawn() == NULL)
             {
                 bprint("Can not add bot, server full.\n");
                 return false;
             }
             if (!multiple_per_frame)
             {
                 break;
             }
         }
         while (currentbots > bots && bots >= 0)
             bot_removenewest();
     }
 
     return true;
 }

Here is the caller graph for this function:

◆ bot_list_commands()

void bot_list_commands ( )

Definition at line 444 of file scripting.qc.

Referenced by GameCommand_bot_cmd().

 {
     int i;
     string ptype;
 
     if(!bot_cmds_initialized)
         bot_commands_init();
 
     LOG_HELP("Bot commands:");
 
     for(i=1;i<BOT_CMD_COUNTER;++i)
     {
         switch(bot_cmd_parm_type[i])
         {
             case BOT_CMD_PARAMETER_FLOAT:
                 ptype = "float";
                 break;
             case BOT_CMD_PARAMETER_STRING:
                 ptype = "string";
                 break;
             case BOT_CMD_PARAMETER_VECTOR:
                 ptype = "vector";
                 break;
             default:
                 ptype = "none";
                 break;
         }
         if (ptype != "none")
             LOG_HELP("  ^2", bot_cmd_string[i]," ^7<", ptype, ">");
         else
             LOG_HELP("  ^2", bot_cmd_string[i]);
     }
     LOG_HELP("For help about a specific command, type bot_cmd help <command>");
 }

Here is the caller graph for this function:

◆ bot_queuecommand()

void bot_queuecommand	(	entity	bot,
		string	cmdstring
	)

Definition at line 30 of file scripting.qc.

Referenced by GameCommand_bot_cmd().

 {
     if(!bot.bot_cmdqueuebuf_allocated)
     {
         bot.bot_cmdqueuebuf = buf_create();
         bot.bot_cmdqueuebuf_allocated = true;
         bot.bot_cmdqueuebuf_start = 0;
         bot.bot_cmdqueuebuf_end = 0;
     }
 
     bufstr_set(bot.bot_cmdqueuebuf, bot.bot_cmdqueuebuf_end, cmdstring);
 
     // if the command was a "sound" command, precache the sound NOW
     // this prevents lagging!
     {
         float sp;
         string parm;
         string cmdstr;
 
         sp = strstrofs(cmdstring, " ", 0);
         if(sp >= 0)
         {
             parm = substring(cmdstring, sp + 1, -1);
             cmdstr = substring(cmdstring, 0, sp);
             if(cmdstr == "sound")
             {
                 // find the LAST word
                 for (;;)
                 {
                     sp = strstrofs(parm, " ", 0);
                     if(sp < 0)
                         break;
                     parm = substring(parm, sp + 1, -1);
                 }
                 precache_sound(parm);
             }
         }
     }
 
     bot.bot_cmdqueuebuf_end += 1;
 }

Here is the caller graph for this function:

◆ bot_relinkplayerlist()

void bot_relinkplayerlist ( )

Definition at line 381 of file bot.qc.

Referenced by bot_cmd_continue(), bot_cmd_pause(), ClientConnect(), ClientDisconnect(), PutClientInServer(), and PutObserverInServer().

 {
     player_count = 0;
     currentbots = 0;
     bot_list = NULL;
 
     entity prevbot = NULL;
     FOREACH_CLIENT(true,
     {
         ++player_count;
 
         if(IS_BOT_CLIENT(it))
         {
             if (!IS_OBSERVER(it) && !bot_ispaused(it))
             {
                 if(prevbot)
                     prevbot.nextbot = it;
                 else
                     bot_list = it;
                 prevbot = it;
             }
             ++currentbots;
         }
     });
     if(prevbot)
         prevbot.nextbot = NULL;
     bot_strategytoken = bot_list;
     bot_strategytoken_taken = true;
 }

Here is the caller graph for this function:

◆ bot_resetqueues()

void bot_resetqueues ( )

Definition at line 1165 of file scripting.qc.

Referenced by GameCommand_bot_cmd().

 {
     FOREACH_CLIENT(it.isbot, {
         it.bot_cmd_execution_index = 0;
         bot_clearqueue(it);
         // also, cancel all barriers
         it.bot_barrier = 0;
         for(int i = 0; i < it.bot_places_count; ++i)
         {
             strfree(it.(bot_placenames[i]));
         }
         it.bot_places_count = 0;
     });
 
     bot_barriertime = time;
 }

Here is the caller graph for this function:

◆ bot_serverframe()

void bot_serverframe ( )

Definition at line 658 of file bot.qc.

Referenced by StartFrame().

 {
     if (intermission_running && currentbots > 0)
     {
         // after the end of the match all bots stay unless all human players disconnect
         int realplayers = 0;
         FOREACH_CLIENT(IS_REAL_CLIENT(it), { ++realplayers; });
         if (!realplayers)
         {
             FOREACH_CLIENT(IS_BOT_CLIENT(it), { dropclient(it); });
             currentbots = 0;
         }
         return;
     }
 
     if (game_stopped)
         return;
 
     // Added 0.5 to avoid possible addition + immediate removal of bots that would make them appear as
     // spectators in the scoreboard and never go away. This issue happens at time 2 if map is changed
     // with the gotomap command, minplayers is > 1 and human clients join as players very soon
     // either intentionally or automatically (sv_spectate 0)
     if (time < 2.5)
     {
         currentbots = -1;
         return;
     }
 
     if (currentbots == -1)
     {
         // count bots already in the server from the previous match
         currentbots = 0;
         FOREACH_CLIENT(IS_BOT_CLIENT(it), { ++currentbots; });
     }
 
     if(autocvar_skill != skill)
     {
         float wpcost_update = false;
         if(skill >= autocvar_bot_ai_bunnyhop_skilloffset && autocvar_skill < autocvar_bot_ai_bunnyhop_skilloffset)
             wpcost_update = true;
         if(skill < autocvar_bot_ai_bunnyhop_skilloffset && autocvar_skill >= autocvar_bot_ai_bunnyhop_skilloffset)
             wpcost_update = true;
 
         skill = autocvar_skill;
         if (wpcost_update)
             waypoint_updatecost_foralllinks();
     }
 
     bot_calculate_stepheightvec();
     bot_navigation_movemode = ((autocvar_bot_navigation_ignoreplayers) ? MOVE_NOMONSTERS : MOVE_NORMAL);
 
     if(time > autoskill_nextthink)
     {
         float a;
         a = autocvar_skill_auto;
         if(a)
             autoskill(a);
         autoskill_nextthink = time + 5;
     }
 
     if(time > botframe_nextthink)
     {
         if(!bot_fixcount(false))
             botframe_nextthink = time + 10;
     }
 
     if(botframe_spawnedwaypoints)
     {
         if(autocvar_waypoint_benchmark)
             localcmd("quit\n");
     }
 
     if (currentbots > 0 || waypointeditor_enabled || autocvar_g_waypointeditor_auto)
     if (botframe_spawnedwaypoints)
     {
         if(botframe_cachedwaypointlinks)
         {
             if(!botframe_loadedforcedlinks)
                 waypoint_load_hardwiredlinks();
         }
         else
         {
             // TODO: Make this check cleaner
             IL_EACH(g_waypoints, time - it.nextthink > 10,
             {
                 waypoint_save_links();
                 break;
             });
         }
     }
     else
     {
         botframe_spawnedwaypoints = true;
         waypoint_loadall();
         waypoint_load_links();
     }
 
     if (bot_list)
     {
         // cycle the goal token from one bot to the next each frame
         // (this prevents them from all doing spawnfunc_waypoint searches on the same
         //  frame, which causes choppy framerates)
         if (bot_strategytoken_taken)
         {
             // give goal token to the first bot without goals; if all bots don't have
             // any goal (or are dead/frozen) simply give it to the next one
             bot_strategytoken_taken = false;
             entity bot_strategytoken_save = bot_strategytoken;
             while (true)
             {
                 if (bot_strategytoken)
                     bot_strategytoken = bot_strategytoken.nextbot;
                 if (!bot_strategytoken)
                     bot_strategytoken = bot_list;
 
                 if (!(IS_DEAD(bot_strategytoken) || STAT(FROZEN, bot_strategytoken))
                     && !bot_strategytoken.goalcurrent)
                     break;
 
                 if (!bot_strategytoken_save) // break loop if all the bots are dead or frozen
                     break;
                 if (bot_strategytoken == bot_strategytoken_save)
                     bot_strategytoken_save = NULL; // looped through all the bots
             }
         }
 
         if (botframe_nextdangertime < time)
         {
             float interval;
             interval = autocvar_bot_ai_dangerdetectioninterval;
             if (botframe_nextdangertime < time - interval * 1.5)
                 botframe_nextdangertime = time;
             botframe_nextdangertime = botframe_nextdangertime + interval;
             botframe_updatedangerousobjects(autocvar_bot_ai_dangerdetectionupdates);
         }
     }
 
     if (waypointeditor_enabled)
         botframe_showwaypointlinks();
 
     if (autocvar_g_waypointeditor_auto)
         botframe_autowaypoints();
 
     if (currentbots > 0)
         bot_custom_weapon_priority_setup();
 }

Here is the caller graph for this function:

◆ bot_shouldattack()

bool bot_shouldattack	(	entity	this,
		entity	e
	)

Definition at line 112 of file aim.qc.

Referenced by havocbot_chooseenemy(), and havocbot_goalrating_enemyplayers().

 {
     if (targ.team == this.team)
     {
         if (targ == this)
             return false;
         if (teamplay)
         if (targ.team != 0)
             return false;
     }
 
     if(STAT(FROZEN, targ))
         return false;
 
     if(teamplay)
     {
         if(targ.team==0)
             return false;
     }
     else if (autocvar_bot_ignore_bots && IS_BOT_CLIENT(targ))
         return false;
 
     if (!targ.takedamage)
         return false;
     if (IS_DEAD(targ))
         return false;
     if (PHYS_INPUT_BUTTON_CHAT(targ) && !autocvar_bot_typefrag)
         return false;
     if(targ.flags & FL_NOTARGET)
         return false;
     if(targ.alpha <= 0.1 && targ.alpha != 0)
         return false; // invisible via alpha
 
     if(MUTATOR_CALLHOOK(BotShouldAttack, this, targ))
         return false;
 
     return true;
 }

Here is the caller graph for this function:

◆ bot_think()

void bot_think ( entity this )

Definition at line 57 of file bot.qc.

Referenced by sys_phys_ai().

 {
     if (this.bot_nextthink > time)
         return;
 
     this.flags &= ~FL_GODMODE;
     if(autocvar_bot_god)
         this.flags |= FL_GODMODE;
 
     this.bot_nextthink = max(time, this.bot_nextthink) + max(0.01, autocvar_bot_ai_thinkinterval * (0.5 ** this.bot_aiskill) * min(14 / (skill + 14), 1));
 
     if (!IS_PLAYER(this) || (autocvar_g_campaign && !campaign_bots_may_start))
     {
         CS(this).movement = '0 0 0';
         this.bot_nextthink = time + 0.5;
         return;
     }
 
     if (this.fixangle)
     {
         this.v_angle = this.angles;
         this.v_angle_z = 0;
         this.fixangle = false;
     }
 
     this.dmg_take = 0;
     this.dmg_save = 0;
     this.dmg_inflictor = NULL;
 
     // calculate an aiming latency based on the skill setting
     // (simulated network latency + naturally delayed reflexes)
     //this.ping = 0.7 - bound(0, 0.05 * skill, 0.5); // moved the reflexes to bot_aimdir (under the name 'think')
     // minimum ping 20+10 random
     CS(this).ping = bound(0,0.07 - bound(0, (skill + this.bot_pingskill) * 0.005,0.05)+random()*0.01,0.65); // Now holds real lag to server, and higer skill players take a less laggy server
     // skill 10 = ping 0.2 (adrenaline)
     // skill 0 = ping 0.7 (slightly drunk)
 
     // clear buttons
     PHYS_INPUT_BUTTON_ATCK(this) = false;
     // keep jump button pressed for a short while, useful with ramp jumps
     PHYS_INPUT_BUTTON_JUMP(this) = (!IS_DEAD(this) && time < this.bot_jump_time + 0.2);
     PHYS_INPUT_BUTTON_ATCK2(this) = false;
     PHYS_INPUT_BUTTON_ZOOM(this) = false;
     PHYS_INPUT_BUTTON_CROUCH(this) = false;
     PHYS_INPUT_BUTTON_HOOK(this) = false;
     PHYS_INPUT_BUTTON_INFO(this) = false;
     PHYS_INPUT_BUTTON_DRAG(this) = false;
     PHYS_INPUT_BUTTON_CHAT(this) = false;
     PHYS_INPUT_BUTTON_USE(this) = false;
 
     if (time < game_starttime)
     {
         // block the bot during the countdown to game start
         CS(this).movement = '0 0 0';
         this.bot_nextthink = game_starttime;
         return;
     }
 
     // if dead, just wait until we can respawn
     if (IS_DEAD(this) || IS_OBSERVER(this))
     {
         if (bot_waypoint_queue_owner == this)
             bot_waypoint_queue_owner = NULL;
         this.aistatus = 0;
         CS(this).movement = '0 0 0';
         if (IS_OBSERVER(this))
             return;
         if (IS_DEAD(this))
         {
             if (!navigation_goalrating_timeout(this))
                 navigation_goalrating_timeout_force(this);
             // jump must not be pressed for at least one frame in order for
             // PlayerThink to detect the key down event
             if (this.deadflag == DEAD_DYING)
                 PHYS_INPUT_BUTTON_JUMP(this) = false;
             else if (this.deadflag == DEAD_DEAD)
                 PHYS_INPUT_BUTTON_JUMP(this) = true; // press jump to respawn
         }
     }
     else if(this.aistatus & AI_STATUS_STUCK)
         navigation_unstuck(this);
 
     // now call the current bot AI (havocbot for example)
     this.bot_ai(this);
 }

Here is the caller graph for this function:

◆ find_bot_by_name()

entity find_bot_by_name ( string name )

Definition at line 235 of file scripting.qc.

Referenced by GameCommand_bot_cmd().

 {
     FOREACH_CLIENT(IS_BOT_CLIENT(it) && it.netname == name,
     {
         return it;
     });
 
     return NULL;
 }

Here is the caller graph for this function:

◆ find_bot_by_number()

entity find_bot_by_number ( float number )

Definition at line 246 of file scripting.qc.

Referenced by GameCommand_bot_cmd().

 {
     entity bot;
     float c = 0;
 
     if(!number)
         return NULL;
 
     bot = findchainflags(flags, FL_CLIENT); // TODO: doesn't findchainflags loop backwards through entities?
     while (bot)
     {
         if(IS_BOT_CLIENT(bot))
         {
             if(++c==number)
                 return bot;
         }
         bot = bot.chain;
     }
 
     return NULL;
 }

Here is the caller graph for this function:

◆ float()

float	(	entity	player,
		entity	item
	)

◆ get_closer_dest()

vector get_closer_dest	(	entity	ent,
		vector	org
	)

Definition at line 103 of file navigation.qc.

References bound(), dest, and vector().

Referenced by havocbot_ai(), havocbot_bunnyhop(), havocbot_moveto(), and havocbot_movetogoal().

 {
     vector dest = '0 0 0';
     if ((ent.classname != "waypoint") || ent.wpisbox)
     {
         vector wm1 = ent.origin + ent.mins;
         vector wm2 = ent.origin + ent.maxs;
         dest.x = bound(wm1.x, org.x, wm2.x);
         dest.y = bound(wm1.y, org.y, wm2.y);
         dest.z = bound(wm1.z, org.z, wm2.z);
     }
     else
         dest = ent.origin;
     return dest;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ havocbot_goalrating_enemyplayers()

void havocbot_goalrating_enemyplayers	(	entity	this,
		float	ratingscale,
		vector	org,
		float	sradius
	)

Definition at line 176 of file roles.qc.

References autocvar_bot_nofire, BOT_RATING_ENEMY, bot_shouldattack(), bound(), FOREACH_CLIENT, GetResource(), IS_PLAYER, max(), navigation_routerating(), RES_HEALTH, skill, time, vdist, vec2, waterlevel, and WATERLEVEL_WETFEET.

Referenced by havocbot_role_generic().

 {
     if (autocvar_bot_nofire)
         return;
 
     // don't chase players if we're under water
     if(this.waterlevel > WATERLEVEL_WETFEET)
         return;
 
     ratingscale = ratingscale * 0.0001;
 
     FOREACH_CLIENT(IS_PLAYER(it) && bot_shouldattack(this, it), {
         // TODO: Merge this logic with the bot_shouldattack function
         if(vdist(it.origin - org, <, 100) || vdist(it.origin - org, >, sradius))
             continue;
         if(vdist(vec2(it.velocity), >, autocvar_sv_maxspeed * 2))
             continue;
 
         // rate only visible enemies
         /*
         traceline(this.origin + this.view_ofs, it.origin, MOVE_NOMONSTERS, this);
         if (trace_fraction < 1 || trace_ent != it)
             continue;
         */
 
         float t = ((GetResource(this, RES_HEALTH) + GetResource(this, RES_ARMOR)) - (GetResource(it, RES_HEALTH) + GetResource(it, RES_ARMOR))) / 150;
         t = bound(0, 1 + t, 3);
         if (skill > 3)
         {
             if (time < StatusEffects_gettime(STATUSEFFECT_Strength, this) - 1) t += 0.5;
             if (time < StatusEffects_gettime(STATUSEFFECT_Strength, it) - 1) t -= 0.5;
             if (time < StatusEffects_gettime(STATUSEFFECT_Shield, this) - 1) t += 0.2;
             if (time < StatusEffects_gettime(STATUSEFFECT_Shield, it) - 1) t -= 0.4;
         }
         t += max(0, 8 - skill) * 0.05; // less skilled bots attack more mindlessly
         ratingscale *= t;
         if (ratingscale > 0)
             navigation_routerating(this, it, ratingscale * BOT_RATING_ENEMY, 2000);
     });
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ havocbot_goalrating_item_pickable_check_players()

bool havocbot_goalrating_item_pickable_check_players	(	entity	this,
		vector	org,
		entity	item,
		vector	item_org
	)

Definition at line 60 of file roles.qc.

References autocvar_bot_ai_friends_aware_pickup_radius, FLOAT_MAX, FOREACH_CLIENT, IS_DEAD, IS_PLAYER, teamplay, and vlen2.

Referenced by havocbot_goalrating_items(), and navigation_goalrating_timeout_can_be_anticipated().

 {
     if(!teamplay)
         return true;
 
     // these variables hold squared distances in order to optimize code
     float friend_dist2 = FLOAT_MAX;
     float enemy_dist2 = FLOAT_MAX;
     float dist2;
 
     FOREACH_CLIENT(IS_PLAYER(it) && it != this && !(IS_DEAD(it) || STAT(FROZEN, it)),
     {
         if (it.team == this.team)
         {
             if (!IS_REAL_CLIENT(it))
                 continue;
 
             dist2 = vlen2(it.origin - item_org);
             if (dist2 > friend_dist2)
                 continue;
 
             if(havocbot_goalrating_item_can_be_left_to_teammate(this, it, item))
             {
                 friend_dist2 = dist2;
                 continue;
             }
         }
         else
         {
             // If enemy only track distances
             // TODO: track only if visible ?
             dist2 = vlen2(it.origin - item_org);
             if (dist2 < enemy_dist2)
                 enemy_dist2 = dist2;
         }
     });
 
     // Rate the item only if no one needs it, or if an enemy is closer to it
     dist2 = vlen2(item_org - org);
     if ((enemy_dist2 < friend_dist2 && dist2 < enemy_dist2)
         || (friend_dist2 > autocvar_bot_ai_friends_aware_pickup_radius ** 2)
         || (dist2 < friend_dist2 && dist2 < 200 ** 2))
         return true;
     return false;
 };

Here is the caller graph for this function:

◆ havocbot_goalrating_items()

void havocbot_goalrating_items	(	entity	this,
		float	ratingscale,
		vector	org,
		float	sradius
	)

Definition at line 106 of file roles.qc.

References g_items, havocbot_goalrating_item_pickable_check_players(), ignoregoal, ignoregoaltime, IL_EACH, IN_LAVA, IS_ONGROUND, Item_IsLoot(), navigation_routerating(), NULL, time, trace_endpos, vdist, and vector().

Referenced by havocbot_role_generic().

 {
     ratingscale = ratingscale * 0.0001;
 
     IL_EACH(g_items, it.bot_pickup,
     {
         // ignore if bot already rated this item with a higher ratingscale
         // NOTE: this code assumes each bot rates items in a different frame
         if(it.bot_ratingscale_time == time && ratingscale < it.bot_ratingscale)
             continue;
 
         if(!it.solid)
         {
             if(!autocvar_bot_ai_timeitems)
                 continue;
             if(!it.scheduledrespawntime)
                 continue;
             if(it.respawntime < max(11, autocvar_bot_ai_timeitems_minrespawndelay))
                 continue;
             if(it.respawntimejitter && !it.itemdef.instanceOfPowerup)
                 continue;
 
             float t = 0;
             if(it.itemdef.instanceOfPowerup)
                 t = bound(0, skill / 10, 1) * 6;
             else if(skill >= 9)
                 t = 4;
 
             if(time < it.scheduledrespawntime - t)
                 continue;
 
             it.bot_pickup_respawning = true;
         }
         vector o = (it.absmin + it.absmax) * 0.5;
         if(vdist(o - org, >, sradius) || (it == this.ignoregoal && time < this.ignoregoaltime) )
             continue;
 
         // Check if the item can be picked up safely
         if(Item_IsLoot(it))
         {
             if(!IS_ONGROUND(it))
                 continue;
             traceline(o, o + '0 0 -1500', true, NULL);
 
             if(IN_LAVA(trace_endpos + '0 0 1'))
                 continue;
 
             // this tracebox_hits_trigger_hurt call isn't needed:
             // dropped weapons are removed as soon as they fall on a trigger_hurt
             // and can't be rated while they are in the air
             //if(tracebox_hits_trigger_hurt(it.origin, it.mins, it.maxs, trace_endpos))
             //  continue;
         }
         else
         {
             if(IN_LAVA(it.origin + (it.mins + it.maxs) * 0.5))
                 continue;
         }
 
         if(!havocbot_goalrating_item_pickable_check_players(this, org, it, o))
             continue;
 
         it.bot_ratingscale_time = time;
         it.bot_ratingscale = ratingscale;
         float rating = it.bot_pickupevalfunc(this, it);
         if(rating > 0)
             navigation_routerating(this, it, rating * ratingscale, 2000);
     });
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ havocbot_goalrating_waypoints()

void havocbot_goalrating_waypoints	(	entity	this,
		float	ratingscale,
		vector	org,
		float	sradius
	)

Definition at line 16 of file roles.qc.

References g_waypoints, IL_EACH, max(), navigation_bestgoal, random(), vdist, and WAYPOINTFLAG_TELEPORT.

Referenced by havocbot_role_dom(), havocbot_role_ft_freeing(), havocbot_role_ft_offense(), havocbot_role_generic(), and havocbot_role_ka_carrier().

 {
     // rate waypoints only if there's no alternative goal
     if(navigation_bestgoal)
         return;
 
     float f;
     float range = 500;
     sradius = max(range, (0.5 + random() * 0.5) * sradius);
     while(sradius > 100)
     {
         IL_EACH(g_waypoints, vdist(it.origin - org, <, sradius)
             && vdist(it.origin - org, >, max(100, sradius - range))
             && !(it.wpflags & WAYPOINTFLAG_TELEPORT),
         {
             if(vdist(it.origin - this.wp_goal_prev0.origin, <, range * 1.5))
                 f = 0.1;
             else if(vdist(it.origin - this.wp_goal_prev1.origin, <, range * 1.5))
                 f = 0.1;
             else
                 f = 0.5 + random() * 0.5;
             navigation_routerating(this, it, ratingscale * f, 2000);
         });
         if(navigation_bestgoal)
             break;
         sradius -= range;
     }
 };

Here is the call graph for this function:

Here is the caller graph for this function:

◆ navigation_dynamicgoal_init()

void navigation_dynamicgoal_init	(	entity	this,
		bool	initially_static
	)

Definition at line 76 of file navigation.qc.

Referenced by ctf_DelayedFlagSetup(), ka_SpawnBall(), kh_Key_Spawn(), PutPlayerInServer(), and W_ThrowNewWeapon().

 {
     this.navigation_dynamicgoal = true;
     this.bot_basewaypoint = this.nearestwaypoint;
     if(initially_static)
         this.nearestwaypointtimeout = -1;
     else
         this.nearestwaypointtimeout = time;
 }

Here is the caller graph for this function:

◆ navigation_dynamicgoal_set()

void navigation_dynamicgoal_set	(	entity	this,
		entity	dropper
	)

Definition at line 86 of file navigation.qc.

Referenced by ctf_Handle_Throw(), ka_DropEvent(), ka_RespawnBall(), and kh_Key_Detach().

 {
     this.nearestwaypointtimeout = time;
     if (dropper && dropper.nearestwaypointtimeout && dropper.nearestwaypointtimeout < time + 2)
         this.nearestwaypoint = dropper.nearestwaypoint;
     if (this.nearestwaypoint)
         this.nearestwaypointtimeout += 2;
 }

Here is the caller graph for this function:

◆ navigation_dynamicgoal_unset()

void navigation_dynamicgoal_unset ( entity this )

Definition at line 95 of file navigation.qc.

Referenced by ctf_RespawnFlag(), ka_TouchEvent(), and kh_Key_Attach().

 {
     if(this.bot_basewaypoint)
         this.nearestwaypoint = this.bot_basewaypoint;
     this.nearestwaypointtimeout = -1;
 }

Here is the caller graph for this function:

◆ navigation_findnearestwaypoint()

entity navigation_findnearestwaypoint	(	entity	ent,
		float	walkfromwp
	)

Definition at line 1011 of file navigation.qc.

Referenced by botframe_autowaypoints_fix_from(), waypoint_remove_fromeditor(), and waypoint_unreachable().

 {
     entity wp = navigation_findnearestwaypoint_withdist_except(ent, walkfromwp, 1050, NULL);
     if (autocvar_g_waypointeditor_auto)
     {
         entity wp2 = navigation_findnearestwaypoint_withdist_except(ent, walkfromwp, 1050, wp);
         if (wp && !wp2)
             wp.wpflags |= WAYPOINTFLAG_PROTECTED;
     }
     return wp;
 }

Here is the caller graph for this function:

◆ navigation_goalrating_end()

void navigation_goalrating_end ( entity this )

Definition at line 1845 of file navigation.qc.

Referenced by havocbot_moveto_refresh_route(), havocbot_role_ast_defense(), havocbot_role_ast_offense(), havocbot_role_ctf_carrier(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), havocbot_role_ctf_retriever(), havocbot_role_cts(), havocbot_role_dom(), havocbot_role_ft_freeing(), havocbot_role_ft_offense(), havocbot_role_generic(), havocbot_role_ka_carrier(), havocbot_role_ka_collector(), havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), havocbot_role_kh_offense(), havocbot_role_ons_offense(), and havocbot_role_race().

 {
     if(this.aistatus & AI_STATUS_STUCK)
         return;
 
     entity wp = this.goalstack31; // save to wp as this.goalstack31 is set by navigation_routetogoal
     this.goalstack31 = NULL;
 
     navigation_routetogoal(this, navigation_bestgoal, this.origin);
     LOG_DEBUG("best goal ", navigation_bestgoal.classname);
 
     if (wp && this.goalcurrent == wp)
         navigation_poproute(this);
 
     // If the bot got stuck then try to reach the farthest waypoint
     if (!this.goalentity)
     {
         if (autocvar_bot_wander_enable && !(this.aistatus & AI_STATUS_STUCK))
         {
             LOG_DEBUG(this.netname, " cannot walk to any goal");
             this.aistatus |= AI_STATUS_STUCK;
         }
         this.goalentity_shouldbefrozen = false;
     }
     else
         this.goalentity_shouldbefrozen = boolean(STAT(FROZEN, this.goalentity));
 }

Here is the caller graph for this function:

◆ navigation_goalrating_start()

void navigation_goalrating_start ( entity this )

Definition at line 1830 of file navigation.qc.

Referenced by havocbot_moveto_refresh_route(), havocbot_role_ast_defense(), havocbot_role_ast_offense(), havocbot_role_ctf_carrier(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), havocbot_role_ctf_retriever(), havocbot_role_cts(), havocbot_role_dom(), havocbot_role_ft_freeing(), havocbot_role_ft_offense(), havocbot_role_generic(), havocbot_role_ka_carrier(), havocbot_role_ka_collector(), havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), havocbot_role_kh_offense(), havocbot_role_ons_offense(), and havocbot_role_race().

 {
     if(this.aistatus & AI_STATUS_STUCK)
         return;
 
     this.navigation_jetpack_goal = NULL;
     navigation_bestrating = -1;
     entity wp = navigation_get_really_close_waypoint(this);
     navigation_clearroute(this);
     navigation_bestgoal = NULL;
     navigation_markroutes(this, wp);
     this.goalstack31 = wp; // temporarly save the really close waypoint
 }

Here is the caller graph for this function:

◆ navigation_goalrating_timeout()

bool navigation_goalrating_timeout ( entity this )

Definition at line 43 of file navigation.qc.

Referenced by bot_think(), havocbot_role_ast_defense(), havocbot_role_ast_offense(), havocbot_role_ctf_carrier(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), havocbot_role_ctf_retriever(), havocbot_role_cts(), havocbot_role_dom(), havocbot_role_ft_freeing(), havocbot_role_ft_offense(), havocbot_role_generic(), havocbot_role_ka_carrier(), havocbot_role_ka_collector(), havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), havocbot_role_kh_offense(), havocbot_role_ons_offense(), and havocbot_role_race().

 {
     return this.bot_strategytime < time;
 }

Here is the caller graph for this function:

◆ navigation_goalrating_timeout_can_be_anticipated()

bool navigation_goalrating_timeout_can_be_anticipated ( entity this )

Definition at line 55 of file navigation.qc.

References autocvar_bot_ai_ignoregoal_timeout, bot_strategytime, goalentity, havocbot_goalrating_item_pickable_check_players(), ignoregoal, ignoregoaltime, IS_MOVABLE, origin, time, vdist, and vector().

Referenced by havocbot_movetogoal().

 {
     vector gco = (this.goalentity.absmin + this.goalentity.absmax) * 0.5;
     if (vdist(gco - this.origin, >, autocvar_sv_maxspeed * 1.5)
         && time > this.bot_strategytime - (IS_MOVABLE(this.goalentity) ? 3 : 2))
     {
         return true;
     }
 
     if (this.goalentity.bot_pickup && time > this.bot_strategytime - 5)
     {
         if(!havocbot_goalrating_item_pickable_check_players(this, this.origin, this.goalentity, gco))
         {
             this.ignoregoal = this.goalentity;
             this.ignoregoaltime = time + autocvar_bot_ai_ignoregoal_timeout;
             return true;
         }
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ navigation_goalrating_timeout_expire()

void navigation_goalrating_timeout_expire	(	entity	this,
		float	seconds
	)

Definition at line 35 of file navigation.qc.

References bot_strategytime, and time.

Referenced by havocbot_movetogoal(), havocbot_role_ctf_escort(), havocbot_role_ctf_setrole(), havocbot_role_ka_carrier(), havocbot_role_ka_collector(), navigation_goalrating_timeout_force(), and navigation_unstuck().

 {
     if (seconds <= 0)
         this.bot_strategytime = 0;
     else if (this.bot_strategytime > time + seconds)
         this.bot_strategytime = time + seconds;
 }

Here is the caller graph for this function:

◆ navigation_goalrating_timeout_extend_if_needed()

void navigation_goalrating_timeout_extend_if_needed	(	entity	this,
		float	seconds
	)

Definition at line 49 of file navigation.qc.

References bot_strategytime, max(), and time.

 {
     this.bot_strategytime = max(this.bot_strategytime, time + seconds);
 }

Here is the call graph for this function:

◆ navigation_goalrating_timeout_force()

void navigation_goalrating_timeout_force ( entity this )

Definition at line 28 of file navigation.qc.

Referenced by bot_think(), havocbot_ai(), havocbot_chooserole(), havocbot_movetogoal(), havocbot_role_ctf_retriever(), and havocbot_role_ctf_setrole().

 {
     navigation_goalrating_timeout_expire(this, 0);
 }

Here is the caller graph for this function:

◆ navigation_goalrating_timeout_set()

void navigation_goalrating_timeout_set ( entity this )

Definition at line 19 of file navigation.qc.

Referenced by havocbot_role_ast_defense(), havocbot_role_ast_offense(), havocbot_role_ctf_carrier(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), havocbot_role_ctf_retriever(), havocbot_role_cts(), havocbot_role_dom(), havocbot_role_ft_freeing(), havocbot_role_ft_offense(), havocbot_role_generic(), havocbot_role_ka_carrier(), havocbot_role_ka_collector(), havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), havocbot_role_kh_offense(), havocbot_role_ons_offense(), and havocbot_role_race().

 {
     if(IS_MOVABLE(this.goalentity))
         this.bot_strategytime = time + autocvar_bot_ai_strategyinterval_movingtarget;
     else
         this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 }

Here is the caller graph for this function:

◆ navigation_markroutes()

void navigation_markroutes	(	entity	this,
		entity	fixed_source_waypoint
	)

Definition at line 1081 of file navigation.qc.

Referenced by waypoint_unreachable().

 {
     float cost, cost2;
     vector p;
 
     IL_EACH(g_waypoints, true,
     {
         it.wpconsidered = false;
         it.wpnearestpoint = '0 0 0';
         it.wpcost = 10000000;
         it.wpfire = 0;
         it.enemy = NULL;
     });
 
     if(fixed_source_waypoint)
     {
         fixed_source_waypoint.wpconsidered = true;
         fixed_source_waypoint.wpnearestpoint = fixed_source_waypoint.origin + 0.5 * (fixed_source_waypoint.mins + fixed_source_waypoint.maxs);
         fixed_source_waypoint.wpcost = fixed_source_waypoint.dmg;
         fixed_source_waypoint.wpfire = 1;
         fixed_source_waypoint.enemy = NULL;
     }
     else
     {
         // try a short range search for the nearest waypoints, and expand the search repeatedly if none are found
         // as this search is expensive we will use lower values if the bot is on the air
         float increment, maxdistance;
         if(IS_ONGROUND(this))
         {
             increment = 750;
             maxdistance = 50000;
         }
         else
         {
             increment = 500;
             maxdistance = 1500;
         }
 
         for(int j = increment; !navigation_markroutes_nearestwaypoints(this, j) && j < maxdistance; j += increment);
     }
 
     bool searching = true;
     while (searching)
     {
         searching = false;
         IL_EACH(g_waypoints, it.wpfire,
         {
             searching = true;
             it.wpfire = 0;
             cost = it.wpcost;
             p = it.wpnearestpoint;
             entity wp;
             wp = it.wp00;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp00mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp01;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp01mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp02;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp02mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp03;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp03mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp04;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp04mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp05;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp05mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp06;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp06mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp07;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp07mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp08;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp08mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp09;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp09mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp10;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp10mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp11;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp11mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp12;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp12mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp13;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp13mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp14;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp14mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp15;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp15mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp16;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp16mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp17;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp17mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp18;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp18mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp19;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp19mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp20;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp20mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp21;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp21mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp22;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp22mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp23;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp23mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp24;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp24mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp25;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp25mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp26;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp26mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp27;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp27mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp28;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp28mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp29;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp29mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp30;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp30mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             wp = it.wp31;if (wp){cost2 = cost + wp.dmg;if (wp.wpcost > cost2 + it.wp31mincost) navigation_markroutes_checkwaypoint(it, wp, cost2, p);
             }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
         });
     }
 }

Here is the caller graph for this function:

◆ navigation_markroutes_inverted()

void navigation_markroutes_inverted ( entity fixed_source_waypoint )

Definition at line 1171 of file navigation.qc.

Referenced by waypoint_unreachable().

 {
     float cost, cost2;
     vector p;
     IL_EACH(g_waypoints, true,
     {
         it.wpconsidered = false;
         it.wpnearestpoint = '0 0 0';
         it.wpcost = 10000000;
         it.wpfire = 0;
         it.enemy = NULL;
     });
 
     if(fixed_source_waypoint)
     {
         fixed_source_waypoint.wpconsidered = true;
         fixed_source_waypoint.wpnearestpoint = fixed_source_waypoint.origin + 0.5 * (fixed_source_waypoint.mins + fixed_source_waypoint.maxs);
         fixed_source_waypoint.wpcost = fixed_source_waypoint.dmg; // the cost to get from X to fixed_source_waypoint
         fixed_source_waypoint.wpfire = 1;
         fixed_source_waypoint.enemy = NULL;
     }
     else
     {
         error("need to start with a waypoint\n");
     }
 
     bool searching = true;
     while (searching)
     {
         searching = false;
         IL_EACH(g_waypoints, it.wpfire,
         {
             searching = true;
             it.wpfire = 0;
             cost = it.wpcost; // cost to walk from it to home
             p = it.wpnearestpoint;
             entity wp = it;
             IL_EACH(g_waypoints, it != wp,
             {
                 if(!waypoint_islinked(it, wp))
                     continue;
                 cost2 = cost + it.dmg;
                 navigation_markroutes_checkwaypoint(wp, it, cost2, p);
             });
         });
     }
 }

Here is the caller graph for this function:

◆ navigation_routerating()

void navigation_routerating	(	entity	this,
		entity	e,
		float	f,
		float	rangebias
	)

Definition at line 1220 of file navigation.qc.

 {
     if (!e || e.blacklisted) { return; }
 
     rangebias = waypoint_getlinearcost(rangebias);
     f = waypoint_getlinearcost(f);
 
     if (IS_PLAYER(e))
     {
         bool rate_wps = false;
         if (e.watertype < CONTENT_WATER || (e.waterlevel > WATERLEVEL_WETFEET && !STAT(FROZEN, e))
             || (e.flags & FL_PARTIALGROUND))
         {
             rate_wps = true;
         }
 
         if(!IS_ONGROUND(e))
         {
             traceline(e.origin, e.origin + '0 0 -1500', true, NULL);
             int t = pointcontents(trace_endpos + '0 0 1');
             if(t != CONTENT_SOLID )
             {
                 if(t == CONTENT_WATER || t == CONTENT_SLIME || t == CONTENT_LAVA)
                     rate_wps = true;
                 else if(tracebox_hits_trigger_hurt(e.origin, e.mins, e.maxs, trace_endpos))
                     return;
             }
         }
 
         if(rate_wps)
         {
             entity theEnemy = e;
             entity best_wp = NULL;
             float best_dist = FLOAT_MAX;
             IL_EACH(g_waypoints, !(it.wpflags & WAYPOINTFLAG_TELEPORT)
                 && vdist(it.origin - theEnemy.origin, <, 500)
                 && vdist(it.origin - this.origin, >, 100)
                 && vdist(it.origin - this.origin, <, 10000),
             {
                 float dist = vlen2(it.origin - theEnemy.origin);
                 if (dist < best_dist)
                 {
                     best_wp = it;
                     best_dist = dist;
                 }
             });
             if (!best_wp)
                 return;
             e = best_wp;
         }
     }
 
     vector goal_org = (e.absmin + e.absmax) * 0.5;
 
     //print("routerating ", etos(e), " = ", ftos(f), " - ", ftos(rangebias), "\n");
 
     // Evaluate path using jetpack
     if(this.items & IT_JETPACK)
     if(autocvar_bot_ai_navigation_jetpack)
     if(vdist(this.origin - goal_org, >, autocvar_bot_ai_navigation_jetpack_mindistance))
     {
         vector pointa, pointb;
 
         LOG_DEBUG("jetpack ai: evaluating path for ", e.classname);
 
         // Point A
         traceline(this.origin, this.origin + '0 0 65535', MOVE_NORMAL, this);
         pointa = trace_endpos - '0 0 1';
 
         // Point B
         traceline(goal_org, goal_org + '0 0 65535', MOVE_NORMAL, e);
         pointb = trace_endpos - '0 0 1';
 
         // Can I see these two points from the sky?
         traceline(pointa, pointb, MOVE_NORMAL, this);
 
         if(trace_fraction==1)
         {
             LOG_DEBUG("jetpack ai: can bridge these two points");
 
             // Lower the altitude of these points as much as possible
             float zdistance, xydistance, cost, t, fuel;
             vector down, npa, npb;
 
             down = '0 0 -1' * (STAT(PL_MAX, this).z - STAT(PL_MIN, this).z) * 10;
 
             do{
                 npa = pointa + down;
                 npb = pointb + down;
 
                 if(npa.z<=this.absmax.z)
                     break;
 
                 if(npb.z<=e.absmax.z)
                     break;
 
                 traceline(npa, npb, MOVE_NORMAL, this);
                 if(trace_fraction==1)
                 {
                     pointa = npa;
                     pointb = npb;
                 }
             }
             while(trace_fraction == 1);
 
 
             // Rough estimation of fuel consumption
             // (ignores acceleration and current xyz velocity)
             xydistance = vlen(pointa - pointb);
             zdistance = fabs(pointa.z - this.origin.z);
 
             t = zdistance / autocvar_g_jetpack_maxspeed_up;
             t += xydistance / autocvar_g_jetpack_maxspeed_side;
             fuel = t * autocvar_g_jetpack_fuel * 0.8;
 
             LOG_DEBUG("jetpack ai: required fuel ", ftos(fuel), ", have ", ftos(GetResource(this, RES_FUEL)));
 
             // enough fuel ?
             if(GetResource(this, RES_FUEL) > fuel || (this.items & IT_UNLIMITED_AMMO))
             {
                 // Estimate cost
                 // (as onground costs calculation is mostly based on distances, here we do the same establishing some relationship
                 //  - between air and ground speeds)
 
                 cost = xydistance / (autocvar_g_jetpack_maxspeed_side/autocvar_sv_maxspeed);
                 cost += zdistance / (autocvar_g_jetpack_maxspeed_up/autocvar_sv_maxspeed);
                 cost *= 1.5;
 
                 // Compare against other goals
                 f = f * rangebias / (rangebias + cost);
 
                 if (navigation_bestrating < f)
                 {
                     LOG_DEBUG("jetpack path: added goal ", e.classname, " (with rating ", ftos(f), ")");
                     navigation_bestrating = f;
                     navigation_bestgoal = e;
                     this.navigation_jetpack_goal = e;
                     this.navigation_jetpack_point = pointb;
                 }
                 return;
             }
         }
     }
 
     entity nwp;
     //te_wizspike(e.origin);
     //bprint(etos(e));
     //bprint("\n");
     // update the cached spawnfunc_waypoint link on a dynamic item entity
     if(e.classname == "waypoint" && !(e.wpflags & WAYPOINTFLAG_PERSONAL))
     {
         nwp = e;
     }
     else
     {
         if(waypointeditor_enabled && e.nearestwaypointtimeout >= 0 && time > e.nearestwaypointtimeout)
             e.nearestwaypoint = NULL;
 
         if ((!e.nearestwaypoint || e.navigation_dynamicgoal)
             && e.nearestwaypointtimeout >= 0 && time > e.nearestwaypointtimeout)
         {
             if(IS_BOT_CLIENT(e) && e.goalcurrent && e.goalcurrent.classname == "waypoint")
                 e.nearestwaypoint = nwp = e.goalcurrent;
             else
                 e.nearestwaypoint = nwp = navigation_findnearestwaypoint(e, true);
             if(!nwp)
             {
                 LOG_DEBUG("FAILED to find a nearest waypoint to '", e.classname, "' #", etos(e));
 
                 if(!e.navigation_dynamicgoal)
                     e.blacklisted = true;
 
                 if(e.blacklisted)
                 {
                     LOG_DEBUG("The entity '", e.classname, "' is going to be excluded from path finding during this match");
                     return;
                 }
             }
 
             if(e.navigation_dynamicgoal)
                 e.nearestwaypointtimeout = time + 2;
             else if(waypointeditor_enabled)
                 e.nearestwaypointtimeout = time + 3 + random() * 2;
         }
         nwp = e.nearestwaypoint;
     }
 
     if (nwp && nwp.wpcost < 10000000)
     {
         //te_wizspike(nwp.wpnearestpoint);
         float nwptoitem_cost = 0;
         if(nwp.wpflags & WAYPOINTFLAG_TELEPORT)
             nwptoitem_cost = nwp.wp00mincost;
         else
             nwptoitem_cost = waypoint_gettravelcost(nwp.wpnearestpoint, goal_org, nwp, e);
         float cost = nwp.wpcost + nwptoitem_cost;
         LOG_DEBUG("checking ^5", e.classname, "^7 with base rating ^xf04", ftos(f), "^7 and rangebias ^xf40", ftos(rangebias));
         f = f * rangebias / (rangebias + cost);
         LOG_DEBUG("         ^5", e.classname, "^7 with cost ^6", ftos(cost), "^7 and final rating ^2", ftos(f));
         if (navigation_bestrating < f)
         {
             LOG_DEBUG(" ground path: ^3added goal ^5", e.classname);
             navigation_bestrating = f;
             navigation_bestgoal = e;
         }
     }
 }

Here is the caller graph for this function:

◆ set_tracewalk_dest()

void set_tracewalk_dest	(	entity	ent,
		vector	org,
		bool	fix_player_dest
	)

Definition at line 119 of file navigation.qc.

References bound(), IS_MONSTER, IS_ONGROUND, IS_PLAYER, MOVE_NORMAL, trace_endpos, trace_startsolid, tracewalk_dest, tracewalk_dest_height, vec2, and vector().

Referenced by havocbot_movetogoal(), navigation_findnearestwaypoint_withdist_except(), navigation_get_really_close_waypoint(), navigation_routetogoal(), navigation_shortenpath(), and navigation_unstuck().

 {
     if ((ent.classname != "waypoint") || ent.wpisbox)
     {
         vector wm1 = ent.origin + ent.mins;
         vector wm2 = ent.origin + ent.maxs;
         if (IS_PLAYER(ent) || IS_MONSTER(ent))
         {
             // move destination point out of player bbox otherwise tracebox always fails
             // (if bot_navigation_ignoreplayers is false)
             wm1 += vec2(PL_MIN_CONST) + '-1 -1 0';
             wm2 += vec2(PL_MAX_CONST) + '1 1 0';
         }
         // set destination point to x and y coords of ent that are closer to org
         // z coord is set to ent's min height
         tracewalk_dest.x = bound(wm1.x, org.x, wm2.x);
         tracewalk_dest.y = bound(wm1.y, org.y, wm2.y);
         if ((IS_PLAYER(ent) || IS_MONSTER(ent))
             && org.x == tracewalk_dest.x && org.y == tracewalk_dest.y && org.z > tracewalk_dest.z)
         {
             tracewalk_dest.z = wm2.z - PL_MIN_CONST.z;
             tracewalk_dest_height = 0;
             fix_player_dest = false;
         }
         else
         {
             tracewalk_dest.z = wm1.z;
             tracewalk_dest_height = wm2.z - wm1.z;
         }
     }
     else
     {
         tracewalk_dest = ent.origin;
         tracewalk_dest_height = 0;
     }
     if (fix_player_dest && IS_PLAYER(ent) && !IS_ONGROUND(ent))
     {
         // snap player to the ground
         if (org.x == tracewalk_dest.x && org.y == tracewalk_dest.y)
         {
             // bot is right under the player
             tracebox(ent.origin, ent.mins, ent.maxs, ent.origin - '0 0 700', MOVE_NORMAL, ent);
             tracewalk_dest = trace_endpos;
             tracewalk_dest_height = 0;
         }
         else
         {
             tracebox(tracewalk_dest, ent.mins, ent.maxs, tracewalk_dest - '0 0 700', MOVE_NORMAL, ent);
             if (!trace_startsolid && tracewalk_dest.z - trace_endpos.z > 0)
             {
                 tracewalk_dest_height = tracewalk_dest.z - trace_endpos.z;
                 tracewalk_dest.z = trace_endpos.z;
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_tracewalk_dest_2()

vector set_tracewalk_dest_2	(	entity	ent,
		vector	org
	)

Definition at line 177 of file navigation.qc.

References bound(), tracewalk_dest, tracewalk_dest_height, and vector().

Referenced by waypoint_think().

 {
     vector closer_dest = '0 0 0';
     if ((ent.classname != "waypoint") || ent.wpisbox)
     {
         vector wm1 = ent.origin + ent.mins;
         vector wm2 = ent.origin + ent.maxs;
         closer_dest.x = bound(wm1.x, org.x, wm2.x);
         closer_dest.y = bound(wm1.y, org.y, wm2.y);
         closer_dest.z = bound(wm1.z, org.z, wm2.z);
         // set destination point to x and y coords of ent that are closer to org
         // z coord is set to ent's min height
         tracewalk_dest.x = closer_dest.x;
         tracewalk_dest.y = closer_dest.y;
         tracewalk_dest.z = wm1.z;
         tracewalk_dest_height = wm2.z - wm1.z; // destination height
     }
     else
     {
         closer_dest = ent.origin;
         tracewalk_dest = closer_dest;
         tracewalk_dest_height = 0;
     }
     return closer_dest;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ STATIC_INIT()

STATIC_INIT ( botapi )

Definition at line 151 of file api.qh.

References IL_NEW.

 {
     g_waypoints = IL_NEW();
     g_bot_targets = IL_NEW();
     g_bot_dodge = IL_NEW();
 }

◆ tracewalk()

bool tracewalk	(	entity	e,
		vector	start,
		vector	m1,
		vector	m2,
		vector	end,
		float	end_height,
		float	movemode
	)

Definition at line 273 of file navigation.qc.

Referenced by GameCommand_trace(), and havocbot_movetogoal().

 {
     if(autocvar_bot_debug_tracewalk)
     {
         debugresetnodes();
         debugnode(e, start);
     }
 
     vector org = start;
     vector flatdir = end - start;
     flatdir.z = 0;
     float flatdist = vlen(flatdir);
     flatdir = normalize(flatdir);
     float stepdist = 32;
     bool ignorehazards = false;
     int nav_action;
 
     // Analyze starting point
     if (IN_LAVA(start))
         ignorehazards = true;
 
     tracebox(start, m1, m2, start, MOVE_NOMONSTERS, e);
     if (trace_startsolid)
     {
         // Bad start
         if(autocvar_bot_debug_tracewalk)
             debugnodestatus(start, DEBUG_NODE_FAIL);
 
         //print("tracewalk: ", vtos(start), " is a bad start\n");
         return false;
     }
 
     vector end2 = end;
     if(end_height)
         end2.z += end_height;
 
     vector fixed_end = end;
     vector move;
 
     if (flatdist > 0 && WETFEET(org))
     {
         if (SUBMERGED(org))
             nav_action = NAV_SWIM_UNDERWATER;
         else
         {
             // tracebox down by player's height
             // useful to know if water level is so low that bot can still walk
             tracebox(org, m1, m2, org - eZ * (m2.z - m1.z), movemode, e);
             if (SUBMERGED(trace_endpos))
             {
                 org = trace_endpos;
                 nav_action = NAV_SWIM_UNDERWATER;
             }
             else
                 nav_action = NAV_WALK;
         }
     }
     else
         nav_action =  NAV_WALK;
 
     // Movement loop
     while (true)
     {
         if (flatdist <= 0)
         {
             bool success = true;
             if (org.z > end2.z + 1)
             {
                 tracebox(org, m1, m2, end2, movemode, e);
                 org = trace_endpos;
                 if (org.z > end2.z + 1)
                     success = false;
             }
             else if (org.z < end.z - 1)
             {
                 tracebox(org, m1, m2, org - jumpheight_vec, movemode, e);
                 if (SUBMERGED(trace_endpos))
                 {
                     vector v = trace_endpos;
                     tracebox(v, m1, m2, end, movemode, e);
                     if(trace_endpos.z >= end.z - 1)
                     {
                         RESURFACE_LIMITED(v, trace_endpos.z);
                         trace_endpos = v;
                     }
                 }
                 else if (trace_endpos.z > org.z - jumpheight_vec.z)
                     tracebox(trace_endpos, m1, m2, trace_endpos + jumpheight_vec, movemode, e);
                 org = trace_endpos;
                 if (org.z < end.z - 1)
                     success = false;
             }
 
             if (success)
             {
                 // Succeeded
                 if(autocvar_bot_debug_tracewalk)
                 {
                     debugnode(e, org);
                     debugnodestatus(org, DEBUG_NODE_SUCCESS);
                 }
 
                 //print("tracewalk: ", vtos(start), " can reach ", vtos(end), "\n");
                 return true;
             }
         }
 
         if(autocvar_bot_debug_tracewalk)
             debugnode(e, org);
 
         if (flatdist <= 0)
             break;
 
         if (stepdist > flatdist)
             stepdist = flatdist;
         if(nav_action == NAV_SWIM_UNDERWATER || (nav_action == NAV_SWIM_ONWATER && org.z > end2.z))
         {
             // can't use movement direction here to calculate move because of
             // precision errors especially when direction has a high enough z value
             //water_dir = normalize(water_end - org);
             //move = org + water_dir * stepdist;
             fixed_end.z = bound(end.z, org.z, end2.z);
             if (stepdist == flatdist) {
                 move = fixed_end;
                 flatdist = 0;
             } else {
                 move = org + (fixed_end - org) * (stepdist / flatdist);
                 flatdist = vlen(vec2(fixed_end - move));
             }
         }
         else // horiz. direction
         {
             flatdist -= stepdist;
             move = org + flatdir * stepdist;
         }
 
         if(nav_action == NAV_SWIM_ONWATER)
         {
             tracebox(org, m1, m2, move, movemode, e); // swim
 
             // hit something
             if (trace_fraction < 1)
             {
                 // stepswim
                 tracebox(org + stepheightvec, m1, m2, move + stepheightvec, movemode, e);
 
                 if (trace_fraction < 1 || trace_startsolid) // can't jump obstacle out of water
                 {
                     org = trace_endpos;
                     if(navigation_checkladders(e, org, m1, m2, end, end2, movemode))
                     {
                         if(autocvar_bot_debug_tracewalk)
                         {
                             debugnode(e, org);
                             debugnodestatus(org, DEBUG_NODE_SUCCESS);
                         }
 
                         //print("tracewalk: ", vtos(start), " can reach ", vtos(end), "\n");
                         return true;
                     }
 
                     if(autocvar_bot_debug_tracewalk)
                         debugnodestatus(org, DEBUG_NODE_FAIL);
 
                     return false;
                     //print("tracewalk: ", vtos(start), " hit something when trying to reach ", vtos(end), "\n");
                 }
 
                 //succesful stepswim
 
                 if (flatdist <= 0)
                 {
                     org = trace_endpos;
                     continue;
                 }
 
                 if (org.z <= move.z) // going horiz.
                 {
                     tracebox(trace_endpos, m1, m2, move, movemode, e);
                     org = trace_endpos;
                     nav_action = NAV_WALK;
                     continue;
                 }
             }
 
             if (org.z <= move.z) // going horiz.
             {
                 org = trace_endpos;
                 nav_action = NAV_SWIM_ONWATER;
             }
             else // going down
             {
                 org = trace_endpos;
                 if (SUBMERGED(org))
                     nav_action = NAV_SWIM_UNDERWATER;
                 else
                     nav_action = NAV_SWIM_ONWATER;
             }
         }
         else if(nav_action == NAV_SWIM_UNDERWATER)
         {
             if (move.z >= org.z) // swimming upwards or horiz.
             {
                 tracebox(org, m1, m2, move, movemode, e); // swim
 
                 bool stepswum = false;
 
                 // hit something
                 if (trace_fraction < 1)
                 {
                     // stepswim
                     vector stepswim_move = move + stepheightvec;
                     if (flatdist > 0 && stepswim_move.z > end2.z + stepheightvec.z) // don't allow stepswim to go higher than destination
                         stepswim_move.z = end2.z;
 
                     tracebox(org + stepheightvec, m1, m2, stepswim_move, movemode, e);
 
                     // hit something
                     if (trace_startsolid)
                     {
                         if(autocvar_bot_debug_tracewalk)
                             debugnodestatus(org, DEBUG_NODE_FAIL);
 
                         //print("tracewalk: ", vtos(start), " hit something when trying to reach ", vtos(end), "\n");
                         return false;
                     }
 
                     if (trace_fraction < 1)
                     {
                         float org_z_prev = org.z;
                         RESURFACE_LIMITED(org, end2.z);
                         if(org.z == org_z_prev)
                         {
                             if(autocvar_bot_debug_tracewalk)
                                 debugnodestatus(org, DEBUG_NODE_FAIL);
 
                             //print("tracewalk: ", vtos(start), " can't reach ", vtos(end), "\n");
                             return false;
                         }
                         if(SUBMERGED(org))
                             nav_action = NAV_SWIM_UNDERWATER;
                         else
                             nav_action = NAV_SWIM_ONWATER;
 
                         // we didn't advance horiz. in this step, flatdist decrease should be reverted
                         // but we can't do it properly right now... apply this workaround instead
                         if (flatdist <= 0)
                             flatdist = 1;
 
                         continue;
                     }
 
                     //succesful stepswim
 
                     if (flatdist <= 0)
                     {
                         org = trace_endpos;
                         continue;
                     }
 
                     stepswum = true;
                 }
 
                 if (!WETFEET(trace_endpos))
                 {
                     tracebox(trace_endpos, m1, m2, trace_endpos - eZ * (stepdist + (m2.z - m1.z)), movemode, e);
                     // if stepswum we'll land on the obstacle, avoid the SUBMERGED check
                     if (!stepswum && SUBMERGED(trace_endpos))
                     {
                         RESURFACE_LIMITED(trace_endpos, end2.z);
                         org = trace_endpos;
                         nav_action = NAV_SWIM_ONWATER;
                         continue;
                     }
 
                     // not submerged
                     org = trace_endpos;
                     nav_action = NAV_WALK;
                     continue;
                 }
 
                 // wetfeet
                 org = trace_endpos;
                 nav_action = NAV_SWIM_UNDERWATER;
                 continue;
             }
             else //if (move.z < org.z) // swimming downwards
             {
                 tracebox(org, m1, m2, move, movemode, e); // swim
 
                 // hit something
                 if (trace_fraction < 1)
                 {
                     // stepswim
                     tracebox(org + stepheightvec, m1, m2, move + stepheightvec, movemode, e);
 
                     // hit something
                     if (trace_fraction < 1 || trace_startsolid) // can't jump obstacle out of water
                     {
                         if(autocvar_bot_debug_tracewalk)
                             debugnodestatus(move, DEBUG_NODE_FAIL);
 
                         //print("tracewalk: ", vtos(start), " hit something when trying to reach ", vtos(end), "\n");
                         return false;
                     }
 
                     //succesful stepswim
 
                     if (flatdist <= 0)
                     {
                         org = trace_endpos;
                         continue;
                     }
 
                     if (trace_endpos.z > org.z && !SUBMERGED(trace_endpos))
                     {
                         // stepswim caused upwards direction
                         tracebox(trace_endpos, m1, m2, trace_endpos - stepheightvec, movemode, e);
                         if (!SUBMERGED(trace_endpos))
                         {
                             org = trace_endpos;
                             nav_action = NAV_WALK;
                             continue;
                         }
                     }
                 }
 
                 org = trace_endpos;
                 nav_action = NAV_SWIM_UNDERWATER;
                 continue;
             }
         }
         else if(nav_action == NAV_WALK)
         {
             // walk
             tracebox(org, m1, m2, move, movemode, e);
 
             if(autocvar_bot_debug_tracewalk)
                 debugnode(e, trace_endpos);
 
             // hit something
             if (trace_fraction < 1)
             {
                 // check if we can walk over this obstacle, possibly by jumpstepping
                 tracebox(org + stepheightvec, m1, m2, move + stepheightvec, movemode, e);
                 if (trace_fraction < 1 || trace_startsolid)
                 {
                     if (trace_startsolid) // hit ceiling above org
                     {
                         // reduce stepwalk height
                         tracebox(org, m1, m2, org + stepheightvec, movemode, e);
                         tracebox(trace_endpos, m1, m2, move + eZ * (trace_endpos.z - move.z), movemode, e);
                     }
                     else //if (trace_fraction < 1)
                     {
                         tracebox(org + jumpstepheightvec, m1, m2, move + jumpstepheightvec, movemode, e);
                         if (trace_startsolid) // hit ceiling above org
                         {
                             // reduce jumpstepwalk height
                             tracebox(org, m1, m2, org + jumpstepheightvec, movemode, e);
                             tracebox(trace_endpos, m1, m2, move + eZ * (trace_endpos.z - move.z), movemode, e);
                         }
                     }
 
                     if (trace_fraction < 1)
                     {
                         vector v = trace_endpos;
                         v.z = org.z + jumpheight_vec.z;
                         if(navigation_checkladders(e, v, m1, m2, end, end2, movemode))
                         {
                             if(autocvar_bot_debug_tracewalk)
                             {
                                 debugnode(e, v);
                                 debugnodestatus(v, DEBUG_NODE_SUCCESS);
                             }
 
                             //print("tracewalk: ", vtos(start), " can reach ", vtos(end), "\n");
                             return true;
                         }
 
                         if(autocvar_bot_debug_tracewalk)
                             debugnodestatus(trace_endpos, DEBUG_NODE_WARNING);
 
                         traceline( org, move, movemode, e);
 
                         if ( trace_ent.classname == "door_rotating" || trace_ent.classname == "door")
                         {
                             vector nextmove;
                             move = trace_endpos;
                             while(trace_ent.classname == "door_rotating" || trace_ent.classname == "door")
                             {
                                 nextmove = move + (flatdir * stepdist);
                                 traceline( move, nextmove, movemode, e);
                                 move = nextmove;
                             }
                             flatdist = vlen(vec2(end - move));
                         }
                         else
                         {
                             if(autocvar_bot_debug_tracewalk)
                                 debugnodestatus(trace_endpos, DEBUG_NODE_FAIL);
 
                             //print("tracewalk: ", vtos(start), " hit something when trying to reach ", vtos(end), "\n");
                             //te_explosion(trace_endpos);
                             //print(ftos(e.dphitcontentsmask), "\n");
                             return false; // failed
                         }
                     }
                     else
                         move = trace_endpos;
                 }
                 else
                     move = trace_endpos;
             }
             else
                 move = trace_endpos;
 
             // trace down from stepheight as far as possible and move there,
             // if this starts in solid we try again without the stepup, and
             // if that also fails we assume it is a wall
             // (this is the same logic as the Quake walkmove function used)
             tracebox(move, m1, m2, move + '0 0 -65536', movemode, e);
 
             org = trace_endpos;
 
             if (!ignorehazards)
             {
                 if (IN_LAVA(org))
                 {
                     if(autocvar_bot_debug_tracewalk)
                     {
                         debugnode(e, trace_endpos);
                         debugnodestatus(org, DEBUG_NODE_FAIL);
                     }
 
                     //print("tracewalk: ", vtos(start), " hits a hazard when trying to reach ", vtos(end), "\n");
                     return false;
                 }
             }
 
             if (flatdist <= 0)
             {
                 if(move.z >= end2.z && org.z < end2.z)
                     org.z = end2.z;
                 continue;
             }
 
             if(org.z > move.z - 1 || !SUBMERGED(org))
             {
                 nav_action = NAV_WALK;
                 continue;
             }
 
             // ended up submerged while walking
             if(autocvar_bot_debug_tracewalk)
                 debugnode(e, org);
 
             RESURFACE_LIMITED(org, move.z);
             nav_action = NAV_SWIM_ONWATER;
             continue;
         }
     }
 
     //print("tracewalk: ", vtos(start), " did not arrive at ", vtos(end), " but at ", vtos(org), "\n");
 
     // moved but didn't arrive at the intended destination
     if(autocvar_bot_debug_tracewalk)
         debugnodestatus(org, DEBUG_NODE_FAIL);
 
     return false;
 }

Here is the caller graph for this function:

◆ void()

void ( entity this )

◆ waypoint_getSymmetricalAxis_cmd()

void waypoint_getSymmetricalAxis_cmd	(	entity	caller,
		bool	save,
		int	arg_idx
	)

Definition at line 137 of file waypoints.qc.

References argv(), cvar_set(), cvar_string(), fabs(), ftos(), sprint(), stov(), strcat(), and vector().

Referenced by ClientCommand_wpeditor().

 {
     vector v1 = stov(argv(arg_idx++));
     vector v2 = stov(argv(arg_idx++));
     vector mid = (v1 + v2) / 2;
 
     float diffy = (v2.y - v1.y);
     float diffx = (v2.x - v1.x);
     if (v1.y == v2.y)
         diffy = 0.000001;
     if (v1.x == v2.x)
         diffx = 0.000001;
     float m = - diffx / diffy;
     float q = - m * mid.x + mid.y;
     if (fabs(m) <= 0.000001) m = 0;
     if (fabs(q) <= 0.000001) q = 0;
 
     string axis_str =  strcat(ftos(m), " ", ftos(q));
     if (save)
         cvar_set("g_waypointeditor_symmetrical_axis", axis_str);
     axis_str = strcat("\"", axis_str, "\"");
     sprint(caller, strcat("Axis of symmetry based on input points: ", axis_str, "\n"));
     if (save)
         sprint(caller, sprintf(" ^3saved to %s\n", "g_waypointeditor_symmetrical_axis"));
     if (save)
     {
         cvar_set("g_waypointeditor_symmetrical", "-2");
         sprint(caller, strcat("g_waypointeditor_symmetrical", " has been set to ",
             cvar_string("g_waypointeditor_symmetrical"), "\n"));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ waypoint_getSymmetricalOrigin_cmd()

void waypoint_getSymmetricalOrigin_cmd	(	entity	caller,
		bool	save,
		int	arg_idx
	)

Definition at line 169 of file waypoints.qc.

References argv(), cvar_set(), cvar_string(), fabs(), ftos(), havocbot_middlepoint, havocbot_middlepoint_radius, sprint(), stov(), strcat(), vec2, and vector().

Referenced by ClientCommand_wpeditor().

 {
     vector org = '0 0 0';
     int ctf_flags = 0;
     for (int i = 0; i < 6; i++)
     {
         if (argv(arg_idx + i) != "")
             ctf_flags++;
     }
     if (ctf_flags < 2)
     {
         ctf_flags = 0;
         org = vec2(havocbot_middlepoint);
         if (argv(arg_idx) != "")
             sprint(caller, "WARNING: Ignoring single input point\n");
         if (havocbot_middlepoint_radius == 0)
         {
             sprint(caller, "Origin of symmetry can't be automatically determined\n");
             return;
         }
     }
     else
     {
         vector v1, v2, v3, v4, v5, v6;
         for (int i = 1; i <= ctf_flags; i++)
         {
             if (i == 1) { v1 = stov(argv(arg_idx++)); org = v1 / ctf_flags; }
             else if (i == 2) { v2 = stov(argv(arg_idx++)); org += v2 / ctf_flags; }
             else if (i == 3) { v3 = stov(argv(arg_idx++)); org += v3 / ctf_flags; }
             else if (i == 4) { v4 = stov(argv(arg_idx++)); org += v4 / ctf_flags; }
             else if (i == 5) { v5 = stov(argv(arg_idx++)); org += v5 / ctf_flags; }
             else if (i == 6) { v6 = stov(argv(arg_idx++)); org += v6 / ctf_flags; }
         }
     }
 
     if (fabs(org.x) <= 0.000001) org.x = 0;
     if (fabs(org.y) <= 0.000001) org.y = 0;
     string org_str = strcat(ftos(org.x), " ", ftos(org.y));
     if (save)
     {
         cvar_set("g_waypointeditor_symmetrical_origin", org_str);
         cvar_set("g_waypointeditor_symmetrical_order", ftos(ctf_flags));
     }
     org_str = strcat("\"", org_str, "\"");
 
     if (ctf_flags < 2)
         sprint(caller, strcat("Origin of symmetry based on flag positions: ", org_str, "\n"));
     else
         sprint(caller, strcat("Origin of symmetry based on input points: ", org_str, "\n"));
     if (save)
         sprint(caller, sprintf(" ^3saved to %s\n", "g_waypointeditor_symmetrical_origin"));
 
     if (ctf_flags < 2)
         sprint(caller, "Order of symmetry: 0 (autodetected)\n");
     else
         sprint(caller, strcat("Order of symmetry: ", ftos(ctf_flags), "\n"));
     if (save)
         sprint(caller, sprintf(" ^3saved to %s\n", "g_waypointeditor_symmetrical_order"));
 
     if (save)
     {
         if (ctf_flags < 2)
             cvar_set("g_waypointeditor_symmetrical", "0");
         else
             cvar_set("g_waypointeditor_symmetrical", "-1");
         sprint(caller, strcat("g_waypointeditor_symmetrical", " has been set to ",
             cvar_string("g_waypointeditor_symmetrical"), "\n"));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ waypoint_lock()

void waypoint_lock ( entity pl )

Definition at line 268 of file waypoints.qc.

References crosshair_trace_waypoints(), and trace_ent.

Referenced by ClientCommand_wpeditor().

 {
     crosshair_trace_waypoints(pl);
     pl.wp_locked = trace_ent;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ waypoint_remove()

void waypoint_remove ( entity wp )

Definition at line 821 of file waypoints.qc.

Referenced by havocbot_moveto().

 {
     IL_EACH(g_waypoints, it != wp,
     {
         if (it.SUPPORT_WP == wp)
         {
             it.SUPPORT_WP = NULL;
             waypoint_schedulerelink(it); // restore incoming links
         }
         if (waypoint_islinked(it, wp))
         {
             if (waypoint_is_hardwiredlink(it, wp))
                 waypoint_unmark_hardwiredlink(it, wp);
             waypoint_removelink(it, wp);
         }
     });
     delete(wp);
 }

Here is the caller graph for this function:

◆ waypoint_remove_fromeditor()

void waypoint_remove_fromeditor ( entity pl )

Definition at line 840 of file waypoints.qc.

Referenced by ClientCommand_wpeditor().

 {
     if (WAYPOINT_VERSION < waypoint_version_loaded)
     {
         LOG_INFOF("^1Editing waypoints with a higher version number (%f) is not allowed.\n"
             "Update Xonotic to make them editable.", waypoint_version_loaded);
         return;
     }
 
     entity e = navigation_findnearestwaypoint(pl, false);
 
     int ctf_flags = havocbot_symmetry_origin_order;
     bool sym = ((autocvar_g_waypointeditor_symmetrical > 0 && ctf_flags >= 2)
                || (autocvar_g_waypointeditor_symmetrical < 0));
     if(autocvar_g_waypointeditor_symmetrical_order >= 2)
         ctf_flags = autocvar_g_waypointeditor_symmetrical_order;
     if (sym && ctf_flags < 2)
         ctf_flags = 2;
     int wp_num = ctf_flags;
 
     LABEL(remove_wp);
     if (!e) return;
 
     if (e.wpflags & WAYPOINTFLAG_GENERATED)
     {
         if (start_wp_is_spawned)
             waypoint_clear_start_wp_globals(pl, true);
         return;
     }
 
     if (waypoint_has_hardwiredlinks(e))
     {
         LOG_INFO("Can't remove a waypoint with hardwired links, remove links with \"wpeditor hardwire\" first\n");
         return;
     }
 
     entity wp_sym = NULL;
     if (sym)
     {
         vector org = waypoint_getSymmetricalPoint(e.origin, ctf_flags);
         FOREACH_ENTITY_CLASS("waypoint", !(it.wpflags & WAYPOINTFLAG_GENERATED), {
             if(vdist(org - it.origin, <, 3))
             {
                 wp_sym = it;
                 break;
             }
         });
     }
 
     bprint(strcat("Waypoint removed at ", vtos(e.origin), "\n"));
     te_explosion(e.origin);
     waypoint_remove(e);
 
     if (sym && wp_sym)
     {
         e = wp_sym;
         if(wp_num > 2)
             wp_num--;
         else
             sym = false;
         goto remove_wp;
     }
 
     if (start_wp_is_spawned)
         waypoint_clear_start_wp_globals(pl, true);
 }

Here is the caller graph for this function:

◆ waypoint_saveall()

void waypoint_saveall ( )

Definition at line 1760 of file waypoints.qc.

Referenced by ClientCommand_wpeditor().

 {
     if (WAYPOINT_VERSION < waypoint_version_loaded)
     {
         LOG_INFOF("^1Overwriting waypoints with a higher version number (%f) is not allowed.\n"
             "Update Xonotic to make them editable.", waypoint_version_loaded);
         return;
     }
     string gt_ext = GET_GAMETYPE_EXTENSION();
 
     string filename = sprintf("maps/%s.waypoints", strcat(mapname, gt_ext));
     int file = fopen(filename, FILE_WRITE);
     if (file < 0)
     {
         waypoint_save_links(); // save anyway?
         botframe_loadedforcedlinks = false;
 
         LOG_INFOF("waypoint links: save to %s failed", filename);
         return;
     }
 
     float sym = autocvar_g_waypointeditor_symmetrical;
     string sym_str = ftos(sym);
     if (sym == -1 || (sym == 1 && autocvar_g_waypointeditor_symmetrical_order >= 2))
     {
         if (sym == 1)
         {
             sym_str = cons(sym_str, "-");
             sym_str = cons(sym_str, "-");
         }
         else
         {
             sym_str = cons(sym_str, ftos(autocvar_g_waypointeditor_symmetrical_origin.x));
             sym_str = cons(sym_str, ftos(autocvar_g_waypointeditor_symmetrical_origin.y));
         }
         if (autocvar_g_waypointeditor_symmetrical_order >= 2)
             sym_str = cons(sym_str, ftos(autocvar_g_waypointeditor_symmetrical_order));
     }
     else if (autocvar_g_waypointeditor_symmetrical == -2)
     {
         sym_str = cons(sym_str, ftos(autocvar_g_waypointeditor_symmetrical_axis.x));
         sym_str = cons(sym_str, ftos(autocvar_g_waypointeditor_symmetrical_axis.y));
     }
 
     // a group of 3 comments doesn't break compatibility with older Xonotic versions
     // (they are read as a waypoint with origin '0 0 0' and flag 0 though)
     fputs(file, strcat("//", "WAYPOINT_VERSION ", ftos_decimals(WAYPOINT_VERSION, 2), "\n"));
     fputs(file, strcat("//", "WAYPOINT_SYMMETRY ", sym_str, "\n"));
 
     strcpy(waypoint_time, strftime(true, "%Y-%m-%d %H:%M:%S"));
     fputs(file, strcat("//", "WAYPOINT_TIME ", waypoint_time, "\n"));
     //fputs(file, strcat("//", "\n"));
     //fputs(file, strcat("//", "\n"));
     //fputs(file, strcat("//", "\n"));
 
     int c = 0;
     IL_EACH(g_waypoints, true,
     {
         if(it.wpflags & WAYPOINTFLAG_GENERATED)
             continue;
 
         string s;
         // NOTE: vtos rounds vector components to 1 decimal place
         s = strcat(vtos(it.origin + it.mins), "\n");
         s = strcat(s, vtos(it.origin + it.maxs));
         s = strcat(s, "\n");
         s = strcat(s, ftos(it.wpflags));
         s = strcat(s, "\n");
         fputs(file, s);
         c++;
     });
     fclose(file);
     waypoint_save_links();
     waypoint_save_hardwiredlinks();
 
     botframe_loadedforcedlinks = false;
 
     waypoint_version_loaded = WAYPOINT_VERSION;
     LOG_INFOF("saved %d waypoints to %s", c, filename);
 }

Here is the caller graph for this function:

◆ waypoint_schedulerelink()

void waypoint_schedulerelink ( entity wp )

Definition at line 1275 of file waypoints.qc.

 {
     if (wp == NULL)
         return;
 
     waypoint_setupmodel(wp);
     wp.wpisbox = vdist(wp.size, >, 0);
     wp.enemy = NULL;
     if (!(wp.wpflags & WAYPOINTFLAG_PERSONAL))
         wp.owner = NULL;
     if (!(wp.wpflags & WPFLAGMASK_NORELINK))
         waypoint_clearlinks(wp);
     // schedule an actual relink on next frame
     setthink(wp, waypoint_think);
     wp.nextthink = time;
     wp.effects = EF_LOWPRECISION;
 }

◆ waypoint_schedulerelinkall()

void waypoint_schedulerelinkall ( )

Definition at line 1309 of file waypoints.qc.

Referenced by ClientCommand_wpeditor().

 {
     relink_total = relink_walkculled = relink_pvsculled = relink_lengthculled = 0;
     IL_EACH(g_waypoints, true,
     {
         waypoint_schedulerelink(it);
     });
     waypoint_load_hardwiredlinks();
 }

Here is the caller graph for this function:

◆ waypoint_spawn()

entity waypoint_spawn	(	vector	m1,
		vector	m2,
		float	f
	)

Definition at line 431 of file waypoints.qc.

 {
     if(!(f & (WAYPOINTFLAG_PERSONAL | WAYPOINTFLAG_GENERATED)) && m1 == m2)
     {
         entity wp_found = waypoint_get(m1, m2);
         if (wp_found)
             return wp_found;
     }
     // spawn only one destination waypoint for teleports teleporting player to the exact same spot
     // otherwise links loaded from file would be applied only to the first destination
     // waypoint since link format doesn't specify waypoint entities but just positions
     if((f & WAYPOINTFLAG_GENERATED) && !(f & (WPFLAGMASK_NORELINK | WAYPOINTFLAG_PERSONAL)) && m1 == m2)
     {
         IL_EACH(g_waypoints, boxesoverlap(m1, m2, it.absmin, it.absmax),
         {
             return it;
         });
     }
 
     entity w = new(waypoint);
     IL_PUSH(g_waypoints, w);
     w.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
     w.wpflags = f;
     w.solid = SOLID_TRIGGER;
     w.createdtime = time;
     w.origin = (m1 + m2) * 0.5;
     if (waypointeditor_enabled)
         setorigin(w, w.origin);
     else // don't link into the world, only bots are aware of waypoints
         make_pure(w);
     setsize(w, m1 - w.origin, m2 - w.origin);
     if (w.size)
         w.wpisbox = true;
 
     if(!w.wpisbox)
     {
         if (f & WAYPOINTFLAG_CROUCH)
             setsize(w, PL_CROUCH_MIN_CONST - '1 1 0', PL_CROUCH_MAX_CONST + '1 1 0');
         else
             setsize(w, PL_MIN_CONST - '1 1 0', PL_MAX_CONST + '1 1 0');
         if(!move_out_of_solid(w))
         {
             if(!(f & WAYPOINTFLAG_GENERATED))
             {
                 LOG_TRACE("Killed a waypoint that was stuck in solid at ", vtos(w.origin));
                 delete(w);
                 return NULL;
             }
             else
             {
                 if(autocvar_developer > 0)
                 {
                     LOG_INFO("A generated waypoint is stuck in solid at ", vtos(w.origin));
                     backtrace("Waypoint stuck");
                 }
             }
         }
         setsize(w, '0 0 0', '0 0 0');
     }
 
     waypoint_clearlinks(w);
     //waypoint_schedulerelink(w);
 
     waypoint_setupmodel(w);
 
     return w;
 }

◆ waypoint_spawn_fromeditor()

void waypoint_spawn_fromeditor	(	entity	pl,
		bool	at_crosshair,
		bool	is_jump_wp,
		bool	is_crouch_wp,
		bool	is_support_wp
	)

Definition at line 570 of file waypoints.qc.

Referenced by ClientCommand_wpeditor().

 {
     if (WAYPOINT_VERSION < waypoint_version_loaded)
     {
         LOG_INFOF("^1Editing waypoints with a higher version number (%f) is not allowed.\n"
             "Update Xonotic to make them editable.", waypoint_version_loaded);
         return;
     }
 
     entity e = NULL, jp = NULL;
     vector org = pl.origin;
     if (at_crosshair)
     {
         crosshair_trace_waypoints(pl);
         org = trace_endpos;
         if (!trace_ent)
             org.z -= PL_MIN_CONST.z;
         if (!(start_wp_is_hardwired || start_wp_is_support))
             IL_EACH(g_jumppads, boxesoverlap(org + PL_MIN_CONST, org + PL_MAX_CONST, it.absmin, it.absmax),
             {
                 jp = it;
                 break;
             });
         if (!jp && !start_wp_is_spawned && trace_ent)
         {
             if (trace_ent.wpflags & (WAYPOINTFLAG_JUMP))
                 is_jump_wp = true;
             else if (trace_ent.wpflags & (WAYPOINTFLAG_SUPPORT))
                 is_support_wp = true;
         }
     }
     if (jp || is_jump_wp || is_support_wp)
     {
         if (start_wp_is_spawned)
             start_wp_is_spawned = false;
         LOG_INFO("^xf80Spawning start waypoint...\n");
     }
     int ctf_flags = havocbot_symmetry_origin_order;
     bool sym = ((autocvar_g_waypointeditor_symmetrical > 0 && ctf_flags >= 2)
                || (autocvar_g_waypointeditor_symmetrical < 0));
     if(autocvar_g_waypointeditor_symmetrical_order >= 2)
         ctf_flags = autocvar_g_waypointeditor_symmetrical_order;
     if (sym && ctf_flags < 2)
         ctf_flags = 2;
     int wp_num = ctf_flags;
 
     if(!PHYS_INPUT_BUTTON_CROUCH(pl) && !at_crosshair && !is_jump_wp && !is_support_wp)
     {
         // snap waypoint to item's origin if close enough
         IL_EACH(g_items, true,
         {
             vector item_org = (it.absmin + it.absmax) * 0.5;
             item_org.z = it.absmin.z - PL_MIN_CONST.z;
             if (vlen(item_org - org) < 20)
             {
                 org = item_org;
                 break;
             }
         });
     }
 
     vector start_org = '0 0 0';
     if (start_wp_is_spawned)
     {
         if (!start_wp_is_hardwired)
             LOG_INFO("^xf80Spawning destination waypoint...\n");
         start_org = start_wp_origin;
     }
 
     // save org as it can be modified spawning symmetrycal waypoints
     vector initial_origin = '0 0 0';
     bool initial_origin_is_set = false;
 
     LABEL(add_wp);
 
     if (jp)
     {
         e = NULL;
         IL_EACH(g_waypoints, (it.wpflags & WPFLAGMASK_NORELINK)
             && boxesoverlap(org + PL_MIN_CONST, org + PL_MAX_CONST, it.absmin, it.absmax),
         {
             e = it; break;
         });
         if (!e)
             e = waypoint_spawn(jp.absmin - PL_MAX_CONST + '1 1 1', jp.absmax - PL_MIN_CONST + '-1 -1 -1', WAYPOINTFLAG_TELEPORT);
         if (!pl.wp_locked)
             pl.wp_locked = e;
     }
     else if (is_jump_wp || is_support_wp)
     {
         int type_flag = (is_jump_wp) ? WAYPOINTFLAG_JUMP : WAYPOINTFLAG_SUPPORT;
 
         entity wp_found = waypoint_get(org, org);
         if (wp_found && !(wp_found.wpflags & type_flag))
         {
             LOG_INFOF("Error: can't spawn a %s waypoint over an existent waypoint of a different type\n", (is_jump_wp) ? "Jump" : "Support");
             return;
         }
         e = waypoint_spawn(org, org, type_flag);
         if (!pl.wp_locked)
             pl.wp_locked = e;
     }
     else
         e = waypoint_spawn(org, org, (is_crouch_wp) ? WAYPOINTFLAG_CROUCH : 0);
     if(!e)
     {
         LOG_INFOF("Couldn't spawn waypoint at %v\n", org);
         if (start_wp_is_spawned)
             waypoint_clear_start_wp_globals(pl, true);
         return;
     }
 
     if (!initial_origin_is_set)
     {
         initial_origin = e.origin;
         initial_origin_is_set = true;
     }
 
     entity start_wp = NULL;
     if (start_wp_is_spawned)
     {
         IL_EACH(g_waypoints, (start_wp_is_hardwired || (it.wpflags & WPFLAGMASK_NORELINK))
             && boxesoverlap(start_org, start_org, it.absmin, it.absmax),
         {
             start_wp = it; break;
         });
         if(!start_wp)
         {
             // should not happen
             LOG_INFOF("Couldn't find start waypoint at %v\n", start_org);
             waypoint_clear_start_wp_globals(pl, true);
             return;
         }
         if (start_wp_is_hardwired)
         {
             if (waypoint_is_hardwiredlink(start_wp, e))
             {
                 waypoint_unmark_hardwiredlink(start_wp, e);
                 waypoint_removelink(start_wp, e);
                 string s = strcat(vtos(start_wp.origin), "*", vtos(e.origin));
                 LOG_INFOF("^x80fRemoved hardwired link %s.\n", s);
             }
             else
             {
                 if (e.createdtime == time)
                 {
                     LOG_INFO("Error: hardwired links can be created only between 2 existing (and unconnected) waypoints.\n");
                     waypoint_remove(e);
                     waypoint_clear_start_wp_globals(pl, true);
                     waypoint_spawn_fromeditor(pl, at_crosshair, is_jump_wp, is_crouch_wp, is_support_wp);
                     return;
                 }
                 if (start_wp == e)
                 {
                     LOG_INFO("Error: start and destination waypoints coincide.\n");
                     waypoint_clear_start_wp_globals(pl, true);
                     return;
                 }
                 if (waypoint_islinked(start_wp, e))
                 {
                     LOG_INFO("Error: waypoints are already linked.\n");
                     waypoint_clear_start_wp_globals(pl, true);
                     return;
                 }
                 waypoint_addlink(start_wp, e);
                 waypoint_mark_hardwiredlink(start_wp, e);
                 string s = strcat(vtos(start_wp.origin), "*", vtos(e.origin));
                 LOG_INFOF("^x80fAdded hardwired link %s.\n", s);
             }
         }
         else
         {
             if (start_wp_is_support)
             {
                 if (e.SUPPORT_WP)
                 {
                     LOG_INFOF("Waypoint %v has already a support waypoint, delete it first.\n", e.origin);
                     waypoint_clear_start_wp_globals(pl, true);
                     return;
                 }
                 // clear all links to e
                 IL_EACH(g_waypoints, it != e,
                 {
                     if (waypoint_islinked(it, e) && !waypoint_is_hardwiredlink(it, e))
                         waypoint_removelink(it, e);
                 });
             }
             waypoint_addlink(start_wp, e);
         }
     }
 
     if (!(jp || is_jump_wp || is_support_wp || start_wp_is_hardwired))
         waypoint_schedulerelink(e);
 
     string wp_type_str = waypoint_get_type_name(e);
 
     bprint(strcat(wp_type_str, "^7 spawned at ", vtos(e.origin), "\n"));
 
     if (start_wp_is_spawned)
     {
         pl.wp_locked = NULL;
         if (!start_wp_is_hardwired)
             waypoint_schedulerelink(start_wp);
         if (start_wp.wpflags & WAYPOINTFLAG_TELEPORT)
         {
             if (start_wp.wp00_original == start_wp.wp00)
                 start_wp.wpflags &= ~WAYPOINTFLAG_CUSTOM_JP;
             else
                 start_wp.wpflags |= WAYPOINTFLAG_CUSTOM_JP;
         }
     }
 
     if (sym)
     {
         org = waypoint_getSymmetricalPoint(org, ctf_flags);
         if (jp)
         {
             IL_EACH(g_jumppads, boxesoverlap(org + PL_MIN_CONST, org + PL_MAX_CONST, it.absmin, it.absmax),
             {
                 jp = it; break;
             });
         }
         if (start_wp_is_spawned)
             start_org = waypoint_getSymmetricalPoint(start_org, ctf_flags);
         if (vdist(org - pl.origin, >, 32))
         {
             if(wp_num > 2)
                 wp_num--;
             else
                 sym = false;
             goto add_wp;
         }
     }
     if (jp || is_jump_wp || is_support_wp)
     {
         if (!start_wp_is_spawned)
         {
             // we've just created a custom jumppad waypoint
             // the next one created by the user will be the destination waypoint
             start_wp_is_spawned = true;
             start_wp_origin = initial_origin;
             if (is_support_wp)
                 start_wp_is_support = true;
         }
     }
     else if (start_wp_is_spawned)
     {
         waypoint_clear_start_wp_globals(pl, false);
     }
 }

Here is the caller graph for this function:

◆ waypoint_spawnforitem()

void waypoint_spawnforitem ( entity e )

Definition at line 2007 of file waypoints.qc.

Referenced by _StartItem(), and dom_controlpoint_setup().

 {
     if(!bot_waypoints_for_items)
         return;
 
     waypoint_spawnforitem_force(e, e.origin);
 }

Here is the caller graph for this function:

◆ waypoint_spawnforitem_force()

void waypoint_spawnforitem_force	(	entity	e,
		vector	org
	)

Definition at line 1978 of file waypoints.qc.

Referenced by ctf_DelayedFlagSetup(), ons_DelayedGeneratorSetup(), spawnfunc(), and target_checkpoint_setup().

 {
     // Fix the waypoint altitude if necessary
     org = waypoint_fixorigin(org, NULL);
 
     // don't spawn an item spawnfunc_waypoint if it already exists
     IL_EACH(g_waypoints, true,
     {
         if(it.wpisbox)
         {
             if(boxesoverlap(org, org, it.absmin, it.absmax))
             {
                 e.nearestwaypoint = it;
                 return;
             }
         }
         else
         {
             if(vdist(it.origin - org, <, 16))
             {
                 e.nearestwaypoint = it;
                 return;
             }
         }
     });
 
     e.nearestwaypoint = waypoint_spawn(org, org, WAYPOINTFLAG_GENERATED | WAYPOINTFLAG_ITEM);
 }

Here is the caller graph for this function:

◆ waypoint_spawnforteleporter()

void waypoint_spawnforteleporter	(	entity	e,
		vector	destination,
		float	timetaken,
		entity	tracetest_ent
	)

Definition at line 2069 of file waypoints.qc.

Referenced by teleport_findtarget(), and trigger_push_test().

 {
     destination = waypoint_fixorigin(destination, tracetest_ent);
     waypoint_spawnforteleporter_boxes(e, WAYPOINTFLAG_TELEPORT, e.absmin - PL_MAX_CONST + '1 1 1', e.absmax - PL_MIN_CONST + '-1 -1 -1', destination, destination, timetaken);
 }

Here is the caller graph for this function:

◆ waypoint_spawnforteleporter_wz()

void waypoint_spawnforteleporter_wz	(	entity	e,
		entity	tracetest_ent
	)

Definition at line 2031 of file waypoints.qc.

Referenced by WarpZone_PostInitialize_Callback().

 {
     float src_angle = e.warpzone_angles.x;
     while (src_angle < -180) src_angle += 360;
     while (src_angle > 180) src_angle -= 360;
 
     float dest_angle = e.enemy.warpzone_angles.x;
     while (dest_angle < -180) dest_angle += 360;
     while (dest_angle > 180) dest_angle -= 360;
 
     // no waypoints for warpzones pointing upwards, they can't be used by the bots
     if (src_angle == -90 || dest_angle == -90)
         return;
 
     makevectors(e.warpzone_angles);
     vector src = (e.absmin + e.absmax) * 0.5;
     src += ((e.warpzone_origin - src) * v_forward) * v_forward + 16 * v_right;
     vector down_dir_src = -v_up;
 
     makevectors(e.enemy.warpzone_angles);
     vector dest = (e.enemy.absmin + e.enemy.absmax) * 0.5;
     dest += ((e.enemy.warpzone_origin - dest) * v_forward) * v_forward - 16 * v_right;
     vector down_dir_dest = -v_up;
 
     int extra_flag = 0;
     // don't snap to the ground waypoints for source warpzones pointing downwards
     if (src_angle != 90)
     {
         src = waypoint_fixorigin_down_dir(src, tracetest_ent, down_dir_src);
         dest = waypoint_fixorigin_down_dir(dest, tracetest_ent, down_dir_dest);
         // oblique warpzones need a jump otherwise bots gets stuck
         if (src_angle != 0)
             extra_flag = WAYPOINTFLAG_JUMP;
     }
 
     waypoint_spawnforteleporter_boxes(e, WAYPOINTFLAG_TELEPORT | extra_flag, src, src, dest, dest, 0);
 }

Here is the caller graph for this function:

◆ waypoint_start_hardwiredlink()

void waypoint_start_hardwiredlink	(	entity	pl,
		bool	at_crosshair
	)

Definition at line 534 of file waypoints.qc.

References crosshair_trace_waypoints(), entity(), err, LOG_INFO, LOG_INFOF, start_wp_is_hardwired, start_wp_is_spawned, start_wp_origin, trace_ent, vtos(), and WPFLAGMASK_NORELINK.

Referenced by ClientCommand_wpeditor().

 {
     entity wp = pl.nearestwaypoint;
     if (at_crosshair)
     {
         crosshair_trace_waypoints(pl);
         wp = trace_ent;
     }
     string err = "";
     if (start_wp_is_spawned && !start_wp_is_hardwired)
         err = "can't hardwire while in the process of creating a special link";
     else if (!wp)
     {
         if (at_crosshair)
             err = "couldn't find any waypoint at crosshair";
         else
             err = "couldn't find any waypoint nearby";
     }
     else if (wp.wpflags & WPFLAGMASK_NORELINK)
         err = "can't hardwire a waypoint with special links";
 
     if (err == "")
     {
         start_wp_is_hardwired = true;
         start_wp_is_spawned = true;
         start_wp_origin = wp.origin;
         pl.wp_locked = wp;
         LOG_INFOF("^x80fWaypoint %s marked as hardwired link origin.\n", vtos(wp.origin));
     }
     else
     {
         start_wp_is_hardwired = false;
         LOG_INFO("Error: ", err, "\n");
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ waypoint_unreachable()

void waypoint_unreachable ( entity pl )

Definition at line 28 of file waypoints.qc.

Referenced by ClientCommand_wpeditor().

 {
     IL_EACH(g_waypoints, true,
     {
         it.colormod = '0.5 0.5 0.5';
         it.effects &= ~(EF_NODEPTHTEST | EF_RED | EF_BLUE);
     });
 
     entity e2 = navigation_findnearestwaypoint(pl, false);
     if(!e2)
     {
         LOG_INFO("Can't find any waypoint nearby\n");
         return;
     }
 
     navigation_markroutes(pl, e2);
 
     int j = 0;
     int m = 0;
     IL_EACH(g_waypoints, it.wpcost >= 10000000,
     {
         LOG_INFO("unreachable: ", etos(it), " ", vtos(it.origin), "\n");
         it.colormod_z = 8;
         it.effects |= EF_NODEPTHTEST | EF_BLUE;
         j++;
         m++;
     });
     if (j) LOG_INFOF("%d waypoints cannot be reached from here in any way (marked with blue light)\n", j);
     navigation_markroutes_inverted(e2);
 
     j = 0;
     IL_EACH(g_waypoints, it.wpcost >= 10000000,
     {
         LOG_INFO("cannot reach me: ", etos(it), " ", vtos(it.origin), "\n");
         it.colormod_x = 8;
         if (!(it.effects & EF_NODEPTHTEST))  // not already reported before
             m++;
         it.effects |= EF_NODEPTHTEST | EF_RED;
         j++;
     });
     if (j) LOG_INFOF("%d waypoints cannot walk to here in any way (marked with red light)\n", j);
     if (m) LOG_INFOF("%d waypoints have been marked total\n", m);
 
     j = 0;
     IL_EACH(g_spawnpoints, true,
     {
         if (navigation_findnearestwaypoint(it, false))
         {
             if(it.spawnpointmodel)
             {
                 delete(it.spawnpointmodel);
                 it.spawnpointmodel = NULL;
             }
         }
         else
         {
             if(!it.spawnpointmodel)
             {
                 tracebox(it.origin, PL_MIN_CONST, PL_MAX_CONST, it.origin - '0 0 512', MOVE_NOMONSTERS, NULL);
                 entity e = new(spawnpointmodel);
                 vector org = trace_endpos + eZ;
                 setorigin(e, org);
                 e.solid = SOLID_TRIGGER;
                 it.spawnpointmodel = e;
             }
             LOG_INFO("spawn without waypoint: ", etos(it), " ", vtos(it.origin), "\n");
             it.spawnpointmodel.effects |= EF_NODEPTHTEST;
             _setmodel(it.spawnpointmodel, pl.model);
             it.spawnpointmodel.frame = ANIM_idle.m_id;
             it.spawnpointmodel.skin = pl.skin;
             it.spawnpointmodel.colormap = 1024 + 68;
             it.spawnpointmodel.glowmod = '1 0 0';
             it.spawnpointmodel.angles = it.angles;
             setsize(it.spawnpointmodel, PL_MIN_CONST, PL_MAX_CONST);
             j++;
         }
     });
     if (j) LOG_INFOF("%d spawnpoints have no nearest waypoint (marked by player model)\n", j);
 
     j = 0;
     IL_EACH(g_items, true,
     {
         it.effects &= ~(EF_NODEPTHTEST | EF_RED | EF_BLUE);
         it.colormod = '0.5 0.5 0.5';
     });
     IL_EACH(g_items, true,
     {
         if (navigation_findnearestwaypoint(it, false))
             continue;
         LOG_INFO("item without waypoint: ", etos(it), " ", vtos(it.origin), "\n");
         it.effects |= EF_NODEPTHTEST | EF_RED;
         it.colormod_x = 8;
         j++;
     });
     if (j) LOG_INFOF("%d items have no nearest waypoint and cannot be walked away from (marked with red light)\n", j);
 
     j = 0;
     IL_EACH(g_items, true,
     {
         if (navigation_findnearestwaypoint(it, true))
             continue;
         LOG_INFO("item without waypoint: ", etos(it), " ", vtos(it.origin), "\n");
         it.effects |= EF_NODEPTHTEST | EF_BLUE;
         it.colormod_z = 8;
         j++;
     });
     if (j) LOG_INFOF("%d items have no nearest waypoint and cannot be walked to (marked with blue light)\n", j);
 }