Polyglotize.
[super-star-trek.git] / sst.py
diff --git a/sst.py b/sst.py
index 957ddfbd14e36d745ef5c8138133f51cc4144576..2cc711bff8a37f570eec3fcefec01e5605ff8a2e 100755 (executable)
--- a/sst.py
+++ b/sst.py
@@ -11,29 +11,48 @@ Stas Sergeev, and Eric S. Raymond.
 See the doc/HACKING file in the distribution for designers notes and advice
 on how to modify (and how not to modify!) this code.
 """
-import os, sys, math, curses, time, readline, cPickle, random, copy, gettext, getpass
+import os, sys, math, curses, time, pickle, random, copy, gettext, getpass
+import getopt, socket, locale
+
+# This import only works on Unixes.  The intention is to enable
+# Ctrl-P, Ctrl-N, and friends in Cmd.
+try:
+    import readline
+except ImportError:
+    pass
+
+# Prevent lossage under Python 3
+try:
+    my_input = raw_input
+except NameError:
+    my_input = input
 
-version="2.0"
 
-docpath        = (".", "../doc", "/usr/share/doc/sst")
+version = "2.1"
 
-def _(str): return gettext.gettext(str)
+docpath        = (".", "doc/", "/usr/share/doc/sst/")
+
+def _(st):
+    return gettext.gettext(st)
 
 GALSIZE        = 8             # Galaxy size in quadrants
-NINHAB         = (GALSIZE * GALSIZE / 2)       # Number of inhabited worlds
+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
+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 
+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
 
+ALGERON                = 2311          # Date of the Treaty of Algeron
+
+
 DEFAULT      = -1
 BLACK        = 0
 BLUE         = 1
@@ -58,14 +77,14 @@ class TrekError(Exception):
 class JumpOut(Exception):
     pass
 
-class coord:
+class Coord:
     def __init__(self, x=None, y=None):
         self.i = x
         self.j = y
     def valid_quadrant(self):
-        return self.i>=0 and self.i<GALSIZE and self.j>=0 and self.j<GALSIZE
+        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
+        return self.i >= 0 and self.i < QUADSIZE and self.j >= 0 and self.j < QUADSIZE
     def invalidate(self):
         self.i = self.j = None
     def is_valid(self):
@@ -73,30 +92,31 @@ class coord:
     def __eq__(self, other):
         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
+        return other is None or self.i != other.i or self.j != other.j
     def __add__(self, other):
-        return coord(self.i+other.i, self.j+other.j)
+        return Coord(self.i+other.i, self.j+other.j)
     def __sub__(self, other):
-        return coord(self.i-other.i, self.j-other.j)
+        return Coord(self.i-other.i, self.j-other.j)
     def __mul__(self, other):
-        return coord(self.i*other, self.j*other)
+        return Coord(self.i*other, self.j*other)
     def __rmul__(self, other):
-        return coord(self.i*other, self.j*other)
+        return Coord(self.i*other, self.j*other)
     def __div__(self, other):
-        return coord(self.i/other, self.j/other)
+        return Coord(self.i/other, self.j/other)
     def __mod__(self, other):
-        return coord(self.i % other, self.j % other)
+        return Coord(self.i % other, self.j % other)
     def __rdiv__(self, other):
-        return coord(self.i/other, self.j/other)
+        return Coord(self.i/other, self.j/other)
     def roundtogrid(self):
-        return coord(int(round(self.i)), int(round(self.j)))
+        return Coord(int(round(self.i)), int(round(self.j)))
     def distance(self, other=None):
-        if not other: other = coord(0, 0)
+        if not other:
+            other = Coord(0, 0)
         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()
+        s = Coord()
         if self.i == 0:
             s.i = 0
         else:
@@ -112,157 +132,177 @@ class coord:
     def sector(self):
         return self.roundtogrid() % QUADSIZE
     def scatter(self):
-        s = coord()
+        s = Coord()
         s.i = self.i + randrange(-1, 2)
         s.j = self.j + randrange(-1, 2)
         return s
     def __str__(self):
-        if self.i == None or self.j == None:
+        if self.i is None or self.j is None:
             return "Nowhere"
         return "%s - %s" % (self.i+1, self.j+1)
     __repr__ = __str__
 
-class planet:
+class Thingy(Coord):
+    "Do not anger the Space Thingy!"
+    def __init__(self):
+        Coord.__init__(self)
+        self.angered = False
+    def angry(self):
+        self.angered = True
+    def at(self, q):
+        return (q.i, q.j) == (self.i, self.j)
+
+class Planet:
     def __init__(self):
-        self.name = None       # string-valued if inhabited
-        self.quadrant = coord()        # quadrant located
-        self.pclass = None     # could be ""M", "N", "O", or "destroyed"
+        self.name = None        # string-valued if inhabited
+        self.quadrant = Coord()        # quadrant located
+        self.pclass = None        # could be ""M", "N", "O", or "destroyed"
         self.crystals = "absent"# could be "mined", "present", "absent"
-        self.known = "unknown" # could be "unknown", "known", "shuttle_down"
-        self.inhabited = False # is it inhabites?
+        self.known = "unknown"        # could be "unknown", "known", "shuttle_down"
+        self.inhabited = False        # is it inhabited?
     def __str__(self):
         return self.name
 
-class quadrant:
+class Quadrant:
     def __init__(self):
         self.stars = 0
         self.planet = None
-       self.starbase = False
-       self.klingons = 0
-       self.romulans = 0
-       self.supernova = False
-       self.charted = False
-        self.status = "secure" # Could be "secure", "distressed", "enslaved"
-
-class page:
+        self.starbase = False
+        self.klingons = 0
+        self.romulans = 0
+        self.supernova = False
+        self.charted = False
+        self.status = "secure"        # Could be "secure", "distressed", "enslaved"
+
+class Page:
     def __init__(self):
-       self.stars = None
-       self.starbase = None
-       self.klingons = None
+        self.stars = None
+        self.starbase = False
+        self.klingons = None
+    def __repr__(self):
+        return "<%s,%s,%s>" % (self.klingons, self.starbase, self.stars)
 
 def fill2d(size, fillfun):
     "Fill an empty list in 2D."
     lst = []
     for i in range(size):
-        lst.append([]) 
+        lst.append([])
         for j in range(size):
             lst[i].append(fillfun(i, j))
     return lst
 
-class snapshot:
+class Snapshot:
     def __init__(self):
-        self.snap = False      # snapshot taken
-        self.crew = 0          # crew complement
-       self.remkl = 0          # remaining klingons
-       self.nscrem = 0         # remaining super commanders
-       self.starkl = 0         # destroyed stars
-       self.basekl = 0         # destroyed bases
-       self.nromrem = 0        # Romulans remaining
-       self.nplankl = 0        # destroyed uninhabited planets
-       self.nworldkl = 0       # destroyed inhabited planets
-        self.planets = []      # Planet information
-        self.date = 0.0        # stardate
-       self.remres = 0         # remaining resources
-       self.remtime = 0        # remaining time
-        self.baseq = []        # Base quadrant coordinates
-        self.kcmdr = []        # Commander quadrant coordinates
-       self.kscmdr = coord()   # Supercommander quadrant coordinates
+        self.snap = False        # snapshot taken
+        self.crew = 0           # crew complement
+        self.remkl = 0          # remaining klingons
+        self.nscrem = 0                # remaining super commanders
+        self.starkl = 0         # destroyed stars
+        self.basekl = 0         # destroyed bases
+        self.nromrem = 0        # Romulans remaining
+        self.nplankl = 0        # destroyed uninhabited planets
+        self.nworldkl = 0        # destroyed inhabited planets
+        self.planets = []        # Planet information
+        self.date = 0.0           # stardate
+        self.remres = 0         # remaining resources
+        self.remtime = 0        # remaining time
+        self.baseq = []         # Base quadrant coordinates
+        self.kcmdr = []         # Commander quadrant coordinates
+        self.kscmdr = Coord()        # Supercommander quadrant coordinates
         # the galaxy
-        self.galaxy = fill2d(GALSIZE, lambda i_unused, j_unused: quadrant())
+        self.galaxy = fill2d(GALSIZE, lambda i_unused, j_unused: Quadrant())
         # the starchart
-       self.chart = fill2d(GALSIZE, lambda i_unused, j_unused: page())
+        self.chart = fill2d(GALSIZE, lambda i_unused, j_unused: Page())
 
-class event:
+class Event:
     def __init__(self):
-        self.date = None       # A real number
-        self.quadrant = None   # A coord structure
-
-# game options 
-OPTION_ALL     = 0xffffffff
-OPTION_TTY     = 0x00000001    # old interface 
-OPTION_CURSES  = 0x00000002    # new interface 
-OPTION_IOMODES = 0x00000003    # cover both interfaces 
-OPTION_PLANETS = 0x00000004    # planets and mining 
-OPTION_THOLIAN = 0x00000008    # Tholians and their webs (UT 1979 version)
-OPTION_THINGY  = 0x00000010    # Space Thingy can shoot back (Stas, 2005)
-OPTION_PROBE   = 0x00000020    # deep-space probes (DECUS version, 1980)
-OPTION_SHOWME  = 0x00000040    # bracket Enterprise in chart 
-OPTION_RAMMING = 0x00000080    # enemies may ram Enterprise (Almy)
-OPTION_MVBADDY = 0x00000100    # more enemies can move (Almy)
-OPTION_BLKHOLE = 0x00000200    # black hole may timewarp you (Stas, 2005) 
-OPTION_BASE    = 0x00000400    # bases have good shields (Stas, 2005)
-OPTION_WORLDS  = 0x00000800    # logic for inhabited worlds (ESR, 2006)
-OPTION_AUTOSCAN        = 0x00001000    # automatic LRSCAN before CHART (ESR, 2006)
-OPTION_PLAIN   = 0x01000000    # user chose plain game 
-OPTION_ALMY    = 0x02000000    # user chose Almy variant 
-OPTION_COLOR    = 0x04000000   # enable color display (experimental, ESR, 2010)
-
-# Define devices 
-DSRSENS        = 0
-DLRSENS        = 1
-DPHASER        = 2
-DPHOTON        = 3
-DLIFSUP        = 4
-DWARPEN        = 5
-DIMPULS        = 6
-DSHIELD        = 7
-DRADIO = 0
-DSHUTTL = 9
-DCOMPTR = 10
-DNAVSYS        = 11
-DTRANSP = 12
-DSHCTRL        = 13
-DDRAY  = 14
-DDSP   = 15
-NDEVICES= 16   # Number of devices
-
-SKILL_NONE     = 0
-SKILL_NOVICE   = 1
-SKILL_FAIR     = 2
-SKILL_GOOD     = 3
-SKILL_EXPERT   = 4
-SKILL_EMERITUS = 5
-
-def damaged(dev):      return (game.damage[dev] != 0.0)
-def communicating():   return not damaged(DRADIO) or game.condition=="docked"
-
-# Define future events 
-FSPY   = 0     # Spy event happens always (no future[] entry)
-               # can cause SC to tractor beam Enterprise
-FSNOVA  = 1    # Supernova
-FTBEAM  = 2    # Commander tractor beams Enterprise
-FSNAP   = 3    # Snapshot for time warp
-FBATTAK = 4    # Commander attacks base
-FCDBAS  = 5    # Commander destroys base
-FSCMOVE = 6    # Supercommander moves (might attack base)
-FSCDBAS = 7    # Supercommander destroys base
-FDSPROB = 8    # Move deep space probe
-FDISTR = 9     # Emit distress call from an inhabited world 
-FENSLV = 10    # Inhabited word is enslaved */
-FREPRO = 11    # Klingons build a ship in an enslaved system
-NEVENTS        = 12
+        self.date = None        # A real number
+        self.quadrant = None        # A coord structure
+
+# game options
+OPTION_ALL        = 0xffffffff
+OPTION_TTY        = 0x00000001        # old interface
+OPTION_CURSES     = 0x00000002        # new interface
+OPTION_IOMODES    = 0x00000003        # cover both interfaces
+OPTION_PLANETS    = 0x00000004        # planets and mining
+OPTION_THOLIAN    = 0x00000008        # Tholians and their webs (UT 1979 version)
+OPTION_THINGY     = 0x00000010        # Space Thingy can shoot back (Stas, 2005)
+OPTION_PROBE      = 0x00000020        # deep-space probes (DECUS version, 1980)
+OPTION_SHOWME     = 0x00000040        # bracket Enterprise in chart
+OPTION_RAMMING    = 0x00000080        # enemies may ram Enterprise (Almy)
+OPTION_MVBADDY    = 0x00000100        # more enemies can move (Almy)
+OPTION_BLKHOLE    = 0x00000200        # black hole may timewarp you (Stas, 2005)
+OPTION_BASE       = 0x00000400        # bases have good shields (Stas, 2005)
+OPTION_WORLDS     = 0x00000800        # logic for inhabited worlds (ESR, 2006)
+OPTION_AUTOSCAN   = 0x00001000        # automatic LRSCAN before CHART (ESR, 2006)
+OPTION_CAPTURE    = 0x00002000        # Enable BSD-Trek capture (Almy, 2013).
+OPTION_CLOAK      = 0x80004000        # Enable BSD-Trek capture (Almy, 2013).
+OPTION_PLAIN      = 0x01000000        # user chose plain game
+OPTION_ALMY       = 0x02000000        # user chose Almy variant
+OPTION_COLOR      = 0x04000000        # enable color display (ESR, 2010)
+
+# Define devices
+DSRSENS         = 0
+DLRSENS         = 1
+DPHASER         = 2
+DPHOTON         = 3
+DLIFSUP         = 4
+DWARPEN         = 5
+DIMPULS         = 6
+DSHIELD         = 7
+DRADIO          = 8
+DSHUTTL         = 9
+DCOMPTR         = 10
+DNAVSYS         = 11
+DTRANSP         = 12
+DSHCTRL         = 13
+DDRAY           = 14
+DDSP            = 15
+DCLOAK          = 16
+NDEVICES        = 17        # Number of devices
+
+SKILL_NONE        = 0
+SKILL_NOVICE        = 1
+SKILL_FAIR        = 2
+SKILL_GOOD        = 3
+SKILL_EXPERT        = 4
+SKILL_EMERITUS        = 5
+
+def damaged(dev):
+    return (game.damage[dev] != 0.0)
+def communicating():
+    return not damaged(DRADIO) or game.condition=="docked"
+
+# Define future events
+FSPY        = 0        # Spy event happens always (no future[] entry)
+                # can cause SC to tractor beam Enterprise
+FSNOVA  = 1        # Supernova
+FTBEAM  = 2        # Commander tractor beams Enterprise
+FSNAP   = 3        # Snapshot for time warp
+FBATTAK = 4        # Commander attacks base
+FCDBAS  = 5        # Commander destroys base
+FSCMOVE = 6        # Supercommander moves (might attack base)
+FSCDBAS = 7        # Supercommander destroys base
+FDSPROB = 8        # Move deep space probe
+FDISTR        = 9        # Emit distress call from an inhabited world
+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 
-def findevent(evtype): return game.future[evtype]
+# 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.location = coord()
+class Enemy:
+    def __init__(self, etype=None, loc=None, power=None):
+        self.type = etype
+        self.location = Coord()
+        self.kdist = None
+        self.kavgd = None
         if loc:
             self.move(loc)
-        self.power = power     # enemy energy level
+        self.power = power        # enemy energy level
         game.enemies.append(self)
     def move(self, loc):
         motion = (loc != self.location)
@@ -277,101 +317,110 @@ class enemy:
             game.quad[self.location.i][self.location.j] = self.type
             self.kdist = self.kavgd = (game.sector - loc).distance()
         else:
-            self.location = 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.location, self.power)   # For debugging
+        return "<%s,%s.%f>" % (self.type, self.location, self.power)        # For debugging
 
-class gamestate:
+class Gamestate:
     def __init__(self):
-        self.options = None    # Game options
-        self.state = snapshot()        # A snapshot structure
-        self.snapsht = snapshot()      # Last snapshot taken for time-travel purposes
-        self.quad = None       # contents of our quadrant
-        self.damage = [0.0] * NDEVICES # damage encountered
-        self.future = []       # future events
+        self.options = None        # Game options
+        self.state = Snapshot()        # A snapshot structure
+        self.snapsht = Snapshot()        # Last snapshot taken for time-travel purposes
+        self.quad = None        # contents of our quadrant
+        self.damage = [0.0] * NDEVICES        # damage encountered
+        self.future = []        # future events
         i = NEVENTS
         while i > 0:
             i -= 1
-            self.future.append(event())
-        self.passwd  = None;           # Self Destruct password
+            self.future.append(Event())
+        self.passwd  = None        # Self Destruct password
         self.enemies = []
-        self.quadrant = None   # where we are in the large
-        self.sector = None     # where we are in the small
-        self.tholian = None    # Tholian enemy object
-        self.base = None       # position of base in current quadrant
-        self.battle = None     # base coordinates being attacked
-        self.plnet = None      # location of planet in quadrant
-        self.gamewon = False   # Finished!
-        self.ididit = False    # action taken -- allows enemy to attack
-        self.alive = False     # we are alive (not killed)
-        self.justin = False    # just entered quadrant
-        self.shldup = False    # shields are up
-        self.shldchg = False   # shield is changing (affects efficiency)
-        self.iscate = False    # super commander is here
-        self.ientesc = False   # attempted escape from supercommander
-        self.resting = False   # rest time
-        self.icraft = False    # Kirk in Galileo
-        self.landed = False    # party on planet (true), on ship (false)
-        self.alldone = False   # game is now finished
-        self.neutz = False     # Romulan Neutral Zone
-        self.isarmed = False   # probe is armed
-        self.inorbit = False   # orbiting a planet
-        self.imine = False     # mining
-        self.icrystl = False   # dilithium crystals aboard
-        self.iseenit = False   # seen base attack report
-        self.thawed = False    # thawed game
-        self.condition = None  # "green", "yellow", "red", "docked", "dead"
-        self.iscraft = None    # "onship", "offship", "removed"
-        self.skill = None      # Player skill level
-        self.inkling = 0       # initial number of klingons
-        self.inbase = 0                # initial number of bases
-        self.incom = 0         # initial number of commanders
-        self.inscom = 0                # initial number of commanders
-        self.inrom = 0         # initial number of commanders
-        self.instar = 0                # initial stars
-        self.intorps = 0       # initial/max torpedoes
-        self.torps = 0         # number of torpedoes
-        self.ship = 0          # ship type -- 'E' is Enterprise
-        self.abandoned = 0     # count of crew abandoned in space
-        self.length = 0                # length of game
-        self.klhere = 0                # klingons here
-        self.casual = 0                # causalties
-        self.nhelp = 0         # calls for help
-        self.nkinks = 0                # count of energy-barrier crossings
-        self.iplnet = None     # planet # in quadrant
-        self.inplan = 0                # initial planets
-        self.irhere = 0                # Romulans in quadrant
-        self.isatb = 0         # =2 if super commander is attacking base
-        self.tourn = None      # tournament number
-        self.nprobes = 0       # number of probes available
-        self.inresor = 0.0     # initial resources
-        self.intime = 0.0      # initial time
-        self.inenrg = 0.0      # initial/max energy
-        self.inshld = 0.0      # initial/max shield
-        self.inlsr = 0.0       # initial life support resources
-        self.indate = 0.0      # initial date
-        self.energy = 0.0      # energy level
-        self.shield = 0.0      # shield level
-        self.warpfac = 0.0     # warp speed
-        self.lsupres = 0.0     # life support reserves
-        self.optime = 0.0      # time taken by current operation
-        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.probe = None      # object holding probe course info
-        self.height = 0.0      # height of orbit around planet
-        self.idebug = False    # Debugging instrumentation enabled?
+        self.quadrant = None        # where we are in the large
+        self.sector = None        # where we are in the small
+        self.tholian = None        # Tholian enemy object
+        self.base = None        # position of base in current quadrant
+        self.battle = None        # base coordinates being attacked
+        self.plnet = None        # location of planet in quadrant
+        self.gamewon = False        # Finished!
+        self.ididit = False        # action taken -- allows enemy to attack
+        self.alive = False        # we are alive (not killed)
+        self.justin = False        # just entered quadrant
+        self.shldup = False        # shields are up
+        self.shldchg = False        # shield is changing (affects efficiency)
+        self.iscate = False        # super commander is here
+        self.ientesc = False        # attempted escape from supercommander
+        self.resting = False        # rest time
+        self.icraft = False        # Kirk in Galileo
+        self.landed = False        # party on planet (true), on ship (false)
+        self.alldone = False        # game is now finished
+        self.neutz = False        # Romulan Neutral Zone
+        self.isarmed = False        # probe is armed
+        self.inorbit = False        # orbiting a planet
+        self.imine = False        # mining
+        self.icrystl = False        # dilithium crystals aboard
+        self.iseenit = False        # seen base attack report
+        self.thawed = False        # thawed game
+        self.condition = None        # "green", "yellow", "red", "docked", "dead"
+        self.iscraft = None        # "onship", "offship", "removed"
+        self.skill = None        # Player skill level
+        self.inkling = 0        # initial number of klingons
+        self.inbase = 0                # initial number of bases
+        self.incom = 0                # initial number of commanders
+        self.inscom = 0                # initial number of commanders
+        self.inrom = 0                # initial number of commanders
+        self.instar = 0                # initial stars
+        self.intorps = 0        # initial/max torpedoes
+        self.torps = 0                # number of torpedoes
+        self.ship = 0                # ship type -- 'E' is Enterprise
+        self.abandoned = 0        # count of crew abandoned in space
+        self.length = 0                # length of game
+        self.klhere = 0                # klingons here
+        self.casual = 0                # causalties
+        self.nhelp = 0                # calls for help
+        self.nkinks = 0                # count of energy-barrier crossings
+        self.iplnet = None        # planet # in quadrant
+        self.inplan = 0                # initial planets
+        self.irhere = 0                # Romulans in quadrant
+        self.isatb = 0                # =2 if super commander is attacking base
+        self.tourn = None        # tournament number
+        self.nprobes = 0        # number of probes available
+        self.inresor = 0.0        # initial resources
+        self.intime = 0.0        # initial time
+        self.inenrg = 0.0        # initial/max energy
+        self.inshld = 0.0        # initial/max shield
+        self.inlsr = 0.0        # initial life support resources
+        self.indate = 0.0        # initial date
+        self.energy = 0.0        # energy level
+        self.shield = 0.0        # shield level
+        self.warpfac = 0.0        # warp speed
+        self.lsupres = 0.0        # life support reserves
+        self.optime = 0.0        # time taken by current operation
+        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.probe = None        # object holding probe course info
+        self.height = 0.0        # height of orbit around planet
+        self.score = 0.0        # overall score
+        self.perdate = 0.0        # rate of kills
+        self.idebug = False        # Debugging instrumentation enabled?
+        self.statekscmdr = None # No SuperCommander coordinates yet.
+        self.brigcapacity = 400     # Enterprise brig capacity
+        self.brigfree = 400       # How many klingons can we put in the brig?
+        self.kcaptured = 0      # Total Klingons captured, for scoring.
+        self.iscloaked = False  # Cloaking device on?
+        self.ncviol = 0         # Algreon treaty violations
+        self.isviolreported = False # We have been warned
     def recompute(self):
-        # Stas thinks this should be (C expression): 
+        # Stas thinks this should be (C expression):
         # game.state.remkl + len(game.state.kcmdr) > 0 ?
-       #       game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) : 99
+        #        game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) : 99
         # He says the existing expression is prone to divide-by-zero errors
         # after killing the last klingon when score is shown -- perhaps also
         # if the only remaining klingon is SCOM.
-        game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr))
+        self.state.remtime = self.state.remres/(self.state.remkl + 4*len(self.state.kcmdr))
 
 FWON = 0
 FDEPLETE = 1
@@ -395,6 +444,7 @@ FDRAY = 18
 FTRIBBLE = 19
 FHOLE = 20
 FCREW = 21
+FCLOAK = 22
 
 def withprob(p):
     return random.random() < p
@@ -405,9 +455,9 @@ def randrange(*args):
 def randreal(*args):
     v = random.random()
     if len(args) == 1:
-        v *= args[0]           # from [0, args[0])
+        v *= args[0]                 # from [0, args[0])
     elif len(args) == 2:
-        v = args[0] + v*(args[1]-args[0])      # from [args[0], args[1])
+        v = args[0] + v*(args[1]-args[0])        # from [args[0], args[1])
     return v
 
 # Code from ai.c begins here
@@ -415,171 +465,168 @@ def randreal(*args):
 def welcoming(iq):
     "Would this quadrant welcome another Klingon?"
     return iq.valid_quadrant() and \
-       not game.state.galaxy[iq.i][iq.j].supernova and \
-       game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD
+        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 = Coord()
     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;
+        return False
     if enemy.type == 'R':
-       return False; # Romulans cannot escape! 
+        return False # Romulans cannot escape!
     if not irun:
-       # avoid intruding on another commander's territory 
-       if enemy.type == 'C':
+        # avoid intruding on another commander's territory
+        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.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.location) + \
-              (_(" escapes to Quadrant %s (and regains strength).") % iq))
+                return []
+            # refuse to leave if currently attacking starbase
+            if game.battle == game.quadrant:
+                return []
+        # don't leave if over 1000 units of energy
+        if enemy.power > 1000.0:
+            return []
+    oldloc = copy.copy(enemy.location)
     # handle local matters related to escape
     enemy.move(None)
     game.klhere -= 1
     if game.condition != "docked":
-       newcnd()
-    # Handle global matters related to escape 
+        newcnd()
+    # Handle global matters related to escape
     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
-       schedule(FSCMOVE, 0.2777)
-       unschedule(FSCDBAS)
-       game.state.kscmdr=iq
+    if enemy.type == 'S':
+        game.iscate = False
+        game.ientesc = False
+        game.isatb = 0
+        schedule(FSCMOVE, 0.2777)
+        unschedule(FSCDBAS)
+        game.state.kscmdr = iq
     else:
-       for cmdr in game.state.kcmdr:
-           if cmdr == game.quadrant:
-               game.state.kcmdr.append(iq)
-               break
-    return True; # success 
+        for cmdr in game.state.kcmdr:
+            if cmdr == game.quadrant:
+                game.state.kcmdr.append(iq)
+                break
+    # report move out of quadrant.
+    return [(True, enemy, oldloc, iq)]
 
 # The bad-guy movement algorithm:
-# 
+#
 # 1. Enterprise has "force" based on condition of phaser and photon torpedoes.
 # If both are operating full strength, force is 1000. If both are damaged,
 # force is -1000. Having shields down subtracts an additional 1000.
-# 
+#
 # 2. Enemy has forces equal to the energy of the attacker plus
 # 100*(K+R) + 500*(C+S) - 400 for novice through good levels OR
 # 346*K + 400*R + 500*(C+S) - 400 for expert and emeritus.
-# 
+#
 # Attacker Initial energy levels (nominal):
 # Klingon   Romulan   Commander   Super-Commander
-# Novice    400        700        1200        
+# Novice    400        700        1200
 # Fair      425        750        1250
 # Good      450        800        1300        1750
 # Expert    475        850        1350        1875
 # Emeritus  500        900        1400        2000
 # VARIANCE   75        200         200         200
-# 
+#
 # Enemy vessels only move prior to their attack. In Novice - Good games
 # only commanders move. In Expert games, all enemy vessels move if there
 # is a commander present. In Emeritus games all enemy vessels move.
-# 
+#
 # 3. If Enterprise is not docked, an aggressive action is taken if enemy
 # forces are 1000 greater than Enterprise.
-# 
+#
 # Agressive action on average cuts the distance between the ship and
 # the enemy to 1/4 the original.
-# 
+#
 # 4.  At lower energy advantage, movement units are proportional to the
 # advantage with a 650 advantage being to hold ground, 800 to move forward
 # 1, 950 for two, 150 for back 4, etc. Variance of 100.
-# 
+#
 # If docked, is reduced by roughly 1.75*game.skill, generally forcing a
 # 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."
-    goto = coord(); look = coord()
+    goto = Coord()
+    look = Coord()
     irun = False
-    # This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant) 
+    # This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
     if game.skill >= SKILL_EXPERT:
-       nbaddys = (((game.quadrant in game.state.kcmdr)*2 + (game.state.kscmdr==game.quadrant)*2+game.klhere*1.23+game.irhere*1.5)/2.0)
+        nbaddys = (((game.quadrant in game.state.kcmdr)*2 + (game.state.kscmdr==game.quadrant)*2+game.klhere*1.23+game.irhere*1.5)/2.0)
     else:
-       nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
-    dist1 = enemy.kdist
-    mdist = int(dist1 + 0.5); # Nearest integer distance 
-    # If SC, check with spy to see if should hi-tail it 
-    if enemy.type=='S' and \
-       (enemy.power <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
-       irun = True
-       motion = -QUADSIZE
+        nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
+    old_dist = enemy.kdist
+    mdist = int(old_dist + 0.5) # Nearest integer distance
+    # If SC, check with spy to see if should hi-tail it
+    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.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):
-            if damaged(DPHASER): # phasers damaged 
-               forces += 300.0
-           else:
-               forces -= 0.2*(game.energy - 2500.0)
-           if damaged(DPHOTON): # photon torpedoes damaged 
-               forces += 300.0
-           else:
-               forces -= 50.0*game.torps
-       else:
-           # phasers and photon tubes both out! 
-           forces += 1000.0
-       motion = 0
-        if forces <= 1000.0 and game.condition != "docked": # Typical situation 
-           motion = ((forces + randreal(200))/150.0) - 5.0
-       else:
-            if forces > 1000.0: # Very strong -- move in for kill 
-               motion = (1.0 - randreal())**2 * dist1 + 1.0
-           if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off ! 
-               motion -= game.skill*(2.0-randreal()**2)
-       if game.idebug:
-           proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces))
-       # don't move if no motion 
-       if motion==0:
-           return
-       # Limit motion according to skill 
-       if abs(motion) > game.skill:
+        # decide whether to advance, retreat, or hold position
+        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):
+            if damaged(DPHASER): # phasers damaged
+                forces += 300.0
+            else:
+                forces -= 0.2*(game.energy - 2500.0)
+            if damaged(DPHOTON): # photon torpedoes damaged
+                forces += 300.0
+            else:
+                forces -= 50.0*game.torps
+        else:
+            # phasers and photon tubes both out!
+            forces += 1000.0
+        motion = 0
+        if forces <= 1000.0 and game.condition != "docked": # Typical situation
+            motion = ((forces + randreal(200))/150.0) - 5.0
+        else:
+            if forces > 1000.0: # Very strong -- move in for kill
+                motion = (1.0 - randreal())**2 * old_dist + 1.0
+            if game.condition == "docked" and (game.options & OPTION_BASE): # protected by base -- back off !
+                motion -= game.skill*(2.0-randreal()**2)
+        if game.idebug:
+            proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces))
+        # don't move if no motion
+        if motion == 0:
+            return []
+        # Limit motion according to skill
+        if abs(motion) > game.skill:
             if motion < 0:
                 motion = -game.skill
             else:
                 motion = game.skill
-    # calculate preferred number of steps 
+    # calculate preferred number of steps
     nsteps = abs(int(motion))
     if motion > 0 and nsteps > mdist:
-       nsteps = mdist; # don't overshoot 
+        nsteps = mdist # don't overshoot
     if nsteps > QUADSIZE:
-       nsteps = QUADSIZE; # This shouldn't be necessary 
+        nsteps = QUADSIZE # This shouldn't be necessary
     if nsteps < 1:
-       nsteps = 1; # This shouldn't be necessary 
+        nsteps = 1 # This shouldn't be necessary
     if game.idebug:
-       proutn("NSTEPS = %d:" % nsteps)
-    # Compute preferred values of delta X and Y 
+        proutn("NSTEPS = %d:" % nsteps)
+    # Compute preferred values of delta X and Y
     m = game.sector - enemy.location
     if 2.0 * abs(m.i) < abs(m.j):
-       m.i = 0
+        m.i = 0
     if 2.0 * abs(m.j) < abs(game.sector.i-enemy.location.i):
-       m.j = 0
+        m.j = 0
     m = (motion * m).sgn()
     goto = enemy.location
-    # main move loop 
+    # main move loop
     for ll in range(nsteps):
-       if game.idebug:
-           proutn(" %d" % (ll+1))
-       # Check if preferred position available 
-       look = goto + m
+        if game.idebug:
+            proutn(" %d" % (ll+1))
+        # Check if preferred position available
+        look = goto + m
         if m.i < 0:
             krawli = 1
         else:
@@ -588,235 +635,232 @@ def movebaddy(enemy):
             krawlj = 1
         else:
             krawlj = -1
-       success = False
-       attempts = 0; # Settle mysterious hang problem 
-       while attempts < 20 and not success:
+        success = False
+        attempts = 0 # Settle mysterious hang problem
+        while attempts < 20 and not success:
             attempts += 1
-           if look.i < 0 or look.i >= QUADSIZE:
-               if motion < 0 and tryexit(enemy, look, irun):
-                   return
-               if krawli == m.i or m.j == 0:
-                   break
-               look.i = goto.i + krawli
-               krawli = -krawli
-           elif look.j < 0 or look.j >= QUADSIZE:
-               if motion < 0 and tryexit(enemy, look, irun):
-                   return
-               if krawlj == m.j or m.i == 0:
-                   break
-               look.j = goto.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.i][look.j] == game.ship and \
-                   (enemy.type == 'C' or enemy.type == 'S'):
-                   collision(rammed=True, enemy=enemy)
-                   return
-               if krawli != m.i and m.j != 0:
-                   look.i = goto.i + krawli
-                   krawli = -krawli
-               elif krawlj != m.j and m.i != 0:
-                   look.j = goto.j + krawlj
-                   krawlj = -krawlj
-               else:
-                   break; # we have failed 
-           else:
-               success = True
-       if success:
-           goto = look
-           if game.idebug:
-               proutn(`goto`)
-       else:
-           break; # done early 
+            if look.i < 0 or look.i >= QUADSIZE:
+                if motion < 0:
+                    return tryexit(enemy, look, irun)
+                if krawli == m.i or m.j == 0:
+                    break
+                look.i = goto.i + krawli
+                krawli = -krawli
+            elif look.j < 0 or look.j >= QUADSIZE:
+                if motion < 0:
+                    return tryexit(enemy, look, irun)
+                if krawlj == m.j or m.i == 0:
+                    break
+                look.j = goto.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.i][look.j] == game.ship and \
+                    (enemy.type == 'C' or enemy.type == 'S'):
+                    collision(rammed=True, enemy=enemy)
+                    return []
+                if krawli != m.i and m.j != 0:
+                    look.i = goto.i + krawli
+                    krawli = -krawli
+                elif krawlj != m.j and m.i != 0:
+                    look.j = goto.j + krawlj
+                    krawlj = -krawlj
+                else:
+                    break # we have failed
+            else:
+                success = True
+        if success:
+            goto = look
+            if game.idebug:
+                proutn(repr(goto))
+        else:
+            break # done early
     if game.idebug:
-       skip(1)
-    if enemy.move(goto):
-       if not damaged(DSRSENS) or game.condition == "docked":
-           proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.location))
-           if enemy.kdist < dist1:
-               proutn(_(" advances to "))
-           else:
-               proutn(_(" retreats to "))
-           prout("Sector %s." % goto)
+        skip(1)
+    # Enemy moved, but is still in sector
+    return [(False, enemy, old_dist, goto)]
 
 def moveklings():
     "Sequence Klingon tactical movement."
     if game.idebug:
-       prout("== MOVCOM")
+        prout("== MOVCOM")
     # Figure out which Klingon is the commander (or Supercommander)
     # and do move
+    tacmoves = []
     if game.quadrant in game.state.kcmdr:
         for enemy in game.enemies:
-           if enemy.type == 'C':
-               movebaddy(enemy)
-    if game.state.kscmdr==game.quadrant:
+            if enemy.type == 'C':
+                tacmoves += movebaddy(enemy)
+    if game.state.kscmdr == game.quadrant:
         for enemy in game.enemies:
-           if enemy.type == 'S':
-               movebaddy(enemy)
-               break
+            if enemy.type == 'S':
+                tacmoves += movebaddy(enemy)
+                break
     # If skill level is high, move other Klingons and Romulans too!
     # Move these last so they can base their actions on what the
     # commander(s) do.
     if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
         for enemy in game.enemies:
             if enemy.type in ('K', 'R'):
-               movebaddy(enemy)
-    game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+                tacmoves += movebaddy(enemy)
+    return tacmoves
 
 def movescom(iq, avoid):
-    "Commander movement helper." 
-    # Avoid quadrants with bases if we want to avoid Enterprise 
+    "Commander movement helper."
+    # Avoid quadrants with bases if we want to avoid Enterprise
     if not welcoming(iq) or (avoid and iq in game.state.baseq):
-       return False
+        return False
     if game.justin and not game.iscate:
-       return False
-    # do the move 
+        return False
+    # do the move
     game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons -= 1
     game.state.kscmdr = iq
     game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons += 1
-    if game.state.kscmdr==game.quadrant:
-       # SC has scooted, remove him from current quadrant 
-       game.iscate=False
-       game.isatb=0
-       game.ientesc = False
-       unschedule(FSCDBAS)
-       for enemy in game.enemies:
-           if enemy.type == 'S':
-               break
-       enemy.move(None)
-       game.klhere -= 1
-       if game.condition != "docked":
-           newcnd()
-        game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
-    # check for a helpful planet 
+    if game.state.kscmdr == game.quadrant:
+        # SC has scooted, remove him from current quadrant
+        game.iscate = False
+        game.isatb = 0
+        game.ientesc = False
+        unschedule(FSCDBAS)
+        for enemy in game.enemies:
+            if enemy.type == 'S':
+                enemy.move(None)
+        game.klhere -= 1
+        if game.condition != "docked":
+            newcnd()
+        sortenemies()
+    # check for a helpful planet
     for i in range(game.inplan):
-       if game.state.planets[i].quadrant == game.state.kscmdr and \
-           game.state.planets[i].crystals == "present":
-           # destroy the planet 
-           game.state.planets[i].pclass = "destroyed"
-           game.state.galaxy[game.state.kscmdr.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 True; # looks good! 
-                       
+        if game.state.planets[i].quadrant == game.state.kscmdr and \
+            game.state.planets[i].crystals == "present":
+            # destroy the planet
+            game.state.planets[i].pclass = "destroyed"
+            game.state.galaxy[game.state.kscmdr.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 True # looks good!
+
 def supercommander():
-    "Move the Super Commander." 
-    iq = coord(); sc = coord(); ibq = coord(); idelta = coord()
+    "Move the Super Commander."
+    iq = Coord()
+    sc = Coord()
+    ibq = Coord()
+    idelta = Coord()
     basetbl = []
     if game.idebug:
-       prout("== SUPERCOMMANDER")
-    # Decide on being active or passive 
+        prout("== SUPERCOMMANDER")
+    # Decide on being active or passive
     avoid = ((game.incom - len(game.state.kcmdr) + game.inkling - game.state.remkl)/(game.state.date+0.01-game.indate) < 0.1*game.skill*(game.skill+1.0) or \
-           (game.state.date-game.indate) < 3.0)
+            (game.state.date-game.indate) < 3.0)
     if not game.iscate and avoid:
-       # compute move away from Enterprise 
-       idelta = game.state.kscmdr-game.quadrant
-       if idelta.distance() > 2.0:
-           # circulate in space 
-           idelta.i = game.state.kscmdr.j-game.quadrant.j
-           idelta.j = game.quadrant.i-game.state.kscmdr.i
+        # compute move away from Enterprise
+        idelta = game.state.kscmdr-game.quadrant
+        if idelta.distance() > 2.0:
+            # circulate in space
+            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:
-           # nothing left to do 
-           unschedule(FSCMOVE)
-           return
-       sc = game.state.kscmdr
-        for base in game.state.baseq:
-           basetbl.append((i, (base - sc).distance()))
-       if game.state.baseq > 1:
-            basetbl.sort(lambda x, y: cmp(x[1], y[1]))
-       # look for nearest base without a commander, no Enterprise, and
-        # without too many Klingons, and not already under attack. 
-       ifindit = iwhichb = 0
-       for (i2, base) in enumerate(game.state.baseq):
-           i = basetbl[i2][0]; # bug in original had it not finding nearest
-           if base==game.quadrant or base==game.battle or not welcoming(base):
-               continue
-           # if there is a commander, and no other base is appropriate,
-           # we will take the one with the commander
+        # compute distances to starbases
+        if not game.state.baseq:
+            # nothing left to do
+            unschedule(FSCMOVE)
+            return
+        sc = game.state.kscmdr
+        for (i, base) in enumerate(game.state.baseq):
+            basetbl.append((i, (base - sc).distance()))
+        if game.state.baseq > 1:
+            basetbl.sort(key=lambda x: x[1])
+        # look for nearest base without a commander, no Enterprise, and
+        # without too many Klingons, and not already under attack.
+        ifindit = iwhichb = 0
+        for (i2, base) in enumerate(game.state.baseq):
+            i = basetbl[i2][0]        # bug in original had it not finding nearest
+            if base == game.quadrant or base == game.battle or not welcoming(base):
+                continue
+            # if there is a commander, and no other base is appropriate,
+            # we will take the one with the commander
             for cmdr in game.state.kcmdr:
-               if base == cmdr and ifindit != 2:
-                   ifindit = 2
-                   iwhichb = i
-                   break
-           else:       # no commander -- use this one 
-               ifindit = 1
-               iwhichb = i
-               break
-       if ifindit==0:
-           return # Nothing suitable -- wait until next time
-       ibq = game.state.baseq[iwhichb]
-       # decide how to move toward base 
-       idelta = ibq - game.state.kscmdr
-    # Maximum movement is 1 quadrant in either or both axes 
+                if base == cmdr and ifindit != 2:
+                    ifindit = 2
+                    iwhichb = i
+                    break
+            else:        # no commander -- use this one
+                ifindit = 1
+                iwhichb = i
+                break
+        if ifindit == 0:
+            return # Nothing suitable -- wait until next time
+        ibq = game.state.baseq[iwhichb]
+        # decide how to move toward base
+        idelta = ibq - game.state.kscmdr
+    # Maximum movement is 1 quadrant in either or both axes
     idelta = idelta.sgn()
     # try moving in both x and y directions
     # 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 not movescom(iq, avoid):
-       # failed -- try some other maneuvers 
-       if idelta.i==0 or idelta.j==0:
-           # attempt angle move 
-           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)
-           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.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 
+        # failed -- try some other maneuvers
+        if idelta.i == 0 or idelta.j == 0:
+            # attempt angle move
+            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)
+            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.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)
+        unschedule(FSCMOVE)
     else:
         for ibq in game.state.baseq:
-           if ibq == game.state.kscmdr and game.state.kscmdr == game.battle:
-               # attack the base 
-               if avoid:
-                   return # no, don't attack base! 
-               game.iseenit = False
-               game.isatb = 1
-               schedule(FSCDBAS, randreal(1.0, 3.0))
-               if is_scheduled(FCDBAS):
-                   postpone(FSCDBAS, scheduled(FCDBAS)-game.state.date)
-               if not communicating():
-                   return # no warning 
-               game.iseenit = True
-               announce()
-               prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") \
+            if ibq == game.state.kscmdr and game.state.kscmdr == game.battle:
+                # attack the base
+                if avoid:
+                    return # no, don't attack base!
+                game.iseenit = False
+                game.isatb = 1
+                schedule(FSCDBAS, randreal(1.0, 3.0))
+                if is_scheduled(FCDBAS):
+                    postpone(FSCDBAS, scheduled(FCDBAS)-game.state.date)
+                if not communicating():
+                    return # no warning
+                game.iseenit = True
+                announce()
+                prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") \
                       % game.state.kscmdr)
-               prout(_("   reports that it is under attack from the Klingon Super-commander."))
-               proutn(_("   It can survive until stardate %d.\"") \
+                prout(_("   reports that it is under attack from the Klingon Super-commander."))
+                proutn(_("   It can survive until stardate %d.\"") \
                        % int(scheduled(FSCDBAS)))
-               if not game.resting:
-                   return
-               prout(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
-               if not ja():
-                   return
-               game.resting = False
-               game.optime = 0.0; # actually finished 
-               return
-    # Check for intelligence report 
+                if not game.resting:
+                    return
+                prout(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
+                if not ja():
+                    return
+                game.resting = False
+                game.optime = 0.0 # actually finished
+                return
+    # Check for intelligence report
     if not game.idebug and \
-       (withprob(0.8) or \
-        (not communicating()) or \
-        not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].charted):
-       return
+        (withprob(0.8) or \
+         (not communicating()) or \
+         not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].charted):
+        return
     announce()
     prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
     proutn(_("   the Super-commander is in Quadrant %s,") % game.state.kscmdr)
@@ -825,48 +869,52 @@ def supercommander():
 def movetholian():
     "Move the Tholian."
     if not game.tholian or game.justin:
-       return
-    tid = coord()
+        return
+    tid = Coord()
     if game.tholian.location.i == 0 and game.tholian.location.j == 0:
-       tid.i = 0; tid.j = QUADSIZE-1
+        tid.i = 0
+        tid.j = QUADSIZE-1
     elif game.tholian.location.i == 0 and game.tholian.location.j == QUADSIZE-1:
-       tid.i = QUADSIZE-1; tid.j = QUADSIZE-1
+        tid.i = QUADSIZE-1
+        tid.j = QUADSIZE-1
     elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == QUADSIZE-1:
-       tid.i = QUADSIZE-1; tid.j = 0
+        tid.i = QUADSIZE-1
+        tid.j = 0
     elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == 0:
-       tid.i = 0; tid.j = 0
+        tid.i = 0
+        tid.j = 0
     else:
-       # something is wrong! 
-       game.tholian.move(None)
+        # something is wrong!
+        game.tholian.move(None)
         prout("***Internal error: Tholian in a bad spot.")
-       return
-    # do nothing if we are blocked 
+        return
+    # do nothing if we are blocked
     if game.quad[tid.i][tid.j] not in ('.', '#'):
-       return
+        return
     here = copy.copy(game.tholian.location)
     delta = (tid - game.tholian.location).sgn()
-    # move in x axis 
+    # move in x axis
     while here.i != tid.i:
         here.i += delta.i
-        if game.quad[here.i][here.j]=='.':
+        if game.quad[here.i][here.j] == '.':
             game.tholian.move(here)
-    # move in y axis 
+    # move in y axis
     while here.j != tid.j:
         here.j += delta.j
-        if game.quad[here.i][here.j]=='.':
+        if game.quad[here.i][here.j] == '.':
             game.tholian.move(here)
-    # check to see if all holes plugged 
+    # check to see if all holes plugged
     for i in range(QUADSIZE):
-       if game.quad[0][i]!='#' and game.quad[0][i]!='T':
-           return
-       if game.quad[QUADSIZE-1][i]!='#' and game.quad[QUADSIZE-1][i]!='T':
-           return
-       if game.quad[i][0]!='#' and game.quad[i][0]!='T':
-           return
-       if game.quad[i][QUADSIZE-1]!='#' and game.quad[i][QUADSIZE-1]!='T':
-           return
-    # All plugged up -- Tholian splits 
-    game.quad[game.tholian.location.i][game.tholian.location.j]='#'
+        if game.quad[0][i] != '#' and game.quad[0][i] != 'T':
+            return
+        if game.quad[QUADSIZE-1][i] != '#' and game.quad[QUADSIZE-1][i] != 'T':
+            return
+        if game.quad[i][0] != '#' and game.quad[i][0] != 'T':
+            return
+        if game.quad[i][QUADSIZE-1] != '#' and game.quad[i][QUADSIZE-1] != 'T':
+            return
+    # All plugged up -- Tholian splits
+    game.quad[game.tholian.location.i][game.tholian.location.j] = '#'
     dropin(' ')
     prout(crmena(True, 'T', "sector", game.tholian) + _(" completes web."))
     game.tholian.move(None)
@@ -874,143 +922,223 @@ def movetholian():
 
 # Code from battle.c begins here
 
+def cloak():
+    "Change cloaking-device status."
+    if game.ship == 'F':
+        prout(_("Ye Faerie Queene hath no cloaking device."));
+        return
+
+    key = scanner.nexttok()
+
+    if key == "IHREAL":
+        return
+
+    action = None
+    if key == "IHALPHA":
+        if scanner.sees("on"):
+            if game.iscloaked:
+                prout(_("The cloaking device has already been switched on."))
+                return
+            action = "CLON"
+        elif scanner.sees("off"):
+            if not game.iscloaked:
+                prout(_("The cloaking device has already been switched off."))
+                return
+            action = "CLOFF"
+        else:
+            huh()
+            return
+    else:
+        if not game.iscloaked:
+            proutn(_("Switch cloaking device on? "))
+            if not ja():
+                return
+            action = "CLON"
+        else:
+            proutn(_("Switch cloaking device off? "))
+            if not ja():
+                return
+            action = "CLOFF"
+    if action == None:
+        return;
+
+    if action == "CLOFF":
+        if game.irhere and game.state.date >= ALGERON and not game.isviolreported:
+            prout(_("Spock- \"Captain, the Treaty of Algeron is in effect.\n   Are you sure this is wise?\""))
+            if not ja():
+                return;
+        prout("Engineer Scott- \"Aye, Sir.\"");
+        game.iscloaked = False;
+        if game.irhere and game.state.date >= ALGERON and not game.isviolreported:
+            prout(_("The Romulan ship discovers you are breaking the Treaty of Algeron!"))
+            game.ncviol += 1
+            game.isviolreported = True
+
+            #if (neutz and game.state.date >= ALGERON) finish(FCLOAK);
+            return;
+
+    if action == "CLON":
+        if damaged(DCLOAK):
+            prout(_("Engineer Scott- \"The cloaking device is damaged, Sir.\""))
+            return;
+
+        if game.condition == "docked":
+            prout(_("You cannot cloak while docked."))
+
+       if game.state.date >= ALGERON and not game.isviolreported:
+            prout(_("Spock- \"Captain, using the cloaking device is a violation"))
+            prout(_("  of the Treaty of Algeron. Considering the alternatives,"))
+            proutn(_("  are you sure this is wise? "))
+            if not ja():
+                return
+       prout(_("Engineer Scott- \"Cloaking device has engaging, Sir...\""))
+        attack(True)
+       prout(_("Engineer Scott- \"Cloaking device has engaged, Sir.\""))
+       game.iscloaked = True
+
+        if game.irhere and game.state.date >= ALGERON and not game.isviolreported:
+            prout(_("The Romulan ship discovers you are breaking the Treaty of Algeron!"))
+            game.ncviol += 1
+            game.isviolreported = True
+
 def doshield(shraise):
     "Change shield status."
     action = "NONE"
     game.ididit = False
     if shraise:
-       action = "SHUP"
+        action = "SHUP"
     else:
-       key = scanner.next()
-       if key == "IHALPHA":
-           if scanner.sees("transfer"):
-               action = "NRG"
-           else:
-               if damaged(DSHIELD):
-                   prout(_("Shields damaged and down."))
-                   return
-               if scanner.sees("up"):
-                   action = "SHUP"
-               elif scanner.sees("down"):
-                   action = "SHDN"
-       if action=="NONE":
-           proutn(_("Do you wish to change shield energy? "))
-           if ja():
-               action = "NRG"
-           elif damaged(DSHIELD):
-               prout(_("Shields damaged and down."))
-               return
-           elif game.shldup:
-               proutn(_("Shields are up. Do you want them down? "))
-               if ja():
-                   action = "SHDN"
-               else:
-                   scanner.chew()
-                   return
-           else:
-               proutn(_("Shields are down. Do you want them up? "))
-               if ja():
-                   action = "SHUP"
-               else:
-                   scanner.chew()
-                   return    
-    if action == "SHUP": # raise shields 
-       if game.shldup:
-           prout(_("Shields already up."))
-           return
-       game.shldup = True
-       game.shldchg = True
-       if game.condition != "docked":
-           game.energy -= 50.0
-       prout(_("Shields raised."))
-       if game.energy <= 0:
-           skip(1)
-           prout(_("Shields raising uses up last of energy."))
-           finish(FNRG)
-           return
-       game.ididit=True
-       return
+        key = scanner.nexttok()
+        if key == "IHALPHA":
+            if scanner.sees("transfer"):
+                action = "NRG"
+            else:
+                if damaged(DSHIELD):
+                    prout(_("Shields damaged and down."))
+                    return
+                if scanner.sees("up"):
+                    action = "SHUP"
+                elif scanner.sees("down"):
+                    action = "SHDN"
+        if action == "NONE":
+            proutn(_("Do you wish to change shield energy? "))
+            if ja():
+                action = "NRG"
+            elif damaged(DSHIELD):
+                prout(_("Shields damaged and down."))
+                return
+            elif game.shldup:
+                proutn(_("Shields are up. Do you want them down? "))
+                if ja():
+                    action = "SHDN"
+                else:
+                    scanner.chew()
+                    return
+            else:
+                proutn(_("Shields are down. Do you want them up? "))
+                if ja():
+                    action = "SHUP"
+                else:
+                    scanner.chew()
+                    return
+    if action == "SHUP": # raise shields
+        if game.shldup:
+            prout(_("Shields already up."))
+            return
+        game.shldup = True
+        game.shldchg = True
+        if game.condition != "docked":
+            game.energy -= 50.0
+        prout(_("Shields raised."))
+        if game.energy <= 0:
+            skip(1)
+            prout(_("Shields raising uses up last of energy."))
+            finish(FNRG)
+            return
+        game.ididit = True
+        return
     elif action == "SHDN":
-       if not game.shldup:
-           prout(_("Shields already down."))
-           return
-       game.shldup=False
-       game.shldchg=True
-       prout(_("Shields lowered."))
-       game.ididit = True
-       return
+        if not game.shldup:
+            prout(_("Shields already down."))
+            return
+        game.shldup = False
+        game.shldchg = True
+        prout(_("Shields lowered."))
+        game.ididit = True
+        return
     elif action == "NRG":
-       while scanner.next() != "IHREAL":
-           scanner.chew()
-           proutn(_("Energy to transfer to shields- "))
+        while scanner.nexttok() != "IHREAL":
+            scanner.chew()
+            proutn(_("Energy to transfer to shields- "))
         nrg = scanner.real
-       scanner.chew()
-       if nrg == 0:
-           return
-       if nrg > game.energy:
-           prout(_("Insufficient ship energy."))
-           return
-       game.ididit = True
-       if game.shield+nrg >= game.inshld:
-           prout(_("Shield energy maximized."))
-           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 nrg < 0.0 and game.energy-nrg > game.inenrg:
-           # Prevent shield drain loophole 
-           skip(1)
-           prout(_("Engineering to bridge--"))
-           prout(_("  Scott here. Power circuit problem, Captain."))
-           prout(_("  I can't drain the shields."))
-           game.ididit = False
-           return
-       if game.shield+nrg < 0:
-           prout(_("All shield energy transferred to ship."))
-           game.energy += game.shield
-           game.shield = 0.0
-           return
-       proutn(_("Scotty- \""))
-       if nrg > 0:
-           prout(_("Transferring energy to shields.\""))
-       else:
-           prout(_("Draining energy from shields.\""))
-       game.shield += nrg
-       game.energy -= nrg
-       return
+        scanner.chew()
+        if nrg == 0:
+            return
+        if nrg > game.energy:
+            prout(_("Insufficient ship energy."))
+            return
+        game.ididit = True
+        if game.shield+nrg >= game.inshld:
+            prout(_("Shield energy maximized."))
+            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 nrg < 0.0 and game.energy-nrg > game.inenrg:
+            # Prevent shield drain loophole
+            skip(1)
+            prout(_("Engineering to bridge--"))
+            prout(_("  Scott here. Power circuit problem, Captain."))
+            prout(_("  I can't drain the shields."))
+            game.ididit = False
+            return
+        if game.shield+nrg < 0:
+            prout(_("All shield energy transferred to ship."))
+            game.energy += game.shield
+            game.shield = 0.0
+            return
+        proutn(_("Scotty- \""))
+        if nrg > 0:
+            prout(_("Transferring energy to shields.\""))
+        else:
+            prout(_("Draining energy from shields.\""))
+        game.shield += nrg
+        game.energy -= nrg
+        return
 
 def randdevice():
     "Choose a device to damage, at random."
     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% 
-       65,     # DWARPEN: warp drive                    6.5% 
-       70,     # DIMPULS: impulse engines               6.5% 
-       145,    # DSHIELD: deflector shields            14.5% 
-       30,     # DRADIO:  subspace radio                3.0% 
-       45,     # DSHUTTL: shuttle                       4.5% 
-       15,     # DCOMPTR: computer                      1.5% 
-       20,     # NAVCOMP: navigation system             2.0% 
-       75,     # DTRANSP: transporter                   7.5% 
-       20,     # DSHCTRL: high-speed shield controller  2.0% 
-       10,     # DDRAY: death ray                       1.0% 
-       30,     # DDSP: deep-space probes                3.0% 
+        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%
+        65,        # DWARPEN: warp drive                         6.5%
+        70,        # DIMPULS: impulse engines                 6.5%
+        145,        # DSHIELD: deflector shields                14.5%
+        30,        # DRADIO:  subspace radio                 3.0%
+        45,        # DSHUTTL: shuttle                         4.5%
+        15,        # DCOMPTR: computer                         1.5%
+        20,        # NAVCOMP: navigation system                 2.0%
+        75,        # DTRANSP: transporter                         7.5%
+        20,        # DSHCTRL: high-speed shield controller  2.0%
+        10,        # DDRAY: death ray                         1.0%
+        30,        # DDSP: deep-space probes                 3.0%
+        0,         # DCLOAK: the cloaking device             0.0
     )
     assert(sum(weights) == 1000)
     idx = randrange(1000)
     wsum = 0
     for (i, w) in enumerate(weights):
-       wsum += w
-       if idx < wsum:
-           return i
-    return None;       # we should never get here
+        wsum += w
+        if idx < wsum:
+            return i
+    return None        # we should never get here
 
 def collision(rammed, enemy):
-    "Collision handling fot rammong events."
+    "Collision handling for rammong events."
     prouts(_("***RED ALERT!  RED ALERT!"))
     skip(1)
     prout(_("***COLLISION IMMINENT."))
@@ -1024,7 +1152,7 @@ def collision(rammed, enemy):
         proutn(_(" rams "))
     proutn(crmena(False, enemy.type, "sector", enemy.location))
     if rammed:
-       proutn(_(" (original position)"))
+        proutn(_(" (original position)"))
     skip(1)
     deadkl(enemy.location, enemy.type, game.sector)
     proutn("***" + crmshp() + " heavily damaged.")
@@ -1038,236 +1166,242 @@ def collision(rammed, enemy):
     ncrits = randrange(NDEVICES/2)
     while ncrits > 0:
         ncrits -= 1
-       dev = randdevice()
-       if game.damage[dev] < 0:
-           continue
-       extradm = (10.0*hardness*randreal()+1.0)*game.damfac
-       # Damage for at least time of travel! 
-       game.damage[dev] += game.optime + extradm
+        dev = randdevice()
+        if game.damage[dev] < 0:
+            continue
+        extradm = (10.0*hardness*randreal()+1.0)*game.damfac
+        # Damage for at least time of travel!
+        game.damage[dev] += game.optime + extradm
     game.shldup = False
     prout(_("***Shields are down."))
     if game.state.remkl + len(game.state.kcmdr) + game.state.nscrem:
-       announce()
-       damagereport()
+        announce()
+        damagereport()
     else:
-       finish(FWON)
+        finish(FWON)
     return
 
 def torpedo(origin, bearing, dispersion, number, nburst):
-    "Let a photon torpedo fly" 
-    if not damaged(DSRSENS) or game.condition=="docked":
-       setwnd(srscan_window)
-    else: 
-       setwnd(message_window)
-    ac = bearing + 0.25*dispersion     # dispersion is a random variable
+    "Let a photon torpedo fly"
+    if not damaged(DSRSENS) or game.condition == "docked":
+        setwnd(srscan_window)
+    else:
+        setwnd(message_window)
+    ac = bearing + 0.25*dispersion        # dispersion is a random variable
     bullseye = (15.0 - bearing)*0.5235988
-    track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin)) 
-    bumpto = coord(0, 0)
-    # Loop to move a single torpedo 
+    track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin))
+    bumpto = Coord(0, 0)
+    # Loop to move a single torpedo
     setwnd(message_window)
     for step in range(1, QUADSIZE*2):
-        if not track.next(): break
+        if not track.nexttok():
+            break
         w = track.sector()
-       if not w.valid_sector():
-           break
-       iquad=game.quad[w.i][w.j]
-       tracktorpedo(origin, w, step, number, nburst, iquad)
-       if iquad=='.':
-           continue
-       # hit something 
-       if not damaged(DSRSENS) or game.condition == "docked":
-           skip(1);    # start new line after text track 
-       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-track.angle))
-           newcnd(); # we're blown out of dock 
-           if game.landed or game.condition=="docked":
-               return hit # Cheat if on a planet 
+        if not w.valid_sector():
+            break
+        iquad = game.quad[w.i][w.j]
+        tracktorpedo(w, step, number, nburst, iquad)
+        if iquad == '.':
+            continue
+        # hit something
+        setwnd(message_window)
+        if not damaged(DSRSENS) or game.condition == "docked":
+            skip(1)        # start new line after text track
+        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-track.angle))
+            newcnd() # we're blown out of dock
+            if game.landed or game.condition == "docked":
+                return hit # Cheat if on a planet
             # 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()
+            displacement = course(track.bearing+randreal(-2.4, 2.4), distance=2**0.5)
+            displacement.nexttok()
             bumpto = displacement.sector()
-           if not bumpto.valid_sector():
-               return hit
-           if game.quad[bumpto.i][bumpto.j]==' ':
-               finish(FHOLE)
-               return hit
-           if game.quad[bumpto.i][bumpto.j]!='.':
-               # can't move into object 
-               return hit
-           game.sector = bumpto
-           proutn(crmshp())
-            game.quad[w.i][w.j]='.'
-            game.quad[bumpto.i][bumpto.j]=iquad
+            if not bumpto.valid_sector():
+                return hit
+            if game.quad[bumpto.i][bumpto.j] == ' ':
+                finish(FHOLE)
+                return hit
+            if game.quad[bumpto.i][bumpto.j] != '.':
+                # can't move into object
+                return hit
+            game.sector = bumpto
+            proutn(crmshp())
+            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))
+            sortenemies()
             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 ('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
             for enemy in game.enemies:
-               if w == enemy.location:
-                   break
-           kp = math.fabs(enemy.power)
-           h1 = 700.0 + randrange(100) - \
-               1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
-           h1 = math.fabs(h1)
-           if kp < h1:
-               h1 = kp
-            if enemy.power < 0:
-                enemy.power -= -h1
-            else:
-                enemy.power -= h1
-           if enemy.power == 0:
-               deadkl(w, iquad, w)
-               return None
-           proutn(crmena(True, iquad, "sector", w))
-            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[bumpto.i][bumpto.j] == ' ':
-               prout(_(" buffeted into black hole."))
-               deadkl(w, iquad, bumpto)
-           if game.quad[bumpto.i][bumpto.j] != '.':
-               prout(_(" damaged but not destroyed."))
+                if w == enemy.location:
+                    kp = math.fabs(enemy.power)
+                    h1 = 700.0 + randrange(100) - \
+                        1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
+                    h1 = math.fabs(h1)
+                    if kp < h1:
+                        h1 = kp
+                    if enemy.power < 0:
+                        enemy.power -= -h1
+                    else:
+                        enemy.power -= h1
+                    if enemy.power == 0:
+                        deadkl(w, iquad, w)
+                        return None
+                    proutn(crmena(True, iquad, "sector", w))
+                    displacement = course(track.bearing+randreal(-2.4, 2.4), distance=2**0.5)
+                    displacement.nexttok()
+                    bumpto = displacement.sector()
+                    if not bumpto.valid_sector():
+                        prout(_(" damaged but not destroyed."))
+                        return
+                    if game.quad[bumpto.i][bumpto.j] == ' ':
+                        prout(_(" buffeted into black hole."))
+                        deadkl(w, iquad, bumpto)
+                    if game.quad[bumpto.i][bumpto.j] != '.':
+                        prout(_(" damaged but not destroyed."))
+                    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()
+                        sortenemies()
+                    break
             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))
+                prout("Internal error, no enemy where expected!")
+                raise SystemExit(1)
             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.i][w.j]='.'
-           game.base.invalidate()
-           game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase -= 1
-           game.state.chart[game.quadrant.i][game.quadrant.j].starbase -= 1
-           game.state.basekl += 1
-           newcnd()
-           return None
-       elif iquad == 'P': # Hit a planet 
-           prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
-           game.state.nplankl += 1
-           game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
-           game.iplnet.pclass = "destroyed"
-           game.iplnet = None
-           game.plnet.invalidate()
-           game.quad[w.i][w.j] = '.'
-           if game.landed:
-               # captain perishes on planet 
-               finish(FDPLANET)
-           return None
-       elif iquad == '@': # Hit an inhabited world -- very bad! 
-           prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
-           game.state.nworldkl += 1
-           game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
-           game.iplnet.pclass = "destroyed"
-           game.iplnet = None
-           game.plnet.invalidate()
-           game.quad[w.i][w.j] = '.'
-           if game.landed:
-               # captain perishes on planet 
-               finish(FDPLANET)
-           prout(_("The torpedo destroyed an inhabited planet."))
-           return None
-       elif iquad == '*': # Hit a star 
-           if withprob(0.9):
-               nova(w)
+        elif iquad == 'B': # Hit a base
+            skip(1)
+            prout(_("***STARBASE DESTROYED.."))
+            game.state.baseq = [x for x in game.state.baseq if x != game.quadrant]
+            game.quad[w.i][w.j] = '.'
+            game.base.invalidate()
+            game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase = False
+            game.state.chart[game.quadrant.i][game.quadrant.j].starbase = False
+            game.state.basekl += 1
+            newcnd()
+            return None
+        elif iquad == 'P': # Hit a planet
+            prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
+            game.state.nplankl += 1
+            game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
+            game.iplnet.pclass = "destroyed"
+            game.iplnet = None
+            game.plnet.invalidate()
+            game.quad[w.i][w.j] = '.'
+            if game.landed:
+                # captain perishes on planet
+                finish(FDPLANET)
+            return None
+        elif iquad == '@': # Hit an inhabited world -- very bad!
+            prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
+            game.state.nworldkl += 1
+            game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
+            game.iplnet.pclass = "destroyed"
+            game.iplnet = None
+            game.plnet.invalidate()
+            game.quad[w.i][w.j] = '.'
+            if game.landed:
+                # captain perishes on planet
+                finish(FDPLANET)
+            prout(_("The torpedo destroyed an inhabited planet."))
+            return None
+        elif iquad == '*': # Hit a star
+            if withprob(0.9):
+                nova(w)
             else:
                 prout(crmena(True, '*', "sector", w) + _(" unaffected by photon blast."))
-           return None
-       elif iquad == '?': # Hit a thingy 
-           if not (game.options & OPTION_THINGY) or withprob(0.3):
-               skip(1)
-               prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
-               skip(1)
-               prouts(_("    HACK!     HACK!    HACK!        *CHOKE!*  "))
-               skip(1)
-               proutn(_("Mr. Spock-"))
-               prouts(_("  \"Fascinating!\""))
-               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
-           return None
-       elif iquad == ' ': # Black hole 
-           skip(1)
-           prout(crmena(True, ' ', "sector", w) + _(" swallows torpedo."))
-           return None
-       elif iquad == '#': # hit the web 
-           skip(1)
-           prout(_("***Torpedo absorbed by Tholian web."))
-           return None
-       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.i][w.j] = '.'
-               deadkl(w, iquad, w)
-               game.tholian = None
-               return None
-           skip(1)
-           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.i][w.j] = '#'
-           dropin(' ')
-           return None
+            return None
+        elif iquad == '?': # Hit a thingy
+            if not (game.options & OPTION_THINGY) or withprob(0.3):
+                skip(1)
+                prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
+                skip(1)
+                prouts(_("    HACK!     HACK!    HACK!        *CHOKE!*  "))
+                skip(1)
+                proutn(_("Mr. Spock-"))
+                prouts(_("  \"Fascinating!\""))
+                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()
+            return None
+        elif iquad == ' ': # Black hole
+            skip(1)
+            prout(crmena(True, ' ', "sector", w) + _(" swallows torpedo."))
+            return None
+        elif iquad == '#': # hit the web
+            skip(1)
+            prout(_("***Torpedo absorbed by Tholian web."))
+            return None
+        elif iquad == 'T':  # Hit a Tholian
+            h1 = 700.0 + randrange(100) - \
+                1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
+            h1 = math.fabs(h1)
+            if h1 >= 600:
+                game.quad[w.i][w.j] = '.'
+                deadkl(w, iquad, w)
+                game.tholian = None
+                return None
+            skip(1)
+            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.i][w.j] = '#'
+            dropin(' ')
+            return None
         else: # Problem!
-           skip(1)
-           proutn("Don't know how to handle torpedo collision with ")
-           proutn(crmena(True, iquad, "sector", w))
-           skip(1)
-           return None
-       break
+            skip(1)
+            proutn("Don't know how to handle torpedo collision with ")
+            proutn(crmena(True, iquad, "sector", w))
+            skip(1)
+            return None
+        break
     skip(1)
+    setwnd(message_window)
     prout(_("Torpedo missed."))
-    return None;
+    return None
 
 def fry(hit):
-    "Critical-hit resolution." 
+    "Critical-hit resolution."
     if hit < (275.0-25.0*game.skill)*randreal(1.0, 1.5):
-       return
+        return
     ncrit = int(1.0 + hit/(500.0+randreal(100)))
     proutn(_("***CRITICAL HIT--"))
     # Select devices and cause damage
     cdam = []
     while ncrit > 0:
-        ncrit -= 1
         while True:
-           j = randdevice()
-           # Cheat to prevent shuttle damage unless on ship 
-            if not (game.damage[j]<0.0 or (j==DSHUTTL and game.iscraft != "onship")):
+            j = randdevice()
+            # Cheat to prevent shuttle damage unless on ship
+            if not (game.damage[j]<0.0 or (j == DSHUTTL and game.iscraft != "onship") or (j == DCLOAK and game.ship != 'E' or j == DDRAY)):
                 break
-       cdam.append(j)
-       extradm = (hit*game.damfac)/(ncrit*randreal(75, 100))
-       game.damage[j] += extradm
+        cdam.append(j)
+        extradm = (hit*game.damfac)/(ncrit*randreal(75, 100))
+        game.damage[j] += extradm
+        ncrit -= 1
     skipcount = 0
     for (i, j) in enumerate(cdam):
-       proutn(device[j])
+        proutn(device[j])
         if skipcount % 3 == 2 and i < len(cdam)-1:
             skip(1)
         skipcount += 1
@@ -1275,174 +1409,199 @@ def fry(hit):
             proutn(_(" and "))
     prout(_(" damaged."))
     if damaged(DSHIELD) and game.shldup:
-       prout(_("***Shields knocked down."))
-       game.shldup=False
+        prout(_("***Shields knocked down."))
+        game.shldup = False
+    if damaged(DCLOAK) and game.iscloaked:
+        prout(_("***Cloaking device rendered inoperative."))
+        game.iscloaked = False
 
 def attack(torps_ok):
-    # bad guy attacks us 
-    # torps_ok == False forces use of phasers in an attack 
+    # bad guy attacks us
+    # torps_ok == False forces use of phasers in an attack
+    if game.iscloaked:
+        return
     # 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
+        return
+    attempt = False
+    ihurt = False
+    hitmax = 0.0
+    hittot = 0.0
+    chgfac = 1.0
     where = "neither"
     if game.idebug:
-       prout("=== ATTACK!")
-    # Tholian gets to move before attacking 
+        prout("=== ATTACK!")
+    # Tholian gets to move before attacking
     if game.tholian:
-       movetholian()
-    # if you have just entered the RNZ, you'll get a warning 
-    if game.neutz: # The one chance not to be attacked 
-       game.neutz = False
-       return
-    # commanders get a chance to tac-move towards you 
-    if (((game.quadrant in game.state.kcmdr or game.state.kscmdr==game.quadrant) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok:
-       moveklings()
-    # if no enemies remain after movement, we're done 
-    if len(game.enemies)==0 or (len(game.enemies)==1 and thing == game.quadrant and not thing.angry):
-       return
-    # set up partial hits if attack happens during shield status change 
+        movetholian()
+    # if you have just entered the RNZ, you'll get a warning
+    if game.neutz: # The one chance not to be attacked
+        game.neutz = False
+        return
+    # commanders get a chance to tac-move towards you
+    if (((game.quadrant in game.state.kcmdr or game.state.kscmdr == game.quadrant) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok:
+        for (bugout, enemy, old, goto) in  moveklings():
+            if bugout:
+                # we know about this if either short or long range
+                # sensors are working
+                if damaged(DSRSENS) and damaged(DLRSENS) \
+                       and game.condition != "docked":
+                    prout(crmena(True, enemy.type, "sector", old) + \
+                          (_(" escapes to Quadrant %s (and regains strength).") % goto))
+            else: # Enemy still in-sector
+                if enemy.move(goto):
+                    if not damaged(DSRSENS) or game.condition == "docked":
+                        proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.location))
+                        if enemy.kdist < old:
+                            proutn(_(" advances to "))
+                        else:
+                            proutn(_(" retreats to "))
+                        prout("Sector %s." % goto)
+        sortenemies()
+    # if no enemies remain after movement, we're done
+    if len(game.enemies) == 0 or (len(game.enemies) == 1 and thing.at(game.quadrant) and not thing.angered):
+        return
+    # set up partial hits if attack happens during shield status change
     pfac = 1.0/game.inshld
     if game.shldchg:
-       chgfac = 0.25 + randreal(0.5)
+        chgfac = 0.25 + randreal(0.5)
     skip(1)
-    # message verbosity control 
+    # message verbosity control
     if game.skill <= SKILL_FAIR:
-       where = "sector"
+        where = "sector"
     for enemy in game.enemies:
-       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.power < 500:
-           r *= 0.25; 
-       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 == '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.power*math.pow(dustfac,enemy.kavgd)
-           enemy.power *= 0.75
-       else: # Enemy uses photon torpedo 
-           # We should be able to make the bearing() method work here
-           pcourse = 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.location))
-           attempt = True
-           prout("  ")
-           dispersion = (randreal()+randreal())*0.5 - 0.5
-           dispersion += 0.002*enemy.power*dispersion
-           hit = torpedo(enemy.location, pcourse, 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.i][game.quadrant.j].supernova or game.alldone:
-               return # Supernova or finished 
-           if hit == None:
-               continue
-       # incoming phaser or torpedo, shields may dissipate it 
-       if game.shldup or game.shldchg or game.condition=="docked":
-           # shields will take hits 
-           propor = pfac * game.shield
-            if game.condition =="docked":
+        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.power < 500:
+            r *= 0.25
+        if enemy.type == 'T' or (enemy.type == '?' and not thing.angered):
+            continue
+        # different enemies have different probabilities of throwing a torp
+        usephasers = not torps_ok or \
+            (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.power*math.pow(dustfac, enemy.kavgd)
+            enemy.power *= 0.75
+        else: # Enemy uses photon torpedo
+            # We should be able to make the bearing() method work here
+            pcourse = 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.location))
+            attempt = True
+            prout("  ")
+            dispersion = (randreal()+randreal())*0.5 - 0.5
+            dispersion += 0.002*enemy.power*dispersion
+            hit = torpedo(enemy.location, pcourse, 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.i][game.quadrant.j].supernova or game.alldone:
+                return # Supernova or finished
+            if hit is None:
+                continue
+        # incoming phaser or torpedo, shields may dissipate it
+        if game.shldup or game.shldchg or game.condition == "docked":
+            # shields will take hits
+            propor = pfac * game.shield
+            if game.condition == "docked":
                 propor *= 2.1
-           if propor < 0.1:
-               propor = 0.1
-           hitsh = propor*chgfac*hit+1.0
-           absorb = 0.8*hitsh
-           if absorb > game.shield:
-               absorb = game.shield
-           game.shield -= absorb
-           hit -= hitsh
-           # taking a hit blasts us out of a starbase dock 
-           if game.condition == "docked":
-               dock(False)
-           # but the shields may take care of it 
-           if propor > 0.1 and hit < 0.005*game.energy:
-               continue
-       # hit from this opponent got through shields, so take damage 
-       ihurt = True
-       proutn(_("%d unit hit") % int(hit))
-       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.location))
-       skip(1)
-       # Decide if hit is critical 
-       if hit > hitmax:
-           hitmax = hit
-       hittot += hit
-       fry(hit)
-       game.energy -= hit
+            if propor < 0.1:
+                propor = 0.1
+            hitsh = propor*chgfac*hit+1.0
+            absorb = 0.8*hitsh
+            if absorb > game.shield:
+                absorb = game.shield
+            game.shield -= absorb
+            hit -= hitsh
+            # taking a hit blasts us out of a starbase dock
+            if game.condition == "docked":
+                dock(False)
+            # but the shields may take care of it
+            if propor > 0.1 and hit < 0.005*game.energy:
+                continue
+        # hit from this opponent got through shields, so take damage
+        ihurt = True
+        proutn(_("%d unit hit") % int(hit))
+        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.location))
+        skip(1)
+        # Decide if hit is critical
+        if hit > hitmax:
+            hitmax = hit
+        hittot += hit
+        fry(hit)
+        game.energy -= hit
     if game.energy <= 0:
-       # Returning home upon your shield, not with it... 
-       finish(FBATTLE)
-       return
+        # Returning home upon your shield, not with it...
+        finish(FBATTLE)
+        return
     if not attempt and game.condition == "docked":
-       prout(_("***Enemies decide against attacking your ship."))
+        prout(_("***Enemies decide against attacking your ship."))
     percent = 100.0*pfac*game.shield+0.5
     if not ihurt:
-       # Shields fully protect ship 
-       proutn(_("Enemy attack reduces shield strength to "))
+        # Shields fully protect ship
+        proutn(_("Enemy attack reduces shield strength to "))
     else:
-       # Emit message if starship suffered hit(s) 
-       skip(1)
-       proutn(_("Energy left %2d    shields ") % int(game.energy))
-       if game.shldup:
-           proutn(_("up "))
-       elif not damaged(DSHIELD):
-           proutn(_("down "))
-       else:
-           proutn(_("damaged, "))
+        # Emit message if starship suffered hit(s)
+        skip(1)
+        proutn(_("Energy left %2d    shields ") % int(game.energy))
+        if game.shldup:
+            proutn(_("up "))
+        elif not damaged(DSHIELD):
+            proutn(_("down "))
+        else:
+            proutn(_("damaged, "))
     prout(_("%d%%,   torpedoes left %d") % (percent, game.torps))
-    # Check if anyone was hurt 
+    # Check if anyone was hurt
     if hitmax >= 200 or hittot >= 500:
-       icas = randrange(int(hittot * 0.015))
-       if icas >= 2:
-           skip(1)
-           prout(_("Mc Coy-  \"Sickbay to bridge.  We suffered %d casualties") % icas)
-           prout(_("   in that last attack.\""))
-           game.casual += icas
-           game.state.crew -= icas
-    # After attack, reset average distance to enemies 
+        icas = randrange(int(hittot * 0.015))
+        if icas >= 2:
+            skip(1)
+            prout(_("Mc Coy-  \"Sickbay to bridge.  We suffered %d casualties") % icas)
+            prout(_("   in that last attack.\""))
+            game.casual += icas
+            game.state.crew -= icas
+    # After attack, reset average distance to enemies
     for enemy in game.enemies:
-       enemy.kavgd = enemy.kdist
-    game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+        enemy.kavgd = enemy.kdist
+    sortenemies()
     return
-               
-def deadkl(w, type, mv):
-    "Kill a Klingon, Tholian, Romulan, or Thingy." 
-    # 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 == 'R':
-        # Chalk up a Romulan 
+
+def deadkl(w, etype, mv):
+    "Kill a Klingon, Tholian, Romulan, or Thingy."
+    # Added mv to allow enemy to "move" before dying
+    proutn(crmena(True, etype, "sector", mv))
+    # Decide what kind of enemy it is and update appropriately
+    if etype == '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 == 'T':
-        # Killed a Tholian 
+    elif etype == 'T':
+        # Killed a Tholian
         game.tholian = None
-    elif type == '?':
+    elif etype == '?':
         # Killed a Thingy
         global thing
         thing = None
     else:
-        # Killed some type of Klingon 
+        # Killed some type of Klingon
         game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
         game.klhere -= 1
         if type == 'C':
@@ -1451,7 +1610,7 @@ def deadkl(w, type, mv):
             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)    
+                unschedule(FCDBAS)
         elif type ==  'K':
             game.state.remkl -= 1
         elif type ==  'S':
@@ -1461,34 +1620,34 @@ def deadkl(w, type, mv):
             game.iscate = False
             unschedule(FSCMOVE)
             unschedule(FSCDBAS)
-    # For each kind of enemy, finish message to player 
+    # For each kind of enemy, finish message to player
     prout(_(" destroyed."))
-    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
-       return
+    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
+        return
     game.recompute()
     # Remove enemy ship from arrays describing local conditions
     for e in game.enemies:
-       if e.location == w:
+        if e.location == w:
             e.move(None)
-           break
+            break
     return
 
 def targetcheck(w):
     "Return None if target is invalid, otherwise return a course angle."
     if not w.valid_sector():
-       huh()
-       return None
-    delta = coord()
-    # FIXME: C code this was translated from is wacky -- why the sign reversal?
-    delta.j = (w.j - game.sector.j);
-    delta.i = (game.sector.i - w.i);
-    if delta == coord(0, 0):
-       skip(1)
-       prout(_("Spock-  \"Bridge to sickbay.  Dr. McCoy,"))
-       prout(_("  I recommend an immediate review of"))
-       prout(_("  the Captain's psychological profile.\""))
-       scanner.chew()
-       return None
+        huh()
+        return None
+    delta = Coord()
+    # C code this was translated from is wacky -- why the sign reversal?
+    delta.j = (w.j - game.sector.j)
+    delta.i = (game.sector.i - w.i)
+    if delta == Coord(0, 0):
+        skip(1)
+        prout(_("Spock-  \"Bridge to sickbay.  Dr. McCoy,"))
+        prout(_("  I recommend an immediate review of"))
+        prout(_("  the Captain's psychological profile.\""))
+        scanner.chew()
+        return None
     return delta.bearing()
 
 def torps():
@@ -1496,123 +1655,125 @@ def torps():
     tcourse = []
     game.ididit = False
     if damaged(DPHOTON):
-       prout(_("Photon tubes damaged."))
-       scanner.chew()
-       return
+        prout(_("Photon tubes damaged."))
+        scanner.chew()
+        return
     if game.torps == 0:
-       prout(_("No torpedoes left."))
-       scanner.chew()
-       return
+        prout(_("No torpedoes left."))
+        scanner.chew()
+        return
     # First, get torpedo count
     while True:
-        scanner.next()
-       if scanner.token == "IHALPHA":
-           huh()
-           return
-       elif scanner.token == "IHEOL" or not scanner.waiting():
-           prout(_("%d torpedoes left.") % game.torps)
+        scanner.nexttok()
+        if scanner.token == "IHALPHA":
+            huh()
+            return
+        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"
-           n = scanner.int()
-           if n <= 0: # abort command 
-               scanner.chew()
-               return
-           if n > MAXBURST:
-               scanner.chew()
-               prout(_("Maximum of %d torpedoes per burst.") % MAXBURST)
-               return
+            proutn(_("Number of torpedoes to fire- "))
+            continue        # Go back around to get a number
+        else: # key == "IHREAL"
+            n = scanner.int()
+            if n <= 0: # abort command
+                scanner.chew()
+                return
+            if n > MAXBURST:
+                scanner.chew()
+                prout(_("Maximum of %d torpedoes per burst.") % MAXBURST)
+                return
             if n > game.torps:
-                scanner.chew() # User requested more torps than available
-                continue       # Go back around
-            break      # All is good, go to next stage
+                scanner.chew()        # User requested more torps than available
+                continue        # Go back around
+            break        # All is good, go to next stage
     # Next, get targets
     target = []
     for i in range(n):
-       key = scanner.next()
-       if i==0 and key == "IHEOL":
-           break;      # no coordinate waiting, we will try prompting 
-       if i==1 and key == "IHEOL":
-           # direct all torpedoes at one target 
-           while i < n:
-               target.append(target[0])
-               tcourse.append(tcourse[0])
-               i += 1
-           break
+        key = scanner.nexttok()
+        if i == 0 and key == "IHEOL":
+            break        # no coordinate waiting, we will try prompting
+        if i == 1 and key == "IHEOL":
+            # direct all torpedoes at one target
+            while i < n:
+                target.append(target[0])
+                tcourse.append(tcourse[0])
+                i += 1
+            break
         scanner.push(scanner.token)
         target.append(scanner.getcoord())
-        if target[-1] == None:
+        if target[-1] is None:
             return
         tcourse.append(targetcheck(target[-1]))
-        if tcourse[-1] == None:
-           return
+        if tcourse[-1] is None:
+            return
     scanner.chew()
     if len(target) == 0:
-       # prompt for each one 
-       for i in range(n):
-           proutn(_("Target sector for torpedo number %d- ") % (i+1))
-           scanner.chew()
+        # prompt for each one
+        for i in range(n):
+            proutn(_("Target sector for torpedo number %d- ") % (i+1))
+            scanner.chew()
             target.append(scanner.getcoord())
-            if target[-1] == None:
+            if target[-1] is None:
                 return
             tcourse.append(targetcheck(target[-1]))
-            if tcourse[-1] == None:
+            if tcourse[-1] is None:
                 return
     game.ididit = True
-    # Loop for moving <n> torpedoes 
+    # Loop for moving <n> torpedoes
     for i in range(n):
-       if game.condition != "docked":
-           game.torps -= 1
-       dispersion = (randreal()+randreal())*0.5 -0.5
-       if math.fabs(dispersion) >= 0.47:
-           # misfire! 
-           dispersion *= randreal(1.2, 2.2)
-           if n > 0:
-               prouts(_("***TORPEDO NUMBER %d MISFIRES") % (i+1))
-           else:
-               prouts(_("***TORPEDO MISFIRES."))
-           skip(1)
-           if i < n:
-               prout(_("  Remainder of burst aborted."))
-           if withprob(0.2):
-               prout(_("***Photon tubes damaged by misfire."))
-               game.damage[DPHOTON] = game.damfac * randreal(1.0, 3.0)
-           break
-       if game.shldup or game.condition == "docked":
-           dispersion *= 1.0 + 0.0001*game.shield
-       torpedo(game.sector, tcourse[i], dispersion, number=i, nburst=n)
-       if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
-           return
+        if game.condition != "docked":
+            game.torps -= 1
+        dispersion = (randreal()+randreal())*0.5 -0.5
+        if math.fabs(dispersion) >= 0.47:
+            # misfire!
+            dispersion *= randreal(1.2, 2.2)
+            if n > 0:
+                prouts(_("***TORPEDO NUMBER %d MISFIRES") % (i+1))
+            else:
+                prouts(_("***TORPEDO MISFIRES."))
+            skip(1)
+            if i < n:
+                prout(_("  Remainder of burst aborted."))
+            if withprob(0.2):
+                prout(_("***Photon tubes damaged by misfire."))
+                game.damage[DPHOTON] = game.damfac * randreal(1.0, 3.0)
+            break
+        if game.iscloaked:
+            dispersion *= 1.2
+        elif game.shldup or game.condition == "docked":
+            dispersion *= 1.0 + 0.0001*game.shield
+        torpedo(game.sector, tcourse[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);
+        finish(FWON)
 
 def overheat(rpow):
     "Check for phasers overheating."
     if rpow > 1500:
         checkburn = (rpow-1500.0)*0.00038
         if withprob(checkburn):
-           prout(_("Weapons officer Sulu-  \"Phasers overheated, sir.\""))
-           game.damage[DPHASER] = game.damfac* randreal(1.0, 2.0) * (1.0+checkburn)
+            prout(_("Weapons officer Sulu-  \"Phasers overheated, sir.\""))
+            game.damage[DPHASER] = game.damfac* randreal(1.0, 2.0) * (1.0+checkburn)
 
 def checkshctrl(rpow):
     "Check shield control."
     skip(1)
     if withprob(0.998):
-       prout(_("Shields lowered."))
-       return False
-    # Something bad has happened 
+        prout(_("Shields lowered."))
+        return False
+    # Something bad has happened
     prouts(_("***RED ALERT!  RED ALERT!"))
     skip(2)
     hit = rpow*game.shield/game.inshld
     game.energy -= rpow+hit*0.8
     game.shield -= hit*0.2
     if game.energy <= 0.0:
-       prouts(_("Sulu-  \"Captain! Shield malf***********************\""))
-       skip(1)
-       stars()
-       finish(FPHASER)
-       return True
+        prouts(_("Sulu-  \"Captain! Shield malf***********************\""))
+        skip(1)
+        stars()
+        finish(FPHASER)
+        return True
     prouts(_("Sulu-  \"Captain! Shield malfunction! Phaser fire contained!\""))
     skip(2)
     prout(_("Lt. Uhura-  \"Sir, all decks reporting damage.\""))
@@ -1620,313 +1781,379 @@ def checkshctrl(rpow):
     skip(1)
     fry(0.8*hit)
     if icas:
-       skip(1)
-       prout(_("McCoy to bridge- \"Severe radiation burns, Jim."))
-       prout(_("  %d casualties so far.\"") % icas)
-       game.casual += icas
-       game.state.crew -= icas
+        skip(1)
+        prout(_("McCoy to bridge- \"Severe radiation burns, Jim."))
+        prout(_("  %d casualties so far.\"") % icas)
+        game.casual += icas
+        game.state.crew -= icas
     skip(1)
     prout(_("Phaser energy dispersed by shields."))
     prout(_("Enemy unaffected."))
     overheat(rpow)
-    return True;
+    return True
 
 def hittem(hits):
     "Register a phaser hit on Klingons and Romulans."
-    kk = 0
-    w = coord()
+    w = Coord()
     skip(1)
-    for (k, wham) in enumerate(hits):
-       if wham==0:
-           continue
-       dustfac = randreal(0.9, 1.0)
-       hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
-       kpini = game.enemies[kk].power
-       kp = math.fabs(kpini)
-       if PHASEFAC*hit < kp:
-           kp = PHASEFAC*hit
+    kk = 0
+    for wham in hits:
+        if wham == 0:
+            continue
+        dustfac = randreal(0.9, 1.0)
+        hit = wham*math.pow(dustfac, game.enemies[kk].kdist)
+        kpini = game.enemies[kk].power
+        kp = math.fabs(kpini)
+        if PHASEFAC*hit < kp:
+            kp = PHASEFAC*hit
         if game.enemies[kk].power < 0:
             game.enemies[kk].power -= -kp
         else:
             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.i][w.j]
-       if ienm=='?':
-           thing.angry = True
-       proutn(crmena(False, ienm, "sector", w))
-       skip(1)
-       if kpow == 0:
-           deadkl(w, ienm, w)
-           if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
-               finish(FWON);           
-           if game.alldone:
-               return
-           kk -= 1     # don't do the increment
+        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.i][w.j]
+        if ienm == '?':
+            thing.angry()
+        proutn(crmena(False, ienm, "sector", w))
+        skip(1)
+        if kpow == 0:
+            deadkl(w, ienm, w)
+            if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
+                finish(FWON)
+            if game.alldone:
+                return
+            kk -= 1        # don't do the increment
             continue
-       else: # decide whether or not to emasculate klingon 
-           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].power = -kpow
+        else: # decide whether or not to emasculate klingon
+            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].power = -kpow
         kk += 1
     return
 
 def phasers():
     "Fire phasers at bad guys."
     hits = []
-    kz = 0; k = 1; irec=0 # Cheating inhibitor 
-    ifast = False; no = False; itarg = True; msgflag = True; rpow=0
+    kz = 0
+    k = 1
+    irec = 0 # Cheating inhibitor
+    ifast = False
+    no = False
+    itarg = True
+    msgflag = True
+    rpow = 0.0
     automode = "NOTSET"
-    key=0
+    key = ""
     skip(1)
-    # SR sensors and Computer are needed for automode 
+    # SR sensors and Computer are needed for automode
     if damaged(DSRSENS) or damaged(DCOMPTR):
-       itarg = False
+        itarg = False
     if game.condition == "docked":
-       prout(_("Phasers can't be fired through base shields."))
-       scanner.chew()
-       return
+        prout(_("Phasers can't be fired through base shields."))
+        scanner.chew()
+        return
     if damaged(DPHASER):
-       prout(_("Phaser control damaged."))
-       scanner.chew()
-       return
+        prout(_("Phaser control damaged."))
+        scanner.chew()
+        return
     if game.shldup:
-       if damaged(DSHCTRL):
-           prout(_("High speed shield control damaged."))
-           scanner.chew()
-           return
-       if game.energy <= 200.0:
-           prout(_("Insufficient energy to activate high-speed shield control."))
-           scanner.chew()
-           return
-       prout(_("Weapons Officer Sulu-  \"High-speed shield control enabled, sir.\""))
-       ifast = True
+        if damaged(DSHCTRL):
+            prout(_("High speed shield control damaged."))
+            scanner.chew()
+            return
+        if game.energy <= 200.0:
+            prout(_("Insufficient energy to activate high-speed shield control."))
+            scanner.chew()
+            return
+        prout(_("Weapons Officer Sulu-  \"High-speed shield control enabled, sir.\""))
+        ifast = True
     # Original code so convoluted, I re-did it all
     # (That was Tom Almy talking about the C code, I think -- ESR)
-    while automode=="NOTSET":
-       key=scanner.next()
-       if key == "IHALPHA":
-           if scanner.sees("manual"):
-               if len(game.enemies)==0:
-                   prout(_("There is no enemy present to select."))
-                   scanner.chew()
-                   key = "IHEOL"
-                   automode="AUTOMATIC"
-               else:
-                   automode = "MANUAL"
-                   key = scanner.next()
-           elif scanner.sees("automatic"):
-               if (not itarg) and len(game.enemies) != 0:
-                   automode = "FORCEMAN"
-               else:
-                   if len(game.enemies)==0:
-                       prout(_("Energy will be expended into space."))
-                   automode = "AUTOMATIC"
-                   key = scanner.next()
-           elif scanner.sees("no"):
-               no = True
-           else:
-               huh()
-               return
-       elif key == "IHREAL":
-           if len(game.enemies)==0:
-               prout(_("Energy will be expended into space."))
-               automode = "AUTOMATIC"
-           elif not itarg:
-               automode = "FORCEMAN"
-           else:
-               automode = "AUTOMATIC"
-       else:
-           # "IHEOL" 
-           if len(game.enemies)==0:
-               prout(_("Energy will be expended into space."))
-               automode = "AUTOMATIC"
-           elif not itarg:
-               automode = "FORCEMAN"
-           else: 
-               proutn(_("Manual or automatic? "))
+    while automode == "NOTSET":
+        key = scanner.nexttok()
+        if key == "IHALPHA":
+            if scanner.sees("manual"):
+                if len(game.enemies)==0:
+                    prout(_("There is no enemy present to select."))
+                    scanner.chew()
+                    key = "IHEOL"
+                    automode = "AUTOMATIC"
+                else:
+                    automode = "MANUAL"
+                    key = scanner.nexttok()
+            elif scanner.sees("automatic"):
+                if (not itarg) and len(game.enemies) != 0:
+                    automode = "FORCEMAN"
+                else:
+                    if len(game.enemies)==0:
+                        prout(_("Energy will be expended into space."))
+                    automode = "AUTOMATIC"
+                    key = scanner.nexttok()
+            elif scanner.sees("no"):
+                no = True
+            else:
+                huh()
+                return
+        elif key == "IHREAL":
+            if len(game.enemies)==0:
+                prout(_("Energy will be expended into space."))
+                automode = "AUTOMATIC"
+            elif not itarg:
+                automode = "FORCEMAN"
+            else:
+                automode = "AUTOMATIC"
+        else:
+            # "IHEOL"
+            if len(game.enemies)==0:
+                prout(_("Energy will be expended into space."))
+                automode = "AUTOMATIC"
+            elif not itarg:
+                automode = "FORCEMAN"
+            else:
+                proutn(_("Manual or automatic? "))
                 scanner.chew()
     avail = game.energy
     if ifast:
         avail -= 200.0
     if automode == "AUTOMATIC":
-       if key == "IHALPHA" and scanner.sees("no"):
-           no = True
-           key = scanner.next()
-       if key != "IHREAL" and len(game.enemies) != 0:
-           prout(_("Phasers locked on target. Energy available: %.2f")%avail)
-       irec=0
+        if key == "IHALPHA" and scanner.sees("no"):
+            no = True
+            key = scanner.nexttok()
+        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].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":
-               return
-           rpow = scanner.real
-           if rpow > avail:
-               proutn(_("Energy available= %.2f") % avail)
-               skip(1)
-               key = "IHEOL"
+            scanner.chew()
+            if not kz:
+                for i in range(len(game.enemies)):
+                    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.nexttok()
+            if key != "IHREAL":
+                return
+            rpow = scanner.real
+            if rpow > avail:
+                proutn(_("Energy available= %.2f") % avail)
+                skip(1)
+                key = "IHEOL"
             if not rpow > avail:
                 break
-       if rpow<=0:
-           # chicken out 
-           scanner.chew()
-           return
-        key=scanner.next()
-       if key == "IHALPHA" and scanner.sees("no"):
-           no = True
-       if ifast:
-           game.energy -= 200; # Go and do it! 
-           if checkshctrl(rpow):
-               return
-       scanner.chew()
-       game.energy -= rpow
-       extra = rpow
-       if len(game.enemies):
-           extra = 0.0
-           powrem = rpow
-           for i in range(len(game.enemies)):
-               hits.append(0.0)
-               if powrem <= 0:
-                   continue
-               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
-               if powrem <= 0 and temp < hits[i]:
-                   hits[i] = temp
-               if powrem <= 0:
-                   over = 0.0
-               extra += over
-           if powrem > 0.0:
-               extra += powrem
-           hittem(hits)
-           game.ididit = True
-       if extra > 0 and not game.alldone:
-           if game.tholian:
-               proutn(_("*** Tholian web absorbs "))
-               if len(game.enemies)>0:
-                   proutn(_("excess "))
-               prout(_("phaser energy."))
-           else:
-               prout(_("%d expended on empty space.") % int(extra))
+        if rpow <= 0:
+            # chicken out
+            scanner.chew()
+            return
+        key = scanner.nexttok()
+        if key == "IHALPHA" and scanner.sees("no"):
+            no = True
+        if ifast:
+            game.energy -= 200 # Go and do it!
+            if checkshctrl(rpow):
+                return
+        scanner.chew()
+        game.energy -= rpow
+        extra = rpow
+        if len(game.enemies):
+            extra = 0.0
+            powrem = rpow
+            for i in range(len(game.enemies)):
+                hits.append(0.0)
+                if powrem <= 0:
+                    continue
+                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
+                if powrem <= 0 and temp < hits[i]:
+                    hits[i] = temp
+                if powrem <= 0:
+                    over = 0.0
+                extra += over
+            if powrem > 0.0:
+                extra += powrem
+            hittem(hits)
+            game.ididit = True
+        if extra > 0 and not game.alldone:
+            if game.tholian:
+                proutn(_("*** Tholian web absorbs "))
+                if len(game.enemies)>0:
+                    proutn(_("excess "))
+                prout(_("phaser energy."))
+            else:
+                prout(_("%d expended on empty space.") % int(extra))
     elif automode == "FORCEMAN":
-       scanner.chew()
-       key = "IHEOL"
-       if damaged(DCOMPTR):
-           prout(_("Battle computer damaged, manual fire only."))
-       else:
-           skip(1)
-           prouts(_("---WORKING---"))
-           skip(1)
-           prout(_("Short-range-sensors-damaged"))
-           prout(_("Insufficient-data-for-automatic-phaser-fire"))
-           prout(_("Manual-fire-must-be-used"))
-           skip(1)
+        scanner.chew()
+        key = "IHEOL"
+        if damaged(DCOMPTR):
+            prout(_("Battle computer damaged, manual fire only."))
+        else:
+            skip(1)
+            prouts(_("---WORKING---"))
+            skip(1)
+            prout(_("Short-range-sensors-damaged"))
+            prout(_("Insufficient-data-for-automatic-phaser-fire"))
+            prout(_("Manual-fire-must-be-used"))
+            skip(1)
     elif automode == "MANUAL":
-       rpow = 0.0
+        rpow = 0.0
         for k in range(len(game.enemies)):
-           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 \
+            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 ('C', 'S'):
-               prout(cramen(ienm) + _(" can't be located without short range scan."))
-               scanner.chew()
-               key = "IHEOL"
-               hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko 
-               k += 1
-               continue
-           if key == "IHEOL":
-               scanner.chew()
-               if itarg and k > kz:
-                   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):
-                   proutn("%d" % irec)
-               else:
-                   proutn("??")
-               proutn(")  ")
-               proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))                
-               key = scanner.next()
-           if key == "IHALPHA" and scanner.sees("no"):
-               no = True
-               key = scanner.next()
-               continue
-           if key == "IHALPHA":
-               huh()
-               return
-           if key == "IHEOL":
-               if k==1: # Let me say I'm baffled by this 
-                   msgflag = True
-               continue
-           if scanner.real < 0:
-               # abort out 
-               scanner.chew()
-               return
-           hits[k] = scanner.real
-           rpow += scanner.real
-           # If total requested is too much, inform and start over 
+                prout(cramen(ienm) + _(" can't be located without short range scan."))
+                scanner.chew()
+                key = "IHEOL"
+                hits[k] = 0 # prevent overflow -- thanks to Alexei Voitenko
+                k += 1
+                continue
+            if key == "IHEOL":
+                scanner.chew()
+                if itarg and k > kz:
+                    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):
+                    proutn("%d" % irec)
+                else:
+                    proutn("??")
+                proutn(")  ")
+                proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))
+                key = scanner.nexttok()
+            if key == "IHALPHA" and scanner.sees("no"):
+                no = True
+                key = scanner.nexttok()
+                continue
+            if key == "IHALPHA":
+                huh()
+                return
+            if key == "IHEOL":
+                if k == 1: # Let me say I'm baffled by this
+                    msgflag = True
+                continue
+            if scanner.real < 0:
+                # abort out
+                scanner.chew()
+                return
+            hits[k] = scanner.real
+            rpow += scanner.real
+            # If total requested is too much, inform and start over
             if rpow > avail:
-               prout(_("Available energy exceeded -- try again."))
-               scanner.chew()
-               return
-           key = scanner.next(); # scan for next value 
-           k += 1
-       if rpow == 0.0:
-           # zero energy -- abort 
-           scanner.chew()
-           return
-       if key == "IHALPHA" and scanner.sees("no"):
-           no = True
-       game.energy -= rpow
-       scanner.chew()
-       if ifast:
-           game.energy -= 200.0
-           if checkshctrl(rpow):
-               return
-       hittem(hits)
-       game.ididit = True
-     # Say shield raised or malfunction, if necessary 
+                prout(_("Available energy exceeded -- try again."))
+                scanner.chew()
+                return
+            key = scanner.nexttok() # scan for next value
+            k += 1
+        if rpow == 0.0:
+            # zero energy -- abort
+            scanner.chew()
+            return
+        if key == "IHALPHA" and scanner.sees("no"):
+            no = True
+        game.energy -= rpow
+        scanner.chew()
+        if ifast:
+            game.energy -= 200.0
+            if checkshctrl(rpow):
+                return
+        hittem(hits)
+        game.ididit = True
+     # Say shield raised or malfunction, if necessary
     if game.alldone:
-       return
+        return
     if ifast:
-       skip(1)
-       if no == 0:
-           if withprob(0.01):
-               prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
-               prouts(_("         CLICK   CLICK   POP  . . ."))
-               prout(_(" No response, sir!"))
-               game.shldup = False
-           else:
-               prout(_("Shields raised."))
-       else:
-           game.shldup = False
-    overheat(rpow);
-
-# Code from events,c begins here.
-
-# This isn't a real event queue a la BSD Trek yet -- you can only have one 
-# event of each type active at any given time.  Mostly these means we can 
+        skip(1)
+        if no == 0:
+            if withprob(0.01):
+                prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
+                prouts(_("         CLICK   CLICK   POP  . . ."))
+                prout(_(" No response, sir!"))
+                game.shldup = False
+            else:
+                prout(_("Shields raised."))
+        else:
+            game.shldup = False
+    overheat(rpow)
+
+
+def capture():
+    game.ididit = False # Nothing if we fail
+    game.optime = 0.0;
+
+    # Make sure there is room in the brig */
+    if game.brigfree == 0:
+        prout(_("Security reports the brig is already full."))
+        return;
+
+    if damaged(DRADIO):
+        prout(_("Uhura- \"We have no subspace radio communication, sir.\""))
+        return
+
+    if damaged(DTRANSP):
+        prout(_("Scotty- \"Transporter damaged, sir.\""))
+        return
+
+    # find out if there are any at all
+    if game.klhere < 1:
+        prout(_("Uhura- \"Getting no response, sir.\""))
+        return
+
+    # if there is more than one Klingon, find out which one */
+    #  Cruddy, just takes one at random.  Should ask the captain.
+    #  Nah, just select the weakest one since it is most likely to
+    #  surrender (Tom Almy mod)
+    klingons = [e for e in game.enemies if e.type == 'K']
+    weakest = sorted(klingons, key=lambda e: e.power)[0]
+    game.optime = 0.05         # This action will take some time
+    game.ididit = True #  So any others can strike back
+
+    # check out that Klingon
+    # The algorithm isn't that great and could use some more
+    # intelligent design
+    # x = 300 + 25*skill;
+    x = game.energy / (weakest.power * len(klingons))
+    x *= 2.5;  # would originally have been equivalent of 1.4,
+               # but we want command to work more often, more humanely */
+    #prout(_("Prob = %d (%.4f)\n", i, x))
+    #  x = 100; // For testing, of course!
+    if x > randreal(100):
+        # guess what, he surrendered!!! */
+        prout(_("Klingon captain at %s surrenders.") % weakest.location)
+        i = randreal(200)
+        if i > 0:
+            prout(_("%d Klingons commit suicide rather than be taken captive.") % 200 - i)
+        if i > brigfree:
+            prout(_("%d Klingons die because there is no room for them in the brig.") % i-brigfree)
+            i = brigfree
+        brigfree -= i
+        prout(_("%d captives taken") % i)
+        deadkl(weakest.location, weakest.type, game.sector)
+        if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)<=0:
+            finish(FWON)
+        return
+
+       # big surprise, he refuses to surrender */
+       prout(_("Fat chance, captain!"))
+
+# Code from events.c begins here.
+
+# This isn't a real event queue a la BSD Trek yet -- you can only have one
+# event of each type active at any given time.  Mostly these means we can
 # only have one FDISTR/FENSLV/FREPRO sequence going at any given time
 # BSD Trek, from which we swiped the idea, can have up to 5.
 
@@ -1955,36 +2182,40 @@ def postpone(evtype, offset):
 def cancelrest():
     "Rest period is interrupted by event."
     if game.resting:
-       skip(1)
-       proutn(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
-       if ja():
-           game.resting = False
-           game.optime = 0.0
-           return True
+        skip(1)
+        proutn(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
+        if ja():
+            game.resting = False
+            game.optime = 0.0
+            return True
     return False
 
 def events():
     "Run through the event queue looking for things to do."
-    i=0
-    fintim = game.state.date + game.optime; yank=0
-    ictbeam = False; istract = False
-    w = coord(); hold = coord()
-    ev = event(); ev2 = event()
+    i = 0
+    fintim = game.state.date + game.optime
+    yank = 0
+    ictbeam = False
+    istract = False
+    w = Coord()
+    hold = Coord()
+    ev = Event()
+    ev2 = Event()
 
     def tractorbeam(yank):
-        "Tractor-beaming cases merge here." 
+        "Tractor-beaming cases merge here."
         announce()
-        game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5) 
+        game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5)
         skip(1)
         prout("***" + crmshp() + _(" caught in long range tractor beam--"))
-        # If Kirk & Co. screwing around on planet, handle 
-        atover(True) # atover(true) is Grab 
+        # If Kirk & Co. screwing around on planet, handle
+        atover(True) # atover(true) is Grab
         if game.alldone:
             return
-        if game.icraft: # Caught in Galileo? 
+        if game.icraft: # Caught in Galileo?
             finish(FSTRACTOR)
             return
-        # Check to see if shuttle is aboard 
+        # Check to see if shuttle is aboard
         if game.iscraft == "offship":
             skip(1)
             if withprob(0.5):
@@ -2006,23 +2237,23 @@ def events():
             game.resting = False
         if not game.shldup:
             if not damaged(DSHIELD) and game.shield > 0:
-                doshield(shraise=True) # raise shields 
+                doshield(shraise=True) # raise shields
                 game.shldchg = False
             else:
                 prout(_("(Shields not currently useable.)"))
         newqad()
-        # Adjust finish time to time of tractor beaming 
-        fintim = game.state.date+game.optime
+        # Adjust finish time to time of tractor beaming?
+        fintim = game.state.date+game.optime
         attack(torps_ok=False)
         if not game.state.kcmdr:
             unschedule(FTBEAM)
-        else: 
+        else:
             schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr)))
 
     def destroybase():
-        "Code merges here for any commander destroying a starbase." 
-        # Not perfect, but will have to do 
-        # Handle case where base is in same quadrant as starship 
+        "Code merges here for any commander destroying a starbase."
+        # Not perfect, but will have to do
+        # Handle case where base is in same quadrant as starship
         if game.battle == game.quadrant:
             game.state.chart[game.battle.i][game.battle.j].starbase = False
             game.quad[game.base.i][game.base.j] = '.'
@@ -2031,405 +2262,410 @@ def events():
             skip(1)
             prout(_("Spock-  \"Captain, I believe the starbase has been destroyed.\""))
         elif game.state.baseq and communicating():
-            # Get word via subspace radio 
+            # Get word via subspace radio
             announce()
             skip(1)
             prout(_("Lt. Uhura-  \"Captain, Starfleet Command reports that"))
             proutn(_("   the starbase in Quadrant %s has been destroyed by") % game.battle)
-            if game.isatb == 2: 
+            if game.isatb == 2:
                 prout(_("the Klingon Super-Commander"))
             else:
                 prout(_("a Klingon Commander"))
             game.state.chart[game.battle.i][game.battle.j].starbase = False
-        # Remove Starbase from galaxy 
+        # Remove Starbase from galaxy
         game.state.galaxy[game.battle.i][game.battle.j].starbase = False
-        game.state.baseq = filter(lambda x: x != game.battle, game.state.baseq)
+        game.state.baseq = [x for x in game.state.baseq if x != game.battle]
         if game.isatb == 2:
-            # reinstate a commander's base attack 
+            # reinstate a commander's base attack
             game.battle = hold
             game.isatb = 0
         else:
             game.battle.invalidate()
     if game.idebug:
-       prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
-       for i in range(1, NEVENTS):
-           if   i == FSNOVA:  proutn("=== Supernova       ")
-           elif i == FTBEAM:  proutn("=== T Beam          ")
-           elif i == FSNAP:   proutn("=== Snapshot        ")
-           elif i == FBATTAK: proutn("=== Base Attack     ")
-           elif i == FCDBAS:  proutn("=== Base Destroy    ")
-           elif i == FSCMOVE: proutn("=== SC Move         ")
-           elif i == FSCDBAS: proutn("=== SC Base Destroy ")
-           elif i == FDSPROB: proutn("=== Probe Move      ")
-           elif i == FDISTR:  proutn("=== Distress Call   ")
-           elif i == FENSLV:  proutn("=== Enslavement     ")
-           elif i == FREPRO:  proutn("=== Klingon Build   ")
-           if is_scheduled(i):
-               prout("%.2f" % (scheduled(i)))
-           else:
-               prout("never")
+        prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
+        for i in range(1, NEVENTS):
+            if   i == FSNOVA:  proutn("=== Supernova       ")
+            elif i == FTBEAM:  proutn("=== T Beam          ")
+            elif i == FSNAP:   proutn("=== Snapshot        ")
+            elif i == FBATTAK: proutn("=== Base Attack     ")
+            elif i == FCDBAS:  proutn("=== Base Destroy    ")
+            elif i == FSCMOVE: proutn("=== SC Move         ")
+            elif i == FSCDBAS: proutn("=== SC Base Destroy ")
+            elif i == FDSPROB: proutn("=== Probe Move      ")
+            elif i == FDISTR:  proutn("=== Distress Call   ")
+            elif i == FENSLV:  proutn("=== Enslavement     ")
+            elif i == FREPRO:  proutn("=== Klingon Build   ")
+            if is_scheduled(i):
+                prout("%.2f" % (scheduled(i)))
+            else:
+                prout("never")
     radio_was_broken = damaged(DRADIO)
     hold.i = hold.j = 0
     while True:
-       # Select earliest extraneous event, evcode==0 if no events 
-       evcode = FSPY
-       if game.alldone:
-           return
-       datemin = fintim
-       for l in range(1, NEVENTS):
-           if game.future[l].date < datemin:
-               evcode = l
-               if game.idebug:
-                   prout("== Event %d fires" % evcode)
-               datemin = game.future[l].date
-       xtime = datemin-game.state.date
-       game.state.date = datemin
-       # Decrement Federation resources and recompute remaining time 
-       game.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime
+        # Select earliest extraneous event, evcode==0 if no events
+        evcode = FSPY
+        if game.alldone:
+            return
+        datemin = fintim
+        for l in range(1, NEVENTS):
+            if game.future[l].date < datemin:
+                evcode = l
+                if game.idebug:
+                    prout("== Event %d fires" % evcode)
+                datemin = game.future[l].date
+        xtime = datemin-game.state.date
+        if game.iscloaked:
+            game.energy -= xtime*500.0
+            if game.energy <= 0:
+                finish(FNRG)
+                return
+        game.state.date = datemin
+        # Decrement Federation resources and recompute remaining time
+        game.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime
         game.recompute()
-       if game.state.remtime <=0:
-           finish(FDEPLETE)
-           return
-       # Any crew left alive? 
-       if game.state.crew <=0:
-           finish(FCREW)
-           return
-       # Is life support adequate? 
-       if damaged(DLIFSUP) and game.condition != "docked":
-           if game.lsupres < xtime and game.damage[DLIFSUP] > game.lsupres:
-               finish(FLIFESUP)
-               return
-           game.lsupres -= xtime
-           if game.damage[DLIFSUP] <= xtime:
-               game.lsupres = game.inlsr
-       # Fix devices 
-       repair = xtime
-       if game.condition == "docked":
-           repair /= DOCKFAC
-       # Don't fix Deathray here 
-       for l in range(NDEVICES):
-           if game.damage[l] > 0.0 and l != DDRAY:
+        if game.state.remtime <= 0:
+            finish(FDEPLETE)
+            return
+        # Any crew left alive?
+        if game.state.crew <= 0:
+            finish(FCREW)
+            return
+        # Is life support adequate?
+        if damaged(DLIFSUP) and game.condition != "docked":
+            if game.lsupres < xtime and game.damage[DLIFSUP] > game.lsupres:
+                finish(FLIFESUP)
+                return
+            game.lsupres -= xtime
+            if game.damage[DLIFSUP] <= xtime:
+                game.lsupres = game.inlsr
+        # Fix devices
+        repair = xtime
+        if game.condition == "docked":
+            repair /= DOCKFAC
+        # Don't fix Deathray here
+        for l in range(NDEVICES):
+            if game.damage[l] > 0.0 and l != DDRAY:
                 if game.damage[l]-repair > 0.0:
                     game.damage[l] -= repair
                 else:
                     game.damage[l] = 0.0
-       # If radio repaired, update star chart and attack reports 
-       if radio_was_broken and not damaged(DRADIO):
-           prout(_("Lt. Uhura- \"Captain, the sub-space radio is working and"))
-           prout(_("   surveillance reports are coming in."))
-           skip(1)
-           if not game.iseenit:
-               attackreport(False)
-               game.iseenit = True
-           rechart()
-           prout(_("   The star chart is now up to date.\""))
-           skip(1)
-       # Cause extraneous event EVCODE to occur 
-       game.optime -= xtime
-       if evcode == FSNOVA: # Supernova 
-           announce()
-           supernova(None)
-           schedule(FSNOVA, expran(0.5*game.intime))
-           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 \
-               ictbeam or istract or \
-                game.condition=="docked" or game.isatb==1 or game.iscate:
-               return
-           if game.ientesc or \
-               (game.energy<2000 and game.torps<4 and game.shield < 1250) or \
-               (damaged(DPHASER) and (damaged(DPHOTON) or game.torps<4)) or \
-               (damaged(DSHIELD) and \
-                (game.energy < 2500 or damaged(DPHASER)) and \
+        # If radio repaired, update star chart and attack reports
+        if radio_was_broken and not damaged(DRADIO):
+            prout(_("Lt. Uhura- \"Captain, the sub-space radio is working and"))
+            prout(_("   surveillance reports are coming in."))
+            skip(1)
+            if not game.iseenit:
+                attackreport(False)
+                game.iseenit = True
+            rechart()
+            prout(_("   The star chart is now up to date.\""))
+            skip(1)
+        # Cause extraneous event EVCODE to occur
+        game.optime -= xtime
+        if evcode == FSNOVA: # Supernova
+            announce()
+            supernova(None)
+            schedule(FSNOVA, expran(0.5*game.intime))
+            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 game.iscloaked or \
+                ictbeam or istract or \
+                game.condition == "docked" or game.isatb == 1 or game.iscate:
+                return
+            if game.ientesc or \
+                (game.energy<2000 and game.torps<4 and game.shield < 1250) or \
+                (damaged(DPHASER) and (damaged(DPHOTON) or game.torps<4)) or \
+                (damaged(DSHIELD) and \
+                 (game.energy < 2500 or damaged(DPHASER)) and \
                  (game.torps < 5 or damaged(DPHOTON))):
-               # Tractor-beam her! 
-               istract = ictbeam = True
+                # Tractor-beam her!
+                istract = ictbeam = True
                 tractorbeam((game.state.kscmdr-game.quadrant).distance())
-           else:
-               return
-       elif evcode == FTBEAM: # Tractor beam 
+            else:
+                return
+        elif evcode == FTBEAM: # Tractor beam
             if not game.state.kcmdr:
                 unschedule(FTBEAM)
                 continue
             i = randrange(len(game.state.kcmdr))
             yank = (game.state.kcmdr[i]-game.quadrant).distance()
-            if istract or game.condition == "docked" or yank == 0:
-                # Drats! Have to reschedule 
-                schedule(FTBEAM, 
+            if istract or game.condition == "docked" or game.iscloaked or yank == 0:
+                # Drats! Have to reschedule
+                schedule(FTBEAM,
                          game.optime + expran(1.5*game.intime/len(game.state.kcmdr)))
                 continue
             ictbeam = True
             tractorbeam(yank)
-       elif evcode == FSNAP: # Snapshot of the universe (for time warp) 
-           game.snapsht = copy.deepcopy(game.state)
-           game.state.snap = True
-           schedule(FSNAP, expran(0.5 * game.intime))
-       elif evcode == FBATTAK: # Commander attacks starbase 
-           if not game.state.kcmdr or not game.state.baseq:
-               # no can do 
-               unschedule(FBATTAK)
-               unschedule(FCDBAS)
+        elif evcode == FSNAP: # Snapshot of the universe (for time warp)
+            game.snapsht = copy.deepcopy(game.state)
+            game.state.snap = True
+            schedule(FSNAP, expran(0.5 * game.intime))
+        elif evcode == FBATTAK: # Commander attacks starbase
+            if not game.state.kcmdr or not game.state.baseq:
+                # no can do
+                unschedule(FBATTAK)
+                unschedule(FCDBAS)
                 continue
+            ibq = None # Force battle location to persist past loop
             try:
                 for ibq in game.state.baseq:
-                   for cmdr in game.state.kcmdr: 
-                       if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
-                           raise ibq
-                else:
-                    # no match found -- try later 
-                    schedule(FBATTAK, expran(0.3*game.intime))
-                    unschedule(FCDBAS)
-                    continue
-            except coord:
+                    for cmdr in game.state.kcmdr:
+                        if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
+                            raise JumpOut
+                # no match found -- try later
+                schedule(FBATTAK, expran(0.3*game.intime))
+                unschedule(FCDBAS)
+                continue
+            except JumpOut:
                 pass
-           # commander + starbase combination found -- launch attack 
-           game.battle = ibq
-           schedule(FCDBAS, randreal(1.0, 4.0))
-           if game.isatb: # extra time if SC already attacking 
-               postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date)
-           game.future[FBATTAK].date = game.future[FCDBAS].date + expran(0.3*game.intime)
-           game.iseenit = False
+            # commander + starbase combination found -- launch attack
+            game.battle = ibq
+            schedule(FCDBAS, randreal(1.0, 4.0))
+            if game.isatb: # extra time if SC already attacking
+                postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date)
+            game.future[FBATTAK].date = game.future[FCDBAS].date + expran(0.3*game.intime)
+            game.iseenit = False
             if not communicating():
-               continue # No warning :-( 
-           game.iseenit = True
-           announce()
-           skip(1)
-           prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") % game.battle)
-           prout(_("   reports that it is under attack and that it can"))
-           prout(_("   hold out only until stardate %d.\"") % (int(scheduled(FCDBAS))))
-           if cancelrest():
+                continue # No warning :-(
+            game.iseenit = True
+            announce()
+            skip(1)
+            prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") % game.battle)
+            prout(_("   reports that it is under attack and that it can"))
+            prout(_("   hold out only until stardate %d.\"") % (int(scheduled(FCDBAS))))
+            if cancelrest():
                 return
-       elif evcode == FSCDBAS: # Supercommander destroys base 
-           unschedule(FSCDBAS)
-           game.isatb = 2
-           if not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].starbase: 
-               continue # WAS RETURN! 
-           hold = game.battle
-           game.battle = game.state.kscmdr
-           destroybase()
-       elif evcode == FCDBAS: # Commander succeeds in destroying base 
-           if evcode==FCDBAS:
-               unschedule(FCDBAS)
+        elif evcode == FSCDBAS: # Supercommander destroys base
+            unschedule(FSCDBAS)
+            game.isatb = 2
+            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
+            destroybase()
+        elif evcode == FCDBAS: # Commander succeeds in destroying base
+            if evcode == FCDBAS:
+                unschedule(FCDBAS)
                 if not game.state.baseq() \
                        or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
-                   game.battle.invalidate()
+                    game.battle.invalidate()
                     continue
-               # find the lucky pair 
-               for cmdr in game.state.kcmdr:
-                   if cmdr == game.battle: 
-                       break
+                # find the lucky pair
+                for cmdr in game.state.kcmdr:
+                    if cmdr == game.battle:
+                        break
                 else:
-                   # No action to take after all 
-                   continue
+                    # No action to take after all
+                    continue
             destroybase()
-       elif evcode == FSCMOVE: # Supercommander moves 
-           schedule(FSCMOVE, 0.2777)
-           if not game.ientesc and not istract and game.isatb != 1 and \
-                   (not game.iscate or not game.justin): 
-               supercommander()
-       elif evcode == FDSPROB: # Move deep space probe 
-           schedule(FDSPROB, 0.01)
-            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
+        elif evcode == FSCMOVE: # Supercommander moves
+            schedule(FSCMOVE, 0.2777)
+            if not game.ientesc and not istract and game.isatb != 1 and \
+                   (not game.iscate or not game.justin):
+                supercommander()
+        elif evcode == FDSPROB: # Move deep space probe
+            schedule(FDSPROB, 0.01)
+            if not game.probe.nexttok():
+                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 communicating():
-                       announce()
-                       skip(1)
-                       proutn(_("Lt. Uhura-  \"The deep space probe "))
-                       if not game.probe.quadrant().valid_quadrant():
-                           prout(_("has left the galaxy.\""))
-                       else:
-                           prout(_("is no longer transmitting.\""))
-                   unschedule(FDSPROB)
-                   continue
+                        announce()
+                        skip(1)
+                        proutn(_("Lt. Uhura-  \"The deep space probe "))
+                        if not game.probe.quadrant().valid_quadrant():
+                            prout(_("has left the galaxy.\""))
+                        else:
+                            prout(_("is no longer transmitting.\""))
+                    unschedule(FDSPROB)
+                    continue
                 if communicating():
-                   #announce()
-                   skip(1)
-                   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.probe.quadrant().i][game.probe.quadrant().j]
-               chp.klingons = pdest.klingons
-               chp.starbase = pdest.starbase
-               chp.stars = pdest.stars
-               pdest.charted = True
-           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().i][game.quadrant().j].supernova: 
-                   return
-       elif evcode == FDISTR: # inhabited system issues distress call 
-           unschedule(FDISTR)
-           # try a whole bunch of times to find something suitable 
+                    #announce()
+                    skip(1)
+                    prout(_("Lt. Uhura-  \"The deep space probe is now in Quadrant %s.\"") % game.probe.quadrant())
+            pquad = game.probe.quadrant()
+            pdest = game.state.galaxy[pquad.i][pquad.j]
+            if communicating():
+                game.state.chart[pquad.i][pquad.j].klingons = pdest.klingons
+                game.state.chart[pquad.i][pquad.j].starbase = pdest.starbase
+                game.state.chart[pquad.i][pquad.j].stars = pdest.stars
+                pdest.charted = True
+            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[pquad.i][pquad.j].supernova:
+                    return
+        elif evcode == FDISTR: # inhabited system issues distress call
+            unschedule(FDISTR)
+            # try a whole bunch of times to find something suitable
             for i in range(100):
-               # need a quadrant which is not the current one,
-               # which has some stars which are inhabited and
-               # not already under attack, which is not
-               # supernova'ed, and which has some Klingons in it
-               w = randplace(GALSIZE)
-               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):
+                # need a quadrant which is not the current one,
+                # which has some stars which are inhabited and
+                # not already under attack, which is not
+                # supernova'ed, and which has some Klingons in it
+                w = randplace(GALSIZE)
+                q = game.state.galaxy[w.i][w.j]
+                if not (game.quadrant == w or q.planet is None or \
+                      not q.planet.inhabited or \
+                      q.supernova or q.status!="secure" or q.klingons<=0):
                     break
             else:
-               # can't seem to find one; ignore this call 
-               if game.idebug:
-                   prout("=== Couldn't find location for distress event.")
-               continue
-           # got one!!  Schedule its enslavement 
-           ev = schedule(FENSLV, expran(game.intime))
-           ev.quadrant = w
-           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") \
-                        % (q.planet, `w`))
-               prout(_("by a Klingon invasion fleet."))
-               if cancelrest():
-                   return
-       elif evcode == FENSLV:          # starsystem is enslaved 
-           ev = unschedule(FENSLV)
-           # see if current distress call still active 
-           q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
-           if q.klingons <= 0:
-               q.status = "secure"
-               continue
-           q.status = "enslaved"
-
-           # play stork and schedule the first baby 
-           ev2 = schedule(FREPRO, expran(2.0 * game.intime))
-           ev2.quadrant = ev.quadrant
-
-           # report the disaster if we can 
-           if communicating():
-               prout(_("Uhura- We've lost contact with starsystem %s") % \
+                # can't seem to find one; ignore this call
+                if game.idebug:
+                    prout("=== Couldn't find location for distress event.")
+                continue
+            # got one!!  Schedule its enslavement
+            ev = schedule(FENSLV, expran(game.intime))
+            ev.quadrant = w
+            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") \
+                        % (q.planet, repr(w)))
+                prout(_("by a Klingon invasion fleet."))
+                if cancelrest():
+                    return
+        elif evcode == FENSLV:                # starsystem is enslaved
+            ev = unschedule(FENSLV)
+            # see if current distress call still active
+            q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
+            if q.klingons <= 0:
+                q.status = "secure"
+                continue
+            q.status = "enslaved"
+
+            # play stork and schedule the first baby
+            ev2 = schedule(FREPRO, expran(2.0 * game.intime))
+            ev2.quadrant = ev.quadrant
+
+            # report the disaster if we can
+            if communicating():
+                prout(_("Uhura- We've lost contact with starsystem %s") % \
                         q.planet)
-               prout(_("in Quadrant %s.\n") % ev.quadrant)
-       elif evcode == FREPRO:          # Klingon reproduces 
-           # If we ever switch to a real event queue, we'll need to
-           # 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.i][ev.quadrant.j]
-           if q.klingons <= 0:
-               q.status = "secure"
-               continue
-           if game.state.remkl >=MAXKLGAME:
-               continue                # full right now 
-           # reproduce one Klingon 
-           w = ev.quadrant
-            m = coord()
-           if game.klhere >= MAXKLQUAD:
+                prout(_("in Quadrant %s.\n") % ev.quadrant)
+        elif evcode == FREPRO:                # Klingon reproduces
+            # If we ever switch to a real event queue, we'll need to
+            # 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.i][ev.quadrant.j]
+            if q.klingons <= 0:
+                q.status = "secure"
+                continue
+            if game.state.remkl >= MAXKLGAME:
+                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 
+                    # this quadrant not ok, pick an adjacent one
                     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[m.i][m.j]
-                            # check for this quad ok (not full & no snova) 
+                            # check for this quad ok (not full & no snova)
                             if q.klingons >= MAXKLQUAD or q.supernova:
                                 continue
                             raise JumpOut
-                    else:
-                        continue       # search for eligible quadrant failed
+                    # search for eligible quadrant failed
+                    continue
                 except JumpOut:
                     w = m
-           # deliver the child 
-           game.state.remkl += 1
-           q.klingons += 1
-           if game.quadrant == w:
+            # deliver the child
+            game.state.remkl += 1
+            q.klingons += 1
+            if game.quadrant == w:
                 game.klhere += 1
-               game.enemies.append(newkling())
-           # recompute time left
+                game.enemies.append(newkling())
+            # recompute time left
             game.recompute()
-           if communicating():
-               if game.quadrant == w:
-                   prout(_("Spock- sensors indicate the Klingons have"))
-                   prout(_("launched a warship from %s.") % q.planet)
-               else:
-                   prout(_("Uhura- Starfleet reports increased Klingon activity"))
-                   if q.planet != None:
-                       proutn(_("near %s ") % q.planet)
-                   prout(_("in Quadrant %s.") % w)
-                               
+            if communicating():
+                if game.quadrant == w:
+                    prout(_("Spock- sensors indicate the Klingons have"))
+                    prout(_("launched a warship from %s.") % q.planet)
+                else:
+                    prout(_("Uhura- Starfleet reports increased Klingon activity"))
+                    if q.planet != None:
+                        proutn(_("near %s ") % q.planet)
+                    prout(_("in Quadrant %s.") % w)
+
 def wait():
     "Wait on events."
     game.ididit = False
     while True:
-       key = scanner.next()
-       if key  != "IHEOL":
-           break
-       proutn(_("How long? "))
+        key = scanner.nexttok()
+        if key  != "IHEOL":
+            break
+        proutn(_("How long? "))
     scanner.chew()
     if key != "IHREAL":
-       huh()
-       return
+        huh()
+        return
     origTime = delay = scanner.real
     if delay <= 0.0:
-       return
+        return
     if delay >= game.state.remtime or len(game.enemies) != 0:
-       proutn(_("Are you sure? "))
-       if not ja():
-           return
-    # Alternate resting periods (events) with attacks 
+        proutn(_("Are you sure? "))
+        if not ja():
+            return
+    # Alternate resting periods (events) with attacks
     game.resting = True
     while True:
-       if delay <= 0:
-           game.resting = False
-       if not game.resting:
-           prout(_("%d stardates left.") % int(game.state.remtime))
-           return
-       temp = game.optime = delay
-       if len(game.enemies):
-           rtime = randreal(1.0, 2.0)
-           if rtime < temp:
-               temp = rtime
-           game.optime = temp
-       if game.optime < delay:
-           attack(torps_ok=False)
-       if game.alldone:
-           return
-       events()
-       game.ididit = True
-       if game.alldone:
-           return
-       delay -= temp
-       # Repair Deathray if long rest at starbase 
-       if origTime-delay >= 9.99 and game.condition == "docked":
-           game.damage[DDRAY] = 0.0
-       # leave if quadrant supernovas
+        if delay <= 0:
+            game.resting = False
+        if not game.resting:
+            prout(_("%d stardates left.") % int(game.state.remtime))
+            return
+        temp = game.optime = delay
+        if len(game.enemies):
+            rtime = randreal(1.0, 2.0)
+            if rtime < temp:
+                temp = rtime
+            game.optime = temp
+        if game.optime < delay:
+            attack(torps_ok=False)
+        if game.alldone:
+            return
+        events()
+        game.ididit = True
+        if game.alldone:
+            return
+        delay -= temp
+        # Repair Deathray if long rest at starbase
+        if origTime-delay >= 9.99 and game.condition == "docked":
+            game.damage[DDRAY] = 0.0
+        # leave if quadrant supernovas
         if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
             break
     game.resting = False
-    game.optime = 0
+    game.optime = 0.0
 
 def nova(nov):
-    "Star goes nova." 
+    "Star goes nova."
     ncourse = (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)
+    newc = Coord(); neighbor = Coord(); bump = Coord(0, 0)
     if withprob(0.05):
-       # Wow! We've supernova'ed 
-       supernova(game.quadrant)
-       return
-    # handle initial nova 
+        # Wow! We've supernova'ed
+        supernova(game.quadrant)
+        return
+    # handle initial nova
     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 
+    # Set up queue to recursively trigger adjacent stars
     hits = [nov]
     kount = 0
     while hits:
-        offset = coord()
+        offset = Coord()
         start = hits.pop()
         for offset.i in range(-1, 1+1):
             for offset.j in range(-1, 1+1):
-                if offset.j==0 and offset.i==0:
+                if offset.j == 0 and offset.i == 0:
                     continue
                 neighbor = start + offset
                 if not neighbor.valid_sector():
@@ -2438,25 +2674,25 @@ def nova(nov):
                 # Empty space ends reaction
                 if iquad in ('.', '?', ' ', 'T', '#'):
                     pass
-                elif iquad == '*': # Affect another star 
+                elif iquad == '*': # Affect another star
                     if withprob(0.05):
-                        # This star supernovas 
+                        # This star supernovas
                         supernova(game.quadrant)
                         return
                     else:
                         hits.append(neighbor)
-                       game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
-                       game.state.starkl += 1
-                       proutn(crmena(True, '*', "sector", neighbor))
-                       prout(_(" novas."))
+                        game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
+                        game.state.starkl += 1
+                        proutn(crmena(True, '*', "sector", neighbor))
+                        prout(_(" novas."))
                         game.quad[neighbor.i][neighbor.j] = '.'
                         kount += 1
-                elif iquad in ('P', '@'): # Destroy planet 
+                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
+                        game.state.nworldkl += 1
                     prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
                     game.iplnet.pclass = "destroyed"
                     game.iplnet = None
@@ -2465,15 +2701,15 @@ def nova(nov):
                         finish(FPNOVA)
                         return
                     game.quad[neighbor.i][neighbor.j] = '.'
-                elif iquad == 'B': # Destroy base 
+                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.state.baseq = [x for x in game.state.baseq if x!= game.quadrant]
                     game.base.invalidate()
                     game.state.basekl += 1
                     newcnd()
                     prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
                     game.quad[neighbor.i][neighbor.j] = '.'
-                elif iquad in ('E', 'F'): # Buffet ship 
+                elif iquad in ('E', 'F'): # Buffet ship
                     prout(_("***Starship buffeted by nova."))
                     if game.shldup:
                         if game.shield >= 2000.0:
@@ -2491,115 +2727,119 @@ def nova(nov):
                         finish(FNOVA)
                         return
                     # add in course nova contributes to kicking starship
-                    bump += (game.sector-hits[mm]).sgn()
-                elif iquad == 'K': # kill klingon 
+                    bump += (game.sector-hits[-1]).sgn()
+                elif iquad == 'K': # kill klingon
                     deadkl(neighbor, iquad, neighbor)
-                elif iquad in ('C','S','R'): # Damage/destroy big enemies 
+                elif iquad in ('C','S','R'): # Damage/destroy big enemies
+                    target = None
                     for ll in range(len(game.enemies)):
                         if game.enemies[ll].location == neighbor:
+                            target = game.enemies[ll]
                             break
-                    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 newc.valid_sector():
-                        # can't leave quadrant 
-                        skip(1)
-                        break
-                    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 != '.':
-                        # can't move into something else 
-                        skip(1)
-                        break
-                    proutn(_(", buffeted to Sector %s") % newc)
-                    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. 
+                    if target is not None:
+                        target.power -= 800.0 # If firepower is lost, die
+                        if target.power <= 0.0:
+                            deadkl(neighbor, iquad, neighbor)
+                            continue   # neighbor loop
+                        # Else enemy gets flung by the blast wave
+                        newc = neighbor + neighbor - hits[-1]
+                        proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
+                        if not newc.valid_sector():
+                            # can't leave quadrant
+                            skip(1)
+                            continue
+                        iquad1 = game.quad[newc.i][newc.j]
+                        if iquad1 == ' ':
+                            proutn(_(", blasted into ") + crmena(False, ' ', "sector", newc))
+                            skip(1)
+                            deadkl(neighbor, iquad, newc)
+                            continue
+                        if iquad1 != '.':
+                            # can't move into something else
+                            skip(1)
+                            continue
+                        proutn(_(", buffeted to Sector %s") % newc)
+                        game.quad[neighbor.i][neighbor.j] = '.'
+                        game.quad[newc.i][newc.j] = iquad
+                        target.move(newc)
+    # Starship affected by nova -- kick it away.
     dist = kount*0.1
     direc = ncourse[3*(bump.i+1)+bump.j+2]
     if direc == 0.0:
-       dist = 0.0
+        dist = 0.0
     if dist == 0.0:
-       return
+        return
     scourse = course(bearing=direc, distance=dist)
-    game.optime = scourse.time(warp=4)
+    game.optime = scourse.time(w=4)
     skip(1)
     prout(_("Force of nova displaces starship."))
     imove(scourse, noattack=True)
-    game.optime = scourse.time(warp=4)
+    game.optime = scourse.time(w=4)
     return
-       
+
 def supernova(w):
     "Star goes supernova."
     num = 0; npdead = 0
-    if w != None: 
-       nq = copy.copy(w)
+    if w != None:
+        nq = copy.copy(w)
     else:
-       # Scheduled supernova -- select star at random. 
-       stars = 0
-        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.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:
-               break
-       if game.idebug:
-           proutn("=== Super nova here?")
-           if ja():
-               nq = game.quadrant
+        # Scheduled supernova -- select star at random.
+        nstars = 0
+        nq = Coord()
+        for nq.i in range(GALSIZE):
+            for nq.j in range(GALSIZE):
+                nstars += game.state.galaxy[nq.i][nq.j].stars
+        if stars == 0:
+            return # nothing to supernova exists
+        num = randrange(nstars) + 1
+        for nq.i in range(GALSIZE):
+            for nq.j in range(GALSIZE):
+                num -= game.state.galaxy[nq.i][nq.j].stars
+                if num <= 0:
+                    break
+            if num <=0:
+                break
+        if game.idebug:
+            proutn("=== Super nova here?")
+            if ja():
+                nq = game.quadrant
     if not nq == game.quadrant or game.justin:
-       # it isn't here, or we just entered (treat as enroute) 
-       if communicating():
-           skip(1)
-           prout(_("Message from Starfleet Command       Stardate %.2f") % game.state.date)
-           prout(_("     Supernova in Quadrant %s; caution advised.") % nq)
+        # it isn't here, or we just entered (treat as enroute)
+        if communicating():
+            skip(1)
+            prout(_("Message from Starfleet Command       Stardate %.2f") % game.state.date)
+            prout(_("     Supernova in Quadrant %s; caution advised.") % nq)
     else:
-       ns = coord()
-       # we are in the quadrant! 
-       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
-           if num==0:
-               break
-       skip(1)
-       prouts(_("***RED ALERT!  RED ALERT!"))
-       skip(1)
-       prout(_("***Incipient supernova detected at Sector %s") % ns)
-       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
+        ns = Coord()
+        # we are in the quadrant!
+        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
+            if num==0:
+                break
+        skip(1)
+        prouts(_("***RED ALERT!  RED ALERT!"))
+        skip(1)
+        prout(_("***Incipient supernova detected at Sector %s") % ns)
+        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.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.i = game.state.kscmdr.j = game.isatb =  0
-       game.iscate = False
-       unschedule(FSCMOVE)
-       unschedule(FSCDBAS)
+        # did in the Supercommander!
+        game.state.nscrem = game.state.kscmdr.i = game.state.kscmdr.j = game.isatb =  0
+        game.iscate = False
+        unschedule(FSCMOVE)
+        unschedule(FSCDBAS)
     survivors = filter(lambda w: w != nq, game.state.kcmdr)
     comkills = len(game.state.kcmdr) - len(survivors)
     game.state.kcmdr = survivors
@@ -2607,46 +2847,46 @@ def supernova(w):
     if not game.state.kcmdr:
         unschedule(FTBEAM)
     game.state.remkl -= kldead
-    # destroy Romulans and planets in supernovaed quadrant 
+    # destroy Romulans and planets in supernovaed quadrant
     nrmdead = game.state.galaxy[nq.i][nq.j].romulans
     game.state.galaxy[nq.i][nq.j].romulans = 0
     game.state.nromrem -= nrmdead
-    # Destroy planets 
+    # Destroy planets
     for loop in range(game.inplan):
-       if game.state.planets[loop].quadrant == nq:
-           game.state.planets[loop].pclass = "destroyed"
-           npdead += 1
+        if game.state.planets[loop].quadrant == nq:
+            game.state.planets[loop].pclass = "destroyed"
+            npdead += 1
     # Destroy any base in supernovaed quadrant
-    game.state.baseq = filter(lambda x: x != nq, game.state.baseq)
-    # If starship caused supernova, tally up destruction 
+    game.state.baseq = [x for x in game.state.baseq if x != nq]
+    # If starship caused supernova, tally up destruction
     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 
+        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.i][nq.j].supernova = True
-    # If supernova destroys last Klingons give special message 
+        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 w == None:
-           prout(_("Lucky you!"))
-       proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq)
-       finish(FWON)
-       return
-    # if some Klingons remain, continue or die in supernova 
+        skip(2)
+        if w is None:
+            prout(_("Lucky you!"))
+        proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq)
+        finish(FWON)
+        return
+    # if some Klingons remain, continue or die in supernova
     if game.alldone:
-       finish(FSNOVAED)
+        finish(FSNOVAED)
     return
 
 # Code from finish.c ends here.
 
 def selfdestruct():
-    "Self-destruct maneuver. Finish with a BANG!" 
+    "Self-destruct maneuver. Finish with a BANG!"
     scanner.chew()
     if damaged(DCOMPTR):
-       prout(_("Computer damaged; cannot execute destruct sequence."))
-       return
+        prout(_("Computer damaged; cannot execute destruct sequence."))
+        return
     prouts(_("---WORKING---")); skip(1)
     prouts(_("SELF-DESTRUCT-SEQUENCE-ACTIVATED")); skip(1)
     prouts("   10"); skip(1)
@@ -2661,14 +2901,13 @@ def selfdestruct():
     skip(1)
     prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED"))
     skip(1)
-    scanner.next()
-    scanner.chew()
+    scanner.nexttok()
     if game.passwd != scanner.token:
-       prouts(_("PASSWORD-REJECTED;"))
-       skip(1)
-       prouts(_("CONTINUITY-EFFECTED"))
-       skip(2)
-       return
+        prouts(_("PASSWORD-REJECTED;"))
+        skip(1)
+        prouts(_("CONTINUITY-EFFECTED"))
+        skip(2)
+        return
     prouts(_("PASSWORD-ACCEPTED")); skip(1)
     prouts("                   5"); skip(1)
     prouts("                      4"); skip(1)
@@ -2676,31 +2915,29 @@ def selfdestruct():
     prouts("                            2"); skip(1)
     prouts("                              1"); skip(1)
     if withprob(0.15):
-       prouts(_("GOODBYE-CRUEL-WORLD"))
-       skip(1)
+        prouts(_("GOODBYE-CRUEL-WORLD"))
+        skip(1)
     kaboom()
 
 def kaboom():
     stars()
     if game.ship=='E':
-       prouts("***")
+        prouts("***")
     prouts(_("********* Entropy of %s maximized *********") % crmshp())
     skip(1)
     stars()
     skip(1)
     if len(game.enemies) != 0:
-       whammo = 25.0 * game.energy
-       l=1
-       while l <= len(game.enemies):
-           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
+        whammo = 25.0 * game.energy
+        for l in range(len(game.enemies)):
+            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)
     finish(FDILITHIUM)
-                               
+
 def killrate():
     "Compute our rate of kils over time."
     elapsed = game.state.date - game.indate
-    if elapsed == 0:   # Avoid divide-by-zero error if calculated on turn 0
+    if elapsed == 0:        # Avoid divide-by-zero error if calculated on turn 0
         return 0
     else:
         starting = (game.inkling + game.incom + game.inscom)
@@ -2715,291 +2952,313 @@ def badpoints():
             300*game.state.nworldkl + \
             45.0*game.nhelp +\
             100.0*game.state.basekl +\
-            3.0*game.abandoned
+            3.0*game.abandoned +\
+            100*game.ncviol
     if game.ship == 'F':
         badpt += 100.0
-    elif game.ship == None:
+    elif game.ship is None:
         badpt += 200.0
     return badpt
 
 def finish(ifin):
-    # end the game, with appropriate notfications 
+    # end the game, with appropriate notifications
     igotit = False
     game.alldone = True
     skip(3)
     prout(_("It is stardate %.1f.") % game.state.date)
     skip(1)
     if ifin == FWON: # Game has been won
-       if game.state.nromrem != 0:
-           prout(_("The remaining %d Romulans surrender to Starfleet Command.") %
-                 game.state.nromrem)
-
-       prout(_("You have smashed the Klingon invasion fleet and saved"))
-       prout(_("the Federation."))
-       game.gamewon = True
-       if game.alive:
+        if game.state.nromrem != 0:
+            prout(_("The remaining %d Romulans surrender to Starfleet Command.") %
+                  game.state.nromrem)
+
+        prout(_("You have smashed the Klingon invasion fleet and saved"))
+        prout(_("the Federation."))
+        if game.alive and game.brigcapacity-game.brigfree > 0:
+            game.kcaptured += game.brigcapacity-game.brigfree
+            prout(_("The %d captured Klingons are transferred to Star Fleet Command.") % (game.brigcapacity-game.brigfree))
+        game.gamewon = True
+        if game.alive:
             badpt = badpoints()
             if badpt < 100.0:
-                badpt = 0.0    # Close enough!
+                badpt = 0.0        # Close enough!
             # killsPerDate >= RateMax
-           if game.state.date-game.indate < 5.0 or \
+            if game.state.date-game.indate < 5.0 or \
                 killrate() >= 0.1*game.skill*(game.skill+1.0) + 0.1 + 0.008*badpt:
-               skip(1)
-               prout(_("In fact, you have done so well that Starfleet Command"))
-               if game.skill == SKILL_NOVICE:
-                   prout(_("promotes you one step in rank from \"Novice\" to \"Fair\"."))
-               elif game.skill == SKILL_FAIR:
-                   prout(_("promotes you one step in rank from \"Fair\" to \"Good\"."))
-               elif game.skill == SKILL_GOOD:
-                   prout(_("promotes you one step in rank from \"Good\" to \"Expert\"."))
-               elif game.skill == SKILL_EXPERT:
-                   prout(_("promotes you to Commodore Emeritus."))
-                   skip(1)
-                   prout(_("Now that you think you're really good, try playing"))
-                   prout(_("the \"Emeritus\" game. It will splatter your ego."))
-               elif game.skill == SKILL_EMERITUS:
-                   skip(1)
-                   proutn(_("Computer-  "))
-                   prouts(_("ERROR-ERROR-ERROR-ERROR"))
-                   skip(2)
-                   prouts(_("  YOUR-SKILL-HAS-EXCEEDED-THE-CAPACITY-OF-THIS-PROGRAM"))
-                   skip(1)
-                   prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
-                   skip(1)
-                   prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
-                   skip(1)
-                   prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
-                   skip(1)
-                   prouts(_("  THIS-PROGRAM-MUST?- MUST ? - SUR? ? -?  VI"))
-                   skip(2)
-                   prout(_("Now you can retire and write your own Star Trek game!"))
-                   skip(1)
-               elif game.skill >= SKILL_EXPERT:
-                   if game.thawed and not game.idebug:
-                       prout(_("You cannot get a citation, so..."))
-                   else:
-                       proutn(_("Do you want your Commodore Emeritus Citation printed? "))
-                       scanner.chew()
-                       if ja():
-                           igotit = True
-           # Only grant long life if alive (original didn't!)
-           skip(1)
-           prout(_("LIVE LONG AND PROSPER."))
-       score()
-       if igotit:
-           plaque()        
-       return
+                skip(1)
+                prout(_("In fact, you have done so well that Starfleet Command"))
+                if game.skill == SKILL_NOVICE:
+                    prout(_("promotes you one step in rank from \"Novice\" to \"Fair\"."))
+                elif game.skill == SKILL_FAIR:
+                    prout(_("promotes you one step in rank from \"Fair\" to \"Good\"."))
+                elif game.skill == SKILL_GOOD:
+                    prout(_("promotes you one step in rank from \"Good\" to \"Expert\"."))
+                elif game.skill == SKILL_EXPERT:
+                    prout(_("promotes you to Commodore Emeritus."))
+                    skip(1)
+                    prout(_("Now that you think you're really good, try playing"))
+                    prout(_("the \"Emeritus\" game. It will splatter your ego."))
+                elif game.skill == SKILL_EMERITUS:
+                    skip(1)
+                    proutn(_("Computer-  "))
+                    prouts(_("ERROR-ERROR-ERROR-ERROR"))
+                    skip(2)
+                    prouts(_("  YOUR-SKILL-HAS-EXCEEDED-THE-CAPACITY-OF-THIS-PROGRAM"))
+                    skip(1)
+                    prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
+                    skip(1)
+                    prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
+                    skip(1)
+                    prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
+                    skip(1)
+                    prouts(_("  THIS-PROGRAM-MUST?- MUST ? - SUR? ? -?  VI"))
+                    skip(2)
+                    prout(_("Now you can retire and write your own Star Trek game!"))
+                    skip(1)
+                elif game.skill >= SKILL_EXPERT:
+                    if game.thawed and not game.idebug:
+                        prout(_("You cannot get a citation, so..."))
+                    else:
+                        proutn(_("Do you want your Commodore Emeritus Citation printed? "))
+                        scanner.chew()
+                        if ja():
+                            igotit = True
+            # Only grant long life if alive (original didn't!)
+            skip(1)
+            prout(_("LIVE LONG AND PROSPER."))
+        score()
+        if igotit:
+            plaque()
+        return
     elif ifin == FDEPLETE: # Federation Resources Depleted
-       prout(_("Your time has run out and the Federation has been"))
-       prout(_("conquered.  Your starship is now Klingon property,"))
-       prout(_("and you are put on trial as a war criminal.  On the"))
-       proutn(_("basis of your record, you are "))
-       if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom):
-           prout(_("acquitted."))
-           skip(1)
-           prout(_("LIVE LONG AND PROSPER."))
-       else:
-           prout(_("found guilty and"))
-           prout(_("sentenced to death by slow torture."))
-           game.alive = False
-       score()
-       return
+        prout(_("Your time has run out and the Federation has been"))
+        prout(_("conquered.  Your starship is now Klingon property,"))
+        prout(_("and you are put on trial as a war criminal.  On the"))
+        proutn(_("basis of your record, you are "))
+        if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom):
+            prout(_("acquitted."))
+            skip(1)
+            prout(_("LIVE LONG AND PROSPER."))
+        else:
+            prout(_("found guilty and"))
+            prout(_("sentenced to death by slow torture."))
+            game.alive = False
+        score()
+        return
     elif ifin == FLIFESUP:
-       prout(_("Your life support reserves have run out, and"))
-       prout(_("you die of thirst, starvation, and asphyxiation."))
-       prout(_("Your starship is a derelict in space."))
+        prout(_("Your life support reserves have run out, and"))
+        prout(_("you die of thirst, starvation, and asphyxiation."))
+        prout(_("Your starship is a derelict in space."))
     elif ifin == FNRG:
-       prout(_("Your energy supply is exhausted."))
-       skip(1)
-       prout(_("Your starship is a derelict in space."))
+        prout(_("Your energy supply is exhausted."))
+        skip(1)
+        prout(_("Your starship is a derelict in space."))
     elif ifin == FBATTLE:
-       prout(_("The %s has been destroyed in battle.") % crmshp())
-       skip(1)
-       prout(_("Dulce et decorum est pro patria mori."))
+        prout(_("The %s has been destroyed in battle.") % crmshp())
+        skip(1)
+        prout(_("Dulce et decorum est pro patria mori."))
     elif ifin == FNEG3:
-       prout(_("You have made three attempts to cross the negative energy"))
-       prout(_("barrier which surrounds the galaxy."))
-       skip(1)
-       prout(_("Your navigation is abominable."))
-       score()
+        prout(_("You have made three attempts to cross the negative energy"))
+        prout(_("barrier which surrounds the galaxy."))
+        skip(1)
+        prout(_("Your navigation is abominable."))
+        score()
     elif ifin == FNOVA:
-       prout(_("Your starship has been destroyed by a nova."))
-       prout(_("That was a great shot."))
-       skip(1)
+        prout(_("Your starship has been destroyed by a nova."))
+        prout(_("That was a great shot."))
+        skip(1)
     elif ifin == FSNOVAED:
-       prout(_("The %s has been fried by a supernova.") % crmshp())
-       prout(_("...Not even cinders remain..."))
+        prout(_("The %s has been fried by a supernova.") % crmshp())
+        prout(_("...Not even cinders remain..."))
     elif ifin == FABANDN:
-       prout(_("You have been captured by the Klingons. If you still"))
-       prout(_("had a starbase to be returned to, you would have been"))
-       prout(_("repatriated and given another chance. Since you have"))
-       prout(_("no starbases, you will be mercilessly tortured to death."))
+        prout(_("You have been captured by the Klingons. If you still"))
+        prout(_("had a starbase to be returned to, you would have been"))
+        prout(_("repatriated and given another chance. Since you have"))
+        prout(_("no starbases, you will be mercilessly tortured to death."))
     elif ifin == FDILITHIUM:
-       prout(_("Your starship is now an expanding cloud of subatomic particles"))
+        prout(_("Your starship is now an expanding cloud of subatomic particles"))
     elif ifin == FMATERIALIZE:
-       prout(_("Starbase was unable to re-materialize your starship."))
-       prout(_("Sic transit gloria mundi"))
+        prout(_("Starbase was unable to re-materialize your starship."))
+        prout(_("Sic transit gloria mundi"))
     elif ifin == FPHASER:
-       prout(_("The %s has been cremated by its own phasers.") % crmshp())
+        prout(_("The %s has been cremated by its own phasers.") % crmshp())
     elif ifin == FLOST:
-       prout(_("You and your landing party have been"))
-       prout(_("converted to energy, disipating through space."))
+        prout(_("You and your landing party have been"))
+        prout(_("converted to energy, dissipating through space."))
     elif ifin == FMINING:
-       prout(_("You are left with your landing party on"))
-       prout(_("a wild jungle planet inhabited by primitive cannibals."))
-       skip(1)
-       prout(_("They are very fond of \"Captain Kirk\" soup."))
-       skip(1)
-       prout(_("Without your leadership, the %s is destroyed.") % crmshp())
+        prout(_("You are left with your landing party on"))
+        prout(_("a wild jungle planet inhabited by primitive cannibals."))
+        skip(1)
+        prout(_("They are very fond of \"Captain Kirk\" soup."))
+        skip(1)
+        prout(_("Without your leadership, the %s is destroyed.") % crmshp())
     elif ifin == FDPLANET:
-       prout(_("You and your mining party perish."))
-       skip(1)
-       prout(_("That was a great shot."))
-       skip(1)
+        prout(_("You and your mining party perish."))
+        skip(1)
+        prout(_("That was a great shot."))
+        skip(1)
     elif ifin == FSSC:
-       prout(_("The Galileo is instantly annihilated by the supernova."))
-       prout(_("You and your mining party are atomized."))
-       skip(1)
-       prout(_("Mr. Spock takes command of the %s and") % crmshp())
-       prout(_("joins the Romulans, wreaking terror on the Federation."))
+        prout(_("The Galileo is instantly annihilated by the supernova."))
+        prout(_("You and your mining party are atomized."))
+        skip(1)
+        prout(_("Mr. Spock takes command of the %s and") % crmshp())
+        prout(_("joins the Romulans, wreaking terror on the Federation."))
     elif ifin == FPNOVA:
-       prout(_("You and your mining party are atomized."))
-       skip(1)
-       prout(_("Mr. Spock takes command of the %s and") % crmshp())
-       prout(_("joins the Romulans, wreaking terror on the Federation."))
+        prout(_("You and your mining party are atomized."))
+        skip(1)
+        prout(_("Mr. Spock takes command of the %s and") % crmshp())
+        prout(_("joins the Romulans, wreaking terror on the Federation."))
     elif ifin == FSTRACTOR:
-       prout(_("The shuttle craft Galileo is also caught,"))
-       prout(_("and breaks up under the strain."))
-       skip(1)
-       prout(_("Your debris is scattered for millions of miles."))
-       prout(_("Without your leadership, the %s is destroyed.") % crmshp())
+        prout(_("The shuttle craft Galileo is also caught,"))
+        prout(_("and breaks up under the strain."))
+        skip(1)
+        prout(_("Your debris is scattered for millions of miles."))
+        prout(_("Without your leadership, the %s is destroyed.") % crmshp())
     elif ifin == FDRAY:
-       prout(_("The mutants attack and kill Spock."))
-       prout(_("Your ship is captured by Klingons, and"))
-       prout(_("your crew is put on display in a Klingon zoo."))
+        prout(_("The mutants attack and kill Spock."))
+        prout(_("Your ship is captured by Klingons, and"))
+        prout(_("your crew is put on display in a Klingon zoo."))
     elif ifin == FTRIBBLE:
-       prout(_("Tribbles consume all remaining water,"))
-       prout(_("food, and oxygen on your ship."))
-       skip(1)
-       prout(_("You die of thirst, starvation, and asphyxiation."))
-       prout(_("Your starship is a derelict in space."))
+        prout(_("Tribbles consume all remaining water,"))
+        prout(_("food, and oxygen on your ship."))
+        skip(1)
+        prout(_("You die of thirst, starvation, and asphyxiation."))
+        prout(_("Your starship is a derelict in space."))
     elif ifin == FHOLE:
-       prout(_("Your ship is drawn to the center of the black hole."))
-       prout(_("You are crushed into extremely dense matter."))
+        prout(_("Your ship is drawn to the center of the black hole."))
+        prout(_("You are crushed into extremely dense matter."))
+    elif ifin == FCLOAK:
+        game.ncviol += 1
+        prout(_("You have violated the Treaty of Algeron."))
+        prout(_("The Romulan Empire can never trust you again."))
     elif ifin == FCREW:
-       prout(_("Your last crew member has died."))
+        prout(_("Your last crew member has died."))
+    if ifin != FWON and ifin != FCLOAK and game.iscloaked:
+        prout(_("Your ship was cloaked so your subspace radio did not receive anything."))
+        prout(_("You may have missed some warning messages."))
+        skip(1)
     if game.ship == 'F':
-       game.ship = None
+        game.ship = None
     elif game.ship == 'E':
-       game.ship = 'F'
+        game.ship = 'F'
     game.alive = False
     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
-       goodies = game.state.remres/game.inresor
-       baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom)
-       if goodies/baddies >= randreal(1.0, 1.5):
-           prout(_("As a result of your actions, a treaty with the Klingon"))
-           prout(_("Empire has been signed. The terms of the treaty are"))
-           if goodies/baddies >= randreal(3.0):
-               prout(_("favorable to the Federation."))
-               skip(1)
-               prout(_("Congratulations!"))
-           else:
-               prout(_("highly unfavorable to the Federation."))
-       else:
-           prout(_("The Federation will be destroyed."))
+        goodies = game.state.remres/game.inresor
+        baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom)
+        if goodies/baddies >= randreal(1.0, 1.5):
+            prout(_("As a result of your actions, a treaty with the Klingon"))
+            prout(_("Empire has been signed. The terms of the treaty are"))
+            if goodies/baddies >= randreal(3.0):
+                prout(_("favorable to the Federation."))
+                skip(1)
+                prout(_("Congratulations!"))
+            else:
+                prout(_("highly unfavorable to the Federation."))
+        else:
+            prout(_("The Federation will be destroyed."))
     else:
-       prout(_("Since you took the last Klingon with you, you are a"))
-       prout(_("martyr and a hero. Someday maybe they'll erect a"))
-       prout(_("statue in your memory. Rest in peace, and try not"))
-       prout(_("to think about pigeons."))
-       game.gamewon = True
+        prout(_("Since you took the last Klingon with you, you are a"))
+        prout(_("martyr and a hero. Someday maybe they'll erect a"))
+        prout(_("statue in your memory. Rest in peace, and try not"))
+        prout(_("to think about pigeons."))
+        game.gamewon = True
     score()
+    scanner.chew()     # Clean up leftovers
 
 def score():
     "Compute player's score."
     timused = game.state.date - game.indate
-    iskill = game.skill
     if (timused == 0 or (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0:
-       timused = 5.0
-    perdate = killrate()
-    ithperd = 500*perdate + 0.5
+        timused = 5.0
+    game.perdate = killrate()
+    ithperd = 500*game.perdate + 0.5
     iwon = 0
     if game.gamewon:
-       iwon = 100*game.skill
-    if game.ship == 'E': 
-       klship = 0
-    elif game.ship == 'F': 
-       klship = 1
+        iwon = 100*game.skill
+    if game.ship == 'E':
+        klship = 0
+    elif game.ship == 'F':
+        klship = 1
     else:
-       klship = 2
-    iscore = 10*(game.inkling - game.state.remkl) \
+        klship = 2
+    game.score = 10*(game.inkling - game.state.remkl) \
              + 50*(game.incom - len(game.state.kcmdr)) \
              + ithperd + iwon \
              + 20*(game.inrom - game.state.nromrem) \
              + 200*(game.inscom - game.state.nscrem) \
-            - game.state.nromrem \
+                 - game.state.nromrem \
+             + 3 * game.kcaptured \
              - badpoints()
     if not game.alive:
-       iscore -= 200
+        game.score -= 200
     skip(2)
     prout(_("Your score --"))
     if game.inrom - game.state.nromrem:
-       prout(_("%6d Romulans destroyed                 %5d") %
-             (game.inrom - game.state.nromrem, 20*(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 and game.gamewon:
-       prout(_("%6d Romulans captured                  %5d") %
-             (game.state.nromrem, game.state.nromrem))
+        prout(_("%6d Romulans captured                  %5d") %
+              (game.state.nromrem, game.state.nromrem))
     if game.inkling - game.state.remkl:
-       prout(_("%6d ordinary Klingons destroyed        %5d") %
-             (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl)))
+        prout(_("%6d ordinary Klingons destroyed        %5d") %
+              (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl)))
     if game.incom - len(game.state.kcmdr):
-       prout(_("%6d Klingon commanders destroyed       %5d") %
-             (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr))))
+        prout(_("%6d Klingon commanders destroyed       %5d") %
+              (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr))))
+    if game.kcaptured:
+        prout(_("%d Klingons captured                   %5d") %
+              (game.kcaptured, 3 * game.kcaptured))
     if game.inscom - game.state.nscrem:
-       prout(_("%6d Super-Commander destroyed          %5d") %
-             (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
+        prout(_("%6d Super-Commander destroyed          %5d") %
+              (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
     if ithperd:
-       prout(_("%6.2f Klingons per stardate              %5d") %
-             (perdate, ithperd))
+        prout(_("%6.2f Klingons per stardate              %5d") %
+              (game.perdate, ithperd))
     if game.state.starkl:
-       prout(_("%6d stars destroyed by your action     %5d") %
-             (game.state.starkl, -5*game.state.starkl))
+        prout(_("%6d stars destroyed by your action     %5d") %
+              (game.state.starkl, -5*game.state.starkl))
     if game.state.nplankl:
-       prout(_("%6d planets destroyed by your action   %5d") %
-             (game.state.nplankl, -10*game.state.nplankl))
+        prout(_("%6d planets destroyed by your action   %5d") %
+              (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.nworldkl, -300*game.state.nworldkl))
+        prout(_("%6d inhabited planets destroyed by your action   %5d") %
+              (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))
+        prout(_("%6d bases destroyed by your action     %5d") %
+              (game.state.basekl, -100*game.state.basekl))
     if game.nhelp:
-       prout(_("%6d calls for help from starbase       %5d") %
-             (game.nhelp, -45*game.nhelp))
+        prout(_("%6d calls for help from starbase       %5d") %
+              (game.nhelp, -45*game.nhelp))
     if game.casual:
-       prout(_("%6d casualties incurred                %5d") %
-             (game.casual, -game.casual))
+        prout(_("%6d casualties incurred                %5d") %
+              (game.casual, -game.casual))
     if game.abandoned:
-       prout(_("%6d crew abandoned in space            %5d") %
-             (game.abandoned, -3*game.abandoned))
+        prout(_("%6d crew abandoned in space            %5d") %
+              (game.abandoned, -3*game.abandoned))
     if klship:
-       prout(_("%6d ship(s) lost or destroyed          %5d") %
-             (klship, -100*klship))
+        prout(_("%6d ship(s) lost or destroyed          %5d") %
+              (klship, -100*klship))
+    if game.ncviol > 0:
+        if ncviol == 1:
+            prout(_("1 Treaty of Algeron violation          -100"))
+        else:
+            prout(_("%6d Treaty of Algeron violations       %5d\n") %
+                  (ncviol, -100*ncviol))
     if not game.alive:
-       prout(_("Penalty for getting yourself killed        -200"))
+        prout(_("Penalty for getting yourself killed        -200"))
     if game.gamewon:
-       proutn(_("Bonus for winning "))
-       if game.skill   == SKILL_NOVICE:        proutn(_("Novice game  "))
-       elif game.skill == SKILL_FAIR:          proutn(_("Fair game    "))
-       elif game.skill ==  SKILL_GOOD:         proutn(_("Good game    "))
-       elif game.skill ==  SKILL_EXPERT:       proutn(_("Expert game  "))
-       elif game.skill ==  SKILL_EMERITUS:     proutn(_("Emeritus game"))
-       prout("           %5d" % iwon)
+        proutn(_("Bonus for winning "))
+        if game.skill   == SKILL_NOVICE:        proutn(_("Novice game  "))
+        elif game.skill == SKILL_FAIR:          proutn(_("Fair game    "))
+        elif game.skill ==  SKILL_GOOD:         proutn(_("Good game    "))
+        elif game.skill ==  SKILL_EXPERT:        proutn(_("Expert game  "))
+        elif game.skill ==  SKILL_EMERITUS:        proutn(_("Emeritus game"))
+        prout("           %5d" % iwon)
     skip(1)
-    prout(_("TOTAL SCORE                               %5d") % iscore)
+    prout(_("TOTAL SCORE                               %5d") % game.score)
 
 def plaque():
-    "Emit winner's commemmorative plaque." 
+    "Emit winner's commemmorative plaque."
     skip(2)
     while True:
         proutn(_("File or device name for your plaque: "))
@@ -3012,10 +3271,10 @@ def plaque():
 
     proutn(_("Enter name to go on plaque (up to 30 characters): "))
     winner = cgetline()
-    # The 38 below must be 64 for 132-column paper 
+    # The 38 below must be 64 for 132-column paper
     nskip = 38 - len(winner)/2
     fp.write("\n\n\n\n")
-    # --------DRAW ENTERPRISE PICTURE. 
+    # --------DRAW ENTERPRISE PICTURE.
     fp.write("                                       EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n" )
     fp.write("                                      EEE                      E  : :                                         :  E\n" )
     fp.write("                                    EE   EEE                   E  : :                   NCC-1701              :  E\n")
@@ -3051,69 +3310,68 @@ def plaque():
         fp.write(_(" Cheat level\n\n"))
     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)
-    fp.write(_("                                                    Klingons per stardate:  %.2f\n") % perdate)
+             (timestring+4, timestring+20, timestring+11))
+    fp.write(_("                                                        Your score:  %d\n\n") % game.score)
+    fp.write(_("                                                    Klingons per stardate:  %.2f\n") % game.perdate)
     fp.close()
 
 # Code from io.c begins here
 
-rows = linecount = 0   # for paging 
+rows = linecount = 0        # for paging
 stdscr = None
 replayfp = None
 fullscreen_window = None
-srscan_window     = None
-report_window     = None
-status_window     = None
-lrscan_window     = None
-message_window    = None
-prompt_window     = None
+srscan_window     = None   # Short range scan
+report_window     = None   # Report legends for status window
+status_window     = None   # The status window itself
+lrscan_window     = None   # Long range scan
+message_window    = None   # Main window for scrolling text
+prompt_window     = None   # Prompt window at bottom of display
 curwnd = None
 
 def iostart():
     global stdscr, rows
-    "for some recent versions of python2, the following enables UTF8"
-    "for the older ones we probably need to set C locale, and the python3"
-    "has no problems at all"
+    # for some recent versions of python2, the following enables UTF8
+    # for the older ones we probably need to set C locale, and python3
+    # has no problems at all
     if sys.version_info[0] < 3:
-       import locale
-       locale.setlocale(locale.LC_ALL, "")
+        locale.setlocale(locale.LC_ALL, "")
     gettext.bindtextdomain("sst", "/usr/local/share/locale")
     gettext.textdomain("sst")
     if not (game.options & OPTION_CURSES):
-       ln_env = os.getenv("LINES")
+        ln_env = os.getenv("LINES")
         if ln_env:
             rows = ln_env
         else:
             rows = 25
     else:
-       stdscr = curses.initscr()
-       stdscr.keypad(True)
-       curses.nonl()
-       curses.cbreak()
+        stdscr = curses.initscr()
+        stdscr.keypad(True)
+        curses.nonl()
+        curses.cbreak()
         if game.options & OPTION_COLOR:
-            curses.start_color();
+            curses.start_color()
             curses.use_default_colors()
-            curses.init_pair(curses.COLOR_BLACK,   curses.COLOR_BLACK, -1);
-            curses.init_pair(curses.COLOR_GREEN,   curses.COLOR_GREEN, -1);
-            curses.init_pair(curses.COLOR_RED,     curses.COLOR_RED, -1);
-            curses.init_pair(curses.COLOR_CYAN,    curses.COLOR_CYAN, -1);
-            curses.init_pair(curses.COLOR_WHITE,   curses.COLOR_WHITE, -1);
-            curses.init_pair(curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, -1);
-            curses.init_pair(curses.COLOR_BLUE,    curses.COLOR_BLUE, -1);
-            curses.init_pair(curses.COLOR_YELLOW,  curses.COLOR_YELLOW, -1);
+            curses.init_pair(curses.COLOR_BLACK,   curses.COLOR_BLACK, -1)
+            curses.init_pair(curses.COLOR_GREEN,   curses.COLOR_GREEN, -1)
+            curses.init_pair(curses.COLOR_RED,     curses.COLOR_RED, -1)
+            curses.init_pair(curses.COLOR_CYAN,    curses.COLOR_CYAN, -1)
+            curses.init_pair(curses.COLOR_WHITE,   curses.COLOR_WHITE, -1)
+            curses.init_pair(curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, -1)
+            curses.init_pair(curses.COLOR_BLUE,    curses.COLOR_BLUE, -1)
+            curses.init_pair(curses.COLOR_YELLOW,  curses.COLOR_YELLOW, -1)
         global fullscreen_window, srscan_window, report_window, status_window
         global lrscan_window, message_window, prompt_window
-        (rows, columns)   = stdscr.getmaxyx()
-       fullscreen_window = stdscr
-       srscan_window     = curses.newwin(12, 25, 0,       0)
-       report_window     = curses.newwin(11, 0,  1,       25)
-       status_window     = curses.newwin(10, 0,  1,       39)
-       lrscan_window     = curses.newwin(5,  0,  0,       64) 
-       message_window    = curses.newwin(0,  0,  12,      0)
-       prompt_window     = curses.newwin(1,  0,  rows-2,  0) 
-       message_window.scrollok(True)
-       setwnd(fullscreen_window)
+        (rows, _columns)   = stdscr.getmaxyx()
+        fullscreen_window = stdscr
+        srscan_window     = curses.newwin(12, 25, 0,       0)
+        report_window     = curses.newwin(11, 0,  1,       25)
+        status_window     = curses.newwin(10, 0,  1,       39)
+        lrscan_window     = curses.newwin(5,  0,  0,       64)
+        message_window    = curses.newwin(0,  0,  12,      0)
+        prompt_window     = curses.newwin(1,  0,  rows-2,  0)
+        message_window.scrollok(True)
+        setwnd(fullscreen_window)
 
 def ioend():
     "Wrap up I/O."
@@ -3126,7 +3384,7 @@ def ioend():
 def waitfor():
     "Wait for user action -- OK to do nothing if on a TTY"
     if game.options & OPTION_CURSES:
-       stdscr.getch()
+        stdscr.getch()
 
 def announce():
     skip(1)
@@ -3152,89 +3410,116 @@ def pause_game():
         global linecount
         sys.stdout.write('\n')
         proutn(prompt)
-        raw_input()
+        if not replayfp:
+            my_input()
         sys.stdout.write('\n' * rows)
         linecount = 0
 
 def skip(i):
     "Skip i lines.  Pause game if this would cause a scrolling event."
-    for dummy in range(i):
-       if game.options & OPTION_CURSES:
-            (y, x) = curwnd.getyx()
-            (my, mx) = curwnd.getmaxyx()
-           if curwnd == message_window and y >= my - 2:
-               pause_game()
-               clrscr()
-           else:
-                try:
-                    curwnd.move(y+1, 0)
-                except curses.error:
-                    pass
-       else:
+    for _dummy in range(i):
+        if game.options & OPTION_CURSES:
+            (y, _x) = curwnd.getyx()
+            try:
+                curwnd.move(y+1, 0)
+            except curses.error:
+                pass
+        else:
             global linecount
-           linecount += 1
-           if rows and linecount >= rows:
-               pause_game()
-           else:
-               sys.stdout.write('\n')
+            linecount += 1
+            if rows and linecount >= rows:
+                pause_game()
+            else:
+                sys.stdout.write('\n')
 
-def proutn(line):
+def proutn(proutntline):
     "Utter a line with no following line feed."
     if game.options & OPTION_CURSES:
-       curwnd.addstr(line)
-       curwnd.refresh()
+        (y, x) = curwnd.getyx()
+        (my, _mx) = curwnd.getmaxyx()
+        if curwnd == message_window and y >= my - 2:
+            pause_game()
+            clrscr()
+        # Uncomment this to debug curses problems
+        if logfp:
+            logfp.write("#curses: at %s proutn(%s)\n" % ((y, x), repr(proutntline)))
+        curwnd.addstr(proutntline)
+        curwnd.refresh()
     else:
-       sys.stdout.write(line)
+        sys.stdout.write(proutntline)
         sys.stdout.flush()
 
-def prout(line):
-    proutn(line)
+def prout(proutline):
+    proutn(proutline)
     skip(1)
 
-def prouts(line):
-    "Emit slowly!" 
-    for c in line:
-        if not replayfp or replayfp.closed:    # Don't slow down replays
+def prouts(proutsline):
+    "Emit slowly!"
+    for c in proutsline:
+        if not replayfp or replayfp.closed:        # Don't slow down replays
             time.sleep(0.03)
-       proutn(c)
-       if game.options & OPTION_CURSES:
-           curwnd.refresh()
-       else:
-           sys.stdout.flush()
+        proutn(c)
+        if game.options & OPTION_CURSES:
+            curwnd.refresh()
+        else:
+            sys.stdout.flush()
     if not replayfp or replayfp.closed:
         time.sleep(0.03)
 
 def cgetline():
     "Get a line of input."
     if game.options & OPTION_CURSES:
-       line = curwnd.getstr() + "\n"
-       curwnd.refresh()
+        linein = curwnd.getstr() + "\n"
+        curwnd.refresh()
     else:
-       if replayfp and not replayfp.closed:
+        if replayfp and not replayfp.closed:
             while True:
-                line = replayfp.readline()
-                proutn(line)
-                if line == '':
+                linein = replayfp.readline()
+                proutn(linein)
+                if linein == '':
                     prout("*** Replay finished")
                     replayfp.close()
                     break
-                elif line[0] != "#":
+                elif linein[0] != "#":
                     break
-       else:
-           line = raw_input() + "\n"
+        else:
+            linein = my_input() + "\n"
     if logfp:
-       logfp.write(line)
-    return line
+        logfp.write(linein)
+    return linein
 
 def setwnd(wnd):
     "Change windows -- OK for this to be a no-op in tty mode."
     global curwnd
     if game.options & OPTION_CURSES:
+        # Uncomment this to debug curses problems
+        if logfp:
+            if wnd == fullscreen_window:
+                legend = "fullscreen"
+            elif wnd == srscan_window:
+                legend = "srscan"
+            elif wnd == report_window:
+                legend = "report"
+            elif wnd == status_window:
+                legend = "status"
+            elif wnd == lrscan_window:
+                legend = "lrscan"
+            elif wnd == message_window:
+                legend = "message"
+            elif wnd == prompt_window:
+                legend = "prompt"
+            else:
+                legend = "unknown"
+            logfp.write("#curses: setwnd(%s)\n" % legend)
         curwnd = wnd
-        curses.curs_set(wnd == fullscreen_window or wnd == message_window or wnd == prompt_window)
+        # Some curses implementations get confused when you try this.
+        try:
+            curses.curs_set(wnd in (fullscreen_window, message_window, prompt_window))
+        except curses.error:
+            pass
 
 def clreol():
-    "Clear to end of line -- can be a no-op in tty mode" 
+    "Clear to end of line -- can be a no-op in tty mode"
     if game.options & OPTION_CURSES:
         curwnd.clrtoeol()
         curwnd.refresh()
@@ -3243,47 +3528,47 @@ def clrscr():
     "Clear screen -- can be a no-op in tty mode."
     global linecount
     if game.options & OPTION_CURSES:
-       curwnd.clear()
-       curwnd.move(0, 0)
-       curwnd.refresh()
+        curwnd.clear()
+        curwnd.move(0, 0)
+        curwnd.refresh()
     linecount = 0
 
 def textcolor(color=DEFAULT):
     if game.options & OPTION_COLOR:
-       if color == DEFAULT: 
-           curwnd.attrset(0);
-       elif color ==  BLACK: 
-           curwnd.attron(curses.color_pair(curses.COLOR_BLACK));
-       elif color ==  BLUE: 
-           curwnd.attron(curses.color_pair(curses.COLOR_BLUE));
-       elif color ==  GREEN: 
-           curwnd.attron(curses.color_pair(curses.COLOR_GREEN));
-       elif color ==  CYAN: 
-           curwnd.attron(curses.color_pair(curses.COLOR_CYAN));
-       elif color ==  RED: 
-           curwnd.attron(curses.color_pair(curses.COLOR_RED));
-       elif color ==  MAGENTA: 
-           curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA));
-       elif color ==  BROWN: 
-           curwnd.attron(curses.color_pair(curses.COLOR_YELLOW));
-       elif color ==  LIGHTGRAY: 
-           curwnd.attron(curses.color_pair(curses.COLOR_WHITE));
-       elif color ==  DARKGRAY: 
-           curwnd.attron(curses.color_pair(curses.COLOR_BLACK) | curses.A_BOLD);
-       elif color ==  LIGHTBLUE: 
-           curwnd.attron(curses.color_pair(curses.COLOR_BLUE) | curses.A_BOLD);
-       elif color ==  LIGHTGREEN: 
-           curwnd.attron(curses.color_pair(curses.COLOR_GREEN) | curses.A_BOLD);
-       elif color ==  LIGHTCYAN: 
-           curwnd.attron(curses.color_pair(curses.COLOR_CYAN) | curses.A_BOLD);
-       elif color ==  LIGHTRED: 
-           curwnd.attron(curses.color_pair(curses.COLOR_RED) | curses.A_BOLD);
-       elif color ==  LIGHTMAGENTA: 
-           curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA) | curses.A_BOLD);
-       elif color ==  YELLOW: 
-           curwnd.attron(curses.color_pair(curses.COLOR_YELLOW) | curses.A_BOLD);
-       elif color ==  WHITE:
-           curwnd.attron(curses.color_pair(curses.COLOR_WHITE) | curses.A_BOLD);
+        if color == DEFAULT:
+            curwnd.attrset(0)
+        elif color ==  BLACK:
+            curwnd.attron(curses.color_pair(curses.COLOR_BLACK))
+        elif color ==  BLUE:
+            curwnd.attron(curses.color_pair(curses.COLOR_BLUE))
+        elif color ==  GREEN:
+            curwnd.attron(curses.color_pair(curses.COLOR_GREEN))
+        elif color ==  CYAN:
+            curwnd.attron(curses.color_pair(curses.COLOR_CYAN))
+        elif color ==  RED:
+            curwnd.attron(curses.color_pair(curses.COLOR_RED))
+        elif color ==  MAGENTA:
+            curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA))
+        elif color ==  BROWN:
+            curwnd.attron(curses.color_pair(curses.COLOR_YELLOW))
+        elif color ==  LIGHTGRAY:
+            curwnd.attron(curses.color_pair(curses.COLOR_WHITE))
+        elif color ==  DARKGRAY:
+            curwnd.attron(curses.color_pair(curses.COLOR_BLACK) | curses.A_BOLD)
+        elif color ==  LIGHTBLUE:
+            curwnd.attron(curses.color_pair(curses.COLOR_BLUE) | curses.A_BOLD)
+        elif color ==  LIGHTGREEN:
+            curwnd.attron(curses.color_pair(curses.COLOR_GREEN) | curses.A_BOLD)
+        elif color ==  LIGHTCYAN:
+            curwnd.attron(curses.color_pair(curses.COLOR_CYAN) | curses.A_BOLD)
+        elif color ==  LIGHTRED:
+            curwnd.attron(curses.color_pair(curses.COLOR_RED) | curses.A_BOLD)
+        elif color ==  LIGHTMAGENTA:
+            curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA) | curses.A_BOLD)
+        elif color ==  YELLOW:
+            curwnd.attron(curses.color_pair(curses.COLOR_YELLOW) | curses.A_BOLD)
+        elif color ==  WHITE:
+            curwnd.attron(curses.color_pair(curses.COLOR_WHITE) | curses.A_BOLD)
 
 def highvideo():
     if game.options & OPTION_COLOR:
@@ -3291,28 +3576,28 @@ def highvideo():
 
 #
 # Things past this point have policy implications.
-# 
+#
 
 def drawmaps(mode):
     "Hook to be called after moving to redraw maps."
     if game.options & OPTION_CURSES:
-       if mode == 1:
-           sensor()
+        if mode == 1:
+            sensor()
         setwnd(srscan_window)
         curwnd.move(0, 0)
         srscan()
-       if mode != 2:
-           setwnd(status_window)
-           status_window.clear()
-           status_window.move(0, 0)
-           setwnd(report_window)
-           report_window.clear()
-           report_window.move(0, 0)
-           status()
-           setwnd(lrscan_window)
-           lrscan_window.clear()
-           lrscan_window.move(0, 0)
-           lrscan(silent=False)
+        if mode != 2:
+            setwnd(status_window)
+            status_window.clear()
+            status_window.move(0, 0)
+            setwnd(report_window)
+            report_window.clear()
+            report_window.move(0, 0)
+            status()
+            setwnd(lrscan_window)
+            lrscan_window.clear()
+            lrscan_window.move(0, 0)
+            lrscan(silent=False)
 
 def put_srscan_sym(w, sym):
     "Emit symbol for short-range scan."
@@ -3321,100 +3606,100 @@ def put_srscan_sym(w, sym):
     srscan_window.refresh()
 
 def boom(w):
-    "Enemy fall down, go boom."  
+    "Enemy fall down, go boom."
     if game.options & OPTION_CURSES:
-       drawmaps(2)
-       setwnd(srscan_window)
-       srscan_window.attron(curses.A_REVERSE)
-       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.i][w.j])
-       curses.delay_output(500)
-       setwnd(message_window) 
+        drawmaps(2)
+        setwnd(srscan_window)
+        srscan_window.attron(curses.A_REVERSE)
+        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.i][w.j])
+        curses.delay_output(500)
+        setwnd(message_window)
 
 def warble():
     "Sound and visual effects for teleportation."
     if game.options & OPTION_CURSES:
-       drawmaps(2)
-       setwnd(message_window)
-       #sound(50)
+        drawmaps(2)
+        setwnd(message_window)
+        #sound(50)
     prouts("     . . . . .     ")
     if game.options & OPTION_CURSES:
-       #curses.delay_output(1000)
-       #nosound()
+        #curses.delay_output(1000)
+        #nosound()
         pass
 
-def tracktorpedo(origin, w, step, i, n, iquad):
-    "Torpedo-track animation." 
+def tracktorpedo(w, step, i, n, iquad):
+    "Torpedo-track animation."
     if not game.options & OPTION_CURSES:
-       if step == 1:
-           if n != 1:
-               skip(1)
-               proutn(_("Track for torpedo number %d-  ") % (i+1))
-           else:
-               skip(1)
-               proutn(_("Torpedo track- "))
-       elif step==4 or step==9: 
-           skip(1)
-       proutn("%s   " % w)
+        if step == 1:
+            if n != 1:
+                skip(1)
+                proutn(_("Track for torpedo number %d-  ") % (i+1))
+            else:
+                skip(1)
+                proutn(_("Torpedo track- "))
+        elif step==4 or step==9:
+            skip(1)
+        proutn("%s   " % w)
     else:
-       if not damaged(DSRSENS) or game.condition=="docked":
-           if i != 0 and step == 1:
-               drawmaps(2)
-               time.sleep(0.4)
-           if (iquad=='.') or (iquad==' '):
-               put_srscan_sym(w, '+')
-               #sound(step*10)
-               #time.sleep(0.1)
-               #nosound()
-               put_srscan_sym(w, iquad)
-           else:
-               curwnd.attron(curses.A_REVERSE)
-               put_srscan_sym(w, iquad)
-               #sound(500)
-               #time.sleep(1.0)
-               #nosound()
-               curwnd.attroff(curses.A_REVERSE)
-               put_srscan_sym(w, iquad)
-       else:
-           proutn("%s   " % w)
+        if not damaged(DSRSENS) or game.condition=="docked":
+            if i != 0 and step == 1:
+                drawmaps(2)
+                time.sleep(0.4)
+            if (iquad=='.') or (iquad==' '):
+                put_srscan_sym(w, '+')
+                #sound(step*10)
+                #time.sleep(0.1)
+                #nosound()
+                put_srscan_sym(w, iquad)
+            else:
+                curwnd.attron(curses.A_REVERSE)
+                put_srscan_sym(w, iquad)
+                #sound(500)
+                #time.sleep(1.0)
+                #nosound()
+                curwnd.attroff(curses.A_REVERSE)
+                put_srscan_sym(w, iquad)
+        else:
+            proutn("%s   " % w)
 
 def makechart():
     "Display the current galaxy chart."
     if game.options & OPTION_CURSES:
-       setwnd(message_window)
-       message_window.clear()
+        setwnd(message_window)
+        message_window.clear()
     chart()
     if game.options & OPTION_TTY:
-       skip(1)
+        skip(1)
 
-NSYM   = 14
+NSYM        = 14
 
 def prstat(txt, data):
     proutn(txt)
     if game.options & OPTION_CURSES:
-       skip(1)
-       setwnd(status_window)
+        skip(1)
+        setwnd(status_window)
     else:
         proutn(" " * (NSYM - len(txt)))
     proutn(data)
     skip(1)
     if game.options & OPTION_CURSES:
-       setwnd(report_window)
+        setwnd(report_window)
 
 # Code from moving.c begins here
 
 def imove(icourse=None, noattack=False):
     "Movement execution for warp, impulse, supernova, and tractor-beam events."
-    w = coord()
+    w = Coord()
 
     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:
+        # Leaving quadrant -- allow final enemy attack
+        # Don't set up attack if being pushed by nova or cloaked
+        if len(game.enemies) != 0 and not noattack and not game.iscloaked:
             newcnd()
             for enemy in game.enemies:
                 finald = (w - enemy.location).distance()
@@ -3426,9 +3711,11 @@ def imove(icourse=None, noattack=False):
                 attack(torps_ok=False)
             if game.alldone:
                 return
-        # check for edge of galaxy 
+        # check for edge of galaxy
         kinks = 0
         while True:
+
+
             kink = False
             if icourse.final.i < 0:
                 icourse.final.i = -icourse.final.i
@@ -3449,15 +3736,15 @@ def imove(icourse=None, noattack=False):
         if kinks:
             game.nkinks += 1
             if game.nkinks == 3:
-                # Three strikes -- you're out! 
+                # 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 
+        # Compute final position in new quadrant
+        if trbeam: # Don't bother if we are to be beamed
             return
         game.quadrant = icourse.final.quadrant()
         game.sector = icourse.final.sector()
@@ -3466,19 +3753,21 @@ def imove(icourse=None, noattack=False):
         game.quad[game.sector.i][game.sector.j] = game.ship
         newqad()
         if game.skill>SKILL_NOVICE:
-            attack(torps_ok=False)  
+            attack(torps_ok=False)
 
     def check_collision(h):
         iquad = game.quad[h.i][h.j]
         if iquad != '.':
-            # object encountered in flight path 
+            # object encountered in flight path
             stopegy = 50.0*icourse.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
+                        collision(rammed=False, enemy=enemy)
+                        return True
+                # This should not happen
+                prout(_("Which way did he go?"))
+                return False
             elif iquad == ' ':
                 skip(1)
                 prouts(_("***RED ALERT!  RED ALERT!"))
@@ -3490,16 +3779,16 @@ def imove(icourse=None, noattack=False):
                 # possibility that you'll get timewarped instead.
                 n=0
                 for m in range(NDEVICES):
-                    if game.damage[m]>0: 
+                    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): 
+                if (game.options & OPTION_BLKHOLE) and withprob(1-probf):
                     timwrp()
-                else: 
+                else:
                     finish(FHOLE)
                 return True
             else:
-                # something else 
+                # something else
                 skip(1)
                 proutn(crmshp())
                 if iquad == '#':
@@ -3516,24 +3805,30 @@ def imove(icourse=None, noattack=False):
 
     trbeam = False
     if game.inorbit:
-       prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
-       game.inorbit = False
-    # If tractor beam is to occur, don't move full distance 
+        prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
+        game.inorbit = False
+    # If tractor beam is to occur, don't move full distance
     if game.state.date+game.optime >= scheduled(FTBEAM):
-       trbeam = True
-       game.condition = "red"
-       icourse.distance = icourse.distance*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1
-       game.optime = scheduled(FTBEAM) - game.state.date + 1e-5
+        if game.iscloaked:
+            # We can't be tractor beamed if cloaked,
+            # so move the event into the future
+            postpone(FTBEAM, game.optime + expran(1.5*game.intime/len(game.kcmdr)))
+            pass
+        else:
+            trbeam = True
+            game.condition = "red"
+            icourse.distance = icourse.distance*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1
+            game.optime = scheduled(FTBEAM) - game.state.date + 1e-5
     # Move out
     game.quad[game.sector.i][game.sector.j] = '.'
-    for m in range(icourse.moves):
-        icourse.next()
+    for _m in range(icourse.moves):
+        icourse.nexttok()
         w = icourse.sector()
         if icourse.origin.quadrant() != icourse.location.quadrant():
             newquadrant(noattack)
             break
-        elif check_collision(icourse, w):
-            print "Collision detected"
+        elif check_collision(w):
+            print("Collision detected")
             break
         else:
             game.sector = w
@@ -3544,7 +3839,7 @@ def imove(icourse=None, noattack=False):
             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))
+        sortenemies()
         if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
             attack(torps_ok=False)
         for enemy in game.enemies:
@@ -3558,30 +3853,37 @@ def dock(verbose):
     "Dock our ship at a starbase."
     scanner.chew()
     if game.condition == "docked" and verbose:
-       prout(_("Already docked."))
-       return
+        prout(_("Already docked."))
+        return
     if game.inorbit:
-       prout(_("You must first leave standard orbit."))
-       return
+        prout(_("You must first leave standard orbit."))
+        return
     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
+        prout(crmshp() + _(" not adjacent to base."))
+        return
+    if game.iscloaked:
+        prout(_("You cannot dock while cloaked."))
+        return
     game.condition = "docked"
-    if "verbose":
-       prout(_("Docked."))
+    if verbose:
+        prout(_("Docked."))
     game.ididit = True
     if game.energy < game.inenrg:
-       game.energy = game.inenrg
+        game.energy = game.inenrg
     game.shield = game.inshld
     game.torps = game.intorps
     game.lsupres = game.inlsr
     game.state.crew = FULLCREW
+    if game.brigcapacity-game.brigfree > 0:
+        prout(_("%d captured Klingons transferred to base") % (game.brigcapacity-game.brigfree))
+        game.kcaptured += game.brigcapacity-game.brigfree
+        game.brigfree = game.brigcapacity
     if not damaged(DRADIO) and \
-       ((is_scheduled(FCDBAS) or game.isatb == 1) and not game.iseenit):
-       # get attack report from base 
-       prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\""))
-       attackreport(False)
-       game.iseenit = True
+        ((is_scheduled(FCDBAS) or game.isatb == 1) and not game.iseenit):
+        # get attack report from base
+        prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\""))
+        attackreport(False)
+        game.iseenit = True
 
 def cartesian(loc1=None, loc2=None):
     if loc1 is None:
@@ -3593,137 +3895,137 @@ def cartesian(loc1=None, loc2=None):
 
 def getcourse(isprobe):
     "Get a course and distance from the user."
-    key = 0
+    key = ""
     dquad = copy.copy(game.quadrant)
     navmode = "unspecified"
     itemp = "curt"
-    dsect = coord()
+    dsect = Coord()
     iprompt = False
     if game.landed and not isprobe:
-       prout(_("Dummy! You can't leave standard orbit until you"))
-       proutn(_("are back aboard the ship."))
-       scanner.chew()
-       raise TrekError
+        prout(_("Dummy! You can't leave standard orbit until you"))
+        proutn(_("are back aboard the ship."))
+        scanner.chew()
+        raise TrekError
     while navmode == "unspecified":
-       if damaged(DNAVSYS):
-           if isprobe:
-               prout(_("Computer damaged; manual navigation only"))
-           else:
-               prout(_("Computer damaged; manual movement only"))
-           scanner.chew()
-           navmode = "manual"
-           key = "IHEOL"
-           break
-        key = scanner.next()
-       if key == "IHEOL":
-           proutn(_("Manual or automatic- "))
-           iprompt = True
-           scanner.chew()
-       elif key == "IHALPHA":
+        if damaged(DNAVSYS):
+            if isprobe:
+                prout(_("Computer damaged; manual navigation only"))
+            else:
+                prout(_("Computer damaged; manual movement only"))
+            scanner.chew()
+            navmode = "manual"
+            key = "IHEOL"
+            break
+        key = scanner.nexttok()
+        if key == "IHEOL":
+            proutn(_("Manual or automatic- "))
+            iprompt = True
+            scanner.chew()
+        elif key == "IHALPHA":
             if scanner.sees("manual"):
-               navmode = "manual"
-               key = scanner.next()
-               break
+                navmode = "manual"
+                key = scanner.nexttok()
+                break
             elif scanner.sees("automatic"):
-               navmode = "automatic"
-               key = scanner.next()
-               break
-           else:
-               huh()
-               scanner.chew()
-               raise TrekError
-       else: # numeric 
-           if isprobe:
-               prout(_("(Manual navigation assumed.)"))
-           else:
-               prout(_("(Manual movement assumed.)"))
-           navmode = "manual"
-           break
-    delta = coord()
+                navmode = "automatic"
+                key = scanner.nexttok()
+                break
+            else:
+                huh()
+                scanner.chew()
+                raise TrekError
+        else: # numeric
+            if isprobe:
+                prout(_("(Manual navigation assumed.)"))
+            else:
+                prout(_("(Manual movement assumed.)"))
+            navmode = "manual"
+            break
+    delta = Coord()
     if navmode == "automatic":
-       while key == "IHEOL":
-           if isprobe:
-               proutn(_("Target quadrant or quadrant&sector- "))
-           else:
-               proutn(_("Destination sector or quadrant&sector- "))
-           scanner.chew()
-           iprompt = True
-           key = scanner.next()
-       if key != "IHREAL":
-           huh()
-           raise TrekError
-       xi = int(round(scanner.real))-1
-       key = scanner.next()
-       if key != "IHREAL":
-           huh()
-           raise TrekError
-       xj = int(round(scanner.real))-1
-       key = scanner.next()
-       if key == "IHREAL":
-           # both quadrant and sector specified 
-           xk = int(round(scanner.real))-1
-           key = scanner.next()
-           if key != "IHREAL":
-               huh()
-               raise TrekError
-           xl = int(round(scanner.real))-1
-           dquad.i = xi
-           dquad.j = xj
-           dsect.i = xk
-           dsect.j = xl
-       else:
+        while key == "IHEOL":
+            if isprobe:
+                proutn(_("Target quadrant or quadrant&sector- "))
+            else:
+                proutn(_("Destination sector or quadrant&sector- "))
+            scanner.chew()
+            iprompt = True
+            key = scanner.nexttok()
+        if key != "IHREAL":
+            huh()
+            raise TrekError
+        xi = int(round(scanner.real))-1
+        key = scanner.nexttok()
+        if key != "IHREAL":
+            huh()
+            raise TrekError
+        xj = int(round(scanner.real))-1
+        key = scanner.nexttok()
+        if key == "IHREAL":
+            # both quadrant and sector specified
+            xk = int(round(scanner.real))-1
+            key = scanner.nexttok()
+            if key != "IHREAL":
+                huh()
+                raise TrekError
+            xl = int(round(scanner.real))-1
+            dquad.i = xi
+            dquad.j = xj
+            dsect.i = xk
+            dsect.j = xl
+        else:
             # only one pair of numbers was specified
-           if isprobe:
-               # only quadrant specified -- go to center of dest quad 
-               dquad.i = xi
-               dquad.j = xj
-               dsect.j = dsect.i = 4   # preserves 1-origin behavior
-           else:
+            if isprobe:
+                # only quadrant specified -- go to center of dest quad
+                dquad.i = xi
+                dquad.j = xj
+                dsect.j = dsect.i = 4        # preserves 1-origin behavior
+            else:
                 # only sector specified
-               dsect.i = xi
-               dsect.j = xj
-           itemp = "normal"
-       if not dquad.valid_quadrant() or not dsect.valid_sector():
-           huh()
-           raise TrekError
-       skip(1)
-       if not isprobe:
-           if itemp > "curt":
-               if iprompt:
-                   prout(_("Helmsman Sulu- \"Course locked in for Sector %s.\"") % dsect)
-           else:
-               prout(_("Ensign Chekov- \"Course laid in, Captain.\""))
+                dsect.i = xi
+                dsect.j = xj
+            itemp = "normal"
+        if not dquad.valid_quadrant() or not dsect.valid_sector():
+            huh()
+            raise TrekError
+        skip(1)
+        if not isprobe:
+            if itemp > "curt":
+                if iprompt:
+                    prout(_("Helmsman Sulu- \"Course locked in for Sector %s.\"") % dsect)
+            else:
+                prout(_("Ensign Chekov- \"Course laid in, Captain.\""))
         # the actual deltas get computed here
-       delta.j = dquad.j-game.quadrant.j + (dsect.j-game.sector.j)/(QUADSIZE*1.0)
-       delta.i = game.quadrant.i-dquad.i + (game.sector.i-dsect.i)/(QUADSIZE*1.0)
-    else: # manual 
-       while key == "IHEOL":
-           proutn(_("X and Y displacements- "))
-           scanner.chew()
-           iprompt = True
-           key = scanner.next()
-       itemp = "verbose"
-       if key != "IHREAL":
-           huh()
-           raise TrekError
-       delta.j = scanner.real
-       key = scanner.next()
-       if key != "IHREAL":
-           huh()
-           raise TrekError
-       delta.i = scanner.real
-    # Check for zero movement 
+        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":
+            proutn(_("X and Y displacements- "))
+            scanner.chew()
+            iprompt = True
+            key = scanner.nexttok()
+        itemp = "verbose"
+        if key != "IHREAL":
+            huh()
+            raise TrekError
+        delta.j = scanner.real
+        key = scanner.nexttok()
+        if key != "IHREAL":
+            huh()
+            raise TrekError
+        delta.i = scanner.real
+    # Check for zero movement
     if delta.i == 0 and delta.j == 0:
-       scanner.chew()
-       raise TrekError
+        scanner.chew()
+        raise TrekError
     if itemp == "verbose" and not isprobe:
-       skip(1)
-       prout(_("Helmsman Sulu- \"Aye, Sir.\""))
+        skip(1)
+        prout(_("Helmsman Sulu- \"Aye, Sir.\""))
     scanner.chew()
     return course(bearing=delta.bearing(), distance=delta.distance())
 
 class course:
-    def __init__(self, bearing, distance, origin=None): 
+    def __init__(self, bearing, distance, origin=None):
         self.distance = distance
         self.bearing = bearing
         if origin is None:
@@ -3735,22 +4037,20 @@ class course:
         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))
+        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()
+        self.location = self.origin
+        self.nextlocation = None
     def reset(self):
         self.location = self.origin
         self.step = 0
     def arrived(self):
         return self.location.roundtogrid() == self.final
-    def next(self):
+    def nexttok(self):
         "Next step on course."
         self.step += 1
         self.nextlocation = self.location + self.increment
@@ -3761,370 +4061,377 @@ class course:
         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 power(self, w):
+        return self.distance*(w**3)*(game.shldup+1)
+    def time(self, w):
+        return 10.0*self.distance/w**2
 
 def impulse():
     "Move under impulse power."
     game.ididit = False
     if damaged(DIMPULS):
-       scanner.chew()
-       skip(1)
-       prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\""))
-       return
+        scanner.chew()
+        skip(1)
+        prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\""))
+        return
     if game.energy > 30.0:
         try:
-            course = getcourse(isprobe=False)
+            icourse = getcourse(isprobe=False)
         except TrekError:
-           return
-       power = 20.0 + 100.0*course.distance
+            return
+        power = 20.0 + 100.0*icourse.distance
     else:
-       power = 30.0
+        power = 30.0
     if power >= game.energy:
-       # Insufficient power for trip 
-       skip(1)
-       prout(_("First Officer Spock- \"Captain, the impulse engines"))
-       prout(_("require 20.0 units to engage, plus 100.0 units per"))
-       if game.energy > 30:
-           proutn(_("quadrant.  We can go, therefore, a maximum of %d") %
-                     int(0.01 * (game.energy-20.0)-0.05))
-           prout(_(" quadrants.\""))
-       else:
-           prout(_("quadrant.  They are, therefore, useless.\""))
-       scanner.chew()
-       return
-    # Make sure enough time is left for the trip 
-    game.optime = course.dist/0.095
+        # Insufficient power for trip
+        skip(1)
+        prout(_("First Officer Spock- \"Captain, the impulse engines"))
+        prout(_("require 20.0 units to engage, plus 100.0 units per"))
+        if game.energy > 30:
+            proutn(_("quadrant.  We can go, therefore, a maximum of %d") %
+                   int(0.01 * (game.energy-20.0)-0.05))
+            prout(_(" quadrants.\""))
+        else:
+            prout(_("quadrant.  They are, therefore, useless.\""))
+        scanner.chew()
+        return
+    # Make sure enough time is left for the trip
+    game.optime = icourse.distance/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"))
-       proutn(_("we dare spend the time?\" "))
-       if not ja():
-           return
-    # Activate impulse engines and pay the cost 
-    imove(course, noattack=False)
+        prout(_("First Officer Spock- \"Captain, our speed under impulse"))
+        prout(_("power is only 0.95 sectors per stardate. Are you sure"))
+        proutn(_("we dare spend the time?\" "))
+        if not ja():
+            return
+    # Activate impulse engines and pay the cost
+    imove(icourse, noattack=False)
     game.ididit = True
     if game.alldone:
-       return
-    power = 20.0 + 100.0*course.dist
+        return
+    power = 20.0 + 100.0*icourse.distance
     game.energy -= power
-    game.optime = course.dist/0.095
+    game.optime = icourse.distance/0.095
     if game.energy <= 0:
-       finish(FNRG)
+        finish(FNRG)
     return
 
 def warp(wcourse, involuntary):
     "ove under warp drive."
     blooey = False; twarp = False
-    if not involuntary: # Not WARPX entry 
-       game.ididit = False
-       if game.damage[DWARPEN] > 10.0:
-           scanner.chew()
-           skip(1)
-           prout(_("Engineer Scott- \"The warp engines are damaged, Sir.\""))
-           return
-       if damaged(DWARPEN) and game.warpfac > 4.0:
-           scanner.chew()
-           skip(1)
-           prout(_("Engineer Scott- \"Sorry, Captain. Until this damage"))
-           prout(_("  is repaired, I can only give you warp 4.\""))
-           return
-               # Read in course and distance
-        if wcourse==None:
+    if not involuntary: # Not WARPX entry
+        game.ididit = False
+        if game.iscloaked:
+            scanner.chew()
+            skip(1)
+            prout(_("Engineer Scott- \"The warp engines can not be used while cloaked, Sir.\""))
+            return
+        if game.damage[DWARPEN] > 10.0:
+            scanner.chew()
+            skip(1)
+            prout(_("Engineer Scott- \"The warp engines are damaged, Sir.\""))
+            return
+        if damaged(DWARPEN) and game.warpfac > 4.0:
+            scanner.chew()
+            skip(1)
+            prout(_("Engineer Scott- \"Sorry, Captain. Until this damage"))
+            prout(_("  is repaired, I can only give you warp 4.\""))
+            return
+               # Read in course and distance
+        if wcourse is None:
             try:
                 wcourse = getcourse(isprobe=False)
             except TrekError:
                 return
-       # Make sure starship has enough energy for the trip
+        # 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 wcourse.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*wcourse.power(game.warpfac) > game.energy:
-               iwarp = (game.energy/(wcourse.dist+0.05)) ** 0.333333333
-               if iwarp <= 0:
-                   prout(_("We can't do it, Captain. We don't have enough energy."))
-               else:
-                   proutn(_("We don't have enough energy, but we could do it at warp %d") % iwarp)
-                   if game.shldup:
-                       prout(",")
-                       prout(_("if you'll lower the shields."))
-                   else:
-                       prout(".")
-           else:
-               prout(_("We haven't the energy to go that far with the shields up."))
-           return                              
-       # Make sure enough time is left for the trip 
-       game.optime = wcourse.time(game.warpfac)
-       if game.optime >= 0.8*game.state.remtime:
-           skip(1)
-           prout(_("First Officer Spock- \"Captain, I compute that such"))
-           proutn(_("  a trip would require approximately %2.0f") %
-                  (100.0*game.optime/game.state.remtime))
-           prout(_(" percent of our"))
-           proutn(_("  remaining time.  Are you sure this is wise?\" "))
-           if not ja():
-               game.ididit = False
-               game.optime=0 
-               return
-    # Entry WARPX 
+        if wcourse.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*wcourse.power(game.warpfac) > game.energy:
+                iwarp = (game.energy/(wcourse.distance+0.05)) ** 0.333333333
+                if iwarp <= 0:
+                    prout(_("We can't do it, Captain. We don't have enough energy."))
+                else:
+                    proutn(_("We don't have enough energy, but we could do it at warp %d") % iwarp)
+                    if game.shldup:
+                        prout(",")
+                        prout(_("if you'll lower the shields."))
+                    else:
+                        prout(".")
+            else:
+                prout(_("We haven't the energy to go that far with the shields up."))
+            return
+        # Make sure enough time is left for the trip
+        game.optime = wcourse.time(game.warpfac)
+        if game.optime >= 0.8*game.state.remtime:
+            skip(1)
+            prout(_("First Officer Spock- \"Captain, I compute that such"))
+            proutn(_("  a trip would require approximately %2.0f") %
+                   (100.0*game.optime/game.state.remtime))
+            prout(_(" percent of our"))
+            proutn(_("  remaining time.  Are you sure this is wise?\" "))
+            if not ja():
+                game.ididit = False
+                game.optime=0
+                return
+    # Entry WARPX
     if game.warpfac > 6.0:
-       # Decide if engine damage will occur
-        # ESR: Seems wrong. Probability of damage goes *down* with distance? 
-       prob = wcourse.distance*(6.0-game.warpfac)**2/66.666666666
-       if prob > randreal():
-           blooey = True
-           wcourse.distance = randreal(wcourse.distance)
-       # Decide if time warp will occur 
-       if 0.5*wcourse.distance*math.pow(7.0,game.warpfac-10.0) > randreal():
-           twarp = True
-       if game.idebug and game.warpfac==10 and not twarp:
-           blooey = False
-           proutn("=== Force time warp? ")
-           if ja():
-               twarp = True
-       if blooey or twarp:
-           # If time warp or engine damage, check path 
-           # If it is obstructed, don't do warp or damage 
-            for m_unused in range(wcourse.moves):
-                wcourse.next()
+        # Decide if engine damage will occur
+        # ESR: Seems wrong. Probability of damage goes *down* with distance?
+        prob = wcourse.distance*(6.0-game.warpfac)**2/66.666666666
+        if prob > randreal():
+            blooey = True
+            wcourse.distance = randreal(wcourse.distance)
+        # Decide if time warp will occur
+        if 0.5*wcourse.distance*math.pow(7.0,game.warpfac-10.0) > randreal():
+            twarp = True
+        if game.idebug and game.warpfac==10 and not twarp:
+            blooey = False
+            proutn("=== Force time warp? ")
+            if ja():
+                twarp = True
+        if blooey or twarp:
+            # If time warp or engine damage, check path
+            # If it is obstructed, don't do warp or damage
+            look = wcourse.moves
+            while look > 0:
+                look -= 1
+                wcourse.nexttok()
                 w = wcourse.sector()
                 if not w.valid_sector():
                     break
-               if game.quad[w.i][w.j] != '.':
-                   blooey = False
-                   twarp = False
+                if game.quad[w.i][w.j] != '.':
+                    blooey = False
+                    twarp = False
             wcourse.reset()
-    # Activate Warp Engines and pay the cost 
-    imove(course, noattack=False)
+    # Activate Warp Engines and pay the cost
+    imove(wcourse, noattack=False)
     if game.alldone:
-       return
+        return
     game.energy -= wcourse.power(game.warpfac)
     if game.energy <= 0:
-       finish(FNRG)
+        finish(FNRG)
     game.optime = wcourse.time(game.warpfac)
     if twarp:
-       timwrp()
+        timwrp()
     if blooey:
-       game.damage[DWARPEN] = game.damfac * randreal(1.0, 4.0)
-       skip(1)
-       prout(_("Engineering to bridge--"))
-       prout(_("  Scott here.  The warp engines are damaged."))
-       prout(_("  We'll have to reduce speed to warp 4."))
+        game.damage[DWARPEN] = game.damfac * randreal(1.0, 4.0)
+        skip(1)
+        prout(_("Engineering to bridge--"))
+        prout(_("  Scott here.  The warp engines are damaged."))
+        prout(_("  We'll have to reduce speed to warp 4."))
     game.ididit = True
     return
 
 def setwarp():
     "Change the warp factor."
     while True:
-        key=scanner.next()
+        key=scanner.nexttok()
         if key != "IHEOL":
             break
-       scanner.chew()
-       proutn(_("Warp factor- "))
+        scanner.chew()
+        proutn(_("Warp factor- "))
     if key != "IHREAL":
-       huh()
-       return
+        huh()
+        return
     if game.damage[DWARPEN] > 10.0:
-       prout(_("Warp engines inoperative."))
-       return
+        prout(_("Warp engines inoperative."))
+        return
     if damaged(DWARPEN) and scanner.real > 4.0:
-       prout(_("Engineer Scott- \"I'm doing my best, Captain,"))
-       prout(_("  but right now we can only go warp 4.\""))
-       return
+        prout(_("Engineer Scott- \"I'm doing my best, Captain,"))
+        prout(_("  but right now we can only go warp 4.\""))
+        return
     if scanner.real > 10.0:
-       prout(_("Helmsman Sulu- \"Our top speed is warp 10, Captain.\""))
-       return
+        prout(_("Helmsman Sulu- \"Our top speed is warp 10, Captain.\""))
+        return
     if scanner.real < 1.0:
-       prout(_("Helmsman Sulu- \"We can't go below warp 1, Captain.\""))
-       return
+        prout(_("Helmsman Sulu- \"We can't go below warp 1, Captain.\""))
+        return
     oldfac = game.warpfac
     game.warpfac = scanner.real
     if game.warpfac <= oldfac or game.warpfac <= 6.0:
-       prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") %
-              int(game.warpfac))
-       return
+        prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") %
+              int(game.warpfac))
+        return
     if game.warpfac < 8.00:
-       prout(_("Engineer Scott- \"Aye, but our maximum safe speed is warp 6.\""))
-       return
+        prout(_("Engineer Scott- \"Aye, but our maximum safe speed is warp 6.\""))
+        return
     if game.warpfac == 10.0:
-       prout(_("Engineer Scott- \"Aye, Captain, we'll try it.\""))
-       return
+        prout(_("Engineer Scott- \"Aye, Captain, we'll try it.\""))
+        return
     prout(_("Engineer Scott- \"Aye, Captain, but our engines may not take it.\""))
     return
 
 def atover(igrab):
     "Cope with being tossed out of quadrant by supernova or yanked by beam."
     scanner.chew()
-    # is captain on planet? 
+    # is captain on planet?
     if game.landed:
-       if damaged(DTRANSP):
-           finish(FPNOVA)
-           return
-       prout(_("Scotty rushes to the transporter controls."))
-       if game.shldup:
-           prout(_("But with the shields up it's hopeless."))
-           finish(FPNOVA)
-       prouts(_("His desperate attempt to rescue you . . ."))
-       if withprob(0.5):
-           prout(_("fails."))
-           finish(FPNOVA)
-           return
-       prout(_("SUCCEEDS!"))
-       if game.imine:
-           game.imine = False
-           proutn(_("The crystals mined were "))
-           if withprob(0.25):
-               prout(_("lost."))
-           else:
-               prout(_("saved."))
-               game.icrystl = True
+        if damaged(DTRANSP):
+            finish(FPNOVA)
+            return
+        prout(_("Scotty rushes to the transporter controls."))
+        if game.shldup:
+            prout(_("But with the shields up it's hopeless."))
+            finish(FPNOVA)
+        prouts(_("His desperate attempt to rescue you . . ."))
+        if withprob(0.5):
+            prout(_("fails."))
+            finish(FPNOVA)
+            return
+        prout(_("SUCCEEDS!"))
+        if game.imine:
+            game.imine = False
+            proutn(_("The crystals mined were "))
+            if withprob(0.25):
+                prout(_("lost."))
+            else:
+                prout(_("saved."))
+                game.icrystl = True
     if igrab:
-       return
-    # Check to see if captain in shuttle craft 
+        return
+    # Check to see if captain in shuttle craft
     if game.icraft:
-       finish(FSTRACTOR)
+        finish(FSTRACTOR)
     if game.alldone:
-       return
-    # Inform captain of attempt to reach safety 
+        return
+    # Inform captain of attempt to reach safety
     skip(1)
     while True:
-       if game.justin:
-           prouts(_("***RED ALERT!  RED ALERT!"))
-           skip(1)
-           proutn(_("The %s has stopped in a quadrant containing") % crmshp())
-           prouts(_("   a supernova."))
-           skip(2)
-       prout(_("***Emergency automatic override attempts to hurl ")+crmshp())
-       prout(_("safely out of quadrant."))
-       if not damaged(DRADIO):
-           game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True
-       # Try to use warp engines 
-       if damaged(DWARPEN):
-           skip(1)
-           prout(_("Warp engines damaged."))
-           finish(FSNOVAED)
-           return
-       game.warpfac = randreal(6.0, 8.0)
-       prout(_("Warp factor set to %d") % int(game.warpfac))
-       power = 0.75*game.energy
-       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(bugout, involuntary=True)
-       if not game.justin:
-           # This is bad news, we didn't leave quadrant. 
-           if game.alldone:
-               return
-           skip(1)
-           prout(_("Insufficient energy to leave quadrant."))
-           finish(FSNOVAED)
-           return
-       # Repeat if another snova
+        if game.justin:
+            prouts(_("***RED ALERT!  RED ALERT!"))
+            skip(1)
+            proutn(_("The %s has stopped in a quadrant containing") % crmshp())
+            prouts(_("   a supernova."))
+            skip(2)
+        prout(_("***Emergency automatic override attempts to hurl ")+crmshp())
+        prout(_("safely out of quadrant."))
+        if not damaged(DRADIO):
+            game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True
+        # Try to use warp engines
+        if damaged(DWARPEN):
+            skip(1)
+            prout(_("Warp engines damaged."))
+            finish(FSNOVAED)
+            return
+        game.warpfac = randreal(6.0, 8.0)
+        prout(_("Warp factor set to %d") % int(game.warpfac))
+        power = 0.75*game.energy
+        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(bugout, involuntary=True)
+        if not game.justin:
+            # This is bad news, we didn't leave quadrant.
+            if game.alldone:
+                return
+            skip(1)
+            prout(_("Insufficient energy to leave quadrant."))
+            finish(FSNOVAED)
+            return
+        # Repeat if another snova
         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. 
+    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
+        finish(FWON) # Snova killed remaining enemy.
 
 def timwrp():
     "Let's do the time warp again."
     prout(_("***TIME WARP ENTERED."))
     if game.state.snap and withprob(0.5):
-       # Go back in time 
-       prout(_("You are traveling backwards in time %d stardates.") %
-             int(game.state.date-game.snapsht.date))
-       game.state = game.snapsht
-       game.state.snap = False
-       if len(game.state.kcmdr):
-           schedule(FTBEAM, expran(game.intime/len(game.state.kcmdr)))
-           schedule(FBATTAK, expran(0.3*game.intime))
-       schedule(FSNOVA, expran(0.5*game.intime))
-       # next snapshot will be sooner 
-       schedule(FSNAP, expran(0.25*game.state.remtime))
-                               
-       if game.state.nscrem:
-           schedule(FSCMOVE, 0.2777)       
-       game.isatb = 0
-       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=='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(_("Chekov-  \"Security reports the Galileo has reappeared in the dock!\""))
-           game.iscraft = "onship"
+        # Go back in time
+        prout(_("You are traveling backwards in time %d stardates.") %
+              int(game.state.date-game.snapsht.date))
+        game.state = game.snapsht
+        game.state.snap = False
+        if len(game.state.kcmdr):
+            schedule(FTBEAM, expran(game.intime/len(game.state.kcmdr)))
+            schedule(FBATTAK, expran(0.3*game.intime))
+        schedule(FSNOVA, expran(0.5*game.intime))
+        # next snapshot will be sooner
+        schedule(FSNAP, expran(0.25*game.state.remtime))
+
+        if game.state.nscrem:
+            schedule(FSCMOVE, 0.2777)
+        game.isatb = 0
+        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=='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(_("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"))
+        prout(_("Spock has reconstructed a correct star chart from memory"))
     else:
-       # Go forward in time 
-       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
+        # Go forward in time
+        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()
-    events()   # Stas Sergeev added this -- do pending events 
+    events()        # Stas Sergeev added this -- do pending events
 
 def probe():
-    "Launch deep-space probe." 
-    # New code to launch a deep space probe 
+    "Launch deep-space probe."
+    # New code to launch a deep space probe
     if game.nprobes == 0:
-       scanner.chew()
-       skip(1)
-       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."))
-       return
+        scanner.chew()
+        skip(1)
+        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."))
+        return
     if damaged(DDSP):
-       scanner.chew()
-       skip(1)
-       prout(_("Engineer Scott- \"The probe launcher is damaged, Sir.\""))
-       return
+        scanner.chew()
+        skip(1)
+        prout(_("Engineer Scott- \"The probe launcher is damaged, Sir.\""))
+        return
     if is_scheduled(FDSPROB):
-       scanner.chew()
-       skip(1)
-       if damaged(DRADIO) and game.condition != "docked":
-           prout(_("Spock-  \"Records show the previous probe has not yet"))
-           prout(_("   reached its destination.\""))
-       else:
-           prout(_("Uhura- \"The previous probe is still reporting data, Sir.\""))
-       return
-    key = scanner.next()
+        scanner.chew()
+        skip(1)
+        if damaged(DRADIO) and game.condition != "docked":
+            prout(_("Spock-  \"Records show the previous probe has not yet"))
+            prout(_("   reached its destination.\""))
+        else:
+            prout(_("Uhura- \"The previous probe is still reporting data, Sir.\""))
+        return
+    key = scanner.nexttok()
     if key == "IHEOL":
         if game.nprobes == 1:
             prout(_("1 probe left."))
         else:
             prout(_("%d probes left") % game.nprobes)
-       proutn(_("Are you sure you want to fire a probe? "))
-       if not ja():
-           return
+        proutn(_("Are you sure you want to fire a probe? "))
+        if not ja():
+            return
     game.isarmed = False
     if key == "IHALPHA" and scanner.token == "armed":
-       game.isarmed = True
-       key = scanner.next()
+        game.isarmed = True
+        key = scanner.nexttok()
     elif key == "IHEOL":
-       proutn(_("Arm NOVAMAX warhead? "))
-       game.isarmed = ja()
-    elif key == "IHREAL":              # first element of course
+        proutn(_("Arm NOVAMAX warhead? "))
+        game.isarmed = ja()
+    elif key == "IHREAL":                # first element of course
         scanner.push(scanner.token)
     try:
         game.probe = getcourse(isprobe=True)
@@ -4138,76 +4445,80 @@ def probe():
 
 def mayday():
     "Yell for help from nearest starbase."
-    # There's more than one way to move in this game! 
+    # There's more than one way to move in this game!
     scanner.chew()
-    # Test for conditions which prevent calling for help 
+    # Test for conditions which prevent calling for help
     if game.condition == "docked":
-       prout(_("Lt. Uhura-  \"But Captain, we're already docked.\""))
-       return
+        prout(_("Lt. Uhura-  \"But Captain, we're already docked.\""))
+        return
     if damaged(DRADIO):
-       prout(_("Subspace radio damaged."))
-       return
+        prout(_("Subspace radio damaged."))
+        return
     if not game.state.baseq:
-       prout(_("Lt. Uhura-  \"Captain, I'm not getting any response from Starbase.\""))
-       return
+        prout(_("Lt. Uhura-  \"Captain, I'm not getting any response from Starbase.\""))
+        return
     if game.landed:
-       prout(_("You must be aboard the %s.") % crmshp())
-       return
-    # OK -- call for help from nearest starbase 
+        prout(_("You must be aboard the %s.") % crmshp())
+        return
+    # OK -- call for help from nearest starbase
     game.nhelp += 1
     if game.base.i!=0:
-       # There's one in this quadrant 
-       ddist = (game.base - game.sector).distance()
+        # There's one in this quadrant
+        ddist = (game.base - game.sector).distance()
     else:
-       ddist = FOREVER
+        ibq = None     # Force base-quadrant game to persist past loop
+        ddist = FOREVER
         for ibq in game.state.baseq:
-           xdist = QUADSIZE * (ibq - game.quadrant).distance()
-           if xdist < ddist:
-               ddist = xdist
-       # Since starbase not in quadrant, set up new quadrant 
-       game.quadrant = ibq
-       newqad()
-    # dematerialize starship 
+            xdist = QUADSIZE * (ibq - game.quadrant).distance()
+            if xdist < ddist:
+                ddist = xdist
+        if ibq is None:
+            prout(_("No starbases remain. You are alone in a hostile galaxy."))
+            return
+        # Since starbase not in quadrant, set up new quadrant
+        game.quadrant = ibq
+        newqad()
+    # dematerialize starship
     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 w.valid_sector() and game.quad[w.i][w.j]=='.':
-           # found one -- finish up 
+        w = game.base.scatter()
+        if w.valid_sector() and game.quad[w.i][w.j]=='.':
+            # found one -- finish up
             game.sector = w
-           break
+            break
     if not game.sector.is_valid():
-       prout(_("You have been lost in space..."))
-       finish(FMATERIALIZE)
-       return
-    # Give starbase three chances to rematerialize starship 
+        prout(_("You have been lost in space..."))
+        finish(FMATERIALIZE)
+        return
+    # Give starbase three chances to rematerialize starship
     probf = math.pow((1.0 - math.pow(0.98,ddist)), 0.33333333)
     for m in range(1, 3+1):
-       if m == 1: proutn(_("1st"))
-       elif m == 2: proutn(_("2nd"))