 @@ -1,136 +1,136 @@
-/*	$NetBSD: capture.c,v 1.8 2009/05/24 19:18:44 dholland Exp $	*/
+/*	$NetBSD: capture.c,v 1.9 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)capture.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: capture.c,v 1.8 2009/05/24 19:18:44 dholland Exp $");
+__RCSID("$NetBSD: capture.c,v 1.9 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include "trek.h"
 /*
 **  Ask a Klingon To Surrender
 **
 **	(Fat chance)
 **
 **	The Subspace Radio is needed to ask a Klingon if he will kindly
 **	surrender.  A random Klingon from the ones in the quadrant is
 **	chosen.
 **
 **	The Klingon is requested to surrender.  The probability of this
 **	is a function of that Klingon's remaining power, our power,
 **	etc.
 */
 /*ARGSUSED*/
 void
 capture(int v __unused)
+{
 	int		i;
 	struct kling	*k;
 	double			x;
 	/* check for not cloaked */
 	if (Ship.cloaked)
+	{
 		printf("Ship-ship communications out when cloaked\n");
 		return;
+	}
 	if (damaged(SSRADIO)) {
 		out(SSRADIO);
 		return;
+	}
 	/* find out if there are any at all */
 	if (Etc.nkling <= 0)
+	{
 		printf("Uhura: Getting no response, sir\n");
 		return;
+	}
 	/* if there is more than one Klingon, find out which one */
 	k = selectklingon();
 	Move.free = 0;
 	Move.time = 0.05;
 	/* check out that Klingon */
 	k->srndreq++;
 	x = Param.klingpwr;
 	x *= Ship.energy;
 	x /= k->power * Etc.nkling;
 	x *= Param.srndrprob;
 	i = x;
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
 		printf("Prob = %d (%.4f)\n", i, x);
-#	endif
+#endif
 	if (i > ranf(100))
+	{
 		/* guess what, he surrendered!!! */
 		printf("Klingon at %d,%d surrenders\n", k->x, k->y);
 		i = ranf(Param.klingcrew);
 		if ( i > 0 )
 			printf("%d klingons commit suicide rather than be taken captive\n", Param.klingcrew - i);
 		if (i > Ship.brigfree)
 			i = Ship.brigfree;
 		Ship.brigfree -= i;
 		printf("%d captives taken\n", i);
 		killk(k->x, k->y);
 		return;
+	}
 	/* big surprise, he refuses to surrender */
 	printf("Fat chance, captain\n");
 	return;
+}
 /*
 **  SELECT A KLINGON
 **
 **	Cruddy, just takes one at random.  Should ask the captain.
 */
 struct kling *
 selectklingon(void)
+{
 	int		i;
 	if (Etc.nkling < 2)
 		i = 0;
 	else
 		i = ranf(Etc.nkling);
 	return (&Etc.klingon[i]);
+}

 @@ -1,474 +1,474 @@
-/*	$NetBSD: events.c,v 1.8 2008/01/28 01:15:55 dholland Exp $	*/
+/*	$NetBSD: events.c,v 1.9 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)events.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: events.c,v 1.8 2008/01/28 01:15:55 dholland Exp $");
+__RCSID("$NetBSD: events.c,v 1.9 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
 #include "getpar.h"
 #include "trek.h"
 /*
 **  CAUSE TIME TO ELAPSE
 **
 **	This routine does a hell of a lot.  It elapses time, eats up
 **	energy, regenerates energy, processes any events that occur,
 **	and so on.
 **
 **      'timewarp' is set if called in a time warp.
 */
 int
 events(int timewarp)
