X-Git-Url: http://git.pond.sub.org/?p=empserver;a=blobdiff_plain;f=src%2Flib%2Fsubs%2Fshpsub.c;h=51fe707949ef9aa53d1b3d4128025bd3f78d1066;hp=4cfce330b1d9e515a853e99d930c73366ad51d06;hb=bd07ee186b0e5c8d21cdf3238b71671ef3226d22;hpb=0a50a48141454b8cfd624881c1aef46bc1f011f6

diff --git a/src/lib/subs/shpsub.c b/src/lib/subs/shpsub.c
index 4cfce330b..51fe70794 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-2006, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ *  Copyright (C) 1986-2010, Dave Pare, Jeff Bailey, Thomas Ruschak,
  *                           Ken Stevens, Steve McClure
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -26,62 +26,48 @@
  *  ---
  *
  *  shpsub.c: Ship subroutine stuff
- * 
+ *
  *  Known contributors to this file:
  *     Ken Stevens, 1995
  *     Steve McClure, 1996-2000
- *     Markus Armbruster, 2006
+ *     Markus Armbruster, 2006-2009
  */
 
 #include <config.h>
 
-#include <math.h>
-#include "misc.h"
-#include "queue.h"
-#include "player.h"
-#include "sect.h"
-#include "ship.h"
-#include "plane.h"
-#include "land.h"
-#include "news.h"
-#include "item.h"
-#include "xy.h"
-#include "nsc.h"
+#include <stdlib.h>
+#include "damage.h"
 #include "file.h"
-#include "nat.h"
-#include "path.h"
+#include "map.h"
+#include "misc.h"
 #include "mission.h"
+#include "nsc.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 "xy.h"
+#include "empobj.h"
+#include "unit.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 int shp_check_one_mines(struct ulist *);
+static int shp_hit_mine(struct shpstr *);
+static void shp_mess(char *, struct ulist *);
 
 void
 shp_sel(struct nstr_item *ni, struct emp_qelem *list)
-
-
-    /*  int     wantflags;
-       int      nowantflags;
-     */
 {
     struct shpstr ship;
     struct mchrstr *mcp;
-    struct mlist *mlp;
+    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;
-	 */
 	if (opt_MARKET) {
 	    if (ontradingblock(EF_SHIP, &ship)) {
 		pr("ship #%d inelligible - it's for sale.\n",
@@ -89,25 +75,13 @@ shp_sel(struct nstr_item *ni, struct emp_qelem *list)
 		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);
-	    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 = malloc(sizeof(struct ulist));
+	mlp->chrp = (struct empobj_chr *)mcp;
+	mlp->unit.ship = ship;
 	mlp->mobil = ship.shp_mobil;
 	emp_insque(&mlp->queue, list);
     }
@@ -120,7 +94,7 @@ shp_nav(struct emp_qelem *list, double *minmobp, double *maxmobp,
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     struct sctstr sect;
     struct shpstr ship;
     coord allx;
@@ -132,8 +106,8 @@ shp_nav(struct emp_qelem *list, double *minmobp, double *maxmobp,
     *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);
+	mlp = (struct ulist *)qp;
+	getship(mlp->unit.ship.shp_uid, &ship);
 	if (ship.shp_own != actor) {
 	    mpr(actor, "%s was sunk at %s\n",
 		prship(&ship), xyas(ship.shp_x, ship.shp_y, actor));
@@ -142,7 +116,7 @@ shp_nav(struct emp_qelem *list, double *minmobp, double *maxmobp,
 	    continue;
 	}
 	if (opt_SAIL) {
-	    if (*ship.shp_path && !update_pending) {
+	    if (*ship.shp_path && !update_running) {
 		shp_mess("has a sail path", mlp);
 		mpr(actor, "Use `sail <#> -' to reset\n");
 		continue;
@@ -185,28 +159,7 @@ shp_nav(struct emp_qelem *list, double *minmobp, double *maxmobp,
 	    *minmobp = mlp->mobil;
 	if (mlp->mobil > *maxmobp)
 	    *maxmobp = mlp->mobil;
-	mlp->ship = ship;
-    }
-}
-
-void
-shp_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;
+	mlp->unit.ship = ship;
     }
 }
 
@@ -215,7 +168,7 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, 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;
@@ -223,34 +176,35 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, int takemob, natid actor)
 
     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)) {
+	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->ship));
+		    prship(&mlp->unit.ship));
 	    continue;
 	}
 	if (takemob && mlp->mobil <= 0.0) {
 	    if (verbose)
-		mpr(actor, "%s is out of mobility!\n", prship(&mlp->ship));
+		mpr(actor, "%s is out of mobility!\n",
+		    prship(&mlp->unit.ship));
 	    continue;
 	}
