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

diff --git a/src/lib/subs/shpsub.c b/src/lib/subs/shpsub.c
index bafa098a1..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-2006, 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/>.
  *
  *  ---
  *
@@ -26,230 +25,268 @@
  *  ---
  *
  *  shpsub.c: Ship subroutine stuff
- * 
+ *
  *  Known contributors to this file:
  *     Ken Stevens, 1995
  *     Steve McClure, 1996-2000
+ *     Markus Armbruster, 2006-2015
  */
 
 #include <config.h>
 
-#include <math.h>
+#include <stdlib.h>
+#include "chance.h"
+#include "damage.h"
+#include "empobj.h"
+#include "file.h"
+#include "map.h"
 #include "misc.h"
-#include "queue.h"
-#include "player.h"
-#include "sect.h"
-#include "ship.h"
-#include "plane.h"
-#include "land.h"
+#include "mission.h"
 #include "news.h"
-#include "item.h"
-#include "xy.h"
 #include "nsc.h"
-#include "file.h"
-#include "nat.h"
-#include "path.h"
-#include "mission.h"
 #include "optlist.h"
-#include "damage.h"
-#include "server.h"
+#include "path.h"
+#include "player.h"
 #include "prototypes.h"
+#include "queue.h"
+#include "server.h"
+#include "unit.h"
+#include "xy.h"
 
-static int shp_check_one_mines(struct mlist *);
-static int shp_hit_mine(struct shpstr *, struct mchrstr *);
-static void shp_mess(char *, struct mlist *);
+static void shp_nav_put_one(struct ulist *);
+static int shp_check_one_mines(struct ulist *);
+static int shp_hit_mine(struct shpstr *);
 
-void
-shp_sel(struct nstr_item *ni, struct emp_qelem *list)
+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     wantflags;
-       int      nowantflags;
-     */
+int
+shp_may_nav(struct shpstr *sp, struct shpstr *flg, char *suffix)
 {
-    struct shpstr ship;
-    struct mchrstr *mcp;
-    struct mlist *mlp;
+    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, *flg = NULL;
+    struct ulist *mlp;
 
     emp_initque(list);
     while (nxtitem(ni, &ship)) {
-	if (!player->owner)
-	    continue;
-	mcp = &mchr[(int)ship.shp_type];
-	/* if (wantflags && (mcp->m_flags & wantflags) != wantflags)
-	   continue;
-	   if (nowantflags && mcp->m_flags & nowantflags)
-	   continue;
+	/*
+	 * It would be nice to let deities navigate foreign ships, but
+	 * much of the code assumes that only the ship's owner can
+	 * navigate it.
 	 */
-	if (opt_MARKET) {
-	    if (ontradingblock(EF_SHIP, &ship)) {
-		pr("ship #%d inelligible - it's for sale.\n",
-		   ship.shp_uid);
-		continue;
-	    }
-	}
-	/* This abuse is better fixed by building a ship with the normal negative
-	   mobility that everything else is built with */
-/*
-	if (opt_MOB_ACCESS) {
-	  if (ship.shp_effic < 21 &&
-	    ship.shp_mobil < etu_per_update) {
-	    pr("%s needs at least %d mob to navigate.\n",
-	       prship(&ship), etu_per_update);
+	if (!ship.shp_own || ship.shp_own != player->cnum)
 	    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 mlist));
-	mlp->mcp = mcp;
-	mlp->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 mlist *mlp;
-    struct sctstr sect;
-    struct shpstr ship;
-    coord allx;
-    coord ally;
-    int first = 1;
+    struct ulist *mlp;
+    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 mlist *)qp;
-	getship(mlp->ship.shp_uid, &ship);
-	if (ship.shp_own != actor) {
+	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(&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_pending) {
-		shp_mess("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_mess("is crewless", mlp);
-	    continue;
-	}
-	if (!getsect(ship.shp_x, ship.shp_y, &sect)) {
-	    shp_mess("was sucked into the sky by a strange looking spaceship", mlp);	/* heh -KHS */
-	    continue;
-	}
-	switch (shp_check_nav(&sect, &ship)) {
-	case CN_CONSTRUCTION:
-	    shp_mess("is caught in a construction zone", mlp);
-	    continue;
-	case CN_LANDLOCKED:
-	    shp_mess("is landlocked", mlp);
-	    continue;
-	case CN_NAVIGABLE:
-	    break;
-	case CN_ERROR:
-	default:
-	    shp_mess("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->ship = ship;
     }
 }
 
 void
-shp_put(struct emp_qelem *list, natid actor)
+shp_nav_put(struct emp_qelem *list, natid actor)
 {
-    struct emp_qelem *qp;
-    struct emp_qelem *newqp;
-    struct mlist *mlp;
-
-    qp = list->q_back;
-    while (qp != list) {
-	mlp = (struct mlist *)qp;
-	mpr(actor, "%s stopped at %s\n", prship(&mlp->ship),
-	    xyas(mlp->ship.shp_x, mlp->ship.shp_y, mlp->ship.shp_own));
-	mlp->ship.shp_mobil = (int)mlp->mobil;
-	putship(mlp->ship.shp_uid, &mlp->ship);
-	newqp = qp->q_back;
-	emp_remque(qp);
-	free(qp);
-	qp = newqp;
+    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, natid actor)
+shp_sweep(struct emp_qelem *ship_list, int explicit, int takemob,
+	  natid actor)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     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 mlist *)qp;
-	if (!(mlp->mcp->m_flags & M_SWEEP)) {
-	    if (verbose)
-		mpr(actor, "%s doesn't have minesweeping capability!\n",
-		    prship(&mlp->ship));
-	    continue;
-	}
-	if (mlp->mobil <= 0.0) {
-	    if (verbose)
-		mpr(actor, "%s is out of mobility!\n", prship(&mlp->ship));
-	    continue;
-	}
-	getsect(mlp->ship.shp_x, mlp->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->ship));
-	    continue;
+	mlp = (struct ulist *)qp;
+	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;
 	}
