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

diff --git a/src/lib/subs/shpsub.c b/src/lib/subs/shpsub.c
index c88593f1e..52c5afb65 100644
--- a/src/lib/subs/shpsub.c
+++ b/src/lib/subs/shpsub.c
@@ -1,6 +1,6 @@
 /*
  *  Empire - A multi-player, client/server Internet based war game.
- *  Copyright (C) 1986-2014, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ *  Copyright (C) 1986-2015, Dave Pare, Jeff Bailey, Thomas Ruschak,
  *                Ken Stevens, Steve McClure, Markus Armbruster
  *
  *  Empire is free software: you can redistribute it and/or modify
@@ -29,7 +29,7 @@
  *  Known contributors to this file:
  *     Ken Stevens, 1995
  *     Steve McClure, 1996-2000
- *     Markus Armbruster, 2006-2013
+ *     Markus Armbruster, 2006-2015
  */
 
 #include <config.h>
@@ -53,15 +53,73 @@
 #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);
@@ -73,106 +131,109 @@ shp_sel(struct nstr_item *ni, struct emp_qelem *list)
 	 */
 	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 shpstr *sp;
-    struct sctstr sect;
-    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;
 	sp = &mlp->unit.ship;
 	getship(sp->shp_uid, sp);
+
 	if (sp->shp_own != actor) {
 	    mpr(actor, "%s was sunk at %s\n",
 		prship(sp), xyas(sp->shp_x, sp->shp_y, actor));
-	    emp_remque((struct emp_qelem *)mlp);
+	    emp_remque(&mlp->queue);
 	    free(mlp);
 	    continue;
 	}
-	if (opt_SAIL) {
-	    if (*sp->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 (sp->shp_item[I_MILIT] == 0 && sp->shp_item[I_CIVIL] == 0) {
-	    shp_stays(actor, "is crewless", mlp);
-	    continue;
-	}
-	if (!getsect(sp->shp_x, sp->shp_y, &sect)) {
-	    shp_stays(actor, "was sucked into the sky by a strange looking spaceship", mlp);	/* heh -KHS */
-	    continue;
-	}
-	switch (shp_check_nav(sp, &sect)) {
-	case NAV_02:
-	case NAV_60:
-	    shp_stays(actor, "is caught in a construction zone", mlp);
-	    continue;
-	case NAV_NONE:
-	case NAV_CANAL:
-	    shp_stays(actor, "is landlocked", mlp);
-	    continue;
-	case NAVOK:
-	    break;
-	default:
-	    CANT_REACH();
-	    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 = sp->shp_x;
-	    ally = sp->shp_y;
-	    first = 0;
-	}
-	if (sp->shp_x != allx || sp->shp_y != ally)
-	    *togetherp = 0;
+
+	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;
     }
 }
 
+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;
@@ -180,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));
-	    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));
+	if (!(mchr[mlp->unit.ship.shp_type].m_flags & M_SWEEP))
 	    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);
@@ -225,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);
@@ -255,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;
 }
@@ -266,70 +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);
-}
-
 /*
- * Can SP navigate in SECTP?
- * Sector ownership is *not* considered!
- * Return NAVOK when yes.
- * Return NAV_02 when it could if the sector was at least 2% efficient.
- * Return NAV_60 when it could if the sector was at least 60% efficient.
- * Return NAV_CANAL when it lacks capability M_CANAL.
- * Return NAV_NONE when this sector type isn't navigable at all.
+ * Return whether and why SP would be stuck in SECTP.
  */
-enum d_navigation
+enum shp_stuck
 shp_check_nav(struct shpstr *sp, struct sctstr *sectp)
 {
     switch (dchr[sectp->sct_type].d_nav) {
     case NAVOK:
 	break;
     case NAV_CANAL:
-	if (mchr[sp->shp_type].m_flags & M_CANAL) {
-	    if (sectp->sct_effic < 2)
-		return NAV_02;
-	} else
-	    return NAV_CANAL;
-	break;
+	if (!(mchr[sp->shp_type].m_flags & M_CANAL)) {
+	    return SHP_STUCK_CANAL;
+	}
+	/* fall through */
     case NAV_02:
 	if (sectp->sct_effic < 2)
-	    return NAV_02;
+	    return SHP_STUCK_CONSTRUCTION;
 	break;
     case NAV_60:
 	if (sectp->sct_effic < 60)
-	    return NAV_60;
+	    return SHP_STUCK_CONSTRUCTION;
 	break;
     default:
 	CANT_REACH();
+	/* fall through */
     case NAV_NONE:
-	return NAV_NONE;
+	return SHP_STUCK_IMPASSABLE;
     }
-    return NAVOK;
+    return SHP_STUCK_NOT;
 }
 
 int
@@ -359,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;
     }
@@ -377,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);
     }
 }
@@ -402,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);
     }
@@ -427,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;
     }
@@ -450,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 *)mvs->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;
@@ -483,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)
@@ -572,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,
@@ -732,56 +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;
-    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(&mlp->unit.ship, &sect);
-	if (navigate != NAVOK ||
-	    (sect.sct_own
-	     && relations_with(sect.sct_own, actor) < FRIENDLY)) {
-	    if (navigate == NAV_CANAL)
-		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);
@@ -794,43 +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 */
-	rad_map_set(mlp->unit.ship.shp_own,
-		    mlp->unit.ship.shp_x, mlp->unit.ship.shp_y,
-		    mlp->unit.ship.shp_effic, mlp->unit.ship.shp_tech,
-		    ((struct mchrstr *)mlp->chrp)->m_vrnge);
     }
-    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;
 }
@@ -912,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;