X-Git-Url: https://jxself.org/git/?p=super-star-trek.git;a=blobdiff_plain;f=src%2Fsst.py;h=33149f30dcd454bec93b83d6f344a993d5121dfd;hp=7a54d8b89068674854335678c1e771234843e2ea;hb=3590e0facac5ef56922642ab463ba1ccffd58464;hpb=8c4200ad2ce7e8d65007b14157e41dd785a99538

diff --git a/src/sst.py b/src/sst.py
index 7a54d8b..33149f3 100644
--- a/src/sst.py
+++ b/src/sst.py
@@ -1,17 +1,190 @@
+#!/usr/bin/env python
 """
 sst.py =-- Super Star Trek in Python
 
-This code is a Python translation of a C translation of a FORTRAN original.
-The FORTRANness still shows in many ways, notably the use of 1-origin index
-an a lot of parallel arrays where a more modern language would use structures
-or objects.
+This code is a Python translation of a C translation of a FORTRAN
+original dating back to 1973.  Beautiful Python it is not.  But it
+works.
+
+Dave Matuszek says:
+
+SRSCAN, MOVE, PHASERS, CALL, STATUS, IMPULSE, PHOTONS, ABANDON,
+LRSCAN, WARP, SHIELDS, DESTRUCT, CHART, REST, DOCK, QUIT, and DAMAGE
+were in the original non-"super" version of UT FORTRAN Star Trek.
+
+Tholians were not in the original. Dave is dubious about their merits.
+(They are now controlled by OPTION_THOLIAN and turned off if the game
+type is "plain".)
+
+Planets and dilithium crystals were not in the original.  Dave is OK
+with this idea. (It's now controlled by OPTION_PLANETS and turned 
+off if the game type is "plain".)
+
+Dave says the bit about the Galileo getting turned into a
+McDonald's is "consistant with our original vision".  (This has been
+left permanently enabled, as it can only happen if OPTION_PLANETS
+is on.)
+
+Dave also says the Space Thingy should not be preserved across saved
+games, so you can't prove to others that you've seen it.  He says it
+shouldn't fire back, either.  It should do nothing except scream and
+disappear when hit by photon torpedos.  It's OK that it may move
+when attacked, but it didn't in the original.  (Whether the Thingy
+can fire back is now controlled by OPTION_THINGY and turned off if the
+game type is "plain" or "almy".  The no-save behavior has been restored.)
+
+The Faerie Queen, black holes, and time warping were in the original.
+
+Here are Tom Almy's changes:
+
+In early 1997, I got the bright idea to look for references to
+"Super Star Trek" on the World Wide Web. There weren't many hits,
+but there was one that came up with 1979 Fortran sources! This
+version had a few additional features that mine didn't have,
+however mine had some feature it didn't have. So I merged its
+features that I liked. I also took a peek at the DECUS version (a
+port, less sources, to the PDP-10), and some other variations.
+
+1, Compared to the original UT version, I've changed the "help"
+command to "call" and the "terminate" command to "quit" to better
+match user expectations. The DECUS version apparently made those
+changes as well as changing "freeze" to "save". However I like
+"freeze".  (Both "freeze" and "save" work in SST2K.)
+
+2. The experimental deathray originally had only a 5% chance of
+success, but could be used repeatedly. I guess after a couple
+years of use, it was less "experimental" because the 1979
+version had a 70% success rate. However it was prone to breaking
+after use. I upgraded the deathray, but kept the original set of
+failure modes (great humor!).  (Now controlled by OPTION_DEATHRAY
+and turned off if game type is "plain".)
+
+3. The 1979 version also mentions srscan and lrscan working when
+docked (using the starbase's scanners), so I made some changes here
+to do this (and indicating that fact to the player), and then realized
+the base would have a subspace radio as well -- doing a Chart when docked
+updates the star chart, and all radio reports will be heard. The Dock
+command will also give a report if a base is under attack.
+
+4. Tholian Web from the 1979 version.  (Now controlled by
+OPTION_THOLIAN and turned off if game type is "plain".)
+
+5. Enemies can ram the Enterprise. (Now controlled by OPTION_RAMMING
+and turned off if game type is "plain".)
+
+6. Regular Klingons and Romulans can move in Expert and Emeritus games. 
+This code could use improvement. (Now controlled by OPTION_MVBADDY
+and turned off if game type is "plain".)
+
+7. The deep-space probe feature from the DECUS version.  (Now controlled
+by OPTION_PROBE and turned off if game type is "plain").
+
+8. 'emexit' command from the 1979 version.
+
+9. Bugfix: Klingon commander movements are no longer reported if long-range 
+sensors are damaged.
+
+10. Bugfix: Better base positioning at startup (more spread out).
+That made sense to add because most people abort games with 
+bad base placement.
+
+In June 2002, I fixed two known bugs and a documentation typo.
+In June 2004 I fixed a number of bugs involving: 1) parsing invalid
+numbers, 2) manual phasers when SR scan is damaged and commander is
+present, 3) time warping into the future, 4) hang when moving
+klingons in crowded quadrants.  (These fixes are in SST2K.)
+
+Here are Stas Sergeev's changes:
+
+1. The Space Thingy can be shoved, if you ram it, and can fire back if 
+fired upon. (Now controlled by OPTION_THINGY and turned off if game 
+type is "plain" or "almy".)
+
+2. When you are docked, base covers you with an almost invincible shield. 
+(A commander can still ram you, or a Romulan can destroy the base,
+or a SCom can even succeed with direct attack IIRC, but this rarely 
+happens.)  (Now controlled by OPTION_BASE and turned off if game 
+type is "plain" or "almy".)
+
+3. Ramming a black hole is no longer instant death.  There is a
+chance you might get timewarped instead. (Now controlled by 
+OPTION_BLKHOLE and turned off if game type is "plain" or "almy".)
+
+4. The Tholian can be hit with phasers.
+
+5. SCom can't escape from you if no more enemies remain 
+(without this, chasing SCom can take an eternity).
+
+6. Probe target you enter is now the destination quadrant. Before I don't 
+remember what it was, but it was something I had difficulty using.
+
+7. Secret password is now autogenerated.
+
+8. "Plaque" is adjusted for A4 paper :-)
+
+9. Phasers now tells you how much energy needed, but only if the computer 
+is alive.
+
+10. Planets are auto-scanned when you enter the quadrant.
+
+11. Mining or using crystals in presense of enemy now yields an attack.
+There are other minor adjustments to what yields an attack
+and what does not.
+
+12. "freeze" command reverts to "save", most people will understand this
+better anyway. (SST2K recognizes both.)
+
+13. Screen-oriented interface, with sensor scans always up.  (SST2K
+supports both screen-oriented and TTY modes.)
+
+Eric Raymond's changes:
+
+Mainly, I translated this C code out of FORTRAN into C -- created #defines
+for a lot of magic numbers and refactored the heck out of it.
+
+1. "sos" and "call" becomes "mayday", "freeze" and "save" are both good.
+
+2. Status report now indicates when dilithium crystals are on board.
+
+3. Per Dave Matuszek's remarks, Thingy state is never saved across games.
+
+4. Added game option selection so you can play a close (but not bug-for-
+bug identical) approximation of older versions.
+
+5. Half the quadrants now have inhabited planets, from which one 
+cannot mine dilithium (there will still be the same additional number
+of dilithium-bearing planets).  Torpedoing an inhabited world is *bad*.
+There is BSD-Trek-like logic for Klingons to attack and enslave 
+inhabited worlds, producing more ships (only is skill is 'good' or 
+better). (Controlled by OPTION_WORLDS and turned off if game 
+type is "plain" or "almy".)
+
+6. User input is now logged so we can do regression testing.
+
+7. More BSD-Trek features: You can now lose if your entire crew
+dies in battle.  When abandoning ship in a game with inhabited
+worlds enabled, they must have one in the quadrant to beam down
+to; otherwise they die in space and this counts heavily against
+your score.  Docking at a starbase replenishes your crew.
+
+8. Still more BSD-Trek: we now have a weighted damage table.
+Also, the nav subsystem (enabling automatic course
+setting) can be damaged separately from the main computer (which
+handles weapons targeting, ETA calculation, and self-destruct).
+
+After these features were added, I translated this into Python and added
+more:
+
+9. A long-range scan is done silently whenever you call CHART; thus
+the LRSCAN command is no longer needed.  (Controlled by OPTION_AUTOSCAN
+and turned off if game type is "plain" or "almy".)
 """
-import os, sys, math, curses, time, atexit, readline
+import os, sys, math, curses, time, readline, cPickle, random, copy, gettext
 
-SSTDOC = "/usr/share/doc/sst/sst.doc"
+SSTDOC  	= "/usr/share/doc/sst/sst.doc"
+DOC_NAME	= "sst.doc"
 
-# Stub to be replaced
-def _(str): return str
+def _(str): return gettext.gettext(str)
 
 PHASEFAC	= 2.0
 GALSIZE 	= 8
@@ -19,20 +192,14 @@ NINHAB  	= (GALSIZE * GALSIZE / 2)
 MAXUNINHAB	= 10
 PLNETMAX	= (NINHAB + MAXUNINHAB)
 QUADSIZE	= 10
+BASEMIN		= 2
 BASEMAX 	= (GALSIZE * GALSIZE / 12)
 MAXKLGAME	= 127
 MAXKLQUAD	= 9
 FULLCREW	= 428	# BSD Trek was 387, that's wrong 
 FOREVER 	= 1e30
-
-# These functions hide the difference between 0-origin and 1-origin addressing.
-def VALID_QUADRANT(x, y):	return ((x)>=1 and (x)<=GALSIZE and (y)>=1 and (y)<=GALSIZE)
-def VALID_SECTOR(x, y):	return ((x)>=1 and (x)<=QUADSIZE and (y)>=1 and (y)<=QUADSIZE)
-
-def square(i):		return ((i)*(i))
-def distance(c1, c2):	return math.sqrt(square(c1.x - c2.x) + square(c1.y - c2.y))
-def invalidate(w):	w.x = w.y = 0
-def is_valid(w):	return (w.x != 0 and w.y != 0)
+MAXBURST	= 3
+MINCMDR 	= 10
 
 # How to represent features
 IHR = 'R',
@@ -54,93 +221,130 @@ IHMATER0 = '-',
 IHMATER1 = 'o',
 IHMATER2 = '0'
 
+class TrekError:
+    pass
+
 class coord:
-    def __init(self, x=None, y=None):
-        self.x = x
-        self.y = y
+    def __init__(self, x=None, y=None):
+        self.i = x
+        self.j = y
+    def valid_quadrant(self):
+        return self.i>=0 and self.i<GALSIZE and self.j>=0 and self.j<GALSIZE
+    def valid_sector(self):
+	return self.i>=0 and self.i<QUADSIZE and self.j>=0 and self.j<QUADSIZE
     def invalidate(self):
-        self.x = self.y = None
+        self.i = self.j = None
     def is_valid(self):
-        return self.x != None and self.y != None
+        return self.i != None and self.j != None
     def __eq__(self, other):
-        return self.x == other.y and self.x == other.y
+        return other != None and self.i == other.i and self.j == other.j
+    def __ne__(self, other):
+        return other == None or self.i != other.i or self.j != other.j
     def __add__(self, other):
-        return coord(self.x+self.x, self.y+self.y)
+        return coord(self.i+other.i, self.j+other.j)
     def __sub__(self, other):
-        return coord(self.x-self.x, self.y-self.y)
-    def distance(self, other):
-        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
+        return coord(self.i-other.i, self.j-other.j)
+    def __mul__(self, other):
+        return coord(self.i*other, self.j*other)
+    def __rmul__(self, other):
+        return coord(self.i*other, self.j*other)
+    def __div__(self, other):
+        return coord(self.i/other, self.j/other)
+    def __rdiv__(self, other):
+        return coord(self.i/other, self.j/other)
+    def roundtogrid(self):
+        return coord(int(round(self.i)), int(round(self.j)))
+    def trunctogrid(self):
+        return coord(int(round(self.i)), int(round(self.j)))
+    def distance(self, other=None):
+        if not other: other = coord(0, 0)
+        return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
+    def bearing(self, other=None):
+        if not other: other = coord(0, 0)
+        return 1.90985*math.atan2(self.j-other.j, self.i-other.i)
     def sgn(self):
-        return coord(self.x / abs(x), self.y / abs(y));
+        s = coord()
+        if self.i == 0:
+            s.i = 0
+        else:
+            s.i = self.i / abs(self.i)
+        if self.j == 0:
+            s.j = 0
+        else:
+            s.j = self.j / abs(self.j)
+        return s
+    def scatter(self):
+        s = coord()
+        s.i = self.i + randrange(-1, 2)
+        s.j = self.j + randrange(-1, 2)
+        return s
     def __hash__(self):
         return hash((x, y))
     def __str__(self):
-        return "%d - %d" % (self.x, self.y)
+        if self.i == None or self.j == None:
+            return "Nowhere"
+        return "%s - %s" % (self.i+1, self.j+1)
+    __repr__ = __str__
 
 class planet:
-    def __init(self):
+    def __init__(self):
         self.name = None	# string-valued if inhabited
-        self.w = coord()	# quadrant located
+        self.quadrant = coord()	# quadrant located
         self.pclass = None	# could be ""M", "N", "O", or "destroyed"
-        self.crystals = None	# could be "mined", "present", "absent"
-        self.known = None	# could be "unknown", "known", "shuttle_down"
+        self.crystals = "absent"# could be "mined", "present", "absent"
+        self.known = "unknown"	# could be "unknown", "known", "shuttle_down"
+        self.inhabited = False	# is it inhabites?
     def __str__(self):
         return self.name
 
-NOPLANET = None
 class quadrant:
-    def __init(self):
-        self.stars = None
+    def __init__(self):
+        self.stars = 0
         self.planet = None
-	self.starbase = None
-	self.klingons = None
-	self.romulans = None
-	self.supernova = None
-	self.charted = None
-        self.status = None	# Could be "secure", "distressed", "enslaved"
+	self.starbase = False
+	self.klingons = 0
+	self.romulans = 0
+	self.supernova = False
+	self.charted = False
+        self.status = "secure"	# Could be "secure", "distressed", "enslaved"
 
 class page:
-    def __init(self):
+    def __init__(self):
 	self.stars = None
 	self.starbase = None
 	self.klingons = None
 
+def fill2d(size, fillfun):
+    "Fill an empty list in 2D."
+    lst = []
+    for i in range(size):
+        lst.append([]) 
+        for j in range(size):
+            lst[i].append(fillfun(i, j))
+    return lst
+
 class snapshot:
-    def __init(self):
+    def __init__(self):
         self.snap = False	# snapshot taken
-        self.crew = None	# crew complement
-	self.remkl = None	# remaining klingons
-	self.remcom = None	# remaining commanders
-	self.nscrem = None	# remaining super commanders
-	self.rembase = None	# remaining bases
-	self.starkl = None	# destroyed stars
-	self.basekl = None	# destroyed bases
-	self.nromrem = None	# Romulans remaining
-	self.nplankl = None	# destroyed uninhabited planets
-	self.nworldkl = None	# destroyed inhabited planets
+        self.crew = 0   	# crew complement
+	self.remkl = 0  	# remaining klingons
+	self.nscrem = 0		# remaining super commanders
+	self.starkl = 0 	# destroyed stars
+	self.basekl = 0 	# destroyed bases
+	self.nromrem = 0	# Romulans remaining
+	self.nplankl = 0	# destroyed uninhabited planets
+	self.nworldkl = 0	# destroyed inhabited planets
         self.planets = []	# Planet information
-        for i in range(PLNETMAX):
-            self.planets.append(planet())
-        self.date = None	# stardate
-	self.remres = None	# remaining resources
-	self.remtime = None	# remaining time
+        self.date = 0.0   	# stardate
+	self.remres = 0 	# remaining resources
+	self.remtime = 0	# remaining time
         self.baseq = [] 	# Base quadrant coordinates
-        for i in range(BASEMAX+1):
-            self.baseq.append(coord())
         self.kcmdr = [] 	# Commander quadrant coordinates
-        for i in range(QUADSIZE+1):
-            self.kcmdr.append(coord())
 	self.kscmdr = coord()	# Supercommander quadrant coordinates
-        self.galaxy = [] 	# The Galaxy (subscript 0 not used)
-        for i in range(GALSIZE+1):
-            self.chart.append([])
-            for j in range(GALSIZE+1):
-                self.galaxy[i].append(quadrant())
-    	self.chart = [] 	# the starchart (subscript 0 not used)
-        for i in range(GALSIZE+1):
-            self.chart.append([])
-            for j in range(GALSIZE+1):
-                self.chart[i].append(page())
+        # the galaxy
+        self.galaxy = fill2d(GALSIZE, lambda i, j: quadrant())
+        # the starchart
+    	self.chart = fill2d(GALSIZE, lambda i, j: page())
 
 class event:
     def __init__(self):
@@ -153,15 +357,16 @@ OPTION_TTY	= 0x00000001	# old interface
 OPTION_CURSES	= 0x00000002	# new interface 
 OPTION_IOMODES	= 0x00000003	# cover both interfaces 
 OPTION_PLANETS	= 0x00000004	# planets and mining 
-OPTION_THOLIAN	= 0x00000008	# Tholians and their webs 
-OPTION_THINGY	= 0x00000010	# Space Thingy can shoot back 
-OPTION_PROBE	= 0x00000020	# deep-space probes 
+OPTION_THOLIAN	= 0x00000008	# Tholians and their webs (UT 1979 version)
+OPTION_THINGY	= 0x00000010	# Space Thingy can shoot back (Stas, 2005)
+OPTION_PROBE	= 0x00000020	# deep-space probes (DECUS version, 1980)
 OPTION_SHOWME	= 0x00000040	# bracket Enterprise in chart 
-OPTION_RAMMING	= 0x00000080	# enemies may ram Enterprise 
-OPTION_MVBADDY	= 0x00000100	# more enemies can move 
-OPTION_BLKHOLE	= 0x00000200	# black hole may timewarp you 
-OPTION_BASE	= 0x00000400	# bases have good shields 
-OPTION_WORLDS	= 0x00000800	# logic for inhabited worlds 
+OPTION_RAMMING	= 0x00000080	# enemies may ram Enterprise (Almy)
+OPTION_MVBADDY	= 0x00000100	# more enemies can move (Almy)
+OPTION_BLKHOLE	= 0x00000200	# black hole may timewarp you (Stas, 2005) 
+OPTION_BASE	= 0x00000400	# bases have good shields (Stas, 2005)
+OPTION_WORLDS	= 0x00000800	# logic for inhabited worlds (ESR, 2006)
+OPTION_AUTOSCAN	= 0x00001000	# automatic LRSCAN before CHART (ESR, 2006)
 OPTION_PLAIN	= 0x01000000	# user chose plain game 
 OPTION_ALMY	= 0x02000000	# user chose Almy variant 
 
@@ -216,39 +421,60 @@ NEVENTS	= 12
 # 
 def findevent(evtype):	return game.future[evtype]
 
+class enemy:
+    def __init__(self, type=None, loc=None, power=None):
+        self.type = type
+        self.kloc = coord()
+        if loc:
+            self.move(loc)
+        self.kpower = power	# enemy energy level
+        game.enemies.append(self)
+    def move(self, loc):
+        motion = (loc != self.kloc)
+        if self.kloc.i is not None and self.kloc.j is not None:
+            if motion:
+                if self.type == IHT:
+                    game.quad[self.kloc.i][self.kloc.j] = IHWEB
+                else:
+                    game.quad[self.kloc.i][self.kloc.j] = IHDOT
+        if loc:
+            self.kloc = copy.copy(loc)
+            game.quad[self.kloc.i][self.kloc.j] = self.type
+            self.kdist = self.kavgd = (game.sector - loc).distance()
+        else:
+            self.kloc = coord()
+            self.kdist = self.kavgd = None
+            game.enemies.remove(self)
+        return motion
+    def __repr__(self):
+        return "<%s,%s.%f>" % (self.type, self.kloc, self.kpower)	# For debugging
+
 class gamestate:
     def __init__(self):
         self.options = None	# Game options
-        self.state = None	# A snapshot structure
-        self.snapsht = None	# Last snapshot taken for time-travel purposes
-        self.quad = [[IHDOT * (QUADSIZE+1)] * (QUADSIZE+1)]	# contents of our quadrant
-        self.kpower = [[0 * (QUADSIZE+1)] * (QUADSIZE+1)]	# enemy energy levels
-        self.kdist = [[0 * (QUADSIZE+1)] * (QUADSIZE+1)]	# enemy distances
-        self.kavgd = [[0 * (QUADSIZE+1)] * (QUADSIZE+1)]	# average distances
-        self.damage = [0] * NDEVICES	# damage encountered
-        self.future = [0.0] * NEVENTS	# future events
+        self.state = snapshot()	# A snapshot structure
+        self.snapsht = snapshot()	# Last snapshot taken for time-travel purposes
+        self.quad = None	# contents of our quadrant
+        self.damage = [0.0] * NDEVICES	# damage encountered
+        self.future = []		# future events
         for i in range(NEVENTS):
             self.future.append(event())
         self.passwd  = None;		# Self Destruct password
-        self.ks = [[None * (QUADSIZE+1)] * (QUADSIZE+1)]	# enemy sector locations
+        self.enemies = []
         self.quadrant = None	# where we are in the large
         self.sector = None	# where we are in the small
-        self.tholian = None	# coordinates of Tholian
+        self.tholian = None	# Tholian enemy object
         self.base = None	# position of base in current quadrant
         self.battle = None	# base coordinates being attacked
         self.plnet = None	# location of planet in quadrant
-        self.probec = None	# current probe quadrant
         self.gamewon = False	# Finished!
         self.ididit = False	# action taken -- allows enemy to attack
         self.alive = False	# we are alive (not killed)
         self.justin = False	# just entered quadrant
         self.shldup = False	# shields are up
         self.shldchg = False	# shield is changing (affects efficiency)
-        self.comhere = False	# commander here
-        self.ishere = False	# super-commander in quadrant
         self.iscate = False	# super commander is here
         self.ientesc = False	# attempted escape from supercommander
-        self.ithere = False	# Tholian is here 
         self.resting = False	# rest time
         self.icraft = False	# Kirk in Galileo
         self.landed = False	# party on planet (true), on ship (false)
@@ -278,13 +504,11 @@ class gamestate:
         self.casual = 0		# causalties
         self.nhelp = 0		# calls for help
         self.nkinks = 0		# count of energy-barrier crossings
-        self.iplnet = 0		# planet # in quadrant
+        self.iplnet = None	# planet # in quadrant
         self.inplan = 0		# initial planets
-        self.nenhere = 0	# number of enemies in quadrant
         self.irhere = 0		# Romulans in quadrant
         self.isatb = 0		# =1 if super commander is attacking base
-        self.tourn = 0		# tournament number
-        self.proben = 0		# number of moves for probe
+        self.tourn = None	# tournament number
         self.nprobes = 0	# number of probes available
         self.inresor = 0.0	# initial resources
         self.intime = 0.0	# initial time
@@ -297,27 +521,22 @@ class gamestate:
         self.warpfac = 0.0	# warp speed
         self.wfacsq = 0.0	# squared warp factor
         self.lsupres = 0.0	# life support reserves
-        self.dist = 0.0		# movement distance
-        self.direc = 0.0	# movement direction
         self.optime = 0.0	# time taken by current operation
         self.docfac = 0.0	# repair factor when docking (constant?)
         self.damfac = 0.0	# damage factor
         self.lastchart = 0.0	# time star chart was last updated
         self.cryprob = 0.0	# probability that crystal will work
-        self.probex = 0.0	# location of probe
-        self.probey = 0.0	#
-        self.probeinx = 0.0	# probe x,y increment
-        self.probeiny = 0.0	#
+        self.probe = None	# object holding probe course info
         self.height = 0.0	# height of orbit around planet
     def recompute(self):
         # Stas thinks this should be (C expression): 
-        # game.state.remkl + game.state.remcom > 0 ?
-	#	game.state.remres/(game.state.remkl + 4*game.state.remcom) : 99
+        # game.state.remkl + len(game.state.kcmdr) > 0 ?
+	#	game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) : 99
         # He says the existing expression is prone to divide-by-zero errors
         # after killing the last klingon when score is shown -- perhaps also
         # if the only remaining klingon is SCOM.
-        game.state.remtime = game.state.remres/(game.state.remkl + 4*game.state.remcom)
-# From enumerated type 'feature'
+        game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr))
+
 IHR = 'R'
 IHK = 'K'
 IHC = 'C'
@@ -337,8 +556,6 @@ IHMATER0 = '-'
 IHMATER1 = 'o'
 IHMATER2 = '0'
 
-
-# From enumerated type 'FINTYPE'
 FWON = 0
 FDEPLETE = 1
 FLIFESUP = 2
@@ -362,71 +579,68 @@ FTRIBBLE = 19
 FHOLE = 20
 FCREW = 21
 
-# From enumerated type 'COLORS'
-DEFAULT = 0
-BLACK = 1
-BLUE = 2
-GREEN = 3
-CYAN = 4
-RED = 5
-MAGENTA = 6
-BROWN = 7
-LIGHTGRAY = 8
-DARKGRAY = 9
-LIGHTBLUE = 10
-LIGHTGREEN = 11
-LIGHTCYAN = 12
-LIGHTRED = 13
-LIGHTMAGENTA = 14
-YELLOW = 15
-WHITE = 16
+def withprob(p):
+    v = random.random()
+    #logfp.write("# withprob(%s) -> %f (%s) at %s\n" % (p, v, v<p, traceback.extract_stack()[-2][1:]))
+    return v < p
+
+def randrange(*args):
+    v = random.randrange(*args)
+    #logfp.write("# randrange%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
+    return v
+
+def randreal(*args):
+    v = random.random()
+    if len(args) == 1:
+        v *= args[0] 		# returns from [0, args[0])
+    elif len(args) == 2:
+        v = args[0] + v*(args[1]-args[0])	# returns from [args[0], args[1])
+    #logfp.write("# randreal%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
+    return v
 
 # Code from ai.c begins here
 
-def tryexit(look, ienm, loccom, irun):
-    # a bad guy attempts to bug out 
+def welcoming(iq):
+    "Would this quadrant welcome another Klingon?"
+    return iq.valid_quadrant() and \
+	not game.state.galaxy[iq.i][iq.j].supernova and \
+	game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD
+
+def tryexit(enemy, look, irun):
+    "A bad guy attempts to bug out."
     iq = coord()
-    iq.x = game.quadrant.x+(look.x+(QUADSIZE-1))/QUADSIZE - 1
-    iq.y = game.quadrant.y+(look.y+(QUADSIZE-1))/QUADSIZE - 1
-    if not VALID_QUADRANT(iq.x,iq.y) or \
-	game.state.galaxy[iq.x][iq.y].supernova or \
-	game.state.galaxy[iq.x][iq.y].klingons > MAXKLQUAD-1:
-	return False; # no can do -- neg energy, supernovae, or >MAXKLQUAD-1 Klingons 
-    if ienm == IHR:
+    iq.i = game.quadrant.i+(look.i+(QUADSIZE-1))/QUADSIZE - 1
+    iq.j = game.quadrant.j+(look.j+(QUADSIZE-1))/QUADSIZE - 1
+    if not welcoming(iq):
+	return False;
+    if enemy.type == IHR:
 	return False; # Romulans cannot escape! 
     if not irun:
 	# avoid intruding on another commander's territory 
-	if ienm == IHC:
-	    for n in range(1, game.state.remcom+1):
-		if game.state.kcmdr[n] == iq:
-		    return False
+	if enemy.type == IHC:
+            if iq in game.state.kcmdr:
+                return False
 	    # refuse to leave if currently attacking starbase 
 	    if game.battle == game.quadrant:
 		return False
 	# don't leave if over 1000 units of energy 
-	if game.kpower[loccom] > 1000.0:
+	if enemy.kpower > 1000.0:
 	    return False
-    # print escape message and move out of quadrant.
+    # emit escape message and move out of quadrant.
     # we know this if either short or long range sensors are working
     if not damaged(DSRSENS) or not damaged(DLRSENS) or \
-	game.condition == docked:
-	crmena(True, ienm, "sector", game.ks[loccom])
-	prout(_(" escapes to Quadrant %s (and regains strength).") % q)
-    # handle local matters related to escape 
-    game.quad[game.ks[loccom].x][game.ks[loccom].y] = IHDOT
-    game.ks[loccom] = game.ks[game.nenhere]
-    game.kavgd[loccom] = game.kavgd[game.nenhere]
-    game.kpower[loccom] = game.kpower[game.nenhere]
-    game.kdist[loccom] = game.kdist[game.nenhere]
+	game.condition == "docked":
+	prout(crmena(True, enemy.type, "sector", enemy.kloc) + \
+              (_(" escapes to Quadrant %s (and regains strength).") % q))
+    # handle local matters related to escape
+    enemy.move(None)
     game.klhere -= 1
-    game.nenhere -= 1
-    if game.condition != docked:
+    if game.condition != "docked":
 	newcnd()
     # Handle global matters related to escape 
-    game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons -= 1
-    game.state.galaxy[iq.x][iq.y].klingons += 1
-    if ienm==IHS:
-	game.ishere = False
+    game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
+    game.state.galaxy[iq.i][iq.j].klingons += 1
+    if enemy.type==IHS:
 	game.iscate = False
 	game.ientesc = False
 	game.isatb = 0
@@ -434,14 +648,12 @@ def tryexit(look, ienm, loccom, irun):
 	unschedule(FSCDBAS)
 	game.state.kscmdr=iq
     else:
-	for n in range(1, game.state.remcom+1):
-	    if game.state.kcmdr[n] == game.quadrant:
-		game.state.kcmdr[n]=iq
+	for cmdr in game.state.kcmdr:
+	    if cmdr == game.quadrant:
+		game.state.kcmdr[n] = iq
 		break
-	game.comhere = False
     return True; # success 
 
-#
 # The bad-guy movement algorithm:
 # 
 # 1. Enterprise has "force" based on condition of phaser and photon torpedoes.
@@ -479,29 +691,26 @@ def tryexit(look, ienm, loccom, irun):
 # retreat, especially at high skill levels.
 # 
 # 5.  Motion is limited to skill level, except for SC hi-tailing it out.
-# 
 
-def movebaddy(com, loccom, ienm):
-    # tactical movement for the bad guys 
+def movebaddy(enemy):
+    "Tactical movement for the bad guys."
     next = coord(); look = coord()
     irun = False
-    # This should probably be just game.comhere + game.ishere 
+    # This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant) 
     if game.skill >= SKILL_EXPERT:
-	nbaddys = ((game.comhere*2 + game.ishere*2+game.klhere*1.23+game.irhere*1.5)/2.0)
+	nbaddys = (((game.quadrant in game.state.kcmdr)*2 + (game.state.kscmdr==game.quadrant)*2+game.klhere*1.23+game.irhere*1.5)/2.0)
     else:
-	nbaddys = game.comhere + game.ishere
-
-    dist1 = game.kdist[loccom]
+	nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
+    dist1 = enemy.kdist
     mdist = int(dist1 + 0.5); # Nearest integer distance 
-
     # If SC, check with spy to see if should hi-tail it 
-    if ienm==IHS and \
-	(game.kpower[loccom] <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
+    if enemy.type==IHS and \
+	(enemy.kpower <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
 	irun = True
 	motion = -QUADSIZE
     else:
 	# decide whether to advance, retreat, or hold position 
-	forces = game.kpower[loccom]+100.0*game.nenhere+400*(nbaddys-1)
+	forces = enemy.kpower+100.0*len(game.enemies)+400*(nbaddys-1)
 	if not game.shldup:
 	    forces += 1000; # Good for enemy if shield is down! 
 	if not damaged(DPHASER) or not damaged(DPHOTON):
@@ -518,12 +727,12 @@ def movebaddy(com, loccom, ienm):
 	    forces += 1000.0
 	motion = 0
         if forces <= 1000.0 and game.condition != "docked": # Typical situation 
-	    motion = ((forces+200.0*Rand())/150.0) - 5.0
+	    motion = ((forces + randreal(200))/150.0) - 5.0
 	else:
             if forces > 1000.0: # Very strong -- move in for kill 
-		motion = (1.0-square(Rand()))*dist1 + 1.0
+		motion = (1.0 - randreal())**2 * dist1 + 1.0
 	    if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off ! 
-		motion -= game.skill*(2.0-square(Rand()))
+		motion -= game.skill*(2.0-randreal()**2)
 	if idebug:
 	    proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces))
 	# don't move if no motion 
@@ -536,10 +745,7 @@ def movebaddy(com, loccom, ienm):
             else:
                 motion = game.skill
     # calculate preferred number of steps 
-    if motion < 0:
-        msteps = -motion
-    else:
-        msteps = motion
+    nsteps = abs(int(motion))
     if motion > 0 and nsteps > mdist:
 	nsteps = mdist; # don't overshoot 
     if nsteps > QUADSIZE:
@@ -549,68 +755,57 @@ def movebaddy(com, loccom, ienm):
     if idebug:
 	proutn("NSTEPS = %d:" % nsteps)
     # Compute preferred values of delta X and Y 
-    mx = game.sector.x - com.x
-    my = game.sector.y - com.y
-    if 2.0 * abs(mx) < abs(my):
-	mx = 0
-    if 2.0 * abs(my) < abs(game.sector.x-com.x):
-	my = 0
-    if mx != 0:
-        if mx*motion < 0:
-            mx = -1
-        else:
-            mx = 1
-    if my != 0:
-        if my*motion < 0:
-            my = -1
-        else:
-            my = 1
-    next = com
+    m = game.sector - enemy.kloc
+    if 2.0 * abs(m.i) < abs(m.j):
+	m.i = 0
+    if 2.0 * abs(m.j) < abs(game.sector.i-enemy.kloc.i):
+	m.j = 0
+    m = (motion * m).sgn()
+    next = enemy.kloc
     # main move loop 
     for ll in range(nsteps):
 	if idebug:
 	    proutn(" %d" % (ll+1))
 	# Check if preferred position available 
-	look.x = next.x + mx
-	look.y = next.y + my
-        if mx < 0:
-            krawlx = 1
+	look = next + m
+        if m.i < 0:
+            krawli = 1
         else:
-            krawlx = -1
-        if my < 0:
-            krawly = 1
+            krawli = -1
+        if m.j < 0:
+            krawlj = 1
         else:
-            krawly = -1
+            krawlj = -1
 	success = False
 	attempts = 0; # Settle mysterious hang problem 
 	while attempts < 20 and not success:
             attempts += 1
-	    if look.x < 1 or look.x > QUADSIZE:
-		if motion < 0 and tryexit(look, ienm, loccom, irun):
+	    if look.i < 0 or look.i >= QUADSIZE:
+		if motion < 0 and tryexit(enemy, look, irun):
 		    return
-		if krawlx == mx or my == 0:
+		if krawli == m.i or m.j == 0:
 		    break
-		look.x = next.x + krawlx
-		krawlx = -krawlx
-	    elif look.y < 1 or look.y > QUADSIZE:
-		if motion < 0 and tryexit(look, ienm, loccom, irun):
+		look.i = next.i + krawli
+		krawli = -krawli
+	    elif look.j < 0 or look.j >= QUADSIZE:
+		if motion < 0 and tryexit(enemy, look, irun):
 		    return
-		if krawly == my or mx == 0:
+		if krawlj == m.j or m.i == 0:
 		    break
-		look.y = next.y + krawly
-		krawly = -krawly
-	    elif (game.options & OPTION_RAMMING) and game.quad[look.x][look.y] != IHDOT:
-		# See if we should ram ship 
-		if game.quad[look.x][look.y] == game.ship and \
-		    (ienm == IHC or ienm == IHS):
-		    ram(True, ienm, com)
+		look.j = next.j + krawlj
+		krawlj = -krawlj
+	    elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != IHDOT:
+		# See if enemy should ram ship 
+		if game.quad[look.i][look.j] == game.ship and \
+		    (enemy.type == IHC or enemy.type == IHS):
+		    collision(rammed=True, enemy=enemy)
 		    return
-		if krawlx != mx and my != 0:
-		    look.x = next.x + krawlx
-		    krawlx = -krawlx
-		elif krawly != my and mx != 0:
-		    look.y = next.y + krawly
-		    krawly = -krawly
+		if krawli != m.i and m.j != 0:
+		    look.i = next.i + krawli
+		    krawli = -krawli
+		elif krawlj != m.j and m.i != 0:
+		    look.j = next.j + krawlj
+		    krawlj = -krawlj
 		else:
 		    break; # we have failed 
 	    else:
@@ -621,156 +816,128 @@ def movebaddy(com, loccom, ienm):
 		proutn(`next`)
 	else:
 	    break; # done early 
-	
     if idebug:
 	skip(1)
