.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;
void navigation_dynamicgoal_set(entity this)
{
this.nearestwaypointtimeout = time;
+ if (this.nearestwaypoint)
+ this.nearestwaypointtimeout += 2;
}
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;
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;
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)
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;
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;
te_plasmaburn(org);
entity best = NULL;
- vector v = '0 0 0', v2 = '0 0 0';
- float v2_height = 0;
+ vector v = '0 0 0';
if(ent.size && !IS_PLAYER(ent))
{
if(walkfromwp && (it.wpflags & WAYPOINTFLAG_NORELINK))
continue;
- SET_TRACEWALK_DESTCOORDS(it, org, v2, v2_height);
- if(vdist(v2 - org, <, 1050))
- if(tracewalk(ent, org, PL_MIN_CONST, PL_MAX_CONST, v2, v2_height, bot_navigation_movemode))
+ 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);
+ }
});
}
if(walkfromwp && (it.wpflags & WAYPOINTFLAG_NORELINK))
continue;
v = it.origin;
- if(walkfromwp)
- SET_TRACEWALK_DESTCOORDS(ent, v, v2, v2_height);
+
+ if (walkfromwp)
+ {
+ set_tracewalk_dest(ent, v, true);
+ if (trace_ent == ent)
+ {
+ bestdist = 0;
+ best = it;
+ break;
+ }
+ }
else
- SET_TRACEWALK_DESTCOORDS(it, org, v2, v2_height);
- if(navigation_waypoint_will_link(v, org, ent, v2, v2_height, v2, v2_height, walkfromwp, bestdist))
+ 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)
// finds the waypoints near the bot initiating a navigation query
float navigation_markroutes_nearestwaypoints(entity this, float maxdist)
{
- vector v = '0 0 0';
//navigation_testtracewalk = true;
int c = 0;
- float v_height = 0;
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;
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));
}
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), ")");
return true;
// if it can reach the goal there is nothing more to do
- vector dest = '0 0 0';
- float dest_height = 0;
- SET_TRACEWALK_DESTCOORDS(e, startposition, dest, dest_height);
- 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
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 || autocvar_g_waypointeditor)
+ if (nearest_wp.enemy.wpcost < autocvar_bot_ai_strategyinterval_movingtarget)
{
- SET_TRACEWALK_DESTCOORDS(this.goalentity, nearest_wp.enemy.origin, dest, dest_height);
- if(vdist(dest - nearest_wp.enemy.origin, <, 1050))
- 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 (;;)
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
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)
{
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);
- if(this.goalcurrent && this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT)
- return;
- // 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
}
navigation_poproute(this);
+ ++removed_goals;
if(this.goalcurrent && this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT)
- return;
+ return removed_goals;
}
}
}
}
navigation_poproute(this);
+ ++removed_goals;
if(this.goalcurrent && this.goalcurrent.wpflags & WAYPOINTFLAG_TELEPORT)
- return;
+ 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)
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)
// 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)
{
{
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
wp.model = "";
}
- // create a new spawnfunc_waypoint and automatically link it to other waypoints, and link
- // them back to it as well
- // (suitable for spawnfunc_waypoint editor)
entity waypoint_spawn(vector m1, vector m2, float f)
{
- if(!(f & WAYPOINTFLAG_PERSONAL))
+ if(!(f & (WAYPOINTFLAG_PERSONAL | WAYPOINTFLAG_GENERATED)) && m1 == m2)
{
- vector em1 = m1, em2 = m2;
- if (!(f & WAYPOINTFLAG_GENERATED) && m1 == m2)
- {
- em1 = m1 - '8 8 8';
- em2 = m2 + '8 8 8';
- }
+ vector em1 = m1 - '8 8 8';
+ vector em2 = m2 + '8 8 8';
IL_EACH(g_waypoints, boxesoverlap(em1, em2, it.absmin, it.absmax),
{
return it;
continue;
}
- SET_TRACEWALK_DESTCOORDS_2(this, it.origin, sv, sv2, sv2_height);
- SET_TRACEWALK_DESTCOORDS_2(it, this.origin, ev, ev2, ev2_height);
+ sv = set_tracewalk_dest_2(this, it.origin);
+ sv2 = tracewalk_dest;
+ sv2_height = tracewalk_dest_height;
+ ev = set_tracewalk_dest_2(it, this.origin);
+ ev2 = tracewalk_dest;
+ ev2_height = tracewalk_dest_height;
dv = ev - sv;
dv.z = 0;
waypoint_load_links_hardwired();
}
+ #define GET_GAMETYPE_EXTENSION() ((g_race) ? ".race" : "")
+
// Load waypoint links from file
bool waypoint_load_links()
{
- string filename, s;
+ string s;
float file, tokens, c = 0, found;
entity wp_from = NULL, wp_to;
vector wp_to_pos, wp_from_pos;
- filename = strcat("maps/", mapname);
- filename = strcat(filename, ".waypoints.cache");
+
+ string gt_ext = GET_GAMETYPE_EXTENSION();
+
+ string filename = sprintf("maps/%s.waypoints.cache", strcat(mapname, gt_ext));
file = fopen(filename, FILE_READ);
+ if (gt_ext != "" && file < 0)
+ {
+ // if race waypoint file doesn't exist load the default one
+ filename = sprintf("maps/%s.waypoints.cache", mapname);
+ file = fopen(filename, FILE_READ);
+ }
+
if (file < 0)
{
- LOG_TRACE("waypoint links load from ");
- LOG_TRACE(filename);
- LOG_TRACE(" failed");
+ LOG_TRACE("waypoint links load from ", filename, " failed");
+ waypoint_schedulerelinkall();
return false;
}
else
{
if(ver < WAYPOINT_VERSION)
- return false;
+ {
+ LOG_TRACE("waypoint links for this map are outdated.");
+ if (g_assault)
+ {
+ LOG_TRACE("Assault waypoint links need to be manually updated in the editor");
+ }
+ else
+ {
+ LOG_TRACE("automatically updating...");
+ waypoint_schedulerelinkall();
+ fclose(file);
+ return false;
+ }
+ }
parse_comments = false;
}
}
{
// bad file format
fclose(file);
+ waypoint_schedulerelinkall(); // link all the autogenerated waypoints (teleporters)
return false;
}
LOG_TRACE("waypoint_load_links: couldn't find 'from' waypoint at ", vtos(wp_from_pos));
continue;
}
-
}
// Search "to" waypoint
fclose(file);
- LOG_TRACE("loaded ", ftos(c), " waypoint links from maps/", mapname, ".waypoints.cache");
+ LOG_TRACE("loaded ", ftos(c), " waypoint links from ", filename);
+
+ bool scheduled = false;
+ IL_EACH(g_waypoints, it.wpflags & WAYPOINTFLAG_ITEM,
+ {
+ if (!it.wp00)
+ {
+ waypoint_schedulerelink(it);
+ scheduled = true;
+ }
+ });
+ if (scheduled)
+ return false;
botframe_cachedwaypointlinks = true;
return true;
void waypoint_load_or_remove_links_hardwired(bool removal_mode)
{
- string filename, s;
+ string s;
float file, tokens, c = 0, found;
entity wp_from = NULL, wp_to;
vector wp_to_pos, wp_from_pos;
- filename = strcat("maps/", mapname);
- filename = strcat(filename, ".waypoints.hardwired");
+
+ string gt_ext = GET_GAMETYPE_EXTENSION();
+
+ string filename = sprintf("maps/%s.waypoints.hardwired", strcat(mapname, gt_ext));
file = fopen(filename, FILE_READ);
+ if (gt_ext != "" && file < 0)
+ {
+ // if race waypoint file doesn't exist load the default one
+ filename = sprintf("maps/%s.waypoints.hardwired", mapname);
+ file = fopen(filename, FILE_READ);
+ }
+
botframe_loadedforcedlinks = true;
if (file < 0)
fclose(file);
- if(!removal_mode)
- LOG_TRACE("loaded ", ftos(c), " waypoint links from maps/", mapname, ".waypoints.hardwired");
+ LOG_TRACE(((removal_mode) ? "unloaded " : "loaded "),
+ ftos(c), " waypoint links from maps/", mapname, ".waypoints.hardwired");
}
entity waypoint_get_link(entity w, float i)
// temporarily remove hardwired links so they don't get saved among normal links
waypoint_remove_links_hardwired();
- string filename = sprintf("maps/%s.waypoints.cache", mapname);
+ string gt_ext = GET_GAMETYPE_EXTENSION();
+
+ string filename = sprintf("maps/%s.waypoints.cache", strcat(mapname, gt_ext));
int file = fopen(filename, FILE_WRITE);
if (file < 0)
{
}
});
fclose(file);
+
botframe_cachedwaypointlinks = true;
- LOG_INFOF("saved %d waypoint links to maps/%s.waypoints.cache", c, mapname);
+ LOG_INFOF("saved %d waypoint links to %s", c, filename);
waypoint_load_links_hardwired();
}
// save waypoints to gamedir/data/maps/mapname.waypoints
void waypoint_saveall()
{
- string filename = sprintf("maps/%s.waypoints", mapname);
+ 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();
botframe_loadedforcedlinks = false;
- LOG_INFOF("saved %d waypoints to maps/%s.waypoints", c, mapname);
+ LOG_INFOF("saved %d waypoints to %s", c, filename);
}
// load waypoints from file
float waypoint_loadall()
{
- string filename, s;
+ string s;
float file, cwp, cwb, fl;
vector m1, m2;
cwp = 0;
cwb = 0;
- filename = strcat("maps/", mapname);
- filename = strcat(filename, ".waypoints");
+
+ string gt_ext = GET_GAMETYPE_EXTENSION();
+
+ string filename = sprintf("maps/%s.waypoints", strcat(mapname, gt_ext));
file = fopen(filename, FILE_READ);
- bool parse_comments = true;
- float ver = 0;
+ if (gt_ext != "" && file < 0)
+ {
+ // if race waypoint file doesn't exist load the default one
+ filename = sprintf("maps/%s.waypoints", mapname);
+ file = fopen(filename, FILE_READ);
+ }
if (file < 0)
{
return 0;
}
+ bool parse_comments = true;
+ float ver = 0;
+
while ((s = fgets(file)))
{
if(parse_comments)
else
{
if(floor(ver) < floor(WAYPOINT_VERSION))
+ {
LOG_TRACE("waypoints for this map are outdated");
+ LOG_TRACE("please update them in the editor");
+ }
parse_comments = false;
}
}
projects / xonotic / xonotic-data.pk3dir.git / commitdiff