+{
 	int		i;
 	char			*p;
 	int			j = 0;
 	struct kling		*k;
 	double			rtime;
 	double			xdate;
 	double			idate;
 	struct event		*ev = NULL;
 	int			ix, iy;
 	struct quad	*q;
 	struct event	*e;
 	int			evnum;
 	int			restcancel;
 	/* if nothing happened, just allow for any Klingons killed */
 	if (Move.time <= 0.0)
+	{
 		Now.time = Now.resource / Now.klings;
 		return (0);
+	}
 	/* indicate that the cloaking device is now working */
 	Ship.cloakgood = 1;
 	/* idate is the initial date */
 	idate = Now.date;
 	/* schedule attacks if resting too long */
 	if (Move.time > 0.5 && Move.resting)
 		schedule(E_ATTACK, 0.5, 0, 0, 0);
 	/* scan the event list */
 	while (1)
+	{
 		restcancel = 0;
 		evnum = -1;
 		/* xdate is the date of the current event */
 		xdate = idate + Move.time;
 		/* find the first event that has happened */
 		for (i = 0; i < MAXEVENTS; i++)
+		{
 			e = &Event[i];
 			if (e->evcode == 0 || (e->evcode & E_GHOST))
 				continue;
 			if (e->date < xdate)
+			{
 				xdate = e->date;
 				ev = e;
 				evnum = i;
+			}
+		}
 		e = ev;
 		/* find the time between events */
 		rtime = xdate - Now.date;
 		/* decrement the magic "Federation Resources" pseudo-variable */
 		Now.resource -= Now.klings * rtime;
 		/* and recompute the time left */
 		Now.time = Now.resource / Now.klings;
 		/* move us up to the next date */
 		Now.date = xdate;
 		/* check for out of time */
 		if (Now.time <= 0.0)
 			lose(L_NOTIME);
-#		ifdef xTRACE
+#ifdef xTRACE
 		if (evnum >= 0 && Trace)
 			printf("xdate = %.2f, evcode %d params %d %d %d\n",
 				xdate, e->evcode, e->x, e->y, e->systemname);
-#		endif
+#endif
 		/* if evnum < 0, no events occurred  */
 		if (evnum < 0)
 			break;
 		/* otherwise one did.  Find out what it is */
 		switch (e->evcode & E_EVENT)
+		{
 		  case E_SNOVA:			/* supernova */
 			/* cause the supernova to happen */
 			snova(-1, 0);
 			/* and schedule the next one */
 			xresched(e, E_SNOVA, 1);
 			break;
 		  case E_LRTB:			/* long range tractor beam */
 			/* schedule the next one */
 			xresched(e, E_LRTB, Now.klings);
 			/* LRTB cannot occur if we are docked */
 			if (Ship.cond != DOCKED)
+			{
 				/* pick a new quadrant */
 				i = ranf(Now.klings) + 1;
 				for (ix = 0; ix < NQUADS; ix++)
+				{
 					for (iy = 0; iy < NQUADS; iy++)
+					{
 						q = &Quad[ix][iy];
 						if (q->stars >= 0)
 							if ((i -= q->klings) <= 0)
 								break;
+					}
 					if (i <= 0)
 						break;
+				}
 				/* test for LRTB to same quadrant */
 				if (Ship.quadx == ix && Ship.quady == iy)
 					break;
 				/* nope, dump him in the new quadrant */
 				Ship.quadx = ix;
 				Ship.quady = iy;
 				printf("\n%s caught in long range tractor beam\n", Ship.shipname);
 				printf("*** Pulled to quadrant %d,%d\n", Ship.quadx, Ship.quady);
 				Ship.sectx = ranf(NSECTS);
 				Ship.secty = ranf(NSECTS);
 				initquad(0);
 				/* truncate the move time */
 				Move.time = xdate - idate;
+			}
 			break;
 		  case E_KATSB:			/* Klingon attacks starbase */
 			/* if out of bases, forget it */
 			if (Now.bases <= 0)
+			{
 				unschedule(e);
 				break;
+			}
 			/* check for starbase and Klingons in same quadrant */
 			for (i = 0; i < Now.bases; i++)
+			{
 				ix = Now.base[i].x;
 				iy = Now.base[i].y;
 				/* see if a Klingon exists in this quadrant */
 				q = &Quad[ix][iy];
 				if (q->klings <= 0)
 					continue;
 				/* see if already distressed */
 				for (j = 0; j < MAXEVENTS; j++)
+				{
 					e = &Event[j];
 					if ((e->evcode & E_EVENT) != E_KDESB)
 						continue;
 					if (e->x == ix && e->y == iy)
 						break;
+				}
 				if (j < MAXEVENTS)
 					continue;
 				/* got a potential attack */
 				break;
+			}
 			e = ev;
 			if (i >= Now.bases)
+			{
 				/* not now; wait a while and see if some Klingons move in */
 				reschedule(e, 0.5 + 3.0 * franf());
 				break;
+			}
 			/* schedule a new attack, and a destruction of the base */
 			xresched(e, E_KATSB, 1);
 			e = xsched(E_KDESB, 1, ix, iy, 0);
 			/* report it if we can */
 			if (!damaged(SSRADIO))
+			{
 				printf("\nUhura:  Captain, we have received a distress signal\n");
 				printf("  from the starbase in quadrant %d,%d.\n",
 					ix, iy);
 				restcancel++;
+			}
 			else
 				/* SSRADIO out, make it so we can't see the distress call */
 				/* but it's still there!!! */
 				e->evcode |= E_HIDDEN;
 			break;
 		  case E_KDESB:			/* Klingon destroys starbase */
 			unschedule(e);
 			q = &Quad[e->x][e->y];
 			/* if the base has mysteriously gone away, or if the Klingon
 			   got tired and went home, ignore this event */
 			if (q->bases <=0 || q->klings <= 0)
 				break;
 			/* are we in the same quadrant? */
 			if (e->x == Ship.quadx && e->y == Ship.quady)
+			{
 				/* yep, kill one in this quadrant */
 				printf("\nSpock: ");
 				killb(Ship.quadx, Ship.quady);
+			}
 			else
 				/* kill one in some other quadrant */
 				killb(e->x, e->y);
 			break;
 		  case E_ISSUE:		/* issue a distress call */
 			xresched(e, E_ISSUE, 1);
 			/* if we already have too many, throw this one away */
 			if (Ship.distressed >= MAXDISTR)
 				break;
 			/* try a whole bunch of times to find something suitable */
 			for (i = 0; i < 100; i++)
+			{
 				ix = ranf(NQUADS);
 				iy = ranf(NQUADS);
 				q = &Quad[ix][iy];
 				/* need a quadrant which is not the current one,
 				   which has some stars which are inhabited and
 				   not already under attack, which is not
 				   supernova'ed, and which has some Klingons in it */
 				if (!((ix == Ship.quadx && iy == Ship.quady) || q->stars < 0 ||
 				    (q->qsystemname & Q_DISTRESSED) ||
 				    (q->qsystemname & Q_SYSTEM) == 0 || q->klings <= 0))
 					break;
+			}
 			if (i >= 100)
 				/* can't seem to find one; ignore this call */
 				break;
 			/* got one!!  Schedule its enslavement */
 			Ship.distressed++;
 			e = xsched(E_ENSLV, 1, ix, iy, q->qsystemname);
 			q->qsystemname = (e - Event) | Q_DISTRESSED;
 			/* tell the captain about it if we can */
 			if (!damaged(SSRADIO))
+			{
 				printf("\nUhura: Captain, starsystem %s in quadrant %d,%d is under attack\n",
 					Systemname[e->systemname], ix, iy);
 				restcancel++;
+			}
 			else
 				/* if we can't tell him, make it invisible */
 				e->evcode |= E_HIDDEN;
 			break;
 		  case E_ENSLV:		/* starsystem is enslaved */
 			unschedule(e);
 			/* see if current distress call still active */
 			q = &Quad[e->x][e->y];
 			if (q->klings <= 0)
+			{
 				/* no Klingons, clean up */
 				/* restore the system name */
 				q->qsystemname = e->systemname;
 				break;
+			}
 			/* play stork and schedule the first baby */
 			e = schedule(E_REPRO, Param.eventdly[E_REPRO] * franf(), e->x, e->y, e->systemname);
 			/* report the disaster if we can */
 			if (!damaged(SSRADIO))
+			{
 				printf("\nUhura:  We've lost contact with starsystem %s\n",
 					Systemname[e->systemname]);
 				printf("  in quadrant %d,%d.\n",
 					e->x, e->y);
+			}
 			else
 				e->evcode |= E_HIDDEN;
 			break;
 		  case E_REPRO:		/* Klingon reproduces */
 			/* see if distress call is still active */
 			q = &Quad[e->x][e->y];
 			if (q->klings <= 0)
+			{
 				unschedule(e);
 				q->qsystemname = e->systemname;
 				break;
+			}
 			xresched(e, E_REPRO, 1);
 			/* reproduce one Klingon */
 			ix = e->x;
 			iy = e->y;
 			if (Now.klings == 127)
 				break;		/* full right now */
 			if (q->klings >= MAXKLQUAD)
+			{
 				/* this quadrant not ok, pick an adjacent one */
 				for (i = ix - 1; i <= ix + 1; i++)
+				{
 					if (i < 0 || i >= NQUADS)
 						continue;
 					for (j = iy - 1; j <= iy + 1; j++)
+					{
 						if (j < 0 || j >= NQUADS)
 							continue;
 						q = &Quad[i][j];
 						/* check for this quad ok (not full & no snova) */
 						if (q->klings >= MAXKLQUAD || q->stars < 0)
 							continue;
 						break;
+					}
 					if (j <= iy + 1)
 						break;
+				}
 				if (j > iy + 1)
 					/* cannot create another yet */
 					break;
 				ix = i;
 				iy = j;
+			}
 			/* deliver the child */
 			q->klings++;
 			Now.klings++;
 			if (ix == Ship.quadx && iy == Ship.quady)
+			{
 				/* we must position Klingon */
 				sector(&ix, &iy);
 				Sect[ix][iy] = KLINGON;
 				k = &Etc.klingon[Etc.nkling++];
 				k->x = ix;
 				k->y = iy;
 				k->power = Param.klingpwr;
 				k->srndreq = 0;
 				compkldist(Etc.klingon[0].dist == Etc.klingon[0].avgdist ? 0 : 1);
+			}
 			/* recompute time left */
 			Now.time = Now.resource / Now.klings;
 			break;
 		  case E_SNAP:		/* take a snapshot of the galaxy */
 			xresched(e, E_SNAP, 1);
 			p = (char *) Etc.snapshot;
 			memcpy(p, Quad, sizeof (Quad));
 			p += sizeof(Quad);
 			memcpy(p, Event, sizeof (Event));
 			p += sizeof(Event);
 			memcpy(p, &Now, sizeof (Now));
 			Game.snap = 1;
 			break;
 		  case E_ATTACK:	/* Klingons attack during rest period */
 			if (!Move.resting)
+			{
 				unschedule(e);
 				break;
+			}
 			attack(1);
 			reschedule(e, 0.5);
 			break;
 		  case E_FIXDV:
 			i = e->systemname;
 			unschedule(e);
 			/* de-damage the device */
 			printf("%s reports repair work on the %s finished.\n",
 				Device[i].person, Device[i].name);
 			/* handle special processing upon fix */
 			switch (i)
+			{
 			  case LIFESUP:
 				Ship.reserves = Param.reserves;
 				break;
 			  case SINS:
 				if (Ship.cond == DOCKED)
 					break;
 				printf("Spock has tried to recalibrate your Space Internal Navigation System,\n");
 				printf("  but he has no standard base to calibrate to.  Suggest you get\n");
 				printf("  to a starbase immediately so that you can properly recalibrate.\n");
 				Ship.sinsbad = 1;
 				break;
 			  case SSRADIO:
 				restcancel = dumpssradio();
 				break;
+			}
 			break;
 		  default:
 			break;
+		}
 		if (restcancel && Move.resting && getynpar("Spock: Shall we cancel our rest period"))
 			Move.time = xdate - idate;
+	}
 	/* unschedule an attack during a rest period */
 	if ((e = Now.eventptr[E_ATTACK]) != NULL)
 		unschedule(e);
 	if (!timewarp)
+	{
 		/* eat up energy if cloaked */
 		if (Ship.cloaked)
 			Ship.energy -= Param.cloakenergy * Move.time;
 		/* regenerate resources */
 		rtime = 1.0 - exp(-Param.regenfac * Move.time);
 		Ship.shield += (Param.shield - Ship.shield) * rtime;
 		Ship.energy += (Param.energy - Ship.energy) * rtime;
 		/* decrement life support reserves */
 		if (damaged(LIFESUP) && Ship.cond != DOCKED)
 			Ship.reserves -= Move.time;
+	}
 	return (0);
+}

 @@ -1,117 +1,117 @@
-/*	$NetBSD: externs.c,v 1.8 2003/08/07 09:37:51 agc Exp $	*/
+/*	$NetBSD: externs.c,v 1.9 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)externs.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: externs.c,v 1.8 2003/08/07 09:37:51 agc Exp $");
+__RCSID("$NetBSD: externs.c,v 1.9 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
-# include	"trek.h"
+#include "trek.h"
 /*
 **	global variable definitions
 */
 const struct device	Device[NDEV] =
+{
 	{ "warp drive",		"Scotty" },
 	{ "S.R. scanners",	"Scotty" },
 	{ "L.R. scanners",	"Scotty" },
 	{ "phasers",		"Sulu" },
 	{ "photon tubes",	"Sulu" },
 	{ "impulse engines",	"Scotty" },
 	{ "shield control",	"Sulu" },
 	{ "computer",		"Spock" },
 	{ "subspace radio",	"Uhura" },
 	{ "life support",	"Scotty" },
 	{ "navigation system",	"Chekov" },
 	{ "cloaking device",	"Scotty" },
 	{ "transporter",	"Scotty" },
 	{ "shuttlecraft",	"Scotty" },
 	{ "*ERR 14*",		"Nobody" },
 	{ "*ERR 15*",		"Nobody" }
 };
 const char	*const Systemname[NINHAB] =
+{
 	"ERROR",
 	"Talos IV",
 	"Rigel III",
 	"Deneb VII",
 	"Canopus V",
 	"Icarus I",
 	"Prometheus II",
 	"Omega VII",
 	"Elysium I",
 	"Scalos IV",
 	"Procyon IV",
 	"Arachnid I",
 	"Argo VIII",
 	"Triad III",
 	"Echo IV",
 	"Nimrod III",
 	"Nemisis IV",
 	"Centarurus I",
 	"Kronos III",
 	"Spectros V",
 	"Beta III",
 	"Gamma Tranguli VI",
 	"Pyris III",
 	"Triachus",
 	"Marcus XII",
 	"Kaland",
 	"Ardana",
 	"Stratos",
 	"Eden",
 	"Arrikis",
 	"Epsilon Eridani IV",
 	"Exo III"
 };
 struct quad	Quad[NQUADS][NQUADS];
 /* current sector map */
 char	Sect[NSECTS][NSECTS];
 struct event	Event[MAXEVENTS];	/* dynamic event list; one entry per pending event */
 struct Ship_struct Ship;
 struct Game_struct Game;
 struct Move_struct Move;
 struct Param_struct Param;
 struct Now_struct Now;
 struct Etc_struct Etc;
 int Trace;

 @@ -1,172 +1,172 @@
