#include <common/constants.qh>
#include <common/net_linked.qh>
+#include <common/mapobjects/func/ladder.qh>
#include <common/mapobjects/trigger/jumppads.qh>
.float speed;
return this.bot_strategytime < time;
}
+void navigation_goalrating_timeout_extend_if_needed(entity this, float seconds)
+{
+ this.bot_strategytime = max(this.bot_strategytime, time + seconds);
+}
+
#define MAX_CHASE_DISTANCE 700
bool navigation_goalrating_timeout_can_be_anticipated(entity this)
{
- if(time > this.bot_strategytime - (IS_MOVABLE(this.goalentity) ? 3 : 2))
+ 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)
{
- vector gco = (this.goalentity.absmin + this.goalentity.absmax) * 0.5;
if(!havocbot_goalrating_item_pickable_check_players(this, this.origin, this.goalentity, gco))
{
this.ignoregoal = this.goalentity;
this.nearestwaypointtimeout = time;
}
-void navigation_dynamicgoal_set(entity this)
+void navigation_dynamicgoal_set(entity this, entity dropper)
{
this.nearestwaypointtimeout = time;
+ if (dropper && dropper.nearestwaypointtimeout && dropper.nearestwaypointtimeout < time + 2)
+ this.nearestwaypoint = dropper.nearestwaypoint;
if (this.nearestwaypoint)
this.nearestwaypointtimeout += 2;
}
// 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);
- tracewalk_dest.z = wm1.z;
- tracewalk_dest_height = wm2.z - wm1.z; // destination height
+ 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
{
return false;
}
+// Unfortuntely we can't use trace_inwater since it doesn't hold the fraction of the total
+// distance that was traveled before impact as the description in the engine (collision.h) says.
+// It would have helped to speed up tracewalk underwater
vector resurface_limited(vector org, float lim, vector m1)
{
if (WETFEET(org + eZ * (lim - org.z)))
int nav_action;
// Analyze starting point
- traceline(start, start, MOVE_NORMAL, e);
- if (trace_dpstartcontents & (DPCONTENTS_SLIME | DPCONTENTS_LAVA))
+ if (IN_LAVA(start))
ignorehazards = true;
tracebox(start, m1, m2, start, MOVE_NOMONSTERS, e);
// completely empty the goal stack, used when deciding where to go
void navigation_clearroute(entity this)
{
+ this.lastteleporttime = 0;
this.goalcurrent_prev = this.goalcurrent;
this.goalcurrent_distance_2d = FLOAT_MAX;
this.goalcurrent_distance_z = FLOAT_MAX;
this.goalcurrent_distance_time = 0;
this.goalentity_lock_timeout = 0;
+ this.goalentity_shouldbefrozen = false;
this.goalentity = NULL;
this.goalcurrent = NULL;
this.goalstack01 = NULL;
vector pm1 = ent.origin + ent.mins;
vector pm2 = ent.origin + ent.maxs;
- // do two scans, because box test is cheaper
- IL_EACH(g_waypoints, it != ent && it != except,
+ if (autocvar_g_waypointeditor && !IS_BOT_CLIENT(ent))
+ {
+ // this code allows removing waypoints in the air and seeing jumppad/telepport waypoint links
+ // FIXME it causes a bug where a waypoint spawned really close to another one (max 16 qu)
+ // isn't detected as the nearest waypoint
+ IL_EACH(g_waypoints, it != ent && it != except,
+ {
+ if (boxesoverlap(pm1, pm2, it.absmin, it.absmax))
+ return it;
+ });
+ }
+ else
{
- if(boxesoverlap(pm1, pm2, it.absmin, it.absmax))
+ // do two scans, because box test is cheaper
+ IL_EACH(g_waypoints, it != ent && it != except && !(it.wpflags & (WAYPOINTFLAG_TELEPORT | WAYPOINTFLAG_JUMP)),
{
- if(!autocvar_g_waypointeditor && walkfromwp && !ent.navigation_dynamicgoal)
+ if(boxesoverlap(pm1, pm2, it.absmin, it.absmax))
{
- waypoint_clearlinks(ent); // initialize wpXXmincost fields
- navigation_item_addlink(it, ent);
+ if(walkfromwp && !ent.navigation_dynamicgoal)
+ waypoint_clearlinks(ent); // initialize wpXXmincost fields
+ return it;
}
- return it;
- }
- });
+ });
+ }
vector org = ent.origin;
if (navigation_testtracewalk)
org.z = ent.origin.z + ent.mins.z - PL_MIN_CONST.z; // player height
}
- if(!autocvar_g_waypointeditor && walkfromwp && !ent.navigation_dynamicgoal)
- {
- waypoint_clearlinks(ent); // initialize wpXXmincost fields
- IL_EACH(g_waypoints, it != ent,
- {
- if(walkfromwp && (it.wpflags & WAYPOINTFLAG_NORELINK))
- continue;
-
- set_tracewalk_dest(ent, it.origin, false);
- if (vdist(tracewalk_dest - it.origin, <, 1050)
- && tracewalk(ent, it.origin, PL_MIN_CONST, PL_MAX_CONST,
- tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode))
- {
- navigation_item_addlink(it, ent);
- }
- });
- }
-
// box check failed, try walk
IL_EACH(g_waypoints, it != ent,
{
- if(walkfromwp && (it.wpflags & WAYPOINTFLAG_NORELINK))
+ if (walkfromwp && (it.wpflags & WPFLAGMASK_NORELINK))
continue;
v = it.origin;
// updates the best goal according to a weighted calculation of travel cost and item value of a new proposed item
void navigation_routerating(entity this, entity e, float f, float rangebias)
{
- if (!e)
- return;
-
- if(e.blacklisted)
- return;
+ if (!e || e.blacklisted) { return; }
rangebias = waypoint_getlinearcost(rangebias);
f = waypoint_getlinearcost(f);
if (IS_PLAYER(e))
{
bool rate_wps = false;
- if((e.flags & FL_INWATER) || (e.flags & FL_PARTIALGROUND))
+ if (e.watertype < CONTENT_WATER || (e.waterlevel > WATERLEVEL_WETFEET && !STAT(FROZEN, e))
+ || (e.flags & FL_PARTIALGROUND))
+ {
rate_wps = true;
+ }
if(!IS_ONGROUND(e))
{
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(GetResourceAmount(this, RESOURCE_FUEL)));
+ LOG_DEBUG("jetpack ai: required fuel ", ftos(fuel), ", have ", ftos(GetResource(this, RES_FUEL)));
// enough fuel ?
- if(GetResourceAmount(this, RESOURCE_FUEL) > fuel || (this.items & IT_UNLIMITED_WEAPON_AMMO))
+ 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
nwp = e.nearestwaypoint;
}
- LOG_DEBUG("-- checking ", e.classname, " (with cost ", ftos(nwp.wpcost), ")");
if (nwp && nwp.wpcost < 10000000)
{
//te_wizspike(nwp.wpnearestpoint);
else
nwptoitem_cost = waypoint_gettravelcost(nwp.wpnearestpoint, goal_org, nwp, e);
float cost = nwp.wpcost + nwptoitem_cost;
- LOG_DEBUG(e.classname, " ", ftos(f), "/(1+", ftos(cost), "/", ftos(rangebias), ") = ");
+ 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("considering ", e.classname, " (with rating ", ftos(f), ")");
+ 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: added goal ", e.classname, " (with rating ", ftos(f), ")");
+ LOG_DEBUG(" ground path: ^3added goal ^5", e.classname);
navigation_bestrating = f;
navigation_bestgoal = e;
}
if(e == NULL)
return false;
- if(nearest_wp && nearest_wp.enemy)
+ if(nearest_wp && nearest_wp.enemy && !(nearest_wp.enemy.wpflags & WPFLAGMASK_NORELINK))
{
// often path can be optimized by not adding the nearest waypoint
if (this.goalentity.navigation_dynamicgoal || autocvar_g_waypointeditor)
}
}
}
- else if(navigation_item_islinked(nearest_wp.enemy, this.goalentity))
- e = nearest_wp.enemy;
+ else
+ {
+ // NOTE unlike waypoints, items hold incoming links
+ navigation_item_initlinks_ifneeded(this.goalentity);
+ int link_num = navigation_item_getlinknum(this.goalentity, nearest_wp.enemy);
+ if (link_num >= 0)
+ {
+ if (navigation_item_iswalkablelink(this.goalentity, link_num))
+ e = nearest_wp.enemy;
+ }
+ else // untested link
+ {
+ entity wp = nearest_wp.enemy;
+ entity goal = this.goalentity;
+ bool walkable = false;
+ if (checkpvs(wp.origin, goal))
+ {
+ set_tracewalk_dest(goal, wp.origin, false);
+ if (vdist(tracewalk_dest - wp.origin, <, 1050)
+ && tracewalk(goal, wp.origin, PL_MIN_CONST, PL_MAX_CONST,
+ tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode))
+ {
+ walkable = true;
+ e = nearest_wp.enemy;
+ }
+ }
+ navigation_item_add_link(wp, goal, walkable);
+ }
+ }
}
for (;;)
}
// shorten path by removing intermediate goals
-void navigation_shortenpath(entity this)
+bool navigation_shortenpath(entity this)
{
if (!this.goalstack01 || wasfreed(this.goalstack01))
- return;
+ return false;
if (this.bot_tracewalk_time > time)
- return;
+ return false;
this.bot_tracewalk_time = max(time, this.bot_tracewalk_time) + 0.25;
bool cut_allowed = false;
navigation_poproute(this);
}
while (this.goalcurrent != next);
+ return true;
}
- return;
+ return false;
}
}
next = this.goalstack01;
// if for some reason the bot is closer to the next goal, pop the current one
- if (!IS_MOVABLE(next) // already checked in the previous case
+ if (!IS_MOVABLE(next) && !(this.goalcurrent.wpflags & (WAYPOINTFLAG_TELEPORT | WAYPOINTFLAG_JUMP))
&& vlen2(this.goalcurrent.origin - next.origin) > vlen2(next.origin - this.origin)
&& checkpvs(this.origin + this.view_ofs, next))
{
{
LOG_DEBUG("path optimized for ", this.netname, ", removed a goal from the queue");
navigation_poproute(this);
+ return true;
}
}
+ return false;
}
// removes any currently touching waypoints from the goal stack
if(this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT)
{
+ if (!this.goalcurrent.wpisbox // warpzone
+ && vlen2(this.origin - this.goalstack01.origin) < vlen2(this.origin - this.goalcurrent.origin))
+ {
+ // immediately remove origin and destination waypoints
+ navigation_poproute(this);
+ ++removed_goals;
+ navigation_poproute(this);
+ ++removed_goals;
+ this.lastteleporttime = 0;
+ }
+
// make sure jumppad is really hit, don't rely on distance based checks
// as they may report a touch even if it didn't really happen
if(this.lastteleporttime > 0 && TELEPORT_USED(this, this.goalcurrent))
this.aistatus &= ~AI_STATUS_WAYPOINT_PERSONAL_GOING;
this.aistatus |= AI_STATUS_WAYPOINT_PERSONAL_REACHED;
}
+ if(this.jumppadcount)
+ {
+ // remove jumppad waypoint after a random delay to prevent bots getting
+ // stuck on certain jumppads that require an extra initial horizontal speed
+ float max_delay = 0.1;
+ if (vdist(vec2(this.velocity), >, 2 * autocvar_sv_maxspeed))
+ max_delay = 0.05;
+ if (time - this.lastteleporttime < random() * max_delay)
+ return removed_goals;
+ }
+ else if (this.goalcurrent.wpisbox) // teleport
+ {
+ // immediately remove origin and destination waypoints
+ navigation_poproute(this);
+ ++removed_goals;
+ }
navigation_poproute(this);
this.lastteleporttime = 0;
++removed_goals;
}
- else
- return removed_goals;
+ return removed_goals;
}
else if (this.lastteleporttime > 0)
{
++removed_goals;
return removed_goals;
}
+ // reset of lastteleporttime can be overriden by a jumppad when it's set
+ // in more than one frame: make sure it's reset
+ this.lastteleporttime = 0;
}
// Loose goal touching check when running
- if(this.aistatus & AI_STATUS_RUNNING)
- if(this.goalcurrent.classname=="waypoint")
- if(vdist(vec2(this.velocity), >=, autocvar_sv_maxspeed)) // if -really- running
- {
- if(vdist(this.origin - this.goalcurrent.origin, <, 150))
+ // check goalstack01 to make sure waypoint isn't the final goal
+ if(this.aistatus & AI_STATUS_RUNNING && this.goalcurrent.classname == "waypoint" && !(this.goalcurrent.wpflags & WAYPOINTFLAG_JUMP)
+ && this.goalstack01 && !wasfreed(this.goalstack01) && vdist(vec2(this.velocity), >=, autocvar_sv_maxspeed))
+ {
+ vector gco = this.goalcurrent.origin;
+ float min_dist = BOT_BUNNYHOP_WP_DETECTION_RANGE;
+ // also detect waypoints when bot is way above them but with a narrower horizontal range
+ // so to increase chances bot ends up in the standard range (optimizes nearest waypoint finding)
+ if(vdist(this.origin - gco, <, min_dist)
+ || (vdist(vec2(this.origin - gco), <, min_dist * 0.5) && vdist(this.origin - eZ * 1.5 * min_dist - gco, <, min_dist)))
{
traceline(this.origin + this.view_ofs , this.goalcurrent.origin, true, NULL);
if(trace_fraction==1)
if(this.goalcurrent.classname == "waypoint" && !this.goalcurrent.wpisbox)
{
gc_min = this.goalcurrent.origin - '1 1 1' * 12;
- gc_max = this.goalcurrent.origin + '1 1 1' * 12;
+ gc_max = this.goalcurrent.origin + '1 1 1' * 12 + eZ * (jumpheight_vec.z + STAT(PL_MIN, this).z);
+ }
+ if (time < this.ladder_time)
+ {
+ if (!boxesoverlap(this.absmin, this.absmax - eZ * STAT(PL_MAX, this).z, gc_min, gc_max))
+ break;
+ }
+ else
+ {
+ if (!boxesoverlap(this.absmin, this.absmax, gc_min, gc_max))
+ break;
}
- if(!boxesoverlap(this.absmin, this.absmax, gc_min, gc_max))
- break;
// Detect personal waypoints
if(this.aistatus & AI_STATUS_WAYPOINT_PERSONAL_GOING)
wp = this.goalcurrent_prev;
if(!wp)
return NULL;
- if(wp != this.goalcurrent_prev && vdist(wp.origin - this.origin, >, 50))
+ float min_dist = ((this.aistatus & AI_STATUS_RUNNING) ? BOT_BUNNYHOP_WP_DETECTION_RANGE : 50);
+ if(wp != this.goalcurrent_prev && vdist(wp.origin - this.origin, >, min_dist))
{
wp = this.goalcurrent_prev;
if(!wp)
if(!wp)
return NULL;
}
- if(vdist(wp.origin - this.origin, >, 50))
+ if(vdist(wp.origin - this.origin, >, min_dist))
{
wp = NULL;
- IL_EACH(g_waypoints, !(it.wpflags & WAYPOINTFLAG_TELEPORT),
+ IL_EACH(g_waypoints, !(it.wpflags & (WAYPOINTFLAG_TELEPORT | WAYPOINTFLAG_JUMP)),
{
- if(vdist(it.origin - this.origin, <, 50))
+ if(vdist(it.origin - this.origin, <, min_dist))
{
wp = it;
break;
navigation_clearroute(this);
navigation_bestgoal = NULL;
navigation_markroutes(this, wp);
+ this.goalstack31 = wp; // temporarly save the really close waypoint
}
// ends a goal selection session (updates goal stack to the best goal)
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 ", this.goalcurrent.classname);
+ 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 && autocvar_bot_wander_enable)
+ if (!this.goalentity)
{
- if (!(this.aistatus & AI_STATUS_STUCK))
+ 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));
}
void botframe_updatedangerousobjects(float maxupdate)
{
// evaluate the next goal on the queue
float d = vlen2(this.origin - bot_waypoint_queue_goal.origin);
- LOG_DEBUG(this.netname, " evaluating ", bot_waypoint_queue_goal.classname, " with distance ", ftos(d));
+ LOG_DEBUG(this.netname, " evaluating ", bot_waypoint_queue_goal.classname, " with squared distance ", ftos(d));
set_tracewalk_dest(bot_waypoint_queue_goal, this.origin, false);
if (tracewalk(this, this.origin, STAT(PL_MIN, this), STAT(PL_MAX, this),
tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode))
bot_waypoint_queue_bestgoal = bot_waypoint_queue_goal;
}
}
+
+ // move to a random waypoint while bot is searching for a walkable path;
+ // this is usually sufficient to unstuck bots from bad spots or when other
+ // bots of the same team block all their ways
+ if (!bot_waypoint_queue_bestgoal && (!this.goalentity || random() < 0.1))
+ {
+ navigation_clearroute(this);
+ navigation_routetogoal(this, bot_waypoint_queue_goal, this.origin);
+ navigation_goalrating_timeout_expire(this, 1 + random() * 2);
+ }
+
bot_waypoint_queue_goal = bot_waypoint_queue_goal.bot_waypoint_queue_nextgoal;
if (!bot_waypoint_queue_goal)
if (bot_waypoint_queue_bestgoal)
{
LOG_DEBUG(this.netname, " stuck, reachable waypoint found, heading to it");
+ navigation_clearroute(this);
navigation_routetogoal(this, bot_waypoint_queue_bestgoal, this.origin);
navigation_goalrating_timeout_set(this);
this.aistatus &= ~AI_STATUS_STUCK;