-	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) {
 	    if (verbose)
 		mpr(actor, "%s is not at sea.  No mines there!\n",
-		    prship(&mlp->ship));
+		    prship(&mlp->unit.ship));
 	    continue;
 	}
 	if (takemob) {
-	    mlp->mobil -= shp_mobcost(&mlp->ship);
-	    mlp->ship.shp_mobil = (int)mlp->mobil;
+	    mlp->mobil -= shp_mobcost(&mlp->unit.ship);
+	    mlp->unit.ship.shp_mobil = (int)mlp->mobil;
 	}
-	putship(mlp->ship.shp_uid, &mlp->ship);
+	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
 	if (!(mines = sect.sct_mines))
 	    continue;
-	max = mlp->mcp->m_item[I_SHELL];
-	shells = mlp->ship.shp_item[I_SHELL];
+	max = ((struct mchrstr *)mlp->chrp)->m_item[I_SHELL];
+	shells = mlp->unit.ship.shp_item[I_SHELL];
 	for (m = 0; mines > 0 && m < 5; m++) {
 	    if (chance(0.66)) {
 		mpr(actor, "Sweep...\n");
@@ -260,14 +214,14 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, int takemob, natid actor)
 	    }
 	}
 	sect.sct_mines = mines;
-	mlp->ship.shp_item[I_SHELL] = shells;
+	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);
 	}
-	putship(mlp->ship.shp_uid, &mlp->ship);
-	putsect(&sect);
     }
     if (changed)
 	writemap(actor);
@@ -275,25 +229,25 @@ shp_sweep(struct emp_qelem *ship_list, int verbose, int takemob, 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)
+	putship(mlp->unit.ship.shp_uid, &mlp->unit.ship);
+	if (!mlp->unit.ship.shp_own)
 	    return 1;
     }
     return 0;
@@ -304,12 +258,12 @@ shp_check_mines(struct emp_qelem *ship_list)
 {
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     int stopping = 0;
 
     for (qp = ship_list->q_back; qp != ship_list; qp = next) {
 	next = qp->q_back;
-	mlp = (struct mlist *)qp;
+	mlp = (struct ulist *)qp;
 	if (shp_check_one_mines(mlp)) {
 	    stopping = 1;
 	    emp_remque(qp);
@@ -319,47 +273,16 @@ shp_check_mines(struct emp_qelem *ship_list)
     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("%1.1s", &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)
+shp_mess(char *str, struct ulist *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);
+    mpr(mlp->unit.ship.shp_own, "%s %s & stays in %s\n",
+	prship(&mlp->unit.ship),
+	str, xyas(mlp->unit.ship.shp_x, mlp->unit.ship.shp_y,
+		  mlp->unit.ship.shp_own));
+    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);
 }
@@ -396,6 +319,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;
@@ -408,17 +332,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 &&
+	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    ((struct mchrstr *)mlp->chrp)->m_flags & nowantflags)
 	    continue;
 	++count;
     }
@@ -426,11 +352,11 @@ 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) {
+    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);
 	free(mlp);
     }
@@ -442,7 +368,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;
 
@@ -452,12 +378,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 &&
+	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    ((struct mchrstr *)mlp->chrp)->m_flags & nowantflags)
 	    continue;
 	shp_damage_one(mlp, dam);
     }