-    # Put commander in place within same quadrant 
-    game.quad[com.x][com.y] = IHDOT
-    game.quad[next.x][next.y] = ienm
-    if next != com:
-	# it moved 
-	game.ks[loccom] = next
-	game.kdist[loccom] = game.kavgd[loccom] = distance(game.sector, next)
-	if not damaged(DSRSENS) or game.condition == docked:
-	    proutn("***")
-	    cramen(ienm)
-	    proutn(_(" from Sector %s") % com)
-	    if game.kdist[loccom] < dist1:
+    if enemy.move(next):
+	if not damaged(DSRSENS) or game.condition == "docked":
+	    proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.kloc))
+	    if enemy.kdist < dist1:
 		proutn(_(" advances to "))
 	    else:
 		proutn(_(" retreats to "))
 	    prout("Sector %s." % next)
 
 def moveklings():
-    # Klingon tactical movement 
+    "Sequence Klingon tactical movement."
     if idebug:
 	prout("== MOVCOM")
     # Figure out which Klingon is the commander (or Supercommander)
     # and do move
-    if game.comhere:
-	for i in range(1, game.nenhere+1):
-	    w = game.ks[i]
-	    if game.quad[w.x][w.y] == IHC:
-		movebaddy(w, i, IHC)
-		break
-    if game.ishere:
-	for i in range(1, game.nenhere+1):
-	    w = game.ks[i]
-	    if game.quad[w.x][w.y] == IHS:
-		movebaddy(w, i, IHS)
+    if game.quadrant in game.state.kcmdr:
+        for enemy in game.enemies:
+	    if enemy.type == IHC:
+		movebaddy(enemy)
+    if game.state.kscmdr==game.quadrant:
+        for enemy in game.enemies:
+	    if enemy.type == IHS:
+		movebaddy(enemy)
 		break
     # If skill level is high, move other Klingons and Romulans too!
     # Move these last so they can base their actions on what the
     # commander(s) do.
     if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
-	for i in range(1, game.nenhere+1):
-	    w = game.ks[i]
-	    if game.quad[w.x][w.y] == IHK or game.quad[w.x][w.y] == IHR:
-		movebaddy(w, i, game.quad[w.x][w.y])
-    sortklings();
+        for enemy in game.enemies:
+            if enemy.type in (IHK, IHR):
+		movebaddy(enemy)
+    game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
 
 def movescom(iq, avoid):
-    # commander movement helper 
-    if iq == game.quadrant or not VALID_QUADRANT(iq.x, iq.y) or \
-	game.state.galaxy[iq.x][iq.y].supernova or \
-	game.state.galaxy[iq.x][iq.y].klingons > MAXKLQUAD-1:
-	return 1
-    if avoid:
-	# Avoid quadrants with bases if we want to avoid Enterprise 
-	for i in range(1, game.state.rembase+1):
-	    if game.state.baseq[i] == iq:
-		return True
+    "Commander movement helper." 
+    # Avoid quadrants with bases if we want to avoid Enterprise 
+    if not welcoming(iq) or (avoid and iq in game.state.baseq):
+	return False
     if game.justin and not game.iscate:
-	return True
+	return False
     # do the move 
-    game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].klingons -= 1
+    game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons -= 1
     game.state.kscmdr = iq
-    game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].klingons += 1
-    if game.ishere:
+    game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons += 1
+    if game.state.kscmdr==game.quadrant:
 	# SC has scooted, Remove him from current quadrant 
 	game.iscate=False
 	game.isatb=0
-	game.ishere = False
 	game.ientesc = False
 	unschedule(FSCDBAS)
-	for i in range(1, game.nenhere+1):
-	    if game.quad[game.ks[i].x][game.ks[i].y] == IHS:
+	for enemy in game.enemies:
+	    if enemy.type == IHS:
 		break
-	game.quad[game.ks[i].x][game.ks[i].y] = IHDOT
-	game.ks[i] = game.ks[game.nenhere]
-	game.kdist[i] = game.kdist[game.nenhere]
-	game.kavgd[i] = game.kavgd[game.nenhere]
-	game.kpower[i] = game.kpower[game.nenhere]
+	enemy.move(None)
 	game.klhere -= 1
-	game.nenhere -= 1
-	if game.condition!=docked:
+	if game.condition != "docked":
 	    newcnd()
-	sortklings()
+        game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
     # check for a helpful planet 
     for i in range(game.inplan):
-	if game.state.planets[i].w == game.state.kscmdr and \
+	if game.state.planets[i].quadrant == game.state.kscmdr and \
 	    game.state.planets[i].crystals == "present":
 	    # destroy the planet 
 	    game.state.planets[i].pclass = "destroyed"
-	    game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].planet = NOPLANET
+	    game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].planet = None
 	    if communicating():
 		announce()
 		prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
 		proutn(_("   a planet in Quadrant %s has been destroyed") % game.state.kscmdr)
 		prout(_("   by the Super-commander.\""))
 	    break
-    return False; # looks good! 
+    return True; # looks good! 
 			
 def supercommander():
-    # move the Super Commander 
+    "Move the Super Commander." 
     iq = coord(); sc = coord(); ibq = coord(); idelta = coord()
     basetbl = []
     if idebug:
 	prout("== SUPERCOMMANDER")
     # Decide on being active or passive 
-    avoid = ((game.incom - game.state.remcom + game.inkling - game.state.remkl)/(game.state.date+0.01-game.indate) < 0.1*game.skill*(game.skill+1.0) or \
+    avoid = ((game.incom - len(game.state.kcmdr) + game.inkling - game.state.remkl)/(game.state.date+0.01-game.indate) < 0.1*game.skill*(game.skill+1.0) or \
 	    (game.state.date-game.indate) < 3.0)
     if not game.iscate and avoid:
 	# compute move away from Enterprise 
 	idelta = game.state.kscmdr-game.quadrant
-	if math.sqrt(idelta.x*idelta.x+idelta.y*idelta.y) > 2.0:
+	if idelta.distance() > 2.0:
 	    # circulate in space 
-	    idelta.x = game.state.kscmdr.y-game.quadrant.y
-	    idelta.y = game.quadrant.x-game.state.kscmdr.x
+	    idelta.i = game.state.kscmdr.j-game.quadrant.j
+	    idelta.j = game.quadrant.i-game.state.kscmdr.i
     else:
 	# compute distances to starbases 
-	if game.state.rembase <= 0:
+	if not game.state.baseq:
 	    # nothing left to do 
 	    unschedule(FSCMOVE)
 	    return
 	sc = game.state.kscmdr
-	for i in range(1, game.state.rembase+1):
-	    basetbl.append((i, distance(game.state.baseq[i], sc)))
-	if game.state.rembase > 1:
+        for base in game.state.baseq:
+	    basetbl.append((i, (base - sc).distance()))
+	if game.state.baseq > 1:
             basetbl.sort(lambda x, y: cmp(x[1]. y[1]))
 	# look for nearest base without a commander, no Enterprise, and
         # without too many Klingons, and not already under attack. 
 	ifindit = iwhichb = 0
-	for i2 in range(1, game.state.rembase+1):
+	for (i2, base) in enumerate(game.state.baseq):
 	    i = basetbl[i2][0];	# bug in original had it not finding nearest
-	    ibq = game.state.baseq[i]
-	    if ibq == game.quadrant or ibq == game.battle or \
-		game.state.galaxy[ibq.x][ibq.y].supernova or \
-		game.state.galaxy[ibq.x][ibq.y].klingons > MAXKLQUAD-1:
+	    if base==game.quadrant or base==game.battle or not welcoming(base):
 		continue
 	    # if there is a commander, and no other base is appropriate,
-	    #   we will take the one with the commander
-	    for j in range(1, game.state.remcom+1):
-		if ibq == game.state.kcmdr[j] and ifindit!= 2:
+	    # we will take the one with the commander
+            for cmdr in game.state.kcmdr:
+		if base == cmdr and ifindit != 2:
 		    ifindit = 2
 		    iwhichb = i
 		    break
-	    if j > game.state.remcom: # no commander -- use this one 
+	    else:	# no commander -- use this one 
 		ifindit = 1
 		iwhichb = i
 		break
 	if ifindit==0:
-	    return; # Nothing suitable -- wait until next time
+	    return # Nothing suitable -- wait until next time
 	ibq = game.state.baseq[iwhichb]
 	# decide how to move toward base 
 	idelta = ibq - game.state.kscmdr
@@ -780,44 +947,43 @@ def supercommander():
     # there was what looked like a bug in the Almy C code here,
     # but it might be this translation is just wrong.
     iq = game.state.kscmdr + idelta
-    if movescom(iq, avoid):
+    if not movescom(iq, avoid):
 	# failed -- try some other maneuvers 
-	if idelta.x==0 or idelta.y==0:
+	if idelta.i==0 or idelta.j==0:
 	    # attempt angle move 
-	    if idelta.x != 0:
-		iq.y = game.state.kscmdr.y + 1
-		if movescom(iq, avoid):
-		    iq.y = game.state.kscmdr.y - 1
+	    if idelta.i != 0:
+		iq.j = game.state.kscmdr.j + 1
+		if not movescom(iq, avoid):
+		    iq.j = game.state.kscmdr.j - 1
 		    movescom(iq, avoid)
-	    else:
-		iq.x = game.state.kscmdr.x + 1
-		if movescom(iq, avoid):
-		    iq.x = game.state.kscmdr.x - 1
+	    elif idelta.j != 0:
+		iq.i = game.state.kscmdr.i + 1
+		if not movescom(iq, avoid):
+		    iq.i = game.state.kscmdr.i - 1
 		    movescom(iq, avoid)
 	else:
 	    # try moving just in x or y 
-	    iq.y = game.state.kscmdr.y
-	    if movescom(iq, avoid):
-		iq.y = game.state.kscmdr.y + idelta.y
-		iq.x = game.state.kscmdr.x
+	    iq.j = game.state.kscmdr.j
+	    if not movescom(iq, avoid):
+		iq.j = game.state.kscmdr.j + idelta.j
+		iq.i = game.state.kscmdr.i
 		movescom(iq, avoid)
     # check for a base 
-    if game.state.rembase == 0:
+    if len(game.state.baseq) == 0:
 	unschedule(FSCMOVE)
     else:
-	for i in range(1, game.state.rembase+1):
-	    ibq = game.state.baseq[i]
+        for ibq in game.state.baseq:
 	    if ibq == game.state.kscmdr and game.state.kscmdr == game.battle:
 		# attack the base 
 		if avoid:
-		    return; # no, don't attack base! 
+		    return # no, don't attack base! 
 		game.iseenit = False
 		game.isatb = 1
-		schedule(FSCDBAS, 1.0 +2.0*Rand())
+		schedule(FSCDBAS, randreal(1.0, 3.0))
 		if is_scheduled(FCDBAS):
 		    postpone(FSCDBAS, scheduled(FCDBAS)-game.state.date)
 		if not communicating():
-		    return; # no warning 
+		    return # no warning 
 		game.iseenit = True
 		announce()
 		prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") \
@@ -835,95 +1001,85 @@ def supercommander():
 		return
     # Check for intelligence report 
     if not idebug and \
-	(Rand() > 0.2 or \
+	(withprob(0.8) or \
 	 (not communicating()) or \
-	 not game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].charted):
+	 not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].charted):
 	return
     announce()
     prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
     proutn(_("   the Super-commander is in Quadrant %s,") % game.state.kscmdr)
-    return;
+    return
 
 def movetholian():
-    # move the Tholian 
-    if not game.ithere or game.justin:
+    "Move the Tholian."
+    if not game.tholian or game.justin:
 	return
-
-    if game.tholian.x == 1 and game.tholian.y == 1:
-	idx = 1; idy = QUADSIZE
-    elif game.tholian.x == 1 and game.tholian.y == QUADSIZE:
-	idx = QUADSIZE; idy = QUADSIZE
-    elif game.tholian.x == QUADSIZE and game.tholian.y == QUADSIZE:
-	idx = QUADSIZE; idy = 1
-    elif game.tholian.x == QUADSIZE and game.tholian.y == 1:
-	idx = 1; idy = 1
+    id = coord()
+    if game.tholian.kloc.i == 0 and game.tholian.kloc.j == 0:
+	id.i = 0; id.j = QUADSIZE-1
+    elif game.tholian.kloc.i == 0 and game.tholian.kloc.j == QUADSIZE-1:
+	id.i = QUADSIZE-1; id.j = QUADSIZE-1
+    elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == QUADSIZE-1:
+	id.i = QUADSIZE-1; id.j = 0
+    elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == 0:
+	id.i = 0; id.j = 0
     else:
 	# something is wrong! 
-	game.ithere = False
+	game.tholian.move(None)
+        prout("***Internal error: Tholian in a bad spot.")
 	return
-
     # do nothing if we are blocked 
-    if game.quad[idx][idy]!= IHDOT and game.quad[idx][idy]!= IHWEB:
+    if game.quad[id.i][id.j] not in (IHDOT, IHWEB):
 	return
-    game.quad[game.tholian.x][game.tholian.y] = IHWEB
-
-    if game.tholian.x != idx:
-	# move in x axis 
-	im = math.fabs(idx - game.tholian.x)*1.0/(idx - game.tholian.x)
-	while game.tholian.x != idx:
-	    game.tholian.x += im
-	    if game.quad[game.tholian.x][game.tholian.y]==IHDOT:
-		game.quad[game.tholian.x][game.tholian.y] = IHWEB
-    elif game.tholian.y != idy:
-	# move in y axis 
-	im = math.fabs(idy - game.tholian.y)*1.0/(idy - game.tholian.y)
-	while game.tholian.y != idy:
-	    game.tholian.y += im
-	    if game.quad[game.tholian.x][game.tholian.y]==IHDOT:
-		game.quad[game.tholian.x][game.tholian.y] = IHWEB
-    game.quad[game.tholian.x][game.tholian.y] = IHT
-    game.ks[game.nenhere] = game.tholian
-
+    here = copy.copy(game.tholian.kloc)
+    delta = (id - game.tholian.kloc).sgn()
+    # move in x axis 
+    while here.i != id.i:
+        here.i += delta.i
+        if game.quad[here.i][here.j]==IHDOT:
+            game.tholian.move(here)
+    # move in y axis 
+    while here.j != id.j:
+        here.j += delta.j
+        if game.quad[here.i][here.j]==IHDOT:
+            game.tholian.move(here)
     # check to see if all holes plugged 
-    for i in range(1, QUADSIZE+1):
-	if game.quad[1][i]!=IHWEB and game.quad[1][i]!=IHT:
+    for i in range(QUADSIZE):
+	if game.quad[0][i]!=IHWEB and game.quad[0][i]!=IHT:
 	    return
-	if game.quad[QUADSIZE][i]!=IHWEB and game.quad[QUADSIZE][i]!=IHT:
+	if game.quad[QUADSIZE-1][i]!=IHWEB and game.quad[QUADSIZE-1][i]!=IHT:
 	    return
-	if game.quad[i][1]!=IHWEB and game.quad[i][1]!=IHT:
+	if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT:
 	    return
-	if game.quad[i][QUADSIZE]!=IHWEB and game.quad[i][QUADSIZE]!=IHT:
+	if game.quad[i][QUADSIZE-1]!=IHWEB and game.quad[i][QUADSIZE-1]!=IHT:
 	    return
     # All plugged up -- Tholian splits 
-    game.quad[game.tholian.x][game.tholian.y]=IHWEB
+    game.quad[game.tholian.kloc.i][game.tholian.kloc.j]=IHWEB
     dropin(IHBLANK)
-    crmena(True, IHT, "sector", game.tholian)
-    prout(_(" completes web."))
-    game.ithere = False
-    game.nenhere -= 1
+    prout(crmena(True, IHT, "sector", game.tholian) + _(" completes web."))
+    game.tholian.move(None)
     return
 
 # Code from battle.c begins here
 
 def doshield(shraise):
-    # change shield status 
+    "Change shield status."
     action = "NONE"
     game.ididit = False
     if shraise:
 	action = "SHUP"
     else:
-	key = scan()
-	if key == IHALPHA:
-	    if isit("transfer"):
+	key = scanner.next()
+	if key == "IHALPHA":
+	    if scanner.sees("transfer"):
 		action = "NRG"
 	    else:
-		chew()
 		if damaged(DSHIELD):
 		    prout(_("Shields damaged and down."))
 		    return
-		if isit("up"):
+		if scanner.sees("up"):
 		    action = "SHUP"
-		elif isit("down"):
+		elif scanner.sees("down"):
 		    action = "SHDN"
 	if action=="NONE":
 	    proutn(_("Do you wish to change shield energy? "))
@@ -938,14 +1094,14 @@ def doshield(shraise):
 		if ja() == True:
 		    action = "SHDN"
 		else:
-		    chew()
+		    scanner.chew()
 		    return
 	    else:
 		proutn(_("Shields are down. Do you want them up? "))
 		if ja() == True:
 		    action = "SHUP"
 		else:
-		    chew()
+		    scanner.chew()
 		    return    
     if action == "SHUP": # raise shields 
 	if game.shldup:
@@ -973,24 +1129,24 @@ def doshield(shraise):
 	game.ididit = True
 	return
     elif action == "NRG":
-	while scan() != IHREAL:
-	    chew()
+	while scanner.next() != "IHREAL":
+	    scanner.chew()
 	    proutn(_("Energy to transfer to shields- "))
-	chew()
-	if aaitem==0:
+	scanner.chew()
+	if scanner.real == 0:
 	    return
-	if aaitem > game.energy:
+	if scanner.real > game.energy:
 	    prout(_("Insufficient ship energy."))
 	    return
 	game.ididit = True
-	if game.shield+aaitem >= game.inshld:
+	if game.shield+scanner.real >= game.inshld:
 	    prout(_("Shield energy maximized."))
-	    if game.shield+aaitem > game.inshld:
+	    if game.shield+scanner.real > game.inshld:
 		prout(_("Excess energy requested returned to ship energy"))
 	    game.energy -= game.inshld-game.shield
 	    game.shield = game.inshld
 	    return
-	if aaitem < 0.0 and game.energy-aaitem > game.inenrg:
+	if scanner.real < 0.0 and game.energy-scanner.real > game.inenrg:
 	    # Prevent shield drain loophole 
 	    skip(1)
 	    prout(_("Engineering to bridge--"))
@@ -998,23 +1154,22 @@ def doshield(shraise):
 	    prout(_("  I can't drain the shields."))
 	    game.ididit = False
 	    return
-	if game.shield+aaitem < 0:
+	if game.shield+scanner.real < 0:
 	    prout(_("All shield energy transferred to ship."))
 	    game.energy += game.shield
 	    game.shield = 0.0
 	    return
 	proutn(_("Scotty- \""))
-	if aaitem > 0:
+	if scanner.real > 0:
 	    prout(_("Transferring energy to shields.\""))
 	else:
 	    prout(_("Draining energy from shields.\""))
-	game.shield += aaitem
-	game.energy -= aaitem
+	game.shield += scanner.real
+	game.energy -= scanner.real
 	return
 
 def randdevice():
-    # choose a device to damage, at random. 
-    #
+    "Choose a device to damage, at random."
     # Quoth Eric Allman in the code of BSD-Trek:
     # "Under certain conditions you can get a critical hit.  This
     # sort of hit damages devices.  The probability that a given
@@ -1028,7 +1183,7 @@ def randdevice():
     # 
     # This is one place where OPTION_PLAIN does not restore the
     # original behavior, which was equiprobable damage across
-    # all devices.  If we wanted that, we'd return NDEVICES*Rand()
+    # all devices.  If we wanted that, we'd return randrange(NDEVICES)
     # and have done with it.  Also, in the original game, DNAVYS
     # and DCOMPTR were the same device. 
     # 
@@ -1037,7 +1192,6 @@ def randdevice():
     # We don't have a cloaking device.  The shuttle got the allocation
     # for the cloaking device, then we shaved a half-percent off
     # everything to have some weight to give DSHCTRL/DDRAY/DDSP.
-    # 
     weights = (
 	105,	# DSRSENS: short range scanners	10.5% 
 	105,	# DLRSENS: long range scanners		10.5% 
@@ -1056,7 +1210,7 @@ def randdevice():
 	10,	# DDRAY: death ray			 1.0% 
 	30,	# DDSP: deep-space probes		 3.0% 
     )
-    idx = Rand() * 1000.0	# weights must sum to 1000 
+    idx = randrange(1000)	# weights must sum to 1000 
     sum = 0
     for (i, w) in enumerate(weights):
 	sum += w
@@ -1064,204 +1218,186 @@ def randdevice():
 	    return i
     return None;	# we should never get here
 
-def ram(ibumpd, ienm, w):
-    # make our ship ram something 
+def collision(rammed, enemy):
+    "Collision handling fot rammong events."
     prouts(_("***RED ALERT!  RED ALERT!"))
     skip(1)
     prout(_("***COLLISION IMMINENT."))
     skip(2)
     proutn("***")
-    crmshp()
-    hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(ienm, 1.0)
-    if ibumpd:
+    proutn(crmshp())
+    hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0)
+    if rammed:
         proutn(_(" rammed by "))
     else:
         proutn(_(" rams "))
-    crmena(False, ienm, sector, w)
-    if ibumpd:
+    proutn(crmena(False, enemy.type, "sector", enemy.kloc))
+    if rammed:
 	proutn(_(" (original position)"))
     skip(1)
-    deadkl(w, ienm, game.sector)
-    proutn("***")
-    crmshp()
-    prout(_(" heavily damaged."))
-    icas = 10.0+20.0*Rand()
+    deadkl(enemy.kloc, enemy.type, game.sector)
+    proutn("***" + crmship() + " heavily damaged.")
+    icas = randrange(10, 30)
     prout(_("***Sickbay reports %d casualties"), icas)
     game.casual += icas
     game.state.crew -= icas
-    #
     # In the pre-SST2K version, all devices got equiprobably damaged,
     # which was silly.  Instead, pick up to half the devices at
     # random according to our weighting table,
-    # 
-    ncrits = Rand() * (NDEVICES/2)
+    ncrits = randrange(NDEVICES/2)
     for m in range(ncrits):
 	dev = randdevice()
 	if game.damage[dev] < 0:
 	    continue
-	extradm = (10.0*hardness*Rand()+1.0)*game.damfac
+	extradm = (10.0*hardness*randreal()+1.0)*game.damfac
 	# Damage for at least time of travel! 
 	game.damage[dev] += game.optime + extradm
     game.shldup = False
     prout(_("***Shields are down."))
-    if game.state.remkl + game.state.remcom + game.state.nscrem:
+    if game.state.remkl + len(game.state.kcmdr) + game.state.nscrem:
 	announce()
 	damagereport()
     else:
 	finish(FWON)
-    return;
-
-def torpedo(course, r, incoming, i, n):
-    # let a photon torpedo fly 
-    iquad = 0
-    shoved = False
-    ac = course + 0.25*r
-    angle = (15.0-ac)*0.5235988
-    bullseye = (15.0 - course)*0.5235988
-    deltax = -math.sin(angle);
-    deltay = math.cos(angle);
-    x = incoming.x; y = incoming.y
-    w = coord(); jw = coord()
-    w.x = w.y = jw.x = jw.y = 0
-    bigger = max(math.fabs(deltax), math.fabs(deltay))
-    deltax /= bigger
-    deltay /= bigger
+    return
+
+def torpedo(origin, bearing, dispersion, number, nburst):
+    "Let a photon torpedo fly" 
     if not damaged(DSRSENS) or game.condition=="docked":
 	setwnd(srscan_window)
     else: 
 	setwnd(message_window)
+    ac = bearing + 0.25*dispersion	# dispersion is a random variable
+    bullseye = (15.0 - bearing)*0.5235988
+    track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin)) 
+    bumpto = coord(0, 0)
     # Loop to move a single torpedo 
-    for l in range(1, 15+1):
-	x += deltax
-	w.x = x + 0.5
-	y += deltay
-	w.y = y + 0.5
-	if not VALID_SECTOR(w.x, w.y):
+    setwnd(message_window)
+    for step in range(1, QUADSIZE*2):
+	track.next()
+        w = track.sector()
+	if not w.valid_sector():
 	    break
-	iquad=game.quad[w.x][w.y]
-	tracktorpedo(w, l, i, n, iquad)
+	iquad=game.quad[w.i][w.j]
+	tracktorpedo(origin, w, step, number, nburst, iquad)
 	if iquad==IHDOT:
 	    continue
 	# hit something 
-	setwnd(message_window)
-	if damaged(DSRSENS) and not game.condition=="docked":
+	if not damaged(DSRSENS) or game.condition == "docked":
 	    skip(1);	# start new line after text track 
 	if iquad in (IHE, IHF): # Hit our ship 
 	    skip(1)
-	    proutn(_("Torpedo hits "))
-	    crmshp()
-	    prout(".")
-	    hit = 700.0 + 100.0*Rand() - \
-		1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle))
+	    prout(_("Torpedo hits %s.") % crmshp())
+	    hit = 700.0 + randreal(100) - \
+		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
 	    newcnd(); # we're blown out of dock 
-	    # We may be displaced. 
 	    if game.landed or game.condition=="docked":
 		return hit # Cheat if on a planet 
-	    ang = angle + 2.5*(Rand()-0.5)
+	    ang = track.angle + 2.5*(randreal()-0.5)
 	    temp = math.fabs(math.sin(ang))
 	    if math.fabs(math.cos(ang)) > temp:
 		temp = math.fabs(math.cos(ang))
 	    xx = -math.sin(ang)/temp
 	    yy = math.cos(ang)/temp
-	    jw.x=w.x+xx+0.5
-	    jw.y=w.y+yy+0.5
-	    if not VALID_SECTOR(jw.x, jw.y):
+	    bumpto.i = int(w.i+xx+0.5)
+	    bumpto.j = int(w.j+yy+0.5)
+	    if not bumpto.valid_sector():
 		return hit
-	    if game.quad[jw.x][jw.y]==IHBLANK:
+	    if game.quad[bumpto.i][bumpto.j]==IHBLANK:
 		finish(FHOLE)
 		return hit
-	    if game.quad[jw.x][jw.y]!=IHDOT:
+	    if game.quad[bumpto.i][bumpto.j]!=IHDOT:
 		# can't move into object 
 		return hit
-	    game.sector = jw
-	    crmshp()
-	    shoved = True
-	elif iquad in (IHC, IHS): # Hit a commander 
-	    if Rand() <= 0.05:
-		crmena(True, iquad, sector, w)
-		prout(_(" uses anti-photon device;"))
+	    game.sector = bumpto
+	    proutn(crmshp())
+            game.quad[w.i][w.j]=IHDOT
+            game.quad[bumpto.i][bumpto.j]=iquad
+            prout(_(" displaced by blast to Sector %s ") % bumpto)
+            for enemy in game.enemies:
+                enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
+            game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+            return None
+	elif iquad in (IHC, IHS, IHR, IHK): # Hit a regular enemy 
+	    # find the enemy 
+	    if iquad in (IHC, IHS) and withprob(0.05):
+		prout(crmena(True, iquad, "sector", w) + _(" uses anti-photon device;"))
 		prout(_("   torpedo neutralized."))
 		return None
-	elif iquad in (IHR, IHK): # Hit a regular enemy 
-	    # find the enemy 
-	    for ll in range(1, game.nenhere+1):
-		if w == game.ks[ll]:
+            for enemy in game.enemies:
+		if w == enemy.kloc:
 		    break
-	    kp = math.fabs(game.kpower[ll])
-	    h1 = 700.0 + 100.0*Rand() - \
-		1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle))
+	    kp = math.fabs(enemy.kpower)
+	    h1 = 700.0 + randrange(100) - \
+		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
 	    h1 = math.fabs(h1)
 	    if kp < h1:
 		h1 = kp
-            if game.kpower[ll] < 0:
-                game.kpower[ll] -= -h1
+            if enemy.kpower < 0:
+                enemy.kpower -= -h1
             else:
-                game.kpower[ll] -= h1
-	    if game.kpower[ll] == 0:
+                enemy.kpower -= h1
+	    if enemy.kpower == 0:
 		deadkl(w, iquad, w)
 		return None
-	    crmena(True, iquad, "sector", w)
+	    proutn(crmena(True, iquad, "sector", w))
 	    # If enemy damaged but not destroyed, try to displace 
-	    ang = angle + 2.5*(Rand()-0.5)
+	    ang = track.angle + 2.5*(randreal()-0.5)
 	    temp = math.fabs(math.sin(ang))
 	    if math.fabs(math.cos(ang)) > temp:
 		temp = math.fabs(math.cos(ang))
 	    xx = -math.sin(ang)/temp
 	    yy = math.cos(ang)/temp
-	    jw.x=w.x+xx+0.5
-	    jw.y=w.y+yy+0.5
-	    if not VALID_SECTOR(jw.x, jw.y):
+	    bumpto.i = int(w.i+xx+0.5)
+	    bumpto.j = int(w.j+yy+0.5)
+            if not bumpto.valid_sector():
 		prout(_(" damaged but not destroyed."))
 		return
-	    if game.quad[jw.x][jw.y]==IHBLANK:
+	    if game.quad[bumpto.i][bumpto.j] == IHBLANK:
 		prout(_(" buffeted into black hole."))
-		deadkl(w, iquad, jw)
-		return None
-	    if game.quad[jw.x][jw.y]!=IHDOT:
-		# can't move into object 
+		deadkl(w, iquad, bumpto)
+	    if game.quad[bumpto.i][bumpto.j] != IHDOT:
 		prout(_(" damaged but not destroyed."))
-		return None
-	    proutn(_(" damaged--"))
-	    game.ks[ll] = jw
-	    shoved = True
-	    break
+            else:
+                prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
+                enemy.kloc = bumpto
+                game.quad[w.i][w.j]=IHDOT
+                game.quad[bumpto.i][bumpto.j]=iquad
+                for enemy in game.enemies:
+                    enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
+                game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+            return None
 	elif iquad == IHB: # Hit a base 
 	    skip(1)
 	    prout(_("***STARBASE DESTROYED.."))
-	    for ll in range(1, game.state.rembase+1):
-		if game.state.baseq[ll] == game.quadrant:
-		    game.state.baseq[ll]=game.state.baseq[game.state.rembase]
-		    break
-	    game.quad[w.x][w.y]=IHDOT
-	    game.state.rembase -= 1
-	    game.base.x=game.base.y=0
-	    game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase -= 1
-	    game.state.chart[game.quadrant.x][game.quadrant.y].starbase -= 1
+            game.state.baseq = filter(lambda x: x != game.quadrant, game.state.baseq)
+	    game.quad[w.i][w.j]=IHDOT
+	    game.base.invalidate()
+	    game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase -= 1
+	    game.state.chart[game.quadrant.i][game.quadrant.j].starbase -= 1
 	    game.state.basekl += 1
 	    newcnd()
 	    return None
 	elif iquad == IHP: # Hit a planet 
-	    crmena(True, iquad, sector, w)
-	    prout(_(" destroyed."))
+	    prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
 	    game.state.nplankl += 1
-	    game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = NOPLANET
-	    game.state.planets[game.iplnet].pclass = destroyed
-	    game.iplnet = 0
-	    invalidate(game.plnet)
-	    game.quad[w.x][w.y] = IHDOT
+	    game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
+	    game.iplnet.pclass = "destroyed"
+	    game.iplnet = None
+	    game.plnet.invalidate()
+	    game.quad[w.i][w.j] = IHDOT
 	    if game.landed:
 		# captain perishes on planet 
 		finish(FDPLANET)
 	    return None
 	elif iquad == IHW: # Hit an inhabited world -- very bad! 
-	    crmena(True, iquad, sector, w)
-	    prout(_(" destroyed."))
+	    prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
 	    game.state.nworldkl += 1
-	    game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = NOPLANET
-	    game.state.planets[game.iplnet].pclass = destroyed
-	    game.iplnet = 0
-	    invalidate(game.plnet)
-	    game.quad[w.x][w.y] = IHDOT
+	    game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
+	    game.iplnet.pclass = "destroyed"
+	    game.iplnet = None
+	    game.plnet.invalidate()
+	    game.quad[w.i][w.j] = IHDOT
 	    if game.landed:
 		# captain perishes on planet 
 		finish(FDPLANET)
@@ -1269,14 +1405,13 @@ def torpedo(course, r, incoming, i, n):
 	    prout(_("Celebratory rallies are being held on the Klingon homeworld."))
 	    return None
 	elif iquad == IHSTAR: # Hit a star 
-	    if Rand() > 0.10:
+	    if withprob(0.9):
 		nova(w)
-		return None
-	    crmena(True, IHSTAR, sector, w)
-	    prout(_(" unaffected by photon blast."))
+            else:
+                prout(crmena(True, IHSTAR, "sector", w) + _(" unaffected by photon blast."))
 	    return None
 	elif iquad == IHQUEST: # Hit a thingy 
-	    if not (game.options & OPTION_THINGY) or Rand()>0.7:
+	    if not (game.options & OPTION_THINGY) or withprob(0.3):
 		skip(1)
 		prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
 		skip(1)
@@ -1287,72 +1422,55 @@ def torpedo(course, r, incoming, i, n):
 		skip(1)
 		deadkl(w, iquad, w)
 	    else:
-		#
 		# Stas Sergeev added the possibility that
 		# you can shove the Thingy and piss it off.
 		# It then becomes an enemy and may fire at you.
-		# 
-		iqengry = True
+		thing.angry = True
 		shoved = True
 	    return None
 	elif iquad == IHBLANK: # Black hole 
 	    skip(1)
-	    crmena(True, IHBLANK, sector, w)
-	    prout(_(" swallows torpedo."))
+	    prout(crmena(True, IHBLANK, "sector", w) + _(" swallows torpedo."))
 	    return None
 	elif iquad == IHWEB: # hit the web 
 	    skip(1)
 	    prout(_("***Torpedo absorbed by Tholian web."))
 	    return None
 	elif iquad == IHT:  # Hit a Tholian 
-	    h1 = 700.0 + 100.0*Rand() - \
-		1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle))
+	    h1 = 700.0 + randrange(100) - \
+		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
 	    h1 = math.fabs(h1)
 	    if h1 >= 600:
-		game.quad[w.x][w.y] = IHDOT
-		game.ithere = False
+		game.quad[w.i][w.j] = IHDOT
 		deadkl(w, iquad, w)
+		game.tholian = None
 		return None
 	    skip(1)
-	    crmena(True, IHT, sector, w)
-	    if Rand() > 0.05:
+	    proutn(crmena(True, IHT, "sector", w))
+	    if withprob(0.05):
 		prout(_(" survives photon blast."))
 		return None
 	    prout(_(" disappears."))
-	    game.quad[w.x][w.y] = IHWEB
-	    game.ithere = False
-	    game.nenhere -= 1
+	    game.tholian.move(None)
+	    game.quad[w.i][w.j] = IHWEB
 	    dropin(IHBLANK)
 	    return None
         else: # Problem!
 	    skip(1)
 	    proutn("Don't know how to handle torpedo collision with ")
-	    crmena(True, iquad, sector, w)
+	    proutn(crmena(True, iquad, "sector", w))
 	    skip(1)
 	    return None
 	break
-    if curwnd!=message_window:
-	setwnd(message_window)
-    if shoved:
-	game.quad[w.x][w.y]=IHDOT
-	game.quad[jw.x][jw.y]=iquad
-	prout(_(" displaced by blast to Sector %s ") % jw)
-	for ll in range(1, game.nenhere+1):
-	    game.kdist[ll] = game.kavgd[ll] = distance(game.sector,game.ks[ll])
-	sortklings()
-	return None
     skip(1)
     prout(_("Torpedo missed."))
     return None;
 
 def fry(hit):
-    # critical-hit resolution 
-    ktr=1
-    # a critical hit occured 
-    if hit < (275.0-25.0*game.skill)*(1.0+0.5*Rand()):
+    "Critical-hit resolution." 
+    if hit < (275.0-25.0*game.skill)*randreal(1.0, 1.5):
 	return
-
-    ncrit = 1.0 + hit/(500.0+100.0*Rand())
+    ncrit = int(1.0 + hit/(500.0+randreal(100)))
     proutn(_("***CRITICAL HIT--"))
     # Select devices and cause damage
     cdam = []
@@ -1363,19 +1481,16 @@ def fry(hit):
             if not (game.damage[j]<0.0 or (j==DSHUTTL and game.iscraft != "onship")):
                 break
 	cdam.append(j)
-	extradm = (hit*game.damfac)/(ncrit*(75.0+25.0*Rand()))
+	extradm = (hit*game.damfac)/(ncrit*randreal(75, 100))
 	game.damage[j] += extradm
-	if loop1 > 0:
-            for loop2 in range(loop1):
-                if j == cdam[loop2]:
-                    break
-	    if loop2 < loop1:
-		continue
-	    ktr += 1
-	    if ktr==3:
-		skip(1)
-	    proutn(_(" and "))
+    skipcount = 0
+    for (i, j) in enumerate(cdam):
 	proutn(device[j])
