X-Git-Url: http://git.pond.sub.org/?p=empserver;a=blobdiff_plain;f=src%2Flib%2Fsubs%2Fshpsub.c;h=52c5afb6592493bdd041f18efc702587cd0545ac;hp=54dc821b9e1c7fe7c24028a2c1d5e43f5c48f5e7;hb=beedf8dce;hpb=0d477e5df1cd5e0e03bf58800ed60bd74dd943d9

diff --git a/src/lib/subs/shpsub.c b/src/lib/subs/shpsub.c
index 54dc821b9..52c5afb65 100644
--- a/src/lib/subs/shpsub.c
+++ b/src/lib/subs/shpsub.c
@@ -1,11 +1,11 @@
 /*
  *  Empire - A multi-player, client/server Internet based war game.
- *  Copyright (C) 1986-2010, Dave Pare, Jeff Bailey, Thomas Ruschak,
- *                           Ken Stevens, Steve McClure
+ *  Copyright (C) 1986-2015, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ *                Ken Stevens, Steve McClure, Markus Armbruster
  *
- *  This program is free software; you can redistribute it and/or modify
+ *  Empire is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
+ *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
@@ -14,8 +14,7 @@
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  *  ---
  *
@@ -30,17 +29,20 @@
  *  Known contributors to this file:
  *     Ken Stevens, 1995
  *     Steve McClure, 1996-2000
- *     Markus Armbruster, 2006-2009
+ *     Markus Armbruster, 2006-2015
  */
 
 #include <config.h>
 
 #include <stdlib.h>
+#include "chance.h"
 #include "damage.h"
+#include "empobj.h"
 #include "file.h"
 #include "map.h"
 #include "misc.h"
 #include "mission.h"
+#include "news.h"
 #include "nsc.h"
 #include "optlist.h"
 #include "path.h"
@@ -48,19 +50,76 @@
 #include "prototypes.h"
 #include "queue.h"
 #include "server.h"
-#include "xy.h"
-#include "empobj.h"
 #include "unit.h"
+#include "xy.h"
 
+static void shp_nav_put_one(struct ulist *);
 static int shp_check_one_mines(struct ulist *);
 static int shp_hit_mine(struct shpstr *);
-static void shp_stays(natid, char *, struct ulist *);
+
+static struct ulist *
+shp_find_capable(struct emp_qelem *list, int flags)
+{
+    struct emp_qelem *qp;
+    struct ulist *mlp;
+
+    for (qp = list->q_back; qp != list; qp = qp->q_back) {
+	mlp = (struct ulist *)qp;
+	if (mchr[mlp->unit.ship.shp_type].m_flags & flags)
+	    return mlp;
+    }
+    return NULL;
+}
+
+int
+shp_may_nav(struct shpstr *sp, struct shpstr *flg, char *suffix)
+{
+    struct sctstr sect;
+
+    if (!sp->shp_own || !getsect(sp->shp_x, sp->shp_y, &sect)) {
+	CANT_REACH();
+	return 0;
+    }
+
+    if (opt_MARKET && ontradingblock(EF_SHIP, sp)) {
+	mpr(sp->shp_own, "%s is on the trading block%s\n",
+	    prship(sp), suffix);
+	return 0;
+    }
+
+    if (sp->shp_item[I_MILIT] == 0 && sp->shp_item[I_CIVIL] == 0) {
+	mpr(sp->shp_own, "%s is crewless%s\n", prship(sp), suffix);
+	return 0;
+    }
+
+    switch (shp_check_nav(sp, &sect)) {
+    case SHP_STUCK_NOT:
+	break;
+    case SHP_STUCK_CONSTRUCTION:
+	mpr(sp->shp_own, "%s is caught in a construction zone%s\n",
+	    prship(sp), suffix);
+	return 0;
+    default:
+	CANT_REACH();
+	/* fall through */
+    case SHP_STUCK_CANAL:
+    case SHP_STUCK_IMPASSABLE:
+	mpr(sp->shp_own, "%s is landlocked%s\n", prship(sp), suffix);
+	return 0;
+    }
+
+    if (flg && (sp->shp_x != flg->shp_x || sp->shp_y != flg->shp_y)) {
+	mpr(sp->shp_own, "%s is not with the flagship%s\n",
+	    prship(sp), suffix);
+	return 0;
+    }
+    return 1;
+}
 
 void
 shp_sel(struct nstr_item *ni, struct emp_qelem *list)
 {
-    struct shpstr ship;
-    struct mchrstr *mcp;
+    struct shpstr ship, *flg = NULL;
     struct ulist *mlp;
 
     emp_initque(list);
@@ -70,106 +129,111 @@ shp_sel(struct nstr_item *ni, struct emp_qelem *list)
 	 * much of the code assumes that only the ship's owner can
 	 * navigate it.
 	 */
-	if (ship.shp_own != player->cnum)
+	if (!ship.shp_own || ship.shp_own != player->cnum)
 	    continue;
-	mcp = &mchr[(int)ship.shp_type];
-	if (opt_MARKET) {
-	    if (ontradingblock(EF_SHIP, &ship)) {
-		pr("ship #%d inelligible - it's for sale.\n",
-		   ship.shp_uid);
-		continue;
-	    }
-	}
+	if (!shp_may_nav(&ship, flg, ""))
+	    continue;
+
 	ship.shp_mission = 0;
 	ship.shp_rflags = 0;
 	memset(ship.shp_rpath, 0, sizeof(ship.shp_rpath));
 	putship(ship.shp_uid, &ship);
-	mlp = malloc(sizeof(struct ulist));
-	mlp->chrp = (struct empobj_chr *)mcp;
-	mlp->unit.ship = ship;
-	mlp->mobil = ship.shp_mobil;
-	emp_insque(&mlp->queue, list);
+	mlp = shp_insque(&ship, list);
+	if (!flg)
+	    flg = &mlp->unit.ship;
     }
 }
 
-/* This function assumes that the list was created by shp_sel */
+/*
+ * Append SP to LIST.
+ * Return the new list link.
+ */
+struct ulist *
+shp_insque(struct shpstr *sp, struct emp_qelem *list)
+{
+    struct ulist *mlp = malloc(sizeof(struct ulist));
+
+    mlp->unit.ship = *sp;
+    mlp->mobil = sp->shp_mobil;
+    emp_insque(&mlp->queue, list);
+    return mlp;
+}
+
 void
-shp_nav(struct emp_qelem *list, double *minmobp, double *maxmobp,
-	int *togetherp, natid actor)
+shp_nav_stay_behind(struct emp_qelem *list, natid actor)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
     struct ulist *mlp;
-    struct sctstr sect;
-    struct shpstr ship;
-    coord allx;
-    coord ally;
-    int first = 1;
+    struct shpstr *sp, *flg = NULL;
+    char and_stays[32];
 
-    *minmobp = 9876.0;
-    *maxmobp = -9876.0;
-    *togetherp = 1;
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
 	mlp = (struct ulist *)qp;
-	getship(mlp->unit.ship.shp_uid, &ship);
-	if (ship.shp_own != actor) {
+	sp = &mlp->unit.ship;
+	getship(sp->shp_uid, sp);
+
+	if (sp->shp_own != actor) {
 	    mpr(actor, "%s was sunk at %s\n",
-		prship(&ship), xyas(ship.shp_x, ship.shp_y, actor));
-	    emp_remque((struct emp_qelem *)mlp);
+		prship(sp), xyas(sp->shp_x, sp->shp_y, actor));
+	    emp_remque(&mlp->queue);
 	    free(mlp);
 	    continue;
 	}
