22cddcf8e920 — Eric S. Raymond 8 years ago
Another step in Python 3 translation.

Detabify, and use integer division operations where needed.

All regression testrs pass (in Python 2).
2 files changed, 3400 insertions(+), 3398 deletions(-)

M sst.py
M test/Makefile
M sst.py +3397 -3397
@@ 21,11 21,11 @@ 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 

          
@@ 66,7 66,7 @@ class Coord:
     def valid_quadrant(self):
         return self.i >= 0 and self.i < GALSIZE and self.j >= 0 and self.j < GALSIZE
     def valid_sector(self):
-	return self.i >= 0 and self.i < QUADSIZE and self.j >= 0 and self.j < QUADSIZE
+        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):

          
@@ 136,12 136,12 @@ class Thingy(Coord):
 
 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 inhabited?
+        self.known = "unknown"        # could be "unknown", "known", "shuttle_down"
+        self.inhabited = False        # is it inhabited?
     def __str__(self):
         return self.name
 

          
@@ 149,18 149,18 @@ 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"
+        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 = False
-	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)
 

          
@@ 175,77 175,77 @@ def fill2d(size, fillfun):
 
 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())
         # the starchart
-    	self.chart = fill2d(GALSIZE, lambda i_unused, j_unused: Page())
+        self.chart = fill2d(GALSIZE, lambda i_unused, j_unused: Page())
 
 class Event:
     def __init__(self):
-        self.date = None	# A real number
-        self.quadrant = None	# A coord structure
+        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)
+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
+DSRSENS         = 0
+DLRSENS         = 1
+DPHASER         = 2
+DPHOTON         = 3
+DLIFSUP         = 4
+DWARPEN         = 5
+DIMPULS         = 6
+DSHIELD         = 7
+DRADIO         = 0
 DSHUTTL  = 9
 DCOMPTR  = 10
-DNAVSYS	 = 11
+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
+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)

          
@@ 253,20 253,20 @@ 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
+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 

          
@@ 281,7 281,7 @@ class Enemy:
         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)

          
@@ 301,95 301,95 @@ class Enemy:
             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:
     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.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.score = 0.0	# overall score
-        self.perdate = 0.0	# rate of kills
-        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.
     def recompute(self):
         # 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.

          
@@ 427,9 427,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

          
@@ 437,8 437,8 @@ 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."

          
@@ 446,41 446,41 @@ def tryexit(enemy, look, irun):
     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 []
-	    # 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 []
+            # 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()
+        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
+        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
+        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, ibq)]
 

          
@@ 529,48 529,48 @@ def movebaddy(enemy):
     irun = False
     # 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)
+        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
+        (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):
+        # 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
+                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:
+            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:
+                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:

          
@@ 578,27 578,27 @@ def movebaddy(enemy):
     # 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)
+        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 
     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:

          
@@ 607,115 607,115 @@ 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 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 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 
+                    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)
+        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':
-		tacmoves += movebaddy(enemy)
+            if enemy.type == 'C':
+                tacmoves += movebaddy(enemy)
     if game.state.kscmdr == game.quadrant:
         for enemy in game.enemies:
-	    if enemy.type == 'S':
-		tacmoves += 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'):
-		tacmoves += movebaddy(enemy)
+                tacmoves += movebaddy(enemy)
     return tacmoves
 
 def movescom(iq, avoid):
     "Commander movement helper." 
     # Avoid quadrants with bases if we want to avoid Enterprise 
     if not welcoming(iq) or (avoid and iq in game.state.baseq):
-	return False
+        return False
     if game.justin and not game.iscate:
-	return False
+        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':
-		enemy.move(None)
-	game.klhere -= 1
-	if game.condition != "docked":
-	    newcnd()
+        # 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
+        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()

          
@@ 724,51 724,51 @@ def supercommander():
     idelta = Coord()
     basetbl = []
     if game.idebug:
-	prout("== SUPERCOMMANDER")
+        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
+        # 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.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
+        # 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
+        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
+                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

          
@@ 776,63 776,63 @@ def supercommander():
     # 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)
+        # 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
+                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)

          
@@ 841,28 841,28 @@ def supercommander():
 def movetholian():
     "Move the Tholian."
     if not game.tholian or game.justin:
-	return
+        return
     tid = Coord()
     if game.tholian.location.i == 0 and game.tholian.location.j == 0:
-	tid.i = 0
+        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.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.i = QUADSIZE-1
         tid.j = 0
     elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == 0:
-	tid.i = 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
+        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 

          
@@ 877,14 877,14 @@ def movetholian():
             game.tholian.move(here)
     # 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
+        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(' ')

          
@@ 899,135 899,135 @@ def doshield(shraise):
     action = "NONE"
     game.ididit = False
     if shraise:
-	action = "SHUP"
+        action = "SHUP"
     else:
-	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
+        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
+        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.nexttok() != "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% 
     )
     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 for rammong events."

          
@@ 1044,7 1044,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.")

          
@@ 1058,28 1058,28 @@ 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)
+        setwnd(srscan_window)
     else: 
-	setwnd(message_window)
-    ac = bearing + 0.25*dispersion	# dispersion is a random variable
+        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)

          
@@ 1089,39 1089,39 @@ def torpedo(origin, bearing, dispersion,
         if not track.nexttok():
             break
         w = track.sector()
-	if not w.valid_sector():
-	    break
-	iquad = game.quad[w.i][w.j]
-	tracktorpedo(w, step, number, nburst, iquad)
-	if iquad == '.':
-	    continue
-	# hit something 
+        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 
+            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.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())
+            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)

          
@@ 1129,14 1129,14 @@ def torpedo(origin, bearing, dispersion,
                 enemy.kdist = enemy.kavgd = (game.sector-enemy.location).distance()
             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:
+                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))

          
@@ 1175,99 1175,99 @@ def torpedo(origin, bearing, dispersion,
                 prout("Internal error, no enemy where expected!")
                 raise SystemExit(1)
             return None
-	elif iquad == 'B': # Hit a base 
-	    skip(1)
-	    prout(_("***STARBASE DESTROYED.."))
+        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)
+            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()
-	    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
+            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."))

          
@@ 1276,24 1276,24 @@ def torpedo(origin, bearing, dispersion,
 def fry(hit):
     "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:
         while True:
-	    j = randdevice()
-	    # Cheat to prevent shuttle damage unless on ship 
+            j = randdevice()
+            # Cheat to prevent shuttle damage unless on ship 
             if not (game.damage[j]<0.0 or (j == DSHUTTL and game.iscraft != "onship")):
                 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

          
@@ 1301,15 1301,15 @@ 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
 
 def attack(torps_ok):
     # bad guy attacks us 
     # torps_ok == False forces use of phasers in an attack 
     # game could be over at this point, check
     if game.alldone:
-	return
+        return
     attempt = False
     ihurt = False
     hitmax = 0.0

          
@@ 1317,14 1317,14 @@ def attack(torps_ok):
     chgfac = 1.0
     where = "neither"
     if game.idebug:
-	prout("=== ATTACK!")
+        prout("=== ATTACK!")
     # Tholian gets to move before attacking 
     if game.tholian:
-	movetholian()
+        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
+        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():

          
@@ 1347,129 1347,129 @@ def attack(torps_ok):
         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
+        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 
     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.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 == 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 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 == 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 
     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
+        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
+        enemy.kavgd = enemy.kdist
     sortenemies()
     return
-		
+                
 def deadkl(w, etype, mv):
     "Kill a Klingon, Tholian, Romulan, or Thingy." 
     # Added mv to allow enemy to "move" before dying 

          
@@ 1510,31 1510,31 @@ def deadkl(w, etype, mv):
     # For each kind of enemy, finish message to player 
     prout(_(" destroyed."))
     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
-	return
+        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
+        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
+        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():

          
@@ 1542,63 1542,63 @@ 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.nexttok()
-	if scanner.token == "IHALPHA":
-	    huh()
-	    return
-	elif scanner.token == "IHEOL" or not scanner.waiting():
-	    prout(_("%d torpedoes left.") % game.torps)
+        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.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
+        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:
             return
         tcourse.append(targetcheck(target[-1]))
         if tcourse[-1] == None:
-	    return
+            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:
                 return

          
@@ 1608,45 1608,45 @@ def torps():
     game.ididit = True
     # 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.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
+        prout(_("Shields lowered."))
+        return False
     # Something bad has happened 
     prouts(_("***RED ALERT!  RED ALERT!"))
     skip(2)

          
@@ 1654,11 1654,11 @@ def checkshctrl(rpow):
     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.\""))

          