+        if skipcount % 3 == 2 and i < len(cdam)-1:
+            skip(1)
+        skipcount += 1
+        if i < len(cdam)-1:
+            proutn(_(" and "))
     prout(_(" damaged."))
     if damaged(DSHIELD) and game.shldup:
 	prout(_("***Shields knocked down."))
@@ -1383,91 +1498,78 @@ def fry(hit):
 
 def attack(torps_ok):
     # bad guy attacks us 
-    # torps_ok == false forces use of phasers in an attack 
-    atackd = False; attempt = False; ihurt = False;
-    hitmax=0.0; hittot=0.0; chgfac=1.0
-    jay = coord()
-    where = "neither"
-
-    # game could be over at this point, check 
+    # torps_ok == False forces use of phasers in an attack 
+    # game could be over at this point, check
     if game.alldone:
 	return
-
+    attempt = False; ihurt = False;
+    hitmax=0.0; hittot=0.0; chgfac=1.0
+    where = "neither"
     if idebug:
 	prout("=== ATTACK!")
-
-    # Tholian gewts to move before attacking 
-    if game.ithere:
+    # Tholian gets to move before attacking 
+    if game.tholian:
 	movetholian()
-
     # if you have just entered the RNZ, you'll get a warning 
     if game.neutz: # The one chance not to be attacked 
 	game.neutz = False
 	return
-
     # commanders get a chance to tac-move towards you 
-    if (((game.comhere or game.ishere) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok:
+    if (((game.quadrant in game.state.kcmdr or game.state.kscmdr==game.quadrant) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok:
 	moveklings()
-
     # if no enemies remain after movement, we're done 
-    if game.nenhere==0 or (game.nenhere==1 and iqhere and not iqengry):
+    if len(game.enemies)==0 or (len(game.enemies)==1 and thing == game.quadrant and not thing.angry):
 	return
-
     # set up partial hits if attack happens during shield status change 
     pfac = 1.0/game.inshld
     if game.shldchg:
-	chgfac = 0.25+0.5*Rand()
-
+	chgfac = 0.25 + randreal(0.5)
     skip(1)
-
     # message verbosity control 
     if game.skill <= SKILL_FAIR:
 	where = "sector"
-
-    for loop in range(1, game.nenhere+1):
-	if game.kpower[loop] < 0:
+    for enemy in game.enemies:
+	if enemy.kpower < 0:
 	    continue;	# too weak to attack 
 	# compute hit strength and diminish shield power 
-	r = Rand()
-	# Increase chance of photon torpedos if docked or enemy energy low 
+	r = randreal()
+	# Increase chance of photon torpedos if docked or enemy energy is low 
 	if game.condition == "docked":
 	    r *= 0.25
-	if game.kpower[loop] < 500:
+	if enemy.kpower < 500:
 	    r *= 0.25; 
-	jay = game.ks[loop]
-	iquad = game.quad[jay.x][jay.y]
-	if iquad==IHT or (iquad==IHQUEST and not iqengry):
+	if enemy.type==IHT or (enemy.type==IHQUEST and not thing.angry):
 	    continue
 	# different enemies have different probabilities of throwing a torp 
 	usephasers = not torps_ok or \
-	    (iquad == IHK and r > 0.0005) or \
-	    (iquad==IHC and r > 0.015) or \
-	    (iquad==IHR and r > 0.3) or \
-	    (iquad==IHS and r > 0.07) or \
-	    (iquad==IHQUEST and r > 0.05)
+	    (enemy.type == IHK and r > 0.0005) or \
+	    (enemy.type==IHC and r > 0.015) or \
+	    (enemy.type==IHR and r > 0.3) or \
+	    (enemy.type==IHS and r > 0.07) or \
+	    (enemy.type==IHQUEST and r > 0.05)
 	if usephasers:	    # Enemy uses phasers 
 	    if game.condition == "docked":
 		continue; # Don't waste the effort! 
 	    attempt = True; # Attempt to attack 
-	    dustfac = 0.8+0.05*Rand()
-	    hit = game.kpower[loop]*math.pow(dustfac,game.kavgd[loop])
-	    game.kpower[loop] *= 0.75
+	    dustfac = randreal(0.8, 0.85)
+	    hit = enemy.kpower*math.pow(dustfac,enemy.kavgd)
+	    enemy.kpower *= 0.75
 	else: # Enemy uses photon torpedo 
-	    course = 1.90985*math.atan2(game.sector.y-jay.y, jay.x-game.sector.x)
+	    # We should be able to make the bearing() method work here
+	    course = 1.90985*math.atan2(game.sector.j-enemy.kloc.j, enemy.kloc.i-game.sector.i)
 	    hit = 0
 	    proutn(_("***TORPEDO INCOMING"))
 	    if not damaged(DSRSENS):
-		proutn(_(" From "))
-		crmena(False, iquad, where, jay)
+		proutn(_(" From ") + crmena(False, enemy.type, where, enemy.kloc))
 	    attempt = True
 	    prout("  ")
-	    r = (Rand()+Rand())*0.5 -0.5
-	    r += 0.002*game.kpower[loop]*r
-	    hit = torpedo(course, r, jay, 1, 1)
-	    if (game.state.remkl + game.state.remcom + game.state.nscrem)==0:
+	    dispersion = (randreal()+randreal())*0.5 - 0.5
+	    dispersion += 0.002*enemy.kpower*dispersion
+	    hit = torpedo(enemy.kloc, course, dispersion, number=1, nburst=1)
+	    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
 		finish(FWON); # Klingons did themselves in! 
-	    if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova or game.alldone:
-		return; # Supernova or finished 
+	    if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone:
+		return # Supernova or finished 
 	    if hit == None:
 		continue
 	# incoming phaser or torpedo, shields may dissipate it 
@@ -1494,11 +1596,9 @@ def attack(torps_ok):
 	ihurt = True
 	proutn(_("%d unit hit") % int(hit))
 	if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR:
-	    proutn(_(" on the "))
-	    crmshp()
+	    proutn(_(" on the ") + crmshp())
 	if not damaged(DSRSENS) and usephasers:
-	    proutn(_(" from "))
-	    crmena(False, iquad, where, jay)
+	    prout(_(" from ") + crmena(False, enemy.type, where, enemy.kloc))
 	skip(1)
 	# Decide if hit is critical 
 	if hit > hitmax:
@@ -1512,14 +1612,12 @@ def attack(torps_ok):
 	return
     if not attempt and game.condition == "docked":
 	prout(_("***Enemies decide against attacking your ship."))
-    if not atackd:
-	return
     percent = 100.0*pfac*game.shield+0.5
     if not ihurt:
 	# Shields fully protect ship 
 	proutn(_("Enemy attack reduces shield strength to "))
     else:
-	# Print message if starship suffered hit(s) 
+	# Emit message if starship suffered hit(s) 
 	skip(1)
 	proutn(_("Energy left %2d    shields ") % int(game.energy))
 	if game.shldup:
@@ -1531,7 +1629,7 @@ def attack(torps_ok):
     prout(_("%d%%,   torpedoes left %d") % (percent, game.torps))
     # Check if anyone was hurt 
     if hitmax >= 200 or hittot >= 500:
-	icas= hittot*Rand()*0.015
+	icas = randrange(int(hittot * 0.015))
 	if icas >= 2:
 	    skip(1)
 	    prout(_("Mc Coy-  \"Sickbay to bridge.  We suffered %d casualties") % icas)
@@ -1539,216 +1637,186 @@ def attack(torps_ok):
 	    game.casual += icas
 	    game.state.crew -= icas
     # After attack, reset average distance to enemies 
-    for loop in range(1, game.nenhere+1):
-	game.kavgd[loop] = game.kdist[loop]
-    sortklings()
-    return;
+    for enemy in game.enemies:
+	enemy.kavgd = enemy.kdist
+    game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+    return
 		
 def deadkl(w, type, mv):
-    # kill a Klingon, Tholian, Romulan, or Thingy 
+    "Kill a Klingon, Tholian, Romulan, or Thingy." 
     # Added mv to allow enemy to "move" before dying 
-
-    crmena(True, type, sector, mv)
+    proutn(crmena(True, type, "sector", mv))
     # Decide what kind of enemy it is and update appropriately 
     if type == IHR:
-	# chalk up a Romulan 
-	game.state.galaxy[game.quadrant.x][game.quadrant.y].romulans -= 1
-	game.irhere -= 1
-	game.state.nromrem -= 1
+        # Chalk up a Romulan 
+        game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans -= 1
+        game.irhere -= 1
+        game.state.nromrem -= 1
     elif type == IHT:
-	# Killed a Tholian 
-	game.ithere = False
+        # Killed a Tholian 
+        game.tholian = None
     elif type == IHQUEST:
-	# Killed a Thingy 
-	iqhere = iqengry = False
-	invalidate(thing)
+        # Killed a Thingy
+        global thing
+        thing = None
     else:
-	# Some type of a Klingon 
-	game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons -= 1
-	game.klhere -= 1
-	if type == IHC:
-	    game.comhere = False
-	    for i in range(1, game.state.remcom+1):
-		if game.state.kcmdr[i] == game.quadrant:
-		    break
-	    game.state.kcmdr[i] = game.state.kcmdr[game.state.remcom]
-	    game.state.kcmdr[game.state.remcom].x = 0
-	    game.state.kcmdr[game.state.remcom].y = 0
-	    game.state.remcom -= 1
-	    unschedule(FTBEAM)
-	    if game.state.remcom != 0:
-		schedule(FTBEAM, expran(1.0*game.incom/game.state.remcom))
-	elif type ==  IHK:
-	    game.state.remkl -= 1
-	elif type ==  IHS:
-	    game.state.nscrem -= 1
-	    game.ishere = False
-	    game.state.kscmdr.x = game.state.kscmdr.y = game.isatb = 0
-	    game.iscate = False
-	    unschedule(FSCMOVE)
-	    unschedule(FSCDBAS)
-	else:
-	    prout("*** Internal error, deadkl() called on %s\n" % type)
-
+        # Killed some type of Klingon 
+        game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
+        game.klhere -= 1
+        if type == IHC:
+            game.state.kcmdr.remove(game.quadrant)
+            unschedule(FTBEAM)
+            if game.state.kcmdr:
+                schedule(FTBEAM, expran(1.0*game.incom/len(game.state.kcmdr)))
+            if is_scheduled(FCDBAS) and game.battle == game.quadrant:
+                unschedule(FCDBAS)    
+        elif type ==  IHK:
+            game.state.remkl -= 1
+        elif type ==  IHS:
+            game.state.nscrem -= 1
+            game.state.kscmdr.invalidate()
+            game.isatb = 0
+            game.iscate = False
+            unschedule(FSCMOVE)
+            unschedule(FSCDBAS)
     # For each kind of enemy, finish message to player 
     prout(_(" destroyed."))
-    game.quad[w.x][w.y] = IHDOT
-    if (game.state.remkl + game.state.remcom + game.state.nscrem)==0:
+    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
 	return
     game.recompute()
-    # Remove enemy ship from arrays describing local conditions 
-    if is_scheduled(FCDBAS) and game.battle == game.quadrant and type==IHC:
-	unschedule(FCDBAS)
-    for i in range(1, game.nenhere+1):
-	if game.ks[i] == w:
+    # Remove enemy ship from arrays describing local conditions
+    for e in game.enemies:
+	if e.kloc == w:
+            e.move(None)
 	    break
-    game.nenhere -= 1
-    if i <= game.nenhere:
-        for j in range(i, game.nenhere+1):
-	    game.ks[j] = game.ks[j+1]
-	    game.kpower[j] = game.kpower[j+1]
-	    game.kavgd[j] = game.kdist[j] = game.kdist[j+1]
-    game.ks[game.nenhere+1].x = 0
-    game.ks[game.nenhere+1].x = 0
-    game.kdist[game.nenhere+1] = 0
-    game.kavgd[game.nenhere+1] = 0
-    game.kpower[game.nenhere+1] = 0
-    return;
-
-def targetcheck(x, y):
-    # Return None if target is invalid 
-    if not VALID_SECTOR(x, y):
+    return
+
+def targetcheck(w):
+    "Return None if target is invalid, otherwise return a course angle."
+    if not w.valid_sector():
 	huh()
 	return None
-    deltx = 0.1*(y - game.sector.y)
-    delty = 0.1*(x - game.sector.x)
-    if deltx==0 and delty== 0:
+    delta = coord()
+    # FIXME: C code this was translated from is wacky -- why the sign reversal?
+    delta.j = (w.j - game.sector.j);
+    delta.i = (game.sector.i - w.i);
+    if delta == coord(0, 0):
 	skip(1)
 	prout(_("Spock-  \"Bridge to sickbay.  Dr. McCoy,"))
 	prout(_("  I recommend an immediate review of"))
 	prout(_("  the Captain's psychological profile.\""))
-	chew()
+	scanner.chew()
 	return None
-    return 1.90985932*math.atan2(deltx, delty)
+    return delta.bearing()
 
 def photon():
-    # launch photon torpedo 
+    "Launch photon torpedo."
+    course = []
     game.ididit = False
     if damaged(DPHOTON):
 	prout(_("Photon tubes damaged."))
-	chew()
+	scanner.chew()
 	return
     if game.torps == 0:
 	prout(_("No torpedoes left."))
-	chew()
+	scanner.chew()
 	return
-    key = scan()
+    # First, get torpedo count
     while True:
-	if key == IHALPHA:
+        scanner.next()
+	if scanner.token == "IHALPHA":
 	    huh()
 	    return
-	elif key == IHEOL:
+	elif scanner.token == "IHEOL" or not scanner.waiting():
 	    prout(_("%d torpedoes left.") % game.torps)
+            scanner.chew()
 	    proutn(_("Number of torpedoes to fire- "))
-	    key = scan()
-	else: # key == IHREAL  {
-	    n = aaitem + 0.5
+            continue	# Go back around to get a number
+	else: # key == "IHREAL"
+	    n = scanner.int()
 	    if n <= 0: # abort command 
-		chew()
+		scanner.chew()
 		return
-	    if n > 3:
-		chew()
-		prout(_("Maximum of 3 torpedoes per burst."))
-		key = IHEOL
+	    if n > MAXBURST:
+		scanner.chew()
+		prout(_("Maximum of %d torpedoes per burst.") % MAXBURST)
 		return
-	    if n <= game.torps:
-		break
-	    chew()
-	    key = IHEOL
-    for i in range(1, n+1):
-	key = scan()
-	if i==1 and key == IHEOL:
-	    break;	# we will try prompting 
-	if i==2 and key == IHEOL:
+            if n > game.torps:
+                scanner.chew()	# User requested more torps than available
+                continue	# Go back around
+            break	# All is good, go to next stage
+    # Next, get targets
+    target = []
+    for i in range(n):
+	key = scanner.next()
+	if i==0 and key == "IHEOL":
+	    break;	# no coordinate waiting, we will try prompting 
+	if i==1 and key == "IHEOL":
 	    # direct all torpedoes at one target 
-	    while i <= n:
-		targ[i][1] = targ[1][1]
-		targ[i][2] = targ[1][2]
-		course[i] = course[1]
+	    while i < n:
+		target.append(target[0])
+		course.append(course[0])
 		i += 1
 	    break
-	if key != IHREAL:
-	    huh()
-	    return
-	targ[i][1] = aaitem
-	key = scan()
-	if key != IHREAL:
-	    huh()
-	    return
-	targ[i][2] = aaitem
-	course[i] = targetcheck(targ[i][1], targ[i][2])
-        if course[i] == None:
+        scanner.push(scanner.token)
+        target.append(scanner.getcoord())
+        if target[-1] == None:
+            return
+        course.append(targetcheck(target[-1]))
+        if course[-1] == None:
 	    return
-    chew()
-    if i == 1 and key == IHEOL:
+    scanner.chew()
+    if len(target) == 0:
 	# prompt for each one 
-	for i in range(1, n+1):
-	    proutn(_("Target sector for torpedo number %d- ") % i)
-	    key = scan()
-	    if key != IHREAL:
-		huh()
-		return
-	    targ[i][1] = aaitem
-	    key = scan()
-	    if key != IHREAL:
-		huh()
-		return
-	    targ[i][2] = aaitem
-	    chew()
-            course[i] = targetcheck(targ[i][1], targ[i][2])
-            if course[i] == None:
+	for i in range(n):
+	    proutn(_("Target sector for torpedo number %d- ") % (i+1))
+	    scanner.chew()
+            target.append(scanner.getcoord())
+            if target[-1] == None:
+                return
+            course.append(targetcheck(target[-1]))
+            if course[-1] == None:
                 return
     game.ididit = True
     # Loop for moving <n> torpedoes 
-    for i in range(1, n+1):
+    for i in range(n):
 	if game.condition != "docked":
 	    game.torps -= 1
-	r = (Rand()+Rand())*0.5 -0.5
-	if math.fabs(r) >= 0.47:
+	dispersion = (randreal()+randreal())*0.5 -0.5
+	if math.fabs(dispersion) >= 0.47:
 	    # misfire! 
-	    r = (Rand()+1.2) * r
-	    if n>1:
-		prouts(_("***TORPEDO NUMBER %d MISFIRES") % i)
+	    dispersion *= randreal(1.2, 2.2)
+	    if n > 0:
+		prouts(_("***TORPEDO NUMBER %d MISFIRES") % (i+1))
 	    else:
 		prouts(_("***TORPEDO MISFIRES."))
 	    skip(1)
 	    if i < n:
 		prout(_("  Remainder of burst aborted."))
-	    if Rand() <= 0.2:
+	    if withprob(0.2):
 		prout(_("***Photon tubes damaged by misfire."))
-		game.damage[DPHOTON] = game.damfac*(1.0+2.0*Rand())
+		game.damage[DPHOTON] = game.damfac * randreal(1.0, 3.0)
 	    break
 	if game.shldup or game.condition == "docked":
-	    r *= 1.0 + 0.0001*game.shield
-	torpedo(course[i], r, game.sector, i, n)
-	if game.alldone or game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
+	    dispersion *= 1.0 + 0.0001*game.shield
+	torpedo(game.sector, course[i], dispersion, number=i, nburst=n)
+	if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
 	    return
-    if (game.state.remkl + game.state.remcom + game.state.nscrem)==0:
+    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
 	finish(FWON);
 
 def overheat(rpow):
-    # check for phasers overheating 
+    "Check for phasers overheating."
     if rpow > 1500:
-	chekbrn = (rpow-1500.)*0.00038
-	if Rand() <= chekbrn:
+        checkburn = (rpow-1500.0)*0.00038
+        if withprob(checkburn):
 	    prout(_("Weapons officer Sulu-  \"Phasers overheated, sir.\""))
-	    game.damage[DPHASER] = game.damfac*(1.0 + Rand()) * (1.0+chekbrn)
+	    game.damage[DPHASER] = game.damfac* randreal(1.0, 2.0) * (1.0+checkburn)
 
 def checkshctrl(rpow):
-    # check shield control 
-	
+    "Check shield control."
     skip(1)
-    if Rand() < 0.998:
+    if withprob(0.998):
 	prout(_("Shields lowered."))
 	return False
     # Something bad has happened 
@@ -1766,7 +1834,7 @@ def checkshctrl(rpow):
     prouts(_("Sulu-  \"Captain! Shield malfunction! Phaser fire contained!\""))
     skip(2)
     prout(_("Lt. Uhura-  \"Sir, all decks reporting damage.\""))
-    icas = hit*Rand()*0.012
+    icas = randrange(int(hit*0.012))
     skip(1)
     fry(0.8*hit)
     if icas:
@@ -1781,114 +1849,112 @@ def checkshctrl(rpow):
     overheat(rpow)
     return True;
 
-def hittem(doublehits):
-    # register a phaser hit on Klingons and Romulans 
-    nenhr2=game.nenhere; kk=1
+def hittem(hits):
+    "Register a phaser hit on Klingons and Romulans."
+    nenhr2 = len(game.enemies); kk=0
     w = coord()
     skip(1)
-    for k in range(1, nenhr2+1):
-        wham = hits[k]
+    for (k, wham) in enumerate(hits):
 	if wham==0:
 	    continue
-	dustfac = 0.9 + 0.01*Rand()
-	hit = wham*math.pow(dustfac,game.kdist[kk])
-	kpini = game.kpower[kk]
+	dustfac = randreal(0.9, 1.0)
+	hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
+	kpini = game.enemies[kk].kpower
 	kp = math.fabs(kpini)
 	if PHASEFAC*hit < kp:
 	    kp = PHASEFAC*hit
-        if game.kpower[kk] < 0:
-            game.kpower[kk] -= -kp
+        if game.enemies[kk].kpower < 0:
+            game.enemies[kk].kpower -= -kp
         else:
-            game.kpower[kk] -= kp
-	kpow = game.kpower[kk]
-	w = game.ks[kk]
+            game.enemies[kk].kpower -= kp
+	kpow = game.enemies[kk].kpower
+	w = game.enemies[kk].kloc
 	if hit > 0.005:
 	    if not damaged(DSRSENS):
 		boom(w)
 	    proutn(_("%d unit hit on ") % int(hit))
 	else:
 	    proutn(_("Very small hit on "))
-	ienm = game.quad[w.x][w.y]
+	ienm = game.quad[w.i][w.j]
 	if ienm==IHQUEST:
-	    iqengry = True
-	crmena(False, ienm, "sector", w)
+	    thing.angry = True
+	proutn(crmena(False, ienm, "sector", w))
 	skip(1)
 	if kpow == 0:
 	    deadkl(w, ienm, w)
-	    if (game.state.remkl + game.state.remcom + game.state.nscrem)==0:
+	    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
 		finish(FWON);		
 	    if game.alldone:
 		return
-	    kk -= 1; # don't do the increment 
+	    kk -= 1	# don't do the increment
+            continue
 	else: # decide whether or not to emasculate klingon 
-	    if kpow > 0 and Rand() >= 0.9 and \
-		kpow <= ((0.4 + 0.4*Rand())*kpini):
-		prout(_("***Mr. Spock-  \"Captain, the vessel at Sector %s"), w)
+	    if kpow>0 and withprob(0.9) and kpow <= randreal(0.4, 0.8)*kpini:
+		prout(_("***Mr. Spock-  \"Captain, the vessel at Sector %s")%w)
 		prout(_("   has just lost its firepower.\""))
-		game.kpower[kk] = -kpow
+		game.enemies[kk].kpower = -kpow
         kk += 1
-    return;
+    return
 
 def phasers():
-    # fire phasers 
-    hits = []; rpow=0
+    "Fire phasers at bad guys."
+    hits = []
     kz = 0; k = 1; irec=0 # Cheating inhibitor 
-    ifast = False; no = False; itarg = True; msgflag = True
+    ifast = False; no = False; itarg = True; msgflag = True; rpow=0
     automode = "NOTSET"
     key=0
-
     skip(1)
-    # SR sensors and Computer are needed fopr automode 
+    # SR sensors and Computer are needed for automode 
     if damaged(DSRSENS) or damaged(DCOMPTR):
 	itarg = False
     if game.condition == "docked":
 	prout(_("Phasers can't be fired through base shields."))
-	chew()
+	scanner.chew()
 	return
     if damaged(DPHASER):
 	prout(_("Phaser control damaged."))
-	chew()
+	scanner.chew()
 	return
     if game.shldup:
 	if damaged(DSHCTRL):
 	    prout(_("High speed shield control damaged."))
-	    chew()
+	    scanner.chew()
 	    return
 	if game.energy <= 200.0:
 	    prout(_("Insufficient energy to activate high-speed shield control."))
-	    chew()
+	    scanner.chew()
 	    return
 	prout(_("Weapons Officer Sulu-  \"High-speed shield control enabled, sir.\""))
 	ifast = True
-		
-    # Original code so convoluted, I re-did it all 
+    # Original code so convoluted, I re-did it all
+    # (That was Tom Almy talking about the C code, I think -- ESR)
     while automode=="NOTSET":
-	key=scan()
-	if key == IHALPHA:
-	    if isit("manual"):
-		if game.nenhere==0:
+	key=scanner.next()
+	if key == "IHALPHA":
+	    if scanner.sees("manual"):
+		if len(game.enemies)==0:
 		    prout(_("There is no enemy present to select."))
-		    chew()
-		    key = IHEOL
+		    scanner.chew()
+		    key = "IHEOL"
 		    automode="AUTOMATIC"
 		else:
 		    automode = "MANUAL"
-		    key = scan()
-	    elif isit("automatic"):
-		if (not itarg) and game.nenhere != 0:
+		    key = scanner.next()
+	    elif scanner.sees("automatic"):
+		if (not itarg) and len(game.enemies) != 0:
 		    automode = "FORCEMAN"
 		else:
-		    if game.nenhere==0:
+		    if len(game.enemies)==0:
 			prout(_("Energy will be expended into space."))
 		    automode = "AUTOMATIC"
-		    key = scan()
-	    elif isit("no"):
+		    key = scanner.next()
+	    elif scanner.sees("no"):
 		no = True
 	    else:
 		huh()
 		return
-	elif key == IHREAL:
-	    if game.nenhere==0:
+	elif key == "IHREAL":
+	    if len(game.enemies)==0:
 		prout(_("Energy will be expended into space."))
 		automode = "AUTOMATIC"
 	    elif not itarg:
@@ -1896,66 +1962,67 @@ def phasers():
 	    else:
 		automode = "AUTOMATIC"
 	else:
-	    # IHEOL 
-	    if game.nenhere==0:
+	    # "IHEOL" 
+	    if len(game.enemies)==0:
 		prout(_("Energy will be expended into space."))
 		automode = "AUTOMATIC"
 	    elif not itarg:
 		automode = "FORCEMAN"
 	    else: 
-		proutn(_("Manual or automatic? "))			
+		proutn(_("Manual or automatic? "))
+                scanner.chew()
     avail = game.energy
     if ifast:
         avail -= 200.0
     if automode == "AUTOMATIC":
-	if key == IHALPHA and isit("no"):
+	if key == "IHALPHA" and scanner.sees("no"):
 	    no = True
-	    key = scan()
-	if key != IHREAL and game.nenhere != 0:
+	    key = scanner.next()
+	if key != "IHREAL" and len(game.enemies) != 0:
 	    prout(_("Phasers locked on target. Energy available: %.2f")%avail)
 	irec=0
         while True:
-	    chew()
+	    scanner.chew()
 	    if not kz:
-		for i in range(1, game.nenhere+1):
-		    irec += math.fabs(game.kpower[i])/(PHASEFAC*math.pow(0.90,game.kdist[i]))*(1.01+0.05*Rand()) + 1.0
+		for i in range(len(game.enemies)):
+		    irec += math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
 	    kz=1
 	    proutn(_("%d units required. ") % irec)
-	    chew()
+	    scanner.chew()
 	    proutn(_("Units to fire= "))
-	    key = scan()
-	    if key!=IHREAL:
+	    key = scanner.next()
+	    if key!="IHREAL":
 		return
-	    rpow = aaitem
+	    rpow = scanner.real
 	    if rpow > avail:
 		proutn(_("Energy available= %.2f") % avail)
 		skip(1)
-		key = IHEOL
+		key = "IHEOL"
             if not rpow > avail:
                 break
 	if rpow<=0:
 	    # chicken out 
-	    chew()
+	    scanner.chew()
 	    return
-        key=scan()
-	if key == IHALPHA and isit("no"):
+        key=scanner.next()
+	if key == "IHALPHA" and scanner.sees("no"):
 	    no = True
 	if ifast:
 	    game.energy -= 200; # Go and do it! 
 	    if checkshctrl(rpow):
 		return
-	chew()
+	scanner.chew()
 	game.energy -= rpow
 	extra = rpow
-	if game.nenhere:
+	if len(game.enemies):
 	    extra = 0.0
 	    powrem = rpow
-	    for i in range(1, game.nenhere+1):
-		hits[i] = 0.0
+	    for i in range(len(game.enemies)):
+		hits.append(0.0)
 		if powrem <= 0:
 		    continue
-		hits[i] = math.fabs(game.kpower[i])/(PHASEFAC*math.pow(0.90,game.kdist[i]))
-		over = (0.01 + 0.05*Rand())*hits[i]
+		hits[i] = math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
+		over = randreal(1.01, 1.06) * hits[i]
 		temp = powrem
 		powrem -= hits[i] + over
 		if powrem <= 0 and temp < hits[i]:
@@ -1968,16 +2035,16 @@ def phasers():
 	    hittem(hits)
 	    game.ididit = True
 	if extra > 0 and not game.alldone:
-	    if game.ithere:
+	    if game.tholian:
 		proutn(_("*** Tholian web absorbs "))
-		if game.nenhere>0:
+		if len(game.enemies)>0:
 		    proutn(_("excess "))
 		prout(_("phaser energy."))
 	    else:
 		prout(_("%d expended on empty space.") % int(extra))
     elif automode == "FORCEMAN":
-	chew()
-	key = IHEOL
+	scanner.chew()
+	key = "IHEOL"
 	if damaged(DCOMPTR):
 	    prout(_("Battle computer damaged, manual fire only."))
 	else:
@@ -1990,27 +2057,26 @@ def phasers():
 	    skip(1)
     elif automode == "MANUAL":
 	rpow = 0.0
-        for k in range(1, game.nenhere+1):
-	    aim = game.ks[k]
-	    ienm = game.quad[aim.x][aim.y]
+        for k in range(len(game.enemies)):
+	    aim = game.enemies[k].kloc
+	    ienm = game.quad[aim.i][aim.j]
 	    if msgflag:
 		proutn(_("Energy available= %.2f") % (avail-0.006))
 		skip(1)
 		msgflag = False
 		rpow = 0.0
-	    if damaged(DSRSENS) and not (abs(game.sector.x-aim.x) < 2 and abs(game.sector.y-aim.y) < 2) and \
-		(ienm == IHC or ienm == IHS):
-		cramen(ienm)
-		prout(_(" can't be located without short range scan."))
-		chew()
-		key = IHEOL
+	    if damaged(DSRSENS) and \
+               not game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS):
+		prout(cramen(ienm) + _(" can't be located without short range scan."))
+		scanner.chew()
+		key = "IHEOL"
 		hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko 
 		k += 1
 		continue
-	    if key == IHEOL:
-		chew()
+	    if key == "IHEOL":
+		scanner.chew()
 		if itarg and k > kz:
-		    irec=(abs(game.kpower[k])/(PHASEFAC*math.pow(0.9,game.kdist[k]))) *	(1.01+0.05*Rand()) + 1.0
+		    irec=(abs(game.enemies[k].kpower)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) *	randreal(1.01, 1.06) + 1.0
 		kz = k
 		proutn("(")
 		if not damaged(DCOMPTR):
@@ -2018,42 +2084,40 @@ def phasers():
 		else:
 		    proutn("??")
 		proutn(")  ")
-		proutn(_("units to fire at "))
-		crmena(False, ienm, sector, aim)
-		proutn("-  ")
-		key = scan()
-	    if key == IHALPHA and isit("no"):
+		proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))		
+		key = scanner.next()
+	    if key == "IHALPHA" and scanner.sees("no"):
 		no = True
-		key = scan()
+		key = scanner.next()
 		continue
-	    if key == IHALPHA:
+	    if key == "IHALPHA":
 		huh()
 		return
-	    if key == IHEOL:
+	    if key == "IHEOL":
 		if k==1: # Let me say I'm baffled by this 
 		    msgflag = True
 		continue
-	    if aaitem < 0:
+	    if scanner.real < 0:
 		# abort out 
-		chew()
+		scanner.chew()
 		return
-	    hits[k] = aaitem
-	    rpow += aaitem
+	    hits[k] = scanner.real
+	    rpow += scanner.real
 	    # If total requested is too much, inform and start over 
             if rpow > avail:
 		prout(_("Available energy exceeded -- try again."))
-		chew()
+		scanner.chew()
 		return
-	    key = scan(); # scan for next value 
+	    key = scanner.next(); # scan for next value 
 	    k += 1
 	if rpow == 0.0:
 	    # zero energy -- abort 
-	    chew()
+	    scanner.chew()
 	    return
-	if key == IHALPHA and isit("no"):
+	if key == "IHALPHA" and scanner.sees("no"):
 	    no = True
 	game.energy -= rpow
-	chew()
+	scanner.chew()
 	if ifast:
 	    game.energy -= 200.0
 	    if checkshctrl(rpow):
@@ -2066,7 +2130,7 @@ def phasers():
     if ifast:
 	skip(1)
 	if no == 0:
-	    if Rand() >= 0.99:
+	    if withprob(0.99):
 		prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
 		prouts(_("         CLICK   CLICK   POP  . . ."))
 		prout(_(" No response, sir!"))
@@ -2084,32 +2148,30 @@ def phasers():
 # only have one FDISTR/FENSLV/FREPRO sequence going at any given time
 # BSD Trek, from which we swiped the idea, can have up to 5.
 
-import math
-
 def unschedule(evtype):
-    # remove an event from the schedule 
+    "Remove an event from the schedule."
     game.future[evtype].date = FOREVER
     return game.future[evtype]
 
 def is_scheduled(evtype):
-    # is an event of specified type scheduled 
+    "Is an event of specified type scheduled."
     return game.future[evtype].date != FOREVER
 
 def scheduled(evtype):
-    # when will this event happen? 
+    "When will this event happen?"
     return game.future[evtype].date
 
 def schedule(evtype, offset):
-    # schedule an event of specified type 
+    "Schedule an event of specified type."
     game.future[evtype].date = game.state.date + offset
     return game.future[evtype]
 
 def postpone(evtype, offset):
-    # postpone a scheduled event 
+    "Postpone a scheduled event."
     game.future[evtype].date += offset
 
 def cancelrest():
-    # rest period is interrupted by event 
+    "Rest period is interrupted by event."
     if game.resting:
 	skip(1)
 	proutn(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
@@ -2117,26 +2179,22 @@ def cancelrest():
 	    game.resting = False
 	    game.optime = 0.0
 	    return True
-
     return False
 
 def events():
-    # run through the event queue looking for things to do 
+    "Run through the event queue looking for things to do."
     i=0
     fintim = game.state.date + game.optime; yank=0
     ictbeam = False; istract = False
     w = coord(); hold = coord()
     ev = event(); ev2 = event()
 
-    def tractorbeam():
-        # tractor beaming cases merge here 
-        yank = math.sqrt(yank)
+    def tractorbeam(yank):
+        "Tractor-beaming cases merge here." 
         announce()
         game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5) 
         skip(1)
-        proutn("***")
-        crmshp()
-        prout(_(" caught in long range tractor beam--"))
+        prout("***" + crmshp() + _(" caught in long range tractor beam--"))
         # If Kirk & Co. screwing around on planet, handle 
         atover(True) # atover(true) is Grab 
         if game.alldone:
@@ -2147,51 +2205,50 @@ def events():
         # Check to see if shuttle is aboard 
         if game.iscraft == "offship":
             skip(1)
-            if Rand() > 0.5:
+            if withprob(0.5):
                 prout(_("Galileo, left on the planet surface, is captured"))
                 prout(_("by aliens and made into a flying McDonald's."))
                 game.damage[DSHUTTL] = -10
                 game.iscraft = "removed"
             else:
                 prout(_("Galileo, left on the planet surface, is well hidden."))
-        if evcode==0:
+        if evcode == FSPY:
             game.quadrant = game.state.kscmdr
         else:
             game.quadrant = game.state.kcmdr[i]
         game.sector = randplace(QUADSIZE)
-        crmshp()
-        prout(_(" is pulled to Quadrant %s, Sector %s") \
+        prout(crmshp() + _(" is pulled to Quadrant %s, Sector %s") \
                % (game.quadrant, game.sector))
         if game.resting:
             prout(_("(Remainder of rest/repair period cancelled.)"))
             game.resting = False
         if not game.shldup:
             if not damaged(DSHIELD) and game.shield > 0:
-                doshield(True) # raise shields 
-                game.shldchg=False
+                doshield(shraise=True) # raise shields 
+                game.shldchg = False
             else:
                 prout(_("(Shields not currently useable.)"))
-        newqad(False)
+        newqad()
         # Adjust finish time to time of tractor beaming 
         fintim = game.state.date+game.optime
-        attack(False)
-        if game.state.remcom <= 0:
+        attack(torps_ok=False)
+        if not game.state.kcmdr:
             unschedule(FTBEAM)
         else: 
-            schedule(FTBEAM, game.optime+expran(1.5*game.intime/game.state.remcom))
+            schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr)))
 
     def destroybase():
-        # Code merges here for any commander destroying base 
+        "Code merges here for any commander destroying a starbase." 
         # Not perfect, but will have to do 
         # Handle case where base is in same quadrant as starship 
         if game.battle == game.quadrant:
-            game.state.chart[game.battle.x][game.battle.y].starbase = False
-            game.quad[game.base.x][game.base.y] = IHDOT
-            game.base.x=game.base.y=0
+            game.state.chart[game.battle.i][game.battle.j].starbase = False
+            game.quad[game.base.i][game.base.j] = IHDOT
+            game.base.invalidate()
             newcnd()
             skip(1)
             prout(_("Spock-  \"Captain, I believe the starbase has been destroyed.\""))
-        elif game.state.rembase != 1 and communicating():
+        elif game.state.baseq and communicating():
             # Get word via subspace radio 
             announce()
             skip(1)
@@ -2201,20 +2258,16 @@ def events():
                 prout(_("the Klingon Super-Commander"))
             else:
                 prout(_("a Klingon Commander"))
-            game.state.chart[game.battle.x][game.battle.y].starbase = False
+            game.state.chart[game.battle.i][game.battle.j].starbase = False
         # Remove Starbase from galaxy 
-        game.state.galaxy[game.battle.x][game.battle.y].starbase = False
-        for i in range(1, game.state.rembase+1):
-            if game.state.baseq[i] == game.battle:
-                game.state.baseq[i] = game.state.baseq[game.state.rembase]
-        game.state.rembase -= 1
+        game.state.galaxy[game.battle.i][game.battle.j].starbase = False
+        game.state.baseq = filter(lambda x: x != game.battle, game.state.baseq)
         if game.isatb == 2:
             # reinstate a commander's base attack 
             game.battle = hold
             game.isatb = 0
         else:
-            invalidate(game.battle)
-
+            game.battle.invalidate()
     if idebug:
 	prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
 	for i in range(1, NEVENTS):
@@ -2234,7 +2287,7 @@ def events():
 	    else:
 		prout("never")
     radio_was_broken = damaged(DRADIO)
-    hold.x = hold.y = 0
+    hold.i = hold.j = 0
     while True:
 	# Select earliest extraneous event, evcode==0 if no events 
 	evcode = FSPY
@@ -2250,7 +2303,7 @@ def events():
 	xtime = datemin-game.state.date
 	game.state.date = datemin
 	# Decrement Federation resources and recompute remaining time 
-	game.state.remres -= (game.state.remkl+4*game.state.remcom)*xtime
+	game.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime
         game.recompute()
 	if game.state.remtime <=0:
 	    finish(FDEPLETE)
@@ -2272,7 +2325,7 @@ def events():
 	if game.condition == "docked":
 	    repair /= game.docfac
 	# Don't fix Deathray here 
-	for l in range(0, NDEVICES):
+	for l in range(NDEVICES):
 	    if game.damage[l] > 0.0 and l != DDRAY:
                 if game.damage[l]-repair > 0.0:
                     game.damage[l] -= repair
@@ -2293,9 +2346,9 @@ def events():
 	game.optime -= xtime
 	if evcode == FSNOVA: # Supernova 
 	    announce()
-	    supernova(False)
+	    supernova(None)
 	    schedule(FSNOVA, expran(0.5*game.intime))
-	    if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
+	    if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
 		return
 	elif evcode == FSPY: # Check with spy to see if SC should tractor beam 
 	    if game.state.nscrem == 0 or \
@@ -2309,52 +2362,48 @@ def events():
 		 (game.energy < 2500 or damaged(DPHASER)) and \
                  (game.torps < 5 or damaged(DPHOTON))):
 		# Tractor-beam her! 
-		istract = True
-		yank = distance(game.state.kscmdr, game.quadrant)
-                ictbeam = True
-                tractorbeam()
+		istract = ictbeam = True
+                tractorbeam((game.state.kscmdr-game.quadrant).distance())
 	    else:
 		return
 	elif evcode == FTBEAM: # Tractor beam 
-            if game.state.remcom == 0:
+            if not game.state.kcmdr:
                 unschedule(FTBEAM)
                 continue
-            i = Rand()*game.state.remcom+1.0
-            yank = square(game.state.kcmdr[i].x-game.quadrant.x) + square(game.state.kcmdr[i].y-game.quadrant.y)
+            i = randrange(len(game.state.kcmdr))
+            yank = (game.state.kcmdr[i]-game.quadrant).distance()
             if istract or game.condition == "docked" or yank == 0:
                 # Drats! Have to reschedule 
                 schedule(FTBEAM, 
-                         game.optime + expran(1.5*game.intime/game.state.remcom))
+                         game.optime + expran(1.5*game.intime/len(game.state.kcmdr)))
                 continue
             ictbeam = True
-            tractorbeam()
+            tractorbeam(yank)
 	elif evcode == FSNAP: # Snapshot of the universe (for time warp) 
-	    game.snapsht = game.state
+	    game.snapsht = copy.deepcopy(game.state)
 	    game.state.snap = True
 	    schedule(FSNAP, expran(0.5 * game.intime))
 	elif evcode == FBATTAK: # Commander attacks starbase 
-	    if game.state.remcom==0 or game.state.rembase==0:
+	    if not game.state.kcmdr or not game.state.baseq:
 		# no can do 
 		unschedule(FBATTAK)
 		unschedule(FCDBAS)
                 continue
-	    i = 0
-	    for j in range(1, game.state.rembase+1):
-		for k in range(1, game.state.remcom+1):
-		    if game.state.baseq[j] == game.state.kcmdr[k] and \
-			not game.state.baseq[j] == game.quadrant and \
-                        not game.state.baseq[j] == game.state.kscmdr:
-			i = 1
-		if i == 1:
-		    continue
-	    if j>game.state.rembase:
-		# no match found -- try later 
-		schedule(FBATTAK, expran(0.3*game.intime))
-		unschedule(FCDBAS)
-		continue
+            try:
+                for ibq in game.state.baseq:
+                   for cmdr in game.state.kcmdr: 
+                       if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
+                           raise ibq
+                else:
+                    # no match found -- try later 
+                    schedule(FBATTAK, expran(0.3*game.intime))
+                    unschedule(FCDBAS)
+                    continue
+            except coord:
+                pass
 	    # commander + starbase combination found -- launch attack 
-	    game.battle = game.state.baseq[j]
-	    schedule(FCDBAS, 1.0+3.0*Rand())
+	    game.battle = ibq
+	    schedule(FCDBAS, randreal(1.0, 4.0))
 	    if game.isatb: # extra time if SC already attacking 
 		postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date)
 	    game.future[FBATTAK].date = game.future[FCDBAS].date + expran(0.3*game.intime)
@@ -2364,16 +2413,15 @@ def events():
 	    game.iseenit = True
 	    announce()
 	    skip(1)
-	    proutn(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") % game.battle)
+	    prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") % game.battle)
 	    prout(_("   reports that it is under attack and that it can"))
-	    proutn(_("   hold out only until stardate %d") % (int(scheduled(FCDBAS))))
-            prout(".\"")
+	    prout(_("   hold out only until stardate %d.\"") % (int(scheduled(FCDBAS))))
 	    if cancelrest():
                 return
 	elif evcode == FSCDBAS: # Supercommander destroys base 
 	    unschedule(FSCDBAS)
 	    game.isatb = 2
-	    if not game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].starbase: 
+	    if not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].starbase: 
 		continue # WAS RETURN! 
 	    hold = game.battle
 	    game.battle = game.state.kscmdr
@@ -2381,14 +2429,16 @@ def events():
 	elif evcode == FCDBAS: # Commander succeeds in destroying base 
 	    if evcode==FCDBAS:
 		unschedule(FCDBAS)
+                if not game.state.baseq() \
+                       or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
+		    game.battle.invalidate()
+                    continue
 		# find the lucky pair 
-		for i in range(1, game.state.remcom+1):
-		    if game.state.kcmdr[i] == game.battle: 
+		for cmdr in game.state.kcmdr:
+		    if cmdr == game.battle: 
 			break
-		if i > game.state.remcom or game.state.rembase == 0 or \
-		    not game.state.galaxy[game.battle.x][game.battle.y].starbase:
+                else:
 		    # No action to take after all 
-		    invalidate(game.battle)
 		    continue
             destroybase()
 	elif evcode == FSCMOVE: # Supercommander moves 
@@ -2398,45 +2448,36 @@ def events():
 		supercommander()
 	elif evcode == FDSPROB: # Move deep space probe 
 	    schedule(FDSPROB, 0.01)
-	    game.probex += game.probeinx
-	    game.probey += game.probeiny
-	    i = (int)(game.probex/QUADSIZE +0.05)
-	    j = (int)(game.probey/QUADSIZE + 0.05)
-	    if game.probec.x != i or game.probec.y != j:
-		game.probec.x = i
-		game.probec.y = j
-		if not VALID_QUADRANT(i, j) or \
-		    game.state.galaxy[game.probec.x][game.probec.y].supernova:
+            if game.probe.next(grain=QUADSIZE):
+		if not game.probe.quadrant().valid_quadrant() or \
+		    game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova:
 		    # Left galaxy or ran into supernova
-                    if comunicating():
+                    if communicating():
 			announce()
 			skip(1)
 			proutn(_("Lt. Uhura-  \"The deep space probe "))
-			if not VALID_QUADRANT(j, i):
-			    proutn(_("has left the galaxy"))
+			if not game.probe.quadrant().valid_quadrant():
+			    prout(_("has left the galaxy.\""))
 			else:
-			    proutn(_("is no longer transmitting"))
-			prout(".\"")
+			    prout(_("is no longer transmitting.\""))
 		    unschedule(FDSPROB)
 		    continue
-                if not communicating():
-		    announce()
+                if communicating():
+		    #announce()
 		    skip(1)
-		    proutn(_("Lt. Uhura-  \"The deep space probe is now in Quadrant %s.\"") % game.probec)
-	    pdest = game.state.galaxy[game.probec.x][game.probec.y]
-	    # Update star chart if Radio is working or have access to radio
+		    prout(_("Lt. Uhura-  \"The deep space probe is now in Quadrant %s.\"") % game.probe.quadrant())
+	    pdest = game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j]
 	    if communicating():
-		chp = game.state.chart[game.probec.x][game.probec.y]
+		chp = game.state.chart[game.probe.quadrant().i][game.probe.quadrant().j]
 		chp.klingons = pdest.klingons
 		chp.starbase = pdest.starbase
 		chp.stars = pdest.stars
 		pdest.charted = True
-	    game.proben -= 1 # One less to travel
-	    if game.proben == 0 and game.isarmed and pdest.stars:
-		# lets blow the sucker! 
-		supernova(True, game.probec)
+	    game.probe.moves -= 1 # One less to travel
+	    if game.probe.moves == 0 and game.isarmed and pdest.stars:
+		supernova(game.probe)		# fire in the hole!
 		unschedule(FDSPROB)
-		if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: 
+		if game.state.galaxy[game.quadrant().i][game.quadrant().j].supernova: 
 		    return
 	elif evcode == FDISTR: # inhabited system issues distress call 
 	    unschedule(FDISTR)
@@ -2447,10 +2488,10 @@ def events():
 		# not already under attack, which is not
 		# supernova'ed, and which has some Klingons in it
 		w = randplace(GALSIZE)
-		q = game.state.galaxy[w.x][w.y]
-                if not (game.quadrant == w or q.planet == NOPLANET or \
-		      game.state.planets[q.planet].inhabited == UNINHABITED or \
-		      q.supernova or q.status!=secure or q.klingons<=0):
+		q = game.state.galaxy[w.i][w.j]
+                if not (game.quadrant == w or q.planet == None or \
+		      not q.planet.inhabited or \
+		      q.supernova or q.status!="secure" or q.klingons<=0):
                     break
             else:
 		# can't seem to find one; ignore this call 
@@ -2460,8 +2501,7 @@ def events():
 	    # got one!!  Schedule its enslavement 
 	    ev = schedule(FENSLV, expran(game.intime))
 	    ev.quadrant = w
-	    q.status = distressed
-
+	    q.status = "distressed"
 	    # tell the captain about it if we can 
 	    if communicating():
 		prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \
@@ -2472,7 +2512,7 @@ def events():
 	elif evcode == FENSLV:		# starsystem is enslaved 
 	    ev = unschedule(FENSLV)
 	    # see if current distress call still active 
-	    q = game.state.galaxy[ev.quadrant.x][ev.quadrant.y]
+	    q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
 	    if q.klingons <= 0:
 		q.status = "secure"
 		continue
@@ -2492,7 +2532,7 @@ def events():
 	    # explicitly retrieve and restore the x and y.
 	    ev = schedule(FREPRO, expran(1.0 * game.intime))
 	    # see if current distress call still active 
-	    q = game.state.galaxy[ev.quadrant.x][ev.quadrant.y]
+	    q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
 	    if q.klingons <= 0:
 		q.status = "secure"
 		continue
@@ -2500,14 +2540,15 @@ def events():
 		continue		# full right now 
 	    # reproduce one Klingon 
 	    w = ev.quadrant
+            m = coord()
 	    if game.klhere >= MAXKLQUAD:
                 try:
                     # this quadrant not ok, pick an adjacent one 
-                    for i in range(w.x - 1, w.x + 2):
-                        for j in range(w.y - 1, w.y + 2):
-                            if not VALID_QUADRANT(i, j):
+                    for m.i in range(w.i - 1, w.i + 2):
+                        for m.j in range(w.j - 1, w.j + 2):
+                            if not m.valid_quadrant():
                                 continue
-                            q = game.state.galaxy[w.x][w.y]
+                            q = game.state.galaxy[m.i][m.j]
                             # check for this quad ok (not full & no snova) 
                             if q.klingons >= MAXKLQUAD or q.supernova:
                                 continue
@@ -2515,49 +2556,45 @@ def events():
                     else:
                         continue	# search for eligible quadrant failed
                 except "FOUNDIT":
-                    w.x = i
-                    w.y = j
+                    w = m
 	    # deliver the child 
 	    game.state.remkl += 1
 	    q.klingons += 1
 	    if game.quadrant == w:
                 game.klhere += 1
-		newkling(game.klhere)
+		game.enemies.append(newkling())
 	    # recompute time left
             game.recompute()
-	    # report the disaster if we can 
 	    if communicating():
 		if game.quadrant == w:
 		    prout(_("Spock- sensors indicate the Klingons have"))
 		    prout(_("launched a warship from %s.") % q.planet)
 		else:
 		    prout(_("Uhura- Starfleet reports increased Klingon activity"))
-		    if q.planet != NOPLANET:
+		    if q.planet != None:
 			proutn(_("near %s") % q.planet)
 		    prout(_("in Quadrant %s.") % w)
 				
 def wait():
-    # wait on events 
+    "Wait on events."
     game.ididit = False
     while True:
-	key = scan()
-	if key  != IHEOL:
+	key = scanner.next()
+	if key  != "IHEOL":
 	    break
 	proutn(_("How long? "))
-    chew()
-    if key != IHREAL:
+    scanner.chew()
+    if key != "IHREAL":
 	huh()
 	return
-    origTime = delay = aaitem
+    origTime = delay = scanner.real
     if delay <= 0.0:
 	return
-    if delay >= game.state.remtime or game.nenhere != 0:
+    if delay >= game.state.remtime or len(game.enemies) != 0:
 	proutn(_("Are you sure? "))
 	if ja() == False:
 	    return
-
     # Alternate resting periods (events) with attacks 
-
     game.resting = True
     while True:
 	if delay <= 0:
@@ -2566,13 +2603,13 @@ def wait():
 	    prout(_("%d stardates left.") % int(game.state.remtime))
 	    return
 	temp = game.optime = delay
-	if game.nenhere:
-	    rtime = 1.0 + Rand()
+	if len(game.enemies):
+	    rtime = randreal(1.0, 2.0)
 	    if rtime < temp:
 		temp = rtime
 	    game.optime = temp
 	if game.optime < delay:
-	    attack(False)
+	    attack(torps_ok=False)
 	if game.alldone:
 	    return
 	events()
@@ -2584,193 +2621,158 @@ def wait():
 	if origTime-delay >= 9.99 and game.condition == "docked":
 	    game.damage[DDRAY] = 0.0
 	# leave if quadrant supernovas
-        if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
+        if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
             break
     game.resting = False
     game.optime = 0
 
-# A nova occurs.  It is the result of having a star hit with a
-# photon torpedo, or possibly of a probe warhead going off.
-# Stars that go nova cause stars which surround them to undergo
-# the same probabilistic process.  Klingons next to them are
-# destroyed.  And if the starship is next to it, it gets zapped.
-# If the zap is too much, it gets destroyed.
-        
 def nova(nov):
-    # star goes nova 
+    "Star goes nova." 
     course = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
-    newc = coord(); scratch = coord()
-
-    if Rand() < 0.05:
+    newc = coord(); neighbor = coord(); bump = coord(0, 0)
+    if withprob(0.05):
 	# Wow! We've supernova'ed 
-	supernova(False, nov)
+	supernova(game.quadrant)
 	return
-
     # handle initial nova 
-    game.quad[nov.x][nov.y] = IHDOT
-    crmena(False, IHSTAR, sector, nov)
-    prout(_(" novas."))
-    game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1
+    game.quad[nov.i][nov.j] = IHDOT
+    prout(crmena(False, IHSTAR, "sector", nov) + _(" novas."))
+    game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
     game.state.starkl += 1
-	
-    # Set up stack to recursively trigger adjacent stars 
-    bot = top = top2 = 1
+    # Set up queue to recursively trigger adjacent stars 
+    hits = [nov]
     kount = 0
-    icx = icy = 0
-    hits[1][1] = nov.x
-    hits[1][2] = nov.y
-    while True:
-	for mm in range(bot, top+1): 
-	    for nn in range(1, 3+1):  # nn,j represents coordinates around current 
-		for j in range(1, 3+1):
-		    if j==2 and nn== 2:
-			continue
-		    scratch.x = hits[mm][1]+nn-2
-		    scratch.y = hits[mm][2]+j-2
-		    if not VALID_SECTOR(scratch.y, scratch.x):
-			continue
-		    iquad = game.quad[scratch.x][scratch.y]
-                    # Empty space ends reaction
-                    if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB):
-			break
-		    elif iquad == IHSTAR: # Affect another star 
-			if Rand() < 0.05:
-			    # This star supernovas 
-			    scratch = supernova(False)
-			    return
-			top2 += 1
-			hits[top2][1]=scratch.x
-			hits[top2][2]=scratch.y
-			game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1
+    while hits:
+        offset = coord()
+        start = hits.pop()
+        for offset.i in range(-1, 1+1):
+            for offset.j in range(-1, 1+1):
+                if offset.j==0 and offset.i==0:
+                    continue
+                neighbor = start + offset
+                if not neighbor.valid_sector():
+                    continue
+                iquad = game.quad[neighbor.i][neighbor.j]
+                # Empty space ends reaction
+                if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB):
+                    pass
+                elif iquad == IHSTAR: # Affect another star 
+                    if withprob(0.05):
+                        # This star supernovas 
+                        supernova(game.quadrant)
+                        return
+                    else:
+                        hits.append(neighbor)
+			game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
 			game.state.starkl += 1
-			crmena(True, IHSTAR, sector, scratch)
+			proutn(crmena(True, IHSTAR, "sector", neighbor))
 			prout(_(" novas."))
-			game.quad[scratch.x][scratch.y] = IHDOT
-		    elif iquad == IHP: # Destroy planet 
-			game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = NOPLANET
-			game.state.nplankl += 1
-			crmena(True, IHP, sector, scratch)
-			prout(_(" destroyed."))
-			game.state.planets[game.iplnet].pclass = destroyed
-			game.iplnet = 0
-			invalidate(game.plnet)
-			if game.landed:
-			    finish(FPNOVA)
-			    return
-			game.quad[scratch.x][scratch.y] = IHDOT
-		    elif iquad == IHB: # Destroy base 
-			game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase = False
-			for i in range(1, game.state.rembase+1):
-			    if game.state.baseq[i] == game.quadrant: 
-				break
-			game.state.baseq[i] = game.state.baseq[game.state.rembase]
-			game.state.rembase -= 1
-			invalidate(game.base)
-			game.state.basekl += 1
-			newcnd()
-			crmena(True, IHB, sector, scratch)
-			prout(_(" destroyed."))
-			game.quad[scratch.x][scratch.y] = IHDOT
-		    elif iquad in (IHE, IHF): # Buffet ship 
-			prout(_("***Starship buffeted by nova."))
-			if game.shldup:
-			    if game.shield >= 2000.0:
-				game.shield -= 2000.0
-			    else:
-				diff = 2000.0 - game.shield
-				game.energy -= diff
-				game.shield = 0.0
-				game.shldup = False
-				prout(_("***Shields knocked out."))
-				game.damage[DSHIELD] += 0.005*game.damfac*Rand()*diff
-			else:
-			    game.energy -= 2000.0
-			if game.energy <= 0:
-			    finish(FNOVA)
-			    return
-			# add in course nova contributes to kicking starship
-			icx += game.sector.x-hits[mm][1]
-			icy += game.sector.y-hits[mm][2]
-			kount += 1
-		    elif iquad == IHK: # kill klingon 
-			deadkl(scratch,iquad, scratch)
-                    elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies 
-			for ll in range(1, game.nenhere+1):
-			    if game.ks[ll] == scratch:
-				break
-			game.kpower[ll] -= 800.0 # If firepower is lost, die 
-			if game.kpower[ll] <= 0.0:
-			    deadkl(scratch, iquad, scratch)
-			    break
-			newc.x = scratch.x + scratch.x - hits[mm][1]
-			newc.y = scratch.y + scratch.y - hits[mm][2]
-			crmena(True, iquad, sector, scratch)
-			proutn(_(" damaged"))
-			if not VALID_SECTOR(newc.x, newc.y):
-			    # can't leave quadrant 
-			    skip(1)
-			    break
-			iquad1 = game.quad[newc.x][newc.y]
-			if iquad1 == IHBLANK:
-			    proutn(_(", blasted into "))
-			    crmena(False, IHBLANK, sector, newc)
-			    skip(1)
-			    deadkl(scratch, iquad, newc)
-			    break
-			if iquad1 != IHDOT:
-			    # can't move into something else 
-			    skip(1)
-			    break
-			proutn(_(", buffeted to Sector %s") % newc)
-			game.quad[scratch.x][scratch.y] = IHDOT
-			game.quad[newc.x][newc.y] = iquad
-			game.ks[ll] = newc
-			game.kdist[ll] = game.kavgd[ll] = distance(game.sector, newc)
-			skip(1)
-	if top == top2: 
-	    break
-	bot = top + 1
-	top = top2
-    if kount==0: 
-	return
-
+                        game.quad[neighbor.i][neighbor.j] = IHDOT
+                        kount += 1
+                elif iquad in (IHP, IHW): # Destroy planet 
+                    game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
+                    if iquad == IHP:
+                        game.state.nplankl += 1
+                    else:
+                        game.state.worldkl += 1
+                    prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
+                    game.iplnet.pclass = "destroyed"
+                    game.iplnet = None
+                    game.plnet.invalidate()
+                    if game.landed:
+                        finish(FPNOVA)
+                        return
+                    game.quad[neighbor.i][neighbor.j] = IHDOT
+                elif iquad == IHB: # Destroy base 
+                    game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase = False
+                    game.state.baseq = filter(lambda x: x!= game.quadrant, game.state.baseq)
+                    game.base.invalidate()
+                    game.state.basekl += 1
+                    newcnd()
+                    prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
+                    game.quad[neighbor.i][neighbor.j] = IHDOT
+                elif iquad in (IHE, IHF): # Buffet ship 
+                    prout(_("***Starship buffeted by nova."))
+                    if game.shldup:
+                        if game.shield >= 2000.0:
+                            game.shield -= 2000.0
+                        else:
+                            diff = 2000.0 - game.shield
+                            game.energy -= diff
+                            game.shield = 0.0
+                            game.shldup = False
+                            prout(_("***Shields knocked out."))
+                            game.damage[DSHIELD] += 0.005*game.damfac*randreal()*diff
+                    else:
+                        game.energy -= 2000.0
+                    if game.energy <= 0:
+                        finish(FNOVA)
+                        return
+                    # add in course nova contributes to kicking starship
+                    bump += (game.sector-hits[mm]).sgn()
+                elif iquad == IHK: # kill klingon 
+                    deadkl(neighbor, iquad, neighbor)
+                elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies 
+                    for ll in range(len(game.enemies)):
+                        if game.enemies[ll].kloc == neighbor:
+                            break
+                    game.enemies[ll].kpower -= 800.0 # If firepower is lost, die 
+                    if game.enemies[ll].kpower <= 0.0:
+                        deadkl(neighbor, iquad, neighbor)
+                        break
+                    newc = neighbor + neighbor - hits[mm]
+                    proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
+                    if not newc.valid_sector():
+                        # can't leave quadrant 
+                        skip(1)
+                        break
+                    iquad1 = game.quad[newc.i][newc.j]
+                    if iquad1 == IHBLANK:
+                        proutn(_(", blasted into ") + crmena(False, IHBLANK, "sector", newc))
+                        skip(1)
+                        deadkl(neighbor, iquad, newc)
+                        break
+                    if iquad1 != IHDOT:
+                        # can't move into something else 
+                        skip(1)
+                        break
+                    proutn(_(", buffeted to Sector %s") % newc)
+                    game.quad[neighbor.i][neighbor.j] = IHDOT
+                    game.quad[newc.i][newc.j] = iquad
+                    game.enemies[ll].move(newc)
     # Starship affected by nova -- kick it away. 
-    game.dist = kount*0.1
-    icx = sgn(icx)
-    icy = sgn(icy)
-    game.direc = course[3*(icx+1)+icy+2]
-    if game.direc == 0.0:
-	game.dist = 0.0
-    if game.dist == 0.0:
+    dist = kount*0.1
+    direc = course[3*(bump.i+1)+bump.j+2]
+    if direc == 0.0:
+	dist = 0.0
+    if dist == 0.0:
 	return
-    game.optime = 10.0*game.dist/16.0
+    course = course(bearing=direc, distance=dist)
+    game.optime = course.time(warp=4)
     skip(1)
     prout(_("Force of nova displaces starship."))
-    imove(True)
-    game.optime = 10.0*game.dist/16.0
+    imove(course, novapush=True)
+    game.optime = course.time(warp=4)
     return
 	
-def supernova(induced, w=None):
-    # star goes supernova 
+def supernova(w):
+    "Star goes supernova."
     num = 0; npdead = 0
-    nq = coord()
-
     if w != None: 
-	nq = w
+	nq = copy.copy(w)
     else:
+	# Scheduled supernova -- select star at random. 
 	stars = 0
-	# Scheduled supernova -- select star 
-	# logic changed here so that we won't favor quadrants in top
-        # left of universe 
-	for nq.x in range(1, GALSIZE+1):
-	    for nq.y in range(1, GALSIZE+1):
-		stars += game.state.galaxy[nq.x][nq.y].stars
+        nq = coord()
+	for nq.i in range(GALSIZE):
+	    for nq.j in range(GALSIZE):
+		stars += game.state.galaxy[nq.i][nq.j].stars
 	if stars == 0:
 	    return # nothing to supernova exists 
-	num = Rand()*stars + 1
-	for nq.x in range(1, GALSIZE+1):
-	    for nq.y in range(1, GALSIZE+1):
-		num -= game.state.galaxy[nq.x][nq.y].stars
+	num = randrange(stars) + 1
+	for nq.i in range(GALSIZE):
+	    for nq.j in range(GALSIZE):
+		num -= game.state.galaxy[nq.i][nq.j].stars
 		if num <= 0:
 		    break
 	    if num <=0:
@@ -2779,7 +2781,6 @@ def supernova(induced, w=None):
 	    proutn("=== Super nova here?")
 	    if ja() == True:
 		nq = game.quadrant
-
     if not nq == game.quadrant or game.justin:
 	# it isn't here, or we just entered (treat as enroute) 
 	if communicating():
@@ -2789,78 +2790,64 @@ def supernova(induced, w=None):
     else:
 	ns = coord()
 	# we are in the quadrant! 
-	num = Rand()* game.state.galaxy[nq.x][nq.y].stars + 1
-	for ns.x in range(1, QUADSIZE+1):
-	    for ns.y in range(1, QUADSIZE+1):
-		if game.quad[ns.x][ns.y]==IHSTAR:
+	num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
+	for ns.i in range(QUADSIZE):
+	    for ns.j in range(QUADSIZE):
+		if game.quad[ns.i][ns.j]==IHSTAR:
 		    num -= 1
 		    if num==0:
 			break
 	    if num==0:
 		break
-
 	skip(1)
 	prouts(_("***RED ALERT!  RED ALERT!"))
 	skip(1)
 	prout(_("***Incipient supernova detected at Sector %s") % ns)
-	if square(ns.x-game.sector.x) + square(ns.y-game.sector.y) <= 2.1:
+	if (ns.i-game.sector.i)**2 + (ns.j-game.sector.j)**2 <= 2.1:
 	    proutn(_("Emergency override attempts t"))
 	    prouts("***************")
 	    skip(1)
 	    stars()
 	    game.alldone = True
-
-    # destroy any Klingons in supernovaed quadrant 
-    kldead = game.state.galaxy[nq.x][nq.y].klingons
-    game.state.galaxy[nq.x][nq.y].klingons = 0
+    # destroy any Klingons in supernovaed quadrant
+    kldead = game.state.galaxy[nq.i][nq.j].klingons
+    game.state.galaxy[nq.i][nq.j].klingons = 0
     if nq == game.state.kscmdr:
 	# did in the Supercommander! 
-	game.state.nscrem = game.state.kscmdr.x = game.state.kscmdr.y = game.isatb =  0
+	game.state.nscrem = game.state.kscmdr.i = game.state.kscmdr.j = game.isatb =  0
 	game.iscate = False
 	unschedule(FSCMOVE)
 	unschedule(FSCDBAS)
-    if game.state.remcom:
-	maxloop = game.state.remcom
-	for l in range(1, maxloop+1):
-	    if game.state.kcmdr[l] == nq:
-		game.state.kcmdr[l] = game.state.kcmdr[game.state.remcom]
-		invalidate(game.state.kcmdr[game.state.remcom])
-		game.state.remcom -= 1
-		kldead -= 1
-		if game.state.remcom==0:
-		    unschedule(FTBEAM)
-		break
+    survivors = filter(lambda w: w != nq, game.state.kcmdr)
+    comkills = len(game.state.kcmdr) - len(survivors)
+    game.state.kcmdr = survivors
+    kldead -= comkills
+    if not game.state.kcmdr:
+        unschedule(FTBEAM)
     game.state.remkl -= kldead
     # destroy Romulans and planets in supernovaed quadrant 
-    nrmdead = game.state.galaxy[nq.x][nq.y].romulans
-    game.state.galaxy[nq.x][nq.y].romulans = 0
+    nrmdead = game.state.galaxy[nq.i][nq.j].romulans
+    game.state.galaxy[nq.i][nq.j].romulans = 0
     game.state.nromrem -= nrmdead
     # Destroy planets 
     for loop in range(game.inplan):
-	if game.state.planets[loop].w == nq:
-	    game.state.planets[loop].pclass = destroyed
+	if game.state.planets[loop].quadrant == nq:
+	    game.state.planets[loop].pclass = "destroyed"
 	    npdead += 1
-    # Destroy any base in supernovaed quadrant 
-    if game.state.rembase:
-	maxloop = game.state.rembase
-	for loop in range(1, maxloop+1):
-	    if game.state.baseq[loop] == nq:
-		game.state.baseq[loop] = game.state.baseq[game.state.rembase]
-		invalidate(game.state.baseq[game.state.rembase])
-		game.state.rembase -= 1
-		break
+    # Destroy any base in supernovaed quadrant
+    game.state.baseq = filter(lambda x: x != nq, game.state.baseq)
     # If starship caused supernova, tally up destruction 
-    if induced:
-	game.state.starkl += game.state.galaxy[nq.x][nq.y].stars
-	game.state.basekl += game.state.galaxy[nq.x][nq.y].starbase
+    if w != None:
+	game.state.starkl += game.state.galaxy[nq.i][nq.j].stars
+	game.state.basekl += game.state.galaxy[nq.i][nq.j].starbase
 	game.state.nplankl += npdead
     # mark supernova in galaxy and in star chart 
     if game.quadrant == nq or communicating():
-	game.state.galaxy[nq.x][nq.y].supernova = True
+	game.state.galaxy[nq.i][nq.j].supernova = True
     # If supernova destroys last Klingons give special message 
-    if (game.state.remkl + game.state.remcom + game.state.nscrem)==0 and not nq == game.quadrant:
+    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0 and not nq == game.quadrant:
 	skip(2)
-	if not induced:
+	if w == None:
 	    prout(_("Lucky you!"))
 	proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq)
 	finish(FWON)
@@ -2873,9 +2860,8 @@ def supernova(induced, w=None):
 # Code from finish.c ends here.
 
 def selfdestruct():
-    # self-destruct maneuver 
-    # Finish with a BANG! 
-    chew()
+    "Self-destruct maneuver. Finish with a BANG!" 
+    scanner.chew()
     if damaged(DCOMPTR):
 	prout(_("Computer damaged; cannot execute destruct sequence."))
 	return
@@ -2893,9 +2879,9 @@ def selfdestruct():
     skip(1)
     prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED"))
     skip(1)
-    scan()
-    chew()
-    if game.passwd != citem:
+    scanner.next()
+    scanner.chew()
+    if game.passwd != scanner.token:
 	prouts(_("PASSWORD-REJECTED;"))
 	skip(1)
 	prouts(_("CONTINUITY-EFFECTED"))
@@ -2907,7 +2893,7 @@ def selfdestruct():
     prouts("                         3"); skip(1)
     prouts("                            2"); skip(1)
     prouts("                              1"); skip(1)
-    if Rand() < 0.15:
+    if withprob(0.15):
 	prouts(_("GOODBYE-CRUEL-WORLD"))
 	skip(1)
     kaboom()
@@ -2916,24 +2902,28 @@ def kaboom():
     stars()
     if game.ship==IHE:
 	prouts("***")
-    prouts(_("********* Entropy of "))
-    crmshp()
-    prouts(_(" maximized *********"))
+    prouts(_("********* Entropy of %s maximized *********") % crmshp())
     skip(1)
     stars()
     skip(1)
-    if game.nenhere != 0:
+    if len(game.enemies) != 0:
 	whammo = 25.0 * game.energy
 	l=1
-	while l <= game.nenhere:
-	    if game.kpower[l]*game.kdist[l] <= whammo: 
-		deadkl(game.ks[l], game.quad[game.ks[l].x][game.ks[l].y], game.ks[l])
+	while l <= len(game.enemies):
+	    if game.enemies[l].kpower*game.enemies[l].kdist <= whammo: 
+		deadkl(game.enemies[l].kloc, game.quad[game.enemies[l].kloc.i][game.enemies[l].kloc.j], game.enemies[l].kloc)
 	    l += 1
     finish(FDILITHIUM)
 				
 def killrate():
     "Compute our rate of kils over time."
-    return ((game.inkling + game.incom + game.inscom) - (game.state.remkl + game.state.remcom + game.state.nscrem))/(game.state.date-game.indate)
+    elapsed = game.state.date - game.indate
+    if elapsed == 0:	# Avoid divide-by-zero error if calculated on turn 0
+        return 0
+    else:
+        starting = (game.inkling + game.incom + game.inscom)
+        remaining = (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)
+        return (starting - remaining)/elapsed
 
 def badpoints():
     "Compute demerits."
@@ -2950,7 +2940,6 @@ def badpoints():
         badpt += 200.0
     return badpt
 
-
 def finish(ifin):
     # end the game, with appropriate notfications 
     igotit = False
@@ -3008,7 +2997,7 @@ def finish(ifin):
 			prout(_("You cannot get a citation, so..."))
 		    else:
 			proutn(_("Do you want your Commodore Emeritus Citation printed? "))
-			chew()
+			scanner.chew()
 			if ja() == True:
 			    igotit = True
 	    # Only grant long life if alive (original didn't!)
@@ -3023,7 +3012,7 @@ def finish(ifin):
 	prout(_("conquered.  Your starship is now Klingon property,"))
 	prout(_("and you are put on trial as a war criminal.  On the"))
 	proutn(_("basis of your record, you are "))
-	if (game.state.remkl + game.state.remcom + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom):
+	if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom):
 	    prout(_("acquitted."))
 	    skip(1)
 	    prout(_("LIVE LONG AND PROSPER."))
@@ -3042,9 +3031,7 @@ def finish(ifin):
 	skip(1)
 	prout(_("Your starship is a derelict in space."))
     elif ifin == FBATTLE:
-	proutn(_("The "))
-	crmshp()
-	prout(_("has been destroyed in battle."))
+	prout(_("The %s has been destroyed in battle.") % crmshp())
 	skip(1)
 	prout(_("Dulce et decorum est pro patria mori."))
     elif ifin == FNEG3:
@@ -3058,9 +3045,7 @@ def finish(ifin):
 	prout(_("That was a great shot."))
 	skip(1)
     elif ifin == FSNOVAED:
-	proutn(_("The "))
-	crmshp()
-	prout(_(" has been fried by a supernova."))
+	prout(_("The %s has been fried by a supernova.") % crmshp())
 	prout(_("...Not even cinders remain..."))
     elif ifin == FABANDN:
 	prout(_("You have been captured by the Klingons. If you still"))
@@ -3073,9 +3058,7 @@ def finish(ifin):
 	prout(_("Starbase was unable to re-materialize your starship."))
 	prout(_("Sic transit gloria mundi"))
     elif ifin == FPHASER:
-	proutn(_("The "))
-	crmshp()
-	prout(_(" has been cremated by its own phasers."))
+	prout(_("The %s has been cremated by its own phasers.") % crmshp())
     elif ifin == FLOST:
 	prout(_("You and your landing party have been"))
 	prout(_("converted to energy, disipating through space."))
@@ -3085,9 +3068,7 @@ def finish(ifin):
 	skip(1)
 	prout(_("They are very fond of \"Captain Kirk\" soup."))
 	skip(1)
-	proutn(_("Without your leadership, the "))
-	crmshp()
-	prout(_(" is destroyed."))
+	prout(_("Without your leadership, the %s is destroyed.") % crmshp())
     elif ifin == FDPLANET:
 	prout(_("You and your mining party perish."))
 	skip(1)
@@ -3097,25 +3078,19 @@ def finish(ifin):
 	prout(_("The Galileo is instantly annihilated by the supernova."))
 	prout(_("You and your mining party are atomized."))
 	skip(1)
-	proutn(_("Mr. Spock takes command of the "))
-	crmshp()
-	prout(_(" and"))
-	prout(_("joins the Romulans, reigning terror on the Federation."))
+	prout(_("Mr. Spock takes command of the %s and") % crmshp())
+	prout(_("joins the Romulans, wreaking terror on the Federation."))
     elif ifin == FPNOVA:
 	prout(_("You and your mining party are atomized."))
 	skip(1)
-	proutn(_("Mr. Spock takes command of the "))
-	crmshp()
-	prout(_(" and"))
-	prout(_("joins the Romulans, reigning terror on the Federation."))
+	prout(_("Mr. Spock takes command of the %s and") % crmshp())
+	prout(_("joins the Romulans, wreaking terror on the Federation."))
     elif ifin == FSTRACTOR:
 	prout(_("The shuttle craft Galileo is also caught,"))
 	prout(_("and breaks up under the strain."))
 	skip(1)
 	prout(_("Your debris is scattered for millions of miles."))
-	proutn(_("Without your leadership, the "))
-	crmshp()
-	prout(_(" is destroyed."))
+	prout(_("Without your leadership, the %s is destroyed.") % crmshp())
     elif ifin == FDRAY:
 	prout(_("The mutants attack and kill Spock."))
 	prout(_("Your ship is captured by Klingons, and"))
@@ -3136,13 +3111,13 @@ def finish(ifin):
     elif game.ship == IHE:
 	game.ship = IHF
     game.alive = False
-    if (game.state.remkl + game.state.remcom + game.state.nscrem) != 0:
+    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
 	goodies = game.state.remres/game.inresor
-	baddies = (game.state.remkl + 2.0*game.state.remcom)/(game.inkling+2.0*game.incom)
-	if goodies/baddies >= 1.0+0.5*Rand():
+	baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom)
+	if goodies/baddies >= randreal(1.0, 1.5):
 	    prout(_("As a result of your actions, a treaty with the Klingon"))
 	    prout(_("Empire has been signed. The terms of the treaty are"))
-	    if goodies/baddies >= 3.0+Rand():
+	    if goodies/baddies >= randreal(3.0):
 		prout(_("favorable to the Federation."))
 		skip(1)
 		prout(_("Congratulations!"))
@@ -3159,11 +3134,10 @@ def finish(ifin):
     score()
 
 def score():
-    # compute player's score 
+    "Compute player's score."
     timused = game.state.date - game.indate
-
     iskill = game.skill
-    if (timused == 0 or (game.state.remkl + game.state.remcom + game.state.nscrem) != 0) and timused < 5.0:
+    if (timused == 0 or (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0:
 	timused = 5.0
     perdate = killrate()
     ithperd = 500*perdate + 0.5
@@ -3179,7 +3153,7 @@ def score():
     if not game.gamewon:
 	game.state.nromrem = 0 # None captured if no win
     iscore = 10*(game.inkling - game.state.remkl) \
-             + 50*(game.incom - game.state.remcom) \
+             + 50*(game.incom - len(game.state.kcmdr)) \
              + ithperd + iwon \
              + 20*(game.inrom - game.state.nromrem) \
              + 200*(game.inscom - game.state.nscrem) \
@@ -3198,9 +3172,9 @@ def score():
     if game.inkling - game.state.remkl:
 	prout(_("%6d ordinary Klingons destroyed        %5d") %
 	      (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl)))
-    if game.incom - game.state.remcom:
+    if game.incom - len(game.state.kcmdr):
 	prout(_("%6d Klingon commanders destroyed       %5d") %
-	      (game.incom - game.state.remcom, 50*(game.incom - game.state.remcom)))
+	      (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr))))
     if game.inscom - game.state.nscrem:
 	prout(_("%6d Super-Commander destroyed          %5d") %
 	      (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
@@ -3245,11 +3219,11 @@ def score():
     prout(_("TOTAL SCORE                               %5d") % iscore)
 
 def plaque():
-    # emit winner's commemmorative plaque 
+    "Emit winner's commemmorative plaque." 
     skip(2)
     while True:
         proutn(_("File or device name for your plaque: "))
-        cgetline(winner, sizeof(winner))
+        winner = cgetline()
         try:
             fp = open(winner, "w")
             break
@@ -3257,10 +3231,9 @@ def plaque():
             prout(_("Invalid name."))
 
     proutn(_("Enter name to go on plaque (up to 30 characters): "))
-    cgetline(winner, sizeof(winner))
+    winner = cgetline()
     # The 38 below must be 64 for 132-column paper 
     nskip = 38 - len(winner)/2
-
     fp.write("\n\n\n\n")
     # --------DRAW ENTERPRISE PICTURE. 
     fp.write("                                       EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n" )
@@ -3296,7 +3269,7 @@ def plaque():
         fp.write(_("Emeritus level\n\n"))
     else:
         fp.write(_(" Cheat level\n\n"))
-    timestring = ctime()
+    timestring = time.ctime()
     fp.write(_("                                                 This day of %.6s %.4s, %.8s\n\n") %
                     (timestring+4, timestring+20, timestring+11))
     fp.write(_("                                                        Your score:  %d\n\n") % iscore)
@@ -3307,6 +3280,7 @@ def plaque():
 
 rows = linecount = 0	# for paging 
 stdscr = None
+replayfp = None
 fullscreen_window = None
 srscan_window     = None
 report_window     = None
@@ -3314,28 +3288,12 @@ status_window     = None
 lrscan_window     = None
 message_window    = None
 prompt_window     = None
-
-def outro():
-    "wrap up, either normally or due to signal"
-    if game.options & OPTION_CURSES:
-	#clear()
-	#curs_set(1)
-	#refresh()
-	#resetterm()
-	#echo()
-	curses.endwin()
-	stdout.write('\n')
-    if logfp:
-	logfp.close()
+curwnd = None
 
 def iostart():
-    global stdscr
-    #setlocale(LC_ALL, "")
-    #bindtextdomain(PACKAGE, LOCALEDIR)
-    #textdomain(PACKAGE)
-    if atexit.register(outro):
-	sys.stderr.write("Unable to register outro(), exiting...\n")
-	os.exit(1)
+    global stdscr, rows
+    gettext.bindtextdomain("sst", "/usr/local/share/locale")
+    gettext.textdomain("sst")
     if not (game.options & OPTION_CURSES):
 	ln_env = os.getenv("LINES")
         if ln_env:
@@ -3345,21 +3303,11 @@ def iostart():
     else:
 	stdscr = curses.initscr()
 	stdscr.keypad(True)
-	#saveterm()
 	curses.nonl()
 	curses.cbreak()
-        curses.start_color()
-        curses.init_pair(curses.COLOR_BLACK, curses.COLOR_BLACK, curses.COLOR_BLACK)
-        curses.init_pair(curses.COLOR_GREEN, curses.COLOR_GREEN, curses.COLOR_BLACK)
-        curses.init_pair(curses.COLOR_RED, curses.COLOR_RED, curses.COLOR_BLACK)
-        curses.init_pair(curses.COLOR_CYAN, curses.COLOR_CYAN, curses.COLOR_BLACK)
-        curses.init_pair(curses.COLOR_WHITE, curses.COLOR_WHITE, curses.COLOR_BLACK)
-        curses.init_pair(curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
-        curses.init_pair(curses.COLOR_BLUE, curses.COLOR_BLUE, curses.COLOR_BLACK)
-        curses.init_pair(curses.COLOR_YELLOW, curses.COLOR_YELLOW, curses.COLOR_BLACK)
-	#noecho()
         global fullscreen_window, srscan_window, report_window, status_window
         global lrscan_window, message_window, prompt_window
+        (rows, columns)   = stdscr.getmaxyx()
 	fullscreen_window = stdscr
 	srscan_window     = curses.newwin(12, 25, 0,       0)
 	report_window     = curses.newwin(11, 0,  1,       25)
@@ -3369,20 +3317,23 @@ def iostart():
 	prompt_window     = curses.newwin(1,  0,  rows-2,  0) 
 	message_window.scrollok(True)
 	setwnd(fullscreen_window)
-	textcolor(DEFAULT)
 
+def ioend():
+    "Wrap up I/O."
+    if game.options & OPTION_CURSES:
+        stdscr.keypad(False)
+        curses.echo()
+        curses.nocbreak()
+        curses.endwin()
 
 def waitfor():
-    "wait for user action -- OK to do nothing if on a TTY"
+    "Wait for user action -- OK to do nothing if on a TTY"
     if game.options & OPTION_CURSES:
-	stsdcr.getch()
+	stdscr.getch()
 
 def announce():
     skip(1)
-    if game.skill > SKILL_FAIR:
-	prouts(_("[ANOUNCEMENT ARRIVING...]"))
-    else:
-	prouts(_("[IMPORTANT ANNOUNCEMENT ARRIVING -- PRESS ENTER TO CONTINUE]"))
+    prouts(_("[ANNOUNCEMENT ARRIVING...]"))
     skip(1)
 
 def pause_game():
@@ -3394,7 +3345,7 @@ def pause_game():
     if game.options & OPTION_CURSES:
         drawmaps(0)
         setwnd(prompt_window)
-        prompt_window.wclear()
+        prompt_window.clear()
         prompt_window.addstr(prompt)
         prompt_window.getstr()
         prompt_window.clear()
@@ -3402,16 +3353,16 @@ def pause_game():
         setwnd(message_window)
     else:
         global linecount
-        stdout.write('\n')
+        sys.stdout.write('\n')
         proutn(prompt)
         raw_input()
-        for j in range(0, rows):
-            stdout.write('\n')
+        for j in range(rows):
+            sys.stdout.write('\n')
         linecount = 0
 
 def skip(i):
     "Skip i lines.  Pause game if this would cause a scrolling event."
-    while dummy in range(i):
+    for dummy in range(i):
 	if game.options & OPTION_CURSES:
             (y, x) = curwnd.getyx()
             (my, mx) = curwnd.getmaxyx()
@@ -3419,14 +3370,17 @@ def skip(i):
 		pause_game()
 		clrscr()
 	    else:
-		proutn("\n")
+                try:
+                    curwnd.move(y+1, 0)
+                except curses.error:
+                    pass
 	else:
             global linecount
 	    linecount += 1
-	    if linecount >= rows:
+	    if rows and linecount >= rows:
 		pause_game()
 	    else:
-		stdout.write('\n')
+		sys.stdout.write('\n')
 
 def proutn(line):
     "Utter a line with no following line feed."
@@ -3434,38 +3388,51 @@ def proutn(line):
 	curwnd.addstr(line)
 	curwnd.refresh()
     else:
-	stdout.write(line)
+	sys.stdout.write(line)
+        sys.stdout.flush()
 
 def prout(line):
     proutn(line)
     skip(1)
 
 def prouts(line):
-    "print slowly!" 
+    "Emit slowly!" 
     for c in line:
-	curses.delay_output(30)
+        if not replayfp or replayfp.closed:	# Don't slow down replays
+            time.sleep(0.03)
 	proutn(c)
 	if game.options & OPTION_CURSES:
-	    wrefresh(curwnd)
+	    curwnd.refresh()
 	else:
 	    sys.stdout.flush()
-    curses.delay_output(300)
+    if not replayfp or replayfp.closed:
+        time.sleep(0.03)
 
-def cgetline(line, max):
+def cgetline():
     "Get a line of input."
     if game.options & OPTION_CURSES:
 	line = curwnd.getstr() + "\n"
 	curwnd.refresh()
     else:
 	if replayfp and not replayfp.closed:
-	    line = replayfp.readline()
+            while True:
+                line = replayfp.readline()
+                proutn(line)
+                if line == '':
+                    prout("*** Replay finished")
+                    replayfp.close()
+                    break
+                elif line[0] != "#":
+                    break
 	else:
-	    sys.stdin.readline()
+	    line = raw_input() + "\n"
     if logfp:
 	logfp.write(line)
+    return line
 
 def setwnd(wnd):
-    "Change windows -- OK for this to be a no-op in tty mode." 
+    "Change windows -- OK for this to be a no-op in tty mode."
+    global curwnd
     if game.options & OPTION_CURSES:
         curwnd = wnd
         curses.curs_set(wnd == fullscreen_window or wnd == message_window or wnd == prompt_window)
@@ -3473,8 +3440,8 @@ def setwnd(wnd):
 def clreol():
     "Clear to end of line -- can be a no-op in tty mode" 
     if game.options & OPTION_CURSES:
-        wclrtoeol(curwnd)
-        wrefresh(curwnd)
+        curwnd.clrtoeol()
+        curwnd.refresh()
 
 def clrscr():
     "Clear screen -- can be a no-op in tty mode."
@@ -3484,53 +3451,12 @@ def clrscr():
        curwnd.move(0, 0)
        curwnd.refresh()
     linecount = 0
-
-def textcolor(color):
-    "Set the current text color"
-    if game.options & OPTION_CURSES:
-	if color == DEFAULT: 
-	    curwnd.attrset(0)
-	elif color == BLACK: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLACK))
-	elif color == BLUE: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLUE))
-	elif color == GREEN: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_GREEN))
-	elif color == CYAN: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_CYAN))
-	elif color == RED: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_RED))
-	elif color == MAGENTA: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_MAGENTA))
-	elif color == BROWN: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_YELLOW))
-	elif color == LIGHTGRAY: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_WHITE))
-	elif color == DARKGRAY: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLACK) | curses.A_BOLD)
-	elif color == LIGHTBLUE: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLUE) | curses.A_BOLD)
-	elif color == LIGHTGREEN: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_GREEN) | curses.A_BOLD)
-	elif color == LIGHTCYAN: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_CYAN) | curses.A_BOLD)
-	elif color == LIGHTRED: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_RED) | curses.A_BOLD)
-	elif color == LIGHTMAGENTA: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_MAGENTA) | curses.A_BOLD)
-	elif color == YELLOW: 
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_YELLOW) | curses.A_BOLD)
-	elif color == WHITE:
-	    curwnd.attron(curses.COLOR_PAIR(curses.COLOR_WHITE) | curses.A_BOLD)
-
+    
 def highvideo():
     "Set highlight video, if this is reasonable."
     if game.options & OPTION_CURSES:
 	curwnd.attron(curses.A_REVERSE)
  
-def commandhook(cmd, before):
-    pass
-
 #
 # Things past this point have policy implications.
 # 
@@ -3550,15 +3476,15 @@ def drawmaps(mode):
 	    setwnd(report_window)
 	    report_window.clear()
 	    report_window.move(0, 0)
-	    status(0)
+	    status()
 	    setwnd(lrscan_window)
 	    lrscan_window.clear()
 	    lrscan_window.move(0, 0)
-	    lrscan()
+	    lrscan(silent=False)
 
 def put_srscan_sym(w, sym):
     "Emit symbol for short-range scan."
-    srscan_window.move(w.x+1, w.y*2+2)
+    srscan_window.move(w.i+1, w.j*2+2)
     srscan_window.addch(sym)
     srscan_window.refresh()
 
@@ -3568,12 +3494,12 @@ def boom(w):
 	drawmaps(2)
 	setwnd(srscan_window)
 	srscan_window.attron(curses.A_REVERSE)
-	put_srscan_sym(w, game.quad[w.x][w.y])
+	put_srscan_sym(w, game.quad[w.i][w.j])
 	#sound(500)
-	#delay(1000)
+	#time.sleep(1.0)
 	#nosound()
 	srscan_window.attroff(curses.A_REVERSE)
-	put_srscan_sym(w, game.quad[w.x][w.y])
+	put_srscan_sym(w, game.quad[w.i][w.j])
 	curses.delay_output(500)
 	setwnd(message_window) 
 
@@ -3589,40 +3515,40 @@ def warble():
 	#nosound()
         pass
 
-def tracktorpedo(w, l, i, n, iquad):
+def tracktorpedo(origin, w, step, i, n, iquad):
     "Torpedo-track animation." 
     if not game.options & OPTION_CURSES:
-	if l == 1:
+	if step == 1:
 	    if n != 1:
 		skip(1)
-		proutn(_("Track for torpedo number %d-  ") % i)
+		proutn(_("Track for torpedo number %d-  ") % (i+1))
 	    else:
 		skip(1)
 		proutn(_("Torpedo track- "))
-	elif l==4 or l==9: 
+	elif step==4 or step==9: 
 	    skip(1)
-	proutn("%d - %d   " % (w.x, w.y))
+	proutn("%s   " % w)
     else:
 	if not damaged(DSRSENS) or game.condition=="docked":
-	    if i != 1 and l == 1:
+	    if i != 0 and step == 1:
 		drawmaps(2)
-		curses.delay_output(400)
+		time.sleep(0.4)
 	    if (iquad==IHDOT) or (iquad==IHBLANK):
 		put_srscan_sym(w, '+')
-		#sound(l*10)
-		#curses.delay_output(100)
+		#sound(step*10)
+		#time.sleep(0.1)
 		#nosound()
 		put_srscan_sym(w, iquad)
 	    else:
 		curwnd.attron(curses.A_REVERSE)
 		put_srscan_sym(w, iquad)
 		#sound(500)
-		#curses.delay_output(1000)
+		#time.sleep(1.0)
 		#nosound()
 		curwnd.attroff(curses.A_REVERSE)
 		put_srscan_sym(w, iquad)
 	else:
-	    proutn("%d - %d   " % (w.x, w.y))
+	    proutn("%s   " % w)
 
 def makechart():
     "Display the current galaxy chart."
@@ -3641,113 +3567,107 @@ def prstat(txt, data):
 	skip(1)
 	setwnd(status_window)
     else:
-        proutn(" " * NSYM - len(tx))
-    vproutn(data)
+        proutn(" " * (NSYM - len(txt)))
+    proutn(data)
     skip(1)
     if game.options & OPTION_CURSES:
 	setwnd(report_window)
 
 # Code from moving.c begins here
 
-def imove(novapush):
-    # movement execution for warp, impulse, supernova, and tractor-beam events 
+def imove(course=None, novapush=False):
+    "Movement execution for warp, impulse, supernova, and tractor-beam events."
     w = coord(); final = coord()
     trbeam = False
 
     def no_quad_change():
-        # No quadrant change -- compute new avg enemy distances 
-        game.quad[game.sector.x][game.sector.y] = game.ship
-        if game.nenhere:
-            for m in range(1, game.nenhere+1):
-                finald = distance(w, game.ks[m])
-                game.kavgd[m] = 0.5 * (finald+game.kdist[m])
-                game.kdist[m] = finald
-            sortklings()
-            if not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
-                attack(False)
-            for m in range(1, game.nenhere+1):
-                game.kavgd[m] = game.kdist[m]
+        # No quadrant change -- compute new average enemy distances 
+        game.quad[game.sector.i][game.sector.j] = game.ship
+        if game.enemies:
+            for enemy in game.enemies:
+                finald = (w-enemy.kloc).distance()
+                enemy.kavgd = 0.5 * (finald + enemy.kdist)
+                enemy.kdist = finald
+            game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+            if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
+                attack(torps_ok=False)
+            for enemy in game.enemies:
+                enemy.kavgd = enemy.kdist
         newcnd()
         drawmaps(0)
         setwnd(message_window)
-
-    w.x = w.y = 0
+    w.i = w.j = 0
     if game.inorbit:
 	prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
 	game.inorbit = False
-
-    angle = ((15.0 - game.direc) * 0.5235988)
+    angle = ((15.0 - course.bearing) * 0.5235988)
     deltax = -math.sin(angle)
     deltay = math.cos(angle)
     if math.fabs(deltax) > math.fabs(deltay):
 	bigger = math.fabs(deltax)
     else:
 	bigger = math.fabs(deltay)
-		
     deltay /= bigger
     deltax /= bigger
-
     # If tractor beam is to occur, don't move full distance 
     if game.state.date+game.optime >= scheduled(FTBEAM):
 	trbeam = True
 	game.condition = "red"
-	game.dist = game.dist*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1
+	course.distance = course.distance*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1
 	game.optime = scheduled(FTBEAM) - game.state.date + 1e-5
     # Move within the quadrant 
-    game.quad[game.sector.x][game.sector.y] = IHDOT
-    x = game.sector.x
-    y = game.sector.y
-    n = 10.0*game.dist*bigger+0.5
-
+    game.quad[game.sector.i][game.sector.j] = IHDOT
+    x = game.sector.i
+    y = game.sector.j
+    n = int(10.0*course.distance*bigger+0.5)
     if n > 0:
 	for m in range(1, n+1):
             x += deltax
             y += deltay
-	    w.x = x + 0.5
-	    w.y = y + 0.5
-	    if not VALID_SECTOR(w.x, w.y):
+	    w.i = int(round(x))
+	    w.j = int(round(y))
+	    if not w.valid_sector():
 		# Leaving quadrant -- allow final enemy attack 
 		# Don't do it if being pushed by Nova 
-		if game.nenhere != 0 and not novapush:
+		if len(game.enemies) != 0 and not novapush:
 		    newcnd()
-		    for m in range(1, game.nenhere+1):
-			finald = distance(w, game.ks[m])
-			game.kavgd[m] = 0.5 * (finald + game.kdist[m])
+		    for enemy in game.enemies:
+			finald = (w - enemy.kloc).distance()
+			enemy.kavgd = 0.5 * (finald + enemy.kdist)
 		    #
 		    # Stas Sergeev added the condition
 		    # that attacks only happen if Klingons
 		    # are present and your skill is good.
 		    # 
-		    if game.skill > SKILL_GOOD and game.klhere > 0 and not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
-			attack(False)
+		    if game.skill > SKILL_GOOD and game.klhere > 0 and not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
+			attack(torps_ok=False)
 		    if game.alldone:
 			return
 		# compute final position -- new quadrant and sector 
-		x = QUADSIZE*(game.quadrant.x-1)+game.sector.x
-		y = QUADSIZE*(game.quadrant.y-1)+game.sector.y
-		w.x = x+10.0*game.dist*bigger*deltax+0.5
-		w.y = y+10.0*game.dist*bigger*deltay+0.5
+		x = (QUADSIZE*game.quadrant.i)+game.sector.i
+		y = (QUADSIZE*game.quadrant.j)+game.sector.j
+		w.i = int(round(x+QUADSIZE*course.distance*bigger*deltax))
+		w.j = int(round(y+QUADSIZE*course.distance*bigger*deltay))
 		# check for edge of galaxy 
 		kinks = 0
                 while True:
-		    kink = 0
-		    if w.x <= 0:
-			w.x = -w.x + 1
-			kink = 1
-		    if w.y <= 0:
-			w.y = -w.y + 1
-			kink = 1
-		    if w.x > GALSIZE*QUADSIZE:
-			w.x = (GALSIZE*QUADSIZE*2)+1 - w.x
-			kink = 1
-		    if w.y > GALSIZE*QUADSIZE:
-			w.y = (GALSIZE*QUADSIZE*2)+1 - w.y
-			kink = 1
+		    kink = False
+		    if w.i < 0:
+			w.i = -w.i
+			kink = True
+		    if w.j < 0:
+			w.j = -w.j
+			kink = True
+		    if w.i >= GALSIZE*QUADSIZE:
+			w.i = (GALSIZE*QUADSIZE*2) - w.i
+			kink = True
+		    if w.j >= GALSIZE*QUADSIZE:
+			w.j = (GALSIZE*QUADSIZE*2) - w.j
+			kink = True
 		    if kink:
-			kinks = 1
-		if not kink:
-                    break
-
+			kinks += 1
+                    else:
+                        break
 		if kinks:
 		    game.nkinks += 1
 		    if game.nkinks == 3:
@@ -3761,44 +3681,44 @@ def imove(novapush):
 		# Compute final position in new quadrant 
 		if trbeam: # Don't bother if we are to be beamed 
 		    return
-		game.quadrant.x = (w.x+(QUADSIZE-1))/QUADSIZE
-		game.quadrant.y = (w.y+(QUADSIZE-1))/QUADSIZE
-		game.sector.x = w.x - QUADSIZE*(game.quadrant.x-1)
-		game.sector.y = w.y - QUADSIZE*(game.quadrant.y-1)
+		game.quadrant.i = w.i/QUADSIZE
+		game.quadrant.j = w.j/QUADSIZE
+		game.sector.i = w.i - (QUADSIZE*game.quadrant.i)
+		game.sector.j = w.j - (QUADSIZE*game.quadrant.j)
 		skip(1)
 		prout(_("Entering Quadrant %s.") % game.quadrant)
-		game.quad[game.sector.x][game.sector.y] = game.ship
-		newqad(False)
+		game.quad[game.sector.i][game.sector.j] = game.ship
+		newqad()
 		if game.skill>SKILL_NOVICE:
-		    attack(False)  
+		    attack(torps_ok=False)  
 		return
-	    iquad = game.quad[w.x][w.y]
+	    iquad = game.quad[w.i][w.j]
 	    if iquad != IHDOT:
 		# object encountered in flight path 
-		stopegy = 50.0*game.dist/game.optime
-		game.dist = distance(game.sector, w) / (QUADSIZE * 1.0)
-                if iquad in (IHT. IHK, OHC, IHS, IHR, IHQUEST):
+		stopegy = 50.0*course.dist/game.optime
+		course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
+                if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST):
 		    game.sector = w
-		    ram(False, iquad, game.sector)
+                    for enemy in game.enemies:
+                        if enemy.kloc == game.sector:
+                            break
+		    collision(rammed=False, enemy=enemy)
 		    final = game.sector
 		elif iquad == IHBLANK:
 		    skip(1)
 		    prouts(_("***RED ALERT!  RED ALERT!"))
 		    skip(1)
-		    proutn("***")
-		    crmshp()
+		    proutn("***" + crmshp())
 		    proutn(_(" pulled into black hole at Sector %s") % w)
-		    #
 		    # Getting pulled into a black hole was certain
 		    # death in Almy's original.  Stas Sergeev added a
 		    # possibility that you'll get timewarped instead.
-		    # 
 		    n=0
-		    for m in range(0, NDEVICES):
+		    for m in range(NDEVICES):
 			if game.damage[m]>0: 
 			    n += 1
 		    probf=math.pow(1.4,(game.energy+game.shield)/5000.0-1.0)*math.pow(1.3,1.0/(n+1)-1.0)
-		    if (game.options & OPTION_BLKHOLE) and Rand()>probf: 
+		    if (game.options & OPTION_BLKHOLE) and withprob(1-probf): 
 			timwrp()
 		    else: 
 			finish(FHOLE)
@@ -3806,16 +3726,16 @@ def imove(novapush):
 		else:
 		    # something else 
 		    skip(1)
-		    crmshp()
+		    proutn(crmshp())
 		    if iquad == IHWEB:
-			proutn(_(" encounters Tholian web at %s;") % w)
+			prout(_(" encounters Tholian web at %s;") % w)
 		    else:
-			proutn(_(" blocked by object at %s;") % w)
+			prout(_(" blocked by object at %s;") % w)
 		    proutn(_("Emergency stop required "))
 		    prout(_("%2d units of energy.") % int(stopegy))
 		    game.energy -= stopegy
-		    final.x = x-deltax+0.5
-		    final.y = y-deltay+0.5
+		    final.i = int(round(deltax))
+		    final.j = int(round(deltay))
 		    game.sector = final
 		    if game.energy <= 0:
 			finish(FNRG)
@@ -3823,24 +3743,23 @@ def imove(novapush):
                 # We're here!
 		no_quad_change()
                 return
-	game.dist = distance(game.sector, w) / (QUADSIZE * 1.0)
+	course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
 	game.sector = w
     final = game.sector
     no_quad_change()
     return
 
 def dock(verbose):
-    # dock our ship at a starbase 
-    chew()
+    "Dock our ship at a starbase."
+    scanner.chew()
     if game.condition == "docked" and verbose:
 	prout(_("Already docked."))
 	return
     if game.inorbit:
 	prout(_("You must first leave standard orbit."))
 	return
-    if not is_valid(game.base) or abs(game.sector.x-game.base.x) > 1 or abs(game.sector.y-game.base.y) > 1:
-	crmshp()
-	prout(_(" not adjacent to base."))
+    if not game.base.is_valid() or abs(game.sector.i-game.base.i) > 1 or abs(game.sector.j-game.base.j) > 1:
+	prout(crmshp() + _(" not adjacent to base."))
 	return
     game.condition = "docked"
     if "verbose":
@@ -3858,8 +3777,7 @@ def dock(verbose):
 	prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\""))
 	attackreport(False)
 	game.iseenit = True
-
-# 
+ 
 # This program originally required input in terms of a (clock)
 # direction and distance. Somewhere in history, it was changed to
 # cartesian coordinates. So we need to convert.  Probably
@@ -3867,59 +3785,56 @@ def dock(verbose):
 # pain if the computer isn't working! Manual mode is still confusing
 # because it involves giving x and y motions, yet the coordinates
 # are always displayed y - x, where +y is downward!
-# 
 
-def getcd(isprobe, akey):
-    # get course and distance 
-    irowq=game.quadrant.x; icolq=game.quadrant.y; key=0
+def cartesian(loc1=None, loc2=None):
+    if loc1 is None:
+        return game.quadrant * QUADSIZE + game.sector
+    elif loc2 is None:
+        return game.quadrant * QUADSIZE + loc1
+    else:
+        return loc1 * QUADSIZE + loc2
+
+def getcourse(isprobe):
+    "Get a course and distance from the user."
+    key = 0
+    dquad = copy.copy(game.quadrant)
     navmode = "unspecified"
     itemp = "curt"
-    incr = coord()
+    dsect = coord()
     iprompt = False
-
-    # Get course direction and distance. If user types bad values, return
-    # with DIREC = -1.0.
-    game.direc = -1.0
-	
     if game.landed and not isprobe:
 	prout(_("Dummy! You can't leave standard orbit until you"))
 	proutn(_("are back aboard the ship."))
-	chew()
-	return
+	scanner.chew()
+	raise TrekError
     while navmode == "unspecified":
 	if damaged(DNAVSYS):
 	    if isprobe:
 		prout(_("Computer damaged; manual navigation only"))
 	    else:
 		prout(_("Computer damaged; manual movement only"))
-	    chew()
+	    scanner.chew()
 	    navmode = "manual"
-	    key = IHEOL
+	    key = "IHEOL"
 	    break
-	if isprobe and akey != -1:
-	    # For probe launch, use pre-scanned value first time 
-	    key = akey
-	    akey = -1
-	else: 
-	    key = scan()
-
-	if key == IHEOL:
+        key = scanner.next()
+	if key == "IHEOL":
 	    proutn(_("Manual or automatic- "))
 	    iprompt = True
-	    chew()
-	elif key == IHALPHA:
-            if isit("manual"):
+	    scanner.chew()
+	elif key == "IHALPHA":
+            if scanner.sees("manual"):
 		navmode = "manual"
-		key = scan()
+		key = scanner.next()
 		break
-            elif isit("automatic"):
+            elif scanner.sees("automatic"):
 		navmode = "automatic"
-		key = scan()
+		key = scanner.next()
 		break
 	    else:
 		huh()
-		chew()
-		return
+		scanner.chew()
+		raise TrekError
 	else: # numeric 
 	    if isprobe:
 		prout(_("(Manual navigation assumed.)"))
@@ -3927,108 +3842,142 @@ def getcd(isprobe, akey):
 		prout(_("(Manual movement assumed.)"))
 	    navmode = "manual"
 	    break
-
+    delta = coord()
     if navmode == "automatic":
-	while key == IHEOL:
+	while key == "IHEOL":
 	    if isprobe:
 		proutn(_("Target quadrant or quadrant&sector- "))
 	    else:
 		proutn(_("Destination sector or quadrant&sector- "))
-	    chew()
+	    scanner.chew()
 	    iprompt = True
-	    key = scan()
-
-	if key != IHREAL:
+	    key = scanner.next()
+	if key != "IHREAL":
 	    huh()
-	    return
-	xi = aaitem
-	key = scan()
-	if key != IHREAL:
+	    raise TrekError
+	xi = int(round(scanner.real))-1
+	key = scanner.next()
+	if key != "IHREAL":
 	    huh()
-	    return
-	xj = aaitem
-	key = scan()
-	if key == IHREAL:
+	    raise TrekError
+	xj = int(round(scanner.real))-1
+	key = scanner.next()
+	if key == "IHREAL":
 	    # both quadrant and sector specified 
-	    xk = aaitem
-	    key = scan()
-	    if key != IHREAL:
+	    xk = int(round(scanner.real))-1
+	    key = scanner.next()
+	    if key != "IHREAL":
 		huh()
-		return
-	    xl = aaitem
-
-	    irowq = xi + 0.5
-	    icolq = xj + 0.5
-	    incr.y = xk + 0.5
-	    incr.x = xl + 0.5
+		raise TrekError
+	    xl = int(round(scanner.real))-1
+	    dquad.i = xi
+	    dquad.j = xj
+	    dsect.i = xk
+	    dsect.j = xl
 	else:
+            # only one pair of numbers was specified
 	    if isprobe:
 		# only quadrant specified -- go to center of dest quad 
-		irowq = xi + 0.5
-		icolq = xj + 0.5
-		incr.y = incr.x = 5
+		dquad.i = xi
+		dquad.j = xj
+		dsect.j = dsect.i = 4	# preserves 1-origin behavior
 	    else:
-		incr.y = xi + 0.5
-		incr.x = xj + 0.5
+                # only sector specified
+		dsect.i = xi
+		dsect.j = xj
 	    itemp = "normal"
-	if not VALID_QUADRANT(icolq,irowq) or not VALID_SECTOR(incr.x,incr.y):
+	if not dquad.valid_quadrant() or not dsect.valid_sector():
 	    huh()
-	    return
+	    raise TrekError
 	skip(1)
 	if not isprobe:
 	    if itemp > "curt":
 		if iprompt:
-		    prout(_("Helmsman Sulu- \"Course locked in for Sector %s.\"") % incr)
+		    prout(_("Helmsman Sulu- \"Course locked in for Sector %s.\"") % dsect)
 	    else:
 		prout(_("Ensign Chekov- \"Course laid in, Captain.\""))
-	deltax = icolq - game.quadrant.y + 0.1*(incr.x-game.sector.y)
-	deltay = game.quadrant.x - irowq + 0.1*(game.sector.x-incr.y)
+        # the actual deltas get computed here
+	delta.j = dquad.j-game.quadrant.j + (dsect.j-game.sector.j)/(QUADSIZE*1.0)
+	delta.i = game.quadrant.i-dquad.i + (game.sector.i-dsect.i)/(QUADSIZE*1.0)
     else: # manual 
-	while key == IHEOL:
+	while key == "IHEOL":
 	    proutn(_("X and Y displacements- "))
-	    chew()
+	    scanner.chew()
 	    iprompt = True
-	    key = scan()
+	    key = scanner.next()
 	itemp = "verbose"
-	if key != IHREAL:
+	if key != "IHREAL":
 	    huh()
-	    return
-	deltax = aaitem
-	key = scan()
-	if key != IHREAL:
+	    raise TrekError
+	delta.j = scanner.real
+	key = scanner.next()
+	if key != "IHREAL":
 	    huh()
-	    return
-	deltay = aaitem
+	    raise TrekError
+	delta.i = scanner.real
     # Check for zero movement 
-    if deltax == 0 and deltay == 0:
-	chew()
-	return
+    if delta.i == 0 and delta.j == 0:
+	scanner.chew()
+	raise TrekError
     if itemp == "verbose" and not isprobe:
 	skip(1)
 	prout(_("Helmsman Sulu- \"Aye, Sir.\""))
-    game.dist = math.sqrt(deltax*deltax + deltay*deltay)
-    game.direc = math.atan2(deltax, deltay)*1.90985932
-    if game.direc < 0.0:
-	game.direc += 12.0
-    chew()
-    return
+    scanner.chew()
+    return course(bearing=delta.bearing(), distance=delta.distance())
+
+class course:
+    def __init__(self, bearing, distance, origin=None): 
+        self.distance = distance
+        self.bearing = bearing
+        # The bearing() code we inherited from FORTRAN is actually computing
+        # clockface directions!
+        if self.bearing < 0.0:
+            self.bearing += 12.0
+        self.angle = ((15.0 - self.bearing) * 0.5235988)
+        if origin is None:
+            self.location = cartesian(game.quadrant, game.sector)
+        else:
+            self.location = cartesian(game.quadrant, origin)
+        self.increment = coord(-math.sin(self.angle), math.cos(self.angle))
+        bigger = max(abs(self.increment.i), abs(self.increment.j))
+        self.increment /= bigger
+        self.moves = 10*self.distance*bigger +0.5
+    def next(self, grain=1):
+        "Next step on course."
+        self.moves -=1
+        self.nextlocation = self.location + self.increment
+        oldloc = (self.location/grain).roundtogrid()
+        newloc = (self.nextlocation/grain).roundtogrid()
+        self.location = self.nextlocation
+        if newloc != oldloc:
+            return True
+        else:
+            return False
+    def quadrant(self):
+        return (self.location / QUADSIZE).roundtogrid()
+    def sector(self):
+        return coord(int(round(self.location.i)) % QUADSIZE, int(round(self.location.j)) % QUADSIZE)
+    def power(self, warp):
+	return self.distance*(warp**3)*(game.shldup+1)
+    def time(self, warp):
+        return 10.0*self.distance/warp**2
 
 def impulse():
-    # move under impulse power 
+    "Move under impulse power."
     game.ididit = False
     if damaged(DIMPULS):
-	chew()
+	scanner.chew()
 	skip(1)
 	prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\""))
 	return
     if game.energy > 30.0:
-	getcd(False, 0)
-	if game.direc == -1.0:
+        try:
+            course = getcourse(isprobe=False)
+        except TrekError:
 	    return
-	power = 20.0 + 100.0*game.dist
+	power = 20.0 + 100.0*course.distance
     else:
 	power = 30.0
-
     if power >= game.energy:
 	# Insufficient power for trip 
 	skip(1)
@@ -4040,10 +3989,10 @@ def impulse():
 	    prout(_(" quadrants.\""))
 	else:
 	    prout(_("quadrant.  They are, therefore, useless.\""))
-	chew()
+	scanner.chew()
 	return
     # Make sure enough time is left for the trip 
-    game.optime = game.dist/0.095
+    game.optime = course.dist/0.095
     if game.optime >= game.state.remtime:
 	prout(_("First Officer Spock- \"Captain, our speed under impulse"))
 	prout(_("power is only 0.95 sectors per stardate. Are you sure"))
@@ -4051,48 +4000,49 @@ def impulse():
 	if ja() == False:
 	    return
     # Activate impulse engines and pay the cost 
-    imove(False)
+    imove(course, novapush=False)
     game.ididit = True
     if game.alldone:
 	return
-    power = 20.0 + 100.0*game.dist
+    power = 20.0 + 100.0*course.dist
     game.energy -= power
-    game.optime = game.dist/0.095
+    game.optime = course.dist/0.095
     if game.energy <= 0:
 	finish(FNRG)
     return
 
-def warp(timewarp):
-    # move under warp drive 
+def warp(course, involuntary):
+    "ove under warp drive."
     blooey = False; twarp = False
-    if not timewarp: # Not WARPX entry 
+    if not involuntary: # Not WARPX entry 
 	game.ididit = False
 	if game.damage[DWARPEN] > 10.0:
-	    chew()
+	    scanner.chew()
 	    skip(1)
-	    prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\""))
+	    prout(_("Engineer Scott- \"The warp engines are damaged, Sir.\""))
 	    return
 	if damaged(DWARPEN) and game.warpfac > 4.0:
-	    chew()
+	    scanner.chew()
 	    skip(1)
 	    prout(_("Engineer Scott- \"Sorry, Captain. Until this damage"))
 	    prout(_("  is repaired, I can only give you warp 4.\""))
 	    return
-			
-	# Read in course and distance 
-	getcd(False, 0)
-	if game.direc == -1.0:
-	    return
-
-	# Make sure starship has enough energy for the trip 
-	power = (game.dist+0.05)*game.warpfac*game.warpfac*game.warpfac*(game.shldup+1)
-	if power >= game.energy:
+       	# Read in course and distance
+        if course==None:
+            try:
+                course = getcourse(isprobe=False)
+            except TrekError:
+                return
+	# Make sure starship has enough energy for the trip
+        # Note: this formula is slightly different from the C version,
+        # and lets you skate a bit closer to the edge.
+	if course.power(game.warpfac) >= game.energy:
 	    # Insufficient power for trip 
 	    game.ididit = False
 	    skip(1)
 	    prout(_("Engineering to bridge--"))
 	    if not game.shldup or 0.5*power > game.energy:
-		iwarp = math.pow((game.energy/(game.dist+0.05)), 0.333333333)
+		iwarp = (game.energy/(course.dist+0.05)) ** 0.333333333
 		if iwarp <= 0:
 		    prout(_("We can't do it, Captain. We don't have enough energy."))
 		else:
@@ -4104,10 +4054,9 @@ def warp(timewarp):
 			prout(".")
 	    else:
 		prout(_("We haven't the energy to go that far with the shields up."))
-	    return
-						
+	    return				
 	# Make sure enough time is left for the trip 
-	game.optime = 10.0*game.dist/game.wfacsq
+	game.optime = course.time(game.warpfac)
 	if game.optime >= 0.8*game.state.remtime:
 	    skip(1)
 	    prout(_("First Officer Spock- \"Captain, I compute that such"))
@@ -4121,13 +4070,14 @@ def warp(timewarp):
 		return
     # Entry WARPX 
     if game.warpfac > 6.0:
-	# Decide if engine damage will occur 
-	prob = game.dist*(6.0-game.warpfac)*(6.0-game.warpfac)/66.666666666
-	if prob > Rand():
+	# Decide if engine damage will occur
+        # ESR: Seems wrong. Probability of damage goes *down* with distance? 
+	prob = course.dist*(6.0-game.warpfac)**2/66.666666666
+	if prob > randreal():
 	    blooey = True
-	    game.dist = Rand()*game.dist
+	    course.distance = randreal(course.distance)
 	# Decide if time warp will occur 
-	if 0.5*game.dist*math.pow(7.0,game.warpfac-10.0) > Rand():
+	if 0.5*course.dist*math.pow(7.0,game.warpfac-10.0) > randreal():
 	    twarp = True
 	if idebug and game.warpfac==10 and not twarp:
 	    blooey = False
@@ -4137,43 +4087,40 @@ def warp(timewarp):
 	if blooey or twarp:
 	    # If time warp or engine damage, check path 
 	    # If it is obstructed, don't do warp or damage 
-	    angle = ((15.0-game.direc)*0.5235998)
+	    angle = ((15.0-course.bearing)*0.5235998)
 	    deltax = -math.sin(angle)
 	    deltay = math.cos(angle)
 	    if math.fabs(deltax) > math.fabs(deltay):
 		bigger = math.fabs(deltax)
 	    else:
 		bigger = math.fabs(deltay)
-			
 	    deltax /= bigger
 	    deltay /= bigger
-	    n = 10.0 * game.dist * bigger +0.5
-	    x = game.sector.x
-	    y = game.sector.y
+	    n = 10.0 * course.distance * bigger +0.5
+	    x = game.sector.i
+	    y = game.sector.j
 	    for l in range(1, n+1):
 		x += deltax
 		ix = x + 0.5
 		y += deltay
 		iy = y +0.5
-		if not VALID_SECTOR(ix, iy):
+		if not coord(ix, iy).valid_sector():
 		    break
 		if game.quad[ix][iy] != IHDOT:
 		    blooey = False
 		    twarp = False
-				
-
     # Activate Warp Engines and pay the cost 
-    imove(False)
+    imove(course, novapush=False)
     if game.alldone:
 	return
-    game.energy -= game.dist*game.warpfac*game.warpfac*game.warpfac*(game.shldup+1)
+    game.energy -= course.power(game.warpfac)
     if game.energy <= 0:
 	finish(FNRG)
-    game.optime = 10.0*game.dist/game.wfacsq
+    game.optime = course.time(game.warpfac)
     if twarp:
 	timwrp()
     if blooey:
-	game.damage[DWARPEN] = game.damfac*(3.0*Rand()+1.0)
+	game.damage[DWARPEN] = game.damfac * randreal(1.0, 4.0)
 	skip(1)
 	prout(_("Engineering to bridge--"))
 	prout(_("  Scott here.  The warp engines are damaged."))
@@ -4182,33 +4129,32 @@ def warp(timewarp):
     return
 
 def setwarp():
-    # change the warp factor 	
+    "Change the warp factor."
     while True:
-        key=scan()
-        if key != IHEOL:
+        key=scanner.next()
+        if key != "IHEOL":
             break
-	chew()
+	scanner.chew()
 	proutn(_("Warp factor- "))
-    chew()
-    if key != IHREAL:
+    scanner.chew()
+    if key != "IHREAL":
 	huh()
 	return
     if game.damage[DWARPEN] > 10.0:
 	prout(_("Warp engines inoperative."))
 	return
-    if damaged(DWARPEN) and aaitem > 4.0:
+    if damaged(DWARPEN) and scanner.real > 4.0:
 	prout(_("Engineer Scott- \"I'm doing my best, Captain,"))
 	prout(_("  but right now we can only go warp 4.\""))
 	return
-    if aaitem > 10.0:
+    if scanner.real > 10.0:
 	prout(_("Helmsman Sulu- \"Our top speed is warp 10, Captain.\""))
 	return
-    if aaitem < 1.0:
+    if scanner.real < 1.0:
 	prout(_("Helmsman Sulu- \"We can't go below warp 1, Captain.\""))
 	return
     oldfac = game.warpfac
-    game.warpfac = aaitem
-    game.wfacsq=game.warpfac*game.warpfac
+    game.warpfac = scanner.real
     if game.warpfac <= oldfac or game.warpfac <= 6.0:
 	prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") %
 	       int(game.warpfac))
@@ -4223,9 +4169,8 @@ def setwarp():
     return
 
 def atover(igrab):
-    # cope with being tossed out of quadrant by supernova or yanked by beam 
-
-    chew()
+    "Cope with being tossed out of quadrant by supernova or yanked by beam."
+    scanner.chew()
     # is captain on planet? 
     if game.landed:
 	if damaged(DTRANSP):
@@ -4236,7 +4181,7 @@ def atover(igrab):
 	    prout(_("But with the shields up it's hopeless."))
 	    finish(FPNOVA)
 	prouts(_("His desperate attempt to rescue you . . ."))
-	if Rand() <= 0.5:
+	if withprob(0.5):
 	    prout(_("fails."))
 	    finish(FPNOVA)
 	    return
@@ -4244,56 +4189,49 @@ def atover(igrab):
 	if game.imine:
 	    game.imine = False
 	    proutn(_("The crystals mined were "))
-	    if Rand() <= 0.25:
+	    if withprob(0.25):
 		prout(_("lost."))
 	    else:
 		prout(_("saved."))
 		game.icrystl = True
     if igrab:
 	return
-
     # Check to see if captain in shuttle craft 
     if game.icraft:
 	finish(FSTRACTOR)
     if game.alldone:
 	return
-
     # Inform captain of attempt to reach safety 
     skip(1)
     while True:
 	if game.justin:
 	    prouts(_("***RED ALERT!  RED ALERT!"))
 	    skip(1)
-	    proutn(_("The "))
-	    crmshp()
-	    prout(_(" has stopped in a quadrant containing"))
+	    proutn(_("The %s has stopped in a quadrant containing") % crmshp())
 	    prouts(_("   a supernova."))
 	    skip(2)
-	proutn(_("***Emergency automatic override attempts to hurl "))
-	crmshp()
-	skip(1)
+	proutn(_("***Emergency automatic override attempts to hurl ")+crmshp())
 	prout(_("safely out of quadrant."))
 	if not damaged(DRADIO):
-	    game.state.galaxy[game.quadrant.x][game.quadrant.y].charted = True
+	    game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True
 	# Try to use warp engines 
 	if damaged(DWARPEN):
 	    skip(1)
 	    prout(_("Warp engines damaged."))
 	    finish(FSNOVAED)
 	    return
-	game.warpfac = 6.0+2.0*Rand()
-	game.wfacsq = game.warpfac * game.warpfac
+	game.warpfac = randreal(6.0, 8.0)
 	prout(_("Warp factor set to %d") % int(game.warpfac))
 	power = 0.75*game.energy
-	game.dist = power/(game.warpfac*game.warpfac*game.warpfac*(game.shldup+1))
-	distreq = 1.4142+Rand()
+	dist = power/(game.warpfac*game.warpfac*game.warpfac*(game.shldup+1))
+	distreq = randreal(math.sqrt(2))
 	if distreq < game.dist:
-	    game.dist = distreq
-	game.optime = 10.0*game.dist/game.wfacsq
-	game.direc = 12.0*Rand()	# How dumb! 
+	    dist = distreq
+        course = course(bearing=randreal(12), distance=dist)	# How dumb!
+	game.optime = course.time()
 	game.justin = False
 	game.inorbit = False
-	warp(True)
+	warp(course, involuntary=True)
 	if not game.justin:
 	    # This is bad news, we didn't leave quadrant. 
 	    if game.alldone:
@@ -4303,22 +4241,22 @@ def atover(igrab):
 	    finish(FSNOVAED)
 	    return
 	# Repeat if another snova
-        if not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
+        if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
             break
-    if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: 
+    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0: 
 	finish(FWON) # Snova killed remaining enemy. 
 
 def timwrp():
-    # let's do the time warp again 
+    "Let's do the time warp again."
     prout(_("***TIME WARP ENTERED."))
-    if game.state.snap and Rand() < 0.5:
+    if game.state.snap and withprob(0.5):
 	# Go back in time 
 	prout(_("You are traveling backwards in time %d stardates.") %
 	      int(game.state.date-game.snapsht.date))
 	game.state = game.snapsht
 	game.state.snap = False
-	if game.state.remcom:
-	    schedule(FTBEAM, expran(game.intime/game.state.remcom))
+	if len(game.state.kcmdr):
+	    schedule(FTBEAM, expran(game.intime/len(game.state.kcmdr)))
 	    schedule(FBATTAK, expran(0.3*game.intime))
 	schedule(FSNOVA, expran(0.5*game.intime))
 	# next snapshot will be sooner 
@@ -4329,8 +4267,7 @@ def timwrp():
 	game.isatb = 0
 	unschedule(FCDBAS)
 	unschedule(FSCDBAS)
-	invalidate(game.battle)
-
+	game.battle.invalidate()
 	# Make sure Galileo is consistant -- Snapshot may have been taken
         # when on planet, which would give us two Galileos! 
 	gotit = False
@@ -4345,26 +4282,24 @@ def timwrp():
 	if game.iscraft == "offship" and not gotit and game.damage[DSHUTTL] >= 0.0:
 	    prout(_("Checkov-  \"Security reports the Galileo has reappeared in the dock!\""))
 	    game.iscraft = "onship"
-	# 
-#	 * There used to be code to do the actual reconstrction here,
-#	 * but the starchart is now part of the snapshotted galaxy state.
-#	 
+        # There used to be code to do the actual reconstrction here,
+        # but the starchart is now part of the snapshotted galaxy state.
 	prout(_("Spock has reconstructed a correct star chart from memory"))
     else:
 	# Go forward in time 
-	game.optime = -0.5*game.intime*math.log(Rand())
+	game.optime = -0.5*game.intime*math.log(randreal())
 	prout(_("You are traveling forward in time %d stardates.") % int(game.optime))
 	# cheat to make sure no tractor beams occur during time warp 
 	postpone(FTBEAM, game.optime)
 	game.damage[DRADIO] += game.optime
-    newqad(False)
+    newqad()
     events()	# Stas Sergeev added this -- do pending events 
 
 def probe():
-    # launch deep-space probe 
+    "Launch deep-space probe." 
     # New code to launch a deep space probe 
     if game.nprobes == 0:
-	chew()
+	scanner.chew()
 	skip(1)
 	if game.ship == IHE: 
 	    prout(_("Engineer Scott- \"We have no more deep space probes, Sir.\""))
@@ -4372,12 +4307,12 @@ def probe():
 	    prout(_("Ye Faerie Queene has no deep space probes."))
 	return
     if damaged(DDSP):
-	chew()
+	scanner.chew()
 	skip(1)
 	prout(_("Engineer Scott- \"The probe launcher is damaged, Sir.\""))
 	return
     if is_scheduled(FDSPROB):
-	chew()
+	scanner.chew()
 	skip(1)
 	if damaged(DRADIO) and game.condition != "docked":
 	    prout(_("Spock-  \"Records show the previous probe has not yet"))
@@ -4385,10 +4320,8 @@ def probe():
 	else:
 	    prout(_("Uhura- \"The previous probe is still reporting data, Sir.\""))
 	return
-    key = scan()
-
-    if key == IHEOL:
-	# slow mode, so let Kirk know how many probes there are left
+    key = scanner.next()
+    if key == "IHEOL":
         if game.nprobes == 1:
             prout(_("1 probe left."))
         else:
@@ -4396,60 +4329,29 @@ def probe():
 	proutn(_("Are you sure you want to fire a probe? "))
 	if ja() == False:
 	    return
-
     game.isarmed = False
-    if key == IHALPHA and citem == "armed":
+    if key == "IHALPHA" and scanner.token == "armed":
 	game.isarmed = True
-	key = scan()
-    elif key == IHEOL:
+	key = scanner.next()
+    elif key == "IHEOL":
 	proutn(_("Arm NOVAMAX warhead? "))
 	game.isarmed = ja()
-    getcd(True, key)
-    if game.direc == -1.0:
-	return
+    elif key == "IHREAL":		# first element of course
+        scanner.push(scanner.token)
+    try:
+        game.probe = getcourse(isprobe=True)
+    except TrekError:
+        return
     game.nprobes -= 1
-    angle = ((15.0 - game.direc) * 0.5235988)
-    game.probeinx = -math.sin(angle)
-    game.probeiny = math.cos(angle)
-    if math.fabs(game.probeinx) > math.fabs(game.probeiny):
-	bigger = math.fabs(game.probeinx)
-    else:
-	bigger = math.fabs(game.probeiny)
-		
-    game.probeiny /= bigger
-    game.probeinx /= bigger
-    game.proben = 10.0*game.dist*bigger +0.5
-    game.probex = game.quadrant.x*QUADSIZE + game.sector.x - 1	# We will use better packing than original
-    game.probey = game.quadrant.y*QUADSIZE + game.sector.y - 1
-    game.probec = game.quadrant
     schedule(FDSPROB, 0.01) # Time to move one sector
     prout(_("Ensign Chekov-  \"The deep space probe is launched, Captain.\""))
     game.ididit = True
     return
 
-# Here's how the mayday code works:
-# 
-# First, the closest starbase is selected.  If there is a a starbase
-# in your own quadrant, you are in good shape.  This distance takes
-# quadrant distances into account only.
-#
-# A magic number is computed based on the distance which acts as the
-# probability that you will be rematerialized.  You get three tries.
-#
-# When it is determined that you should be able to be rematerialized
-# (i.e., when the probability thing mentioned above comes up
-# positive), you are put into that quadrant (anywhere).  Then, we try
-# to see if there is a spot adjacent to the star- base.  If not, you
-# can't be rematerialized!!!  Otherwise, it drops you there.  It only
-# tries five times to find a spot to drop you.  After that, it's your
-# problem.
-
 def mayday():
-    # yell for help from nearest starbase 
+    "Yell for help from nearest starbase."
     # There's more than one way to move in this game! 
-    line = 0
-
-    chew()
+    scanner.chew()
     # Test for conditions which prevent calling for help 
     if game.condition == "docked":
 	prout(_("Lt. Uhura-  \"But Captain, we're already docked.\""))
@@ -4457,44 +4359,38 @@ def mayday():
     if damaged(DRADIO):
 	prout(_("Subspace radio damaged."))
 	return
-    if game.state.rembase==0:
+    if not game.state.baseq:
 	prout(_("Lt. Uhura-  \"Captain, I'm not getting any response from Starbase.\""))
 	return
     if game.landed:
-	proutn(_("You must be aboard the "))
-	crmshp()
-	prout(".")
+	prout(_("You must be aboard the %s.") % crmshp())
 	return
     # OK -- call for help from nearest starbase 
     game.nhelp += 1
-    if game.base.x!=0:
+    if game.base.i!=0:
 	# There's one in this quadrant 
-	ddist = distance(game.base, game.sector)
+	ddist = (game.base - game.sector).distance()
     else:
 	ddist = FOREVER
-	for m in range(1, game.state.rembase+1):
-	    xdist = QUADSIZE * distance(game.state.baseq[m], game.quadrant)
+        for ibq in game.state.baseq:
+	    xdist = QUADSIZE * (ibq - game.quadrant).distance()
 	    if xdist < ddist:
 		ddist = xdist
-		line = m
 	# Since starbase not in quadrant, set up new quadrant 
-	game.quadrant = game.state.baseq[line]
-	newqad(True)
+	game.quadrant = ibq
+	newqad()
     # dematerialize starship 
-    game.quad[game.sector.x][game.sector.y]=IHDOT
-    proutn(_("Starbase in Quadrant %s responds--") % game.quadrant)
-    crmshp()
-    prout(_(" dematerializes."))
-    game.sector.x=0
+    game.quad[game.sector.i][game.sector.j]=IHDOT
+    proutn(_("Starbase in Quadrant %s responds--%s dematerializes") \
+           % (game.quadrant, crmshp()))
+    game.sector.invalidate()
     for m in range(1, 5+1):
-	ix = game.base.x+3.0*Rand()-1
-	iy = game.base.y+3.0*Rand()-1
-	if VALID_SECTOR(ix,iy) and game.quad[ix][iy]==IHDOT:
+        w = game.base.scatter() 
+	if w.valid_sector() and game.quad[w.i][w.j]==IHDOT:
 	    # found one -- finish up 
-	    game.sector.x=ix
-	    game.sector.y=iy
+            game.sector = w
 	    break
-    if not is_valid(game.sector):
+    if not game.sector.is_valid():
 	prout(_("You have been lost in space..."))
 	finish(FMATERIALIZE)
 	return
@@ -4504,16 +4400,15 @@ def mayday():
 	if m == 1: proutn(_("1st"))
 	elif m == 2: proutn(_("2nd"))
 	elif m == 3: proutn(_("3rd"))
-	proutn(_(" attempt to re-materialize "))
-	crmshp()
+	proutn(_(" attempt to re-materialize ") + crmshp())
 	game.quad[ix][iy]=(IHMATER0,IHMATER1,IHMATER2)[m-1]
-	textcolor(RED)
+	#textcolor("red")
 	warble()
-	if Rand() > probf:
+	if randreal() > probf:
 	    break
 	prout(_("fails."))
 	curses.delay_output(500)
-	textcolor(DEFAULT)
+	#textcolor(None)
     if m > 3:
 	game.quad[ix][iy]=IHQUEST
 	game.alive = False
@@ -4522,34 +4417,16 @@ def mayday():
 	finish(FMATERIALIZE)
 	return
     game.quad[ix][iy]=game.ship
-    textcolor(GREEN)
+    #textcolor("green")
     prout(_("succeeds."))
-    textcolor(DEFAULT)
+    #textcolor(None)
     dock(False)
     skip(1)
     prout(_("Lt. Uhura-  \"Captain, we made it!\""))
 
-# Abandon Ship (the BSD-Trek description)
-# 
-# The ship is abandoned.  If your current ship is the Faire
-# Queene, or if your shuttlecraft is dead, you're out of
-# luck.  You need the shuttlecraft in order for the captain
-# (that's you!!) to escape.
-# 
-# Your crew can beam to an inhabited starsystem in the
-# quadrant, if there is one and if the transporter is working.
-# If there is no inhabited starsystem, or if the transporter
-# is out, they are left to die in outer space.
-# 
-# If there are no starbases left, you are captured by the
-# Klingons, who torture you mercilessly.  However, if there
-# is at least one starbase, you are returned to the
-# Federation in a prisoner of war exchange.  Of course, this
-# can't happen unless you have taken some prisoners.
-
 def abandon():
-    # abandon ship 
-    chew()
+    "Abandon ship."
+    scanner.chew()
     if game.condition=="docked":
 	if game.ship!=IHE:
 	    prout(_("You cannot abandon Ye Faerie Queene."))
@@ -4571,23 +4448,23 @@ def abandon():
 	if game.iscraft != "onship":
 	    prout(_("Shuttle craft not currently available."))
 	    return
-	# Print abandon ship messages 
+	# Emit abandon ship messages 
 	skip(1)
 	prouts(_("***ABANDON SHIP!  ABANDON SHIP!"))
 	skip(1)
 	prouts(_("***ALL HANDS ABANDON SHIP!"))
 	skip(2)
 	prout(_("Captain and crew escape in shuttle craft."))
-	if game.state.rembase==0:
+	if not game.state.baseq:
 	    # Oops! no place to go... 
 	    finish(FABANDN)
 	    return
-	q = game.state.galaxy[game.quadrant.x][game.quadrant.y]
+	q = game.state.galaxy[game.quadrant.i][game.quadrant.j]
 	# Dispose of crew 
 	if not (game.options & OPTION_WORLDS) and not damaged(DTRANSP):
 	    prout(_("Remainder of ship's complement beam down"))
 	    prout(_("to nearest habitable planet."))
-	elif q.planet != NOPLANET and not damaged(DTRANSP):
+	elif q.planet != None and not damaged(DTRANSP):
 	    prout(_("Remainder of ship's complement beam down to %s.") %
 		    q.planet)
 	else:
@@ -4595,35 +4472,33 @@ def abandon():
 		    game.state.crew)
 	    game.casual += game.state.crew
 	    game.abandoned += game.state.crew
-
 	# If at least one base left, give 'em the Faerie Queene 
 	skip(1)
 	game.icrystl = False # crystals are lost 
 	game.nprobes = 0 # No probes 
 	prout(_("You are captured by Klingons and released to"))
 	prout(_("the Federation in a prisoner-of-war exchange."))
-	nb = Rand()*game.state.rembase+1
+	nb = randrange(len(game.state.baseq))
 	# Set up quadrant and position FQ adjacient to base 
 	if not game.quadrant == game.state.baseq[nb]:
 	    game.quadrant = game.state.baseq[nb]
-	    game.sector.x = game.sector.y = 5
-	    newqad(True)
+	    game.sector.i = game.sector.j = 5
+	    newqad()
 	while True:
 	    # position next to base by trial and error 
-	    game.quad[game.sector.x][game.sector.y] = IHDOT
-	    for l in range(1, QUADSIZE+1):
-		game.sector.x = 3.0*Rand() - 1.0 + game.base.x
-		game.sector.y = 3.0*Rand() - 1.0 + game.base.y
-		if VALID_SECTOR(game.sector.x, game.sector.y) and \
-                       game.quad[game.sector.x][game.sector.y] == IHDOT:
+	    game.quad[game.sector.i][game.sector.j] = IHDOT
+	    for l in range(QUADSIZE):
+		game.sector = game.base.scatter()
+		if game.sector.valid_sector() and \
+                       game.quad[game.sector.i][game.sector.j] == IHDOT:
                     break
 	    if l < QUADSIZE+1:
 		break # found a spot 
-	    game.sector.x=QUADSIZE/2
-	    game.sector.y=QUADSIZE/2
-	    newqad(True)
+	    game.sector.i=QUADSIZE/2
+	    game.sector.j=QUADSIZE/2
+	    newqad()
     # Get new commission 
-    game.quad[game.sector.x][game.sector.y] = game.ship = IHF
+    game.quad[game.sector.i][game.sector.j] = game.ship = IHF
     game.state.crew = FULLCREW
     prout(_("Starfleet puts you in command of another ship,"))
     prout(_("the Faerie Queene, which is antiquated but,"))
@@ -4634,7 +4509,7 @@ def abandon():
     game.iscraft = "offship" # Galileo disappears 
     # Resupply ship 
     game.condition="docked"
-    for l in range(0, NDEVICES): 
+    for l in range(NDEVICES): 
 	game.damage[l] = 0.0
     game.damage[DSHUTTL] = -1
     game.energy = game.inenrg = 3000.0
@@ -4643,36 +4518,35 @@ def abandon():
     game.lsupres=game.inlsr=3.0
     game.shldup=False
     game.warpfac=5.0
-    game.wfacsq=25.0
     return
 
 # Code from planets.c begins here.
 
 def consumeTime():
-    # abort a lengthy operation if an event interrupts it 
+    "Abort a lengthy operation if an event interrupts it." 
     game.ididit = True
     events()
-    if game.alldone or game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova or game.justin: 
+    if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.justin: 
 	return True
     return False
 
 def survey():
-    # report on (uninhabited) planets in the galaxy 
+    "Report on (uninhabited) planets in the galaxy."
     iknow = False
     skip(1)
-    chew()
+    scanner.chew()
     prout(_("Spock-  \"Planet report follows, Captain.\""))
     skip(1)
     for i in range(game.inplan):
-	if game.state.planets[i].pclass == destroyed:
+	if game.state.planets[i].pclass == "destroyed":
 	    continue
 	if (game.state.planets[i].known != "unknown" \
-            and game.state.planets[i].inhabited == UNINHABITED) \
+            and not game.state.planets[i].inhabited) \
             or idebug:
 	    iknow = True
 	    if idebug and game.state.planets[i].known=="unknown":
 		proutn("(Unknown) ")
-	    proutn(_("Quadrant %s") % game.state.planets[i].w)
+	    proutn(_("Quadrant %s") % game.state.planets[i].quadrant)
 	    proutn(_("   class "))
 	    proutn(game.state.planets[i].pclass)
 	    proutn("   ")
@@ -4685,85 +4559,89 @@ def survey():
 	prout(_("No information available."))
 
 def orbit():
-    # enter standard orbit 
+    "Enter standard orbit." 
     skip(1)
-    chew()
+    scanner.chew()
     if game.inorbit:
 	prout(_("Already in standard orbit."))
 	return
     if damaged(DWARPEN) and damaged(DIMPULS):
 	prout(_("Both warp and impulse engines damaged."))
 	return
-    if not is_valid(game.plnet) or abs(game.sector.x-game.plnet.x) > 1 or abs(game.sector.y-game.plnet.y) > 1:
-	crmshp()
-	prout(_(" not adjacent to planet."))
+    if not game.plnet.is_valid():
+        prout("There is no planet in this sector.")
+        return
+    if abs(game.sector.i-game.plnet.i)>1 or abs(game.sector.j-game.plnet.j)>1:
+	prout(crmshp() + _(" not adjacent to planet."))
 	skip(1)
 	return
-    game.optime = 0.02+0.03*Rand()
+    game.optime = randreal(0.02, 0.05)
     prout(_("Helmsman Sulu-  \"Entering standard orbit, Sir.\""))
     newcnd()
     if consumeTime():
 	return
-    game.height = (1400.0+7200.0*Rand())
+    game.height = randreal(1400, 8600)
     prout(_("Sulu-  \"Entered orbit at altitude %.2f kilometers.\"") % game.height)
     game.inorbit = True
     game.ididit = True
 
 def sensor():
-    # examine planets in this quadrant 
+    "Examine planets in this quadrant."
     if damaged(DSRSENS):
 	if game.options & OPTION_TTY:
 	    prout(_("Short range sensors damaged."))
 	return
-    if not is_valid(game.plnet):
+    if game.iplnet == None:
 	if game.options & OPTION_TTY:
 	    prout(_("Spock- \"No planet in this quadrant, Captain.\""))
 	return
-    if game.state.planets[game.iplnet].known == "unknown":
+    if game.iplnet.known == "unknown":
 	prout(_("Spock-  \"Sensor scan for Quadrant %s-") % game.quadrant)
 	skip(1)
 	prout(_("         Planet at Sector %s is of class %s.") %
-	      (sector,game.plnet, game.state.planets[game.iplnet]))
-	if game.state.planets[game.iplnet].known=="shuttle_down": 
+	      (game.plnet, game.iplnet.pclass))
+	if game.iplnet.known=="shuttle_down": 
 	    prout(_("         Sensors show Galileo still on surface."))
 	proutn(_("         Readings indicate"))
-	if game.state.planets[game.iplnet].crystals != present:
+	if game.iplnet.crystals != "present":
 	    proutn(_(" no"))
 	prout(_(" dilithium crystals present.\""))
-	if game.state.planets[game.iplnet].known == "unknown":
-	    game.state.planets[game.iplnet].known = "known"
+	if game.iplnet.known == "unknown":
+	    game.iplnet.known = "known"
+    elif game.iplnet.inhabited:
+        prout(_("Spock-  \"The inhabited planet %s ") % game.iplnet.name)
+        prout(_("        is located at Sector %s, Captain.\"") % game.plnet)
 
 def beam():
-    # use the transporter 
+    "Use the transporter."
     nrgneed = 0
-    chew()
+    scanner.chew()
     skip(1)
     if damaged(DTRANSP):
 	prout(_("Transporter damaged."))
-	if not damaged(DSHUTTL) and (game.state.planets[game.iplnet].known=="shuttle_down" or game.iscraft == "onship"):
+	if not damaged(DSHUTTL) and (game.iplnet.known=="shuttle_down" or game.iscraft == "onship"):
 	    skip(1)
 	    proutn(_("Spock-  \"May I suggest the shuttle craft, Sir?\" "))
 	    if ja() == True:
 		shuttle()
 	return
     if not game.inorbit:
-	crmshp()
-	prout(_(" not in standard orbit."))
+	prout(crmshp() + _(" not in standard orbit."))
 	return
     if game.shldup:
 	prout(_("Impossible to transport through shields."))
 	return
-    if game.state.planets[game.iplnet].known=="unknown":
+    if game.iplnet.known=="unknown":
 	prout(_("Spock-  \"Captain, we have no information on this planet"))
 	prout(_("  and Starfleet Regulations clearly state that in this situation"))
 	prout(_("  you may not go down.\""))
 	return
-    if not game.landed and game.state.planets[game.iplnet].crystals==absent:
+    if not game.landed and game.iplnet.crystals=="absent":
 	prout(_("Spock-  \"Captain, I fail to see the logic in"))
 	prout(_("  exploring a planet with no dilithium crystals."))
 	proutn(_("  Are you sure this is wise?\" "))
 	if ja() == False:
-	    chew()
+	    scanner.chew()
 	    return
     if not (game.options & OPTION_PLAIN):
 	nrgneed = 50 * game.skill + game.height / 100.0
@@ -4775,18 +4653,18 @@ def beam():
     	    prout(_("Engineering to bridge--"))
 	    prout(_("  Captain, we have enough energy only to transport you down to"))
 	    prout(_("  the planet, but there wouldn't be an energy for the trip back."))
-	    if game.state.planets[game.iplnet].known == "shuttle_down":
+	    if game.iplnet.known == "shuttle_down":
 		prout(_("  Although the Galileo shuttle craft may still be on a surface."))
 	    proutn(_("  Are you sure this is wise?\" "))
 	    if ja() == False:
-		chew()
+		scanner.chew()
 		return
     if game.landed:
 	# Coming from planet 
-	if game.state.planets[game.iplnet].known=="shuttle_down":
+	if game.iplnet.known=="shuttle_down":
 	    proutn(_("Spock-  \"Wouldn't you rather take the Galileo?\" "))
 	    if ja() == True:
-		chew()
+		scanner.chew()
 		return
 	    prout(_("Your crew hides the Galileo to prevent capture by aliens."))
 	prout(_("Landing party assembled, ready to beam up."))
@@ -4806,7 +4684,7 @@ def beam():
     skip(1)
     prouts("WWHOOOIIIIIRRRRREEEE.E.E.  .  .  .  .   .    .")
     skip(2)
-    if Rand() > 0.98:
+    if withprob(0.98):
 	prouts("BOOOIIIOOOIIOOOOIIIOIING . . .")
 	skip(2)
 	prout(_("Scotty-  \"Oh my God!  I've lost them.\""))
@@ -4817,7 +4695,7 @@ def beam():
     game.energy -= nrgneed
     skip(2)
     prout(_("Transport complete."))