-/*	$NetBSD: schedule.c,v 1.8 2009/05/24 19:18:44 dholland Exp $	*/
+/*	$NetBSD: schedule.c,v 1.9 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)schedule.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: schedule.c,v 1.8 2009/05/24 19:18:44 dholland Exp $");
+__RCSID("$NetBSD: schedule.c,v 1.9 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include <math.h>
 #include <err.h>
 #include <limits.h>
 #include "trek.h"
 /*
 **  SCHEDULE AN EVENT
 **
 **	An event of type 'type' is scheduled for time NOW + 'offset'
 **	into the first available slot.  'x', 'y', and 'z' are
 **	considered the attributes for this event.
 **
 **	The address of the slot is returned.
 */
 struct event *
 schedule(int type, double offset, int x, int y, int z)
+{
 	struct event	*e;
 	int		i;
 	double			date;
 	date = Now.date + offset;
 	for (i = 0; i < MAXEVENTS; i++)
+	{
 		e = &Event[i];
 		if (e->evcode)
 			continue;
 		/* got a slot */
-#		ifdef xTRACE
+#ifdef xTRACE
 		if (Trace)
 			printf("schedule: type %d @ %.2f slot %d parm %d %d %d\n",
 				type, date, i, x, y, z);
-#		endif
+#endif
 		e->evcode = type;
 		e->date = date;
 		e->x = x;
 		e->y = y;
 		e->systemname = z;
 		Now.eventptr[type & ~E_GHOST] = e;
 		return (e);
+	}
 	errx(1, "Cannot schedule event %d parm %d %d %d", type, x, y, z);
+}
 /*
 **  RESCHEDULE AN EVENT
 **
 **	The event pointed to by 'e' is rescheduled to the current
 **	time plus 'offset'.
 */
 void
 reschedule(struct event *e1, double offset)
+{
 	double			date;
 	struct event	*e;
 	e = e1;
 	date = Now.date + offset;
 	e->date = date;
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
 		printf("reschedule: type %d parm %d %d %d @ %.2f\n",
 			e->evcode, e->x, e->y, e->systemname, date);
-#	endif
+#endif
 	return;
+}
 /*
 **  UNSCHEDULE AN EVENT
 **
 **	The event at slot 'e' is deleted.
 */
 void
 unschedule(struct event *e1)
+{
 	struct event	*e;
 	e = e1;
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
 		printf("unschedule: type %d @ %.2f parm %d %d %d\n",
 			e->evcode, e->date, e->x, e->y, e->systemname);
-#	endif
+#endif
 	Now.eventptr[e->evcode & E_EVENT] = 0;
 	e->date = TOOLARGE;
 	e->evcode = 0;
 	return;
+}
 /*
 **  Abreviated schedule routine
 **
 **	Parameters are the event index and a factor for the time
 **	figure.
 */
 struct event *
 xsched(int ev1, int factor, int x, int y, int z)
+{
 	int	ev;
 	ev = ev1;
 	return (schedule(ev, -Param.eventdly[ev] * Param.time * log(franf()) / factor, x, y, z));
+}
 /*
 **  Simplified reschedule routine
 **
 **	Parameters are the event index, the initial date, and the
 **	division factor.  Look at the code to see what really happens.
 */
 void
 xresched(struct event *e1, int ev1, int factor)
+{
 	int		ev;
 	struct event	*e;
 	ev = ev1;
 	e = e1;
 	reschedule(e, -Param.eventdly[ev] * Param.time * log(franf()) / factor);
+}

 @@ -1,186 +1,186 @@
-/*	$NetBSD: klmove.c,v 1.6 2009/05/24 19:18:44 dholland Exp $	*/
+/*	$NetBSD: klmove.c,v 1.7 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)klmove.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: klmove.c,v 1.6 2009/05/24 19:18:44 dholland Exp $");
+__RCSID("$NetBSD: klmove.c,v 1.7 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include "trek.h"
 /*
 **  Move Klingons Around
 **
 **	This is a largely incomprehensible block of code that moves
 **	Klingons around in a quadrant.  It was written in a very
 **	"program as you go" fashion, and is a prime candidate for
 **	rewriting.
 **
 **	The flag `fl' is zero before an attack, one after an attack,
 **	and two if you are leaving a quadrant.  This serves to
 **	change the probability and distance that it moves.
 **
 **	Basically, what it will try to do is to move a certain number
 **	of steps either toward you or away from you.  It will avoid
 **	stars whenever possible.  Nextx and nexty are the next
 **	sector to move to on a per-Klingon basis; they are roughly
 **	equivalent to Ship.sectx and Ship.secty for the starship.  Lookx and
 **	looky are the sector that you are going to look at to see
 **	if you can move their.  Dx and dy are the increment.  Fudgex
 **	and fudgey are the things you change around to change your
 **	course around stars.
 */
 void
 klmove(int fl)
+{
 	int			n;
 	struct kling	*k;
 	double			dx, dy;
 	int			nextx, nexty;
 	int		lookx, looky;
 	int			motion;
 	int			fudgex, fudgey;
 	int			qx, qy;
 	double			bigger;
 	int			i;
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
 		printf("klmove: fl = %d, Etc.nkling = %d\n", fl, Etc.nkling);
-#	endif
+#endif
 	for (n = 0; n < Etc.nkling; n++)
+	{
 		k = &Etc.klingon[n];
 		i = 100;
 		if (fl)
 			i = 100.0 * k->power / Param.klingpwr;
 		if (ranf(i) >= Param.moveprob[2 * Move.newquad + fl])
 			continue;
 		/* compute distance to move */
 		motion = ranf(75) - 25;
 		motion *= k->avgdist * Param.movefac[2 * Move.newquad + fl];
 		/* compute direction */
 		dx = Ship.sectx - k->x + ranf(3) - 1;
 		dy = Ship.secty - k->y + ranf(3) - 1;
 		bigger = dx;
 		if (dy > bigger)
 			bigger = dy;
 		if (bigger == 0.0)
 			bigger = 1.0;
 		dx = dx / bigger + 0.5;
 		dy = dy / bigger + 0.5;
 		if (motion < 0)
+		{
 			motion = -motion;
 			dx = -dx;
 			dy = -dy;
+		}
 		fudgex = fudgey = 1;
 		/* try to move the klingon */
 		nextx = k->x;
 		nexty = k->y;
 		for (; motion > 0; motion--)
+		{
 			lookx = nextx + dx;
 			looky = nexty + dy;
 			if (lookx < 0 || lookx >= NSECTS || looky < 0 || looky >= NSECTS)
+			{
 				/* new quadrant */
 				qx = Ship.quadx;
 				qy = Ship.quady;
 				if (lookx < 0)
 					qx -= 1;
 				else
 					if (lookx >= NSECTS)
 						qx += 1;
 				if (looky < 0)
 					qy -= 1;
 				else
 					if (looky >= NSECTS)
 						qy += 1;
 				if (qx < 0 || qx >= NQUADS || qy < 0 || qy >= NQUADS ||
 						Quad[qx][qy].stars < 0 || Quad[qx][qy].klings > MAXKLQUAD - 1)
 					break;
 				if (!damaged(SRSCAN))
+				{
 					printf("Klingon at %d,%d escapes to quadrant %d,%d\n",
 						k->x, k->y, qx, qy);
 					motion = Quad[qx][qy].scanned;
 					if (motion >= 0 && motion < 1000)
 						Quad[qx][qy].scanned += 100;
 					motion = Quad[Ship.quadx][Ship.quady].scanned;
 					if (motion >= 0 && motion < 1000)
 						Quad[Ship.quadx][Ship.quady].scanned -= 100;
+				}
 				Sect[k->x][k->y] = EMPTY;
 				Quad[qx][qy].klings += 1;
 				Etc.nkling -= 1;
 				*k = Etc.klingon[Etc.nkling];
 				Quad[Ship.quadx][Ship.quady].klings -= 1;
 				k = 0;
 				break;
+			}
 			if (Sect[lookx][looky] != EMPTY)
+			{
 				lookx = nextx + fudgex;
 				if (lookx < 0 || lookx >= NSECTS)
 					lookx = nextx + dx;
 				if (Sect[lookx][looky] != EMPTY)
+				{
 					fudgex = -fudgex;
 					looky = nexty + fudgey;
 					if (looky < 0 || looky >= NSECTS || Sect[lookx][looky] != EMPTY)
+					{
 						fudgey = -fudgey;
 						break;
+					}
+				}
+			}
 			nextx = lookx;
 			nexty = looky;
+		}
 		if (k && (k->x != nextx || k->y != nexty))
+		{
 			if (!damaged(SRSCAN))
 				printf("Klingon at %d,%d moves to %d,%d\n",
 					k->x, k->y, nextx, nexty);
 			Sect[k->x][k->y] = EMPTY;
 			Sect[k->x = nextx][k->y = nexty] = KLINGON;
+		}
+	}
 	compkldist(0);
+}

 @@ -1,176 +1,176 @@
-/*	$NetBSD: dumpgame.c,v 1.12 2009/05/24 19:18:44 dholland Exp $	*/
+/*	$NetBSD: dumpgame.c,v 1.13 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)dumpgame.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: dumpgame.c,v 1.12 2009/05/24 19:18:44 dholland Exp $");
+__RCSID("$NetBSD: dumpgame.c,v 1.13 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include <err.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include "trek.h"
 /***  THIS CONSTANT MUST CHANGE AS THE DATA SPACES CHANGE ***/
