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
BASEMIN		= 2				# Minimum starbases
-BASEMAX 	= (GALSIZE * GALSIZE / 12)	# Maximum starbases
+BASEMAX 	= (GALSIZE * GALSIZE // 12)	# Maximum starbases
MAXKLGAME	= 127		# Maximum Klingons per game
FULLCREW	= 428		# Crew size. BSD Trek was 387, that's wrong

@@ 66,7 66,7 @@ class Coord:
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.pclass = None	# could be ""M", "N", "O", or "destroyed"
+        self.name = None        # string-valued if inhabited
+        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
+DSRSENS         = 0
+DLRSENS         = 1
+DPHASER         = 2
+DPHOTON         = 3
+DLIFSUP         = 4
+DWARPEN         = 5
+DIMPULS         = 6
+DSHIELD         = 7
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():

# 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.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.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?"
-	not game.state.galaxy[iq.i][iq.j].supernova and \
+        not game.state.galaxy[iq.i][iq.j].supernova and \

def tryexit(enemy, look, irun):
"A bad guy attempts to bug out."

@@ 446,41 446,41 @@ def tryexit(enemy, look, irun):
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
-		return []
-	# don't leave if over 1000 units of energy
-	if enemy.power > 1000.0:
-	    return []
+            # refuse to leave if currently attacking starbase
+                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[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:
-		game.state.kcmdr.append(iq)
-		break
+        for cmdr in game.state.kcmdr:
+                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
if game.skill >= SKILL_EXPERT:
else:
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
+        (enemy.power <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
+        irun = True
else:
-	# decide whether to advance, retreat, or hold position
-	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
+        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
-	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 = []
for enemy in game.enemies:
-	    if enemy.type == 'C':
+            if enemy.type == 'C':
for enemy in game.enemies:
-	    if enemy.type == 'S':
-		break
+            if enemy.type == 'S':
+                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'):
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
-	# 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
-	if idelta.distance() > 2.0:
-	    # circulate in space
+        # compute move away from Enterprise
+        if idelta.distance() > 2.0:
+            # circulate in space
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
elif game.tholian.location.i == 0 and game.tholian.location.j == 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
-	    return
-	    return
-	    return
-	    return
+            return
+            return
+            return
+            return
# All plugged up -- Tholian splits
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:
-	    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:
+            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:
-	    return
-	game.shldup = False
-	game.shldchg = True
-	prout(_("Shields lowered."))
-	game.ididit = True
-	return
+        if not game.shldup:
+            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%
-	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%
+        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)
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
-	# Damage for at least time of travel!
-	game.damage[dev] += game.optime + extradm
+        dev = randdevice()
+        if game.damage[dev] < 0:
+            continue
+        # 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
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
-	tracktorpedo(w, step, number, nburst, iquad)
-	    continue
-	# hit something
+        if not w.valid_sector():
+            break
+        tracktorpedo(w, step, number, nburst, 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
-		# 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
+                # can't move into object
+                return hit
+            game.sector = bumpto
+            proutn(crmshp())
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.base.invalidate()
-	    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.iplnet.pclass = "destroyed"
-	    game.iplnet = None
-	    game.plnet.invalidate()
-	    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.iplnet.pclass = "destroyed"
-	    game.iplnet = None
-	    game.plnet.invalidate()
-	    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.base.invalidate()
+            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.iplnet.pclass = "destroyed"
+            game.iplnet = None
+            game.plnet.invalidate()
+            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.iplnet.pclass = "destroyed"
+            game.iplnet = None
+            game.plnet.invalidate()
+            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)
-	    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.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)
-	    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)
+            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.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)
+            dropin(' ')
+            return None
else: # Problem!
-	    skip(1)
-	    proutn("Don't know how to handle torpedo collision with ")
-	    skip(1)
-	    return None
-	break
+            skip(1)
+            proutn("Don't know how to handle torpedo collision with ")
+            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)
+        cdam.append(j)
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):
# 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!
-		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!
+                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
-
+
"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)
-	    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)
+            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
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 "))
-	if ienm == '?':
-	    thing.angry()
-	proutn(crmena(False, ienm, "sector", w))
-	skip(1)
-	if kpow == 0:
-	    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
-		finish(FWON)
-	    if game.alldone:
-		return
-	    kk -= 1	# don't do the increment
+        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 "))
+        if ienm == '?':
+            thing.angry()
+        proutn(crmena(False, ienm, "sector", w))
+        skip(1)
+        if kpow == 0:
+            if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
+                finish(FWON)
+            if game.alldone:
+                return
+            kk -= 1        # don't do the increment
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
-	    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
+            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")
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
-	    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))
-		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
+            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))
+                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
-	    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():
-		    # Left galaxy or ran into supernova
+                    # Left galaxy or ran into supernova
if communicating():
-			announce()
-			skip(1)
-			proutn(_("Lt. Uhura-  \"The deep space probe "))
-			    prout(_("has left the galaxy.\""))
-			else:
-			    prout(_("is no longer transmitting.\""))
-		    unschedule(FDSPROB)
-		    continue
+                        announce()
+                        skip(1)
+                        proutn(_("Lt. Uhura-  \"The deep space probe "))
+                            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())
-	    if communicating():
-		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)
-		    return
-	elif evcode == FDISTR: # inhabited system issues distress call
-	    unschedule(FDISTR)
-	    # try a whole bunch of times to find something suitable
+            if communicating():
+                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)
+                    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))
-	    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))
+            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
-	    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))
-
-	    # 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
+            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))
+
+            # report the disaster if we can
+            if communicating():
+                prout(_("Uhura- We've lost contact with starsystem %s") % \
q.planet)
-	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
-	    if q.klingons <= 0:
-		q.status = "secure"
-		continue
-	    if game.state.remkl >= MAXKLGAME:
-		continue		# full right now
-	    # reproduce one Klingon
+        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
+            if q.klingons <= 0:
+                q.status = "secure"
+                continue
+            if game.state.remkl >= MAXKLGAME:
+                continue                # full right now
+            # reproduce one Klingon
m = Coord()
try:
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
+            # deliver the child
+            game.state.remkl += 1
+            q.klingons += 1
game.klhere += 1
-		game.enemies.append(newkling())
-	    # recompute time left
+                game.enemies.append(newkling())
+            # recompute time left
game.recompute()
-	    if communicating():
-		    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():
+                    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
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
-	return
+        # Wow! We've supernova'ed
+        return
# handle initial nova
prout(crmena(False, '*', "sector", nov) + _(" novas."))