-	if (opt_SAIL) {
-	    if (*ship.shp_path && !update_running) {
-		shp_stays(actor, "has a sail path", mlp);
-		mpr(actor, "Use `sail <#> -' to reset\n");
-		continue;
-	    }
-	}
-	/* check crew - uws don't count */
-	if (ship.shp_item[I_MILIT] == 0 && ship.shp_item[I_CIVIL] == 0) {
-	    shp_stays(actor, "is crewless", mlp);
-	    continue;
-	}
-	if (!getsect(ship.shp_x, ship.shp_y, &sect)) {
-	    shp_stays(actor, "was sucked into the sky by a strange looking spaceship", mlp);	/* heh -KHS */
-	    continue;
-	}
-	switch (shp_check_nav(&sect, &ship)) {
-	case CN_CONSTRUCTION:
-	    shp_stays(actor, "is caught in a construction zone", mlp);
-	    continue;
-	case CN_LANDLOCKED:
-	    shp_stays(actor, "is landlocked", mlp);
-	    continue;
-	case CN_NAVIGABLE:
-	    break;
-	case CN_ERROR:
-	default:
-	    shp_stays(actor, "was just swallowed by a big green worm", mlp);
+
+	snprintf(and_stays, sizeof(and_stays), " & stays in %s",
+		 xyas(sp->shp_x, sp->shp_y, actor));
+	if (!shp_may_nav(sp, flg, and_stays)) {
+	    shp_nav_put_one(mlp);
 	    continue;
 	}
-	if (first) {
-	    allx = ship.shp_x;
-	    ally = ship.shp_y;
-	    first = 0;
-	}
-	if (ship.shp_x != allx || ship.shp_y != ally)
-	    *togetherp = 0;
-	if (ship.shp_mobil + 1 < (int)mlp->mobil) {
-	    mlp->mobil = ship.shp_mobil;
+
+	if (!flg)
+	    flg = sp;
+	if (sp->shp_mobil + 1 < (int)mlp->mobil) {
+	    mlp->mobil = sp->shp_mobil;
 	}
-	if (mlp->mobil < *minmobp)
-	    *minmobp = mlp->mobil;
-	if (mlp->mobil > *maxmobp)
-	    *maxmobp = mlp->mobil;
-	mlp->unit.ship = ship;
     }
 }
 
+void
+shp_nav_put(struct emp_qelem *list, natid actor)
+{
+    struct emp_qelem *qp, *next;
+    struct ulist *mlp;
+    struct shpstr *sp;
+
+    for (qp = list->q_back; qp != list; qp = next) {
+	next = qp->q_back;
+	mlp = (struct ulist *)qp;
+	sp = &mlp->unit.ship;
+	mpr(actor, "%s stopped at %s\n",
+	    prship(sp), xyas(sp->shp_x, sp->shp_y, actor));
+	shp_nav_put_one(mlp);
+    }
+}
+
+static void
+shp_nav_put_one(struct ulist *mlp)
+{
+    mlp->unit.ship.shp_mobil = (int)mlp->mobil;
+    putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
+    emp_remque(&mlp->queue);
+    free(mlp);
+}
+
+/*
+ * Sweep seamines with engineers in SHIP_LIST for ACTOR.
+ * All ships in SHIP_LIST must be in the same sector.
+ * If EXPLICIT is non-zero, this is for an explicit sweep command from
+ * a player.  Else it's an automatic "on the move" sweep.
+ * If TAKEMOB is non-zero, require and charge mobility.
+ * Return non-zero when the ships should stop.
+ */
 int
-shp_sweep(struct emp_qelem *ship_list, int verbose, int takemob, natid actor)
+shp_sweep(struct emp_qelem *ship_list, int explicit, int takemob,
+	  natid actor)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
@@ -177,41 +241,52 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, int takemob, natid actor)
     struct sctstr sect;
     int mines, m, max, shells;
     int changed = 0;