-# define	VERSION		2
+#define VERSION		2
 struct dump
+{
 	char	*area;
 	int	count;
 };
 static int readdump(int);
 struct dump	Dump_template[] =
+{
 	{ (char *)&Ship,	sizeof (Ship) },
 	{ (char *)&Now,		sizeof (Now) },
 	{ (char *)&Param,	sizeof (Param) },
 	{ (char *)&Etc,		sizeof (Etc) },
 	{ (char *)&Game,	sizeof (Game) },
 	{ (char *)Sect,		sizeof (Sect) },
 	{ (char *)Quad,		sizeof (Quad) },
 	{ (char *)&Move,	sizeof (Move) },
 	{ (char *)Event,	sizeof (Event) },
 	{ NULL,			0 }
 };
 /*
 **  DUMP GAME
 **
 **	This routine dumps the game onto the file "trek.dump".  The
 **	first two bytes of the file are a version number, which
 **	reflects whether this image may be used.  Obviously, it must
 **	change as the size, content, or order of the data structures
 **	output change.
 */
 /*ARGSUSED*/
 void
 dumpgame(int v __unused)
+{
 	int		version;
 	int		fd;
 	struct dump	*d;
 	int		i;
 	if ((fd = creat("trek.dump", 0644)) < 0) {
 		warn("cannot open `trek.dump'");
 		return;
+	}
 	version = VERSION;
 	write(fd, &version, sizeof version);
 	/* output the main data areas */
 	for (d = Dump_template; d->area; d++)
+	{
 		write(fd, &d->area, sizeof d->area);
 		i = d->count;
 		write(fd, d->area, i);
+	}
 	close(fd);
+}
 /*
 **  RESTORE GAME
 **
 **	The game is restored from the file "trek.dump".  In order for
 **	this to succeed, the file must exist and be readable, must
 **	have the correct version number, and must have all the appro-
 **	priate data areas.
 **
 **	Return value is zero for success, one for failure.
 */
 int
 restartgame(void)
+{
 	int	fd;
 	int		version;
 	if ((fd = open("trek.dump", O_RDONLY)) < 0 ||
 	    read(fd, &version, sizeof version) != sizeof version ||
 	    version != VERSION ||
 	    readdump(fd))
+	{
 		printf("cannot restart\n");
 		if (fd >= 0)
 			close(fd);
 		return (1);
+	}
 	close(fd);
 	return (0);
+}
 /*
 **  READ DUMP
 **
 **	This is the business end of restartgame().  It reads in the
 **	areas.
 **
 **	Returns zero for success, one for failure.
 */
 static int
 readdump(int fd1)
+{
 	int		fd;
 	struct dump	*d;
 	int		i;
 	long			junk;
 	fd = fd1;
 	for (d = Dump_template; d->area; d++)
+	{
 		if (read(fd, &junk, sizeof junk) != (sizeof junk))
 			return (1);
 		if ((char *)junk != d->area)
 			return (1);
 		i = d->count;
 		if (read(fd, d->area, i) != i)
 			return (1);
+	}
 	/* make quite certain we are at EOF */
 	return (read(fd, &junk, 1));
+}

 @@ -1,527 +1,527 @@
-/*	$NetBSD: trek.h,v 1.12 2009/03/31 18:48:16 christos Exp $	*/
+/*	$NetBSD: trek.h,v 1.13 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)trek.h	8.1 (Berkeley) 5/31/93
  */
 /*
 **  Global Declarations
 **
 **	Virtually all non-local variable declarations are made in this
 **	file.  Exceptions are those things which are initialized, which
 **	are defined in "externs.c", and things which are local to one
 **	program file.
 **
 **	So far as I know, nothing in here must be preinitialized to
 **	zero.
 */
 /* external function definitions */
 /*********************  GALAXY  **************************/
 /* galactic parameters */
-# define	NSECTS		10	/* dimensions of quadrant in sectors */
+#define NSECTS		10	/* dimensions of quadrant in sectors */
-# define	NQUADS		8	/* dimension of galazy in quadrants */
+#define NQUADS		8	/* dimension of galazy in quadrants */
-# define	NINHAB		32	/* number of quadrants which are inhabited */
+#define NINHAB		32	/* number of quadrants which are inhabited */
 struct quad		/* definition for each quadrant */
+{
 	unsigned char	bases;	/* number of bases in this quadrant */
 	char	klings;		/* number of Klingons in this quadrant */
 	char	holes;		/* number of black holes in this quadrant */
 	int	scanned;	/* star chart entry (see below) */
 	short	stars;		/* number of stars in this quadrant */
 	char	qsystemname;	/* starsystem name (see below) */
 };
-# define	Q_DISTRESSED	0200
+#define Q_DISTRESSED	0200
-# define	Q_SYSTEM	077
+#define Q_SYSTEM	077
 /*  systemname conventions:
  *	1 -> NINHAB	index into Systemname table for live system.
  *	+ Q_DISTRESSED	distressed starsystem -- systemname & Q_SYSTEM
  *			is the index into the Event table which will
  *			have the system name
  *	0		dead or nonexistent starsystem
+ *
  *  starchart ("scanned") conventions:
  *	0 -> 999	taken as is
  *	-1		not yet scanned ("...")
  *	1000		supernova ("///")
  *	1001		starbase + ??? (".1.")
 */
 /* ascii names of systems */
 extern const char	*const Systemname[NINHAB];
 /* quadrant definition */
 extern struct quad	Quad[NQUADS][NQUADS];
 /* defines for sector map  (below) */
-# define	EMPTY		'.'
+#define EMPTY		'.'
-# define	STAR		'*'
+#define STAR		'*'
-# define	BASE		'#'
+#define BASE		'#'
-# define	ENTERPRISE	'E'
+#define ENTERPRISE	'E'
-# define	QUEENE		'Q'
+#define QUEENE		'Q'
-# define	KLINGON		'K'
+#define KLINGON		'K'
-# define	INHABIT		'@'
+#define INHABIT		'@'
-# define	HOLE		' '
+#define HOLE		' '
 /* current sector map */
 extern char	Sect[NSECTS][NSECTS];
 /************************ DEVICES ******************************/
-# define	NDEV		16	/* max number of devices */
+#define	NDEV		16	/* max number of devices */
 /* device tokens */
-# define	WARP		0	/* warp engines */
+#define WARP		0	/* warp engines */
-# define	SRSCAN		1	/* short range scanners */
+#define SRSCAN		1	/* short range scanners */
-# define	LRSCAN		2	/* long range scanners */
+#define LRSCAN		2	/* long range scanners */
-# define	PHASER		3	/* phaser control */
+#define PHASER		3	/* phaser control */
-# define	TORPED		4	/* photon torpedo control */
+#define TORPED		4	/* photon torpedo control */
-# define	IMPULSE		5	/* impulse engines */
+#define IMPULSE		5	/* impulse engines */
-# define	SHIELD		6	/* shield control */
+#define SHIELD		6	/* shield control */
-# define	COMPUTER	7	/* on board computer */
+#define COMPUTER	7	/* on board computer */
-# define	SSRADIO		8	/* subspace radio */
+#define SSRADIO		8	/* subspace radio */
-# define	LIFESUP		9	/* life support systems */
+#define LIFESUP		9	/* life support systems */
-# define	SINS		10	/* Space Inertial Navigation System */
+#define SINS		10	/* Space Inertial Navigation System */
-# define	CLOAK		11	/* cloaking device */
+#define CLOAK		11	/* cloaking device */
-# define	XPORTER		12	/* transporter */
+#define XPORTER		12	/* transporter */
-# define	SHUTTLE		13	/* shuttlecraft */
+#define SHUTTLE		13	/* shuttlecraft */
 /* device names */
 struct device
+{
 	const char	*name;		/* device name */
 	const char	*person;	/* the person who fixes it */
 };
 extern const struct device	Device[NDEV];
 /***************************  EVENTS  ****************************/
-# define	NEVENTS		12	/* number of different event types */
+#define	NEVENTS		12	/* number of different event types */
-# define	E_LRTB		1	/* long range tractor beam */
+#define E_LRTB		1	/* long range tractor beam */
-# define	E_KATSB		2	/* Klingon attacks starbase */
+#define E_KATSB		2	/* Klingon attacks starbase */
-# define	E_KDESB		3	/* Klingon destroys starbase */
+#define E_KDESB		3	/* Klingon destroys starbase */
-# define	E_ISSUE		4	/* distress call is issued */
+#define E_ISSUE		4	/* distress call is issued */
-# define	E_ENSLV		5	/* Klingons enslave a quadrant */
+#define E_ENSLV		5	/* Klingons enslave a quadrant */
-# define	E_REPRO		6	/* a Klingon is reproduced */
+#define E_REPRO		6	/* a Klingon is reproduced */
-# define	E_FIXDV		7	/* fix a device */
+#define E_FIXDV		7	/* fix a device */
-# define	E_ATTACK	8	/* Klingon attack during rest period */
+#define E_ATTACK	8	/* Klingon attack during rest period */
-# define	E_SNAP		9	/* take a snapshot for time warp */
+#define E_SNAP		9	/* take a snapshot for time warp */
-# define	E_SNOVA		10	/* supernova occurs */
+#define E_SNOVA		10	/* supernova occurs */
-# define	E_GHOST		0100	/* ghost of a distress call if ssradio out */
+#define E_GHOST		0100	/* ghost of a distress call if ssradio out */
-# define	E_HIDDEN	0200	/* event that is unreportable because ssradio out */
+#define E_HIDDEN	0200	/* event unreportable because ssradio out */
-# define	E_EVENT		077	/* mask to get event code */
+#define E_EVENT		077	/* mask to get event code */
 struct event