@@ 2501,10 2501,10 @@ def nova(nov):
return
else:
hits.append(neighbor)
-			game.state.starkl += 1
-			proutn(crmena(True, '*', "sector", neighbor))
-			prout(_(" novas."))
+                        game.state.starkl += 1
+                        proutn(crmena(True, '*', "sector", neighbor))
+                        prout(_(" novas."))
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():
+        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():
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)
+        # 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)
else:
-	ns = Coord()
-	# we are in the quadrant!
-	num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
-		    num -= 1
-		    if num==0:
-			break
-	    if num==0:
-		break
-	skip(1)
-	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
+                    num -= 1
+                    if num==0:
+                        break
+            if num==0:
+                break
+        skip(1)
+        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
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):
# Destroy planets
for loop in range(game.inplan):
-	    game.state.planets[loop].pclass = "destroyed"
+            game.state.planets[loop].pclass = "destroyed"
# 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.starkl += game.state.galaxy[nq.i][nq.j].stars
+        game.state.basekl += game.state.galaxy[nq.i][nq.j].starbase
# 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:
-	skip(1)
-	prouts(_("CONTINUITY-EFFECTED"))
-	skip(2)
-	return
+        skip(1)
+        prouts(_("CONTINUITY-EFFECTED"))
+        skip(2)
+        return
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:
+        whammo = 25.0 * game.energy
+        for l in range(len(game.enemies)):
+            if game.enemies[l].power*game.enemies[l].kdist <= whammo:
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 = 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:
```