-    if game.landed and game.state.planets[game.iplnet].known=="shuttle_down":
+    if game.landed and game.iplnet.known=="shuttle_down":
 	prout(_("The shuttle craft Galileo is here!"))
     if not game.landed and game.imine:
 	game.icrystl = True
@@ -4826,39 +4704,37 @@ def beam():
     return
 
 def mine():
-    # strip-mine a world for dilithium 
+    "Strip-mine a world for dilithium."
     skip(1)
-    chew()
+    scanner.chew()
     if not game.landed:
 	prout(_("Mining party not on planet."))
 	return
-    if game.state.planets[game.iplnet].crystals == mined:
+    if game.iplnet.crystals == "mined":
 	prout(_("This planet has already been strip-mined for dilithium."))
 	return
-    elif game.state.planets[game.iplnet].crystals == absent:
+    elif game.iplnet.crystals == "absent":
 	prout(_("No dilithium crystals on this planet."))
 	return
     if game.imine:
 	prout(_("You've already mined enough crystals for this trip."))
 	return
     if game.icrystl and game.cryprob == 0.05:
-	proutn(_("With all those fresh crystals aboard the "))
-	crmshp()
-	skip(1)
+	prout(_("With all those fresh crystals aboard the ") + crmshp())
 	prout(_("there's no reason to mine more at this time."))
 	return
-    game.optime = (0.1+0.2*Rand())*game.state.planets[game.iplnet].pclass
+    game.optime = randreal(0.1, 0.3)*(ord(game.iplnet.pclass)-ord("L"))
     if consumeTime():
 	return
     prout(_("Mining operation complete."))
-    game.state.planets[game.iplnet].crystals = mined
+    game.iplnet.crystals = "mined"
     game.imine = game.ididit = True
 
 def usecrystals():
-    # use dilithium crystals 
+    "Use dilithium crystals."
     game.ididit = False
     skip(1)
-    chew()
+    scanner.chew()
     if not game.icrystl:
 	prout(_("No dilithium crystals available."))
 	return
@@ -4871,7 +4747,7 @@ def usecrystals():
     prout(_("  system may risk a severe explosion."))
     proutn(_("  Are you sure this is wise?\" "))
     if ja() == False:
-	chew()
+	scanner.chew()
 	return
     skip(1)
     prout(_("Engineering Officer Scott-  \"(GULP) Aye Sir."))
@@ -4882,7 +4758,7 @@ def usecrystals():
     skip(1)
     prouts(_("Scotty-  \"Keep your fingers crossed, Sir!\""))
     skip(1)
-    if Rand() <= game.cryprob:
+    if with(game.cryprob):
 	prouts(_("  \"Activating now! - - No good!  It's***"))
 	skip(2)
 	prouts(_("***RED ALERT!  RED A*L********************************"))
@@ -4892,7 +4768,7 @@ def usecrystals():
 	skip(1)
 	kaboom()
 	return
-    game.energy += 5000.0*(1.0 + 0.9*Rand())
+    game.energy += randreal(5000.0, 5500.0)
     prouts(_("  \"Activating now! - - "))
     prout(_("The instruments"))
     prout(_("   are going crazy, but I think it's"))
@@ -4901,12 +4777,12 @@ def usecrystals():
     game.ididit = True
 
 def shuttle():
-    # use shuttlecraft for planetary jaunt 
-    chew()
+    "Use shuttlecraft for planetary jaunt."
+    scanner.chew()
     skip(1)
     if damaged(DSHUTTL):
 	if game.damage[DSHUTTL] == -1.0:
-	    if game.inorbit and game.state.planets[game.iplnet].known == "shuttle_down":
+	    if game.inorbit and game.iplnet.known == "shuttle_down":
 		prout(_("Ye Faerie Queene has no shuttle craft bay to dock it at."))
 	    else:
 		prout(_("Ye Faerie Queene had no shuttle craft."))
@@ -4916,19 +4792,18 @@ def shuttle():
 	    prout(_("Shuttle craft is now serving Big Macs."))
 	return
     if not game.inorbit:
-	crmshp()
-	prout(_(" not in standard orbit."))
+	prout(crmshp() + _(" not in standard orbit."))
 	return
-    if (game.state.planets[game.iplnet].known != "shuttle_down") and game.iscraft != "onship":
+    if (game.iplnet.known != "shuttle_down") and game.iscraft != "onship":
 	prout(_("Shuttle craft not currently available."))
 	return
-    if not game.landed and game.state.planets[game.iplnet].known=="shuttle_down":
+    if not game.landed and game.iplnet.known=="shuttle_down":
 	prout(_("You will have to beam down to retrieve the shuttle craft."))
 	return
     if game.shldup or game.condition == "docked":
 	prout(_("Shuttle craft cannot pass through shields."))
 	return
-    if game.state.planets[game.iplnet].known=="unknown":
+    if game.iplnet.known=="unknown":
 	prout(_("Spock-  \"Captain, we have no information on this planet"))
 	prout(_("  and Starfleet Regulations clearly state that in this situation"))
 	prout(_("  you may not fly down.\""))
@@ -4960,7 +4835,7 @@ def shuttle():
 	    skip(1)
 	    if consumeTime():
 		return
-	    game.state.planets[game.iplnet].known="shuttle_down"
+	    game.iplnet.known="shuttle_down"
 	    prout(_("Trip complete."))
 	    return
 	else:
@@ -4970,7 +4845,7 @@ def shuttle():
 	    skip(1)
 	    prouts(_("The short hop begins . . ."))
 	    skip(1)
-	    game.state.planets[game.iplnet].known="known"
+	    game.iplnet.known="known"
 	    game.icraft = True
 	    skip(1)
 	    game.landed = False
@@ -4985,8 +4860,7 @@ def shuttle():
 	    prout(_("Trip complete."))
 	    return
     else:
-	# Kirk on ship 
-	# and so is Galileo 
+	# Kirk on ship and so is Galileo 
 	prout(_("Mining party assembles in the hangar deck,"))
 	prout(_("ready to board the shuttle craft \"Galileo\"."))
 	skip(1)
@@ -4996,23 +4870,21 @@ def shuttle():
 	game.iscraft = "offship"
 	if consumeTime():
 	    return
-	game.state.planets[game.iplnet].known = "shuttle_down"
+	game.iplnet.known = "shuttle_down"
 	game.landed = True
 	game.icraft = False
 	prout(_("Trip complete."))
 	return
 
 def deathray():
-    # use the big zapper 
-    r = Rand()
-	
+    "Use the big zapper."
     game.ididit = False
     skip(1)
-    chew()
+    scanner.chew()
     if game.ship != IHE:
 	prout(_("Ye Faerie Queene has no death ray."))
 	return
-    if game.nenhere==0:
+    if len(game.enemies)==0:
 	prout(_("Sulu-  \"But Sir, there are no enemies in this quadrant.\""))
 	return
     if damaged(DDRAY):
@@ -5037,27 +4909,28 @@ def deathray():
     skip(1)
     prouts(_("WHIRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR"))
     skip(1)
-    dprob = .30
+    dprob = 0.30
     if game.options & OPTION_PLAIN:
-	dprob = .5
+	dprob = 0.5
+    r = randreal()
     if r > dprob:
 	prouts(_("Sulu- \"Captain!  It's working!\""))
 	skip(2)
-	while game.nenhere > 0:
-	    deadkl(game.ks[1], game.quad[game.ks[1].x][game.ks[1].y],game.ks[1])
+	while len(game.enemies) > 0:
+	    deadkl(game.enemies[1].kloc, game.quad[game.enemies[1].kloc.i][game.enemies[1].kloc.j],game.enemies[1].kloc)
 	prout(_("Ensign Chekov-  \"Congratulations, Captain!\""))
-	if (game.state.remkl + game.state.remcom + game.state.nscrem) == 0:
+	if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
 	    finish(FWON)    
 	if (game.options & OPTION_PLAIN) == 0:
 	    prout(_("Spock-  \"Captain, I believe the `Experimental Death Ray'"))
-	    if Rand() <= 0.05:
+	    if withprob(0.05):
 		prout(_("   is still operational.\""))
 	    else:
 		prout(_("   has been rendered nonfunctional.\""))
 		game.damage[DDRAY] = 39.95
 	return
-    r = Rand()	# Pick failure method 
-    if r <= .30:
+    r = randreal()	# Pick failure method 
+    if r <= 0.30:
 	prouts(_("Sulu- \"Captain!  It's working!\""))
 	skip(1)
 	prouts(_("***RED ALERT!  RED ALERT!"))
@@ -5071,7 +4944,7 @@ def deathray():
 	skip(1)
 	kaboom()
 	return
-    if r <= .55:
+    if r <= 0.55:
 	prouts(_("Sulu- \"Captain!  Yagabandaghangrapl, brachriigringlanbla!\""))
 	skip(1)
 	prout(_("Lt. Uhura-  \"Graaeek!  Graaeek!\""))
@@ -5090,8 +4963,8 @@ def deathray():
 	proutn(_("Spock-  \"I believe the word is"))
 	prouts(_(" *ASTONISHING*"))
 	prout(_(" Mr. Sulu."))
-	for i in range(1, QUADSIZE+1):
-	    for j in range(1, QUADSIZE+1):
+	for i in range(QUADSIZE):
+	    for j in range(QUADSIZE):
 		if game.quad[i][j] == IHDOT:
 		    game.quad[i][j] = IHQUEST
 	prout(_("  Captain, our quadrant is now infested with"))
@@ -5109,7 +4982,7 @@ def deathray():
 # Code from reports.c begins here
 
 def attackreport(curt):
-    # report status of bases under attack 
+    "eport status of bases under attack."
     if not curt:
 	if is_scheduled(FCDBAS):
 	    prout(_("Starbase in Quadrant %s is currently under Commander attack.") % game.battle)
@@ -5128,7 +5001,7 @@ def attackreport(curt):
 
 def report():
     # report on general game status 