+{
 	unsigned char 	x, y;		/* coordinates */
 	double		date;		/* trap stardate */
 	char		evcode;		/* event type */
 	unsigned char	systemname;	/* starsystem name */
 };
 /* systemname conventions:
  *	1 -> NINHAB	index into Systemname table for reported distress calls
+ *
  * evcode conventions:
  *	1 -> NEVENTS-1	event type
  *	+ E_HIDDEN	unreported (SSradio out)
  *	+ E_GHOST	actually already expired
  *	0		unallocated
  */
-# define	MAXEVENTS	25	/* max number of concurrently pending events */
+#define MAXEVENTS	25	/* max number of concurrently pending events */
 extern struct event	Event[MAXEVENTS];	/* dynamic event list; one entry per pending event */
 /*****************************  KLINGONS  *******************************/
 struct kling
+{
 	unsigned char	x, y;	/* coordinates */
 	int	power;		/* power left */
 	double	dist;		/* distance to Enterprise */
 	double	avgdist;	/* average over this move */
 	char	srndreq;	/* set if surrender has been requested */
 };
-# define	MAXKLQUAD	9	/* maximum klingons per quadrant */
+#define MAXKLQUAD	9	/* maximum klingons per quadrant */
 /********************** MISCELLANEOUS ***************************/
 /* condition codes */
-# define	GREEN		0
+#define GREEN		0
-# define	DOCKED		1
+#define DOCKED		1
-# define	YELLOW		2
+#define YELLOW		2
-# define	RED		3
+#define RED		3
 /* starbase coordinates */
-# define	MAXBASES	9	/* maximum number of starbases in galaxy */
+#define MAXBASES	9	/* maximum number of starbases in galaxy */
 /*  distress calls  */
-# define	MAXDISTR	5	/* maximum concurrent distress calls */
+#define MAXDISTR	5	/* maximum concurrent distress calls */
 /* phaser banks */
-# define	NBANKS		6	/* number of phaser banks */
+#define NBANKS		6	/* number of phaser banks */
 struct xy
+{
 	unsigned char	x, y;		/* coordinates */
 };
 /*
  *	note that much of the stuff in the following structs CAN NOT
  *	be moved around!!!!
  */
 /* information regarding the state of the starship */
 struct Ship_struct
+{
 	double	warp;		/* warp factor */
 	double	warp2;		/* warp factor squared */
 	double	warp3;		/* warp factor cubed */
 	char	shldup;		/* shield up flag */
 	char	cloaked;	/* set if cloaking device on */
 	int	energy;		/* starship's energy */
 	int	shield;		/* energy in shields */
 	double	reserves;	/* life support reserves */
 	int	crew;		/* ship's complement */
 	int	brigfree;	/* space left in brig */
 	char	torped;		/* torpedoes */
 	char	cloakgood;	/* set if we have moved */
 	int	quadx;		/* quadrant x coord */
 	int	quady;		/* quadrant y coord */
 	int	sectx;		/* sector x coord */
 	int	secty;		/* sector y coord */
 	unsigned char	cond;	/* condition code */
 	char	sinsbad;	/* Space Inertial Navigation System condition */
 	const char *shipname;	/* name of current starship */
 	char	ship;		/* current starship */
 	int	distressed;	/* number of distress calls */
 };
 extern struct Ship_struct Ship;
 /* sinsbad is set if SINS is working but not calibrated */
 /* game related information, mostly scoring */
 struct Game_struct
+{
 	int	killk;		/* number of klingons killed */
 	int	deaths;		/* number of deaths onboard Enterprise */
 	char	negenbar;	/* number of hits on negative energy barrier */
 	char	killb;		/* number of starbases killed */
 	int	kills;		/* number of stars killed */
 	char	skill;		/* skill rating of player */
 	char	length;		/* length of game */
 	char	killed;		/* set if you were killed */
 	char	killinhab;	/* number of inhabited starsystems killed */
 	char	tourn;		/* set if a tournament game */
 	char	passwd[15];	/* game password */
 	char	snap;		/* set if snapshot taken */
 	char	helps;		/* number of help calls */
 	int	captives;	/* total number of captives taken */
 };
 extern struct Game_struct Game;
 /* per move information */
 struct Move_struct
+{
 	char	free;		/* set if a move is free */
 	char	endgame;	/* end of game flag */
 	char	shldchg;	/* set if shields changed this move */
 	char	newquad;	/* set if just entered this quadrant */
 	char	resting;	/* set if this move is a rest */
 	double	time;		/* time used this move */
 };
 extern struct Move_struct Move;
 /* parametric information */
 struct Param_struct
+{
 	unsigned char	bases;	/* number of starbases */
 	char	klings;		/* number of klingons */
 	double	date;		/* stardate */
 	double	time;		/* time left */
 	double	resource;	/* Federation resources */
 	int	energy;		/* starship's energy */
 	int	shield;		/* energy in shields */
 	double	reserves;	/* life support reserves */
 	int	crew;		/* size of ship's complement */
 	int	brigfree;	/* max possible number of captives */
 	char	torped;		/* photon torpedos */
 	double	damfac[NDEV];	/* damage factor */
 	double	dockfac;	/* docked repair time factor */
 	double	regenfac;	/* regeneration factor */
 	int	stopengy;	/* energy to do emergency stop */
 	int	shupengy;	/* energy to put up shields */
 	int	klingpwr;	/* Klingon initial power */
 	int	warptime;	/* time chewer multiplier */
 	double	phasfac;	/* Klingon phaser power eater factor */
 	char	moveprob[6];	/* probability that a Klingon moves */
 	double	movefac[6];	/* Klingon move distance multiplier */
 	double	eventdly[NEVENTS];	/* event time multipliers */
 	double	navigcrud[2];	/* navigation crudup factor */
 	int	cloakenergy;	/* cloaking device energy per stardate */
 	double	damprob[NDEV];	/* damage probability */
 	double	hitfac;		/* Klingon attack factor */
 	int	klingcrew;	/* number of Klingons in a crew */
 	double	srndrprob;	/* surrender probability */
 	int	energylow;	/* low energy mark (cond YELLOW) */
 };
 extern struct Param_struct Param;
 /* Sum of damage probabilities must add to 1000 */
 /* other information kept in a snapshot */
 struct Now_struct
+{
 	unsigned char	bases;	/* number of starbases */
 	char	klings;		/* number of klingons */
 	double	date;		/* stardate */
 	double	time;		/* time left */
 	double	resource;	/* Federation resources */
 	char	distressed;	/* number of currently distressed quadrants */
 	struct event	*eventptr[NEVENTS];	/* pointer to event structs */
 	struct xy	base[MAXBASES];		/* locations of starbases */
 };
 extern struct Now_struct Now;
 /* Other stuff, not dumped in a snapshot */
 struct Etc_struct
+{
 	struct kling	klingon[MAXKLQUAD];	/* sorted Klingon list */
 	short		nkling;			/* number of Klingons in this sector */
 						/* < 0 means automatic override mode */
 	char		fast;			/* set if speed > 300 baud */
 	struct xy	starbase;	/* starbase in current quadrant */
 	char		snapshot[sizeof Quad + sizeof Event + sizeof Now];	/* snapshot for time warp */
 	char		statreport;		/* set to get a status report on a srscan */
 };
 extern struct Etc_struct Etc;
 /*
  *	eventptr is a pointer to the event[] entry of the last
  *	scheduled event of each type.  Zero if no such event scheduled.
  */
 /* Klingon move indicies */
-# define	KM_OB		0	/* Old quadrant, Before attack */
+#define KM_OB		0	/* Old quadrant, Before attack */
-# define	KM_OA		1	/* Old quadrant, After attack */
+#define KM_OA		1	/* Old quadrant, After attack */
-# define	KM_EB		2	/* Enter quadrant, Before attack */
+#define KM_EB		2	/* Enter quadrant, Before attack */
-# define	KM_EA		3	/* Enter quadrant, After attack */
+#define KM_EA		3	/* Enter quadrant, After attack */
-# define	KM_LB		4	/* Leave quadrant, Before attack */
+#define KM_LB		4	/* Leave quadrant, Before attack */
-# define	KM_LA		5	/* Leave quadrant, After attack */
+#define KM_LA		5	/* Leave quadrant, After attack */
 /* you lose codes */
-# define	L_NOTIME	1	/* ran out of time */
+#define L_NOTIME	1	/* ran out of time */
-# define	L_NOENGY	2	/* ran out of energy */
+#define L_NOENGY	2	/* ran out of energy */
-# define	L_DSTRYD	3	/* destroyed by a Klingon */
+#define L_DSTRYD	3	/* destroyed by a Klingon */
-# define	L_NEGENB	4	/* ran into the negative energy barrier */
+#define L_NEGENB	4	/* ran into the negative energy barrier */
-# define	L_SUICID	5	/* destroyed in a nova */
+#define L_SUICID	5	/* destroyed in a nova */
-# define	L_SNOVA		6	/* destroyed in a supernova */
+#define L_SNOVA		6	/* destroyed in a supernova */
-# define	L_NOLIFE	7	/* life support died (so did you) */
+#define L_NOLIFE	7	/* life support died (so did you) */
-# define	L_NOHELP	8	/* you could not be rematerialized */
+#define L_NOHELP	8	/* you could not be rematerialized */
-# define	L_TOOFAST	9	/* pretty stupid going at warp 10 */
+#define L_TOOFAST	9	/* pretty stupid going at warp 10 */
-# define	L_STAR		10	/* ran into a star */
+#define L_STAR		10	/* ran into a star */
-# define	L_DSTRCT	11	/* self destructed */
+#define L_DSTRCT	11	/* self destructed */
-# define	L_CAPTURED	12	/* captured by Klingons */
+#define L_CAPTURED	12	/* captured by Klingons */
-# define	L_NOCREW	13	/* you ran out of crew */
+#define L_NOCREW	13	/* you ran out of crew */
 /******************  COMPILE OPTIONS  ***********************/
 /* Trace info */
-# define	xTRACE		1
+#define xTRACE		1
 extern int	Trace;
-# define 	TOOLARGE	(DBL_MAX / 2)	/* < DOUBLE_MAX for everyone */
+#define TOOLARGE	(DBL_MAX / 2)	/* < DOUBLE_MAX for everyone */
 /* abandon.c */
 void abandon(int);
 /* attack.c */
 void attack(int);
 /* autover.c */
 void autover(void);
 /* capture.c */
 void capture(int);
 struct kling *selectklingon(void);
 /* cgetc.c */
 char cgetc(int);
 /* check_out.c */
 int check_out(int);
 /* checkcond.c */
 void checkcond(void);
 /* compkl.c */
 void compkldist(int);
 /* computer.c */
 void computer(int);
 /* damage.c */
 void damage(int, double);
 /* damaged.c */
 int damaged(int);
 /* dcrept.c */
 void dcrept(int);
 /* destruct.c */
 void destruct(int);
 /* dock.c */
 void dock(int);
 void undock(int);
 /* dumpgame.c */
 void dumpgame(int);
 int restartgame(void);
 /* dumpme.c */
 void dumpme(int);
 /* dumpssradio.c */
 int dumpssradio(void);
 /* events.c */
 int events(int);
 /* externs.c */
 /* getcodi.c */
 int getcodi(int *, double *);
 /* help.c */
 void help(int);
 /* impulse.c */
 void impulse(int);
 /* initquad.c */
 void initquad(int);
 void sector(int *, int *);
 /* kill.c */
 void killk(int, int );
 void killb(int, int );
 void kills(int, int , int);
 void killd(int, int , int);
 /* klmove.c */
 void klmove(int);
 /* lose.c */
 void lose(int) __attribute__((__noreturn__));
 /* lrscan.c */
 void lrscan(int);
 /* move.c */
 double move(int, int, double, double);
 /* nova.c */
 void nova(int, int );
 /* out.c */
 void out(int);
 /* phaser.c */
 void phaser(int);
 /* play.c */
 void myreset(int) __attribute__((__noreturn__));
 void play(void) __attribute__((__noreturn__));
 /* ram.c */
 void ram(int, int );
 /* ranf.c */
 int ranf(int);
 double franf(void);
 /* rest.c */
 void rest(int);
 /* schedule.c */
 struct event *schedule(int, double, int, int , int);
 void reschedule(struct event *, double);
 void unschedule(struct event *);
 struct event *xsched(int, int, int, int , int );
 void xresched(struct event *, int, int);
 /* score.c */
 long score(void);
 /* setup.c */
 void setup(void);
 /* setwarp.c */
 void setwarp(int);
 /* shield.c */
 void shield(int);
 /* snova.c */
 void snova(int, int );
 /* srscan.c */
 void srscan(int);
 /* systemname.c */
 const char *systemname(const struct quad *);
 /* torped.c */
 void torped(int);
 /* visual.c */
 void visual(int);
 /* warp.c */
 void dowarp(int);
 void warp(int, int, double);
 /* win.c */
 void win(void) __attribute__((__noreturn__));

 @@ -1,251 +1,251 @@
-/*	$NetBSD: main.c,v 1.14 2009/05/24 19:18:44 dholland Exp $	*/
+/*	$NetBSD: main.c,v 1.15 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 __COPYRIGHT("@(#) Copyright (c) 1980, 1993\
  The Regents of the University of California.  All rights reserved.");
 #endif /* not lint */
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)main.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: main.c,v 1.14 2009/05/24 19:18:44 dholland Exp $");
+__RCSID("$NetBSD: main.c,v 1.15 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include <setjmp.h>
 #include <termios.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <err.h>
 #include <time.h>
 #include <sys/types.h>
 #include "trek.h"
 #include "getpar.h"
-# define	PRIO		00	/* default priority */
+#define PRIO		00	/* default priority */
 uid_t	Mother	= 51 + (51 << 8);
 /*
 **	 ####  #####    #    ####          #####  ####   #####  #   #
 **	#        #     # #   #   #           #    #   #  #      #  #
 **	 ###     #    #####  ####            #    ####   ###    ###
 **	    #    #    #   #  #  #            #    #  #   #      #  #
 **	####     #    #   #  #   #           #    #   #  #####  #   #
 **
 **	C version by Eric P. Allman 5/76 (U.C. Berkeley) with help
 **		from Jeff Poskanzer and Pete Rubinstein.
 **
 **	I also want to thank everyone here at Berkeley who
 **	where crazy enough to play the undebugged game.  I want to
 **	particularly thank Nick Whyte, who made considerable
 **	suggestions regarding the content of the game.  Why, I'll
 **	never forget the time he suggested the name for the
 **	"capture" command.
 **
 **	Please send comments, questions, and suggestions about this
 **		game to:
 **			Eric P. Allman
 **			Project INGRES
 **			Electronics Research Laboratory
 **			Cory Hall
 **			University of California
 **			Berkeley, California  94720
 **
 **	If you make ANY changes in the game, I sure would like to
 **	know about them.  It is sort of an ongoing project for me,
 **	and I very much want to put in any bug fixes and improvements
 **	that you might come up with.
 **
 **	FORTRASH version by Kay R. Fisher (DEC) "and countless others".
 **	That was adapted from the "original BASIC program" (ha!) by
 **		Mike Mayfield (Centerline Engineering).
 **
 **	Additional inspiration taken from FORTRAN version by
 **		David Matuszek and Paul Reynolds which runs on the CDC
 **		7600 at Lawrence Berkeley Lab, maintained there by
 **		Andy Davidson.  This version is also available at LLL
 **		and at LMSC.  In all fairness, this version was the
 **		major inspiration for this version of the game (trans-
 **		lation:  I ripped off a whole lot of code).
 **
 **	Minor other input from the "Battelle Version 7A" by Joe Miller
 **		(Graphics Systems Group, Battelle-Columbus Labs) and
 **		Ross Pavlac (Systems Programmer, Battelle Memorial
 **		Institute).  That version was written in December '74
 **		and extensively modified June '75.  It was adapted
 **		from the FTN version by Ron Williams of CDC Sunnyvale,
 **		which was adapted from the Basic version distributed
 **		by DEC.  It also had "neat stuff swiped" from T. T.
 **		Terry and Jim Korp (University of Texas), Hicks (Penn
 **		U.), and Rick Maus (Georgia Tech).  Unfortunately, it
 **		was not as readable as it could have been and so the
 **		translation effort was severely hampered.  None the
 **		less, I got the idea of inhabited starsystems from this
 **		version.
 **
 **	Permission is given for use, copying, and modification of
 **		all or part of this program and related documentation,
 **		provided that all reference to the authors are maintained.
 **
 **
 **********************************************************************
 **
 **  NOTES TO THE MAINTAINER:
 **
 **	There is a compilation option xTRACE which must be set for any
 **	trace information to be generated.  It is probably defined in
 **	the version that you get.  It can be removed, however, if you
 **	have trouble finding room in core.
 **
 **	Many things in trek are not as clear as they might be, but are
 **	done to reduce space.  I compile with the -f and -O flags.  I
 **	am constrained to running with non-separated I/D space, since
 **	we don't have doubleing point hardware here; even if we did, I
 **	would like trek to be available to the large number of people
 **	who either have an 11/40 or do not have FP hardware.  I also
 **	found it desirable to make the code run reentrant, so this
 **	added even more space constraints.
 **
 **	I use the portable C library to do my I/O.  This is done be-
 **	cause I wanted the game easily transportable to other C
 **	implementations, and because I was too lazy to do the doubleing
 **	point input myself.  Little did I know.  The portable C library
 **	released by Bell Labs has more bugs than you would believe, so
 **	I ended up rewriting the whole blessed thing.  Trek excercises
 **	many of the bugs in it, as well as bugs in some of the section
 **	III UNIX routines.  We have fixed them here.  One main problem
 **	was a bug in alloc() that caused it to always ask for a large
 **	hunk of memory, which worked fine unless you were almost out,
 **	which I inevitably was.  If you want the code for all of this
 **	stuff, it is also available through me.
 **
 ***********************************************************************
 */
 jmp_buf env;
 int main(int, char **);
 int
 main(int argc, char **argv)
+{
 	time_t		curtime;
 	long			vect;
 	char		opencode;
 	int			prio;
 	int		ac;
 	char		**av;
 	struct	termios		argp;
 	/* Revoke setgid privileges */
 	setgid(getgid());
 	av = argv;
 	ac = argc;
 	av++;
 	time(&curtime);
 	vect = (long) curtime;
 	srand(vect);
 	opencode = 'w';
 	prio = PRIO;
 	if (tcgetattr(1, &argp) == 0)
+	{
 		if (cfgetispeed(&argp) < B1200)
 			Etc.fast++;
+	}
 	while (ac > 1 && av[0][0] == '-')
+	{
 		switch (av[0][1])
+		{
 		  case 'a':	/* append to log file */
 			opencode = 'a';
 			break;
 		  case 'f':	/* set fast mode */
 			Etc.fast++;
 			break;
 		  case 's':	/* set slow mode */
 			Etc.fast = 0;
 			break;
-#		ifdef xTRACE
+#ifdef xTRACE
 		  case 't':	/* trace */
 			if (getuid() != Mother)
 				goto badflag;
 			Trace++;
 			break;
-#		endif
+#endif
 		  case 'p':	/* set priority */
 			if (getuid() != Mother)
 				goto badflag;
 			prio = atoi(av[0] + 2);
 			break;
 		  default:
 		  badflag:
 			printf("Invalid option: %s\n", av[0]);
+		}
 		ac--;
 		av++;
+	}
 	if (ac > 2)
 		errx(1, "arg count");
 		/*
 	if (ac > 1)
 		f_log = fopen(av[0], opencode);
 		*/
 	printf("\n   * * *   S T A R   T R E K   * * *\n\nPress return to continue.\n");
 	if (setjmp(env))
+	{
 		if ( !getynpar("Another game") )
 			exit(0);
+	}
 	do
+	{
 		setup();
 		play();
 	} while (getynpar("Another game"));
 	fflush(stdout);
 	return 0;
+}

 @@ -1,232 +1,232 @@
-/*	$NetBSD: move.c,v 1.7 2009/05/24 19:18:44 dholland Exp $	*/
+/*	$NetBSD: move.c,v 1.8 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)move.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: move.c,v 1.7 2009/05/24 19:18:44 dholland Exp $");
+__RCSID("$NetBSD: move.c,v 1.8 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include <math.h>
 #include "trek.h"
 /*
 **  Move Under Warp or Impulse Power
 **
 **	`Ramflag' is set if we are to be allowed to ram stars,
 **	Klingons, etc.  This is passed from warp(), which gets it from
 **	either play() or ram().  Course is the course (0 -> 360) at
 **	which we want to move.  `Speed' is the speed we
 **	want to go, and `time' is the expected time.  It
 **	can get cut short if a long range tractor beam is to occur.  We
 **	cut short the move so that the user doesn't get docked time and
 **	energy for distance which he didn't travel.
 **
 **	We check the course through the current quadrant to see that he
 **	doesn't run into anything.  After that, though, space sort of
 **	bends around him.  Note that this puts us in the awkward posi-
 **	tion of being able to be dropped into a sector which is com-
 **	pletely surrounded by stars.  Oh Well.
 **
 **	If the SINS (Space Inertial Navigation System) is out, we ran-
 **	domize the course accordingly before ever starting to move.
 **	We will still move in a straight line.
 **
 **	Note that if your computer is out, you ram things anyway.  In
 **	other words, if your computer and sins are both out, you're in
 **	potentially very bad shape.
 **
 **	Klingons get a chance to zap you as you leave the quadrant.
 **	By the way, they also try to follow you (heh heh).
 **
 **	Return value is the actual amount of time used.
 **
 **
 **	Uses trace flag 4.
 */
 double
 move(int ramflag, int course, double time, double speed)
+{
 	double			angle;
 	double			x, y, dx, dy;
 	int		ix = 0, iy = 0;
 	double			bigger;
 	int			n;
 	int		i;
 	double			dist;
 	double			sectsize;
 	double			xn;
 	double			evtime;
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
 		printf("move: ramflag %d course %d time %.2f speed %.2f\n",
 			ramflag, course, time, speed);
-#	endif
+#endif
 	sectsize = NSECTS;
 	/* initialize delta factors for move */
 	angle = course * 0.0174532925;
 	if (damaged(SINS))
 		angle += Param.navigcrud[1] * (franf() - 0.5);
 	else
 		if (Ship.sinsbad)
 			angle += Param.navigcrud[0] * (franf() - 0.5);
 	dx = -cos(angle);
 	dy = sin(angle);
 	bigger = fabs(dx);
 	dist = fabs(dy);
 	if (dist > bigger)
 		bigger = dist;
 	dx /= bigger;
 	dy /= bigger;
 	/* check for long range tractor beams */
 	/****  TEMPORARY CODE == DEBUGGING  ****/
 	evtime = Now.eventptr[E_LRTB]->date - Now.date;
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
 		printf("E.ep = %p, ->evcode = %d, ->date = %.2f, evtime = %.2f\n",
 			Now.eventptr[E_LRTB], Now.eventptr[E_LRTB]->evcode,
 			Now.eventptr[E_LRTB]->date, evtime);
-#	endif
+#endif
 	if (time > evtime && Etc.nkling < 3)
+	{
 		/* then we got a LRTB */
 		evtime += 0.005;
 		time = evtime;
+	}
 	else
 		evtime = -1.0e50;
 	dist = time * speed;
 	/* move within quadrant */
 	Sect[Ship.sectx][Ship.secty] = EMPTY;
 	x = Ship.sectx + 0.5;
 	y = Ship.secty + 0.5;
 	xn = NSECTS * dist * bigger;
 	n = xn + 0.5;
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
 		printf("dx = %.2f, dy = %.2f, xn = %.2f, n = %d\n", dx, dy, xn, n);
-#	endif
+#endif
 	Move.free = 0;
 	for (i = 0; i < n; i++)
+	{
 		ix = (x += dx);
 		iy = (y += dy);
-#		ifdef xTRACE
+#ifdef xTRACE
 		if (Trace)
 			printf("ix = %d, x = %.2f, iy = %d, y = %.2f\n", ix, x, iy, y);
-#		endif
+#endif
 		if (x < 0.0 || y < 0.0 || x >= sectsize || y >= sectsize)
+		{
 			/* enter new quadrant */
 			dx = Ship.quadx * NSECTS + Ship.sectx + dx * xn;
 			dy = Ship.quady * NSECTS + Ship.secty + dy * xn;
 			if (dx < 0.0)
 				ix = -1;
 			else
 				ix = dx + 0.5;
 			if (dy < 0.0)
 				iy = -1;
 			else
 				iy = dy + 0.5;
-#			ifdef xTRACE
+#ifdef xTRACE
 			if (Trace)
 				printf("New quad: ix = %d, iy = %d\n", ix, iy);
-#			endif
+#endif
 			Ship.sectx = x;
 			Ship.secty = y;
 			compkldist(0);
 			Move.newquad = 2;
 			attack(0);
 			checkcond();
 			Ship.quadx = ix / NSECTS;
 			Ship.quady = iy / NSECTS;
 			Ship.sectx = ix % NSECTS;
 			Ship.secty = iy % NSECTS;
 			if (ix < 0 || Ship.quadx >= NQUADS || iy < 0 ||
 			    Ship.quady >= NQUADS) {
 				if (!damaged(COMPUTER)) {
 					dumpme(0);
 				} else
 					lose(L_NEGENB);
+			}
 			initquad(0);
 			n = 0;
 			break;
+		}
 		if (Sect[ix][iy] != EMPTY)
+		{
 			/* we just hit something */
 			if (!damaged(COMPUTER) && ramflag <= 0)
+			{
 				ix = x - dx;
 				iy = y - dy;
 				printf("Computer reports navigation error; %s stopped at %d,%d\n",
 					Ship.shipname, ix, iy);
 				Ship.energy -= Param.stopengy * speed;
 				break;
+			}
 			/* test for a black hole */
 			if (Sect[ix][iy] == HOLE)
+			{
 				/* get dumped elsewhere in the galaxy */
 				dumpme(1);
 				initquad(0);
 				n = 0;
 				break;
+			}
 			ram(ix, iy);
 			break;
+		}
+	}
 	if (n > 0)
+	{
 		dx = Ship.sectx - ix;
 		dy = Ship.secty - iy;
 		dist = sqrt(dx * dx + dy * dy) / NSECTS;
 		time = dist / speed;
 		if (evtime > time)
 			time = evtime;		/* spring the LRTB trap */
 		Ship.sectx = ix;
 		Ship.secty = iy;
+	}
 	Sect[Ship.sectx][Ship.secty] = Ship.ship;
 	compkldist(0);
 	return (time);
+}

 @@ -1,384 +1,384 @@
-/*	$NetBSD: phaser.c,v 1.11 2009/05/24 19:18:44 dholland Exp $	*/
+/*	$NetBSD: phaser.c,v 1.12 2009/05/24 20:39:43 dholland Exp $	*/
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)phaser.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: phaser.c,v 1.11 2009/05/24 19:18:44 dholland Exp $");
+__RCSID("$NetBSD: phaser.c,v 1.12 2009/05/24 20:39:43 dholland Exp $");
 #endif
 #endif /* not lint */
 #include <stdio.h>
 #include <math.h>
 #include "trek.h"
 #include "getpar.h"
 /* factors for phaser hits; see description below */