@@ 1666,11 1666,11 @@ 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."))

          
@@ 1683,44 1683,44 @@ def hittem(hits):
     skip(1)
     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 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()
-	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
 

          
@@ 1740,239 1740,239 @@ def phasers():
     skip(1)
     # 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.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? "))
+        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.nexttok()
-	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.nexttok()
-	    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
+        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))
+        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.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 
+                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.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
+                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
+        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.

          
@@ 2007,12 2007,12 @@ 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():

          
@@ 2107,104 2107,104 @@ def events():
         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
+        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 \
+        # 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 \
+                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

          
@@ 2217,15 2217,15 @@ def events():
                 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
             try:
                 for ibq in game.state.baseq:

          
@@ 2239,147 2239,147 @@ def events():
                     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 \
+        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)
+                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 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())
+                    #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 
+            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]
+                # 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):
+                      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") \
+                # 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") % \
+                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
+                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:
+            if game.klhere >= MAXKLQUAD:
                 try:
                     # this quadrant not ok, pick an adjacent one 
                     for m.i in range(w.i - 1, w.i + 2):

          
@@ 2392,73 2392,73 @@ def events():
                                 continue
                             raise JumpOut
                     else:
-                        continue	# search for eligible quadrant failed
+                        continue        # search for eligible quadrant failed
                 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.nexttok()
-	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
+        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

          
@@ 2469,9 2469,9 @@ def nova(nov):
     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)
     if withprob(0.05):
-	# Wow! We've supernova'ed 
-	supernova(game.quadrant)
-	return
+        # Wow! We've supernova'ed 
+        supernova(game.quadrant)
+        return
     # handle initial nova 
     game.quad[nov.i][nov.j] = '.'
     prout(crmena(False, '*', "sector", nov) + _(" novas."))

          
@@ 2501,10 2501,10 @@ def nova(nov):
                         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 

          
@@ 2582,9 2582,9 @@ def nova(nov):
     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)
     skip(1)

          
@@ 2592,70 2592,70 @@ def nova(nov):
     imove(scourse, noattack=True)
     game.optime = scourse.time(warp=4)
     return
-	
+        
 def supernova(w):
     "Star goes supernova."
     num = 0; npdead = 0
     if w != None: 
-	nq = copy.copy(w)
+        nq = copy.copy(w)
     else:
-	# Scheduled supernova -- select star at random. 
-	stars = 0
+        # 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
+        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
     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

          
@@ 2669,30 2669,30 @@ def supernova(w):
     game.state.nromrem -= nrmdead
     # 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 = [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
+        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
+        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
+        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 
     if game.alldone:
-	finish(FSNOVAED)
+        finish(FSNOVAED)
     return
 
 # Code from finish.c ends here.

          
@@ 2701,8 2701,8 @@ def selfdestruct():
     "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)

          
@@ 2719,11 2719,11 @@ def selfdestruct():
     skip(1)
     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)

          
@@ 2731,29 2731,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
-	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)
+        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)

          
@@ 2783,270 2783,270 @@ def finish(ifin):
     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."))
+        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: