X-Git-Url: https://jxself.org/git/?p=super-star-trek.git;a=blobdiff_plain;f=src%2Fsst.py;h=00f6df3dfa65ec08b449a6fa8c933283ebca08ca;hp=747f6dfa16cf629502adc84ec80f88f343093039;hb=c873e794bf5a029fef3a5ee5385cc0fec6220fa0;hpb=2684cee445448819a1d70659b4d09f24cfcac41a

diff --git a/src/sst.py b/src/sst.py
index 747f6df..00f6df3 100644
--- a/src/sst.py
+++ b/src/sst.py
@@ -1,288 +1,103 @@
 #!/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 a lot of
-parallel arrays where a more modern language would use structures
-or objects.  (However, 1-origin array indexing was fixed.)
-
-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".)
+sst.py -- Super Star Trek 2K
 
-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.)
+SST2K is a Python translation of a C translation of a FORTRAN
+original dating back to 1973.  Beautiful Python it is not, but it
+works.  Translation by Eric S. Raymond; original game by David Matuszek
+and Paul Reynolds, with modifications by Don Smith, Tom Almy,
+Stas Sergeev, and Eric S. Raymond.
 
-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".)
+See the doc/HACKING file in the distribution for designers notes and advice
+ion how to modify (and how not to modify!) this code.
 """
-import os,sys,math,curses,time,atexit,readline,cPickle,random,getopt,copy
+import os, sys, math, curses, time, readline, cPickle, random, copy, gettext, getpass
 
 SSTDOC  	= "/usr/share/doc/sst/sst.doc"
 DOC_NAME	= "sst.doc"
 
-# Stub to be replaced
-def _(str): return str
-
-PHASEFAC	= 2.0
-GALSIZE 	= 8
-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
-MAXBURST	= 3
-MINCMDR 	= 10
-
-# These functions hide the difference between 0-origin and 1-origin addressing.
-def VALID_QUADRANT(x, y):	return ((x)>=0 and (x)<GALSIZE and (y)>=0 and (y)<GALSIZE)
-def VALID_SECTOR(x, y):	return ((x)>=0 and (x)<QUADSIZE and (y)>=0 and (y)<QUADSIZE)
-
-# How to represent features
-IHR = 'R',
-IHK = 'K',
-IHC = 'C',
-IHS = 'S',
-IHSTAR = '*',
-IHP = 'P',
-IHW = '@',
-IHB = 'B',
-IHBLANK = ' ',
-IHDOT = '.',
-IHQUEST = '?',
-IHE = 'E',
-IHF = 'F',
-IHT = 'T',
-IHWEB = '#',
-IHMATER0 = '-',
-IHMATER1 = 'o',
-IHMATER2 = '0'
-
-IHEOL = '\n'
-IHREAL = 0.0
-IHALPHA = " "
+def _(str): return gettext.gettext(str)
+
+GALSIZE 	= 8		# Galaxy size in quadrants
+NINHAB  	= (GALSIZE * GALSIZE / 2)	# Number of inhabited worlds
+MAXUNINHAB	= 10		# Maximum uninhabited worlds
+QUADSIZE	= 10		# Quadrant size in sectors
+BASEMIN		= 2				# Minimum starbases
+BASEMAX 	= (GALSIZE * GALSIZE / 12)	# Maximum starbases
+MAXKLGAME	= 127		# Maximum Klingons per game
+MAXKLQUAD	= 9		# Maximum Klingons per quadrant
+FULLCREW	= 428		# Crew size. BSD Trek was 387, that's wrong 
+FOREVER 	= 1e30		# Time for the indefinite future
+MAXBURST	= 3		# Max # of torps you can launch in one turn
+MINCMDR 	= 10		# Minimum number of Klingon commanders
+DOCKFAC		= 0.25		# Repair faster when docked
+PHASEFAC	= 2.0		# Unclear what this is, it was in the C version
+
+class TrekError:
+    pass
 
 class coord:
     def __init__(self, x=None, y=None):
-        self.x = x
-        self.y = y
+        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 other != None and 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-other.x, self.y-other.y)
+        return coord(self.i-other.i, self.j-other.j)
     def __mul__(self, other):
-        return coord(self.x*other, self.y*other)
+        return coord(self.i*other, self.j*other)
     def __rmul__(self, other):
-        return coord(self.x*other, self.y*other)
+        return coord(self.i*other, self.j*other)
     def __div__(self, other):
-        return coord(self.x/other, self.y/other)
+        return coord(self.i/other, self.j/other)
+    def __mod__(self, other):
+        return coord(self.i % other, self.j % other)
     def __rdiv__(self, other):
-        return coord(self.x/other, self.y/other)
-    def snaptogrid(self):
-        return coord(int(round(self.x)), int(round(self.y)))
+        return coord(self.i/other, self.j/other)
+    def roundtogrid(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.x - other.x)**2 + (self.y - other.y)**2)
-    def bearing(self, other=None):
-        if not other: other = coord(0, 0)
-        return 1.90985*math.atan2(self.x-other.x, self.y-other.y)
+        return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
+    def bearing(self):
+        return 1.90985*math.atan2(self.j, self.i)
     def sgn(self):
         s = coord()
-        if self.x == 0:
-            s.x = 0
+        if self.i == 0:
+            s.i = 0
         else:
-            s.x = self.x / abs(self.x)
-        if self.y == 0:
-            s.y = 0
+            s.i = self.i / abs(self.i)
+        if self.j == 0:
+            s.j = 0
         else:
-            s.y = self.y / abs(self.y)
+            s.j = self.j / abs(self.j)
         return s
+    def quadrant(self):
+        #print "Location %s -> %s" % (self, (self / QUADSIZE).roundtogrid())
+        return self.roundtogrid() / QUADSIZE
+    def sector(self):
+        return self.roundtogrid() % QUADSIZE
     def scatter(self):
         s = coord()
-        s.x = self.x + randrange(-1, 2)
-        s.y = self.y + randrange(-1, 2)
+        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):
-        if self.x == None or self.y == None:
+        if self.i == None or self.j == None:
             return "Nowhere"
-        return "%s - %s" % (self.x+1, self.y+1)
+        return "%s - %s" % (self.i+1, self.j+1)
     __repr__ = __str__
 
 class planet:
@@ -340,9 +155,9 @@ class snapshot:
         self.baseq = [] 	# Base quadrant coordinates
         self.kcmdr = [] 	# Commander quadrant coordinates
 	self.kscmdr = coord()	# Supercommander quadrant coordinates
-        # the galaxy (subscript 0 not used)
+        # the galaxy
         self.galaxy = fill2d(GALSIZE, lambda i, j: quadrant())
-        # the starchart (subscript 0 not used)
+        # the starchart
     	self.chart = fill2d(GALSIZE, lambda i, j: page())
 
 class event:
@@ -414,39 +229,37 @@ FENSLV	= 10	# Inhabited word is enslaved */
 FREPRO	= 11	# Klingons build a ship in an enslaved system
 NEVENTS	= 12
 
-#
-# abstract out the event handling -- underlying data structures will change
-# when we implement stateful events
-# 
+# Abstract out the event handling -- underlying data structures will change
+# when we implement stateful events 
 def findevent(evtype):	return game.future[evtype]
 
 class enemy:
     def __init__(self, type=None, loc=None, power=None):
         self.type = type
-        self.kloc = coord()
+        self.location = coord()
         if loc:
             self.move(loc)
-        self.kpower = power	# enemy energy level
+        self.power = power	# enemy energy level
         game.enemies.append(self)
     def move(self, loc):
-        motion = (loc != self.kloc)
-        if self.kloc.x is not None and self.kloc.y is not None:
+        motion = (loc != self.location)
+        if self.location.i is not None and self.location.j is not None:
             if motion:
-                if self.type == IHT:
-                    game.quad[self.kloc.x][self.kloc.y] = IHWEB
+                if self.type == 'T':
+                    game.quad[self.location.i][self.location.j] = '#'
                 else:
-                    game.quad[self.kloc.x][self.kloc.y] = IHDOT
+                    game.quad[self.location.i][self.location.j] = '.'
         if loc:
-            self.kloc = copy.copy(loc)
-            game.quad[self.kloc.x][self.kloc.y] = self.type
+            self.location = copy.copy(loc)
+            game.quad[self.location.i][self.location.j] = self.type
             self.kdist = self.kavgd = (game.sector - loc).distance()
         else:
-            self.kloc = coord()
+            self.location = 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
+        return "<%s,%s.%f>" % (self.type, self.location, self.power)	# For debugging
 
 class gamestate:
     def __init__(self):
@@ -466,7 +279,6 @@ class gamestate:
         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)
@@ -509,7 +321,6 @@ class gamestate:
         self.irhere = 0		# Romulans in quadrant
         self.isatb = 0		# =1 if super commander is attacking base
         self.tourn = None	# tournament number
-        self.proben = 0		# number of moves for probe
         self.nprobes = 0	# number of probes available
         self.inresor = 0.0	# initial resources
         self.intime = 0.0	# initial time
@@ -520,19 +331,12 @@ class gamestate:
         self.energy = 0.0	# energy level
         self.shield = 0.0	# shield level
         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): 
@@ -542,28 +346,7 @@ class gamestate:
         # 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*len(game.state.kcmdr))
-# From enumerated type 'feature'
-IHR = 'R'
-IHK = 'K'
-IHC = 'C'
-IHS = 'S'
-IHSTAR = '*'
-IHP = 'P'
-IHW = '@'
-IHB = 'B'
-IHBLANK = ' '
-IHDOT = '.'
-IHQUEST = '?'
-IHE = 'E'
-IHF = 'F'
-IHT = 'T'
-IHWEB = '#'
-IHMATER0 = '-'
-IHMATER1 = 'o'
-IHMATER2 = '0'
-
-
-# From enumerated type 'FINTYPE'
+
 FWON = 0
 FDEPLETE = 1
 FLIFESUP = 2
@@ -587,63 +370,53 @@ FTRIBBLE = 19
 FHOLE = 20
 FCREW = 21
 
-# Log the results of pulling random numbers so we can check determinism.
-
-import traceback
-
 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
+    return random.random() < 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
+    return random.randrange(*args)
 
 def randreal(*args):
     v = random.random()
     if len(args) == 1:
-        v *= args[0] 		# returns from [0, args[0])
+        v *= args[0] 		# 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:]))
+        v = args[0] + v*(args[1]-args[0])	# from [args[0], args[1])
     return v
 
 # Code from ai.c begins here
 
 def welcoming(iq):
     "Would this quadrant welcome another Klingon?"
-    return VALID_QUADRANT(iq.x,iq.y) and \
-	not game.state.galaxy[iq.x][iq.y].supernova or \
-	game.state.galaxy[iq.x][iq.y].klingons < MAXKLQUAD
-
+    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
+    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:
+    if enemy.type == 'R':
 	return False; # Romulans cannot escape! 
     if not irun:
 	# avoid intruding on another commander's territory 
-	if enemy.type == IHC:
+	if enemy.type == 'C':
             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 enemy.kpower > 1000.0:
+	if enemy.power > 1000.0:
 	    return False
     # 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":
-	prout(crmena(True, enemy.type, "sector", enemy.kloc) + \
+	prout(crmena(True, enemy.type, "sector", enemy.location) + \
               (_(" escapes to Quadrant %s (and regains strength).") % q))
     # handle local matters related to escape
     enemy.move(None)
@@ -651,9 +424,9 @@ def tryexit(enemy, look, irun):
     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 enemy.type==IHS:
+    game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
+    game.state.galaxy[iq.i][iq.j].klingons += 1
+    if enemy.type=='S':
 	game.iscate = False
 	game.ientesc = False
 	game.isatb = 0
@@ -667,7 +440,6 @@ def tryexit(enemy, look, irun):
 		break
     return True; # success 
 
-#
 # The bad-guy movement algorithm:
 # 
 # 1. Enterprise has "force" based on condition of phaser and photon torpedoes.
@@ -705,7 +477,6 @@ def tryexit(enemy, look, irun):
 # retreat, especially at high skill levels.
 # 
 # 5.  Motion is limited to skill level, except for SC hi-tailing it out.
-# 
 
 def movebaddy(enemy):
     "Tactical movement for the bad guys."
@@ -719,13 +490,13 @@ def movebaddy(enemy):
     dist1 = enemy.kdist
     mdist = int(dist1 + 0.5); # Nearest integer distance 
     # If SC, check with spy to see if should hi-tail it 
-    if enemy.type==IHS and \
-	(enemy.kpower <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
+    if enemy.type=='S' and \
+	(enemy.power <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
 	irun = True
 	motion = -QUADSIZE
     else:
 	# decide whether to advance, retreat, or hold position 
-	forces = enemy.kpower+100.0*len(game.enemies)+400*(nbaddys-1)
+	forces = enemy.power+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):
@@ -760,10 +531,7 @@ def movebaddy(enemy):
             else:
                 motion = game.skill
     # calculate preferred number of steps 
-    if motion < 0:
-        nsteps = -motion
-    else:
-        nsteps = motion
+    nsteps = abs(int(motion))
     if motion > 0 and nsteps > mdist:
 	nsteps = mdist; # don't overshoot 
     if nsteps > QUADSIZE:
@@ -773,66 +541,57 @@ def movebaddy(enemy):
     if idebug:
 	proutn("NSTEPS = %d:" % nsteps)
     # Compute preferred values of delta X and Y 
-    m = game.sector - enemy.kloc
-    if 2.0 * abs(m.x) < abs(m.y):
-	m.x = 0
-    if 2.0 * abs(m.y) < abs(game.sector.x-enemy.kloc.x):
-	m.y = 0
-    if m.x != 0:
-        if m.x*motion < 0:
-            m.x = -1
-        else:
-            m.x = 1
-    if m.y != 0:
-        if m.y*motion < 0:
-            m.y = -1
-        else:
-            m.y = 1
-    next = enemy.kloc
+    m = game.sector - enemy.location
+    if 2.0 * abs(m.i) < abs(m.j):
+	m.i = 0
+    if 2.0 * abs(m.j) < abs(game.sector.i-enemy.location.i):
+	m.j = 0
+    m = (motion * m).sgn()
+    next = enemy.location
     # main move loop 
     for ll in range(nsteps):
 	if idebug:
 	    proutn(" %d" % (ll+1))
 	# Check if preferred position available 
 	look = next + m
-        if m.x < 0:
-            krawlx = 1
+        if m.i < 0:
+            krawli = 1
         else:
-            krawlx = -1
-        if m.y < 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 < 0 or look.x >= QUADSIZE:
+	    if look.i < 0 or look.i >= QUADSIZE:
 		if motion < 0 and tryexit(enemy, look, irun):
 		    return
-		if krawlx == m.x or m.y == 0:
+		if krawli == m.i or m.j == 0:
 		    break
-		look.x = next.x + krawlx
-		krawlx = -krawlx
-	    elif look.y < 0 or look.y >= QUADSIZE:
+		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 == m.y or m.x == 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:
+		look.j = next.j + krawlj
+		krawlj = -krawlj
+	    elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != '.':
 		# See if enemy should ram ship 
-		if game.quad[look.x][look.y] == game.ship and \
-		    (enemy.type == IHC or enemy.type == IHS):
+		if game.quad[look.i][look.j] == game.ship and \
+		    (enemy.type == 'C' or enemy.type == 'S'):
 		    collision(rammed=True, enemy=enemy)
 		    return
-		if krawlx != m.x and m.y != 0:
-		    look.x = next.x + krawlx
-		    krawlx = -krawlx
-		elif krawly != m.y and m.x != 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:
@@ -847,7 +606,7 @@ def movebaddy(enemy):
 	skip(1)
     if enemy.move(next):
 	if not damaged(DSRSENS) or game.condition == "docked":
-	    proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.kloc))
+	    proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.location))
 	    if enemy.kdist < dist1:
 		proutn(_(" advances to "))
 	    else:
@@ -862,11 +621,11 @@ def moveklings():
     # and do move
     if game.quadrant in game.state.kcmdr:
         for enemy in game.enemies:
-	    if enemy.type == IHC:
+	    if enemy.type == 'C':
 		movebaddy(enemy)
     if game.state.kscmdr==game.quadrant:
         for enemy in game.enemies:
-	    if enemy.type == IHS:
+	    if enemy.type == 'S':
 		movebaddy(enemy)
 		break
     # If skill level is high, move other Klingons and Romulans too!
@@ -874,7 +633,7 @@ def moveklings():
     # commander(s) do.
     if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
         for enemy in game.enemies:
-            if enemy.type in (IHK, IHR):
+            if enemy.type in ('K', 'R'):
 		movebaddy(enemy)
     game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
 
@@ -882,13 +641,13 @@ def movescom(iq, avoid):
     "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 True
+	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
+    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
@@ -896,7 +655,7 @@ def movescom(iq, avoid):
 	game.ientesc = False
 	unschedule(FSCDBAS)
 	for enemy in game.enemies:
-	    if enemy.type == IHS:
+	    if enemy.type == 'S':
 		break
 	enemy.move(None)
 	game.klhere -= 1
@@ -909,14 +668,14 @@ def movescom(iq, avoid):
 	    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 = None
+	    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." 
@@ -930,10 +689,10 @@ def supercommander():
     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 not game.state.baseq:
@@ -974,32 +733,32 @@ 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 len(game.state.baseq) == 0:
 	unschedule(FSCMOVE)
     else:
-        for (i, ibq) in enumerate(game.state.baseq):
+        for ibq in game.state.baseq:
 	    if ibq == game.state.kscmdr and game.state.kscmdr == game.battle:
 		# attack the base 
 		if avoid:
@@ -1030,7 +789,7 @@ def supercommander():
     if not idebug and \
 	(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"))
@@ -1042,48 +801,48 @@ def movetholian():
     if not game.tholian or game.justin:
 	return
     id = coord()
-    if game.tholian.kloc.x == 0 and game.tholian.kloc.y == 0:
-	id.x = 0; id.y = QUADSIZE-1
-    elif game.tholian.kloc.x == 0 and game.tholian.kloc.y == QUADSIZE-1:
-	id.x = QUADSIZE-1; id.y = QUADSIZE-1
-    elif game.tholian.kloc.x == QUADSIZE-1 and game.tholian.kloc.y == QUADSIZE-1:
-	id.x = QUADSIZE-1; id.y = 0
-    elif game.tholian.kloc.x == QUADSIZE-1 and game.tholian.kloc.y == 0:
-	id.x = 0; id.y = 0
+    if game.tholian.location.i == 0 and game.tholian.location.j == 0:
+	id.i = 0; id.j = QUADSIZE-1
+    elif game.tholian.location.i == 0 and game.tholian.location.j == QUADSIZE-1:
+	id.i = QUADSIZE-1; id.j = QUADSIZE-1
+    elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == QUADSIZE-1:
+	id.i = QUADSIZE-1; id.j = 0
+    elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == 0:
+	id.i = 0; id.j = 0
     else:
 	# something is wrong! 
 	game.tholian.move(None)
         prout("***Internal error: Tholian in a bad spot.")
 	return
     # do nothing if we are blocked 
-    if game.quad[id.x][id.y] not in (IHDOT, IHWEB):
+    if game.quad[id.i][id.j] not in ('.', '#'):
 	return
-    here = copy.copy(game.tholian.kloc)
-    delta = (id - game.tholian.kloc).sgn()
+    here = copy.copy(game.tholian.location)
+    delta = (id - game.tholian.location).sgn()
     # move in x axis 
-    while here.x != id.x:
-        here.x += delta.x
-        if game.quad[here.x][here.y]==IHDOT:
+    while here.i != id.i:
+        here.i += delta.i
+        if game.quad[here.i][here.j]=='.':
             game.tholian.move(here)
     # move in y axis 
-    while here.y != id.y:
-        here.y += delta.y
-        if game.quad[here.x][here.y]==IHDOT:
+    while here.j != id.j:
+        here.j += delta.j
+        if game.quad[here.i][here.j]=='.':
             game.tholian.move(here)
     # check to see if all holes plugged 
     for i in range(QUADSIZE):
-	if game.quad[0][i]!=IHWEB and game.quad[0][i]!=IHT:
+	if game.quad[0][i]!='#' and game.quad[0][i]!='T':
 	    return
-	if game.quad[QUADSIZE][i]!=IHWEB and game.quad[QUADSIZE][i]!=IHT:
+	if game.quad[QUADSIZE-1][i]!='#' and game.quad[QUADSIZE-1][i]!='T':
 	    return
-	if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT:
+	if game.quad[i][0]!='#' and game.quad[i][0]!='T':
 	    return
-	if game.quad[i][QUADSIZE]!=IHWEB and game.quad[i][QUADSIZE]!=IHT:
+	if game.quad[i][QUADSIZE-1]!='#' and game.quad[i][QUADSIZE-1]!='T':
 	    return
     # All plugged up -- Tholian splits 
-    game.quad[game.tholian.kloc.x][game.tholian.kloc.y]=IHWEB
-    dropin(IHBLANK)
-    prout(crmena(True, IHT, "sector", game.tholian) + _(" completes web."))
+    game.quad[game.tholian.location.i][game.tholian.location.j]='#'
+    dropin(' ')
+    prout(crmena(True, 'T', "sector", game.tholian) + _(" completes web."))
     game.tholian.move(None)
     return
 
@@ -1097,7 +856,7 @@ def doshield(shraise):
 	action = "SHUP"
     else:
 	key = scanner.next()
-	if key == IHALPHA:
+	if key == "IHALPHA":
 	    if scanner.sees("transfer"):
 		action = "NRG"
 	    else:
@@ -1111,7 +870,6 @@ def doshield(shraise):
 	if action=="NONE":
 	    proutn(_("Do you wish to change shield energy? "))
 	    if ja() == True:
-		proutn(_("Energy to transfer to shields- "))
 		action = "NRG"
 	    elif damaged(DSHIELD):
 		prout(_("Shields damaged and down."))
@@ -1156,24 +914,25 @@ def doshield(shraise):
 	game.ididit = True
 	return
     elif action == "NRG":
-	while scanner.next() != IHREAL:
+	while scanner.next() != "IHREAL":
 	    scanner.chew()
 	    proutn(_("Energy to transfer to shields- "))
+        nrg = scanner.real
 	scanner.chew()
-	if scanner.real == 0:
+	if nrg == 0:
 	    return
-	if scanner.real > game.energy:
+	if nrg > game.energy:
 	    prout(_("Insufficient ship energy."))
 	    return
 	game.ididit = True
-	if game.shield+scanner.real >= game.inshld:
+	if game.shield+nrg >= game.inshld:
 	    prout(_("Shield energy maximized."))
-	    if game.shield+scanner.real > game.inshld:
+	    if game.shield+nrg > game.inshld:
 		prout(_("Excess energy requested returned to ship energy"))
 	    game.energy -= game.inshld-game.shield
 	    game.shield = game.inshld
 	    return
-	if scanner.real < 0.0 and game.energy-scanner.real > game.inenrg:
+	if nrg < 0.0 and game.energy-nrg > game.inenrg:
 	    # Prevent shield drain loophole 
 	    skip(1)
 	    prout(_("Engineering to bridge--"))
@@ -1181,50 +940,28 @@ def doshield(shraise):
 	    prout(_("  I can't drain the shields."))
 	    game.ididit = False
 	    return
-	if game.shield+scanner.real < 0:
+	if game.shield+nrg < 0:
 	    prout(_("All shield energy transferred to ship."))
 	    game.energy += game.shield
 	    game.shield = 0.0
 	    return
 	proutn(_("Scotty- \""))
-	if scanner.real > 0:
+	if nrg > 0:
 	    prout(_("Transferring energy to shields.\""))
 	else:
 	    prout(_("Draining energy from shields.\""))
-	game.shield += scanner.real
-	game.energy -= scanner.real
+	game.shield += nrg
+	game.energy -= nrg
 	return
 
 def randdevice():
     "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
-    # device is damaged depends on the device.  Well protected
-    # devices (such as the computer, which is in the core of the
-    # ship and has considerable redundancy) almost never get
-    # damaged, whereas devices which are exposed (such as the
-    # warp engines) or which are particularly delicate (such as
-    # the transporter) have a much higher probability of being
-    # damaged."
-    # 
-    # 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 randrange(NDEVICES)
-    # and have done with it.  Also, in the original game, DNAVYS
-    # and DCOMPTR were the same device. 
-    # 
-    # Instead, we use a table of weights similar to the one from BSD Trek.
-    # BSD doesn't have the shuttle, shield controller, death ray, or probes. 
-    # 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% 
 	120,	# DPHASER: phasers			12.0% 
 	120,	# DPHOTON: photon torpedoes		12.0% 
-	25,	# DLIFSUP: life support		 2.5% 
+	25,	# DLIFSUP: life support			 2.5% 
 	65,	# DWARPEN: warp drive			 6.5% 
 	70,	# DIMPULS: impulse engines		 6.5% 
 	145,	# DSHIELD: deflector shields		14.5% 
@@ -1253,16 +990,16 @@ def collision(rammed, enemy):
     skip(2)
     proutn("***")
     proutn(crmshp())
-    hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0)
+    hardness = {'R':1.5, 'C':2.0, 'S':2.5, 'T':0.5, '?':4.0}.get(enemy.type, 1.0)
     if rammed:
         proutn(_(" rammed by "))
     else:
         proutn(_(" rams "))
-    proutn(crmena(False, enemy.type, "sector", enemy.kloc))
+    proutn(crmena(False, enemy.type, "sector", enemy.location))
     if rammed:
 	proutn(_(" (original position)"))
     skip(1)
-    deadkl(enemy.kloc, enemy.type, game.sector)
+    deadkl(enemy.location, enemy.type, game.sector)
     proutn("***" + crmship() + " heavily damaged.")
     icas = randrange(10, 30)
     prout(_("***Sickbay reports %d casualties"), icas)
@@ -1288,160 +1025,146 @@ def collision(rammed, enemy):
 	finish(FWON)
     return
 
-def torpedo(course, dispersion, origin, number, nburst):
+def torpedo(origin, bearing, dispersion, number, nburst):
     "Let a photon torpedo fly" 
-    iquad = 0
-    shoved = False
-    ac = course + 0.25*dispersion
-    angle = (15.0-ac)*0.5235988
-    bullseye = (15.0 - course)*0.5235988
-    deltax = -math.sin(angle);
-    deltay = math.cos(angle);
-    x = origin.x; y = origin.y
-    w = coord(0, 0); jw = coord(0, 0)
-    bigger = max(math.fabs(deltax), math.fabs(deltay))
-    deltax /= bigger
-    deltay /= bigger
     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 step in range(1, 15+1):
-	x += deltax
-	w.x = int(x + 0.5)
-	y += deltay
-	w.y = int(y + 0.5)
-	if not VALID_SECTOR(w.x, w.y):
+    setwnd(message_window)
+    for step in range(1, QUADSIZE*2):
+        if not track.next(): break
+        w = track.sector()
+	if not w.valid_sector():
 	    break
-	iquad=game.quad[w.x][w.y]
+	iquad=game.quad[w.i][w.j]
 	tracktorpedo(origin, w, step, number, nburst, iquad)
-	if iquad==IHDOT:
+	if iquad=='.':
 	    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 
+	if iquad in ('E', 'F'): # Hit our ship 
 	    skip(1)
 	    prout(_("Torpedo hits %s.") % crmshp())
 	    hit = 700.0 + randreal(100) - \
-		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
+		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*(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 = int(w.x+xx+0.5)
-	    jw.y = int(w.y+yy+0.5)
-	    if not VALID_SECTOR(jw.x, jw.y):
+            # In the C/FORTRAN version, dispersion was 2.5 radians, which
+            # is 143 degrees, which is almost exactly 4.8 clockface units
+            displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5)
+            displacement.next()
+            bumpto = displacement.sector()
+	    if not bumpto.valid_sector():
 		return hit
-	    if game.quad[jw.x][jw.y]==IHBLANK:
+	    if game.quad[bumpto.i][bumpto.j]==' ':
 		finish(FHOLE)
 		return hit
-	    if game.quad[jw.x][jw.y]!=IHDOT:
+	    if game.quad[bumpto.i][bumpto.j]!='.':
 		# can't move into object 
 		return hit
-	    game.sector = jw
+	    game.sector = bumpto
 	    proutn(crmshp())
-	    shoved = True
-	elif iquad in (IHC, IHS): # Hit a commander 
-	    if withprob(0.05):
+            game.quad[w.i][w.j]='.'
+            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.location).distance()
+            game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+            return None
+	elif iquad in ('C', 'S', 'R', 'K'): # Hit a regular enemy 
+	    # find the enemy 
+	    if iquad in ('C', 'S') 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 enemy in game.enemies:
-		if w == game.enemies[ll].kloc:
+		if w == enemy.location:
 		    break
-	    kp = math.fabs(e.kpower)
+	    kp = math.fabs(enemy.power)
 	    h1 = 700.0 + randrange(100) - \
-		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
+		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
 	    h1 = math.fabs(h1)
 	    if kp < h1:
 		h1 = kp
-            if enemy.kpower < 0:
-                enemy.kpower -= -h1
+            if enemy.power < 0:
+                enemy.power -= -h1
             else:
-                enemy.kpower -= h1
-	    if enemy.kpower == 0:
+                enemy.power -= h1
+	    if enemy.power == 0:
 		deadkl(w, iquad, w)
 		return None
 	    proutn(crmena(True, iquad, "sector", w))
-	    # If enemy damaged but not destroyed, try to displace 
-	    ang = 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 = int(w.x+xx+0.5)
-	    jw.y = int(w.y+yy+0.5)
-	    if not VALID_SECTOR(jw.x, jw.y):
+            displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5)
+            displacement.next()
+            bumpto = displacement.sector()
+            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] == ' ':
 		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] != '.':
 		prout(_(" damaged but not destroyed."))
-		return None
-	    proutn(_(" damaged--"))
-	    enemy.kloc = jw
-	    shoved = True
-	    break
-	elif iquad == IHB: # Hit a base 
+            else:
+                prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
+                enemy.location = bumpto
+                game.quad[w.i][w.j]='.'
+                game.quad[bumpto.i][bumpto.j]=iquad
+                for enemy in game.enemies:
+                    enemy.kdist = enemy.kavgd = (game.sector-enemy.location).distance()
+                game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+            return None
+	elif iquad == 'B': # Hit a base 
 	    skip(1)
 	    prout(_("***STARBASE DESTROYED.."))
             game.state.baseq = filter(lambda x: x != game.quadrant, game.state.baseq)
-	    game.quad[w.x][w.y]=IHDOT
+	    game.quad[w.i][w.j]='.'
 	    game.base.invalidate()
-	    game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase -= 1
-	    game.state.chart[game.quadrant.x][game.quadrant.y].starbase -= 1
+	    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 
+	elif iquad == 'P': # Hit a planet 
 	    prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
 	    game.state.nplankl += 1
-	    game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None
+	    game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
 	    game.iplnet.pclass = "destroyed"
 	    game.iplnet = None
 	    game.plnet.invalidate()
-	    game.quad[w.x][w.y] = IHDOT
+	    game.quad[w.i][w.j] = '.'
 	    if game.landed:
 		# captain perishes on planet 
 		finish(FDPLANET)
 	    return None
-	elif iquad == IHW: # Hit an inhabited world -- very bad! 
+	elif iquad == '@': # Hit an inhabited world -- very bad! 
 	    prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
 	    game.state.nworldkl += 1
-	    game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None
+	    game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
 	    game.iplnet.pclass = "destroyed"
 	    game.iplnet = None
 	    game.plnet.invalidate()
-	    game.quad[w.x][w.y] = IHDOT
+	    game.quad[w.i][w.j] = '.'
 	    if game.landed:
 		# captain perishes on planet 
 		finish(FDPLANET)
-	    prout(_("You have just destroyed an inhabited planet."))
-	    prout(_("Celebratory rallies are being held on the Klingon homeworld."))
+	    prout(_("The torpedo destroyed an inhabited planet."))
 	    return None
-	elif iquad == IHSTAR: # Hit a star 
+	elif iquad == '*': # Hit a star 
 	    if withprob(0.9):
 		nova(w)
             else:
-                prout(crmena(True, IHSTAR, "sector", w) + _(" unaffected by photon blast."))
+                prout(crmena(True, '*', "sector", w) + _(" unaffected by photon blast."))
 	    return None
-	elif iquad == IHQUEST: # Hit a thingy 
+	elif iquad == '?': # Hit a thingy 
 	    if not (game.options & OPTION_THINGY) or withprob(0.3):
 		skip(1)
 		prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
@@ -1453,40 +1176,38 @@ def torpedo(course, dispersion, origin, number, nburst):
 		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.
-		#
 		thing.angry = True
 		shoved = True
 	    return None
-	elif iquad == IHBLANK: # Black hole 
+	elif iquad == ' ': # Black hole 
 	    skip(1)
-	    prout(crmena(True, IHBLANK, "sector", w) + _(" swallows torpedo."))
+	    prout(crmena(True, ' ', "sector", w) + _(" swallows torpedo."))
 	    return None
-	elif iquad == IHWEB: # hit the web 
+	elif iquad == '#': # hit the web 
 	    skip(1)
 	    prout(_("***Torpedo absorbed by Tholian web."))
 	    return None
-	elif iquad == IHT:  # Hit a Tholian 
+	elif iquad == 'T':  # Hit a Tholian 
 	    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.quad[w.i][w.j] = '.'
 		deadkl(w, iquad, w)
 		game.tholian = None
 		return None
 	    skip(1)
-	    proutn(crmena(True, IHT, "sector", w))
+	    proutn(crmena(True, 'T', "sector", w))
 	    if withprob(0.05):
 		prout(_(" survives photon blast."))
 		return None
 	    prout(_(" disappears."))
 	    game.tholian.move(None)
-	    game.quad[w.x][w.y] = IHWEB
-	    dropin(IHBLANK)
+	    game.quad[w.i][w.j] = '#'
+	    dropin(' ')
 	    return None
         else: # Problem!
 	    skip(1)
@@ -1495,16 +1216,6 @@ def torpedo(course, dispersion, origin, number, nburst):
 	    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(len(game.enemies)):
-	    game.enemies[ll].kdist = game.enemies[ll].kavgd = (game.sector-game.enemies[ll].kloc).distance()
-        game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
-	return None
     skip(1)
     prout(_("Torpedo missed."))
     return None;
@@ -1542,12 +1253,12 @@ def fry(hit):
 def attack(torps_ok):
     # bad guy attacks us 
     # 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"
-    # game could be over at this point, check 
-    if game.alldone:
-	return
     if idebug:
 	prout("=== ATTACK!")
     # Tholian gets to move before attacking 
@@ -1572,46 +1283,46 @@ def attack(torps_ok):
     if game.skill <= SKILL_FAIR:
 	where = "sector"
     for enemy in game.enemies:
-	if enemy.kpower < 0:
+	if enemy.power < 0:
 	    continue;	# too weak to attack 
 	# compute hit strength and diminish shield power 
 	r = randreal()
 	# Increase chance of photon torpedos if docked or enemy energy is low 
 	if game.condition == "docked":
 	    r *= 0.25
-	if enemy.kpower < 500:
+	if enemy.power < 500:
 	    r *= 0.25; 
-	if enemy.type==IHT or (enemy.type==IHQUEST and not thing.angry):
+	if enemy.type=='T' or (enemy.type=='?' and not thing.angry):
 	    continue
 	# different enemies have different probabilities of throwing a torp 
 	usephasers = not torps_ok or \
-	    (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)
+	    (enemy.type == 'K' and r > 0.0005) or \
+	    (enemy.type=='C' and r > 0.015) or \
+	    (enemy.type=='R' and r > 0.3) or \
+	    (enemy.type=='S' and r > 0.07) or \
+	    (enemy.type=='?' 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 = randreal(0.8, 0.85)
-	    hit = enemy.kpower*math.pow(dustfac,enemy.kavgd)
-	    enemy.kpower *= 0.75
+	    hit = enemy.power*math.pow(dustfac,enemy.kavgd)
+	    enemy.power *= 0.75
 	else: # Enemy uses photon torpedo 
-	    #course2 = (enemy.kloc-game.sector).bearing()
-	    course = 1.90985*math.atan2(game.sector.y-enemy.kloc.y, enemy.kloc.x-game.sector.x)
+	    # We should be able to make the bearing() method work here
+	    course = 1.90985*math.atan2(game.sector.j-enemy.location.j, enemy.location.i-game.sector.i)
 	    hit = 0
 	    proutn(_("***TORPEDO INCOMING"))
 	    if not damaged(DSRSENS):
-		proutn(_(" From ") + crmena(False, enemy.type, where, enemy.kloc))
+		proutn(_(" From ") + crmena(False, enemy.type, where, enemy.location))
 	    attempt = True
 	    prout("  ")
 	    dispersion = (randreal()+randreal())*0.5 - 0.5
-	    dispersion += 0.002*enemy.kpower*dispersion
-	    hit = torpedo(course, dispersion, origin=enemy.kloc, number=1, nburst=1)
+	    dispersion += 0.002*enemy.power*dispersion
+	    hit = torpedo(enemy.location, 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:
+	    if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone:
 		return # Supernova or finished 
 	    if hit == None:
 		continue
@@ -1641,7 +1352,7 @@ def attack(torps_ok):
 	if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR:
 	    proutn(_(" on the ") + crmshp())
 	if not damaged(DSRSENS) and usephasers:
-	    prout(_(" from ") + crmena(False, enemy.type, where, enemy.kloc))
+	    prout(_(" from ") + crmena(False, enemy.type, where, enemy.location))
 	skip(1)
 	# Decide if hit is critical 
 	if hit > hitmax:
@@ -1690,32 +1401,32 @@ def deadkl(w, type, mv):
     # Added mv to allow enemy to "move" before dying 
     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
+    if type == 'R':
+        # 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:
+    elif type == 'T':
         # Killed a Tholian 
         game.tholian = None
-    elif type == IHQUEST:
+    elif type == '?':
         # Killed a Thingy
         global thing
         thing = None
     else:
-        # Some type of a Klingon 
-        game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons -= 1
+        # Killed some type of Klingon 
+        game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
         game.klhere -= 1
-        if type == IHC:
+        if type == 'C':
             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:
+        elif type ==  'K':
             game.state.remkl -= 1
-        elif type ==  IHS:
+        elif type ==  'S':
             game.state.nscrem -= 1
             game.state.kscmdr.invalidate()
             game.isatb = 0
@@ -1729,18 +1440,21 @@ def deadkl(w, type, mv):
     game.recompute()
     # Remove enemy ship from arrays describing local conditions
     for e in game.enemies:
-	if e.kloc == w:
+	if e.location == w:
             e.move(None)
 	    break
     return
 
 def targetcheck(w):
     "Return None if target is invalid, otherwise return a course angle."
-    if not VALID_SECTOR(w.x, w.y):
+    if not w.valid_sector():
 	huh()
 	return None
-    delta = 0.1*(w - game.sector)
-    if delta.x==0 and delta.y== 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"))
@@ -1751,7 +1465,7 @@ def targetcheck(w):
 
 def photon():
     "Launch photon torpedo."
-    course = [0.0] * MAXBURST
+    course = []
     game.ididit = False
     if damaged(DPHOTON):
 	prout(_("Photon tubes damaged."))
@@ -1764,15 +1478,15 @@ def photon():
     # First, get torpedo count
     while True:
         scanner.next()
-	if scanner.token == IHALPHA:
+	if scanner.token == "IHALPHA":
 	    huh()
 	    return
-	elif scanner.token == IHEOL or not scanner.waiting():
+	elif scanner.token == "IHEOL" or not scanner.waiting():
 	    prout(_("%d torpedoes left.") % game.torps)
             scanner.chew()
 	    proutn(_("Number of torpedoes to fire- "))
             continue	# Go back around to get a number
-	else: # key == IHREAL
+	else: # key == "IHREAL"
 	    n = scanner.int()
 	    if n <= 0: # abort command 
 		scanner.chew()
@@ -1789,24 +1503,24 @@ def photon():
     target = []
     for i in range(n):
 	key = scanner.next()
-	if i==0 and key == IHEOL:
+	if i==0 and key == "IHEOL":
 	    break;	# no coordinate waiting, we will try prompting 
-	if i==1 and key == IHEOL:
+	if i==1 and key == "IHEOL":
 	    # direct all torpedoes at one target 
 	    while i < n:
-		target.append(targets[0])
+		target.append(target[0])
 		course.append(course[0])
 		i += 1
 	    break
-        scanner.push(key)
+        scanner.push(scanner.token)
         target.append(scanner.getcoord())
         if target[-1] == None:
             return
-        course.append(targetcheck(target[1]))
-        if course[i] == None:
+        course.append(targetcheck(target[-1]))
+        if course[-1] == None:
 	    return
     scanner.chew()
-    if i == 0:
+    if len(target) == 0:
 	# prompt for each one 
 	for i in range(n):
 	    proutn(_("Target sector for torpedo number %d- ") % (i+1))
@@ -1839,8 +1553,8 @@ def photon():
 	    break
 	if game.shldup or game.condition == "docked":
 	    dispersion *= 1.0 + 0.0001*game.shield
-	torpedo(course[i], dispersion, origin=game.sector, number=i, nburst=n)
-	if game.alldone or game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
+	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 + len(game.state.kcmdr) + game.state.nscrem)==0:
 	finish(FWON);
@@ -1899,24 +1613,24 @@ def hittem(hits):
 	    continue
 	dustfac = randreal(0.9, 1.0)
 	hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
-	kpini = game.enemies[kk].kpower
+	kpini = game.enemies[kk].power
 	kp = math.fabs(kpini)
 	if PHASEFAC*hit < kp:
 	    kp = PHASEFAC*hit
-        if game.enemies[kk].kpower < 0:
-            game.enemies[kk].kpower -= -kp
+        if game.enemies[kk].power < 0:
+            game.enemies[kk].power -= -kp
         else:
-            game.enemies[kk].kpower -= kp
-	kpow = game.enemies[kk].kpower
-	w = game.enemies[kk].kloc
+            game.enemies[kk].power -= kp
+	kpow = game.enemies[kk].power
+	w = game.enemies[kk].location
 	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]
-	if ienm==IHQUEST:
+	ienm = game.quad[w.i][w.j]
+	if ienm=='?':
 	    thing.angry = True
 	proutn(crmena(False, ienm, "sector", w))
 	skip(1)
@@ -1932,7 +1646,7 @@ def hittem(hits):
 	    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.enemies[kk].kpower = -kpow
+		game.enemies[kk].power = -kpow
         kk += 1
     return
 
@@ -1970,12 +1684,12 @@ def phasers():
     # (That was Tom Almy talking about the C code, I think -- ESR)
     while automode=="NOTSET":
 	key=scanner.next()
-	if key == IHALPHA:
+	if key == "IHALPHA":
 	    if scanner.sees("manual"):
 		if len(game.enemies)==0:
 		    prout(_("There is no enemy present to select."))
 		    scanner.chew()
-		    key = IHEOL
+		    key = "IHEOL"
 		    automode="AUTOMATIC"
 		else:
 		    automode = "MANUAL"
@@ -1993,7 +1707,7 @@ def phasers():
 	    else:
 		huh()
 		return
-	elif key == IHREAL:
+	elif key == "IHREAL":
 	    if len(game.enemies)==0:
 		prout(_("Energy will be expended into space."))
 		automode = "AUTOMATIC"
@@ -2002,7 +1716,7 @@ def phasers():
 	    else:
 		automode = "AUTOMATIC"
 	else:
-	    # IHEOL 
+	    # "IHEOL" 
 	    if len(game.enemies)==0:
 		prout(_("Energy will be expended into space."))
 		automode = "AUTOMATIC"
@@ -2015,29 +1729,29 @@ def phasers():
     if ifast:
         avail -= 200.0
     if automode == "AUTOMATIC":
-	if key == IHALPHA and scanner.sees("no"):
+	if key == "IHALPHA" and scanner.sees("no"):
 	    no = True
 	    key = scanner.next()
-	if key != IHREAL and len(game.enemies) != 0:
+	if key != "IHREAL" and len(game.enemies) != 0:
 	    prout(_("Phasers locked on target. Energy available: %.2f")%avail)
 	irec=0
         while True:
 	    scanner.chew()
 	    if not kz:
 		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
+		    irec += math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
 	    kz=1
 	    proutn(_("%d units required. ") % irec)
 	    scanner.chew()
 	    proutn(_("Units to fire= "))
 	    key = scanner.next()
-	    if key!=IHREAL:
+	    if key!="IHREAL":
 		return
 	    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:
@@ -2045,7 +1759,7 @@ def phasers():
 	    scanner.chew()
 	    return
         key=scanner.next()
-	if key == IHALPHA and scanner.sees("no"):
+	if key == "IHALPHA" and scanner.sees("no"):
 	    no = True
 	if ifast:
 	    game.energy -= 200; # Go and do it! 
@@ -2061,7 +1775,7 @@ def phasers():
 		hits.append(0.0)
 		if powrem <= 0:
 		    continue
-		hits[i] = math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
+		hits[i] = math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
 		over = randreal(1.01, 1.06) * hits[i]
 		temp = powrem
 		powrem -= hits[i] + over
@@ -2084,7 +1798,7 @@ def phasers():
 		prout(_("%d expended on empty space.") % int(extra))
     elif automode == "FORCEMAN":
 	scanner.chew()
-	key = IHEOL
+	key = "IHEOL"
 	if damaged(DCOMPTR):
 	    prout(_("Battle computer damaged, manual fire only."))
 	else:
@@ -2098,25 +1812,25 @@ def phasers():
     elif automode == "MANUAL":
 	rpow = 0.0
         for k in range(len(game.enemies)):
-	    aim = game.enemies[k].kloc
-	    ienm = game.quad[aim.x][aim.y]
+	    aim = game.enemies[k].location
+	    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 game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS):
+               not game.sector.distance(aim)<2**0.5 and ienm in ('C', 'S'):
 		prout(cramen(ienm) + _(" can't be located without short range scan."))
 		scanner.chew()
-		key = IHEOL
+		key = "IHEOL"
 		hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko 
 		k += 1
 		continue
-	    if key == IHEOL:
+	    if key == "IHEOL":
 		scanner.chew()
 		if itarg and k > kz:
-		    irec=(abs(game.enemies[k].kpower)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) *	randreal(1.01, 1.06) + 1.0
+		    irec=(abs(game.enemies[k].power)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) *	randreal(1.01, 1.06) + 1.0
 		kz = k
 		proutn("(")
 		if not damaged(DCOMPTR):
@@ -2124,17 +1838,16 @@ def phasers():
 		else:
 		    proutn("??")
 		proutn(")  ")
-		proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))
-		
+		proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))		
 		key = scanner.next()
-	    if key == IHALPHA and scanner.sees("no"):
+	    if key == "IHALPHA" and scanner.sees("no"):
 		no = True
 		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
@@ -2155,7 +1868,7 @@ def phasers():
 	    # zero energy -- abort 
 	    scanner.chew()
 	    return
-	if key == IHALPHA and scanner.sees("no"):
+	if key == "IHALPHA" and scanner.sees("no"):
 	    no = True
 	game.energy -= rpow
 	scanner.chew()
@@ -2171,7 +1884,7 @@ def phasers():
     if ifast:
 	skip(1)
 	if no == 0:
-	    if withprob(0.99):
+	    if withprob(0.01):
 		prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
 		prouts(_("         CLICK   CLICK   POP  . . ."))
 		prout(_(" No response, sir!"))
@@ -2269,7 +1982,7 @@ def events():
                 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(torps_ok=False)
@@ -2283,8 +1996,8 @@ def events():
         # 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.state.chart[game.battle.i][game.battle.j].starbase = False
+            game.quad[game.base.i][game.base.j] = '.'
             game.base.invalidate()
             newcnd()
             skip(1)
@@ -2299,9 +2012,9 @@ 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
+        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 
@@ -2328,7 +2041,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
@@ -2364,7 +2077,7 @@ def events():
 	# Fix devices 
 	repair = xtime
 	if game.condition == "docked":
-	    repair /= game.docfac
+	    repair /= DOCKFAC
 	# Don't fix Deathray here 
 	for l in range(NDEVICES):
 	    if game.damage[l] > 0.0 and l != DDRAY:
@@ -2387,9 +2100,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 \
@@ -2434,14 +2147,16 @@ def events():
                 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 "foundit"
-            except "foundit":
-		# no match found -- try later 
-		schedule(FBATTAK, expran(0.3*game.intime))
-		unschedule(FCDBAS)
-		continue
+                           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]
+	    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)
@@ -2460,7 +2175,7 @@ def events():
 	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
@@ -2469,7 +2184,7 @@ def events():
 	    if evcode==FCDBAS:
 		unschedule(FCDBAS)
                 if not game.state.baseq() \
-                       or not game.state.galaxy[game.battle.x][game.battle.y].starbase:
+                       or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
 		    game.battle.invalidate()
                     continue
 		# find the lucky pair 
@@ -2487,45 +2202,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 not game.probe.next():
+		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.arrived() 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)
@@ -2536,7 +2242,7 @@ 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]
+		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):
@@ -2549,8 +2255,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") \
@@ -2561,7 +2266,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
@@ -2581,7 +2286,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
@@ -2589,14 +2294,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
@@ -2604,8 +2310,7 @@ 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
@@ -2614,7 +2319,6 @@ def events():
 		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"))
@@ -2622,7 +2326,7 @@ def events():
 		else:
 		    prout(_("Uhura- Starfleet reports increased Klingon activity"))
 		    if q.planet != None:
-			proutn(_("near %s") % q.planet)
+			proutn(_("near %s ") % q.planet)
 		    prout(_("in Quadrant %s.") % w)
 				
 def wait():
@@ -2630,11 +2334,11 @@ def wait():
     game.ididit = False
     while True:
 	key = scanner.next()
-	if key  != IHEOL:
+	if key  != "IHEOL":
 	    break
 	proutn(_("How long? "))
     scanner.chew()
-    if key != IHREAL:
+    if key != "IHREAL":
 	huh()
 	return
     origTime = delay = scanner.real
@@ -2671,30 +2375,23 @@ 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." 
     course = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
     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
-    prout(crmena(False, IHSTAR, "sector", nov) + _(" novas."))
-    game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1
+    game.quad[nov.i][nov.j] = '.'
+    prout(crmena(False, '*', "sector", nov) + _(" novas."))
+    game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
     game.state.starkl += 1
     # Set up queue to recursively trigger adjacent stars 
     hits = [nov]
@@ -2702,53 +2399,53 @@ def nova(nov):
     while hits:
         offset = coord()
         start = hits.pop()
-        for offset.x in range(-1, 1+1):
-            for offset.y in range(-1, 1+1):
-                if offset.y==0 and offset.x==0:
+        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 VALID_SECTOR(neighbor.y, neighbor.x):
+                if not neighbor.valid_sector():
                     continue
-                iquad = game.quad[neighbor.x][neighbor.y]
+                iquad = game.quad[neighbor.i][neighbor.j]
                 # Empty space ends reaction
-                if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB):
+                if iquad in ('.', '?', ' ', 'T', '#'):
                     pass
-                elif iquad == IHSTAR: # Affect another star 
+                elif iquad == '*': # Affect another star 
                     if withprob(0.05):
                         # This star supernovas 
-                        supernova(False)
+                        supernova(game.quadrant)
                         return
                     else:
                         hits.append(neighbor)
-			game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1
+			game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
 			game.state.starkl += 1
-			proutn(crmena(True, IHSTAR, "sector", neighbor))
+			proutn(crmena(True, '*', "sector", neighbor))
 			prout(_(" novas."))
-                        game.quad[neighbor.x][neighbor.y] = IHDOT
+                        game.quad[neighbor.i][neighbor.j] = '.'
                         kount += 1
-                elif iquad in (IHP, IHW): # Destroy planet 
-                    game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None
-                    if iquad == IHP:
+                elif iquad in ('P', '@'): # Destroy planet 
+                    game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
+                    if iquad == 'P':
                         game.state.nplankl += 1
                     else:
                         game.state.worldkl += 1
-                    prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
+                    prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
                     game.iplnet.pclass = "destroyed"
                     game.iplnet = None
                     game.plnet.invalidate()
                     if game.landed:
                         finish(FPNOVA)
                         return
-                    game.quad[neighbor.x][neighbor.y] = IHDOT
-                elif iquad == IHB: # Destroy base 
-                    game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase = False
+                    game.quad[neighbor.i][neighbor.j] = '.'
+                elif iquad == 'B': # 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.x][neighbor.y] = IHDOT
-                elif iquad in (IHE, IHF): # Buffet ship 
+                    prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
+                    game.quad[neighbor.i][neighbor.j] = '.'
+                elif iquad in ('E', 'F'): # Buffet ship 
                     prout(_("***Starship buffeted by nova."))
                     if game.shldup:
                         if game.shield >= 2000.0:
@@ -2767,70 +2464,69 @@ def nova(nov):
                         return
                     # add in course nova contributes to kicking starship
                     bump += (game.sector-hits[mm]).sgn()
-                elif iquad == IHK: # kill klingon 
+                elif iquad == 'K': # kill klingon 
                     deadkl(neighbor, iquad, neighbor)
-                elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies 
+                elif iquad in ('C','S','R'): # Damage/destroy big enemies 
                     for ll in range(len(game.enemies)):
-                        if game.enemies[ll].kloc == neighbor:
+                        if game.enemies[ll].location == neighbor:
                             break
-                    game.enemies[ll].kpower -= 800.0 # If firepower is lost, die 
-                    if game.enemies[ll].kpower <= 0.0:
+                    game.enemies[ll].power -= 800.0 # If firepower is lost, die 
+                    if game.enemies[ll].power <= 0.0:
                         deadkl(neighbor, iquad, neighbor)
                         break
                     newc = neighbor + neighbor - hits[mm]
                     proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
-                    if not VALID_SECTOR(newc.x, newc.y):
+                    if not newc.valid_sector():
                         # 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))
+                    iquad1 = game.quad[newc.i][newc.j]
+                    if iquad1 == ' ':
+                        proutn(_(", blasted into ") + crmena(False, ' ', "sector", newc))
                         skip(1)
                         deadkl(neighbor, iquad, newc)
                         break
-                    if iquad1 != IHDOT:
+                    if iquad1 != '.':
                         # can't move into something else 
                         skip(1)
                         break
                     proutn(_(", buffeted to Sector %s") % newc)
-                    game.quad[neighbor.x][neighbor.y] = IHDOT
-                    game.quad[newc.x][newc.y] = iquad
+                    game.quad[neighbor.i][neighbor.j] = '.'
+                    game.quad[newc.i][newc.j] = iquad
                     game.enemies[ll].move(newc)
     # Starship affected by nova -- kick it away. 
-    game.dist = kount*0.1
-    game.direc = course[3*(bump.x+1)+bump.y+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(novapush=True)
-    game.optime = 10.0*game.dist/16.0
+    imove(course, noattack=True)
+    game.optime = course.time(warp=4)
     return
 	
-def supernova(induced, w=None):
+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(GALSIZE):
-	    for nq.y in range(GALSIZE):
-		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 = randrange(stars) + 1
-	for nq.x in range(GALSIZE):
-	    for nq.y in range(GALSIZE):
-		num -= game.state.galaxy[nq.x][nq.y].stars
+	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:
@@ -2848,10 +2544,10 @@ def supernova(induced, w=None):
     else:
 	ns = coord()
 	# we are in the quadrant! 
-	num = randrange(game.state.galaxy[nq.x][nq.y].stars) + 1
-	for ns.x in range(QUADSIZE):
-	    for ns.y in range(QUADSIZE):
-		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]=='*':
 		    num -= 1
 		    if num==0:
 			break
@@ -2861,18 +2557,18 @@ def supernova(induced, w=None):
 	prouts(_("***RED ALERT!  RED ALERT!"))
 	skip(1)
 	prout(_("***Incipient supernova detected at Sector %s") % ns)
-	if (ns.x-game.sector.x)**2 + (ns.y-game.sector.y)**2 <= 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)
@@ -2884,8 +2580,8 @@ def supernova(induced, w=None):
         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):
@@ -2895,17 +2591,17 @@ def supernova(induced, w=None):
     # 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 + 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)
@@ -2958,7 +2654,7 @@ def selfdestruct():
 
 def kaboom():
     stars()
-    if game.ship==IHE:
+    if game.ship=='E':
 	prouts("***")
     prouts(_("********* Entropy of %s maximized *********") % crmshp())
     skip(1)
@@ -2968,8 +2664,8 @@ def kaboom():
 	whammo = 25.0 * game.energy
 	l=1
 	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.x][game.enemies[l].kloc.y], game.enemies[l].kloc)
+	    if game.enemies[l].power*game.enemies[l].kdist <= whammo: 
+		deadkl(game.enemies[l].location, game.quad[game.enemies[l].location.i][game.enemies[l].location.j], game.enemies[l].location)
 	    l += 1
     finish(FDILITHIUM)
 				
@@ -2992,7 +2688,7 @@ def badpoints():
             45.0*game.nhelp +\
             100.0*game.state.basekl +\
             3.0*game.abandoned
-    if game.ship == IHF:
+    if game.ship == 'F':
         badpt += 100.0
     elif game.ship == None:
         badpt += 200.0
@@ -3164,10 +2860,10 @@ def finish(ifin):
 	prout(_("You are crushed into extremely dense matter."))
     elif ifin == FCREW:
 	prout(_("Your last crew member has died."))
-    if game.ship == IHF:
+    if game.ship == 'F':
 	game.ship = None
-    elif game.ship == IHE:
-	game.ship = IHF
+    elif game.ship == 'E':
+	game.ship = 'F'
     game.alive = False
     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
 	goodies = game.state.remres/game.inresor
@@ -3202,14 +2898,12 @@ def score():
     iwon = 0
     if game.gamewon:
 	iwon = 100*game.skill
-    if game.ship == IHE: 
+    if game.ship == 'E': 
 	klship = 0
-    elif game.ship == IHF: 
+    elif game.ship == 'F': 
 	klship = 1
     else:
 	klship = 2
-    if not game.gamewon:
-	game.state.nromrem = 0 # None captured if no win
     iscore = 10*(game.inkling - game.state.remkl) \
              + 50*(game.incom - len(game.state.kcmdr)) \
              + ithperd + iwon \
@@ -3224,7 +2918,7 @@ def score():
     if game.inrom - game.state.nromrem:
 	prout(_("%6d Romulans destroyed                 %5d") %
 	      (game.inrom - game.state.nromrem, 20*(game.inrom - game.state.nromrem)))
-    if game.state.nromrem:
+    if game.state.nromrem and game.gamewon:
 	prout(_("%6d Romulans captured                  %5d") %
 	      (game.state.nromrem, game.state.nromrem))
     if game.inkling - game.state.remkl:
@@ -3247,7 +2941,7 @@ def score():
 	      (game.state.nplankl, -10*game.state.nplankl))
     if (game.options & OPTION_WORLDS) and game.state.nworldkl:
 	prout(_("%6d inhabited planets destroyed by your action   %5d") %
-	      (game.state.nplankl, -300*game.state.nworldkl))
+	      (game.state.nworldkl, -300*game.state.nworldkl))
     if game.state.basekl:
 	prout(_("%6d bases destroyed by your action     %5d") %
 	      (game.state.basekl, -100*game.state.basekl))
@@ -3327,7 +3021,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)
@@ -3348,27 +3042,10 @@ message_window    = None
 prompt_window     = None
 curwnd = 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()
-	sys.stdout.write('\n')
-    if logfp:
-	logfp.close()
-
 def iostart():
     global stdscr, rows
-    #setlocale(LC_ALL, "")
-    #bindtextdomain(PACKAGE, LOCALEDIR)
-    #textdomain(PACKAGE)
-    if atexit.register(outro):
-	sys.stderr.write("Unable to register outro(), exiting...\n")
-	raise SysExit,1
+    gettext.bindtextdomain("sst", "/usr/local/share/locale")
+    gettext.textdomain("sst")
     if not (game.options & OPTION_CURSES):
 	ln_env = os.getenv("LINES")
         if ln_env:
@@ -3378,19 +3055,8 @@ 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()
@@ -3403,24 +3069,23 @@ def iostart():
 	prompt_window     = curses.newwin(1,  0,  rows-2,  0) 
 	message_window.scrollok(True)
 	setwnd(fullscreen_window)
-	textcolor(DEFAULT)
-
-def textcolor(color):
-    "Set text foreground color.  Presently a stub."
-    pass	# FIXME
 
 def ioend():
-    "Wrap up I/O.  Presently a stub."
-    pass
+    "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"
     if game.options & OPTION_CURSES:
-	stsdcr.getch()
+	stdscr.getch()
 
 def announce():
     skip(1)
-    prouts(_("[ANOUNCEMENT ARRIVING...]"))
+    prouts(_("[ANNOUNCEMENT ARRIVING...]"))
     skip(1)
 
 def pause_game():
@@ -3432,7 +3097,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()
@@ -3457,7 +3122,10 @@ def skip(i):
 		pause_game()
 		clrscr()
 	    else:
-		proutn("\n")
+                try:
+                    curwnd.move(y+1, 0)
+                except curses.error:
+                    pass
 	else:
             global linecount
 	    linecount += 1
@@ -3486,7 +3154,7 @@ def prouts(line):
             time.sleep(0.03)
 	proutn(c)
 	if game.options & OPTION_CURSES:
-	    wrefresh(curwnd)
+	    curwnd.refresh()
 	else:
 	    sys.stdout.flush()
     if not replayfp or replayfp.closed:
@@ -3524,8 +3192,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."
@@ -3536,11 +3204,6 @@ def clrscr():
        curwnd.refresh()
     linecount = 0
     
-def highvideo():
-    "Set highlight video, if this is reasonable."
-    if game.options & OPTION_CURSES:
-	curwnd.attron(curses.A_REVERSE)
- 
 #
 # Things past this point have policy implications.
 # 
@@ -3568,7 +3231,7 @@ def drawmaps(mode):
 
 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()
 
@@ -3578,12 +3241,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)
 	#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) 
 
@@ -3605,7 +3268,7 @@ def tracktorpedo(origin, w, step, i, n, iquad):
 	if step == 1:
 	    if n != 1:
 		skip(1)
-		proutn(_("Track for %s torpedo number %d-  ") % (game.quad[origin.x][origin.y],i+1))
+		proutn(_("Track for torpedo number %d-  ") % (i+1))
 	    else:
 		skip(1)
 		proutn(_("Torpedo track- "))
@@ -3617,7 +3280,7 @@ def tracktorpedo(origin, w, step, i, n, iquad):
 	    if i != 0 and step == 1:
 		drawmaps(2)
 		time.sleep(0.4)
-	    if (iquad==IHDOT) or (iquad==IHBLANK):
+	    if (iquad=='.') or (iquad==' '):
 		put_srscan_sym(w, '+')
 		#sound(step*10)
 		#time.sleep(0.1)
@@ -3659,180 +3322,151 @@ def prstat(txt, data):
 
 # Code from moving.c begins here
 
-def imove(novapush):
+def imove(course=None, noattack=False):
     "Movement execution for warp, impulse, supernova, and tractor-beam events."
-    w = coord(); final = coord()
-    trbeam = False
+    w = coord()
 
-    def no_quad_change():
-        # No quadrant change -- compute new average enemy distances 
-        game.quad[game.sector.x][game.sector.y] = game.ship
-        if game.enemies:
+    def newquadrant(noattack):
+        # Leaving quadrant -- allow final enemy attack 
+        # Don't do it if being pushed by Nova 
+        if len(game.enemies) != 0 and not noattack:
+            newcnd()
             for enemy in game.enemies:
-                finald = (w-enemy.kloc).distance()
+                finald = (w - enemy.location).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.x][game.quadrant.y].supernova:
+            # 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.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
+            if game.alldone:
+                return
+        # check for edge of galaxy 
+        kinks = 0
+        while True:
+            kink = False
+            if course.final.i < 0:
+                course.final.i = -course.final.i
+                kink = True
+            if course.final.j < 0:
+                course.final.j = -course.final.j
+                kink = True
+            if course.final.i >= GALSIZE*QUADSIZE:
+                course.final.i = (GALSIZE*QUADSIZE*2) - course.final.i
+                kink = True
+            if course.final.j >= GALSIZE*QUADSIZE:
+                course.final.j = (GALSIZE*QUADSIZE*2) - course.final.j
+                kink = True
+            if kink:
+                kinks += 1
+            else:
+                break
+        if kinks:
+            game.nkinks += 1
+            if game.nkinks == 3:
+                # Three strikes -- you're out! 
+                finish(FNEG3)
+                return
+            skip(1)
+            prout(_("YOU HAVE ATTEMPTED TO CROSS THE NEGATIVE ENERGY BARRIER"))
+            prout(_("AT THE EDGE OF THE GALAXY.  THE THIRD TIME YOU TRY THIS,"))
+            prout(_("YOU WILL BE DESTROYED."))
+        # Compute final position in new quadrant 
+        if trbeam: # Don't bother if we are to be beamed 
+            return
+        game.quadrant = course.final.quadrant()
+        game.sector = course.final.sector()
+        skip(1)
+        prout(_("Entering Quadrant %s.") % game.quadrant)
+        game.quad[game.sector.i][game.sector.j] = game.ship
+        newqad()
+        if game.skill>SKILL_NOVICE:
+            attack(torps_ok=False)  
+
+    def check_collision(h):
+        iquad = game.quad[h.i][h.j]
+        if iquad != '.':
+            # object encountered in flight path 
+            stopegy = 50.0*course.distance/game.optime
+            if iquad in ('T', 'K', 'C', 'S', 'R', '?'):
+                for enemy in game.enemies:
+                    if enemy.location == game.sector:
+                        break
+                collision(rammed=False, enemy=enemy)
+                return True
+            elif iquad == ' ':
+                skip(1)
+                prouts(_("***RED ALERT!  RED ALERT!"))
+                skip(1)
+                proutn("***" + crmshp())
+                proutn(_(" pulled into black hole at Sector %s") % h)
+                # 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(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 withprob(1-probf): 
+                    timwrp()
+                else: 
+                    finish(FHOLE)
+                return True
+            else:
+                # something else 
+                skip(1)
+                proutn(crmshp())
+                if iquad == '#':
+                    prout(_(" encounters Tholian web at %s;") % h)
+                else:
+                    prout(_(" blocked by object at %s;") % h)
+                proutn(_("Emergency stop required "))
+                prout(_("%2d units of energy.") % int(stopegy))
+                game.energy -= stopegy
+                if game.energy <= 0:
+                    finish(FNRG)
+                return True
+        return False
+
+    trbeam = False
     if game.inorbit:
 	prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
 	game.inorbit = False
-    angle = ((15.0 - game.direc) * 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 = int(10.0*game.dist*bigger+0.5)
-    if n > 0:
-	for m in range(1, n+1):
-            x += deltax
-            y += deltay
-	    w.x = int(round(x))
-	    w.y = int(round(y))
-	    if not VALID_SECTOR(w.x, w.y):
-		# Leaving quadrant -- allow final enemy attack 
-		# Don't do it if being pushed by Nova 
-		if len(game.enemies) != 0 and not novapush:
-		    newcnd()
-		    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(torps_ok=False)
-		    if game.alldone:
-			return
-		# compute final position -- new quadrant and sector 
-		x = (QUADSIZE*game.quadrant.x)+game.sector.x
-		y = (QUADSIZE*game.quadrant.y)+game.sector.y
-		w.x = int(round(x+10.0*game.dist*bigger*deltax))
-		w.y = int(round(y+10.0*game.dist*bigger*deltay))
-		# check for edge of galaxy 
-		kinks = 0
-                while True:
-		    kink = False
-		    if w.x < 0:
-			w.x = -w.x
-			kink = True
-		    if w.y < 0:
-			w.y = -w.y
-			kink = True
-		    if w.x >= GALSIZE*QUADSIZE:
-			w.x = (GALSIZE*QUADSIZE*2) - w.x
-			kink = True
-		    if w.y >= GALSIZE*QUADSIZE:
-			w.y = (GALSIZE*QUADSIZE*2) - w.y
-			kink = True
-		    if kink:
-			kinks += 1
-                    else:
-                        break
-		if kinks:
-		    game.nkinks += 1
-		    if game.nkinks == 3:
-			# Three strikes -- you're out! 
-			finish(FNEG3)
-			return
-		    skip(1)
-		    prout(_("YOU HAVE ATTEMPTED TO CROSS THE NEGATIVE ENERGY BARRIER"))
-		    prout(_("AT THE EDGE OF THE GALAXY.  THE THIRD TIME YOU TRY THIS,"))
-		    prout(_("YOU WILL BE DESTROYED."))
-		# Compute final position in new quadrant 
-		if trbeam: # Don't bother if we are to be beamed 
-		    return
-		game.quadrant.x = w.x/QUADSIZE
-		game.quadrant.y = w.y/QUADSIZE
-		game.sector.x = w.x - (QUADSIZE*game.quadrant.x)
-		game.sector.y = w.y - (QUADSIZE*game.quadrant.y)
-		skip(1)
-		prout(_("Entering Quadrant %s.") % game.quadrant)
-		game.quad[game.sector.x][game.sector.y] = game.ship
-		newqad(False)
-		if game.skill>SKILL_NOVICE:
-		    attack(torps_ok=False)  
-		return
-	    iquad = game.quad[w.x][w.y]
-	    if iquad != IHDOT:
-		# object encountered in flight path 
-		stopegy = 50.0*game.dist/game.optime
-		game.dist = (game.sector - w).distance() / (QUADSIZE * 1.0)
-                if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST):
-		    game.sector = w
-                    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(_(" 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(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 withprob(1-probf): 
-			timwrp()
-		    else: 
-			finish(FHOLE)
-		    return
-		else:
-		    # something else 
-		    skip(1)
-		    proutn(crmshp())
-		    if iquad == IHWEB:
-			prout(_(" encounters Tholian web at %s;") % w)
-		    else:
-			prout(_(" blocked by object at %s;") % w)
-		    proutn(_("Emergency stop required "))
-		    prout(_("%2d units of energy.") % int(stopegy))
-		    game.energy -= stopegy
-		    final.x = int(round(deltax))
-		    final.y = int(round(deltay))
-		    game.sector = final
-		    if game.energy <= 0:
-			finish(FNRG)
-			return
-                # We're here!
-		no_quad_change()
-                return
-	game.dist = (game.sector - w).distance() / (QUADSIZE * 1.0)
-	game.sector = w
-    final = game.sector
-    no_quad_change()
+    # Move out
+    game.quad[game.sector.i][game.sector.j] = '.'
+    for m in range(course.moves):
+        course.next()
+        w = course.sector()
+        if course.origin.quadrant() != course.location.quadrant():
+            newquadrant(noattack)
+            break
+        elif check_collision(w):
+            print "Collision detected"
+            break
+        else:
+            game.sector = w
+    # We're in destination quadrant -- 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.location).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)
     return
 
 def dock(verbose):
@@ -3844,7 +3478,7 @@ def dock(verbose):
     if game.inorbit:
 	prout(_("You must first leave standard orbit."))
 	return
-    if not game.base.is_valid() or abs(game.sector.x-game.base.x) > 1 or abs(game.sector.y-game.base.y) > 1:
+    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"
@@ -3863,16 +3497,16 @@ 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
-# "manual" input should still be done this way -- it's a real
-# 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 getcourse(isprobe, akey):
+
+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)
@@ -3884,7 +3518,7 @@ def getcourse(isprobe, akey):
 	prout(_("Dummy! You can't leave standard orbit until you"))
 	proutn(_("are back aboard the ship."))
 	scanner.chew()
-	return False
+	raise TrekError
     while navmode == "unspecified":
 	if damaged(DNAVSYS):
 	    if isprobe:
@@ -3893,19 +3527,14 @@ def getcourse(isprobe, akey):
 		prout(_("Computer damaged; manual movement only"))
 	    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 = scanner.next()
-	if key == IHEOL:
+        key = scanner.next()
+	if key == "IHEOL":
 	    proutn(_("Manual or automatic- "))
 	    iprompt = True
 	    scanner.chew()
-	elif key == IHALPHA:
+	elif key == "IHALPHA":
             if scanner.sees("manual"):
 		navmode = "manual"
 		key = scanner.next()
@@ -3917,7 +3546,7 @@ def getcourse(isprobe, akey):
 	    else:
 		huh()
 		scanner.chew()
-		return False
+		raise TrekError
 	else: # numeric 
 	    if isprobe:
 		prout(_("(Manual navigation assumed.)"))
@@ -3925,8 +3554,9 @@ def getcourse(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:
@@ -3934,43 +3564,43 @@ def getcourse(isprobe, akey):
 	    scanner.chew()
 	    iprompt = True
 	    key = scanner.next()
-	if key != IHREAL:
+	if key != "IHREAL":
 	    huh()
-	    return False
+	    raise TrekError
 	xi = int(round(scanner.real))-1
 	key = scanner.next()
-	if key != IHREAL:
+	if key != "IHREAL":
 	    huh()
-	    return False
+	    raise TrekError
 	xj = int(round(scanner.real))-1
 	key = scanner.next()
-	if key == IHREAL:
+	if key == "IHREAL":
 	    # both quadrant and sector specified 
 	    xk = int(round(scanner.real))-1
 	    key = scanner.next()
-	    if key != IHREAL:
+	    if key != "IHREAL":
 		huh()
-		return False
+		raise TrekError
 	    xl = int(round(scanner.real))-1
-	    dquad.x = xi
-	    dquad.y = xj
-	    dsect.y = xk
-	    dsect.x = xl
+	    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 
-		dquad.x = xi
-		dquad.y = xj
-		dsect.y = dsect.x = 4	# preserves 1-origin behavior
+		dquad.i = xi
+		dquad.j = xj
+		dsect.j = dsect.i = 4	# preserves 1-origin behavior
 	    else:
                 # only sector specified
-		dsect.y = xi
-		dsect.x = xj
+		dsect.i = xi
+		dsect.j = xj
 	    itemp = "normal"
-	if not VALID_QUADRANT(dquad.y,dquad.x) or not VALID_SECTOR(dsect.x,dsect.y):
+	if not dquad.valid_quadrant() or not dsect.valid_sector():
 	    huh()
-	    return False
+	    raise TrekError
 	skip(1)
 	if not isprobe:
 	    if itemp > "curt":
@@ -3979,39 +3609,77 @@ def getcourse(isprobe, akey):
 	    else:
 		prout(_("Ensign Chekov- \"Course laid in, Captain.\""))
         # the actual deltas get computed here
-        delta = coord()
-	delta.x = dquad.y-game.quadrant.y + 0.1*(dsect.x-game.sector.y)
-	delta.y = game.quadrant.x-dquad.x + 0.1*(game.sector.x-dsect.y)
+	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- "))
 	    scanner.chew()
 	    iprompt = True
 	    key = scanner.next()
 	itemp = "verbose"
-	if key != IHREAL:
+	if key != "IHREAL":
 	    huh()
-	    return False
-	delta.x = scanner.real
+	    raise TrekError
+	delta.j = scanner.real
 	key = scanner.next()
-	if key != IHREAL:
+	if key != "IHREAL":
 	    huh()
-	    return False
-	delta.y = scanner.real
+	    raise TrekError
+	delta.i = scanner.real
     # Check for zero movement 
-    if delta.x == 0 and delta.y == 0:
+    if delta.i == 0 and delta.j == 0:
 	scanner.chew()
-	return False
+	raise TrekError
     if itemp == "verbose" and not isprobe:
 	skip(1)
 	prout(_("Helmsman Sulu- \"Aye, Sir.\""))
-    # Course actually laid in.
-    game.dist = delta.distance()
-    game.direc = delta.bearing()
-    if game.direc < 0.0:
-	game.direc += 12.0
     scanner.chew()
-    return True
+    return course(bearing=delta.bearing(), distance=delta.distance())
+
+class course:
+    def __init__(self, bearing, distance, origin=None): 
+        self.distance = distance
+        self.bearing = bearing
+        if origin is None:
+            self.origin = cartesian(game.quadrant, game.sector)
+        else:
+            self.origin = origin
+        # 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.origin = cartesian(game.quadrant, game.sector)
+        else:
+            self.origin = 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 = int(round(10*self.distance*bigger))
+        self.reset()
+        self.final = (self.location + self.moves*self.increment).roundtogrid()
+    def reset(self):
+        self.location = self.origin
+        self.step = 0
+    def arrived(self):
+        return self.location.roundtogrid() == self.final
+    def next(self):
+        "Next step on course."
+        self.step += 1
+        self.nextlocation = self.location + self.increment
+        samequad = (self.location.quadrant() == self.nextlocation.quadrant())
+        self.location = self.nextlocation
+        return samequad
+    def quadrant(self):
+        return self.location.quadrant()
+    def sector(self):
+        return self.location.sector()
+    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."
@@ -4022,9 +3690,11 @@ def impulse():
 	prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\""))
 	return
     if game.energy > 30.0:
-        if not getcourse(isprobe=False, akey=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:
@@ -4041,7 +3711,7 @@ def impulse():
 	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"))
@@ -4049,26 +3719,26 @@ def impulse():
 	if ja() == False:
 	    return
     # Activate impulse engines and pay the cost 
-    imove(novapush=False)
+    imove(course, noattack=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):
+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:
 	    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:
 	    scanner.chew()
@@ -4076,18 +3746,22 @@ def warp(timewarp):
 	    prout(_("Engineer Scott- \"Sorry, Captain. Until this damage"))
 	    prout(_("  is repaired, I can only give you warp 4.\""))
 	    return
-       	# Read in course and distance 
-        if not getcourse(isprobe=False, akey=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:
@@ -4099,10 +3773,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"))
@@ -4118,12 +3791,12 @@ def warp(timewarp):
     if game.warpfac > 6.0:
 	# Decide if engine damage will occur
         # ESR: Seems wrong. Probability of damage goes *down* with distance? 
-	prob = game.dist*(6.0-game.warpfac)**2/66.666666666
+	prob = course.distance*(6.0-game.warpfac)**2/66.666666666
 	if prob > randreal():
 	    blooey = True
-	    game.dist = randreal(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) > randreal():
+	if 0.5*course.distance*math.pow(7.0,game.warpfac-10.0) > randreal():
 	    twarp = True
 	if idebug and game.warpfac==10 and not twarp:
 	    blooey = False
@@ -4133,36 +3806,23 @@ 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)
-	    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
-	    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):
-		    break
-		if game.quad[ix][iy] != IHDOT:
+            for m in range(course.moves):
+                course.next()
+                w = course.sector()
+                if not w.valid_sector():
+                    break
+		if game.quad[w.i][w.j] != '.':
 		    blooey = False
 		    twarp = False
+            course.reset()
     # Activate Warp Engines and pay the cost 
-    imove(novapush=False)
+    imove(course, noattack=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:
@@ -4178,12 +3838,12 @@ def setwarp():
     "Change the warp factor."
     while True:
         key=scanner.next()
-        if key != IHEOL:
+        if key != "IHEOL":
             break
 	scanner.chew()
 	proutn(_("Warp factor- "))
     scanner.chew()
-    if key != IHREAL:
+    if key != "IHREAL":
 	huh()
 	return
     if game.damage[DWARPEN] > 10.0:
@@ -4201,7 +3861,6 @@ def setwarp():
 	return
     oldfac = game.warpfac
     game.warpfac = scanner.real
-    game.wfacsq=game.warpfac*game.warpfac
     if game.warpfac <= oldfac or game.warpfac <= 6.0:
 	prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") %
 	       int(game.warpfac))
@@ -4258,10 +3917,9 @@ def atover(igrab):
 	    prouts(_("   a supernova."))
 	    skip(2)
 	prout(_("***Emergency automatic override attempts to hurl ")+crmshp())
-	skip(1)
 	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)
@@ -4269,18 +3927,15 @@ def atover(igrab):
 	    finish(FSNOVAED)
 	    return
 	game.warpfac = randreal(6.0, 8.0)
-	game.wfacsq = game.warpfac * game.warpfac
 	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 = randreal(math.sqrt(2))
-	if distreq < game.dist:
-	    game.dist = distreq
-	game.optime = 10.0*game.dist/game.wfacsq
-	game.direc = randreal(12)	# How dumb! 
+	dist = power/(game.warpfac*game.warpfac*game.warpfac*(game.shldup+1))
+	dist = max(dist, randreal(math.sqrt(2)))
+        bugout = course(bearing=randreal(12), distance=dist)	# How dumb!
+	game.optime = bugout.time(game.warpfac)
 	game.justin = False
 	game.inorbit = False
-	warp(True)
+	warp(bugout, involuntary=True)
 	if not game.justin:
 	    # This is bad news, we didn't leave quadrant. 
 	    if game.alldone:
@@ -4290,7 +3945,7 @@ 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 + len(game.state.kcmdr) + game.state.nscrem)==0: 
 	finish(FWON) # Snova killed remaining enemy. 
@@ -4317,32 +3972,31 @@ def timwrp():
 	unschedule(FCDBAS)
 	unschedule(FSCDBAS)
 	game.battle.invalidate()
-
 	# Make sure Galileo is consistant -- Snapshot may have been taken
         # when on planet, which would give us two Galileos! 
 	gotit = False
 	for l in range(game.inplan):
 	    if game.state.planets[l].known == "shuttle_down":
 		gotit = True
-		if game.iscraft == "onship" and game.ship==IHE:
+		if game.iscraft == "onship" and game.ship=='E':
 		    prout(_("Chekov-  \"Security reports the Galileo has disappeared, Sir!"))
 		    game.iscraft = "offship"
 	# Likewise, if in the original time the Galileo was abandoned, but
 	# was on ship earlier, it would have vanished -- let's restore it.
 	if game.iscraft == "offship" and not gotit and game.damage[DSHUTTL] >= 0.0:
-	    prout(_("Checkov-  \"Security reports the Galileo has reappeared in the dock!\""))
+	    prout(_("Chekov-  \"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.
 	prout(_("Spock has reconstructed a correct star chart from memory"))
     else:
 	# Go forward in time 
-	game.optime = -0.5*game.intime*math.log(randreal())
+	game.optime = expran(0.5*game.intime)
 	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():
@@ -4351,7 +4005,7 @@ def probe():
     if game.nprobes == 0:
 	scanner.chew()
 	skip(1)
-	if game.ship == IHE: 
+	if game.ship == 'E': 
 	    prout(_("Engineer Scott- \"We have no more deep space probes, Sir.\""))
 	else:
 	    prout(_("Ye Faerie Queene has no deep space probes."))
@@ -4371,8 +4025,7 @@ def probe():
 	    prout(_("Uhura- \"The previous probe is still reporting data, Sir.\""))
 	return
     key = scanner.next()
-    if key == IHEOL:
-	# slow mode, so let Kirk know how many probes there are left
+    if key == "IHEOL":
         if game.nprobes == 1:
             prout(_("1 probe left."))
         else:
@@ -4381,50 +4034,24 @@ def probe():
 	if ja() == False:
 	    return
     game.isarmed = False
-    if key == IHALPHA and scanner.token == "armed":
+    if key == "IHALPHA" and scanner.token == "armed":
 	game.isarmed = True
 	key = scanner.next()
-    elif key == IHEOL:
+    elif key == "IHEOL":
 	proutn(_("Arm NOVAMAX warhead? "))
 	game.isarmed = ja()
-    if not getcourse(isprobe=True, akey=key):
-	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."
     # There's more than one way to move in this game! 
@@ -4444,7 +4071,7 @@ def mayday():
 	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 = (game.base - game.sector).distance()
     else:
@@ -4455,15 +4082,15 @@ def mayday():
 		ddist = xdist
 	# Since starbase not in quadrant, set up new quadrant 
 	game.quadrant = ibq
-	newqad(True)
+	newqad()
     # dematerialize starship 
-    game.quad[game.sector.x][game.sector.y]=IHDOT
+    game.quad[game.sector.i][game.sector.j]='.'
     proutn(_("Starbase in Quadrant %s responds--%s dematerializes") \
            % (game.quadrant, crmshp()))
     game.sector.invalidate()
     for m in range(1, 5+1):
         w = game.base.scatter() 
-	if VALID_SECTOR(w.x,w.y) and game.quad[w.x][w.y]==IHDOT:
+	if w.valid_sector() and game.quad[w.i][w.j]=='.':
 	    # found one -- finish up 
             game.sector = w
 	    break
@@ -4478,52 +4105,30 @@ def mayday():
 	elif m == 2: proutn(_("2nd"))
 	elif m == 3: proutn(_("3rd"))
 	proutn(_(" attempt to re-materialize ") + crmshp())
-	game.quad[ix][iy]=(IHMATER0,IHMATER1,IHMATER2)[m-1]
-	textcolor("red")
+	game.quad[ix][iy]=('-','o','O')[m-1]
 	warble()
 	if randreal() > probf:
 	    break
 	prout(_("fails."))
 	curses.delay_output(500)
-	textcolor(None)
     if m > 3:
-	game.quad[ix][iy]=IHQUEST
+	game.quad[ix][iy]='?'
 	game.alive = False
 	drawmaps(1)
 	setwnd(message_window)
 	finish(FMATERIALIZE)
 	return
     game.quad[ix][iy]=game.ship
-    textcolor("green")
     prout(_("succeeds."))
-    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."
     scanner.chew()
     if game.condition=="docked":
-	if game.ship!=IHE:
+	if game.ship!='E':
 	    prout(_("You cannot abandon Ye Faerie Queene."))
 	    return
     else:
@@ -4554,7 +4159,7 @@ def abandon():
 	    # 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"))
@@ -4577,23 +4182,23 @@ def abandon():
 	# 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
+	    game.quad[game.sector.i][game.sector.j] = '.'
 	    for l in range(QUADSIZE):
 		game.sector = game.base.scatter()
-		if VALID_SECTOR(game.sector.x, game.sector.y) and \
-                       game.quad[game.sector.x][game.sector.y] == IHDOT:
+		if game.sector.valid_sector() and \
+                       game.quad[game.sector.i][game.sector.j] == '.':
                     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 = 'F'
     game.state.crew = FULLCREW
     prout(_("Starfleet puts you in command of another ship,"))
     prout(_("the Faerie Queene, which is antiquated but,"))
@@ -4613,7 +4218,6 @@ 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.
@@ -4622,7 +4226,7 @@ def consumeTime():
     "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
 
@@ -4667,7 +4271,7 @@ def orbit():
     if not game.plnet.is_valid():
         prout("There is no planet in this sector.")
         return
-    if abs(game.sector.x-game.plnet.x)>1 or abs(game.sector.y-game.plnet.y)>1:
+    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
@@ -4977,7 +4581,7 @@ def deathray():
     game.ididit = False
     skip(1)
     scanner.chew()
-    if game.ship != IHE:
+    if game.ship != 'E':
 	prout(_("Ye Faerie Queene has no death ray."))
 	return
     if len(game.enemies)==0:
@@ -5013,7 +4617,7 @@ def deathray():
 	prouts(_("Sulu- \"Captain!  It's working!\""))
 	skip(2)
 	while len(game.enemies) > 0:
-	    deadkl(game.enemies[1].kloc, game.quad[game.enemies[1].kloc.x][game.enemies[1].kloc.y],game.enemies[1].kloc)
+	    deadkl(game.enemies[1].location, game.quad[game.enemies[1].location.i][game.enemies[1].location.j],game.enemies[1].location)
 	prout(_("Ensign Chekov-  \"Congratulations, Captain!\""))
 	if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
 	    finish(FWON)    
@@ -5061,8 +4665,8 @@ def deathray():
 	prout(_(" Mr. Sulu."))
 	for i in range(QUADSIZE):
 	    for j in range(QUADSIZE):
-		if game.quad[i][j] == IHDOT:
-		    game.quad[i][j] = IHQUEST
+		if game.quad[i][j] == '.':
+		    game.quad[i][j] = '?'
 	prout(_("  Captain, our quadrant is now infested with"))
 	prouts(_(" - - - - - -  *THINGS*."))
 	skip(1)
@@ -5136,7 +4740,7 @@ def report():
 	prout(_("%d casualt%s suffered so far.") % (game.casual, ("y", "ies")[game.casual!=1]))
     if game.nhelp:
 	prout(_("There were %d call%s for help.") % (game.nhelp,  ("" , _("s"))[game.nhelp!=1]))
-    if game.ship == IHE:
+    if game.ship == 'E':
 	proutn(_("You have "))
 	if game.nprobes:
 	    proutn("%d" % (game.nprobes))
@@ -5177,11 +4781,11 @@ def lrscan(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):
+    for x in range(game.quadrant.i-1, game.quadrant.i+2):
         if not silent:
             proutn(" ")
-        for y in range(game.quadrant.y-1, game.quadrant.y+2):
-	    if not VALID_QUADRANT(x, y):
+        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:
@@ -5200,7 +4804,6 @@ def damagereport():
     "Damage report."
     jdam = False
     scanner.chew()
-
     for i in range(NDEVICES):
 	if damaged(i):
 	    if not jdam:
@@ -5209,7 +4812,7 @@ def damagereport():
 		jdam = True
 	    prout("  %-26s\t%8.2f\t\t%8.2f" % (device[i],
                                                game.damage[i]+0.05,
-                                               game.docfac*game.damage[i]+0.005))
+                                               DOCKFAC*game.damage[i]+0.005))
     if not jdam:
 	prout(_("All devices functional."))
 
@@ -5240,7 +4843,7 @@ def chart():
     for i in range(GALSIZE):
 	proutn("%d |" % (i+1))
 	for j in range(GALSIZE):
-	    if (game.options & OPTION_SHOWME) and i == game.quadrant.x and j == game.quadrant.y:
+	    if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j:
 		proutn("<")
 	    else:
 		proutn(" ")
@@ -5253,7 +4856,7 @@ def chart():
 	    else:
 		show = "..."
 	    proutn(show)
-	    if (game.options & OPTION_SHOWME) and i == game.quadrant.x and j == game.quadrant.y:
+	    if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j:
 		proutn(">")
 	    else:
 		proutn(" ")
@@ -5263,17 +4866,8 @@ def chart():
 
 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):
-	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.quad[i][j] != game.ship: 
-		highvideo()
+    if goodScan or (abs(i-game.sector.i)<= 1 and abs(j-game.sector.j) <= 1):
 	proutn("%c " % game.quad[i][j])
-	textcolor(None)
     else:
 	proutn("- ")
 
@@ -5285,11 +4879,8 @@ def status(req=0):
     if not req or req == 2:
 	if game.condition != "docked":
 	    newcnd()
-        dam = 0
-	for t in range(NDEVICES):
-	    if game.damage[t]>0: 
-		dam += 1
-	prstat(_("Condition"), _("%s, %i DAMAGES") % (game.condition.upper(), dam))
+	prstat(_("Condition"), _("%s, %i DAMAGES") % \
+               (game.condition.upper(), sum(map(lambda x: x > 0, game.damage))))
     if not req or req == 3:
 	prstat(_("Position"), "%s , %s" % (game.quadrant, game.sector))
     if not req or req == 4:
@@ -5322,10 +4913,10 @@ def status(req=0):
 	prstat(_("Shields"), s+data)
     if not req or req == 9:
         prstat(_("Klingons Left"), "%d" \
-               % (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem))
+               % (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
+	    plnet = game.state.galaxy[game.quadrant.i][game.quadrant.j].planet
 	    if plnet and plnet.inhabited:
 		prstat(_("Major system"), plnet.name)
 	    else:
@@ -5336,7 +4927,7 @@ def status(req=0):
 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 scanner.next() == IHEOL:
+    while scanner.next() == "IHEOL":
 	proutn(_("Information desired? "))
     scanner.chew()
     if scanner.token in requests:
@@ -5359,10 +4950,10 @@ 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()
@@ -5371,7 +4962,7 @@ def srscan():
 	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."
     w1 = coord(); w2 = coord()
@@ -5380,49 +4971,49 @@ def eta():
 	prout(_("COMPUTER DAMAGED, USE A POCKET CALCULATOR."))
 	skip(1)
 	return
-    if scanner.next() != IHREAL:
+    if scanner.next() != "IHREAL":
 	prompt = True
 	scanner.chew()
 	proutn(_("Destination quadrant and/or sector? "))
-	if scanner.next()!=IHREAL:
+	if scanner.next()!="IHREAL":
 	    huh()
 	    return
-    w1.y = int(scanner.real-0.5)
-    if scanner.next() != IHREAL:
+    w1.j = int(scanner.real-0.5)
+    if scanner.next() != "IHREAL":
 	huh()
 	return
-    w1.x = int(scanner.real-0.5)
-    if scanner.next() == IHREAL:
-	w2.y = int(scanner.real-0.5)
-	if scanner.next() != 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 = int(scanner.real-0.5)
+	w2.i = int(scanner.real-0.5)
     else:
-	if game.quadrant.y>w1.x:
-	    w2.x = 0
+	if game.quadrant.j>w1.i:
+	    w2.i = 0
 	else:
-	    w2.x=QUADSIZE-1
-	if game.quadrant.x>w1.y:
-	    w2.y = 0
+	    w2.i=QUADSIZE-1
+	if game.quadrant.i>w1.j:
+	    w2.j = 0
 	else:
-	    w2.y=QUADSIZE-1
-    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((w1.y-game.quadrant.y+0.1*(w2.y-game.sector.y))**2+
-		(w1.x-game.quadrant.x+0.1*(w2.x-game.sector.x))**2)
+    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:
 	scanner.chew()
 	proutn(_("Time or arrival date? "))
-	if scanner.next()==IHREAL:
+	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."))
 		scanner.chew()
@@ -5432,7 +5023,7 @@ def eta():
 	    break
 	scanner.chew()
 	proutn(_("Warp factor? "))
-	if scanner.next()== IHREAL:
+	if scanner.next()== "IHREAL":
 	    wfl = True
 	    twarp = scanner.real
 	    if twarp<1.0 or twarp > 10.0:
@@ -5442,15 +5033,15 @@ def eta():
 	prout(_("Captain, certainly you can give me one of these."))
     while True:
 	scanner.chew()
-	ttime = (10.0*game.dist)/twarp**2
-	tpower = game.dist*twarp*twarp*twarp*(game.shldup+1)
+	ttime = (10.0*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 scanner.next() == IHREAL:
+		if scanner.next() == "IHREAL":
 		    wfl = True
 		    twarp = scanner.real
 		    if twarp<1.0 or twarp > 10.0:
@@ -5483,7 +5074,7 @@ 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 scanner.next() == IHREAL:
+	if scanner.next() == "IHREAL":
 	    wfl = True
 	    twarp = scanner.real
 	    if twarp<1.0 or twarp > 10.0:
@@ -5508,18 +5099,17 @@ def prelim():
 def freeze(boss):
     "Save game."
     if boss:
-	scanner.token = "emsave.trk"
-    else:
+	scanner.push("emsave.trk")
+    key = scanner.next()
+    if key == "IHEOL":
+        proutn(_("File name: "))
         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"
+    if key != "IHALPHA":
+        huh()
+        return
+    scanner.chew()
+    if '.' not in scanner.token:
+        scanner.token += ".trk"
     try:
         fp = open(scanner.token, "wb")
     except IOError:
@@ -5532,10 +5122,10 @@ def thaw():
     "Retrieve saved game." 
     game.passwd[0] = '\0'
     key = scanner.next()
-    if key == IHEOL:
+    if key == "IHEOL":
 	proutn(_("File name: "))
 	key = scanner.next()
-    if key != IHALPHA:
+    if key != "IHALPHA":
 	huh()
 	return True
     scanner.chew()
@@ -5562,11 +5152,11 @@ systnames = (
     _("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) 
+    _("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" 
+    _("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" 
@@ -5628,13 +5218,11 @@ def setup():
     if choose():
 	return # frozen game
     # Prepare the Enterprise
-    game.alldone = game.gamewon = False
-    game.ship = IHE
+    game.alldone = game.gamewon = game.shldchg = game.shldup = False
+    game.ship = 'E'
     game.state.crew = FULLCREW
     game.energy = game.inenrg = 5000.0
     game.shield = game.inshld = 2500.0
-    game.shldchg = False
-    game.shldup = False
     game.inlsr = 4.0
     game.lsupres = 4.0
     game.quadrant = randplace(GALSIZE)
@@ -5642,7 +5230,6 @@ def setup():
     game.torps = game.intorps = 10
     game.nprobes = randrange(2, 5)
     game.warpfac = 5.0
-    game.wfacsq = game.warpfac * game.warpfac
     for i in range(NDEVICES): 
 	game.damage[i] = 0.0
     # Set up assorted game parameters
@@ -5655,7 +5242,6 @@ def setup():
     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
@@ -5670,7 +5256,7 @@ def setup():
         while True:
             while True:
                 w = randplace(GALSIZE)
-                if not game.state.galaxy[w.x][w.y].starbase:
+                if not game.state.galaxy[w.i][w.j].starbase:
                     break
 	    contflag = False
             # C version: for (j = i-1; j > 0; j--)
@@ -5689,7 +5275,7 @@ def setup():
             if not contflag:
                 break
 	game.state.baseq.append(w)
-	game.state.galaxy[w.x][w.y].starbase = game.state.chart[w.x][w.y].starbase = True
+	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
@@ -5703,10 +5289,10 @@ def setup():
 	krem -= klump
         while True:
             w = randplace(GALSIZE)
-            if not game.state.galaxy[w.x][w.y].supernova and \
-               game.state.galaxy[w.x][w.y].klingons + klump <= MAXKLQUAD:
+            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.x][w.y].klingons += int(klump)
+	game.state.galaxy[w.i][w.j].klingons += int(klump)
         if krem <= 0:
             break
     # Position Klingon Commander Ships
@@ -5715,15 +5301,15 @@ def setup():
             w = randplace(GALSIZE)
             if not welcoming(w) or w in game.state.kcmdr:
                 continue
-            if (game.state.galaxy[w.x][w.y].klingons or withprob(0.25)):
+            if (game.state.galaxy[w.i][w.j].klingons or withprob(0.25)):
                 break
-	game.state.galaxy[w.x][w.y].klingons += 1
+	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.x][w.y].planet == None:
+            if game.state.galaxy[w.i][w.j].planet == None:
                 break
         new = planet()
 	new.quadrant = w
@@ -5740,12 +5326,12 @@ def setup():
                 new.crystals = "present"
 	    new.known = "unknown"
 	    new.inhabited = False
-	game.state.galaxy[w.x][w.y].planet = new
+	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.x][w.y].romulans += 1
+	game.state.galaxy[w.i][w.j].romulans += 1
     # Place the Super-Commander if needed
     if game.state.nscrem > 0:
         while True:
@@ -5753,7 +5339,7 @@ def setup():
             if welcoming(w):
                 break
 	game.state.kscmdr = w
-	game.state.galaxy[w.x][w.y].klingons += 1
+	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))))
@@ -5773,9 +5359,14 @@ def setup():
     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:
-        thing = randplace(GALSIZE)
+        while True:
+            thing = randplace(GALSIZE)
+            if thing not in game.state.baseq:
+                break
     skip(2)
     game.state.snap = False
     if game.skill == SKILL_NOVICE:
@@ -5808,7 +5399,7 @@ def setup():
     if game.state.nscrem:
 	prout(_("  YOU'LL NEED IT."))
     waitfor()
-    newqad(False)
+    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
@@ -5816,19 +5407,15 @@ def setup():
 
 def choose():
     "Choose your game type."
-    global thing
     while True:
-	game.tourn = 0
+	game.tourn = game.length = 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 len(scanner.token)==0: # Try again
-	    continue
         if scanner.sees("tournament"):
-	    while scanner.next() == IHEOL:
+	    while scanner.next() == "IHEOL":
 		proutn(_("Type in tournament number-"))
 	    if scanner.real == 0:
 		scanner.chew()
@@ -5854,7 +5441,7 @@ def choose():
 	proutn(_("What is \"%s\"?") % scanner.token)
 	scanner.chew()
     while game.length==0 or game.skill==SKILL_NONE:
-	if scanner.next() == IHALPHA:
+	if scanner.next() == "IHALPHA":
             if scanner.sees("short"):
 		game.length = 1
 	    elif scanner.sees("medium"):
@@ -5882,9 +5469,9 @@ def choose():
 	    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:
+    if scanner.next() != "IHALPHA":
 	scanner.chew()
-	proutn(_("Choose your game style (or just press enter): "))
+	proutn(_("Choose your game style (plain, almy, fancy or just press enter): "))
 	scanner.next()
     if scanner.sees("plain"):
 	# Approximates the UT FORTRAN version.
@@ -5894,7 +5481,7 @@ def choose():
 	# Approximates Tom Almy's version.
 	game.options &=~ (OPTION_THINGY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS)
 	game.options |= OPTION_ALMY
-    elif scanner.sees("fancy"):
+    elif scanner.sees("fancy") or scanner.sees("\n"):
 	pass
     elif len(scanner.token):
         proutn(_("What is \"%s\"?") % scanner.token)
@@ -5926,10 +5513,10 @@ def dropin(iquad=None):
     "Drop a feature on a random dot in the current quadrant."
     while True:
         w = randplace(QUADSIZE)
-        if game.quad[w.x][w.y] == IHDOT:
+        if game.quad[w.i][w.j] == '.':
             break
     if iquad is not None:
-        game.quad[w.x][w.y] = iquad
+        game.quad[w.i][w.j] = iquad
     return w
 
 def newcnd():
@@ -5937,41 +5524,35 @@ def newcnd():
     game.condition = "green"
     if game.energy < 1000.0:
 	game.condition = "yellow"
-    if game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons or game.state.galaxy[game.quadrant.x][game.quadrant.y].romulans:
+    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)
+    return enemy('K', loc=dropin(), power=randreal(300,450)+25.0*game.skill)
 
-def newqad(shutup):
+def newqad():
     "Set up a new state of quadrant, for when we enter or re-enter it."
-    w = coord()
     game.justin = True
-    game.klhere = 0
-    game.irhere = 0
-    game.iplnet = 0
-    game.neutz = False
-    game.inorbit = False
-    game.landed = False
-    game.ientesc = False
-    game.iseenit = False
+    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)
+    game.quad = fill2d(QUADSIZE, lambda i, j: '.')
     if game.iscate:
 	# Attempt to escape Super-commander, so tbeam back!
 	game.iscate = False
 	game.ientesc = True
-    q = game.state.galaxy[game.quadrant.x][game.quadrant.y]
+    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.x][game.sector.y] = game.ship
+    game.quad[game.sector.i][game.sector.j] = game.ship
     game.enemies = []
     if q.klingons:
 	# Position ordinary Klingons
@@ -5981,28 +5562,28 @@ def newqad(shutup):
         for cmdr in game.state.kcmdr:
 	    if cmdr == game.quadrant:
                 e = game.enemies[game.klhere-1]
-                game.quad[e.kloc.x][e.kloc.y] = IHC
-                e.kpower = randreal(950,1350) + 50.0*game.skill
+                game.quad[e.location.i][e.location.j] = 'C'
+                e.power = 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.x][e.kloc.y] = IHS
-	    e.kpower = randreal(1175.0,  1575.0) + 125.0*game.skill
+	    game.quad[e.location.i][e.location.j] = 'S'
+	    e.power = 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)
+        enemy('R', 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)
+	game.base = dropin('B')
     # If quadrant needs a planet, put it in
     if q.planet:
 	game.iplnet = q.planet
 	if not q.planet.inhabited:
-	    game.plnet = dropin(IHP)
+	    game.plnet = dropin('P')
 	else:
-	    game.plnet = dropin(IHW)
+	    game.plnet = dropin('@')
     # Check for condition
     newcnd()
     # Check for RNZ
@@ -6015,15 +5596,14 @@ def newqad(shutup):
 	    skip(1)
 	    prout(_("INTRUDER! YOU HAVE VIOLATED THE ROMULAN NEUTRAL ZONE."))
 	    prout(_("LEAVE AT ONCE, OR YOU WILL BE DESTROYED!"))
-    if shutup==0:
-	# 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.\""))
+    # Put in THING if needed
+    if thing == game.quadrant:
+        enemy(type='?', 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 \
@@ -6031,39 +5611,39 @@ def newqad(shutup):
             (game.skill > SKILL_GOOD and withprob(0.08)):
             w = coord()
             while True:
-		w.x = withprob(0.5) * (QUADSIZE-1)
-		w.y = withprob(0.5) * (QUADSIZE-1)
-                if game.quad[w.x][w.y] == IHDOT:
+		w.i = withprob(0.5) * (QUADSIZE-1)
+		w.j = withprob(0.5) * (QUADSIZE-1)
+                if game.quad[w.i][w.j] == '.':
                     break
-            game.tholian = enemy(type=IHT, loc=w,
+            game.tholian = enemy(type='T', loc=w,
                                  power=randrange(100, 500) + 25.0*game.skill)
 	    # Reserve unoccupied corners 
-	    if game.quad[0][0]==IHDOT:
+	    if game.quad[0][0]=='.':
 		game.quad[0][0] = 'X'
-	    if game.quad[0][QUADSIZE-1]==IHDOT:
+	    if game.quad[0][QUADSIZE-1]=='.':
 		game.quad[0][QUADSIZE-1] = 'X'
-	    if game.quad[QUADSIZE-1][0]==IHDOT:
+	    if game.quad[QUADSIZE-1][0]=='.':
 		game.quad[QUADSIZE-1][0] = 'X'
-	    if game.quad[QUADSIZE-1][QUADSIZE-1]==IHDOT:
+	    if game.quad[QUADSIZE-1][QUADSIZE-1]=='.':
 		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)
+	dropin('*')
     # Put in a few black holes
     for i in range(1, 3+1):
 	if withprob(0.5): 
-	    dropin(IHBLANK)
+	    dropin(' ')
     # Take out X's in corners if Tholian present
     if game.tholian:
 	if game.quad[0][0]=='X':
-	    game.quad[0][0] = IHDOT
+	    game.quad[0][0] = '.'
 	if game.quad[0][QUADSIZE-1]=='X':
-	    game.quad[0][QUADSIZE-1] = IHDOT
+	    game.quad[0][QUADSIZE-1] = '.'
 	if game.quad[QUADSIZE-1][0]=='X':
-	    game.quad[QUADSIZE-1][0] = IHDOT
+	    game.quad[QUADSIZE-1][0] = '.'
 	if game.quad[QUADSIZE-1][QUADSIZE-1]=='X':
-	    game.quad[QUADSIZE-1][QUADSIZE-1] = IHDOT
+	    game.quad[QUADSIZE-1][QUADSIZE-1] = '.'
 
 def setpassword():
     "Set the self-destruct password."
@@ -6126,30 +5706,32 @@ commands = {
 
 def listCommands():
     "Generate a list of legal commands."
-    proutn(_("LEGAL COMMANDS ARE:"))
-    for (k, key) in enumerate(commands):
-	if not commands[cmd] or (commands[key] & game.options):
-            if k % 5 == 0:
+    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)
-            proutn("%-12s " % key) 
     skip(1)
 
 def helpme():
     "Browse on-line help."
     key = scanner.next()
     while True:
-	if key == IHEOL:
+	if key == "IHEOL":
 	    setwnd(prompt_window)
 	    proutn(_("Help on what command? "))
 	    key = scanner.next()
 	setwnd(message_window)
-	if key == IHEOL:
+	if key == "IHEOL":
 	    return
         if scanner.token in commands or scanner.token == "ABBREV":
 	    break
 	skip(1)
 	listCommands()
-	key = IHEOL
+	key = "IHEOL"
 	scanner.chew()
 	skip(1)
     cmd = scanner.token.upper()
@@ -6166,10 +5748,8 @@ def helpme():
             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()
@@ -6198,13 +5778,12 @@ def makemoves():
 	drawmaps(1)
         while True:	# get a command 
 	    hitme = False
-	    game.justin = False
-	    game.optime = 0.0
+	    game.optime = game.justin = False
 	    scanner.chew()
 	    setwnd(prompt_window)
 	    clrscr()
 	    proutn("COMMAND> ")
-	    if scanner.next() == IHEOL:
+	    if scanner.next() == "IHEOL":
 		if game.options & OPTION_CURSES:
 		    makechart()
 		continue
@@ -6241,7 +5820,7 @@ def makemoves():
 	    if game.ididit:
 		hitme = True
 	elif cmd == "MOVE":		# move under warp
-	    warp(False)
+	    warp(course=None, involuntary=False)
 	elif cmd == "SHIELDS":		# shields
 	    doshield(shraise=False)
 	    if game.ididit:
@@ -6331,14 +5910,14 @@ def makemoves():
 		events()
 		if game.alldone:
 		    break	# Events did us in
-	    if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
+	    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.x][game.quadrant.y].supernova:
+		if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
 		    atover(False)
 		    hitme = True
 		    continue
@@ -6350,18 +5929,18 @@ def makemoves():
 
 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")
+    if   type == 'R': s = _("Romulan")
+    elif type == 'K': s = _("Klingon")
+    elif type == 'C': s = _("Commander")
+    elif type == 'S': s = _("Super-commander")
+    elif type == '*': s = _("Star")
+    elif type == 'P': s = _("Planet")
+    elif type == 'B': s = _("Starbase")
+    elif type == ' ': s = _("Black hole")
+    elif type == 'T': s = _("Tholian")
+    elif type == '#': s = _("Tholian web")
+    elif type == '?': s = _("Stranger")
+    elif type == '@': s = _("Inhabited World")
     else: s = "Unknown??"
     return s
 
@@ -6379,7 +5958,7 @@ def crmena(stars, enemy, loctype, w):
 
 def crmshp():
     "Emit our ship name." 
-    return{IHE:_("Enterprise"),IHF:_("Faerie Queene")}.get(game.ship,"Ship???")
+    return{'E':_("Enterprise"),'F':_("Faerie Queene")}.get(game.ship,"Ship???")
 
 def stars():
     "Emit a line of stars" 
@@ -6392,8 +5971,8 @@ def expran(avrage):
 def randplace(size):
     "Choose a random location."
     w = coord()
-    w.x = randrange(size) 
-    w.y = randrange(size)
+    w.i = randrange(size) 
+    w.j = randrange(size)
     return w
 
 class sstscanner:
@@ -6415,40 +5994,36 @@ class sstscanner:
                 clrscr()
             if line == '':
                 return None
-            # Skip leading white space
-            line = line.lstrip()
             if not line:
                 continue
             else:
-                self.inqueue = line.lstrip().split() + [IHEOL] 
+                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 == IHEOL:
-            self.type = IHEOL
-            return IHEOL
+        if self.token == "\n":
+            self.type = "IHEOL"
+            return "IHEOL"
         try:
             self.real = float(self.token)
-            self.type = IHREAL
-            return IHREAL
+            self.type = "IHREAL"
+            return "IHREAL"
         except ValueError:
             pass
         # Treat as alpha
         self.token = self.token.lower()
-        self.type = IHALPHA
+        self.type = "IHALPHA"
         self.real = None
-        return IHALPHA
-    def push(self, tok):
+        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 chew2(self):
-        # return IHEOL next time 
-        self.inqueue = [IHEOL]
-        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)
@@ -6458,27 +6033,29 @@ class sstscanner:
     def getcoord(self):
         s = coord()
         scanner.next()
-    	if scanner.type != IHREAL:
+    	if scanner.type != "IHREAL":
 	    huh()
 	    return None
-	s.x = scanner.int()-1
+	s.i = scanner.int()-1
         scanner.next()
-	if scanner.type != IHREAL:
+	if scanner.type != "IHREAL":
 	    huh()
 	    return None
-	s.y = scanner.int()-1
+	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()
-	scanner.chew()
 	if scanner.token == 'y':
 	    return True
 	if scanner.token == 'n':
 	    return False
+	scanner.chew()
 	proutn(_("Please answer with \"y\" or \"n\": "))
 
 def huh():
@@ -6514,7 +6091,7 @@ def debugme():
 	    proutn("Kill %s?" % device[i])
 	    scanner.chew()
 	    key = scanner.next()
-            if key == IHALPHA and scanner.sees("y"):
+            if key == "IHALPHA" and scanner.sees("y"):
 		game.damage[i] = 10.0
     proutn("Examine/change events? ")
     if ja() == True:
@@ -6548,33 +6125,34 @@ def debugme():
 	    if key == 'n':
 		unschedule(i)
 		scanner.chew()
-	    elif key == IHREAL:
+	    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:
+		    # "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.x = int(round(scanner.real))
+			w.i = int(round(scanner.real))
 			key = scanner.next()
-			if key != IHREAL:
+			if key != "IHREAL":
 			    prout("Event %d canceled, no y coordinate." % (i))
 			    unschedule(i)
 			    continue
-			w.y = int(round(scanner.real))
+			w.j = int(round(scanner.real))
 			ev.quadrant = w
 	scanner.chew()
     proutn("Induce supernova here? ")
     if ja() == True:
-	game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova = 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
@@ -6583,11 +6161,10 @@ if __name__ == '__main__':
         game = gamestate()
         idebug = 0
         game.options = OPTION_ALL &~ (OPTION_IOMODES | OPTION_PLAIN | OPTION_ALMY)
-        # Disable curses mode until the game logic is working.
-        #    if os.getenv("TERM"):
-        #	game.options |= OPTION_CURSES | OPTION_SHOWME
-        #    else:
-        game.options |= OPTION_TTY
+        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:
@@ -6621,15 +6198,18 @@ if __name__ == '__main__':
                 raise SystemExit, 1
         # where to save the input in case of bugs
         try:
-            logfp = open("/usr/tmp/sst-input.log", "w")
+            logfp = open("/tmp/sst-input.log", "w")
         except IOError:
             sys.stderr.write("sst: warning, can't open logfile\n")
+            sys.exit(1)
         if logfp:
             logfp.write("# seed %s\n" % seed)
             logfp.write("# options %s\n" % " ".join(arguments))
+            logfp.write("# recorded by %s@%s on %s\n" % \
+                    (getpass.getuser(),socket.gethostname(),time.ctime()))
         random.seed(seed)
         scanner = sstscanner()
-        map(scanner.push, arguments)
+        map(scanner.append, arguments)
         try:
             iostart()
             while True: # Play a game 
@@ -6648,7 +6228,8 @@ if __name__ == '__main__':
                 if game.tourn and game.alldone:
                     proutn(_("Do you want your score recorded?"))
                     if ja() == True:
-                        scanner.chew2()
+                        scanner.chew()
+                        scanner.push("\n")
                         freeze(False)
                 scanner.chew()
                 proutn(_("Do you want to play again? "))
@@ -6660,5 +6241,6 @@ if __name__ == '__main__':
             ioend()
         raise SystemExit, 0
     except KeyboardInterrupt:
-        print""
-        pass
+        if logfp:
+            logfp.close()
+        print ""