-# define	ALPHA		3.0		/* spread */
+#define ALPHA		3.0		/* spread */
-# define	BETA		3.0		/* franf() */
+#define BETA		3.0		/* franf() */
-# define	GAMMA		0.30		/* cos(angle) */
+#define GAMMA		0.30		/* cos(angle) */
-# define	EPSILON		150.0		/* dist ** 2 */
+#define EPSILON		150.0		/* dist ** 2 */
-# define	OMEGA		10.596		/* overall scaling factor */
+#define OMEGA		10.596		/* overall scaling factor */
 /* OMEGA ~= 100 * (ALPHA + 1) * (BETA + 1) / (EPSILON + 1) */
 /*
 **  Phaser Control
 **
 **	There are up to NBANKS phaser banks which may be fired
 **	simultaneously.  There are two modes, "manual" and
 **	"automatic".  In manual mode, you specify exactly which
 **	direction you want each bank to be aimed, the number
 **	of units to fire, and the spread angle.  In automatic
 **	mode, you give only the total number of units to fire.
 **
 **	The spread is specified as a number between zero and
 **	one, with zero being minimum spread and one being maximum
 **	spread.  You  will normally want zero spread, unless your
 **	short range scanners are out, in which case you probably
 **	don't know exactly where the Klingons are.  In that case,
 **	you really don't have any choice except to specify a
 **	fairly large spread.
 **
 **	Phasers spread slightly, even if you specify zero spread.
 **
 **	Uses trace flag 30
 */
 struct cvntab	Matab[] =
+{
 	{ "m",		"anual",	(cmdfun) 1,	0 },
 	{ "a",		"utomatic",	(cmdfun) 0,	0 },
 	{ NULL,		NULL,		NULL,		0 }
 };
 struct banks
+{
 	int	units;
 	double	angle;
 	double	spread;
 };
 /*ARGSUSED*/
 void
 phaser(int v __unused)
+{
 	int		i;
 	int		j;
 	struct kling	*k;
 	double		dx, dy;
 	double		anglefactor, distfactor;
 	struct banks	*b;
 	int		manual, flag, extra = 0;
 	int		hit;
 	double		tot;
 	int		n;
 	int		hitreqd[NBANKS];
 	struct banks	bank[NBANKS];
 	const struct cvntab	*ptr;
 	if (Ship.cond == DOCKED) {
 		printf("Phasers cannot fire through starbase shields\n");
 		return;
+	}
 	if (damaged(PHASER)) {
 		out(PHASER);
 		return;
+	}
 	if (Ship.shldup) {
 		printf("Sulu: Captain, we cannot fire through shields.\n");
 		return;
+	}
 	if (Ship.cloaked)
+	{
 		printf("Sulu: Captain, surely you must realize that we cannot fire\n");
 		printf("  phasers with the cloaking device up.\n");
 		return;
+	}
 	/* decide if we want manual or automatic mode */
 	manual = 0;
 	if (testnl())
+	{
 		if (damaged(COMPUTER))
+		{
 			printf("%s", Device[COMPUTER].name);
 			manual++;
+		}
 		else
 			if (damaged(SRSCAN))
+			{
 				printf("%s", Device[SRSCAN].name);
 				manual++;
+			}
 		if (manual)
 			printf(" damaged, manual mode selected\n");
+	}
 	if (!manual)
+	{
 		ptr = getcodpar("Manual or automatic", Matab);
 		manual = (long) ptr->value;
+	}
 	if (!manual && damaged(COMPUTER))
+	{
 		printf("Computer damaged, manual selected\n");
 		skiptonl(0);
 		manual++;
+	}
 	/* initialize the bank[] array */
 	flag = 1;
 	for (i = 0; i < NBANKS; i++)
 		bank[i].units = 0;
 	if (manual)
+	{
 		/* collect manual mode statistics */
 		while (flag)
+		{
 			printf("%d units available\n", Ship.energy);
 			extra = 0;
 			flag = 0;
 			for (i = 0; i < NBANKS; i++)
+			{
 				b = &bank[i];
 				printf("\nBank %d:\n", i);
 				hit = getintpar("units");
 				if (hit < 0)
 					return;
 				if (hit == 0)
 					break;
 				extra += hit;
 				if (extra > Ship.energy)
+				{
 					printf("available energy exceeded.  ");
 					skiptonl(0);
 					flag++;
 					break;
+				}
 				b->units = hit;
 				hit = getintpar("course");
 				if (hit < 0 || hit > 360)
 					return;
 				b->angle = hit * 0.0174532925;
 				b->spread = getfltpar("spread");
 				if (b->spread < 0 || b->spread > 1)
 					return;
+			}
 			Ship.energy -= extra;
+		}
 		extra = 0;
+	}
 	else
+	{
 		/* automatic distribution of power */
 		if (Etc.nkling <= 0) {
 			printf("Sulu: But there are no Klingons in this quadrant\n");
 			return;
+		}
 		printf("Phasers locked on target.  ");
 		while (flag)
+		{
 			printf("%d units available\n", Ship.energy);
 			hit = getintpar("Units to fire");
 			if (hit <= 0)
 				return;
 			if (hit > Ship.energy)
+			{
 				printf("available energy exceeded.  ");
 				skiptonl(0);
 				continue;
+			}
 			flag = 0;
 			Ship.energy -= hit;
 			extra = hit;
 			n = Etc.nkling;
 			if (n > NBANKS)
 				n = NBANKS;
 			tot = n * (n + 1) / 2;
 			for (i = 0; i < n; i++)
+			{
 				k = &Etc.klingon[i];
 				b = &bank[i];
 				distfactor = k->dist;
 				anglefactor = ALPHA * BETA * OMEGA / (distfactor * distfactor + EPSILON);
 				anglefactor *= GAMMA;
 				distfactor = k->power;
 				distfactor /= anglefactor;
 				hitreqd[i] = distfactor + 0.5;
 				dx = Ship.sectx - k->x;
 				dy = k->y - Ship.secty;
 				b->angle = atan2(dy, dx);
 				b->spread = 0.0;
 				b->units = ((n - i) / tot) * extra;
-#				ifdef xTRACE
+#ifdef xTRACE
 				if (Trace)
+				{
 					printf("b%d hr%d u%d df%.2f af%.2f\n",
 						i, hitreqd[i], b->units,
 						distfactor, anglefactor);
+				}
-#				endif
+#endif
 				extra -= b->units;
 				hit = b->units - hitreqd[i];
 				if (hit > 0)
+				{
 					extra += hit;
 					b->units -= hit;
+				}
+			}
 			/* give out any extra energy we might have around */
 			if (extra > 0)
+			{
 				for (i = 0; i < n; i++)
+				{
 					b = &bank[i];
 					hit = hitreqd[i] - b->units;
 					if (hit <= 0)
 						continue;
 					if (hit >= extra)
+					{
 						b->units += extra;
 						extra = 0;
 						break;
+					}
 					b->units = hitreqd[i];
 					extra -= hit;
+				}
 				if (extra > 0)
 					printf("%d units overkill\n", extra);
+			}
+		}
+	}
-#	ifdef xTRACE
+#ifdef xTRACE
 	if (Trace)
+	{
 		for (i = 0; i < NBANKS; i++)
+		{
 			b = &bank[i];
 			printf("b%d u%d", i, b->units);
 			if (b->units > 0)
 				printf(" a%.2f s%.2f\n", b->angle, b->spread);
 			else
 				printf("\n");
+		}
+	}
-#	endif
+#endif
 	/* actually fire the shots */
 	Move.free = 0;
 	for (i = 0; i < NBANKS; i++)
+	{
 		b = &bank[i];
 		if (b->units <= 0)
+		{
 			continue;
+		}
 		printf("\nPhaser bank %d fires:\n", i);
 		n = Etc.nkling;
 		k = Etc.klingon;
 		for (j = 0; j < n; j++)
+		{
 			if (b->units <= 0)
 				break;
 			/*
 			** The formula for hit is as follows:
 			**
 			**  zap = OMEGA * [(sigma + ALPHA) * (rho + BETA)]
 			**	/ (dist ** 2 + EPSILON)]
 			**	* [cos(delta * sigma) + GAMMA]
 			**	* hit
 			**
 			** where sigma is the spread factor,
 			** rho is a random number (0 -> 1),
 			** GAMMA is a crud factor for angle (essentially
 			**	cruds up the spread factor),
 			** delta is the difference in radians between the
 			**	angle you are shooting at and the actual
 			**	angle of the klingon,
 			** ALPHA scales down the significance of sigma,
 			** BETA scales down the significance of rho,
 			** OMEGA is the magic number which makes everything
 			**	up to "* hit" between zero and one,
 			** dist is the distance to the klingon
 			** hit is the number of units in the bank, and
 			** zap is the amount of the actual hit.
 			**
 			** Everything up through dist squared should maximize
 			** at 1.0, so that the distance factor is never
 			** greater than one.  Conveniently, cos() is
 			** never greater than one, but the same restric-
 			** tion applies.
 			*/
 			distfactor = BETA + franf();
 			distfactor *= ALPHA + b->spread;
 			distfactor *= OMEGA;
 			anglefactor = k->dist;
 			distfactor /= anglefactor * anglefactor + EPSILON;
 			distfactor *= b->units;
 			dx = Ship.sectx - k->x;
 			dy = k->y - Ship.secty;
 			anglefactor = atan2(dy, dx) - b->angle;
 			anglefactor = cos((anglefactor * b->spread) + GAMMA);
 			if (anglefactor < 0.0)
+			{
 				k++;
 				continue;
+			}
 			hit = anglefactor * distfactor + 0.5;
 			k->power -= hit;
 			printf("%d unit hit on Klingon", hit);
 			if (!damaged(SRSCAN))
 				printf(" at %d,%d", k->x, k->y);
 			printf("\n");
 			b->units -= hit;
 			if (k->power <= 0)
+			{
 				killk(k->x, k->y);
 				continue;
+			}
 			k++;
+		}
+	}
 	/* compute overkill */
 	for (i = 0; i < NBANKS; i++)
 		extra += bank[i].units;
 	if (extra > 0)
 		printf("\n%d units expended on empty space\n", extra);
+}