-	mlp->mobil -= shp_mobcost(&mlp->ship);
-	mlp->ship.shp_mobil = (int)mlp->mobil;
-	putship(mlp->ship.shp_uid, &mlp->ship);
+	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 = mlp->mcp->m_item[I_SHELL];
-	shells = mlp->ship.shp_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);
@@ -257,14 +294,10 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, natid actor)
 	    }
 	}
 	sect.sct_mines = mines;
-	mlp->ship.shp_item[I_SHELL] = shells;
-	if (shp_check_one_mines(mlp)) {
-	    stopping = 1;
-	    emp_remque(qp);
-	    free(qp);
-	}
-	putship(mlp->ship.shp_uid, &mlp->ship);
+	mlp->unit.ship.shp_item[I_SHELL] = shells;
+	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
 	putsect(&sect);
+	stopping |= shp_check_one_mines(mlp);
     }
     if (changed)
 	writemap(actor);
@@ -272,26 +305,29 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, natid actor)
 }
 
 static int
-shp_check_one_mines(struct mlist *mlp)
+shp_check_one_mines(struct ulist *mlp)
 {
     struct sctstr sect;
     int actor;
 
-    getsect(mlp->ship.shp_x, mlp->ship.shp_y, &sect);
+    getsect(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y, &sect);
     if (sect.sct_type != SCT_WATER)
 	return 0;
     if (!sect.sct_mines)
 	return 0;
     if (chance(DMINE_HITCHANCE(sect.sct_mines))) {
-	actor = mlp->ship.shp_own;
-	shp_hit_mine(&mlp->ship, mlp->mcp);
+	actor = mlp->unit.ship.shp_own;
+	shp_hit_mine(&mlp->unit.ship);
 	sect.sct_mines--;
 	if (map_set(actor, sect.sct_x, sect.sct_y, 'X', 0))
 	    writemap(actor);
 	putsect(&sect);
-	putship(mlp->ship.shp_uid, &mlp->ship);
-	if (!mlp->ship.shp_own)
-	    return 1;
+	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
+	if (!mlp->unit.ship.shp_own) {
+	    emp_remque(&mlp->queue);
+	    free(mlp);
+	}
+	return 1;
     }
     return 0;
 }
@@ -301,91 +337,44 @@ shp_check_mines(struct emp_qelem *ship_list)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
     int stopping = 0;
 
     for (qp = ship_list->q_back; qp != ship_list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct mlist *)qp;
-	if (shp_check_one_mines(mlp)) {
-	    stopping = 1;
-	    emp_remque(qp);
-	    free(qp);
-	}
+	stopping |= shp_check_one_mines((struct ulist *)qp);
     }
     return stopping;
 }
 