@@ -470,47 +398,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 &&
+	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    ((struct mchrstr *)mlp->chrp)->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 (((struct mchrstr *)mlp->chrp)->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 (!((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)
 	    continue;
 	if (!mvs) {
 	    mvs = mlp;
 	    continue;
 	}
-	if (mlp->mcp->m_cost * mlp->ship.shp_effic >
-	    mvs->mcp->m_cost * mvs->ship.shp_effic)
+	if (((struct mchrstr *)mlp->chrp)->m_cost * mlp->unit.ship.shp_effic >
+	    ((struct mchrstr *)mlp->chrp)->m_cost * mvs->unit.ship.shp_effic)
 	    mvs = mlp;
     }
     return mvs;
@@ -521,19 +454,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 &&
+	    (((struct mchrstr *)mlp->chrp)->m_flags & wantflags) != wantflags)
 	    continue;
-	if (nowantflags && mlp->mcp->m_flags & nowantflags)
+	if (nowantflags &&
+	    ((struct mchrstr *)mlp->chrp)->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;
@@ -545,38 +480,48 @@ 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);
+		if (dam) {
+		    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;
@@ -591,7 +536,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;
 
@@ -608,17 +553,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 (((struct mchrstr *)mlp->chrp)->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;
@@ -631,9 +577,8 @@ 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;
@@ -669,35 +614,22 @@ shp_fort_interdiction(struct emp_qelem *list, coord newx, coord newy,
     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,
@@ -706,8 +638,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
@@ -719,26 +669,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;
 }
 
@@ -750,17 +686,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;
 
@@ -770,7 +706,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_uid].m_flags & M_SWEEP)
 	m /= 2.0;
 
     shipdamage(sp, ldround(m, 1));
@@ -778,29 +714,6 @@ 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)
@@ -808,7 +721,7 @@ shp_nav_one_sector(struct emp_qelem *list, int dir, natid actor,
     struct sctstr sect;
     struct emp_qelem *qp;
     struct emp_qelem *next;
-    struct mlist *mlp;
+    struct ulist *mlp;
     struct emp_qelem done;
     coord dx;
     coord dy;
@@ -822,23 +735,23 @@ shp_nav_one_sector(struct emp_qelem *list, int dir, natid actor,
     int navigate;
 
     if (dir <= DIR_STOP || dir >= DIR_VIEW) {
-	shp_put(list, actor);
+	unit_put(list, actor);
 	return 1;
     }
     dx = diroff[dir][0];
     dy = diroff[dir][1];
     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);
+	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->ship);
+	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 &&
-		!(mlp->mcp->m_flags & M_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",
@@ -858,25 +771,27 @@ shp_nav_one_sector(struct emp_qelem *list, int dir, natid actor,
 	    shp_mess("is out of mobility", 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);
+	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->ship.shp_tech, mlp->mcp->m_vrnge);
-	if (mlp->mcp->m_flags & M_SONAR)
-	    tf = techfact(mlp->ship.shp_tech, 1.0);
+	tech = techfact(mlp->unit.ship.shp_tech,
+			((struct mchrstr *)mlp->chrp)->m_vrnge);
+	if (((struct mchrstr *)mlp->chrp)->m_flags & M_SONAR)
+	    tf = techfact(mlp->unit.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);
+	radmapupd(mlp->unit.ship.shp_own,
+		  mlp->unit.ship.shp_x, mlp->unit.ship.shp_y,
+		  (int)mlp->unit.ship.shp_effic, (int)tech, tf);
     }
     if (QEMPTY(list))
 	return stopping;
@@ -890,15 +805,16 @@ shp_nav_one_sector(struct emp_qelem *list, int dir, natid actor,
     /* 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;
+	mlp = (struct ulist *)list->q_back;
+	newx = mlp->unit.ship.shp_x;
+	newy = mlp->unit.ship.shp_y;
 	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) {
+	    mlp = (struct ulist *)qp;
+	    if (mlp->unit.ship.shp_x == newx &&
+		mlp->unit.ship.shp_y == newy) {
 		emp_remque(qp);
 		emp_insque(qp, &done);
 	    }
@@ -912,11 +828,11 @@ shp_nav_one_sector(struct emp_qelem *list, int dir, natid actor,
 }
 
 /*
- * 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
  */
 
@@ -926,7 +842,6 @@ shp_missile_defense(coord dx, coord dy, natid bombown, int hardtarget)
     struct nstr_item ni;
     struct shpstr ship;
     int hitchance;
-    int shell;
     double gun, eff, teff;
 
     snxtitem_dist(&ni, EF_SHIP, dx, dy, 1);
@@ -944,20 +859,17 @@ shp_missile_defense(coord dx, coord dy, natid bombown, int hardtarget)
 	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 */
@@ -972,9 +884,6 @@ shp_missile_defense(coord dx, coord dy, natid bombown, int hardtarget)
 	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);
 
 	if (roll(100) <= hitchance) {
 	    mpr(bombown, "KABOOOM!! Missile destroyed\n\n");
@@ -990,69 +899,38 @@ shp_missile_defense(coord dx, coord dy, natid bombown, int hardtarget)
     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 = 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);
-    sprintf(buf, "%s", prship(&mlp->ship));
+    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);
@@ -1061,7 +939,7 @@ shp_missdef(struct shpstr *sp, natid victim)
 double
 shp_mobcost(struct shpstr *sp)
 {
-    return speed_factor(sp->shp_effic * 0.01 * sp->shp_speed,
+    return speed_factor(sp->shp_effic * 0.01 * shp_speed(sp),
 			sp->shp_tech);
 }
 
@@ -1072,17 +950,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);
 }