-    chew()
+    scanner.chew()
     s1 = "" and game.thawed and _("thawed ")
     s2 = {1:"short", 2:"medium", 4:"long"}[game.length]
     s3 = (None, _("novice"). _("fair"),
@@ -5139,23 +5012,23 @@ def report():
     if game.tourn:
 	prout(_("This is tournament game %d.") % game.tourn)
     prout(_("Your secret password is \"%s\"") % game.passwd)
-    proutn(_("%d of %d Klingons have been killed") % (((game.inkling + game.incom + game.inscom) - (game.state.remkl + game.state.remcom + game.state.nscrem)), 
+    proutn(_("%d of %d Klingons have been killed") % (((game.inkling + game.incom + game.inscom) - (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)), 
 	   (game.inkling + game.incom + game.inscom)))
-    if game.incom - game.state.remcom:
-	prout(_(", including %d Commander%s.") % (game.incom - game.state.remcom, (_("s"), "")[(game.incom - game.state.remcom)==1]))
+    if game.incom - len(game.state.kcmdr):
+	prout(_(", including %d Commander%s.") % (game.incom - len(game.state.kcmdr), (_("s"), "")[(game.incom - len(game.state.kcmdr))==1]))
     elif game.inkling - game.state.remkl + (game.inscom - game.state.nscrem) > 0:
 	prout(_(", but no Commanders."))
     else:
 	prout(".")
     if game.skill > SKILL_FAIR:
 	prout(_("The Super Commander has %sbeen destroyed.") % ("", _("not "))[game.state.nscrem])
-    if game.state.rembase != game.inbase:
+    if len(game.state.baseq) != game.inbase:
 	proutn(_("There "))
-	if game.inbase-game.state.rembase==1:
+	if game.inbase-len(game.state.baseq)==1:
 	    proutn(_("has been 1 base"))
 	else:
-	    proutn(_("have been %d bases") % (game.inbase-game.state.rembase))
-	prout(_(" destroyed, %d remaining.") % game.state.rembase)
+	    proutn(_("have been %d bases") % (game.inbase-len(game.state.baseq)))
+	prout(_(" destroyed, %d remaining.") % len(game.state.baseq))
     else:
 	prout(_("There are %d bases.") % game.inbase)
     if communicating() or game.iseenit:
@@ -5196,38 +5069,41 @@ def report():
                   (i, (_("s"), "")[i==1]))
     skip(1)
 	
-def lrscan():
-    # long-range sensor scan 
+def lrscan(silent):
+    "Long-range sensor scan."
     if damaged(DLRSENS):
 	# Now allow base's sensors if docked 
 	if game.condition != "docked":
-	    prout(_("LONG-RANGE SENSORS DAMAGED."))
+            if not silent:
+                prout(_("LONG-RANGE SENSORS DAMAGED."))
 	    return
-	prout(_("Starbase's long-range scan"))
-    else:
+        if not silent:
+            prout(_("Starbase's long-range scan"))
+    elif not silent:
 	prout(_("Long-range scan"))
-    for x in range(game.quadrant.x-1, game.quadrant.x+2):
-        proutn(" ")
-        for y in range(game.quadrant.y-1, game.quadrant.y+2):
-	    if not VALID_QUADRANT(x, y):
-		proutn("  -1")
+    for x in range(game.quadrant.i-1, game.quadrant.i+2):
+        if not silent:
+            proutn(" ")
+        for y in range(game.quadrant.j-1, game.quadrant.j+2):
+	    if not coord(x, y).valid_quadrant():
+                if not silent:
+                    proutn("  -1")
 	    else:
 		if not damaged(DRADIO):
 		    game.state.galaxy[x][y].charted = True
 		game.state.chart[x][y].klingons = game.state.galaxy[x][y].klingons
 		game.state.chart[x][y].starbase = game.state.galaxy[x][y].starbase
 		game.state.chart[x][y].stars = game.state.galaxy[x][y].stars
-		if game.state.galaxy[x][y].supernova: 
+		if not silent and game.state.galaxy[x][y].supernova: 
 		    proutn(" ***")
-		else:
+		elif not silent:
 		    proutn(" %3d" % (game.state.chart[x][y].klingons*100 + game.state.chart[x][y].starbase * 10 + game.state.chart[x][y].stars))
 	prout(" ")
 
 def damagereport():
-    # damage report 
+    "Damage report."
     jdam = False
-    chew()
-
+    scanner.chew()
     for i in range(NDEVICES):
 	if damaged(i):
 	    if not jdam:
@@ -5241,45 +5117,46 @@ def damagereport():
 	prout(_("All devices functional."))
 
 def rechart():
-    # update the chart in the Enterprise's computer from galaxy data 
+    "Update the chart in the Enterprise's computer from galaxy data."
     game.lastchart = game.state.date
-    for i in range(1, GALSIZE+1):
-	for j in range(1, GALSIZE+1):
+    for i in range(GALSIZE):
+	for j in range(GALSIZE):
 	    if game.state.galaxy[i][j].charted:
 		game.state.chart[i][j].klingons = game.state.galaxy[i][j].klingons
 		game.state.chart[i][j].starbase = game.state.galaxy[i][j].starbase
 		game.state.chart[i][j].stars = game.state.galaxy[i][j].stars
 
 def chart():
-    # display the star chart  
-    chew()
+    "Display the star chart."
+    scanner.chew()
+    if (game.options & OPTION_AUTOSCAN):
+        lrscan(silent=True)
     if not damaged(DRADIO):
 	rechart()
     if game.lastchart < game.state.date and game.condition == "docked":
 	prout(_("Spock-  \"I revised the Star Chart from the starbase's records.\""))
 	rechart()
-
     prout(_("       STAR CHART FOR THE KNOWN GALAXY"))
     if game.state.date > game.lastchart:
 	prout(_("(Last surveillance update %d stardates ago).") % ((int)(game.state.date-game.lastchart)))
     prout("      1    2    3    4    5    6    7    8")
-    for i in range(1, GALSIZE+1):
-	proutn("%d |" % (i))
-	for j in range(1, GALSIZE+1):
-	    if (game.options & OPTION_SHOWME) and i == game.quadrant.x and j == game.quadrant.y:
+    for i in range(GALSIZE):
+	proutn("%d |" % (i+1))
+	for j in range(GALSIZE):
+	    if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j:
 		proutn("<")
 	    else:
 		proutn(" ")
 	    if game.state.galaxy[i][j].supernova:
-		strcpy(buf, "***")
+		show = "***"
 	    elif not game.state.galaxy[i][j].charted and game.state.galaxy[i][j].starbase:
-		strcpy(buf, ".1.")
+		show = ".1."
 	    elif game.state.galaxy[i][j].charted:
-		sprintf(buf, "%3d" % (game.state.chart[i][j].klingons*100 + game.state.chart[i][j].starbase * 10 + game.state.chart[i][j].stars))
+		show = "%3d" % (game.state.chart[i][j].klingons*100 + game.state.chart[i][j].starbase * 10 + game.state.chart[i][j].stars)
 	    else:
-		strcpy(buf, "...")
-	    proutn(buf)
-	    if (game.options & OPTION_SHOWME) and i == game.quadrant.x and j == game.quadrant.y:
+		show = "..."
+	    proutn(show)
+	    if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j:
 		proutn(">")
 	    else:
 		proutn(" ")
@@ -5288,72 +5165,71 @@ def chart():
 	    skip(1)
 
 def sectscan(goodScan, i, j):
-    # light up an individual dot in a sector 
-    if goodScan or (abs(i-game.sector.x)<= 1 and abs(j-game.sector.y) <= 1):
+    "Light up an individual dot in a sector."
+    if goodScan or (abs(i-game.sector.i)<= 1 and abs(j-game.sector.j) <= 1):
 	if (game.quad[i][j]==IHMATER0) or (game.quad[i][j]==IHMATER1) or (game.quad[i][j]==IHMATER2) or (game.quad[i][j]==IHE) or (game.quad[i][j]==IHF):
-	    if game.condition   == "red": textcolor(RED)
-	    elif game.condition == "green": textcolor(GREEN)
-	    elif game.condition == "yellow": textcolor(YELLOW)
-	    elif game.condition == "docked": textcolor(CYAN)
-	    elif game.condition == "dead": textcolor(BROWN)
+	    #if game.condition   == "red": textcolor("red")
+	    #elif game.condition == "green": textcolor("green")
+	    #elif game.condition == "yellow": textcolor("yellow")
+	    #elif game.condition == "docked": textcolor("cyan")
+	    #elif game.condition == "dead": textcolor("brown")
 	    if game.quad[i][j] != game.ship: 
 		highvideo()
 	proutn("%c " % game.quad[i][j])
-	textcolor(DEFAULT)
+	#textcolor(None)
     else:
 	proutn("- ")
 
-def status(req):
-    # print status report lines 
-
+def status(req=0):
+    "Emit status report lines"
     if not req or req == 1:
 	prstat(_("Stardate"), _("%.1f, Time Left %.2f") \
                % (game.state.date, game.state.remtime))
-    elif not req or req == 2:
+    if not req or req == 2:
 	if game.condition != "docked":
 	    newcnd()
         dam = 0
-	for t in range(0, NDEVICES):
+	for t in range(NDEVICES):
 	    if game.damage[t]>0: 
 		dam += 1
 	prstat(_("Condition"), _("%s, %i DAMAGES") % (game.condition.upper(), dam))
-    elif not req or req == 3:
+    if not req or req == 3:
 	prstat(_("Position"), "%s , %s" % (game.quadrant, game.sector))
-    elif not req or req == 4:
+    if not req or req == 4:
 	if damaged(DLIFSUP):
 	    if game.condition == "docked":
-		sprintf(s, _("DAMAGED, Base provides"))
+		s = _("DAMAGED, Base provides")
 	    else:
-		sprintf(s, _("DAMAGED, reserves=%4.2f") % game.lsupres)
+		s = _("DAMAGED, reserves=%4.2f") % game.lsupres
 	else:
-	    sprintf(s, _("ACTIVE"))
+	    s = _("ACTIVE")
 	prstat(_("Life Support"), s)
-    elif not req or req == 5:
-	prstat(_("Warp Factor"), "%.1f" % (game.warpfac))
-    elif not req or req == 6:
+    if not req or req == 5:
+	prstat(_("Warp Factor"), "%.1f" % game.warpfac)
+    if not req or req == 6:
         extra = ""
         if game.icrystl and (game.options & OPTION_SHOWME):
             extra = _(" (have crystals)")
-	prstat(_("Energy"), "%.2f%s" % game.energy, extra)
-    elif not req or req == 7:
+	prstat(_("Energy"), "%.2f%s" % (game.energy, extra))
+    if not req or req == 7:
 	prstat(_("Torpedoes"), "%d" % (game.torps))
-    elif not req or req == 8:
+    if not req or req == 8:
 	if damaged(DSHIELD):
-	    strcpy(s, _("DAMAGED,"))
+	    s = _("DAMAGED,")
 	elif game.shldup:
-	    strcpy(s, _("UP,"))
+	    s = _("UP,")
 	else:
-	    strcpy(s, _("DOWN,"))
+	    s = _("DOWN,")
 	data = _(" %d%% %.1f units") \
                % (int((100.0*game.shield)/game.inshld + 0.5), game.shield)
-	prstat(_("Shields"), s)
-    elif not req or req == 9:
+	prstat(_("Shields"), s+data)
+    if not req or req == 9:
         prstat(_("Klingons Left"), "%d" \
-               % (game.state.remkl + game.state.remcom + game.state.nscrem))
-    elif not req or req == 10:
+               % (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem))
+    if not req or req == 10:
 	if game.options & OPTION_WORLDS:
-	    plnet = game.state.galaxy[game.quadrant.x][game.quadrant.y].planet
-	    if plnet != NOPLANET and game.state.planets[plnet].inhabited != UNINHABITED:
+	    plnet = game.state.galaxy[game.quadrant.i][game.quadrant.j].planet
+	    if plnet and plnet.inhabited:
 		prstat(_("Major system"), plnet.name)
 	    else:
 		prout(_("Sector is uninhabited"))
@@ -5361,19 +5237,20 @@ def status(req):
 	attackreport(not req)
 
 def request():
+    "Request specified status data, a historical relic from slow TTYs."
     requests = ("da","co","po","ls","wa","en","to","sh","kl","sy", "ti")
-    while scan() == IHEOL:
+    while scanner.next() == "IHEOL":
 	proutn(_("Information desired? "))
-    chew()
-    if citem in requests:
-        status(requests.index(citem))
+    scanner.chew()
+    if scanner.token in requests:
+        status(requests.index(scanner.token))
     else:
 	prout(_("UNRECOGNIZED REQUEST. Legal requests are:"))
 	prout(("  date, condition, position, lsupport, warpfactor,"))
 	prout(("  energy, torpedoes, shields, klingons, system, time."))
 		
 def srscan():
-    # short-range scan 
+    "Short-range scan." 
     goodScan=True
     if damaged(DSRSENS):
 	# Allow base's sensors if docked 
@@ -5385,109 +5262,106 @@ def srscan():
     else:
 	prout(_("     Short-range scan"))
     if goodScan and not damaged(DRADIO): 
-	game.state.chart[game.quadrant.x][game.quadrant.y].klingons = game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons
-	game.state.chart[game.quadrant.x][game.quadrant.y].starbase = game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase
-	game.state.chart[game.quadrant.x][game.quadrant.y].stars = game.state.galaxy[game.quadrant.x][game.quadrant.y].stars
-	game.state.galaxy[game.quadrant.x][game.quadrant.y].charted = True
+	game.state.chart[game.quadrant.i][game.quadrant.j].klingons = game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons
+	game.state.chart[game.quadrant.i][game.quadrant.j].starbase = game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase
+	game.state.chart[game.quadrant.i][game.quadrant.j].stars = game.state.galaxy[game.quadrant.i][game.quadrant.j].stars
+	game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True
     prout("    1 2 3 4 5 6 7 8 9 10")
     if game.condition != "docked":
 	newcnd()
-    for i in range(1, QUADSIZE+1):
-	proutn("%2d  " % (i))
-	for j in range(1, QUADSIZE+1):
+    for i in range(QUADSIZE):
+	proutn("%2d  " % (i+1))
+	for j in range(QUADSIZE):
 	    sectscan(goodScan, i, j)
 	skip(1)
-			
-			
+		
 def eta():
-    # use computer to get estimated time of arrival for a warp jump 
+    "Use computer to get estimated time of arrival for a warp jump."
     w1 = coord(); w2 = coord()
     prompt = False
     if damaged(DCOMPTR):
 	prout(_("COMPUTER DAMAGED, USE A POCKET CALCULATOR."))
 	skip(1)
 	return
-    if scan() != IHREAL:
+    if scanner.next() != "IHREAL":
 	prompt = True
-	chew()
+	scanner.chew()
 	proutn(_("Destination quadrant and/or sector? "))
-	if scan()!=IHREAL:
+	if scanner.next()!="IHREAL":
 	    huh()
 	    return
-    w1.y = aaitem +0.5
-    if scan() != IHREAL:
+    w1.j = int(scanner.real-0.5)
+    if scanner.next() != "IHREAL":
 	huh()
 	return
-    w1.x = aaitem + 0.5
-    if scan() == IHREAL:
-	w2.y = aaitem + 0.5
-	if scan() != IHREAL:
+    w1.i = int(scanner.real-0.5)
+    if scanner.next() == "IHREAL":
+	w2.j = int(scanner.real-0.5)
+	if scanner.next() != "IHREAL":
 	    huh()
 	    return
-	w2.x = aaitem + 0.5
+	w2.i = int(scanner.real-0.5)
     else:
-	if game.quadrant.y>w1.x:
-	    w2.x = 1
+	if game.quadrant.j>w1.i:
+	    w2.i = 0
 	else:
-	    w2.x=QUADSIZE
-	if game.quadrant.x>w1.y:
-	    w2.y = 1
+	    w2.i=QUADSIZE-1
+	if game.quadrant.i>w1.j:
+	    w2.j = 0
 	else:
-	    w2.y=QUADSIZE
-
-    if not VALID_QUADRANT(w1.x, w1.y) or not VALID_SECTOR(w2.x, w2.y):
+	    w2.j=QUADSIZE-1
+    if not w1.valid_quadrant() or not w2.valid_sector():
 	huh()
 	return
-    game.dist = math.sqrt(square(w1.y-game.quadrant.y+0.1*(w2.y-game.sector.y))+
-		square(w1.x-game.quadrant.x+0.1*(w2.x-game.sector.x)))
+    dist = math.sqrt((w1.j-game.quadrant.j+(w2.j-game.sector.j)/(QUADSIZE*1.0))**2+
+		(w1.i-game.quadrant.i+(w2.i-game.sector.i)/(QUADSIZE*1.0))**2)
     wfl = False
-
     if prompt:
 	prout(_("Answer \"no\" if you don't know the value:"))
     while True:
-	chew()
+	scanner.chew()
 	proutn(_("Time or arrival date? "))
-	if scan()==IHREAL:
-	    ttime = aaitem
+	if scanner.next()=="IHREAL":
+	    ttime = scanner.real
 	    if ttime > game.state.date:
 		ttime -= game.state.date # Actually a star date
-            twarp=(math.floor(math.sqrt((10.0*game.dist)/ttime)*10.0)+1.0)/10.0
+            twarp=(math.floor(math.sqrt((10.0*dist)/ttime)*10.0)+1.0)/10.0
             if ttime <= 1e-10 or twarp > 10:
 		prout(_("We'll never make it, sir."))
-		chew()
+		scanner.chew()
 		return
 	    if twarp < 1.0:
 		twarp = 1.0
 	    break
-	chew()
+	scanner.chew()
 	proutn(_("Warp factor? "))
-	if scan()== IHREAL:
+	if scanner.next()== "IHREAL":
 	    wfl = True
-	    twarp = aaitem
+	    twarp = scanner.real
 	    if twarp<1.0 or twarp > 10.0:
 		huh()
 		return
 	    break
 	prout(_("Captain, certainly you can give me one of these."))
     while True:
-	chew()
-	ttime = (10.0*game.dist)/square(twarp)
-	tpower = game.dist*twarp*twarp*twarp*(game.shldup+1)
+	scanner.chew()
+	ttime = (10.0*game.dist)/twarp**2
+	tpower = dist*twarp*twarp*twarp*(game.shldup+1)
 	if tpower >= game.energy:
 	    prout(_("Insufficient energy, sir."))
 	    if not game.shldup or tpower > game.energy*2.0:
 		if not wfl:
 		    return
 		proutn(_("New warp factor to try? "))
-		if scan() == IHREAL:
+		if scanner.next() == "IHREAL":
 		    wfl = True
-		    twarp = aaitem
+		    twarp = scanner.real
 		    if twarp<1.0 or twarp > 10.0:
 			huh()
 			return
 		    continue
 		else:
-		    chew()
+		    scanner.chew()
 		    skip(1)
 		    return
 	    prout(_("But if you lower your shields,"))
@@ -5512,77 +5386,1176 @@ def eta():
 	    (scheduled(FCDBAS)<ttime+game.state.date and game.battle == w1):
 	    prout(_("The starbase there will be destroyed by then."))
 	proutn(_("New warp factor to try? "))
-	if scan() == IHREAL:
+	if scanner.next() == "IHREAL":
 	    wfl = True
-	    twarp = aaitem
+	    twarp = scanner.real
 	    if twarp<1.0 or twarp > 10.0:
 		huh()
 		return
 	else:
-	    chew()
+	    scanner.chew()
 	    skip(1)
 	    return
-			
 
-#ifdef BSD_BUG_FOR_BUG
-# A visual scan is made in a particular direction of three sectors
-# in the general direction specified.  This takes time, and
-# Klingons can attack you, so it should be done only when sensors
-# are out.  Code swiped from BSD-Trek.  Not presently used, as we
-# automatically display all adjacent sectors on the short-range
-# scan even when short-range sensors are out.
-
-# This struct[] has the delta x, delta y for particular directions
-
-visdelta = (
-    (-1,-1),
-    (-1, 0),
-    (-1, 1),
-    (0,	 1),
-    (1,	 1),
-    (1,	 0),
-    (1,	-1),
-    (0,	-1),
-    (-1,-1),
-    (-1, 0),
-    (-1, 1),
-)
+# Code from setup.c begins here
 
-def visual():
-    v = coord()
-    if scan() != IHREAL:
-	chew()
-	proutn(_("Direction? "))
-	if scan()!=IHREAL:
-	    huh()
-	    return
-    if aaitem < 0.0 or aaitem > 360.0:
+def prelim():
+    "Issue a historically correct banner."
+    skip(2)
+    prout(_("-SUPER- STAR TREK"))
+    skip(1)
+# From the FORTRAN original
+#    prout(_("Latest update-21 Sept 78"))
+#    skip(1)
+
+def freeze(boss):
+    "Save game."
+    if boss:
+	scanner.push("emsave.trk")
+    key = scanner.next()
+    if key == "IHEOL":
+        proutn(_("File name: "))
+        key = scanner.next()
+    if key != "IHALPHA":
+        huh()
+        return
+    scanner.chew()
+    if '.' not in scanner.token:
+        scanner.token += ".trk"
+    try:
+        fp = open(scanner.token, "wb")
+    except IOError:
+	prout(_("Can't freeze game as file %s") % scanner.token)
 	return
-    co = (aaitem + 22) / 45
-    v = visdelta[co]
-    ix = game.sector.x + v.x
-    iy = game.sector.y + v.y
-    if ix < 0 or ix >= QUADSIZE or iy < 0 or iy >= QUADSIZE:
-	co = '?'
+    cPickle.dump(game, fp)
+    fp.close()
+
+def thaw():
+    "Retrieve saved game." 
+    game.passwd[0] = '\0'
+    key = scanner.next()
+    if key == "IHEOL":
+	proutn(_("File name: "))
+	key = scanner.next()
+    if key != "IHALPHA":
+	huh()
+	return True
+    scanner.chew()
+    if '.' not in scanner.token:
+        scanner.token += ".trk"
+    try:
+        fp = open(scanner.token, "rb")
+    except IOError:
+	prout(_("Can't thaw game in %s") % scanner.token)
+	return
+    game = cPickle.load(fp)
+    fp.close()
+    return False
+
+# I used <http://www.memory-alpha.org> to find planets
+# with references in ST:TOS.  Eath and the Alpha Centauri
+# Colony have been omitted.
+# 
+# Some planets marked Class G and P here will be displayed as class M
+# because of the way planets are generated. This is a known bug.
+systnames = (
+    # Federation Worlds 
+    _("Andoria (Fesoan)"),	# several episodes 
+    _("Tellar Prime (Miracht)"),	# TOS: "Journey to Babel" 
+    _("Vulcan (T'Khasi)"),	# many episodes 
+    _("Medusa"),		# TOS: "Is There in Truth No Beauty?" 
+    _("Argelius II (Nelphia)"),	# TOS: "Wolf in the Fold" ("IV" in BSD) 
+    _("Ardana"),		# TOS: "The Cloud Minders" 
+    _("Catulla (Cendo-Prae)"),	# TOS: "The Way to Eden" 
+    _("Gideon"),		# TOS: "The Mark of Gideon" 
+    _("Aldebaran III"),		# TOS: "The Deadly Years" 
+    _("Alpha Majoris I"),	# TOS: "Wolf in the Fold" 
+    _("Altair IV"),		# TOS: "Amok Time 
+    _("Ariannus"),		# TOS: "Let That Be Your Last Battlefield" 
+    _("Benecia"),		# TOS: "The Conscience of the King" 
+    _("Beta Niobe I (Sarpeidon)"),	# TOS: "All Our Yesterdays" 
+    _("Alpha Carinae II"),	# TOS: "The Ultimate Computer" 
+    _("Capella IV (Kohath)"),	# TOS: "Friday's Child" (Class G) 
+    _("Daran V"),		# TOS: "For the World is Hollow and I Have Touched the Sky" 
+    _("Deneb II"),		# TOS: "Wolf in the Fold" ("IV" in BSD) 
+    _("Eminiar VII"),		# TOS: "A Taste of Armageddon" 
+    _("Gamma Canaris IV"),	# TOS: "Metamorphosis" 
+    _("Gamma Tranguli VI (Vaalel)"),	# TOS: "The Apple" 
+    _("Ingraham B"),		# TOS: "Operation: Annihilate" 
+    _("Janus IV"),		# TOS: "The Devil in the Dark" 
+    _("Makus III"),		# TOS: "The Galileo Seven" 
+    _("Marcos XII"),		# TOS: "And the Children Shall Lead", 
+    _("Omega IV"),		# TOS: "The Omega Glory" 
+    _("Regulus V"),		# TOS: "Amok Time 
+    _("Deneva"),		# TOS: "Operation -- Annihilate!" 
+    # Worlds from BSD Trek 
+    _("Rigel II"),		# TOS: "Shore Leave" ("III" in BSD) 
+    _("Beta III"),		# TOS: "The Return of the Archons" 
+    _("Triacus"),		# TOS: "And the Children Shall Lead", 
+    _("Exo III"),		# TOS: "What Are Little Girls Made Of?" (Class P) 
+#	# Others 
+#    _("Hansen's Planet"),	# TOS: "The Galileo Seven" 
+#    _("Taurus IV"),		# TOS: "The Galileo Seven" (class G) 
+#    _("Antos IV (Doraphane)"),	# TOS: "Whom Gods Destroy", "Who Mourns for Adonais?" 
+#    _("Izar"),			# TOS: "Whom Gods Destroy" 
+#    _("Tiburon"),		# TOS: "The Way to Eden" 
+#    _("Merak II"),		# TOS: "The Cloud Minders" 
+#    _("Coridan (Desotriana)"),	# TOS: "Journey to Babel" 
+#    _("Iotia"),		# TOS: "A Piece of the Action" 
+)
+
+device = (
+	_("S. R. Sensors"), \
+	_("L. R. Sensors"), \
+	_("Phasers"), \
+	_("Photon Tubes"), \
+	_("Life Support"), \
+	_("Warp Engines"), \
+	_("Impulse Engines"), \
+	_("Shields"), \
+	_("Subspace Radio"), \
+	_("Shuttle Craft"), \
+	_("Computer"), \
+	_("Navigation System"), \
+	_("Transporter"), \
+	_("Shield Control"), \
+	_("Death Ray"), \
+	_("D. S. Probe"), \
+)
+
+def setup():
+    "Prepare to play, set up cosmos."
+    w = coord()
+    #  Decide how many of everything
+    if choose():
+	return # frozen game
+    # Prepare the Enterprise
+    game.alldone = game.gamewon = game.shldchg = game.shldup = False
+    game.ship = IHE
+    game.state.crew = FULLCREW
+    game.energy = game.inenrg = 5000.0
+    game.shield = game.inshld = 2500.0
+    game.inlsr = 4.0
+    game.lsupres = 4.0
+    game.quadrant = randplace(GALSIZE)
+    game.sector = randplace(QUADSIZE)
+    game.torps = game.intorps = 10
+    game.nprobes = randrange(2, 5)
+    game.warpfac = 5.0
+    for i in range(NDEVICES): 
+	game.damage[i] = 0.0
+    # Set up assorted game parameters
+    game.battle = coord()
+    game.state.date = game.indate = 100.0 * randreal(20, 51)
+    game.nkinks = game.nhelp = game.casual = game.abandoned = 0
+    game.iscate = game.resting = game.imine = game.icrystl = game.icraft = False
+    game.isatb = game.state.nplankl = 0
+    game.state.starkl = game.state.basekl = 0
+    game.iscraft = "onship"
+    game.landed = False
+    game.alive = True
+    game.docfac = 0.25
+    # Starchart is functional but we've never seen it
+    game.lastchart = FOREVER
+    # Put stars in the galaxy
+    game.instar = 0
+    for i in range(GALSIZE):
+	for j in range(GALSIZE):
+	    k = randrange(1, QUADSIZE**2/10+1)
+	    game.instar += k
+	    game.state.galaxy[i][j].stars = k
+    # Locate star bases in galaxy
+    for i in range(game.inbase):
+        while True:
+            while True:
+                w = randplace(GALSIZE)
+                if not game.state.galaxy[w.i][w.j].starbase:
+                    break
+	    contflag = False
+            # C version: for (j = i-1; j > 0; j--)
+            # so it did them in the opposite order.
+            for j in range(1, i):
+		# Improved placement algorithm to spread out bases
+		distq = (w - game.state.baseq[j]).distance()
+		if distq < 6.0*(BASEMAX+1-game.inbase) and withprob(0.75):
+		    contflag = True
+		    if idebug:
+			prout("=== Abandoning base #%d at %s" % (i, w))
+		    break
+		elif distq < 6.0 * (BASEMAX+1-game.inbase):
+		    if idebug:
+			prout("=== Saving base #%d, close to #%d" % (i, j))
+            if not contflag:
+                break
+	game.state.baseq.append(w)
+	game.state.galaxy[w.i][w.j].starbase = game.state.chart[w.i][w.j].starbase = True
+    # Position ordinary Klingon Battle Cruisers
+    krem = game.inkling
+    klumper = 0.25*game.skill*(9.0-game.length)+1.0
+    if klumper > MAXKLQUAD: 
+	klumper = MAXKLQUAD
+    while True:
+	r = randreal()
+	klump = (1.0 - r*r)*klumper
+	if klump > krem:
+	    klump = krem
+	krem -= klump
+        while True:
+            w = randplace(GALSIZE)
+            if not game.state.galaxy[w.i][w.j].supernova and \
+               game.state.galaxy[w.i][w.j].klingons + klump <= MAXKLQUAD:
+                break
+	game.state.galaxy[w.i][w.j].klingons += int(klump)
+        if krem <= 0:
+            break
+    # Position Klingon Commander Ships
+    for i in range(game.incom):
+        while True:
+            w = randplace(GALSIZE)
+            if not welcoming(w) or w in game.state.kcmdr:
+                continue
+            if (game.state.galaxy[w.i][w.j].klingons or withprob(0.25)):
+                break
+	game.state.galaxy[w.i][w.j].klingons += 1
+	game.state.kcmdr.append(w)
+    # Locate planets in galaxy
+    for i in range(game.inplan):
+        while True:
+            w = randplace(GALSIZE) 
+            if game.state.galaxy[w.i][w.j].planet == None:
+                break
+        new = planet()
+	new.quadrant = w
+        new.crystals = "absent"
+	if (game.options & OPTION_WORLDS) and i < NINHAB:
+	    new.pclass = "M"	# All inhabited planets are class M
+	    new.crystals = "absent"
+	    new.known = "known"
+            new.name = systnames[i]
+	    new.inhabited = True
+	else:
+	    new.pclass = ("M", "N", "O")[randrange(0, 3)]
+            if withprob(0.33):
+                new.crystals = "present"
+	    new.known = "unknown"
+	    new.inhabited = False
+	game.state.galaxy[w.i][w.j].planet = new
+        game.state.planets.append(new)
+    # Locate Romulans
+    for i in range(game.state.nromrem):
+	w = randplace(GALSIZE)
+	game.state.galaxy[w.i][w.j].romulans += 1
+    # Place the Super-Commander if needed
+    if game.state.nscrem > 0:
+        while True:
+            w = randplace(GALSIZE)
+            if welcoming(w):
+                break
+	game.state.kscmdr = w
+	game.state.galaxy[w.i][w.j].klingons += 1
+    # Initialize times for extraneous events
+    schedule(FSNOVA, expran(0.5 * game.intime))
+    schedule(FTBEAM, expran(1.5 * (game.intime / len(game.state.kcmdr))))
+    schedule(FSNAP, randreal(1.0, 2.0)) # Force an early snapshot
+    schedule(FBATTAK, expran(0.3*game.intime))
+    unschedule(FCDBAS)
+    if game.state.nscrem:
+	schedule(FSCMOVE, 0.2777)
     else:
-	co = game.quad[ix][iy]
-    printf("%d,%d %c " % (ix, iy, co))
-    v += 1
-    ix = game.sector.x + v.x
-    iy = game.sector.y + v.y
-    if ix < 0 or ix >= QUADSIZE or iy < 0 or iy >= QUADSIZE:
-	co = '?'
+	unschedule(FSCMOVE)
+    unschedule(FSCDBAS)
+    unschedule(FDSPROB)
+    if (game.options & OPTION_WORLDS) and game.skill >= SKILL_GOOD:
+	schedule(FDISTR, expran(1.0 + game.intime))
     else:
-	co = game.quad[ix][iy]
-    printf("%c " % (co))
-    v += 1
-    ix = game.sector.x + v.x
-    iy = game.sector.y + v.y
-    if ix < 0 or ix >= QUADSIZE or iy < 0 or iy >= QUADSIZE:
-	co = '?'
+	unschedule(FDISTR)
+    unschedule(FENSLV)
+    unschedule(FREPRO)
+    # Place thing (in tournament game, we don't want one!)
+    # New in SST2K: never place the Thing near a starbase.
+    # This makes sense and avoids a special case in the old code.
+    global thing
+    if game.tourn is None:
+        while True:
+            thing = randplace(GALSIZE)
+            if thing not in game.state.baseq:
+                break
+    skip(2)
+    game.state.snap = False
+    if game.skill == SKILL_NOVICE:
+	prout(_("It is stardate %d. The Federation is being attacked by") % int(game.state.date))
+	prout(_("a deadly Klingon invasion force. As captain of the United"))
+	prout(_("Starship U.S.S. Enterprise, it is your mission to seek out"))
+	prout(_("and destroy this invasion force of %d battle cruisers.") % ((game.inkling + game.incom + game.inscom)))
+	prout(_("You have an initial allotment of %d stardates to complete") % int(game.intime))
+	prout(_("your mission.  As you proceed you may be given more time."))
+	skip(1)
+	prout(_("You will have %d supporting starbases.") % (game.inbase))
+	proutn(_("Starbase locations-  "))
     else:
-	co = game.quad[ix][iy]
-    prout("%c %d,%d\n" % (co, ix, iy))
-    game.optime = 0.5
-    game.ididit = True
-#endif
+	prout(_("Stardate %d.") % int(game.state.date))
+	skip(1)
+	prout(_("%d Klingons.") % (game.inkling + game.incom + game.inscom))
+	prout(_("An unknown number of Romulans."))
+	if game.state.nscrem:
+	    prout(_("And one (GULP) Super-Commander."))
+	prout(_("%d stardates.") % int(game.intime))
+	proutn(_("%d starbases in ") % game.inbase)
+    for i in range(game.inbase):
+	proutn(`game.state.baseq[i]`)
+	proutn("  ")
+    skip(2)
+    proutn(_("The Enterprise is currently in Quadrant %s") % game.quadrant)
+    proutn(_(" Sector %s") % game.sector)
+    skip(2)
+    prout(_("Good Luck!"))
+    if game.state.nscrem:
+	prout(_("  YOU'LL NEED IT."))
+    waitfor()
+    newqad()
+    if len(game.enemies) - (thing == game.quadrant) - (game.tholian != None):
+	game.shldup = True
+    if game.neutz:	# bad luck to start in a Romulan Neutral Zone
+	attack(torps_ok=False)
+
+def choose():
+    "Choose your game type."
+    global thing
+    while True:
+	game.tourn = 0
+	game.thawed = False
+	game.skill = SKILL_NONE
+	game.length = 0
+	if not scanner.inqueue: # Can start with command line options 
+	    proutn(_("Would you like a regular, tournament, or saved game? "))
+        scanner.next()
+        if scanner.sees("tournament"):
+	    while scanner.next() == "IHEOL":
+		proutn(_("Type in tournament number-"))
+	    if scanner.real == 0:
+		scanner.chew()
+		continue # We don't want a blank entry
+	    game.tourn = int(round(scanner.real))
+	    random.seed(scanner.real)
+            if logfp:
+                logfp.write("# random.seed(%d)\n" % scanner.real)
+	    break
+        if scanner.sees("saved") or scanner.sees("frozen"):
+	    if thaw():
+		continue
+	    scanner.chew()
+	    if game.passwd == None:
+		continue
+	    if not game.alldone:
+		game.thawed = True # No plaque if not finished
+	    report()
+	    waitfor()
+	    return True
+        if scanner.sees("regular"):
+	    break
+	proutn(_("What is \"%s\"?") % scanner.token)
+	scanner.chew()
+    while game.length==0 or game.skill==SKILL_NONE:
+	if scanner.next() == "IHALPHA":
+            if scanner.sees("short"):
+		game.length = 1
+	    elif scanner.sees("medium"):
+		game.length = 2
+	    elif scanner.sees("long"):
+		game.length = 4
+	    elif scanner.sees("novice"):
+		game.skill = SKILL_NOVICE
+	    elif scanner.sees("fair"):
+		game.skill = SKILL_FAIR
+	    elif scanner.sees("good"):
+		game.skill = SKILL_GOOD
+	    elif scanner.sees("expert"):
+		game.skill = SKILL_EXPERT
+	    elif scanner.sees("emeritus"):
+		game.skill = SKILL_EMERITUS
+	    else:
+		proutn(_("What is \""))
+		proutn(scanner.token)
+		prout("\"?")
+	else:
+	    scanner.chew()
+	    if game.length==0:
+		proutn(_("Would you like a Short, Medium, or Long game? "))
+	    elif game.skill == SKILL_NONE:
+		proutn(_("Are you a Novice, Fair, Good, Expert, or Emeritus player? "))
+    # Choose game options -- added by ESR for SST2K
+    if scanner.next() != "IHALPHA":
+	scanner.chew()
+	proutn(_("Choose your game style (or just press enter): "))
+	scanner.next()
+    if scanner.sees("plain"):
+	# Approximates the UT FORTRAN version.
+	game.options &=~ (OPTION_THOLIAN | OPTION_PLANETS | OPTION_THINGY | OPTION_PROBE | OPTION_RAMMING | OPTION_MVBADDY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS)
+	game.options |= OPTION_PLAIN
+    elif scanner.sees("almy"):
+	# Approximates Tom Almy's version.
+	game.options &=~ (OPTION_THINGY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS)
+	game.options |= OPTION_ALMY
+    elif scanner.sees("fancy") or scanner.sees("\n"):
+	pass
+    elif len(scanner.token):
+        proutn(_("What is \"%s\"?") % scanner.token)
+    setpassword()
+    if game.passwd == "debug":
+	idebug = True
+	prout("=== Debug mode enabled.")
+    # Use parameters to generate initial values of things
+    game.damfac = 0.5 * game.skill
+    game.inbase = randrange(BASEMIN, BASEMAX+1)
+    game.inplan = 0
+    if game.options & OPTION_PLANETS:
+	game.inplan += randrange(MAXUNINHAB/2, MAXUNINHAB+1)
+    if game.options & OPTION_WORLDS:
+	game.inplan += int(NINHAB)
+    game.state.nromrem = game.inrom = randrange(2 *game.skill)
+    game.state.nscrem = game.inscom = (game.skill > SKILL_FAIR)
+    game.state.remtime = 7.0 * game.length
+    game.intime = game.state.remtime
+    game.state.remkl = game.inkling = 2.0*game.intime*((game.skill+1 - 2*randreal())*game.skill*0.1+.15)
+    game.incom = min(MINCMDR, int(game.skill + 0.0625*game.inkling*randreal()))
+    game.state.remres = (game.inkling+4*game.incom)*game.intime
+    game.inresor = game.state.remres
+    if game.inkling > 50:
+        game.state.inbase += 1
+    return False
+
+def dropin(iquad=None):
+    "Drop a feature on a random dot in the current quadrant."
+    while True:
+        w = randplace(QUADSIZE)
+        if game.quad[w.i][w.j] == IHDOT:
+            break
+    if iquad is not None:
+        game.quad[w.i][w.j] = iquad
+    return w
+
+def newcnd():
+    "Update our alert status."
+    game.condition = "green"
+    if game.energy < 1000.0:
+	game.condition = "yellow"
+    if game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons or game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans:
+	game.condition = "red"
+    if not game.alive:
+	game.condition="dead"
+
+def newkling():
+    "Drop new Klingon into current quadrant."
+    return enemy(IHK, loc=dropin(), power=randreal(300,450)+25.0*game.skill)
+
+def newqad():
+    "Set up a new state of quadrant, for when we enter or re-enter it."
+    game.justin = True
+    game.iplnet = None
+    game.neutz = game.inorbit = game.landed = False
+    game.ientesc = game.iseenit = False
+    # Create a blank quadrant
+    game.quad = fill2d(QUADSIZE, lambda i, j: IHDOT)
+    if game.iscate:
+	# Attempt to escape Super-commander, so tbeam back!
+	game.iscate = False
+	game.ientesc = True
+    q = game.state.galaxy[game.quadrant.i][game.quadrant.j]
+    # cope with supernova
+    if q.supernova:
+	return
+    game.klhere = q.klingons
+    game.irhere = q.romulans
+    # Position Starship
+    game.quad[game.sector.i][game.sector.j] = game.ship
+    game.enemies = []
+    if q.klingons:
+	# Position ordinary Klingons
+	for i in range(game.klhere):
+            newkling()
+	# If we need a commander, promote a Klingon
+        for cmdr in game.state.kcmdr:
+	    if cmdr == game.quadrant:
+                e = game.enemies[game.klhere-1]
+                game.quad[e.kloc.i][e.kloc.j] = IHC
+                e.kpower = randreal(950,1350) + 50.0*game.skill
+		break	
+	# If we need a super-commander, promote a Klingon
+	if game.quadrant == game.state.kscmdr:
+            e = game.enemies[0]
+	    game.quad[e.kloc.i][e.kloc.j] = IHS
+	    e.kpower = randreal(1175.0,  1575.0) + 125.0*game.skill
+	    game.iscate = (game.state.remkl > 1)
+    # Put in Romulans if needed
+    for i in range(q.romulans):
+        enemy(IHR, loc=dropin(), power=randreal(400.0,850.0)+50.0*game.skill)
+    # If quadrant needs a starbase, put it in
+    if q.starbase:
+	game.base = dropin(IHB)
+    # If quadrant needs a planet, put it in
+    if q.planet:
+	game.iplnet = q.planet
+	if not q.planet.inhabited:
+	    game.plnet = dropin(IHP)
+	else:
+	    game.plnet = dropin(IHW)
+    # Check for condition
+    newcnd()
+    # Check for RNZ
+    if game.irhere > 0 and game.klhere == 0:
+	game.neutz = True
+	if not damaged(DRADIO):
+	    skip(1)
+	    prout(_("LT. Uhura- \"Captain, an urgent message."))
+	    prout(_("  I'll put it on audio.\"  CLICK"))
+	    skip(1)
+	    prout(_("INTRUDER! YOU HAVE VIOLATED THE ROMULAN NEUTRAL ZONE."))
+	    prout(_("LEAVE AT ONCE, OR YOU WILL BE DESTROYED!"))
+    # Put in THING if needed
+    if thing == game.quadrant:
+        enemy(type=IHQUEST, loc=dropin(),
+                  power=randreal(6000,6500.0)+250.0*game.skill)
+        if not damaged(DSRSENS):
+            skip(1)
+            prout(_("Mr. Spock- \"Captain, this is most unusual."))
+            prout(_("    Please examine your short-range scan.\""))
+    # Decide if quadrant needs a Tholian; lighten up if skill is low 
+    if game.options & OPTION_THOLIAN:
+	if (game.skill < SKILL_GOOD and withprob(0.02)) or \
+	    (game.skill == SKILL_GOOD and withprob(0.05)) or \
+            (game.skill > SKILL_GOOD and withprob(0.08)):
+            w = coord()
+            while True:
+		w.i = withprob(0.5) * (QUADSIZE-1)
+		w.j = withprob(0.5) * (QUADSIZE-1)
+                if game.quad[w.i][w.j] == IHDOT:
+                    break
+            game.tholian = enemy(type=IHT, loc=w,
+                                 power=randrange(100, 500) + 25.0*game.skill)
+	    # Reserve unoccupied corners 
+	    if game.quad[0][0]==IHDOT:
+		game.quad[0][0] = 'X'
+	    if game.quad[0][QUADSIZE-1]==IHDOT:
+		game.quad[0][QUADSIZE-1] = 'X'
+	    if game.quad[QUADSIZE-1][0]==IHDOT:
+		game.quad[QUADSIZE-1][0] = 'X'
+	    if game.quad[QUADSIZE-1][QUADSIZE-1]==IHDOT:
+		game.quad[QUADSIZE-1][QUADSIZE-1] = 'X'
+    game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+    # And finally the stars
+    for i in range(q.stars):
+	dropin(IHSTAR)
+    # Put in a few black holes
+    for i in range(1, 3+1):
+	if withprob(0.5): 
+	    dropin(IHBLANK)
+    # Take out X's in corners if Tholian present
+    if game.tholian:
+	if game.quad[0][0]=='X':
+	    game.quad[0][0] = IHDOT
+	if game.quad[0][QUADSIZE-1]=='X':
+	    game.quad[0][QUADSIZE-1] = IHDOT
+	if game.quad[QUADSIZE-1][0]=='X':
+	    game.quad[QUADSIZE-1][0] = IHDOT
+	if game.quad[QUADSIZE-1][QUADSIZE-1]=='X':
+	    game.quad[QUADSIZE-1][QUADSIZE-1] = IHDOT
+
+def setpassword():
+    "Set the self-destruct password."
+    if game.options & OPTION_PLAIN:
+	while True:
+	    scanner.chew()
+	    proutn(_("Please type in a secret password- "))
+	    scanner.next()
+	    game.passwd = scanner.token
+	    if game.passwd != None:
+		break
+    else:
+        game.passwd = ""
+        for i in range(8):
+	    game.passwd += chr(ord('a')+randrange(26))
+
+# Code from sst.c begins here
+
+commands = {
+    "SRSCAN":   	OPTION_TTY,
+    "STATUS":   	OPTION_TTY,
+    "REQUEST":  	OPTION_TTY,
+    "LRSCAN":   	OPTION_TTY,
+    "PHASERS":  	0,
+    "TORPEDO":  	0,
+    "PHOTONS":  	0,
+    "MOVE":     	0,
+    "SHIELDS":   	0,
+    "DOCK":     	0,
+    "DAMAGES":   	0,
+    "CHART":    	0,
+    "IMPULSE":  	0,
+    "REST":     	0,
+    "WARP":     	0,
+    "SCORE":    	0,
+    "SENSORS":  	OPTION_PLANETS,
+    "ORBIT":		OPTION_PLANETS,
+    "TRANSPORT":	OPTION_PLANETS,
+    "MINE":		OPTION_PLANETS,
+    "CRYSTALS":  	OPTION_PLANETS,
+    "SHUTTLE":  	OPTION_PLANETS,
+    "PLANETS":  	OPTION_PLANETS,
+    "REPORT":   	0,
+    "COMPUTER": 	0,
+    "COMMANDS": 	0,
+    "EMEXIT":		0,
+    "PROBE":		OPTION_PROBE,
+    "SAVE":		0,
+    "FREEZE":		0,	# Synonym for SAVE
+    "ABANDON":  	0,
+    "DESTRUCT": 	0,
+    "DEATHRAY": 	0,
+    "DEBUG":    	0,
+    "MAYDAY":		0,
+    "SOS":		0,	# Synonym for MAYDAY
+    "CALL":		0,	# Synonym for MAYDAY
+    "QUIT":		0,
+    "HELP":		0,
+}
+
+def listCommands():
+    "Generate a list of legal commands."
+    prout(_("LEGAL COMMANDS ARE:"))
+    emitted = 0
+    for key in commands:
+	if not commands[key] or (commands[key] & game.options):
+            proutn("%-12s " % key)
+            emitted += 1
+            if emitted % 5 == 4:
+                skip(1)
+    skip(1)
+
+def helpme():
+    "Browse on-line help."
+    key = scanner.next()
+    while True:
+	if key == "IHEOL":
+	    setwnd(prompt_window)
+	    proutn(_("Help on what command? "))
+	    key = scanner.next()
+	setwnd(message_window)
+	if key == "IHEOL":
+	    return
+        if scanner.token in commands or scanner.token == "ABBREV":
+	    break
+	skip(1)
+	listCommands()
+	key = "IHEOL"
+	scanner.chew()
+	skip(1)
+    cmd = scanner.token.upper()
+    try:
+        fp = open(SSTDOC, "r")
+    except IOError:
+        try:
+            fp = open(DOC_NAME, "r")
+        except IOError:
+            prout(_("Spock-  \"Captain, that information is missing from the"))
+            proutn(_("   computer. You need to find "))
+            proutn(DOC_NAME)
+            prout(_(" and put it in the"))
+            proutn(_("   current directory or to "))
+            proutn(SSTDOC)
+            prout(".\"")
+            # This used to continue: "You need to find SST.DOC and put 
+            # it in the current directory."
+            return
+    while True:
+        linebuf = fp.readline()
+	if linebuf == '':
+	    prout(_("Spock- \"Captain, there is no information on that command.\""))
+	    fp.close()
+	    return
+	if linebuf[0] == '%' and linebuf[1] == '%' and linebuf[2] == ' ':
+            linebuf = linebuf[3:].strip()
+            if cmd == linebuf:
+		break
+    skip(1)
+    prout(_("Spock- \"Captain, I've found the following information:\""))
+    skip(1)
+    while linebuf in fp:
+        if "******" in linebuf:
+	    break
+	proutn(linebuf)
+    fp.close()
+
+def makemoves():
+    "Command-interpretation loop."
+    clrscr()
+    setwnd(message_window)
+    while True: 	# command loop 
+	drawmaps(1)
+        while True:	# get a command 
+	    hitme = False
+	    game.justin = False
+	    game.optime = 0.0
+	    scanner.chew()
+	    setwnd(prompt_window)
+	    clrscr()
+	    proutn("COMMAND> ")
+	    if scanner.next() == "IHEOL":
+		if game.options & OPTION_CURSES:
+		    makechart()
+		continue
+            elif scanner.token == "":
+                continue
+	    game.ididit = False
+	    clrscr()
+	    setwnd(message_window)
+	    clrscr()
+            candidates = filter(lambda x: x.startswith(scanner.token.upper()),
+                                commands)
+            if len(candidates) == 1:
+                cmd = candidates[0]
+                break
+            elif candidates and not (game.options & OPTION_PLAIN):
+                prout("Commands with prefix '%s': %s" % (scanner.token, " ".join(candidates)))
+            else:
+                listCommands()
+                continue
+	if cmd == "SRSCAN":		# srscan
+	    srscan()
+	elif cmd == "STATUS":		# status
+	    status()
+	elif cmd == "REQUEST":		# status request 
+	    request()
+	elif cmd == "LRSCAN":		# long range scan
+	    lrscan(silent=False)
+	elif cmd == "PHASERS":		# phasers
+	    phasers()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "TORPEDO":		# photon torpedos
+	    photon()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "MOVE":		# move under warp
+	    warp(course=None, involuntary=False)
+	elif cmd == "SHIELDS":		# shields
+	    doshield(shraise=False)
+	    if game.ididit:
+		hitme = True
+		game.shldchg = False
+	elif cmd == "DOCK":		# dock at starbase
+	    dock(True)
+	    if game.ididit:
+		attack(torps_ok=False)		
+	elif cmd == "DAMAGES":		# damage reports
+	    damagereport()
+	elif cmd == "CHART":		# chart
+	    makechart()
+	elif cmd == "IMPULSE":		# impulse
+	    impulse()
+	elif cmd == "REST":		# rest
+	    wait()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "WARP":		# warp
+	    setwarp()
+	elif cmd == "SCORE":		# score
+	    score()
+	elif cmd == "SENSORS":		# sensors
+	    sensor()
+	elif cmd == "ORBIT":		# orbit
+	    orbit()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "TRANSPORT":		# transport "beam"
+	    beam()
+	elif cmd == "MINE":		# mine
+	    mine()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "CRYSTALS":		# crystals
+	    usecrystals()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "SHUTTLE":		# shuttle
+	    shuttle()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "PLANETS":		# Planet list
+	    survey()
+	elif cmd == "REPORT":		# Game Report 
+	    report()
+	elif cmd == "COMPUTER":		# use COMPUTER!
+	    eta()
+	elif cmd == "COMMANDS":
+	    listCommands()
+	elif cmd == "EMEXIT":		# Emergency exit
+	    clrscr()			# Hide screen
+	    freeze(True)		# forced save
+	    raise SysExit,1			# And quick exit
+	elif cmd == "PROBE":
+	    probe()			# Launch probe
+	    if game.ididit:
+		hitme = True
+	elif cmd == "ABANDON":		# Abandon Ship
+	    abandon()
+	elif cmd == "DESTRUCT":		# Self Destruct
+	    selfdestruct()
+	elif cmd == "SAVE":		# Save Game
+	    freeze(False)
+	    clrscr()
+	    if game.skill > SKILL_GOOD:
+		prout(_("WARNING--Saved games produce no plaques!"))
+	elif cmd == "DEATHRAY":		# Try a desparation measure
+	    deathray()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "DEBUGCMD":		# What do we want for debug???
+	    debugme()
+	elif cmd == "MAYDAY":		# Call for help
+	    mayday()
+	    if game.ididit:
+		hitme = True
+	elif cmd == "QUIT":
+	    game.alldone = True		# quit the game
+	elif cmd == "HELP":
+	    helpme()			# get help
+	while True:
+	    if game.alldone:
+		break		# Game has ended
+	    if game.optime != 0.0:
+		events()
+		if game.alldone:
+		    break	# Events did us in
+	    if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
+		atover(False)
+		continue
+	    if hitme and not game.justin:
+		attack(torps_ok=True)
+		if game.alldone:
+		    break
+		if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
+		    atover(False)
+		    hitme = True
+		    continue
+	    break
+	if game.alldone:
+	    break
+    if idebug:
+	prout("=== Ending")
+
+def cramen(type):
+    "Emit the name of an enemy or feature." 
+    if   type == IHR: s = _("Romulan")
+    elif type == IHK: s = _("Klingon")
+    elif type == IHC: s = _("Commander")
+    elif type == IHS: s = _("Super-commander")
+    elif type == IHSTAR: s = _("Star")
+    elif type == IHP: s = _("Planet")
+    elif type == IHB: s = _("Starbase")
+    elif type == IHBLANK: s = _("Black hole")
+    elif type == IHT: s = _("Tholian")
+    elif type == IHWEB: s = _("Tholian web")
+    elif type == IHQUEST: s = _("Stranger")
+    elif type == IHW: s = _("Inhabited World")
+    else: s = "Unknown??"
+    return s
+
+def crmena(stars, enemy, loctype, w):
+    "Emit the name of an enemy and his location."
+    buf = ""
+    if stars:
+	buf += "***"
+    buf += cramen(enemy) + _(" at ")
+    if loctype == "quadrant":
+	buf += _("Quadrant ")
+    elif loctype == "sector":
+	buf += _("Sector ")
+    return buf + `w`
+
+def crmshp():
+    "Emit our ship name." 
+    return{IHE:_("Enterprise"),IHF:_("Faerie Queene")}.get(game.ship,"Ship???")
+
+def stars():
+    "Emit a line of stars" 
+    prouts("******************************************************")
+    skip(1)
+
+def expran(avrage):
+    return -avrage*math.log(1e-7 + randreal())
+
+def randplace(size):
+    "Choose a random location."
+    w = coord()
+    w.i = randrange(size) 
+    w.j = randrange(size)
+    return w
+
+class sstscanner:
+    def __init__(self):
+        self.type = None
+        self.token = None
+        self.real = 0.0
+        self.inqueue = []
+    def next(self):
+        # Get a token from the user
+        self.real = 0.0
+        self.token = ''
+        # Fill the token quue if nothing here
+        while not self.inqueue:
+            line = cgetline()
+            if curwnd==prompt_window:
+                clrscr()
+                setwnd(message_window)
+                clrscr()
+            if line == '':
+                return None
+            if not line:
+                continue
+            else:
+                self.inqueue = line.lstrip().split() + ["\n"]
+        # From here on in it's all looking at the queue
+        self.token = self.inqueue.pop(0)
+        if self.token == "\n":
+            self.type = "IHEOL"
+            return "IHEOL"
+        try:
+            self.real = float(self.token)
+            self.type = "IHREAL"
+            return "IHREAL"
+        except ValueError:
+            pass
+        # Treat as alpha
+        self.token = self.token.lower()
+        self.type = "IHALPHA"
+        self.real = None
+        return "IHALPHA"
+    def append(self, tok):
+        self.inqueue.append(tok)
+    def push(self, tok):
+        self.inqueue.insert(0, tok)
+    def waiting(self):
+        return self.inqueue
+    def chew(self):
+        # Demand input for next scan
+        self.inqueue = []
+        self.real = self.token = None
+    def sees(self, s):
+        # compares s to item and returns true if it matches to the length of s
+        return s.startswith(self.token)
+    def int(self):
+        # Round token value to nearest integer
+        return int(round(scanner.real))
+    def getcoord(self):
+        s = coord()
+        scanner.next()
+    	if scanner.type != "IHREAL":
+	    huh()
+	    return None
+	s.i = scanner.int()-1
+        scanner.next()
+	if scanner.type != "IHREAL":
+	    huh()
+	    return None
+	s.j = scanner.int()-1
+        return s
+    def __repr__(str):
+        return "<sstcanner: token=%s, type=%s, queue=%s>" % (scanner.token, scanner.type, scanner.inqueue)
+
+def ja():
+    "Yes-or-no confirmation."
+    scanner.chew()
+    while True:
+	scanner.next()
+	if scanner.token == 'y':
+	    return True
+	if scanner.token == 'n':
+	    return False
+	scanner.chew()
+	proutn(_("Please answer with \"y\" or \"n\": "))
+
+def huh():
+    "Complain about unparseable input."
+    scanner.chew()
+    skip(1)
+    prout(_("Beg your pardon, Captain?"))
+
+def debugme():
+    "Access to the internals for debugging."
+    proutn("Reset levels? ")
+    if ja() == True:
+	if game.energy < game.inenrg:
+	    game.energy = game.inenrg
+	game.shield = game.inshld
+	game.torps = game.intorps
+	game.lsupres = game.inlsr
+    proutn("Reset damage? ")
+    if ja() == True:
+	for i in range(NDEVICES): 
+	    if game.damage[i] > 0.0: 
+		game.damage[i] = 0.0
+    proutn("Toggle debug flag? ")
+    if ja() == True:
+	idebug = not idebug
+	if idebug:
+	    prout("Debug output ON")	    
+	else:
+	    prout("Debug output OFF")
+    proutn("Cause selective damage? ")
+    if ja() == True:
+	for i in range(NDEVICES):
+	    proutn("Kill %s?" % device[i])
+	    scanner.chew()
+	    key = scanner.next()
+            if key == "IHALPHA" and scanner.sees("y"):
+		game.damage[i] = 10.0
+    proutn("Examine/change events? ")
+    if ja() == True:
+	ev = event()
+	w = coord()
+        legends = {
+            FSNOVA:  "Supernova       ",
+            FTBEAM:  "T Beam          ",
+            FSNAP:   "Snapshot        ",
+            FBATTAK: "Base Attack     ",
+            FCDBAS:  "Base Destroy    ",
+            FSCMOVE: "SC Move         ",
+            FSCDBAS: "SC Base Destroy ",
+            FDSPROB: "Probe Move      ",
+            FDISTR:  "Distress Call   ",
+            FENSLV:  "Enslavement     ",
+            FREPRO:  "Klingon Build   ",
+        }
+	for i in range(1, NEVENTS):
+            proutn(legends[i])
+	    if is_scheduled(i):
+		proutn("%.2f" % (scheduled(i)-game.state.date))
+		if i == FENSLV or i == FREPRO:
+		    ev = findevent(i)
+		    proutn(" in %s" % ev.quadrant)
+	    else:
+		proutn("never")
+	    proutn("? ")
+	    scanner.chew()
+	    key = scanner.next()
+	    if key == 'n':
+		unschedule(i)
+		scanner.chew()
+	    elif key == "IHREAL":
+		ev = schedule(i, scanner.real)
+		if i == FENSLV or i == FREPRO:
+		    scanner.chew()
+		    proutn("In quadrant- ")
+		    key = scanner.next()
+		    # "IHEOL" says to leave coordinates as they are 
+		    if key != "IHEOL":
+			if key != "IHREAL":
+			    prout("Event %d canceled, no x coordinate." % (i))
+			    unschedule(i)
+			    continue
+			w.i = int(round(scanner.real))
+			key = scanner.next()
+			if key != "IHREAL":
+			    prout("Event %d canceled, no y coordinate." % (i))
+			    unschedule(i)
+			    continue
+			w.j = int(round(scanner.real))
+			ev.quadrant = w
+	scanner.chew()
+    proutn("Induce supernova here? ")
+    if ja() == True:
+	game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova = True
+	atover(True)
+
+if __name__ == '__main__':
+    import getopt, socket
+    try:
+        global line, thing, game, idebug
+        game = None
+        thing = coord()
+        thing.angry = False
+        game = gamestate()
+        idebug = 0
+        game.options = OPTION_ALL &~ (OPTION_IOMODES | OPTION_PLAIN | OPTION_ALMY)
+        if os.getenv("TERM"):
+            game.options |= OPTION_CURSES
+        else:
+            game.options |= OPTION_TTY
+        seed = int(time.time())
+        (options, arguments) = getopt.getopt(sys.argv[1:], "r:s:tx")
+        for (switch, val) in options:
+            if switch == '-r':
+                try:
+                    replayfp = open(val, "r")
+                except IOError:
+                    sys.stderr.write("sst: can't open replay file %s\n" % val)
+                    raise SystemExit, 1
+                try:
+                    line = replayfp.readline().strip()
+                    (leader, key, seed) = line.split()
+                    seed = eval(seed)
+                    sys.stderr.write("sst2k: seed set to %s\n" % seed)
+                    line = replayfp.readline().strip()
+                    arguments += line.split()[2:]
+                except ValueError:
+                    sys.stderr.write("sst: replay file %s is ill-formed\n"% val)
+                    raise SystemExit(1)
+                game.options |= OPTION_TTY
+                game.options &=~ OPTION_CURSES
+            elif switch == '-s':
+                seed = int(val)
+            elif switch == '-t':
+                game.options |= OPTION_TTY
+                game.options &=~ OPTION_CURSES
+            elif switch == '-x':
+                idebug = True
+            else:
+                sys.stderr.write("usage: sst [-t] [-x] [startcommand...].\n")
+                raise SystemExit, 1
+        # where to save the input in case of bugs
+        try:
+            logfp = open("/usr/tmp/sst-input.log", "w")
+        except IOError:
+            sys.stderr.write("sst: warning, can't open logfile\n")
+        if logfp:
+            logfp.write("# seed %s\n" % seed)
+            logfp.write("# options %s\n" % " ".join(arguments))
+            logfp.write("# recorded by %s@%s on %s\n" % \
+                    (os.getenv("LOGNAME"),socket.gethostname(),time.ctime()))
+        random.seed(seed)
+        scanner = sstscanner()
+        map(scanner.append, arguments)
+        try:
+            iostart()
+            while True: # Play a game 
+                setwnd(fullscreen_window)
+                clrscr()
+                prelim()
+                setup()
+                if game.alldone:
+                    score()
+                    game.alldone = False
+                else:
+                    makemoves()
+                skip(1)
+                stars()
+                skip(1)
+                if game.tourn and game.alldone:
+                    proutn(_("Do you want your score recorded?"))
+                    if ja() == True:
+                        scanner.chew()
+                        scanner.push("\n")
+                        freeze(False)
+                scanner.chew()
+                proutn(_("Do you want to play again? "))
+                if not ja():
+                    break
+            skip(1)
+            prout(_("May the Great Bird of the Galaxy roost upon your home planet."))
+        finally:
+            ioend()
+        raise SystemExit, 0
+    except KeyboardInterrupt:
+        if logfp:
+            logfp.close()
+        print ""