X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fxonotic-data.pk3dir.git;a=blobdiff_plain;f=qcsrc%2Fserver%2Fbot%2Fdefault%2Fnavigation.qc;h=3754897bda3fe5ff2554409d318933ad3e11e38a;hp=fc993400e2845a2da9404964810e099afb63d6fb;hb=13e8382b4bd9c0de8bcfd2a96f56e638ba5d431d;hpb=951b01c85e9c985ffe7b90b6bcc5b5e98b79e505 diff --git a/qcsrc/server/bot/default/navigation.qc b/qcsrc/server/bot/default/navigation.qc index fc993400e2..3754897bda 100644 --- a/qcsrc/server/bot/default/navigation.qc +++ b/qcsrc/server/bot/default/navigation.qc @@ -1,5 +1,7 @@ #include "navigation.qh" +#include +#include #include "cvars.qh" #include "bot.qh" @@ -15,6 +17,54 @@ .float speed; +void navigation_goalrating_timeout_set(entity this) +{ + if(IS_MOVABLE(this.goalentity)) + this.bot_strategytime = time + autocvar_bot_ai_strategyinterval_movingtarget; + else + this.bot_strategytime = time + autocvar_bot_ai_strategyinterval; +} + +// use this when current goal must be discarded immediately +void navigation_goalrating_timeout_force(entity this) +{ + navigation_goalrating_timeout_expire(this, 0); +} + +// use this when current goal can be kept for a short while to increase the chance +// of bot touching a waypoint, which helps to find a new goal more efficiently +void navigation_goalrating_timeout_expire(entity this, float seconds) +{ + if (seconds <= 0) + this.bot_strategytime = 0; + else if (this.bot_strategytime > time + seconds) + this.bot_strategytime = time + seconds; +} + +bool navigation_goalrating_timeout(entity this) +{ + return this.bot_strategytime < time; +} + +#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)) + 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.ignoregoaltime = time + autocvar_bot_ai_ignoregoal_timeout; + return true; + } + } + return false; +} + void navigation_dynamicgoal_init(entity this, bool initially_static) { this.navigation_dynamicgoal = true; @@ -28,6 +78,8 @@ void navigation_dynamicgoal_init(entity this, bool initially_static) void navigation_dynamicgoal_set(entity this) { this.nearestwaypointtimeout = time; + if (this.nearestwaypoint) + this.nearestwaypointtimeout += 2; } void navigation_dynamicgoal_unset(entity this) @@ -37,6 +89,97 @@ void navigation_dynamicgoal_unset(entity this) this.nearestwaypointtimeout = -1; } +// returns point of ent closer to org +vector get_closer_dest(entity ent, vector org) +{ + 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; +} + +void set_tracewalk_dest(entity ent, vector org, bool fix_player_dest) +{ + 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); + tracewalk_dest.z = wm1.z; + tracewalk_dest_height = wm2.z - wm1.z; // destination height + } + 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; + } + } + } +} + +// returns point of ent closer to org +vector set_tracewalk_dest_2(entity ent, vector org) +{ + 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; +} + bool navigation_check_submerged_state(entity ent, vector pos) { bool submerged; @@ -181,7 +324,15 @@ bool tracewalk(entity e, vector start, vector m1, vector m2, vector end, float e { tracebox(org, m1, m2, org - jumpheight_vec, movemode, e); if (SUBMERGED(trace_endpos)) - RESURFACE_LIMITED(trace_endpos, end.z); + { + 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; @@ -301,7 +452,7 @@ bool tracewalk(entity e, vector start, vector m1, vector m2, vector end, float e { tracebox(org, m1, m2, move, movemode, e); // swim - bool stepswimmed = false; + bool stepswum = false; // hit something if (trace_fraction < 1) @@ -356,14 +507,14 @@ bool tracewalk(entity e, vector start, vector m1, vector m2, vector end, float e continue; } - stepswimmed = true; + stepswum = true; } if (!WETFEET(trace_endpos)) { tracebox(trace_endpos, m1, m2, trace_endpos - eZ * (stepdist + (m2.z - m1.z)), movemode, e); - // if stepswimmed we'll land on the obstacle, avoid the SUBMERGED check - if (!stepswimmed && SUBMERGED(trace_endpos)) + // 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; @@ -576,9 +727,10 @@ bool tracewalk(entity e, vector start, vector m1, vector m2, vector end, float e void navigation_clearroute(entity this) { this.goalcurrent_prev = this.goalcurrent; - this.goalcurrent_distance = 10000000; + this.goalcurrent_distance_2d = FLOAT_MAX; + this.goalcurrent_distance_z = FLOAT_MAX; this.goalcurrent_distance_time = 0; - //print("bot ", etos(this), " clear\n"); + this.goalentity_lock_timeout = 0; this.goalentity = NULL; this.goalcurrent = NULL; this.goalstack01 = NULL; @@ -623,7 +775,8 @@ void navigation_clearroute(entity this) void navigation_pushroute(entity this, entity e) { this.goalcurrent_prev = this.goalcurrent; - this.goalcurrent_distance = 10000000; + this.goalcurrent_distance_2d = FLOAT_MAX; + this.goalcurrent_distance_z = FLOAT_MAX; this.goalcurrent_distance_time = 0; //print("bot ", etos(this), " push ", etos(e), "\n"); if(this.goalstack31 == this.goalentity) @@ -668,11 +821,15 @@ void navigation_pushroute(entity this, entity e) void navigation_poproute(entity this) { this.goalcurrent_prev = this.goalcurrent; - this.goalcurrent_distance = 10000000; + this.goalcurrent_distance_2d = FLOAT_MAX; + this.goalcurrent_distance_z = FLOAT_MAX; this.goalcurrent_distance_time = 0; //print("bot ", etos(this), " pop\n"); if(this.goalcurrent == this.goalentity) + { this.goalentity = NULL; + this.goalentity_lock_timeout = 0; + } this.goalcurrent = this.goalstack01; this.goalstack01 = this.goalstack02; this.goalstack02 = this.goalstack03; @@ -710,7 +867,7 @@ void navigation_poproute(entity this) // walking to wp (walkfromwp == false) v2 and v2_height will be used as // waypoint destination coordinates instead of v (only useful for box waypoints) // for normal waypoints v2 == v and v2_height == 0 -float navigation_waypoint_will_link(vector v, vector org, entity ent, vector v2, float v2_height, float walkfromwp, float bestdist) +float navigation_waypoint_will_link(vector v, vector org, entity ent, vector v2, float v2_height, vector o2, float o2_height, float walkfromwp, float bestdist) { if (vdist(v - org, <, bestdist)) { @@ -719,12 +876,12 @@ float navigation_waypoint_will_link(vector v, vector org, entity ent, vector v2, { if (walkfromwp) { - if (tracewalk(ent, v, PL_MIN_CONST, PL_MAX_CONST, org, 0, bot_navigation_movemode)) + if (tracewalk(ent, v, PL_MIN_CONST, PL_MAX_CONST, v2, v2_height, bot_navigation_movemode)) return true; } else { - if (tracewalk(ent, org, PL_MIN_CONST, PL_MAX_CONST, v2, v2_height, bot_navigation_movemode)) + if (tracewalk(ent, org, PL_MIN_CONST, PL_MAX_CONST, o2, o2_height, bot_navigation_movemode)) return true; } } @@ -735,6 +892,9 @@ float navigation_waypoint_will_link(vector v, vector org, entity ent, vector v2, // find the spawnfunc_waypoint near a dynamic goal such as a dropped weapon entity navigation_findnearestwaypoint_withdist_except(entity ent, float walkfromwp, float bestdist, entity except) { + if(ent.tag_entity) + ent = ent.tag_entity; + vector pm1 = ent.origin + ent.mins; vector pm2 = ent.origin + ent.maxs; @@ -742,22 +902,30 @@ entity navigation_findnearestwaypoint_withdist_except(entity ent, float walkfrom IL_EACH(g_waypoints, it != ent && it != except, { if(boxesoverlap(pm1, pm2, it.absmin, it.absmax)) + { + if(!autocvar_g_waypointeditor && walkfromwp && !ent.navigation_dynamicgoal) + { + waypoint_clearlinks(ent); // initialize wpXXmincost fields + navigation_item_addlink(it, ent); + } return it; + } }); - vector org = ent.origin + 0.5 * (ent.mins + ent.maxs); - org.z = ent.origin.z + ent.mins.z - PL_MIN_CONST.z; // player height - // TODO possibly make other code have the same support for bboxes - if(ent.tag_entity) - org = org + ent.tag_entity.origin; + vector org = ent.origin; if (navigation_testtracewalk) te_plasmaburn(org); entity best = NULL; - vector v, v2; - float v2_height; + vector v = '0 0 0'; - if(!autocvar_g_waypointeditor && !ent.navigation_dynamicgoal) + if(ent.size && !IS_PLAYER(ent)) + { + org += 0.5 * (ent.mins + ent.maxs); + 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, @@ -765,9 +933,13 @@ entity navigation_findnearestwaypoint_withdist_except(entity ent, float walkfrom if(walkfromwp && (it.wpflags & WAYPOINTFLAG_NORELINK)) continue; - SET_TRACEWALK_DESTCOORDS_2(it, org, v, v2, v2_height); - if(navigation_waypoint_will_link(v, org, ent, v2, v2_height, walkfromwp, 1050)) + 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); + } }); } @@ -776,13 +948,46 @@ entity navigation_findnearestwaypoint_withdist_except(entity ent, float walkfrom { if(walkfromwp && (it.wpflags & WAYPOINTFLAG_NORELINK)) continue; - SET_TRACEWALK_DESTCOORDS_2(it, org, v, v2, v2_height); - if(navigation_waypoint_will_link(v, org, ent, v2, v2_height, walkfromwp, bestdist)) + v = it.origin; + + if (walkfromwp) + { + set_tracewalk_dest(ent, v, true); + if (trace_ent == ent) + { + bestdist = 0; + best = it; + break; + } + } + else + set_tracewalk_dest(it, org, false); + + if (navigation_waypoint_will_link(v, org, ent, + tracewalk_dest, tracewalk_dest_height, + tracewalk_dest, tracewalk_dest_height, walkfromwp, bestdist)) { - bestdist = vlen(v - org); + if (walkfromwp) + bestdist = vlen(tracewalk_dest - v); + else + bestdist = vlen(v - org); best = it; } }); + if(!best && !ent.navigation_dynamicgoal) + { + int solid_save = ent.solid; + ent.solid = SOLID_BSP; + IL_EACH(g_jumppads, true, + { + if(trigger_push_test(it, ent)) + { + best = it.nearestwaypoint; + break; + } + }); + ent.solid = solid_save; + } return best; } entity navigation_findnearestwaypoint(entity ent, float walkfromwp) @@ -800,23 +1005,22 @@ entity navigation_findnearestwaypoint(entity ent, float walkfromwp) // finds the waypoints near the bot initiating a navigation query float navigation_markroutes_nearestwaypoints(entity this, float maxdist) { - vector v; //navigation_testtracewalk = true; int c = 0; - float v_height; IL_EACH(g_waypoints, !it.wpconsidered, { - SET_TRACEWALK_DESTCOORDS(it, this.origin, v, v_height); + set_tracewalk_dest(it, this.origin, false); - vector diff = v - this.origin; + vector diff = tracewalk_dest - this.origin; diff.z = max(0, diff.z); if(vdist(diff, <, maxdist)) { it.wpconsidered = true; - if (tracewalk(this, this.origin, this.mins, this.maxs, v, v_height, bot_navigation_movemode)) + if (tracewalk(this, this.origin, this.mins, this.maxs, + tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode)) { - it.wpnearestpoint = v; - it.wpcost = waypoint_gettravelcost(this.origin, v, this, it) + it.dmg; + it.wpnearestpoint = tracewalk_dest; + it.wpcost = waypoint_gettravelcost(this.origin, tracewalk_dest, this, it) + it.dmg; it.wpfire = 1; it.enemy = NULL; c = c + 1; @@ -1157,29 +1361,11 @@ void navigation_routerating(entity this, entity e, float f, float rangebias) if ((!e.nearestwaypoint || e.navigation_dynamicgoal) && e.nearestwaypointtimeout >= 0 && time > e.nearestwaypointtimeout) { - nwp = navigation_findnearestwaypoint(e, true); - if(nwp) - { - e.nearestwaypoint = nwp; - - vector m1 = nwp.absmin, m2 = nwp.absmax; - m1.x = nwp.origin.x; m1.y = nwp.origin.y; - m2.x = nwp.origin.x; m2.y = nwp.origin.y; - vector ve = (e.absmin - e.absmax) * 0.5; - ve.x = bound(m1.x, ve.x, m2.x); - ve.y = bound(m1.y, ve.y, m2.y); - ve.z = bound(m1.z, ve.z, m2.z); - - m1 = e.absmin; m2 = e.absmax; - m1.x = e.origin.x; m1.y = e.origin.y; - m2.x = e.origin.x; m2.y = e.origin.y; - vector vnwp = nwp.origin; - vnwp.x = bound(m1.x, vnwp.x, m2.x); - vnwp.y = bound(m1.y, vnwp.y, m2.y); - vnwp.z = bound(m1.z, vnwp.z, m2.z); - e.nearestwaypoint_dist = vlen(ve - vnwp); - } + 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)); @@ -1202,11 +1388,15 @@ void navigation_routerating(entity this, entity e, float f, float rangebias) } LOG_DEBUG("-- checking ", e.classname, " (with cost ", ftos(nwp.wpcost), ")"); - if (nwp) - if (nwp.wpcost < 10000000) + if (nwp && nwp.wpcost < 10000000) { //te_wizspike(nwp.wpnearestpoint); - float cost = nwp.wpcost + waypoint_gettravelcost(nwp.wpnearestpoint, goal_org, nwp, e); + 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(e.classname, " ", ftos(f), "/(1+", ftos(cost), "/", ftos(rangebias), ") = "); f = f * rangebias / (rangebias + cost); LOG_DEBUG("considering ", e.classname, " (with rating ", ftos(f), ")"); @@ -1226,19 +1416,25 @@ bool navigation_routetogoal(entity this, entity e, vector startposition) if (!e) return false; + entity teleport_goal = NULL; + + this.goalentity = e; + if(e.wpflags & WAYPOINTFLAG_TELEPORT) { // force teleport destination as route destination - e.wp00.enemy = e; - e = e.wp00; + teleport_goal = e; + navigation_pushroute(this, e.wp00); + this.goalentity = e.wp00; } - this.goalentity = e; - // put the entity on the goal stack //print("routetogoal ", etos(e), "\n"); navigation_pushroute(this, e); + if(teleport_goal) + e = this.goalentity; + if(e.classname == "waypoint" && !(e.wpflags & WAYPOINTFLAG_PERSONAL)) { this.wp_goal_prev1 = this.wp_goal_prev0; @@ -1250,11 +1446,13 @@ bool navigation_routetogoal(entity this, entity e, vector startposition) return true; // if it can reach the goal there is nothing more to do - vector dest = (e.absmin + e.absmax) * 0.5; - dest.z = e.absmin.z; - float dest_height = e.absmax.z - e.absmin.z; - if (tracewalk(this, startposition, STAT(PL_MIN, this), STAT(PL_MAX, this), dest, dest_height, bot_navigation_movemode)) + set_tracewalk_dest(e, startposition, true); + if ((!IS_MOVABLE(this.goalcurrent) || vdist(tracewalk_dest - this.origin, <, MAX_CHASE_DISTANCE)) + && (trace_ent == this || tracewalk(this, startposition, STAT(PL_MIN, this), STAT(PL_MAX, this), + tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode))) + { return true; + } entity nearest_wp = NULL; // see if there are waypoints describing a path to the item @@ -1263,6 +1461,8 @@ bool navigation_routetogoal(entity this, entity e, vector startposition) e = e.nearestwaypoint; nearest_wp = e; } + else if(teleport_goal) + e = teleport_goal; else e = e.enemy; // we already have added it, so... @@ -1272,21 +1472,27 @@ bool navigation_routetogoal(entity this, entity e, vector startposition) if(nearest_wp && nearest_wp.enemy) { // often path can be optimized by not adding the nearest waypoint - if (this.goalentity.nearestwaypoint_dist < 8) - e = nearest_wp.enemy; - else + if (this.goalentity.navigation_dynamicgoal || autocvar_g_waypointeditor) { - if (this.goalentity.navigation_dynamicgoal) + if (nearest_wp.enemy.wpcost < autocvar_bot_ai_strategyinterval_movingtarget) { - vector dest = (this.goalentity.absmin + this.goalentity.absmax) * 0.5; - dest.z = this.goalentity.absmin.z; - float dest_height = this.goalentity.absmax.z - this.goalentity.absmin.z; - if(tracewalk(this, nearest_wp.enemy.origin, STAT(PL_MIN, this), STAT(PL_MAX, this), dest, dest_height, bot_navigation_movemode)) + if (vdist(vec2(this.goalentity.origin - nearest_wp.origin), <, 32)) e = nearest_wp.enemy; + else + { + set_tracewalk_dest(this.goalentity, nearest_wp.enemy.origin, true); + if (trace_ent == this || (vdist(tracewalk_dest - nearest_wp.enemy.origin, <, 1050) + && vlen2(tracewalk_dest - nearest_wp.enemy.origin) < vlen2(nearest_wp.origin - nearest_wp.enemy.origin) + && tracewalk(this, nearest_wp.enemy.origin, STAT(PL_MIN, this), STAT(PL_MAX, this), + tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode))) + { + e = nearest_wp.enemy; + } + } } - else if(navigation_item_islinked(nearest_wp.enemy, this.goalentity)) - e = nearest_wp.enemy; } + else if(navigation_item_islinked(nearest_wp.enemy, this.goalentity)) + e = nearest_wp.enemy; } for (;;) @@ -1302,10 +1508,86 @@ bool navigation_routetogoal(entity this, entity e, vector startposition) return false; } +// shorten path by removing intermediate goals +void navigation_shortenpath(entity this) +{ + if (!this.goalstack01 || wasfreed(this.goalstack01)) + return; + if (this.bot_tracewalk_time > time) + return; + this.bot_tracewalk_time = max(time, this.bot_tracewalk_time) + 0.25; + + bool cut_allowed = false; + entity next = this.goalentity; + // evaluate whether bot can discard current route and chase directly a player, trying to + // keep waypoint route as long as possible, as it is safer and faster (bot can bunnyhop) + if (IS_MOVABLE(next)) + { + set_tracewalk_dest(next, this.origin, true); + if (vdist(this.origin - tracewalk_dest, <, 200)) + cut_allowed = true; + else if (vdist(tracewalk_dest - this.origin, <, MAX_CHASE_DISTANCE) + && vdist(tracewalk_dest - this.goalcurrent.origin, >, 200) + && vdist(this.origin - this.goalcurrent.origin, >, 100) + && checkpvs(this.origin + this.view_ofs, next)) + { + if (vlen2(next.origin - this.origin) < vlen2(this.goalcurrent.origin - this.origin)) + cut_allowed = true; + else + { + vector deviation = vectoangles(this.goalcurrent.origin - this.origin) - vectoangles(next.origin - this.origin); + while (deviation.y < -180) deviation.y += 360; + while (deviation.y > 180) deviation.y -= 360; + if (fabs(deviation.y) > 25) + cut_allowed = true; + } + } + if (cut_allowed) + { + if (trace_ent == this || tracewalk(this, this.origin, this.mins, this.maxs, + tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode)) + { + LOG_DEBUG("path optimized for ", this.netname, ", route cleared"); + do + { + navigation_poproute(this); + } + while (this.goalcurrent != next); + } + return; + } + } + + 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 + && vlen2(this.goalcurrent.origin - next.origin) > vlen2(next.origin - this.origin) + && checkpvs(this.origin + this.view_ofs, next)) + { + set_tracewalk_dest(next, this.origin, true); + cut_allowed = true; + } + + if (cut_allowed) + { + if (trace_ent == this || tracewalk(this, this.origin, this.mins, this.maxs, + tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode)) + { + LOG_DEBUG("path optimized for ", this.netname, ", removed a goal from the queue"); + navigation_poproute(this); + } + } +} + // removes any currently touching waypoints from the goal stack // (this is how bots detect if they reached a goal) -void navigation_poptouchedgoals(entity this) +int navigation_poptouchedgoals(entity this) { + int removed_goals = 0; + + if(!this.goalcurrent) + return removed_goals; + if(this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT) { // make sure jumppad is really hit, don't rely on distance based checks @@ -1313,6 +1595,12 @@ void navigation_poptouchedgoals(entity this) if(this.lastteleporttime > 0 && time - this.lastteleporttime < ((this.goalcurrent.wpflags & WAYPOINTFLAG_PERSONAL) ? 2 : 0.15)) { + if (this.jumppadcount && !boxesoverlap(this.goalcurrent.absmin, this.goalcurrent.absmax, + this.lastteleport_origin + STAT(PL_MIN, this), this.lastteleport_origin + STAT(PL_MAX, this))) + { + return; + } + if(this.aistatus & AI_STATUS_WAYPOINT_PERSONAL_GOING) if(this.goalcurrent.wpflags & WAYPOINTFLAG_PERSONAL && this.goalcurrent.owner==this) { @@ -1320,30 +1608,11 @@ void navigation_poptouchedgoals(entity this) this.aistatus |= AI_STATUS_WAYPOINT_PERSONAL_REACHED; } navigation_poproute(this); + this.lastteleporttime = 0; + ++removed_goals; } else - return; - } - - // If for some reason the bot is closer to the next goal, pop the current one - if(this.goalstack01 && !wasfreed(this.goalstack01)) - if(vlen2(this.goalcurrent.origin - this.origin) > vlen2(this.goalstack01.origin - this.origin)) - if(checkpvs(this.origin + this.view_ofs, this.goalstack01)) - { - vector dest = (this.goalstack01.absmin + this.goalstack01.absmax) * 0.5; - dest.z = this.goalstack01.absmin.z; - float dest_height = this.goalstack01.absmax.z - this.goalstack01.absmin.z; - if(tracewalk(this, this.origin, this.mins, this.maxs, dest, dest_height, bot_navigation_movemode)) - { - LOG_DEBUG("path optimized for ", this.netname, ", removed a goal from the queue"); - navigation_poproute(this); - // TODO this may also be a nice idea to do "early" (e.g. by - // manipulating the vlen() comparisons) to shorten paths in - // general - this would make bots walk more "on rails" than - // "zigzagging" which they currently do with sufficiently - // random-like waypoints, and thus can make a nice bot - // personality property - } + return removed_goals; } // Loose goal touching check when running @@ -1365,6 +1634,9 @@ void navigation_poptouchedgoals(entity this) } navigation_poproute(this); + ++removed_goals; + if(this.goalcurrent && this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT) + return removed_goals; } } } @@ -1390,7 +1662,56 @@ void navigation_poptouchedgoals(entity this) } navigation_poproute(this); + ++removed_goals; + if(this.goalcurrent && this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT) + return removed_goals; + } + return removed_goals; +} + +entity navigation_get_really_close_waypoint(entity this) +{ + entity wp = this.goalcurrent; + if(!wp) + wp = this.goalcurrent_prev; + if(!wp) + return NULL; + if(wp != this.goalcurrent_prev && vdist(wp.origin - this.origin, >, 50)) + { + wp = this.goalcurrent_prev; + if(!wp) + return NULL; + } + if(wp.classname != "waypoint") + { + wp = wp.nearestwaypoint; + if(!wp) + return NULL; } + if(vdist(wp.origin - this.origin, >, 50)) + { + wp = NULL; + IL_EACH(g_waypoints, !(it.wpflags & WAYPOINTFLAG_TELEPORT), + { + if(vdist(it.origin - this.origin, <, 50)) + { + wp = it; + break; + } + }); + if(!wp) + return NULL; + } + if(wp.wpflags & WAYPOINTFLAG_TELEPORT) + return NULL; + + set_tracewalk_dest(wp, this.origin, false); + if (!tracewalk(this, this.origin, STAT(PL_MIN, this), STAT(PL_MAX, this), + tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode)) + { + return NULL; + } + return wp; } // begin a goal selection session (queries spawnfunc_waypoint network) @@ -1401,9 +1722,10 @@ void navigation_goalrating_start(entity this) 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, NULL); + navigation_markroutes(this, wp); } // ends a goal selection session (updates goal stack to the best goal) @@ -1483,10 +1805,9 @@ void navigation_unstuck(entity this) // 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)); - vector dest = (bot_waypoint_queue_goal.absmin + bot_waypoint_queue_goal.absmax) * 0.5; - dest.z = bot_waypoint_queue_goal.absmin.z; - float dest_height = bot_waypoint_queue_goal.absmax.z - bot_waypoint_queue_goal.absmin.z; - if(tracewalk(bot_waypoint_queue_goal, this.origin, STAT(PL_MIN, this), STAT(PL_MAX, this), dest, dest_height, bot_navigation_movemode)) + set_tracewalk_dest(bot_waypoint_queue_goal, this.origin, false); + if (tracewalk(bot_waypoint_queue_goal, this.origin, STAT(PL_MIN, this), STAT(PL_MAX, this), + tracewalk_dest, tracewalk_dest_height, bot_navigation_movemode)) { if( d > bot_waypoint_queue_bestgoalrating) { @@ -1502,7 +1823,7 @@ void navigation_unstuck(entity this) { LOG_DEBUG(this.netname, " stuck, reachable waypoint found, heading to it"); navigation_routetogoal(this, bot_waypoint_queue_bestgoal, this.origin); - this.bot_strategytime = time + autocvar_bot_ai_strategyinterval; + navigation_goalrating_timeout_set(this); this.aistatus &= ~AI_STATUS_STUCK; } else