-    int stopping = 0;
+    int stopping = 0, first = 1;
+
+    mlp = shp_find_capable(ship_list, M_SWEEP);
+    if (!mlp) {
+	if (explicit)
+	    mpr(actor, "No minesweepers!\n");
+	return 0;
+    }
+
+    getsect(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, &sect);
+    if (sect.sct_type != SCT_WATER) {
+	if (explicit)
+	    mpr(actor, "%s is a %s.  No seamines there!\n",
+	       xyas(sect.sct_x, sect.sct_y, actor),
+	       dchr[sect.sct_type].d_name);
+	return 0;
+    }
 
     for (qp = ship_list->q_back; qp != ship_list; qp = next) {
 	next = qp->q_back;
 	mlp = (struct ulist *)qp;
-	if (!(((struct mchrstr *)mlp->chrp)->m_flags & M_SWEEP)) {
-	    if (verbose)
-		mpr(actor, "%s doesn't have minesweeping capability!\n",
-		    prship(&mlp->unit.ship));
+	if (!(mchr[mlp->unit.ship.shp_type].m_flags & M_SWEEP))
 	    continue;
-	}
-	if (takemob && mlp->mobil <= 0.0) {
-	    if (verbose)
-		mpr(actor, "%s is out of mobility!\n",
-		    prship(&mlp->unit.ship));
-	    continue;
-	}
-	getsect(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, &sect);
-	if (sect.sct_type != SCT_WATER) {
-	    if (verbose)
-		mpr(actor, "%s is not at sea.  No mines there!\n",
-		    prship(&mlp->unit.ship));
-	    continue;
-	}
 	if (takemob) {
+	    if (mlp->mobil <= 0.0) {
+		if (explicit)
+		    mpr(actor, "%s is out of mobility!\n",
+			prship(&mlp->unit.ship));
+		continue;
+	    }
 	    mlp->mobil -= shp_mobcost(&mlp->unit.ship);
 	    mlp->unit.ship.shp_mobil = (int)mlp->mobil;
 	}
 	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
+	getsect(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, &sect);
 	if (!(mines = sect.sct_mines))
 	    continue;
-	max = ((struct mchrstr *)mlp->chrp)->m_item[I_SHELL];
+	max = mchr[mlp->unit.ship.shp_type].m_item[I_SHELL];
 	shells = mlp->unit.ship.shp_item[I_SHELL];
 	for (m = 0; mines > 0 && m < 5; m++) {
 	    if (chance(0.66)) {
+		if (first) {
+		    mpr(actor, "Approaching minefield at %s...\n",
+			xyas(sect.sct_x, sect.sct_y, actor));
+		    first = 0;
+		}
 		mpr(actor, "Sweep...\n");
 		mines--;
 		shells = MIN(max, shells + 1);
@@ -222,11 +297,7 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, int takemob, natid actor)
 	mlp->unit.ship.shp_item[I_SHELL] = shells;
 	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
 	putsect(&sect);
-	if (shp_check_one_mines(mlp)) {
-	    stopping = 1;
-	    emp_remque(qp);
-	    free(qp);
-	}
+	stopping |= shp_check_one_mines(mlp);
     }
     if (changed)
 	writemap(actor);
@@ -252,8 +323,11 @@ shp_check_one_mines(struct ulist *mlp)
 	    writemap(actor);
 	putsect(&sect);
 	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
-	if (!mlp->unit.ship.shp_own)
-	    return 1;
+	if (!mlp->unit.ship.shp_own) {
+	    emp_remque(&mlp->queue);
+	    free(mlp);
+	}
+	return 1;
     }
     return 0;
 }
@@ -263,59 +337,44 @@ shp_check_mines(struct emp_qelem *ship_list)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct ulist *mlp;
     int stopping = 0;
 
     for (qp = ship_list->q_back; qp != ship_list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct ulist *)qp;
-	if (shp_check_one_mines(mlp)) {
-	    stopping = 1;
-	    emp_remque(qp);
-	    free(qp);
-	}
+	stopping |= shp_check_one_mines((struct ulist *)qp);
     }
     return stopping;
 }
 
-
-static void
-shp_stays(natid actor, char *str, struct ulist *mlp)
-{
-    mpr(actor, "%s %s & stays in %s\n",
-	prship(&mlp->unit.ship), str,
-	xyas(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, actor));
-    mlp->unit.ship.shp_mobil = (int)mlp->mobil;
-    putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
-    emp_remque((struct emp_qelem *)mlp);
-    free(mlp);
-}
-
-int
-shp_check_nav(struct sctstr *sect, struct shpstr *shp)
+/*
+ * Return whether and why SP would be stuck in SECTP.
+ */
+enum shp_stuck
+shp_check_nav(struct shpstr *sp, struct sctstr *sectp)
 {
-    switch (dchr[sect->sct_type].d_nav) {
+    switch (dchr[sectp->sct_type].d_nav) {
     case NAVOK:
 	break;
     case NAV_CANAL:
-	if (mchr[(int)shp->shp_type].m_flags & M_CANAL) {
-	    if (sect->sct_effic < 2)
-		return CN_CONSTRUCTION;
-	} else
-	    return CN_LANDLOCKED;
-	break;
+	if (!(mchr[sp->shp_type].m_flags & M_CANAL)) {
+	    return SHP_STUCK_CANAL;
+	}
+	/* fall through */
     case NAV_02:
-	if (sect->sct_effic < 2)
-	    return CN_CONSTRUCTION;
+	if (sectp->sct_effic < 2)
+	    return SHP_STUCK_CONSTRUCTION;
 	break;
     case NAV_60:
-	if (sect->sct_effic < 60)
-	    return CN_CONSTRUCTION;
+	if (sectp->sct_effic < 60)
+	    return SHP_STUCK_CONSTRUCTION;
 	break;
     default:
-	return CN_LANDLOCKED;
+	CANT_REACH();
+	/* fall through */
+    case NAV_NONE:
+	return SHP_STUCK_IMPASSABLE;
     }
-    return CN_NAVIGABLE;
+    return SHP_STUCK_NOT;
 }
 
 int
@@ -345,10 +404,10 @@ shp_count(struct emp_qelem *list, int wantflags, int nowantflags,
 	if (mlp->unit.ship.shp_x != x || mlp->unit.ship.shp_y != y)
 	    continue;
 	if (wantflags &&
-	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
 	if (nowantflags &&
-	    ((struct mchrstr *)mlp->chrp)->m_flags & nowantflags)
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
 	++count;
     }
@@ -363,7 +422,7 @@ shp_damage_one(struct ulist *mlp, int dam)
     shipdamage(&mlp->unit.ship, dam);
     putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
     if (!mlp->unit.ship.shp_own) {
-	emp_remque((struct emp_qelem *)mlp);
+	emp_remque(&mlp->queue);
 	free(mlp);
     }
 }
@@ -388,10 +447,10 @@ shp_damage(struct emp_qelem *list, int totdam, int wantflags,
 	if (mlp->unit.ship.shp_x != x || mlp->unit.ship.shp_y != y)
 	    continue;
 	if (wantflags &&
-	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
 	if (nowantflags &&
-	    ((struct mchrstr *)mlp->chrp)->m_flags & nowantflags)
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
 	shp_damage_one(mlp, dam);
     }
@@ -413,10 +472,10 @@ shp_contains(struct emp_qelem *list, int newx, int newy, int wantflags,
 	if (newx != mlp->unit.ship.shp_x || newy != mlp->unit.ship.shp_y)
 	    continue;
 	if (wantflags &&
-	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
 	if (nowantflags &&
-	    ((struct mchrstr *)mlp->chrp)->m_flags & nowantflags)
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
 	return 1;
     }
@@ -436,20 +495,20 @@ most_valuable_ship(struct emp_qelem *list, coord x, coord y)
 	mlp = (struct ulist *)qp;
 	if (mlp->unit.ship.shp_x != x || mlp->unit.ship.shp_y != y)
 	    continue;
-	if (((struct mchrstr *)mlp->chrp)->m_flags & M_SUB)
+	if (mchr[mlp->unit.ship.shp_type].m_flags & M_SUB)
 	    continue;
-	if (!((struct mchrstr *)mlp->chrp)->m_nxlight &&
-	    !((struct mchrstr *)mlp->chrp)->m_nchoppers &&
-	    ((struct mchrstr *)mlp->chrp)->m_cost < 1000 &&
-	    !((struct mchrstr *)mlp->chrp)->m_nplanes &&
-	    !((struct mchrstr *)mlp->chrp)->m_nland)
+	if (!mchr[mlp->unit.ship.shp_type].m_nxlight &&
+	    !mchr[mlp->unit.ship.shp_type].m_nchoppers &&
+	    mchr[mlp->unit.ship.shp_type].m_cost < 1000 &&
+	    !mchr[mlp->unit.ship.shp_type].m_nplanes &&
+	    !mchr[mlp->unit.ship.shp_type].m_nland)
 	    continue;
 	if (!mvs) {
 	    mvs = mlp;
 	    continue;
 	}
-	if (((struct mchrstr *)mlp->chrp)->m_cost * mlp->unit.ship.shp_effic >
-	    ((struct mchrstr *)mlp->chrp)->m_cost * mvs->unit.ship.shp_effic)
+	if (mchr[mlp->unit.ship.shp_type].m_cost * mlp->unit.ship.shp_effic >
+	    mchr[mvs->unit.ship.shp_type].m_cost * mvs->unit.ship.shp_effic)
 	    mvs = mlp;
     }
     return mvs;
@@ -469,10 +528,10 @@ shp_easiest_target(struct emp_qelem *list, int wantflags, int nowantflags)
 	next = qp->q_back;
 	mlp = (struct ulist *)qp;
 	if (wantflags &&
-	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
 	if (nowantflags &&
-	    ((struct mchrstr *)mlp->chrp)->m_flags & nowantflags)
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
 	hard = shp_hardtarget(&mlp->unit.ship);
 	if (hard < easiest)
@@ -558,7 +617,7 @@ notify_coastguard(struct emp_qelem *list, int trange, struct sctstr *sectp)
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
 	mlp = (struct ulist *)qp;
-	if (((struct mchrstr *)mlp->chrp)->m_flags & M_SUB)
+	if (mchr[mlp->unit.ship.shp_type].m_flags & M_SUB)
 	    continue;
 	if (natp->nat_flags & NF_COASTWATCH)
 	    wu(0, sectp->sct_own,
@@ -589,7 +648,7 @@ shp_fort_interdiction(struct emp_qelem *list, coord newx, coord newy,
 
     /* Inform neutral and worse */
     for (i = 0; i < MAXNOC; ++i) {
-	if (getrel(getnatp(i), victim) <= NEUTRAL)
+	if (relations_with(i, victim) <= NEUTRAL)
 	    notified[i] = 0;
 	else
 	    notified[i] = 1;
@@ -611,7 +670,7 @@ shp_fort_interdiction(struct emp_qelem *list, coord newx, coord newy,
 	return 0;		/* Only coastwatch notify in nofortfire */
     /* Only fire at Hostile ships */
     for (i = 0; i < MAXNOC; ++i) {
-	if (getrel(getnatp(i), victim) >= NEUTRAL)
+	if (relations_with(i, victim) >= NEUTRAL)
 	    notified[i] = 0;
     }
     snxtsct_dist(&ns, newx, newy, fort_max_interdiction_range);
@@ -718,59 +777,91 @@ shp_hit_mine(struct shpstr *sp)
 }
 
 int
-shp_nav_one_sector(struct emp_qelem *list, int dir, natid actor,
-		   int together)
+shp_nav_dir(struct emp_qelem *list, int dir, natid actor)
 {
     struct sctstr sect;
     struct emp_qelem *qp;
     struct emp_qelem *next;
     struct ulist *mlp;
-    struct emp_qelem done;
     coord dx;
     coord dy;
     coord newx;
     coord newy;
-    int stopping = 0;
+    int move;
+    enum shp_stuck stuck;
     double mobcost;
-    double tech;		/* for mapping */
-    char dp[80];
-    int navigate;
 
-    if (dir <= DIR_STOP || dir >= DIR_VIEW) {
-	unit_put(list, actor);
+    if (CANT_HAPPEN(QEMPTY(list)))
+	return 1;
+
+    if (dir <= DIR_STOP || dir > DIR_LAST) {
+	CANT_HAPPEN(dir != DIR_STOP);
+	shp_nav_put(list, actor);
 	return 1;
     }
     dx = diroff[dir][0];
     dy = diroff[dir][1];
+
+    mlp = (struct ulist *)list->q_back;
+    newx = xnorm(mlp->unit.ship.shp_x + dx);
+    newy = ynorm(mlp->unit.ship.shp_y + dy);
+    getsect(newx, newy, &sect);
+
+    if (sect.sct_own && relations_with(sect.sct_own, actor) < FRIENDLY) {
+	mpr(actor, "can't go to %s\n", xyas(newx, newy, actor));
+	return 1;
+    }
+
+    move = 0;
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
 	mlp = (struct ulist *)qp;
-	newx = xnorm(mlp->unit.ship.shp_x + dx);
-	newy = ynorm(mlp->unit.ship.shp_y + dy);
-	getsect(newx, newy, &sect);
-	navigate = shp_check_nav(&sect, &mlp->unit.ship);
-	if (navigate != CN_NAVIGABLE ||
-	    (sect.sct_own && actor != sect.sct_own &&
-	     getrel(getnatp(sect.sct_own), actor) < FRIENDLY)) {
-	    if (dchr[sect.sct_type].d_nav == NAV_CANAL &&
-		!(((struct mchrstr *)mlp->chrp)->m_flags & M_CANAL) &&
-		navigate == CN_LANDLOCKED)
-		sprintf(dp,
-			"is too large to fit into the canal system at %s",
-			xyas(newx, newy, actor));
-	    else
-		sprintf(dp, "can't go to %s", xyas(newx, newy, actor));
-	    if (together) {
-		mpr(actor, "%s\n", dp);
-		return 2;
-	    } else {
-		shp_stays(actor, dp, mlp);
-		continue;
-	    }
+	switch (shp_check_nav(&mlp->unit.ship, &sect)) {
+	case SHP_STUCK_NOT:
+	    move = 1;
+	    break;
+	case SHP_STUCK_CANAL:
+	    break;
+	default:
+	    CANT_REACH();
+	    /* fall through */
+	case SHP_STUCK_CONSTRUCTION:
+	case SHP_STUCK_IMPASSABLE:
+	    mpr(actor, "can't go to %s\n", xyas(newx, newy, actor));
+	    return 1;
+	}
+    }
+    if (!move) {
+	mpr(actor, "is too large to fit into the canal system at %s\n",
+	    xyas(newx, newy, actor));
+	return 1;
+    }
+
+    for (qp = list->q_back; qp != list; qp = next) {
+	next = qp->q_back;
+	mlp = (struct ulist *)qp;
+	stuck = shp_check_nav(&mlp->unit.ship, &sect);
+	if (stuck == SHP_STUCK_CANAL) {
+	    mpr(actor,
+		"%s is too large to fit into the canal system at %s"
+		" & stays in %s\n",
+		prship(&mlp->unit.ship), xyas(newx, newy, actor),
+		xyas(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, actor));
+	    shp_nav_put_one(mlp);
+	    continue;
+	} else if (CANT_HAPPEN(stuck != SHP_STUCK_NOT)) {
+	    mpr(actor, "%s can't go to %s & stays in %s\n",
+		prship(&mlp->unit.ship), xyas(newx, newy, actor),
+		xyas(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, actor));
+	    shp_nav_put_one(mlp);
+	    continue;
 	}
 
 	if (mlp->mobil <= 0.0) {
-	    shp_stays(actor, "is out of mobility", mlp);
+	    mpr(actor, "%s is out of mobility & stays in %s\n",
+		prship(&mlp->unit.ship),
+		xyas(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, actor));
+	    shp_nav_put_one(mlp);
 	    continue;
 	}
 	mobcost = shp_mobcost(&mlp->unit.ship);
@@ -783,44 +874,27 @@ shp_nav_one_sector(struct emp_qelem *list, int dir, natid actor,
 	}
 	mlp->unit.ship.shp_mobil = (int)mlp->mobil;
 	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
-
-	/* Now update the map for this ship */
-	tech = techfact(mlp->unit.ship.shp_tech,
-			((struct mchrstr *)mlp->chrp)->m_vrnge);
-	rad_map_set(mlp->unit.ship.shp_own,
-		    mlp->unit.ship.shp_x, mlp->unit.ship.shp_y,
-		    mlp->unit.ship.shp_effic, (int)tech);
     }
-    if (QEMPTY(list))
-	return stopping;
-    stopping |= shp_sweep(list, 0, 0, actor);
+
+    return 0;
+}
+
+int
+shp_nav_gauntlet(struct emp_qelem *list, int interdict, natid actor)
+{
+    struct ulist *mlp = (struct ulist *)list->q_back;
+    coord newx = mlp->unit.ship.shp_x;
+    coord newy = mlp->unit.ship.shp_y;
+    int stopping;
+
+    stopping = shp_sweep(list, 0, 0, actor);
     if (QEMPTY(list))
 	return stopping;
     stopping |= shp_check_mines(list);
     if (QEMPTY(list))
 	return stopping;
-
-    /* interdict ships sector by sector */
-    emp_initque(&done);
-    while (!QEMPTY(list)) {
-	mlp = (struct ulist *)list->q_back;
-	newx = mlp->unit.ship.shp_x;
-	newy = mlp->unit.ship.shp_y;
+    if (interdict)
 	stopping |= shp_interdict(list, newx, newy, actor);
-	/* move survivors in this sector to done */
-	for (qp = list->q_back; qp != list; qp = next) {
-	    next = qp->q_back;
-	    mlp = (struct ulist *)qp;
-	    if (mlp->unit.ship.shp_x == newx &&
-		mlp->unit.ship.shp_y == newy) {
-		emp_remque(qp);
-		emp_insque(qp, &done);
-	    }
-	}
-    }
-    /* assign surviving ships back to list */
-    emp_insque(list, &done);
-    emp_remque(&done);
 
     return stopping;
 }
@@ -851,7 +925,7 @@ shp_missile_defense(coord dx, coord dy, natid bombown, int hardtarget)
 	if (!(mchr[(int)ship.shp_type].m_flags & M_ANTIMISSILE))
 	    continue;
 
-	if (getrel(getnatp(ship.shp_own), bombown) >= NEUTRAL)
+	if (relations_with(ship.shp_own, bombown) >= NEUTRAL)
 	    continue;
 
 	if (ship.shp_effic < 60)
@@ -872,11 +946,8 @@ shp_missile_defense(coord dx, coord dy, natid bombown, int hardtarget)
 	teff = ship.shp_tech / (ship.shp_tech + 200.0);
 	/* raise 4.5 for better interception -KHS */
 	hitchance = (int)(gun * eff * teff * 4.5) - hardtarget;
-	if (hitchance < 0)
-	    hitchance = 0;
-	if (hitchance > 100)
-	    hitchance = 100;
-	hit = roll(100) <= hitchance;
+	hitchance = LIMIT_TO(hitchance, 0, 100);
+	hit = pct_chance(hitchance);
 
 	mpr(bombown, "%s anti-missile system activated...%s\n",
 	    cname(ship.shp_own),
@@ -905,12 +976,7 @@ shp_missdef(struct shpstr *sp, natid victim)
     char buf[512];
 
     emp_initque(&list);
-
-    mlp = malloc(sizeof(struct ulist));
-    mlp->chrp = (struct empobj_chr *)&mchr[(int)sp->shp_type];
-    mlp->unit.ship = *sp;
-    mlp->mobil = sp->shp_mobil;
-    emp_insque(&mlp->queue, &list);
+    mlp = shp_insque(sp, &list);
     sprintf(buf, "%s", prship(&mlp->unit.ship));
 
     eff = sp->shp_effic;