-void
-shp_list(struct emp_qelem *ship_list)
-{
-    struct emp_qelem *qp;
-    struct emp_qelem *next;
-    struct mlist *mlp;
-    struct shpstr *shp;
-
-    pr("shp#     ship type       x,y   fl  eff mil  sh gun pn he xl ln mob tech\n");
-
-    for (qp = ship_list->q_back; qp != ship_list; qp = next) {
-	next = qp->q_back;
-	mlp = (struct mlist *)qp;
-	shp = &mlp->ship;
-	pr("%4d ", shp->shp_uid);
-	pr("%-16.16s ", mlp->mcp->m_name);
-	prxy("%4d,%-4d ", shp->shp_x, shp->shp_y, mlp->ship.shp_own);
-	pr("%c", shp->shp_fleet);
-	pr("%4d%%", shp->shp_effic);
-	pr("%4d", shp->shp_item[I_MILIT]);
-	pr("%4d", shp->shp_item[I_SHELL]);
-	pr("%4d", shp->shp_item[I_GUN]);
-	count_planes(shp);
-	pr("%3d", shp->shp_nplane);
-	pr("%3d", shp->shp_nchoppers);
-	pr("%3d", shp->shp_nxlight);
-	count_units(shp);
-	pr("%3d", shp->shp_nland);
-	pr("%4d", shp->shp_mobil);
-	pr("%4d\n", shp->shp_tech);
-    }
-}
-
-static void
-shp_mess(char *str, struct mlist *mlp)
-{
-    mpr(mlp->ship.shp_own, "%s %s & stays in %s\n",
-	prship(&mlp->ship),
-	str, xyas(mlp->ship.shp_x, mlp->ship.shp_y, mlp->ship.shp_own));
-    mlp->ship.shp_mobil = (int)mlp->mobil;
-    putship(mlp->ship.shp_uid, &mlp->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
@@ -393,6 +382,7 @@ sect_has_dock(struct sctstr *sect)
 {
     switch (dchr[sect->sct_type].d_nav) {
     case NAV_02:
+    case NAV_CANAL:
 	return 1;
     default:
 	return 0;
@@ -405,17 +395,19 @@ shp_count(struct emp_qelem *list, int wantflags, int nowantflags,
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     int count = 0;
 
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct mlist *)qp;
-	if (mlp->ship.shp_x != x || mlp->ship.shp_y != y)
+	mlp = (struct ulist *)qp;
+	if (mlp->unit.ship.shp_x != x || mlp->unit.ship.shp_y != y)
 	    continue;
-	if (wantflags && (mlp->mcp->m_flags & wantflags) != wantflags)
+	if (wantflags &&
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
 	++count;
     }
@@ -423,12 +415,14 @@ shp_count(struct emp_qelem *list, int wantflags, int nowantflags,
 }
 
 static void
-shp_damage_one(struct mlist *mlp, int dam)
+shp_damage_one(struct ulist *mlp, int dam)
 {
-    shipdamage(&mlp->ship, dam);
-    putship(mlp->ship.shp_uid, &mlp->ship);
-    if (!mlp->ship.shp_own) {
-	emp_remque((struct emp_qelem *)mlp);
+    /* ship might have changed (launched interceptors, missile defense) */
+    getship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
+    shipdamage(&mlp->unit.ship, dam);
+    putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
+    if (!mlp->unit.ship.shp_own) {
+	emp_remque(&mlp->queue);
 	free(mlp);
     }
 }
@@ -439,7 +433,7 @@ shp_damage(struct emp_qelem *list, int totdam, int wantflags,
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     int dam;
     int count;
 
@@ -449,12 +443,14 @@ shp_damage(struct emp_qelem *list, int totdam, int wantflags,
     dam = ldround((double)totdam / count, 1);
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct mlist *)qp;
-	if (mlp->ship.shp_x != x || mlp->ship.shp_y != y)
+	mlp = (struct ulist *)qp;
+	if (mlp->unit.ship.shp_x != x || mlp->unit.ship.shp_y != y)
 	    continue;
-	if (wantflags && (mlp->mcp->m_flags & wantflags) != wantflags)
+	if (wantflags &&
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
 	shp_damage_one(mlp, dam);
     }
@@ -467,47 +463,52 @@ shp_contains(struct emp_qelem *list, int newx, int newy, int wantflags,
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
 
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct mlist *)qp;
+	mlp = (struct ulist *)qp;
 /* If the ship isn't in the requested sector, then continue */
-	if (newx != mlp->ship.shp_x || newy != mlp->ship.shp_y)
+	if (newx != mlp->unit.ship.shp_x || newy != mlp->unit.ship.shp_y)
 	    continue;
-	if (wantflags && (mlp->mcp->m_flags & wantflags) != wantflags)
+	if (wantflags &&
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
 	return 1;
     }
     return 0;
 }
 
-static struct mlist *
-most_valuable_ship(struct emp_qelem *list)
+static struct ulist *
+most_valuable_ship(struct emp_qelem *list, coord x, coord y)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
-    struct mlist *mvs = 0;
+    struct ulist *mlp;
+    struct ulist *mvs = NULL;
 
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct mlist *)qp;
-	if (mlp->mcp->m_flags & M_SUB)
+	mlp = (struct ulist *)qp;
+	if (mlp->unit.ship.shp_x != x || mlp->unit.ship.shp_y != y)
+	    continue;
+	if (mchr[mlp->unit.ship.shp_type].m_flags & M_SUB)
 	    continue;
-	if (!mlp->mcp->m_nxlight &&
-	    !mlp->mcp->m_nchoppers &&
-	    mlp->mcp->m_cost < 1000 &&
-	    !mlp->mcp->m_nplanes && !mlp->mcp->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 (mlp->mcp->m_cost * mlp->ship.shp_effic >
-	    mvs->mcp->m_cost * mvs->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;
@@ -518,19 +519,21 @@ shp_easiest_target(struct emp_qelem *list, int wantflags, int nowantflags)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     int hard;
     int easiest = 9876;		/* things start great for victim */
     int count = 0;
 
     for (qp = list->q_back; qp != list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct mlist *)qp;
-	if (wantflags && (mlp->mcp->m_flags & wantflags) != wantflags)
+	mlp = (struct ulist *)qp;
+	if (wantflags &&
+	    (mchr[mlp->unit.ship.shp_type].m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    mchr[mlp->unit.ship.shp_type].m_flags & nowantflags)
 	    continue;
-	hard = shp_hardtarget(&mlp->ship);
+	hard = shp_hardtarget(&mlp->unit.ship);
 	if (hard < easiest)
 	    easiest = hard;	/* things get worse for victim */
 	++count;
@@ -542,38 +545,46 @@ static int
 shp_missile_interdiction(struct emp_qelem *list, coord newx, coord newy,
 			 natid victim)
 {
-    int dam;
-    int twotries;
+    int dam, sublaunch;
     int stopping = 0;
     struct emp_qelem msl_list, *qp, *newqp;
-    struct mlist *mvs;
-    char what[512];
+    struct plist *plp;
+    struct ulist *mvs;
+
+    mvs = most_valuable_ship(list, newx, newy);
+    if (!mvs)
+	return 0;
 
     msl_sel(&msl_list, newx, newy, victim, P_T | P_MAR, 0, MI_INTERDICT);
 
-    twotries = 0;
-    while (!QEMPTY(&msl_list) && (mvs = most_valuable_ship(list))) {
-	sprintf(what, "%s", prship(&mvs->ship));
-	dam = msl_launch_mindam(&msl_list, newx, newy,
-				shp_hardtarget(&mvs->ship),
-				EF_SHIP, 1, what, victim, MI_INTERDICT);
-	if (dam) {
-	    mpr(victim,
-		"missile interdiction mission does %d damage to %s!\n",
-		dam, what);
-	    shp_damage_one(mvs, dam);
-	    twotries = 0;
-	    stopping |= 1;
-	} else if (++twotries >= 2) {
-	    break;
+    for (qp = msl_list.q_back; qp != &msl_list; qp = newqp) {
+	newqp = qp->q_back;
+	plp = (struct plist *)qp;
+
+	if (mvs && mission_pln_equip(plp, NULL, 'p') >= 0) {
+	    if (msl_launch(&plp->plane, EF_SHIP, prship(&mvs->unit.ship),
+			   newx, newy, victim, &sublaunch) < 0)
+		goto use_up_msl;
+	    stopping = 1;
+	    if (msl_hit(&plp->plane,
+			shp_hardtarget(&mvs->unit.ship), EF_SHIP,
+			N_SHP_MISS, N_SHP_SMISS, sublaunch, victim)) {
+		dam = pln_damage(&plp->plane, 'p', 1);
+		mpr(victim,
+		    "missile interdiction mission does %d damage to %s!\n",
+		    dam, prship(&mvs->unit.ship));
+		shp_damage_one(mvs, dam);
+	    } else {
+		dam = pln_damage(&plp->plane, 'p', 0);
+		collateral_damage(newx, newy, dam);
+	    }
+	    mvs = most_valuable_ship(list, newx, newy);
+	use_up_msl:
+	    plp->plane.pln_effic = 0;
+	    putplane(plp->plane.pln_uid, &plp->plane);
 	}
-    }
-    qp = msl_list.q_forw;
-    while (qp != msl_list.q_forw) {
-	newqp = qp->q_forw;
 	emp_remque(qp);
 	free(qp);
-	qp = newqp;
     }
 
     return stopping;
@@ -588,7 +599,7 @@ notify_coastguard(struct emp_qelem *list, int trange, struct sctstr *sectp)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     struct natstr *natp;
     int vrange;
 
@@ -605,17 +616,18 @@ 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 mlist *)qp;
-	if (mlp->mcp->m_flags & M_SUB)
+	mlp = (struct ulist *)qp;
+	if (mchr[mlp->unit.ship.shp_type].m_flags & M_SUB)
 	    continue;
 	if (natp->nat_flags & NF_COASTWATCH)
 	    wu(0, sectp->sct_own,
 	       "%s %s sighted at %s\n",
-	       cname(mlp->ship.shp_own),
-	       prship(&mlp->ship),
-	       xyas(mlp->ship.shp_x, mlp->ship.shp_y, sectp->sct_own));
+	       cname(mlp->unit.ship.shp_own),
+	       prship(&mlp->unit.ship),
+	       xyas(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y,
+		    sectp->sct_own));
 	if (opt_HIDDEN)
-	    setcont(sectp->sct_own, mlp->ship.shp_own, FOUND_COAST);
+	    setcont(sectp->sct_own, mlp->unit.ship.shp_own, FOUND_COAST);
     }
 
     return 1;
@@ -628,16 +640,15 @@ shp_fort_interdiction(struct emp_qelem *list, coord newx, coord newy,
     struct nstr_sect ns;
     struct sctstr fsect;
     int trange, range;
-    double guneff;
-    int shell, gun;
     int dam;
+    int stopping = 0;
     int totdam = 0;
     signed char notified[MAXNOC];
     int i;
 
     /* 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;
@@ -659,42 +670,28 @@ 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);
     while (nxtsct(&ns, &fsect)) {
 	if (!notified[fsect.sct_own])
 	    continue;
-	gun = fsect.sct_item[I_GUN];
-	if (gun < 1)
-	    continue;
 	range = roundrange(fortrange(&fsect));
 	trange = mapdist(newx, newy, fsect.sct_x, fsect.sct_y);
 	if (trange > range)
 	    continue;
-	if (fsect.sct_item[I_MILIT] < 5)
-	    continue;
-	shell = fsect.sct_item[I_SHELL];
-	if (shell < 1)
-	    shell += supply_commod(fsect.sct_own, fsect.sct_x, fsect.sct_y,
-				   I_SHELL, 1);
-	if (shell < 1)
-	    continue;
-	shell--;
-	fsect.sct_item[I_SHELL] = shell;
+	dam = fort_fire(&fsect);
 	putsect(&fsect);
-	if (gun > 7)
-	    gun = 7;
-	guneff = landgun((int)fsect.sct_effic, gun);
-	dam = (int)guneff;
+	if (dam < 0)
+	    continue;
+	stopping = 1;
 	totdam += dam;
 	mpr(victim, "Incoming fire does %d damage!\n", dam);
-/*
-  mpr(victim, "%s fires at you for %d!\n",
-  xyas(fsect.sct_x,fsect.sct_y,victim),
-  dam);
-*/
+#if 0
+	mpr(victim, "%s fires at you for %d!\n",
+	    xyas(fsect.sct_x, fsect.sct_y, victim), dam);
+#endif
 	wu(0, fsect.sct_own,
 	   "%s fires at %s ships in %s for %d!\n",
 	   xyas(fsect.sct_x, fsect.sct_y,
@@ -703,8 +700,26 @@ shp_fort_interdiction(struct emp_qelem *list, coord newx, coord newy,
 	nreport(fsect.sct_own, N_SHP_SHELL, victim, 1);
     }
     if (totdam > 0)
-	return shp_damage(list, totdam, 0, M_SUB, newx, newy);
-    return 0;
+	shp_damage(list, totdam, 0, M_SUB, newx, newy);
+    return stopping;
+}
+
+static int
+shp_mission_interdiction(struct emp_qelem *list, coord x, coord y,
+			 natid victim, int subs)
+{
+    char *what = subs ? "subs" : "ships";
+    int wantflags = subs ? M_SUB : 0;
+    int nowantflags = subs ? 0 : M_SUB;
+    int mission = subs ? MI_SINTERDICT : MI_INTERDICT;
+    int dam;
+
+    dam = unit_interdict(x, y, victim, what,
+			 shp_easiest_target(list, wantflags, nowantflags),
+			 mission);
+    if (dam >= 0)
+	shp_damage(list, dam, wantflags, nowantflags, x, y);
+    return dam >= 0;
 }
 
 static int
@@ -716,26 +731,12 @@ shp_interdict(struct emp_qelem *list, coord newx, coord newy, natid victim)
 	stopping |= shp_fort_interdiction(list, newx, newy, victim);
 
 	if (shp_contains(list, newx, newy, 0, M_SUB)) {
-	    stopping |=
-		shp_damage(list,
-			   unit_interdict(newx, newy, victim, "ships",
-					  shp_easiest_target(list, 0, M_SUB),
-					  MI_INTERDICT),
-			   0, M_SUB, newx, newy);
-	    if (most_valuable_ship(list)) {
-		stopping |=
-		    shp_missile_interdiction(list, newx, newy, victim);
-	    }
+	    stopping |= shp_mission_interdiction(list, newx, newy, victim, 0);
+	    stopping |= shp_missile_interdiction(list, newx, newy, victim);
 	}
     }
-    if (shp_contains(list, newx, newy, M_SUB, 0)) {
-	stopping |=
-	    shp_damage(list,
-		       unit_interdict(newx, newy, victim, "subs",
-				      shp_easiest_target(list, M_SUB, 0),
-				      MI_SINTERDICT),
-		       M_SUB, 0, newx, newy);
-    }
+    if (shp_contains(list, newx, newy, M_SUB, 0))
+	stopping |= shp_mission_interdiction(list, newx, newy, victim, 1);
     return stopping;
 }
 
@@ -747,17 +748,17 @@ shp_hardtarget(struct shpstr *sp)
     int vis, onsea;
     struct mchrstr *mcp = mchr + sp->shp_type;
 
-    vis = sp->shp_visib;
+    vis = shp_visib(sp);
     getsect(sp->shp_x, sp->shp_y, &sect);
     onsea = sect.sct_type == SCT_WATER;
     if (mcp->m_flags & M_SUB)
 	vis *= 4;
     return (int)((sp->shp_effic / 100.0) *
-		 (20 + sp->shp_speed * onsea / 2.0 - vis));
+		 (20 + shp_speed(sp) * onsea / 2.0 - vis));
 }
 
 static int
-shp_hit_mine(struct shpstr *sp, struct mchrstr *mcp)
+shp_hit_mine(struct shpstr *sp)
 {
     double m;
 
@@ -767,7 +768,7 @@ shp_hit_mine(struct shpstr *sp, struct mchrstr *mcp)
     nreport(sp->shp_own, N_HIT_MINE, 0, 1);
 
     m = MINE_DAMAGE();
-    if (mcp->m_flags & M_SWEEP)
+    if (mchr[sp->shp_type].m_flags & M_SWEEP)
 	m /= 2.0;
 
     shipdamage(sp, ldround(m, 1));
@@ -775,145 +776,135 @@ shp_hit_mine(struct shpstr *sp, struct mchrstr *mcp)
     return (int)m;
 }
 
-void
-shp_view(struct emp_qelem *list)
-{
-    struct sctstr sect;
-    struct emp_qelem *qp;
-    struct emp_qelem *next;
-    struct mlist *mlp;
-
-    for (qp = list->q_back; qp != list; qp = next) {
-	next = qp->q_back;
-	mlp = (struct mlist *)qp;
-	getsect(mlp->ship.shp_x, mlp->ship.shp_y, &sect);
-	if (mlp->mcp->m_flags & M_FOOD)
-	    mpr(mlp->ship.shp_own, "[fert:%d] ", sect.sct_fertil);
-	if (mlp->mcp->m_flags & M_OIL)
-	    mpr(mlp->ship.shp_own, "[oil:%d] ", sect.sct_oil);
-	mpr(mlp->ship.shp_own, "%s @ %s %d%% %s\n",
-	    prship(&mlp->ship),
-	    xyas(mlp->ship.shp_x, mlp->ship.shp_y, player->cnum),
-	    sect.sct_effic, dchr[sect.sct_type].d_name);
-    }
-}
-
 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 mlist *mlp;
-    struct emp_qelem done;
+    struct ulist *mlp;
     coord dx;
     coord dy;
     coord newx;
     coord newy;
-    int stopping = 0;
+    int move;
+    enum shp_stuck stuck;
     double mobcost;
-    double tech;		/* for mapping */
-    double tf;			/* for mapping */
-    char dp[80];
-    int navigate;
 
-    if (dir <= DIR_STOP || dir >= DIR_VIEW) {
-	shp_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 mlist *)qp;
-	newx = xnorm(mlp->ship.shp_x + dx);
-	newy = ynorm(mlp->ship.shp_y + dy);
-	getsect(newx, newy, &sect);
-	navigate = shp_check_nav(&sect, &mlp->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 &&
-		!(mlp->mcp->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_mess(dp, mlp);
-		continue;
-	    }
+	mlp = (struct ulist *)qp;
+	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_mess("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->ship);
-	mlp->ship.shp_x = newx;
-	mlp->ship.shp_y = newy;
+	mobcost = shp_mobcost(&mlp->unit.ship);
+	mlp->unit.ship.shp_x = newx;
+	mlp->unit.ship.shp_y = newy;
 	if (mlp->mobil - mobcost < -127) {
 	    mlp->mobil = -127;
 	} else {
 	    mlp->mobil -= mobcost;
 	}
-	mlp->ship.shp_mobil = (int)mlp->mobil;
-	putship(mlp->ship.shp_uid, &mlp->ship);
-
-	/* Now update the map for this ship */
-	tech = techfact(mlp->ship.shp_tech, mlp->mcp->m_vrnge);
-	if (mlp->mcp->m_flags & M_SONAR)
-	    tf = techfact(mlp->ship.shp_tech, 1.0);
-	else
-	    tf = 0.0;
-	radmapupd(mlp->ship.shp_own, mlp->ship.shp_x, mlp->ship.shp_y,
-		  (int)mlp->ship.shp_effic, (int)tech, tf);
+	mlp->unit.ship.shp_mobil = (int)mlp->mobil;
+	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
     }
-    if (QEMPTY(list))
-	return stopping;
-    stopping |= shp_sweep(list, 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 mlist *)list->q_back;
-	newx = mlp->ship.shp_x;
-	newy = mlp->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 mlist *)qp;
-	    if (mlp->ship.shp_x == newx && mlp->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;
 }
 
 /*
- * shp_miss_defence 
- * Check for incoming missiles with a P_MAR flag. 
+ * shp_miss_defence
+ * Check for incoming missiles with a P_MAR flag.
  * Return True=1 if the missile was shotdown.
  * Or False=0
- * 
+ *
  * Chad Zabel, July 95
  */
 
@@ -922,8 +913,7 @@ shp_missile_defense(coord dx, coord dy, natid bombown, int hardtarget)
 {
     struct nstr_item ni;
     struct shpstr ship;
-    int hitchance;
-    int shell;
+    int hitchance, hit;
     double gun, eff, teff;
 
     snxtitem_dist(&ni, EF_SHIP, dx, dy, 1);
@@ -935,121 +925,73 @@ 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)
 	    continue;
 
-	shell = ship.shp_item[I_SHELL];
 	if (ship.shp_item[I_MILIT] < 1)	/* do we have mil? */
 	    continue;
-	if (shell < 2) {	/* do we need shells */
-	    shell += supply_commod(ship.shp_own, ship.shp_x, ship.shp_y,
-				   I_SHELL, 2);
-	    if (shell < 2)
-		continue;
-	}
 	if (ship.shp_item[I_GUN] < 1)	/* we need at least 1 gun */
 	    continue;
+	if (!shp_supply(&ship, I_SHELL, 2))
+	    continue;
+	ship.shp_item[I_SHELL] -= 2;
+	putship(ship.shp_uid, &ship);
 
 	/* now calculate the odds */
-	gun = MIN(ship.shp_item[I_GUN], ship.shp_glim);
+	gun = shp_usable_guns(&ship);
 	eff = ship.shp_effic / 100.0;
 	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;
+	hitchance = LIMIT_TO(hitchance, 0, 100);
+	hit = pct_chance(hitchance);
 
-	mpr(bombown, "%s anti-missile system activated...",
-	    cname(ship.shp_own));
+	mpr(bombown, "%s anti-missile system activated...%s\n",
+	    cname(ship.shp_own),
+	    hit ? "KABOOOM!! Missile destroyed\n"
+	    : "SWOOSH!!  anti-missile system failed!!");
 	mpr(ship.shp_own, "Ship #%i anti-missile system activated!\n",
 	    ship.shp_uid);
-	mpr(ship.shp_own, "%d%% hitchance...", hitchance);
-	/* use ammo */
-	ship.shp_item[I_SHELL] = shell - 2;
-	putship(ship.shp_uid, &ship);
+	mpr(ship.shp_own, "%d%% hitchance...%s\n", hitchance,
+	    hit ? "KABOOOM!!  Incoming missile destroyed!\n"
+	    : "SWOOSH!!  Missile evades anti-missile systems\n");
 
-	if (roll(100) <= hitchance) {
-	    mpr(bombown, "KABOOOM!! Missile destroyed\n\n");
-	    mpr(ship.shp_own,
-		"KABOOOM!!  Incoming missile destroyed!\n\n");
+	if (hit)
 	    return 1;
-	} else {
-	    mpr(bombown, "SWOOSH!!  anti-missile system failed!!\n");
-	    mpr(ship.shp_own,
-		"SWOOSH!!  Missile evades anti-missile systems\n\n");
-	}
     }
     return 0;			/* all attempts failed */
 }
 
-char *
-shp_path(int together, struct shpstr *shp, char *buf)
-{
-    coord destx;
-    coord desty;
-    struct sctstr d_sect;
-    char *cp;
-
-    if (!sarg_xy(buf, &destx, &desty))
-	return 0;
-    if (!together) {
-	mpr(shp->shp_own,
-	    "Cannot go to a destination sector if not all starting in the same sector\n");
-	return 0;
-    }
-    if (!getsect(destx, desty, &d_sect)) {
-	mpr(shp->shp_own, "%d,%d is not a sector\n", destx, desty);
-	return 0;
-    }
-
-    cp = BestShipPath(buf, shp->shp_x, shp->shp_y,
-		      d_sect.sct_x, d_sect.sct_y, player->cnum);
-    if (!cp || shp->shp_mobil <= 0) {
-	mpr(shp->shp_own, "Can't get to '%s' right now.\n",
-	    xyas(d_sect.sct_x, d_sect.sct_y, player->cnum));
-	return 0;
-    }
-    return cp;
-}
 
 /* Fire missiles at a ship which has fired shells */
 void
 shp_missdef(struct shpstr *sp, natid victim)
 {
     struct emp_qelem list;
-    struct mlist *mlp;
+    struct ulist *mlp;
     int eff;
     char buf[512];
 
     emp_initque(&list);
-
-    mlp = malloc(sizeof(struct mlist));
-    mlp->mcp = &mchr[(int)sp->shp_type];
-    mlp->ship = *sp;
-    mlp->mobil = sp->shp_mobil;
-    emp_insque(&mlp->queue, &list);
-    sprintf(buf, "%s", prship(&mlp->ship));
+    mlp = shp_insque(sp, &list);
+    sprintf(buf, "%s", prship(&mlp->unit.ship));
 
     eff = sp->shp_effic;
-    if (most_valuable_ship(&list)) {
-	shp_missile_interdiction(&list, sp->shp_x, sp->shp_y, sp->shp_own);
-	getship(sp->shp_uid, sp);
-
-	if (!sp->shp_own) {
-	    wu(0, victim,
-	       "missiles launched in defense did 100%% damage to %s\n",
-	       buf);
-	    wu(0, victim, "%s sunk!\n", buf);
-	} else if (eff > 0 && sp->shp_effic < eff) {
-	    wu(0, victim,
-	       "missiles launched in defense did %d%% damage to %s\n",
-	       100 * (eff - sp->shp_effic) / eff, buf);
-	}
+    shp_missile_interdiction(&list, sp->shp_x, sp->shp_y, sp->shp_own);
+    getship(sp->shp_uid, sp);
+
+    if (!sp->shp_own) {
+	wu(0, victim,
+	   "missiles launched in defense did 100%% damage to %s\n",
+	   buf);
+	wu(0, victim, "%s sunk!\n", buf);
+    } else if (eff > 0 && sp->shp_effic < eff) {
+	wu(0, victim,
+	   "missiles launched in defense did %d%% damage to %s\n",
+	   100 * (eff - sp->shp_effic) / eff, buf);
     }
     if (!QEMPTY(&list))
 	free(mlp);
@@ -1058,8 +1000,8 @@ shp_missdef(struct shpstr *sp, natid victim)
 double
 shp_mobcost(struct shpstr *sp)
 {
-    double effspd = sp->shp_effic * 0.01 * sp->shp_speed;
-    return 480.0 / (effspd + techfact(sp->shp_tech, effspd));
+    return speed_factor(sp->shp_effic * 0.01 * shp_speed(sp),
+			sp->shp_tech);
 }
 
 /*
@@ -1069,17 +1011,9 @@ void
 shp_set_tech(struct shpstr *sp, int tlev)
 {
     struct mchrstr *mcp = mchr + sp->shp_type;
-    int tech_diff = tlev - mcp->m_tech;
 
-    if (CANT_HAPPEN(tech_diff < 0)) {
-      tlev -= tech_diff;
-      tech_diff = 0;
-    }
+    if (CANT_HAPPEN(tlev < mcp->m_tech))
+	tlev = mcp->m_tech;
 
     sp->shp_tech = tlev;
-    sp->shp_armor = (short)SHP_DEF(mcp->m_armor, tech_diff);
-    sp->shp_speed = (short)SHP_SPD(mcp->m_speed, tech_diff);
-    sp->shp_visib = (short)SHP_VIS(mcp->m_visib, tech_diff);
-    sp->shp_frnge = (short)SHP_RNG(mcp->m_frnge, tech_diff);
-    sp->shp_glim  = (short)SHP_FIR(mcp->m_glim, tech_diff);
 }