[super-star-trek.git] / src / sst.py

#!/usr/bin/env python
"""
sst.py =-- Super Star Trek in Python

This code is a Python translation of a C translation of a FORTRAN
original dating back to 1973.  Beautiful Python it is not.  But it
works.

Dave Matuszek says:

SRSCAN, MOVE, PHASERS, CALL, STATUS, IMPULSE, PHOTONS, ABANDON,
LRSCAN, WARP, SHIELDS, DESTRUCT, CHART, REST, DOCK, QUIT, and DAMAGE
were in the original non-"super" version of UT FORTRAN Star Trek.

Tholians were not in the original. Dave is dubious about their merits.
(They are now controlled by OPTION_THOLIAN and turned off if the game
type is "plain".)

Planets and dilithium crystals were not in the original.  Dave is OK
with this idea. (It's now controlled by OPTION_PLANETS and turned 
off if the game type is "plain".)

Dave says the bit about the Galileo getting turned into a
McDonald's is "consistant with our original vision".  (This has been
left permanently enabled, as it can only happen if OPTION_PLANETS
is on.)

Dave also says the Space Thingy should not be preserved across saved
games, so you can't prove to others that you've seen it.  He says it
shouldn't fire back, either.  It should do nothing except scream and
disappear when hit by photon torpedos.  It's OK that it may move
when attacked, but it didn't in the original.  (Whether the Thingy
can fire back is now controlled by OPTION_THINGY and turned off if the
game type is "plain" or "almy".  The no-save behavior has been restored.)

The Faerie Queen, black holes, and time warping were in the original.

Here are Tom Almy's changes:

In early 1997, I got the bright idea to look for references to
"Super Star Trek" on the World Wide Web. There weren't many hits,
but there was one that came up with 1979 Fortran sources! This
version had a few additional features that mine didn't have,
however mine had some feature it didn't have. So I merged its
features that I liked. I also took a peek at the DECUS version (a
port, less sources, to the PDP-10), and some other variations.

1, Compared to the original UT version, I've changed the "help"
command to "call" and the "terminate" command to "quit" to better
match user expectations. The DECUS version apparently made those
changes as well as changing "freeze" to "save". However I like
"freeze".  (Both "freeze" and "save" work in SST2K.)

2. The experimental deathray originally had only a 5% chance of
success, but could be used repeatedly. I guess after a couple
years of use, it was less "experimental" because the 1979
version had a 70% success rate. However it was prone to breaking
after use. I upgraded the deathray, but kept the original set of
failure modes (great humor!).  (Now controlled by OPTION_DEATHRAY
and turned off if game type is "plain".)

3. The 1979 version also mentions srscan and lrscan working when
docked (using the starbase's scanners), so I made some changes here
to do this (and indicating that fact to the player), and then realized
the base would have a subspace radio as well -- doing a Chart when docked
updates the star chart, and all radio reports will be heard. The Dock
command will also give a report if a base is under attack.

4. Tholian Web from the 1979 version.  (Now controlled by
OPTION_THOLIAN and turned off if game type is "plain".)

5. Enemies can ram the Enterprise. (Now controlled by OPTION_RAMMING
and turned off if game type is "plain".)

6. Regular Klingons and Romulans can move in Expert and Emeritus games. 
This code could use improvement. (Now controlled by OPTION_MVBADDY
and turned off if game type is "plain".)

7. The deep-space probe feature from the DECUS version.  (Now controlled
by OPTION_PROBE and turned off if game type is "plain").

8. 'emexit' command from the 1979 version.

9. Bugfix: Klingon commander movements are no longer reported if long-range 
sensors are damaged.

10. Bugfix: Better base positioning at startup (more spread out).
That made sense to add because most people abort games with 
bad base placement.

In June 2002, I fixed two known bugs and a documentation typo.
In June 2004 I fixed a number of bugs involving: 1) parsing invalid
numbers, 2) manual phasers when SR scan is damaged and commander is
present, 3) time warping into the future, 4) hang when moving
klingons in crowded quadrants.  (These fixes are in SST2K.)

Here are Stas Sergeev's changes:

1. The Space Thingy can be shoved, if you ram it, and can fire back if 
fired upon. (Now controlled by OPTION_THINGY and turned off if game 
type is "plain" or "almy".)

2. When you are docked, base covers you with an almost invincible shield. 
(A commander can still ram you, or a Romulan can destroy the base,
or a SCom can even succeed with direct attack IIRC, but this rarely 
happens.)  (Now controlled by OPTION_BASE and turned off if game 
type is "plain" or "almy".)

3. Ramming a black hole is no longer instant death.  There is a
chance you might get timewarped instead. (Now controlled by 
OPTION_BLKHOLE and turned off if game type is "plain" or "almy".)

4. The Tholian can be hit with phasers.

5. SCom can't escape from you if no more enemies remain 
(without this, chasing SCom can take an eternity).

6. Probe target you enter is now the destination quadrant. Before I don't 
remember what it was, but it was something I had difficulty using.

7. Secret password is now autogenerated.

8. "Plaque" is adjusted for A4 paper :-)

9. Phasers now tells you how much energy needed, but only if the computer 
is alive.

10. Planets are auto-scanned when you enter the quadrant.

11. Mining or using crystals in presense of enemy now yields an attack.
There are other minor adjustments to what yields an attack
and what does not.

12. "freeze" command reverts to "save", most people will understand this
better anyway. (SST2K recognizes both.)

13. Screen-oriented interface, with sensor scans always up.  (SST2K
supports both screen-oriented and TTY modes.)

Eric Raymond's changes:

Mainly, I translated this C code out of FORTRAN into C -- created #defines
for a lot of magic numbers and refactored the heck out of it.

1. "sos" and "call" becomes "mayday", "freeze" and "save" are both good.

2. Status report now indicates when dilithium crystals are on board.

3. Per Dave Matuszek's remarks, Thingy state is never saved across games.

4. Added game option selection so you can play a close (but not bug-for-
bug identical) approximation of older versions.

5. Half the quadrants now have inhabited planets, from which one 
cannot mine dilithium (there will still be the same additional number
of dilithium-bearing planets).  Torpedoing an inhabited world is *bad*.
There is BSD-Trek-like logic for Klingons to attack and enslave 
inhabited worlds, producing more ships (only is skill is 'good' or 
better). (Controlled by OPTION_WORLDS and turned off if game 
type is "plain" or "almy".)

6. User input is now logged so we can do regression testing.

7. More BSD-Trek features: You can now lose if your entire crew
dies in battle.  When abandoning ship in a game with inhabited
worlds enabled, they must have one in the quadrant to beam down
to; otherwise they die in space and this counts heavily against
your score.  Docking at a starbase replenishes your crew.

8. Still more BSD-Trek: we now have a weighted damage table.
Also, the nav subsystem (enabling automatic course
setting) can be damaged separately from the main computer (which
handles weapons targeting, ETA calculation, and self-destruct).

After these features were added, I translated this into Python and added
more:

9. A long-range scan is done silently whenever you call CHART; thus
the LRSCAN command is no longer needed.  (Controlled by OPTION_AUTOSCAN
and turned off if game type is "plain" or "almy".)
"""
import os, sys, math, curses, time, readline, cPickle, random, copy, gettext

SSTDOC          = "/usr/share/doc/sst/sst.doc"
DOC_NAME        = "sst.doc"

def _(str): return gettext.gettext(str)

PHASEFAC        = 2.0
GALSIZE         = 8
NINHAB          = (GALSIZE * GALSIZE / 2)
MAXUNINHAB      = 10
PLNETMAX        = (NINHAB + MAXUNINHAB)
QUADSIZE        = 10
BASEMIN         = 2
BASEMAX         = (GALSIZE * GALSIZE / 12)
MAXKLGAME       = 127
MAXKLQUAD       = 9
FULLCREW        = 428   # BSD Trek was 387, that's wrong 
FOREVER         = 1e30
MAXBURST        = 3
MINCMDR         = 10

# How to represent features
IHR = 'R',
IHK = 'K',
IHC = 'C',
IHS = 'S',
IHSTAR = '*',
IHP = 'P',
IHW = '@',
IHB = 'B',
IHBLANK = ' ',
IHDOT = '.',
IHQUEST = '?',
IHE = 'E',
IHF = 'F',
IHT = 'T',
IHWEB = '#',
IHMATER0 = '-',
IHMATER1 = 'o',
IHMATER2 = '0'

class TrekError:
    pass

class coord:
    def __init__(self, x=None, y=None):
        self.i = x
        self.j = y
    def valid_quadrant(self):
        return self.i>=0 and self.i<GALSIZE and self.j>=0 and self.j<GALSIZE
    def valid_sector(self):
        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):
        return self.i != None and self.j != None
    def __eq__(self, other):
        return other != None and self.i == other.i and self.j == other.j
    def __ne__(self, other):
        return other == None or self.i != other.i or self.j != other.j
    def __add__(self, other):
        return coord(self.i+other.i, self.j+other.j)
    def __sub__(self, other):
        return coord(self.i-other.i, self.j-other.j)
    def __mul__(self, other):
        return coord(self.i*other, self.j*other)
    def __rmul__(self, other):
        return coord(self.i*other, self.j*other)
    def __div__(self, other):
        return coord(self.i/other, self.j/other)
    def __mod__(self, other):
        return coord(self.i % other, self.j % other)
    def __rdiv__(self, other):
        return coord(self.i/other, self.j/other)
    def roundtogrid(self):
        return coord(int(round(self.i)), int(round(self.j)))
    def distance(self, other=None):
        if not other: other = coord(0, 0)
        return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
    def bearing(self, other=None):
        if not other: other = coord(0, 0)
        return 1.90985*math.atan2(self.j-other.j, self.i-other.i)
    def sgn(self):
        s = coord()
        if self.i == 0:
            s.i = 0
        else:
            s.i = self.i / abs(self.i)
        if self.j == 0:
            s.j = 0
        else:
            s.j = self.j / abs(self.j)
        return s
    def quadrant(self):
        return (self / QUADSIZE).roundtogrid()
    def sector(self):
        return self.roundtogrid() % QUADSIZE
    def scatter(self):
        s = coord()
        s.i = self.i + randrange(-1, 2)
        s.j = self.j + randrange(-1, 2)
        return s
    def __str__(self):
        if self.i == None or self.j == None:
            return "Nowhere"
        return "%s - %s" % (self.i+1, self.j+1)
    __repr__ = __str__

class planet:
    def __init__(self):
        self.name = None        # string-valued if inhabited
        self.quadrant = coord() # quadrant located
        self.pclass = None      # could be ""M", "N", "O", or "destroyed"
        self.crystals = "absent"# could be "mined", "present", "absent"
        self.known = "unknown"  # could be "unknown", "known", "shuttle_down"
        self.inhabited = False  # is it inhabites?
    def __str__(self):
        return self.name

class quadrant:
    def __init__(self):
        self.stars = 0
        self.planet = None
        self.starbase = False
        self.klingons = 0
        self.romulans = 0
        self.supernova = False
        self.charted = False
        self.status = "secure"  # Could be "secure", "distressed", "enslaved"

class page:
    def __init__(self):
        self.stars = None
        self.starbase = None
        self.klingons = None

def fill2d(size, fillfun):
    "Fill an empty list in 2D."
    lst = []
    for i in range(size):
        lst.append([]) 
        for j in range(size):
            lst[i].append(fillfun(i, j))
    return lst

class snapshot:
    def __init__(self):
        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, j: quadrant())
        # the starchart
        self.chart = fill2d(GALSIZE, lambda i, j: page())

class event:
    def __init__(self):
        self.date = None        # A real number
        self.quadrant = None    # A coord structure

# game options 
OPTION_ALL      = 0xffffffff
OPTION_TTY      = 0x00000001    # old interface 
OPTION_CURSES   = 0x00000002    # new interface 
OPTION_IOMODES  = 0x00000003    # cover both interfaces 
OPTION_PLANETS  = 0x00000004    # planets and mining 
OPTION_THOLIAN  = 0x00000008    # Tholians and their webs (UT 1979 version)
OPTION_THINGY   = 0x00000010    # Space Thingy can shoot back (Stas, 2005)
OPTION_PROBE    = 0x00000020    # deep-space probes (DECUS version, 1980)
OPTION_SHOWME   = 0x00000040    # bracket Enterprise in chart 
OPTION_RAMMING  = 0x00000080    # enemies may ram Enterprise (Almy)
OPTION_MVBADDY  = 0x00000100    # more enemies can move (Almy)
OPTION_BLKHOLE  = 0x00000200    # black hole may timewarp you (Stas, 2005) 
OPTION_BASE     = 0x00000400    # bases have good shields (Stas, 2005)
OPTION_WORLDS   = 0x00000800    # logic for inhabited worlds (ESR, 2006)
OPTION_AUTOSCAN = 0x00001000    # automatic LRSCAN before CHART (ESR, 2006)
OPTION_PLAIN    = 0x01000000    # user chose plain game 
OPTION_ALMY     = 0x02000000    # user chose Almy variant 

# Define devices 
DSRSENS = 0
DLRSENS = 1
DPHASER = 2
DPHOTON = 3
DLIFSUP = 4
DWARPEN = 5
DIMPULS = 6
DSHIELD = 7
DRADIO  = 0
DSHUTTL = 9
DCOMPTR = 10
DNAVSYS = 11
DTRANSP = 12
DSHCTRL = 13
DDRAY   = 14
DDSP    = 15
NDEVICES= 16    # Number of devices

SKILL_NONE      = 0
SKILL_NOVICE    = 1
SKILL_FAIR      = 2
SKILL_GOOD      = 3
SKILL_EXPERT    = 4
SKILL_EMERITUS  = 5

def damaged(dev):       return (game.damage[dev] != 0.0)
def communicating():    return not damaged(DRADIO) or game.condition=="docked"

# Define future events 
FSPY    = 0     # Spy event happens always (no future[] entry)
                # can cause SC to tractor beam Enterprise
FSNOVA  = 1     # Supernova
FTBEAM  = 2     # Commander tractor beams Enterprise
FSNAP   = 3     # Snapshot for time warp
FBATTAK = 4     # Commander attacks base
FCDBAS  = 5     # Commander destroys base
FSCMOVE = 6     # Supercommander moves (might attack base)
FSCDBAS = 7     # Supercommander destroys base
FDSPROB = 8     # Move deep space probe
FDISTR  = 9     # Emit distress call from an inhabited world 
FENSLV  = 10    # Inhabited word is enslaved */
FREPRO  = 11    # Klingons build a ship in an enslaved system
NEVENTS = 12

#
# abstract out the event handling -- underlying data structures will change
# when we implement stateful events
# 
def findevent(evtype):  return game.future[evtype]

class enemy:
    def __init__(self, type=None, loc=None, power=None):
        self.type = type
        self.kloc = coord()
        if loc:
            self.move(loc)
        self.kpower = power     # enemy energy level
        game.enemies.append(self)
    def move(self, loc):
        motion = (loc != self.kloc)
        if self.kloc.i is not None and self.kloc.j is not None:
            if motion:
                if self.type == IHT:
                    game.quad[self.kloc.i][self.kloc.j] = IHWEB
                else:
                    game.quad[self.kloc.i][self.kloc.j] = IHDOT
        if loc:
            self.kloc = copy.copy(loc)
            game.quad[self.kloc.i][self.kloc.j] = self.type
            self.kdist = self.kavgd = (game.sector - loc).distance()
        else:
            self.kloc = coord()
            self.kdist = self.kavgd = None
            game.enemies.remove(self)
        return motion
    def __repr__(self):
        return "<%s,%s.%f>" % (self.type, self.kloc, self.kpower)       # For debugging

class gamestate:
    def __init__(self):
        self.options = None     # Game options
        self.state = snapshot() # A snapshot structure
        self.snapsht = snapshot()       # Last snapshot taken for time-travel purposes
        self.quad = None        # contents of our quadrant
        self.damage = [0.0] * NDEVICES  # damage encountered
        self.future = []                # future events
        for i in range(NEVENTS):
            self.future.append(event())
        self.passwd  = None;            # Self Destruct password
        self.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          # =1 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.wfacsq = 0.0       # squared warp factor
        self.lsupres = 0.0      # life support reserves
        self.optime = 0.0       # time taken by current operation
        self.docfac = 0.0       # repair factor when docking (constant?)
        self.damfac = 0.0       # damage factor
        self.lastchart = 0.0    # time star chart was last updated
        self.cryprob = 0.0      # probability that crystal will work
        self.probe = None       # object holding probe course info
        self.height = 0.0       # height of orbit around planet
    def recompute(self):
        # Stas thinks this should be (C expression): 
        # game.state.remkl + len(game.state.kcmdr) > 0 ?
        #       game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) : 99
        # He says the existing expression is prone to divide-by-zero errors
        # after killing the last klingon when score is shown -- perhaps also
        # if the only remaining klingon is SCOM.
        game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr))

IHR = 'R'
IHK = 'K'
IHC = 'C'
IHS = 'S'
IHSTAR = '*'
IHP = 'P'
IHW = '@'
IHB = 'B'
IHBLANK = ' '
IHDOT = '.'
IHQUEST = '?'
IHE = 'E'
IHF = 'F'
IHT = 'T'
IHWEB = '#'
IHMATER0 = '-'
IHMATER1 = 'o'
IHMATER2 = '0'

FWON = 0
FDEPLETE = 1
FLIFESUP = 2
FNRG = 3
FBATTLE = 4
FNEG3 = 5
FNOVA = 6
FSNOVAED = 7
FABANDN = 8
FDILITHIUM = 9
FMATERIALIZE = 10
FPHASER = 11
FLOST = 12
FMINING = 13
FDPLANET = 14
FPNOVA = 15
FSSC = 16
FSTRACTOR = 17
FDRAY = 18
FTRIBBLE = 19
FHOLE = 20
FCREW = 21

def withprob(p):
    v = random.random()
    #logfp.write("# withprob(%s) -> %f (%s) at %s\n" % (p, v, v<p, traceback.extract_stack()[-2][1:]))
    return v < p

def randrange(*args):
    v = random.randrange(*args)
    #logfp.write("# randrange%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
    return v

def randreal(*args):
    v = random.random()
    if len(args) == 1:
        v *= args[0]            # returns from [0, args[0])
    elif len(args) == 2:
        v = args[0] + v*(args[1]-args[0])       # returns from [args[0], args[1])
    #logfp.write("# randreal%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
    return v

# Code from ai.c begins here

def welcoming(iq):
    "Would this quadrant welcome another Klingon?"
    return iq.valid_quadrant() and \
        not game.state.galaxy[iq.i][iq.j].supernova and \
        game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD

def tryexit(enemy, look, irun):
    "A bad guy attempts to bug out."
    iq = coord()
    iq.i = game.quadrant.i+(look.i+(QUADSIZE-1))/QUADSIZE - 1
    iq.j = game.quadrant.j+(look.j+(QUADSIZE-1))/QUADSIZE - 1
    if not welcoming(iq):
        return False;
    if enemy.type == IHR:
        return False; # Romulans cannot escape! 
    if not irun:
        # avoid intruding on another commander's territory 
        if enemy.type == IHC:
            if iq in game.state.kcmdr:
                return False
            # refuse to leave if currently attacking starbase 
            if game.battle == game.quadrant:
                return False
        # don't leave if over 1000 units of energy 
        if enemy.kpower > 1000.0:
            return False
    # emit escape message and move out of quadrant.
    # we know this if either short or long range sensors are working
    if not damaged(DSRSENS) or not damaged(DLRSENS) or \
        game.condition == "docked":
        prout(crmena(True, enemy.type, "sector", enemy.kloc) + \
              (_(" escapes to Quadrant %s (and regains strength).") % q))
    # handle local matters related to escape
    enemy.move(None)
    game.klhere -= 1
    if game.condition != "docked":
        newcnd()
    # Handle global matters related to escape 
    game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
    game.state.galaxy[iq.i][iq.j].klingons += 1
    if enemy.type==IHS:
        game.iscate = False
        game.ientesc = False
        game.isatb = 0
        schedule(FSCMOVE, 0.2777)
        unschedule(FSCDBAS)
        game.state.kscmdr=iq
    else:
        for cmdr in game.state.kcmdr:
            if cmdr == game.quadrant:
                game.state.kcmdr[n] = iq
                break
    return True; # success 

# The bad-guy movement algorithm:
# 
# 1. Enterprise has "force" based on condition of phaser and photon torpedoes.
# If both are operating full strength, force is 1000. If both are damaged,
# force is -1000. Having shields down subtracts an additional 1000.
# 
# 2. Enemy has forces equal to the energy of the attacker plus
# 100*(K+R) + 500*(C+S) - 400 for novice through good levels OR
# 346*K + 400*R + 500*(C+S) - 400 for expert and emeritus.
# 
# Attacker Initial energy levels (nominal):
# Klingon   Romulan   Commander   Super-Commander
# Novice    400        700        1200        
# Fair      425        750        1250
# Good      450        800        1300        1750
# Expert    475        850        1350        1875
# Emeritus  500        900        1400        2000
# VARIANCE   75        200         200         200
# 
# Enemy vessels only move prior to their attack. In Novice - Good games
# only commanders move. In Expert games, all enemy vessels move if there
# is a commander present. In Emeritus games all enemy vessels move.
# 
# 3. If Enterprise is not docked, an aggressive action is taken if enemy
# forces are 1000 greater than Enterprise.
# 
# Agressive action on average cuts the distance between the ship and
# the enemy to 1/4 the original.
# 
# 4.  At lower energy advantage, movement units are proportional to the
# advantage with a 650 advantage being to hold ground, 800 to move forward
# 1, 950 for two, 150 for back 4, etc. Variance of 100.
# 
# If docked, is reduced by roughly 1.75*game.skill, generally forcing a
# retreat, especially at high skill levels.
# 
# 5.  Motion is limited to skill level, except for SC hi-tailing it out.

def movebaddy(enemy):
    "Tactical movement for the bad guys."
    next = coord(); look = coord()
    irun = False
    # This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant) 
    if game.skill >= SKILL_EXPERT:
        nbaddys = (((game.quadrant in game.state.kcmdr)*2 + (game.state.kscmdr==game.quadrant)*2+game.klhere*1.23+game.irhere*1.5)/2.0)
    else:
        nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
    dist1 = enemy.kdist
    mdist = int(dist1 + 0.5); # Nearest integer distance 
    # If SC, check with spy to see if should hi-tail it 
    if enemy.type==IHS and \
        (enemy.kpower <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
        irun = True
        motion = -QUADSIZE
    else:
        # decide whether to advance, retreat, or hold position 
        forces = enemy.kpower+100.0*len(game.enemies)+400*(nbaddys-1)
        if not game.shldup:
            forces += 1000; # Good for enemy if shield is down! 
        if not damaged(DPHASER) or not damaged(DPHOTON):
            if damaged(DPHASER): # phasers damaged 
                forces += 300.0
            else:
                forces -= 0.2*(game.energy - 2500.0)
            if damaged(DPHOTON): # photon torpedoes damaged 
                forces += 300.0
            else:
                forces -= 50.0*game.torps
        else:
            # phasers and photon tubes both out! 
            forces += 1000.0
        motion = 0
        if forces <= 1000.0 and game.condition != "docked": # Typical situation 
            motion = ((forces + randreal(200))/150.0) - 5.0
        else:
            if forces > 1000.0: # Very strong -- move in for kill 
                motion = (1.0 - randreal())**2 * dist1 + 1.0
            if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off ! 
                motion -= game.skill*(2.0-randreal()**2)
        if idebug:
            proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces))
        # don't move if no motion 
        if motion==0:
            return
        # Limit motion according to skill 
        if abs(motion) > game.skill:
            if motion < 0:
                motion = -game.skill
            else:
                motion = game.skill
    # calculate preferred number of steps 
    nsteps = abs(int(motion))
    if motion > 0 and nsteps > mdist:
        nsteps = mdist; # don't overshoot 
    if nsteps > QUADSIZE:
        nsteps = QUADSIZE; # This shouldn't be necessary 
    if nsteps < 1:
        nsteps = 1; # This shouldn't be necessary 
    if idebug:
        proutn("NSTEPS = %d:" % nsteps)
    # Compute preferred values of delta X and Y 
    m = game.sector - enemy.kloc
    if 2.0 * abs(m.i) < abs(m.j):
        m.i = 0
    if 2.0 * abs(m.j) < abs(game.sector.i-enemy.kloc.i):
        m.j = 0
    m = (motion * m).sgn()
    next = enemy.kloc
    # main move loop 
    for ll in range(nsteps):
        if idebug:
            proutn(" %d" % (ll+1))
        # Check if preferred position available 
        look = next + m
        if m.i < 0:
            krawli = 1
        else:
            krawli = -1
        if m.j < 0:
            krawlj = 1
        else:
            krawlj = -1
        success = False
        attempts = 0; # Settle mysterious hang problem 
        while attempts < 20 and not success:
            attempts += 1
            if look.i < 0 or look.i >= QUADSIZE:
                if motion < 0 and tryexit(enemy, look, irun):
                    return
                if krawli == m.i or m.j == 0:
                    break
                look.i = next.i + krawli
                krawli = -krawli
            elif look.j < 0 or look.j >= QUADSIZE:
                if motion < 0 and tryexit(enemy, look, irun):
                    return
                if krawlj == m.j or m.i == 0:
                    break
                look.j = next.j + krawlj
                krawlj = -krawlj
            elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != IHDOT:
                # See if enemy should ram ship 
                if game.quad[look.i][look.j] == game.ship and \
                    (enemy.type == IHC or enemy.type == IHS):
                    collision(rammed=True, enemy=enemy)
                    return
                if krawli != m.i and m.j != 0:
                    look.i = next.i + krawli
                    krawli = -krawli
                elif krawlj != m.j and m.i != 0:
                    look.j = next.j + krawlj
                    krawlj = -krawlj
                else:
                    break; # we have failed 
            else:
                success = True
        if success:
            next = look
            if idebug:
                proutn(`next`)
        else:
            break; # done early 
    if idebug:
        skip(1)
    if enemy.move(next):
        if not damaged(DSRSENS) or game.condition == "docked":
            proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.kloc))
            if enemy.kdist < dist1:
                proutn(_(" advances to "))
            else:
                proutn(_(" retreats to "))
            prout("Sector %s." % next)

def moveklings():
    "Sequence Klingon tactical movement."
    if idebug:
        prout("== MOVCOM")
    # Figure out which Klingon is the commander (or Supercommander)
    # and do move
    if game.quadrant in game.state.kcmdr:
        for enemy in game.enemies:
            if enemy.type == IHC:
                movebaddy(enemy)
    if game.state.kscmdr==game.quadrant:
        for enemy in game.enemies:
            if enemy.type == IHS:
                movebaddy(enemy)
                break
    # If skill level is high, move other Klingons and Romulans too!
    # Move these last so they can base their actions on what the
    # commander(s) do.
    if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
        for enemy in game.enemies:
            if enemy.type in (IHK, IHR):
                movebaddy(enemy)
    game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))

def movescom(iq, avoid):
    "Commander movement helper." 
    # Avoid quadrants with bases if we want to avoid Enterprise 
    if not welcoming(iq) or (avoid and iq in game.state.baseq):
        return False
    if game.justin and not game.iscate:
        return False
    # do the move 
    game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons -= 1
    game.state.kscmdr = iq
    game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons += 1
    if game.state.kscmdr==game.quadrant:
        # SC has scooted, Remove him from current quadrant 
        game.iscate=False
        game.isatb=0
        game.ientesc = False
        unschedule(FSCDBAS)
        for enemy in game.enemies:
            if enemy.type == IHS:
                break
        enemy.move(None)
        game.klhere -= 1
        if game.condition != "docked":
            newcnd()
        game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
    # check for a helpful planet 
    for i in range(game.inplan):
        if game.state.planets[i].quadrant == game.state.kscmdr and \
            game.state.planets[i].crystals == "present":
            # destroy the planet 
            game.state.planets[i].pclass = "destroyed"
            game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].planet = None
            if communicating():
                announce()
                prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
                proutn(_("   a planet in Quadrant %s has been destroyed") % game.state.kscmdr)
                prout(_("   by the Super-commander.\""))
            break
    return True; # looks good! 
                        
def supercommander():
    "Move the Super Commander." 
    iq = coord(); sc = coord(); ibq = coord(); idelta = coord()
    basetbl = []
    if idebug:
        prout("== SUPERCOMMANDER")
    # Decide on being active or passive 
    avoid = ((game.incom - len(game.state.kcmdr) + game.inkling - game.state.remkl)/(game.state.date+0.01-game.indate) < 0.1*game.skill*(game.skill+1.0) or \
            (game.state.date-game.indate) < 3.0)
    if not game.iscate and avoid:
        # compute move away from Enterprise 
        idelta = game.state.kscmdr-game.quadrant
        if idelta.distance() > 2.0:
            # circulate in space 
            idelta.i = game.state.kscmdr.j-game.quadrant.j
            idelta.j = game.quadrant.i-game.state.kscmdr.i
    else:
        # compute distances to starbases 
        if not game.state.baseq:
            # nothing left to do 
            unschedule(FSCMOVE)
            return
        sc = game.state.kscmdr
        for base in game.state.baseq:
            basetbl.append((i, (base - sc).distance()))
        if game.state.baseq > 1:
            basetbl.sort(lambda x, y: cmp(x[1]. y[1]))
        # look for nearest base without a commander, no Enterprise, and
        # without too many Klingons, and not already under attack. 
        ifindit = iwhichb = 0
        for (i2, base) in enumerate(game.state.baseq):
            i = basetbl[i2][0]; # bug in original had it not finding nearest
            if base==game.quadrant or base==game.battle or not welcoming(base):
                continue
            # if there is a commander, and no other base is appropriate,
            # we will take the one with the commander
            for cmdr in game.state.kcmdr:
                if base == cmdr and ifindit != 2:
                    ifindit = 2
                    iwhichb = i
                    break
            else:       # no commander -- use this one 
                ifindit = 1
                iwhichb = i
                break
        if ifindit==0:
            return # Nothing suitable -- wait until next time
        ibq = game.state.baseq[iwhichb]
        # decide how to move toward base 
        idelta = ibq - game.state.kscmdr
    # Maximum movement is 1 quadrant in either or both axes 
    idelta = idelta.sgn()
    # try moving in both x and y directions
    # there was what looked like a bug in the Almy C code here,
    # but it might be this translation is just wrong.
    iq = game.state.kscmdr + idelta
    if not movescom(iq, avoid):
        # failed -- try some other maneuvers 
        if idelta.i==0 or idelta.j==0:
            # attempt angle move 
            if idelta.i != 0:
                iq.j = game.state.kscmdr.j + 1
                if not movescom(iq, avoid):
                    iq.j = game.state.kscmdr.j - 1
                    movescom(iq, avoid)
            elif idelta.j != 0:
                iq.i = game.state.kscmdr.i + 1
                if not movescom(iq, avoid):
                    iq.i = game.state.kscmdr.i - 1
                    movescom(iq, avoid)
        else:
            # try moving just in x or y 
            iq.j = game.state.kscmdr.j
            if not movescom(iq, avoid):
                iq.j = game.state.kscmdr.j + idelta.j
                iq.i = game.state.kscmdr.i
                movescom(iq, avoid)
    # check for a base 
    if len(game.state.baseq) == 0:
        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") \
                      % game.state.kscmdr)
                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 ja() == False:
                    return
                game.resting = False
                game.optime = 0.0; # actually finished 
                return
    # Check for intelligence report 
    if not idebug and \
        (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)
    return

def movetholian():
    "Move the Tholian."
    if not game.tholian or game.justin:
        return
    id = coord()
    if game.tholian.kloc.i == 0 and game.tholian.kloc.j == 0:
        id.i = 0; id.j = QUADSIZE-1
    elif game.tholian.kloc.i == 0 and game.tholian.kloc.j == QUADSIZE-1:
        id.i = QUADSIZE-1; id.j = QUADSIZE-1
    elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == QUADSIZE-1:
        id.i = QUADSIZE-1; id.j = 0
    elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == 0:
        id.i = 0; id.j = 0
    else:
        # something is wrong! 
        game.tholian.move(None)
        prout("***Internal error: Tholian in a bad spot.")
        return
    # do nothing if we are blocked 
    if game.quad[id.i][id.j] not in (IHDOT, IHWEB):
        return
    here = copy.copy(game.tholian.kloc)
    delta = (id - game.tholian.kloc).sgn()
    # move in x axis 
    while here.i != id.i:
        here.i += delta.i
        if game.quad[here.i][here.j]==IHDOT:
            game.tholian.move(here)
    # move in y axis 
    while here.j != id.j:
        here.j += delta.j
        if game.quad[here.i][here.j]==IHDOT:
            game.tholian.move(here)
    # check to see if all holes plugged 
    for i in range(QUADSIZE):
        if game.quad[0][i]!=IHWEB and game.quad[0][i]!=IHT:
            return
        if game.quad[QUADSIZE-1][i]!=IHWEB and game.quad[QUADSIZE-1][i]!=IHT:
            return
        if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT:
            return
        if game.quad[i][QUADSIZE-1]!=IHWEB and game.quad[i][QUADSIZE-1]!=IHT:
            return
    # All plugged up -- Tholian splits 
    game.quad[game.tholian.kloc.i][game.tholian.kloc.j]=IHWEB
    dropin(IHBLANK)
    prout(crmena(True, IHT, "sector", game.tholian) + _(" completes web."))
    game.tholian.move(None)
    return

# Code from battle.c begins here

def doshield(shraise):
    "Change shield status."
    action = "NONE"
    game.ididit = False
    if shraise:
        action = "SHUP"
    else:
        key = scanner.next()
        if key == "IHALPHA":
            if scanner.sees("transfer"):
                action = "NRG"
            else:
                if damaged(DSHIELD):
                    prout(_("Shields damaged and down."))
                    return
                if scanner.sees("up"):
                    action = "SHUP"
                elif scanner.sees("down"):
                    action = "SHDN"
        if action=="NONE":
            proutn(_("Do you wish to change shield energy? "))
            if ja() == True:
                proutn(_("Energy to transfer to shields- "))
                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() == True:
                    action = "SHDN"
                else:
                    scanner.chew()
                    return
            else:
                proutn(_("Shields are down. Do you want them up? "))
                if ja() == True:
                    action = "SHUP"
                else:
                    scanner.chew()
                    return    
    if action == "SHUP": # raise shields 
        if game.shldup:
            prout(_("Shields already up."))
            return
        game.shldup = True
        game.shldchg = True
        if game.condition != "docked":
            game.energy -= 50.0
        prout(_("Shields raised."))
        if game.energy <= 0:
            skip(1)
            prout(_("Shields raising uses up last of energy."))
            finish(FNRG)
            return
        game.ididit=True
        return
    elif action == "SHDN":
        if not game.shldup:
            prout(_("Shields already down."))
            return
        game.shldup=False
        game.shldchg=True
        prout(_("Shields lowered."))
        game.ididit = True
        return
    elif action == "NRG":
        while scanner.next() != "IHREAL":
            scanner.chew()
            proutn(_("Energy to transfer to shields- "))
        scanner.chew()
        if scanner.real == 0:
            return
        if scanner.real > game.energy:
            prout(_("Insufficient ship energy."))
            return
        game.ididit = True
        if game.shield+scanner.real >= game.inshld:
            prout(_("Shield energy maximized."))
            if game.shield+scanner.real > game.inshld:
                prout(_("Excess energy requested returned to ship energy"))
            game.energy -= game.inshld-game.shield
            game.shield = game.inshld
            return
        if scanner.real < 0.0 and game.energy-scanner.real > 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+scanner.real < 0:
            prout(_("All shield energy transferred to ship."))
            game.energy += game.shield
            game.shield = 0.0
            return
        proutn(_("Scotty- \""))
        if scanner.real > 0:
            prout(_("Transferring energy to shields.\""))
        else:
            prout(_("Draining energy from shields.\""))
        game.shield += scanner.real
        game.energy -= scanner.real
        return

def randdevice():
    "Choose a device to damage, at random."
    # Quoth Eric Allman in the code of BSD-Trek:
    # "Under certain conditions you can get a critical hit.  This
    # sort of hit damages devices.  The probability that a given
    # device is damaged depends on the device.  Well protected
    # devices (such as the computer, which is in the core of the
    # ship and has considerable redundancy) almost never get
    # damaged, whereas devices which are exposed (such as the
    # warp engines) or which are particularly delicate (such as
    # the transporter) have a much higher probability of being
    # damaged."
    # 
    # This is one place where OPTION_PLAIN does not restore the
    # original behavior, which was equiprobable damage across
    # all devices.  If we wanted that, we'd return randrange(NDEVICES)
    # and have done with it.  Also, in the original game, DNAVYS
    # and DCOMPTR were the same device. 
    # 
    # Instead, we use a table of weights similar to the one from BSD Trek.
    # BSD doesn't have the shuttle, shield controller, death ray, or probes. 
    # We don't have a cloaking device.  The shuttle got the allocation
    # for the cloaking device, then we shaved a half-percent off
    # everything to have some weight to give DSHCTRL/DDRAY/DDSP.
    weights = (
        105,    # DSRSENS: short range scanners 10.5% 
        105,    # DLRSENS: long range scanners          10.5% 
        120,    # DPHASER: phasers                      12.0% 
        120,    # DPHOTON: photon torpedoes             12.0% 
        25,     # DLIFSUP: life support          2.5% 
        65,     # DWARPEN: warp drive                    6.5% 
        70,     # DIMPULS: impulse engines               6.5% 
        145,    # DSHIELD: deflector shields            14.5% 
        30,     # DRADIO:  subspace radio                3.0% 
        45,     # DSHUTTL: shuttle                       4.5% 
        15,     # DCOMPTR: computer                      1.5% 
        20,     # NAVCOMP: navigation system             2.0% 
        75,     # DTRANSP: transporter                   7.5% 
        20,     # DSHCTRL: high-speed shield controller 2.0% 
        10,     # DDRAY: death ray                       1.0% 
        30,     # DDSP: deep-space probes                3.0% 
    )
    idx = randrange(1000)       # weights must sum to 1000 
    sum = 0
    for (i, w) in enumerate(weights):
        sum += w
        if idx < sum:
            return i
    return None;        # we should never get here

def collision(rammed, enemy):
    "Collision handling fot rammong events."
    prouts(_("***RED ALERT!  RED ALERT!"))
    skip(1)
    prout(_("***COLLISION IMMINENT."))
    skip(2)
    proutn("***")
    proutn(crmshp())
    hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0)
    if rammed:
        proutn(_(" rammed by "))
    else:
        proutn(_(" rams "))
    proutn(crmena(False, enemy.type, "sector", enemy.kloc))
    if rammed:
        proutn(_(" (original position)"))
    skip(1)
    deadkl(enemy.kloc, enemy.type, game.sector)
    proutn("***" + crmship() + " heavily damaged.")
    icas = randrange(10, 30)
    prout(_("***Sickbay reports %d casualties"), icas)
    game.casual += icas
    game.state.crew -= icas
    # In the pre-SST2K version, all devices got equiprobably damaged,
    # which was silly.  Instead, pick up to half the devices at
    # random according to our weighting table,
    ncrits = randrange(NDEVICES/2)
    for m in range(ncrits):
        dev = randdevice()
        if game.damage[dev] < 0:
            continue
        extradm = (10.0*hardness*randreal()+1.0)*game.damfac
        # Damage for at least time of travel! 
        game.damage[dev] += game.optime + extradm
    game.shldup = False
    prout(_("***Shields are down."))
    if game.state.remkl + len(game.state.kcmdr) + game.state.nscrem:
        announce()
        damagereport()
    else:
        finish(FWON)
    return

def torpedo(origin, bearing, dispersion, number, nburst):
    "Let a photon torpedo fly" 
    if not damaged(DSRSENS) or game.condition=="docked":
        setwnd(srscan_window)
    else: 
        setwnd(message_window)
    ac = bearing + 0.25*dispersion      # dispersion is a random variable
    bullseye = (15.0 - bearing)*0.5235988
    track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin)) 
    bumpto = coord(0, 0)
    # Loop to move a single torpedo 
    setwnd(message_window)
    for step in range(1, QUADSIZE*2):
        track.next()
        w = track.sector()
        if not w.valid_sector():
            break
        iquad=game.quad[w.i][w.j]
        tracktorpedo(origin, w, step, number, nburst, iquad)
        if iquad==IHDOT:
            continue
        # hit something 
        if not damaged(DSRSENS) or game.condition == "docked":
            skip(1);    # start new line after text track 
        if iquad in (IHE, IHF): # Hit our ship 
            skip(1)
            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 
            ang = track.angle + 2.5*(randreal()-0.5)
            temp = math.fabs(math.sin(ang))
            if math.fabs(math.cos(ang)) > temp:
                temp = math.fabs(math.cos(ang))
            xx = -math.sin(ang)/temp
            yy = math.cos(ang)/temp
            bumpto.i = int(w.i+xx+0.5)
            bumpto.j = int(w.j+yy+0.5)
            if not bumpto.valid_sector():
                return hit
            if game.quad[bumpto.i][bumpto.j]==IHBLANK:
                finish(FHOLE)
                return hit
            if game.quad[bumpto.i][bumpto.j]!=IHDOT:
                # can't move into object 
                return hit
            game.sector = bumpto
            proutn(crmshp())
            game.quad[w.i][w.j]=IHDOT
            game.quad[bumpto.i][bumpto.j]=iquad
            prout(_(" displaced by blast to Sector %s ") % bumpto)
            for enemy in game.enemies:
                enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
            game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
            return None
        elif iquad in (IHC, IHS, IHR, IHK): # Hit a regular enemy 
            # find the enemy 
            if iquad in (IHC, IHS) and withprob(0.05):
                prout(crmena(True, iquad, "sector", w) + _(" uses anti-photon device;"))
                prout(_("   torpedo neutralized."))
                return None
            for enemy in game.enemies:
                if w == enemy.kloc:
                    break
            kp = math.fabs(enemy.kpower)
            h1 = 700.0 + randrange(100) - \
                1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
            h1 = math.fabs(h1)
            if kp < h1:
                h1 = kp
            if enemy.kpower < 0:
                enemy.kpower -= -h1
            else:
                enemy.kpower -= h1
            if enemy.kpower == 0:
                deadkl(w, iquad, w)
                return None
            proutn(crmena(True, iquad, "sector", w))
            # If enemy damaged but not destroyed, try to displace 
            ang = track.angle + 2.5*(randreal()-0.5)
            temp = math.fabs(math.sin(ang))
            if math.fabs(math.cos(ang)) > temp:
                temp = math.fabs(math.cos(ang))
            xx = -math.sin(ang)/temp
            yy = math.cos(ang)/temp
            bumpto.i = int(w.i+xx+0.5)
            bumpto.j = int(w.j+yy+0.5)
            if not bumpto.valid_sector():
                prout(_(" damaged but not destroyed."))
                return
            if game.quad[bumpto.i][bumpto.j] == IHBLANK:
                prout(_(" buffeted into black hole."))
                deadkl(w, iquad, bumpto)
            if game.quad[bumpto.i][bumpto.j] != IHDOT:
                prout(_(" damaged but not destroyed."))
            else:
                prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
                enemy.kloc = bumpto
                game.quad[w.i][w.j]=IHDOT
                game.quad[bumpto.i][bumpto.j]=iquad
                for enemy in game.enemies:
                    enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
                game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
            return None
        elif iquad == IHB: # Hit a base 
            skip(1)
            prout(_("***STARBASE DESTROYED.."))
            game.state.baseq = filter(lambda x: x != game.quadrant, game.state.baseq)
            game.quad[w.i][w.j]=IHDOT
            game.base.invalidate()
            game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase -= 1
            game.state.chart[game.quadrant.i][game.quadrant.j].starbase -= 1
            game.state.basekl += 1
            newcnd()
            return None
        elif iquad == IHP: # Hit a planet 
            prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
            game.state.nplankl += 1
            game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
            game.iplnet.pclass = "destroyed"
            game.iplnet = None
            game.plnet.invalidate()
            game.quad[w.i][w.j] = IHDOT
            if game.landed:
                # captain perishes on planet 
                finish(FDPLANET)
            return None
        elif iquad == IHW: # Hit an inhabited world -- very bad! 
            prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
            game.state.nworldkl += 1
            game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
            game.iplnet.pclass = "destroyed"
            game.iplnet = None
            game.plnet.invalidate()
            game.quad[w.i][w.j] = IHDOT
            if game.landed:
                # captain perishes on planet 
                finish(FDPLANET)
            prout(_("You have just destroyed an inhabited planet."))
            prout(_("Celebratory rallies are being held on the Klingon homeworld."))
            return None
        elif iquad == IHSTAR: # Hit a star 
            if withprob(0.9):
                nova(w)
            else:
                prout(crmena(True, IHSTAR, "sector", w) + _(" unaffected by photon blast."))
            return None
        elif iquad == IHQUEST: # Hit a thingy 
            if not (game.options & OPTION_THINGY) or withprob(0.3):
                skip(1)
                prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
                skip(1)
                prouts(_("    HACK!     HACK!    HACK!        *CHOKE!*  "))
                skip(1)
                proutn(_("Mr. Spock-"))
                prouts(_("  \"Fascinating!\""))
                skip(1)
                deadkl(w, iquad, w)
            else:
                # Stas Sergeev added the possibility that
                # you can shove the Thingy and piss it off.
                # It then becomes an enemy and may fire at you.
                thing.angry = True
                shoved = True
            return None
        elif iquad == IHBLANK: # Black hole 
            skip(1)
            prout(crmena(True, IHBLANK, "sector", w) + _(" swallows torpedo."))
            return None
        elif iquad == IHWEB: # hit the web 
            skip(1)
            prout(_("***Torpedo absorbed by Tholian web."))
            return None
        elif iquad == IHT:  # Hit a Tholian 
            h1 = 700.0 + randrange(100) - \
                1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
            h1 = math.fabs(h1)
            if h1 >= 600:
                game.quad[w.i][w.j] = IHDOT
                deadkl(w, iquad, w)
                game.tholian = None
                return None
            skip(1)
            proutn(crmena(True, IHT, "sector", w))
            if withprob(0.05):
                prout(_(" survives photon blast."))
                return None
            prout(_(" disappears."))
            game.tholian.move(None)
            game.quad[w.i][w.j] = IHWEB
            dropin(IHBLANK)
            return None
        else: # Problem!
            skip(1)
            proutn("Don't know how to handle torpedo collision with ")
            proutn(crmena(True, iquad, "sector", w))
            skip(1)
            return None
        break
    skip(1)
    prout(_("Torpedo missed."))
    return None;

def fry(hit):
    "Critical-hit resolution." 
    if hit < (275.0-25.0*game.skill)*randreal(1.0, 1.5):
        return
    ncrit = int(1.0 + hit/(500.0+randreal(100)))
    proutn(_("***CRITICAL HIT--"))
    # Select devices and cause damage
    cdam = []
    for loop1 in range(ncrit):
        while True:
            j = randdevice()
            # Cheat to prevent shuttle damage unless on ship 
            if not (game.damage[j]<0.0 or (j==DSHUTTL and game.iscraft != "onship")):
                break
        cdam.append(j)
        extradm = (hit*game.damfac)/(ncrit*randreal(75, 100))
        game.damage[j] += extradm
    skipcount = 0
    for (i, j) in enumerate(cdam):
        proutn(device[j])
        if skipcount % 3 == 2 and i < len(cdam)-1:
            skip(1)
        skipcount += 1
        if i < len(cdam)-1:
            proutn(_(" and "))
    prout(_(" damaged."))
    if damaged(DSHIELD) and game.shldup:
        prout(_("***Shields knocked down."))
        game.shldup=False

def attack(torps_ok):
    # bad guy attacks us 
    # torps_ok == False forces use of phasers in an attack 
    # game could be over at this point, check
    if game.alldone:
        return
    attempt = False; ihurt = False;
    hitmax=0.0; hittot=0.0; chgfac=1.0
    where = "neither"
    if idebug:
        prout("=== ATTACK!")
    # Tholian gets to move before attacking 
    if game.tholian:
        movetholian()
    # if you have just entered the RNZ, you'll get a warning 
    if game.neutz: # The one chance not to be attacked 
        game.neutz = False
        return
    # commanders get a chance to tac-move towards you 
    if (((game.quadrant in game.state.kcmdr or game.state.kscmdr==game.quadrant) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok:
        moveklings()
    # if no enemies remain after movement, we're done 
    if len(game.enemies)==0 or (len(game.enemies)==1 and thing == game.quadrant and not thing.angry):
        return
    # set up partial hits if attack happens during shield status change 
    pfac = 1.0/game.inshld
    if game.shldchg:
        chgfac = 0.25 + randreal(0.5)
    skip(1)
    # message verbosity control 
    if game.skill <= SKILL_FAIR:
        where = "sector"
    for enemy in game.enemies:
        if enemy.kpower < 0:
            continue;   # too weak to attack 
        # compute hit strength and diminish shield power 
        r = randreal()
        # Increase chance of photon torpedos if docked or enemy energy is low 
        if game.condition == "docked":
            r *= 0.25
        if enemy.kpower < 500:
            r *= 0.25; 
        if enemy.type==IHT or (enemy.type==IHQUEST and not thing.angry):
            continue
        # different enemies have different probabilities of throwing a torp 
        usephasers = not torps_ok or \
            (enemy.type == IHK and r > 0.0005) or \
            (enemy.type==IHC and r > 0.015) or \
            (enemy.type==IHR and r > 0.3) or \
            (enemy.type==IHS and r > 0.07) or \
            (enemy.type==IHQUEST and r > 0.05)
        if usephasers:      # Enemy uses phasers 
            if game.condition == "docked":
                continue; # Don't waste the effort! 
            attempt = True; # Attempt to attack 
            dustfac = randreal(0.8, 0.85)
            hit = enemy.kpower*math.pow(dustfac,enemy.kavgd)
            enemy.kpower *= 0.75
        else: # Enemy uses photon torpedo 
            # We should be able to make the bearing() method work here
            course = 1.90985*math.atan2(game.sector.j-enemy.kloc.j, enemy.kloc.i-game.sector.i)
            hit = 0
            proutn(_("***TORPEDO INCOMING"))
            if not damaged(DSRSENS):
                proutn(_(" From ") + crmena(False, enemy.type, where, enemy.kloc))
            attempt = True
            prout("  ")
            dispersion = (randreal()+randreal())*0.5 - 0.5
            dispersion += 0.002*enemy.kpower*dispersion
            hit = torpedo(enemy.kloc, course, dispersion, number=1, nburst=1)
            if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
                finish(FWON); # Klingons did themselves in! 
            if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone:
                return # Supernova or finished 
            if hit == None:
                continue
        # incoming phaser or torpedo, shields may dissipate it 
        if game.shldup or game.shldchg or game.condition=="docked":
            # shields will take hits 
            propor = pfac * game.shield
            if game.condition =="docked":
                propr *= 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.kloc))
        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
    if not attempt and game.condition == "docked":
        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 "))
    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, "))
    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
    # After attack, reset average distance to enemies 
    for enemy in game.enemies:
        enemy.kavgd = enemy.kdist
    game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
    return
                
def deadkl(w, type, mv):
    "Kill a Klingon, Tholian, Romulan, or Thingy." 
    # Added mv to allow enemy to "move" before dying 
    proutn(crmena(True, type, "sector", mv))
    # Decide what kind of enemy it is and update appropriately 
    if type == IHR:
        # Chalk up a Romulan 
        game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans -= 1
        game.irhere -= 1
        game.state.nromrem -= 1
    elif type == IHT:
        # Killed a Tholian 
        game.tholian = None
    elif type == IHQUEST:
        # Killed a Thingy
        global thing
        thing = None
    else:
        # Killed some type of Klingon 
        game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
        game.klhere -= 1
        if type == IHC:
            game.state.kcmdr.remove(game.quadrant)
            unschedule(FTBEAM)
            if game.state.kcmdr:
                schedule(FTBEAM, expran(1.0*game.incom/len(game.state.kcmdr)))
            if is_scheduled(FCDBAS) and game.battle == game.quadrant:
                unschedule(FCDBAS)    
        elif type ==  IHK:
            game.state.remkl -= 1
        elif type ==  IHS:
            game.state.nscrem -= 1
            game.state.kscmdr.invalidate()
            game.isatb = 0
            game.iscate = False
            unschedule(FSCMOVE)
            unschedule(FSCDBAS)
    # For each kind of enemy, finish message to player 
    prout(_(" destroyed."))
    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
        return
    game.recompute()
    # Remove enemy ship from arrays describing local conditions
    for e in game.enemies:
        if e.kloc == w:
            e.move(None)
            break
    return

def targetcheck(w):
    "Return None if target is invalid, otherwise return a course angle."
    if not w.valid_sector():
        huh()
        return None
    delta = coord()
    # FIXME: C code this was translated from is wacky -- why the sign reversal?
    delta.j = (w.j - game.sector.j);
    delta.i = (game.sector.i - w.i);
    if delta == coord(0, 0):
        skip(1)
        prout(_("Spock-  \"Bridge to sickbay.  Dr. McCoy,"))
        prout(_("  I recommend an immediate review of"))
        prout(_("  the Captain's psychological profile.\""))
        scanner.chew()
        return None
    return delta.bearing()

def photon():
    "Launch photon torpedo."
    course = []
    game.ididit = False
    if damaged(DPHOTON):
        prout(_("Photon tubes damaged."))
        scanner.chew()
        return
    if game.torps == 0:
        prout(_("No torpedoes left."))
        scanner.chew()
        return
    # First, get torpedo count
    while True:
        scanner.next()
        if scanner.token == "IHALPHA":
            huh()
            return
        elif scanner.token == "IHEOL" or not scanner.waiting():
            prout(_("%d torpedoes left.") % game.torps)
            scanner.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
            if n > game.torps:
                scanner.chew()  # User requested more torps than available
                continue        # Go back around
            break       # All is good, go to next stage
    # Next, get targets
    target = []
    for i in range(n):
        key = scanner.next()
        if i==0 and key == "IHEOL":
            break;      # no coordinate waiting, we will try prompting 
        if i==1 and key == "IHEOL":
            # direct all torpedoes at one target 
            while i < n:
                target.append(target[0])
                course.append(course[0])
                i += 1
            break
        scanner.push(scanner.token)
        target.append(scanner.getcoord())
        if target[-1] == None:
            return
        course.append(targetcheck(target[-1]))
        if course[-1] == None:
            return
    scanner.chew()
    if len(target) == 0:
        # prompt for each one 
        for i in range(n):
            proutn(_("Target sector for torpedo number %d- ") % (i+1))
            scanner.chew()
            target.append(scanner.getcoord())
            if target[-1] == None:
                return
            course.append(targetcheck(target[-1]))
            if course[-1] == None:
                return
    game.ididit = True
    # Loop for moving <n> torpedoes 
    for i in range(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, course[i], dispersion, number=i, nburst=n)
        if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
            return
    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
        finish(FWON);

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)

def checkshctrl(rpow):
    "Check shield control."
    skip(1)
    if withprob(0.998):
        prout(_("Shields lowered."))
        return False
    # Something bad has happened 
    prouts(_("***RED ALERT!  RED ALERT!"))
    skip(2)
    hit = rpow*game.shield/game.inshld
    game.energy -= rpow+hit*0.8
    game.shield -= hit*0.2
    if game.energy <= 0.0:
        prouts(_("Sulu-  \"Captain! Shield malf***********************\""))
        skip(1)
        stars()
        finish(FPHASER)
        return True
    prouts(_("Sulu-  \"Captain! Shield malfunction! Phaser fire contained!\""))
    skip(2)
    prout(_("Lt. Uhura-  \"Sir, all decks reporting damage.\""))
    icas = randrange(int(hit*0.012))
    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(_("Phaser energy dispersed by shields."))
    prout(_("Enemy unaffected."))
    overheat(rpow)
    return True;

def hittem(hits):
    "Register a phaser hit on Klingons and Romulans."
    nenhr2 = len(game.enemies); kk=0
    w = coord()
    skip(1)
    for (k, wham) in enumerate(hits):
        if wham==0:
            continue
        dustfac = randreal(0.9, 1.0)
        hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
        kpini = game.enemies[kk].kpower
        kp = math.fabs(kpini)
        if PHASEFAC*hit < kp:
            kp = PHASEFAC*hit
        if game.enemies[kk].kpower < 0:
            game.enemies[kk].kpower -= -kp
        else:
            game.enemies[kk].kpower -= kp
        kpow = game.enemies[kk].kpower
        w = game.enemies[kk].kloc
        if hit > 0.005:
            if not damaged(DSRSENS):
                boom(w)
            proutn(_("%d unit hit on ") % int(hit))
        else:
            proutn(_("Very small hit on "))
        ienm = game.quad[w.i][w.j]
        if ienm==IHQUEST:
            thing.angry = True
        proutn(crmena(False, ienm, "sector", w))
        skip(1)
        if kpow == 0:
            deadkl(w, ienm, w)
            if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
                finish(FWON);           
            if game.alldone:
                return
            kk -= 1     # don't do the increment
            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].kpower = -kpow
        kk += 1
    return

def phasers():
    "Fire phasers at bad guys."
    hits = []
    kz = 0; k = 1; irec=0 # Cheating inhibitor 
    ifast = False; no = False; itarg = True; msgflag = True; rpow=0
    automode = "NOTSET"
    key=0
    skip(1)
    # SR sensors and Computer are needed for automode 
    if damaged(DSRSENS) or damaged(DCOMPTR):
        itarg = False
    if game.condition == "docked":
        prout(_("Phasers can't be fired through base shields."))
        scanner.chew()
        return
    if damaged(DPHASER):
        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
    # Original code so convoluted, I re-did it all
    # (That was Tom Almy talking about the C code, I think -- ESR)
    while automode=="NOTSET":
        key=scanner.next()
        if key == "IHALPHA":
            if scanner.sees("manual"):
                if len(game.enemies)==0:
                    prout(_("There is no enemy present to select."))
                    scanner.chew()
                    key = "IHEOL"
                    automode="AUTOMATIC"
                else:
                    automode = "MANUAL"
                    key = scanner.next()
            elif scanner.sees("automatic"):
                if (not itarg) and len(game.enemies) != 0:
                    automode = "FORCEMAN"
                else:
                    if len(game.enemies)==0:
                        prout(_("Energy will be expended into space."))
                    automode = "AUTOMATIC"
                    key = scanner.next()
            elif scanner.sees("no"):
                no = True
            else:
                huh()
                return
        elif key == "IHREAL":
            if len(game.enemies)==0:
                prout(_("Energy will be expended into space."))
                automode = "AUTOMATIC"
            elif not itarg:
                automode = "FORCEMAN"
            else:
                automode = "AUTOMATIC"
        else:
            # "IHEOL" 
            if len(game.enemies)==0:
                prout(_("Energy will be expended into space."))
                automode = "AUTOMATIC"
            elif not itarg:
                automode = "FORCEMAN"
            else: 
                proutn(_("Manual or automatic? "))
                scanner.chew()
    avail = game.energy
    if ifast:
        avail -= 200.0
    if automode == "AUTOMATIC":
        if key == "IHALPHA" and scanner.sees("no"):
            no = True
            key = scanner.next()
        if key != "IHREAL" and len(game.enemies) != 0:
            prout(_("Phasers locked on target. Energy available: %.2f")%avail)
        irec=0
        while True:
            scanner.chew()
            if not kz:
                for i in range(len(game.enemies)):
                    irec += math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
            kz=1
            proutn(_("%d units required. ") % irec)
            scanner.chew()
            proutn(_("Units to fire= "))
            key = scanner.next()
            if key!="IHREAL":
                return
            rpow = scanner.real
            if rpow > avail:
                proutn(_("Energy available= %.2f") % avail)
                skip(1)
                key = "IHEOL"
            if not rpow > avail:
                break
        if rpow<=0:
            # chicken out 
            scanner.chew()
            return
        key=scanner.next()
        if key == "IHALPHA" and scanner.sees("no"):
            no = True
        if ifast:
            game.energy -= 200; # Go and do it! 
            if checkshctrl(rpow):
                return
        scanner.chew()
        game.energy -= rpow
        extra = rpow
        if len(game.enemies):
            extra = 0.0
            powrem = rpow
            for i in range(len(game.enemies)):
                hits.append(0.0)
                if powrem <= 0:
                    continue
                hits[i] = math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
                over = randreal(1.01, 1.06) * hits[i]
                temp = powrem
                powrem -= hits[i] + over
                if powrem <= 0 and temp < hits[i]:
                    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)
    elif automode == "MANUAL":
        rpow = 0.0
        for k in range(len(game.enemies)):
            aim = game.enemies[k].kloc
            ienm = game.quad[aim.i][aim.j]
            if msgflag:
                proutn(_("Energy available= %.2f") % (avail-0.006))
                skip(1)
                msgflag = False
                rpow = 0.0
            if damaged(DSRSENS) and \
               not game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS):
                prout(cramen(ienm) + _(" can't be located without short range scan."))
                scanner.chew()
                key = "IHEOL"
                hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko 
                k += 1
                continue
            if key == "IHEOL":
                scanner.chew()
                if itarg and k > kz:
                    irec=(abs(game.enemies[k].kpower)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) * randreal(1.01, 1.06) + 1.0
                kz = k
                proutn("(")
                if not damaged(DCOMPTR):
                    proutn("%d" % irec)
                else:
                    proutn("??")
                proutn(")  ")
                proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))                
                key = scanner.next()
            if key == "IHALPHA" and scanner.sees("no"):
                no = True
                key = scanner.next()
                continue
            if key == "IHALPHA":
                huh()
                return
            if key == "IHEOL":
                if k==1: # Let me say I'm baffled by this 
                    msgflag = True
                continue
            if scanner.real < 0:
                # abort out 
                scanner.chew()
                return
            hits[k] = scanner.real
            rpow += scanner.real
            # If total requested is too much, inform and start over 
            if rpow > avail:
                prout(_("Available energy exceeded -- try again."))
                scanner.chew()
                return
            key = scanner.next(); # scan for next value 
            k += 1
        if rpow == 0.0:
            # zero energy -- abort 
            scanner.chew()
            return
        if key == "IHALPHA" and scanner.sees("no"):
            no = True
        game.energy -= rpow
        scanner.chew()
        if ifast:
            game.energy -= 200.0
            if checkshctrl(rpow):
                return
        hittem(hits)
        game.ididit = True
     # Say shield raised or malfunction, if necessary 
    if game.alldone:
        return
    if ifast:
        skip(1)
        if no == 0:
            if withprob(0.01):
                prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
                prouts(_("         CLICK   CLICK   POP  . . ."))
                prout(_(" No response, sir!"))
                game.shldup = False
            else:
                prout(_("Shields raised."))
        else:
            game.shldup = False
    overheat(rpow);

# Code from events,c begins here.

# This isn't a real event queue a la BSD Trek yet -- you can only have one 
# event of each type active at any given time.  Mostly these means we can 
# only have one FDISTR/FENSLV/FREPRO sequence going at any given time
# BSD Trek, from which we swiped the idea, can have up to 5.

def unschedule(evtype):
    "Remove an event from the schedule."
    game.future[evtype].date = FOREVER
    return game.future[evtype]

def is_scheduled(evtype):
    "Is an event of specified type scheduled."
    return game.future[evtype].date != FOREVER

def scheduled(evtype):
    "When will this event happen?"
    return game.future[evtype].date

def schedule(evtype, offset):
    "Schedule an event of specified type."
    game.future[evtype].date = game.state.date + offset
    return game.future[evtype]

def postpone(evtype, offset):
    "Postpone a scheduled event."
    game.future[evtype].date += 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() == True:
            game.resting = False
            game.optime = 0.0
            return True
    return False

def events():
    "Run through the event queue looking for things to do."
    i=0
    fintim = game.state.date + game.optime; yank=0
    ictbeam = False; istract = False
    w = coord(); hold = coord()
    ev = event(); ev2 = event()

    def tractorbeam(yank):
        "Tractor-beaming cases merge here." 
        announce()
        game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5) 
        skip(1)
        prout("***" + crmshp() + _(" caught in long range tractor beam--"))
        # If Kirk & Co. screwing around on planet, handle 
        atover(True) # atover(true) is Grab 
        if game.alldone:
            return
        if game.icraft: # Caught in Galileo? 
            finish(FSTRACTOR)
            return
        # Check to see if shuttle is aboard 
        if game.iscraft == "offship":
            skip(1)
            if withprob(0.5):
                prout(_("Galileo, left on the planet surface, is captured"))
                prout(_("by aliens and made into a flying McDonald's."))
                game.damage[DSHUTTL] = -10
                game.iscraft = "removed"
            else:
                prout(_("Galileo, left on the planet surface, is well hidden."))
        if evcode == FSPY:
            game.quadrant = game.state.kscmdr
        else:
            game.quadrant = game.state.kcmdr[i]
        game.sector = randplace(QUADSIZE)
        prout(crmshp() + _(" is pulled to Quadrant %s, Sector %s") \
               % (game.quadrant, game.sector))
        if game.resting:
            prout(_("(Remainder of rest/repair period cancelled.)"))
            game.resting = False
        if not game.shldup:
            if not damaged(DSHIELD) and game.shield > 0:
                doshield(shraise=True) # raise shields 
                game.shldchg = False
            else:
                prout(_("(Shields not currently useable.)"))
        newqad()
        # Adjust finish time to time of tractor beaming 
        fintim = game.state.date+game.optime
        attack(torps_ok=False)
        if not game.state.kcmdr:
            unschedule(FTBEAM)
        else: 
            schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr)))

    def destroybase():
        "Code merges here for any commander destroying a starbase." 
        # Not perfect, but will have to do 
        # Handle case where base is in same quadrant as starship 
        if game.battle == game.quadrant:
            game.state.chart[game.battle.i][game.battle.j].starbase = False
            game.quad[game.base.i][game.base.j] = IHDOT
            game.base.invalidate()
            newcnd()
            skip(1)
            prout(_("Spock-  \"Captain, I believe the starbase has been destroyed.\""))
        elif game.state.baseq and communicating():
            # Get word via subspace radio 
            announce()
            skip(1)
            prout(_("Lt. Uhura-  \"Captain, Starfleet Command reports that"))
            proutn(_("   the starbase in Quadrant %s has been destroyed by") % game.battle)
            if game.isatb == 2: 
                prout(_("the Klingon Super-Commander"))
            else:
                prout(_("a Klingon Commander"))
            game.state.chart[game.battle.i][game.battle.j].starbase = False
        # Remove Starbase from galaxy 
        game.state.galaxy[game.battle.i][game.battle.j].starbase = False
        game.state.baseq = filter(lambda x: x != game.battle, game.state.baseq)
        if game.isatb == 2:
            # reinstate a commander's base attack 
            game.battle = hold
            game.isatb = 0
        else:
            game.battle.invalidate()
    if 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")
    radio_was_broken = damaged(DRADIO)
    hold.i = hold.j = 0
    while True:
        # Select earliest extraneous event, evcode==0 if no events 
        evcode = FSPY
        if game.alldone:
            return
        datemin = fintim
        for l in range(1, NEVENTS):
            if game.future[l].date < datemin:
                evcode = l
                if 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 /= game.docfac
        # Don't fix Deathray here 
        for l in range(NDEVICES):
            if game.damage[l] > 0.0 and l != DDRAY:
                if game.damage[l]-repair > 0.0:
                    game.damage[l] -= repair
                else:
                    game.damage[l] = 0.0
        # If radio repaired, update star chart and attack reports 
        if radio_was_broken and not damaged(DRADIO):
            prout(_("Lt. Uhura- \"Captain, the sub-space radio is working and"))
            prout(_("   surveillance reports are coming in."))
            skip(1)
            if not game.iseenit:
                attackreport(False)
                game.iseenit = True
            rechart()
            prout(_("   The star chart is now up to date.\""))
            skip(1)
        # Cause extraneous event EVCODE to occur 
        game.optime -= xtime
        if evcode == FSNOVA: # Supernova 
            announce()
            supernova(None)
            schedule(FSNOVA, expran(0.5*game.intime))
            if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
                return
        elif evcode == FSPY: # Check with spy to see if SC should tractor beam 
            if game.state.nscrem == 0 or \
                ictbeam or istract or \
                game.condition=="docked" or game.isatb==1 or game.iscate:
                return
            if game.ientesc or \
                (game.energy<2000 and game.torps<4 and game.shield < 1250) or \
                (damaged(DPHASER) and (damaged(DPHOTON) or game.torps<4)) or \
                (damaged(DSHIELD) and \
                 (game.energy < 2500 or damaged(DPHASER)) and \
                 (game.torps < 5 or damaged(DPHOTON))):
                # Tractor-beam her! 
                istract = ictbeam = True
                tractorbeam((game.state.kscmdr-game.quadrant).distance())
            else:
                return
        elif evcode == FTBEAM: # Tractor beam 
            if not game.state.kcmdr:
                unschedule(FTBEAM)
                continue
            i = randrange(len(game.state.kcmdr))
            yank = (game.state.kcmdr[i]-game.quadrant).distance()
            if istract or game.condition == "docked" or yank == 0:
                # Drats! Have to reschedule 
                schedule(FTBEAM, 
                         game.optime + expran(1.5*game.intime/len(game.state.kcmdr)))
                continue
            ictbeam = True
            tractorbeam(yank)
        elif evcode == FSNAP: # Snapshot of the universe (for time warp) 
            game.snapsht = copy.deepcopy(game.state)
            game.state.snap = True
            schedule(FSNAP, expran(0.5 * game.intime))
        elif evcode == FBATTAK: # Commander attacks starbase 
            if not game.state.kcmdr or not game.state.baseq:
                # no can do 
                unschedule(FBATTAK)
                unschedule(FCDBAS)
                continue
            try:
                for ibq in game.state.baseq:
                   for cmdr in game.state.kcmdr: 
                       if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
                           raise ibq
                else:
                    # no match found -- try later 
                    schedule(FBATTAK, expran(0.3*game.intime))
                    unschedule(FCDBAS)
                    continue
            except coord:
                pass
            # commander + starbase combination found -- launch attack 
            game.battle = 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():
                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)
                if not game.state.baseq() \
                       or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
                    game.battle.invalidate()
                    continue
                # find the lucky pair 
                for cmdr in game.state.kcmdr:
                    if cmdr == game.battle: 
                        break
                else:
                    # No action to take after all 
                    continue
            destroybase()
        elif evcode == FSCMOVE: # Supercommander moves 
            schedule(FSCMOVE, 0.2777)
            if not game.ientesc and not istract and game.isatb != 1 and \
                   (not game.iscate or not game.justin): 
                supercommander()
        elif evcode == FDSPROB: # Move deep space probe 
            schedule(FDSPROB, 0.01)
            if game.probe.next(grain=QUADSIZE):
                if not game.probe.quadrant().valid_quadrant() or \
                    game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova:
                    # Left galaxy or ran into supernova
                    if communicating():
                        announce()
                        skip(1)
                        proutn(_("Lt. Uhura-  \"The deep space probe "))
                        if not game.probe.quadrant().valid_quadrant():
                            prout(_("has left the galaxy.\""))
                        else:
                            prout(_("is no longer transmitting.\""))
                    unschedule(FDSPROB)
                    continue
                if communicating():
                    #announce()
                    skip(1)
                    prout(_("Lt. Uhura-  \"The deep space probe is now in Quadrant %s.\"") % game.probe.quadrant())
            pdest = game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j]
            if communicating():
                chp = game.state.chart[game.probe.quadrant().i][game.probe.quadrant().j]
                chp.klingons = pdest.klingons
                chp.starbase = pdest.starbase
                chp.stars = pdest.stars
                pdest.charted = True
            game.probe.moves -= 1 # One less to travel
            if game.probe.moves == 0 and game.isarmed and pdest.stars:
                supernova(game.probe)           # fire in the hole!
                unschedule(FDSPROB)
                if game.state.galaxy[game.quadrant().i][game.quadrant().j].supernova: 
                    return
        elif evcode == FDISTR: # inhabited system issues distress call 
            unschedule(FDISTR)
            # try a whole bunch of times to find something suitable 
            for i in range(100):
                # need a quadrant which is not the current one,
                # which has some stars which are inhabited and
                # not already under attack, which is not
                # supernova'ed, and which has some Klingons in it
                w = randplace(GALSIZE)
                q = game.state.galaxy[w.i][w.j]
                if not (game.quadrant == w or q.planet == None or \
                      not q.planet.inhabited or \
                      q.supernova or q.status!="secure" or q.klingons<=0):
                    break
            else:
                # can't seem to find one; ignore this call 
                if idebug:
                    prout("=== Couldn't find location for distress event.")
                continue
            # got one!!  Schedule its enslavement 
            ev = schedule(FENSLV, expran(game.intime))
            ev.quadrant = w
            q.status = "distressed"
            # tell the captain about it if we can 
            if communicating():
                prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \
                        % (q.planet, `w`))
                prout(_("by a Klingon invasion fleet."))
                if cancelrest():
                    return
        elif evcode == FENSLV:          # starsystem is enslaved 
            ev = unschedule(FENSLV)
            # see if current distress call still active 
            q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
            if q.klingons <= 0:
                q.status = "secure"
                continue
            q.status = "enslaved"

            # play stork and schedule the first baby 
            ev2 = schedule(FREPRO, expran(2.0 * game.intime))
            ev2.quadrant = ev.quadrant

            # report the disaster if we can 
            if communicating():
                prout(_("Uhura- We've lost contact with starsystem %s") % \
                        q.planet)
                prout(_("in Quadrant %s.\n") % ev.quadrant)
        elif evcode == FREPRO:          # Klingon reproduces 
            # If we ever switch to a real event queue, we'll need to
            # explicitly retrieve and restore the x and y.
            ev = schedule(FREPRO, expran(1.0 * game.intime))
            # see if current distress call still active 
            q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
            if q.klingons <= 0:
                q.status = "secure"
                continue
            if game.state.remkl >=MAXKLGAME:
                continue                # full right now 
            # reproduce one Klingon 
            w = ev.quadrant
            m = coord()
            if game.klhere >= MAXKLQUAD:
                try:
                    # this quadrant not ok, pick an adjacent one 
                    for m.i in range(w.i - 1, w.i + 2):
                        for m.j in range(w.j - 1, w.j + 2):
                            if not m.valid_quadrant():
                                continue
                            q = game.state.galaxy[m.i][m.j]
                            # check for this quad ok (not full & no snova) 
                            if q.klingons >= MAXKLQUAD or q.supernova:
                                continue
                            raise "FOUNDIT"
                    else:
                        continue        # search for eligible quadrant failed
                except "FOUNDIT":
                    w = m
            # deliver the child 
            game.state.remkl += 1
            q.klingons += 1
            if game.quadrant == w:
                game.klhere += 1
                game.enemies.append(newkling())
            # recompute time left
            game.recompute()
            if communicating():
                if game.quadrant == w:
                    prout(_("Spock- sensors indicate the Klingons have"))
                    prout(_("launched a warship from %s.") % q.planet)
                else:
                    prout(_("Uhura- Starfleet reports increased Klingon activity"))
                    if q.planet != None:
                        proutn(_("near %s") % q.planet)
                    prout(_("in Quadrant %s.") % w)
                                
def wait():
    "Wait on events."
    game.ididit = False
    while True:
        key = scanner.next()
        if key  != "IHEOL":
            break
        proutn(_("How long? "))
    scanner.chew()
    if key != "IHREAL":
        huh()
        return
    origTime = delay = scanner.real
    if delay <= 0.0:
        return
    if delay >= game.state.remtime or len(game.enemies) != 0:
        proutn(_("Are you sure? "))
        if ja() == False:
            return
    # Alternate resting periods (events) with attacks 
    game.resting = True
    while True:
        if delay <= 0:
            game.resting = False
        if not game.resting:
            prout(_("%d stardates left.") % int(game.state.remtime))
            return
        temp = game.optime = delay
        if len(game.enemies):
            rtime = randreal(1.0, 2.0)
            if rtime < temp:
                temp = rtime
            game.optime = temp
        if game.optime < delay:
            attack(torps_ok=False)
        if game.alldone:
            return
        events()
        game.ididit = True
        if game.alldone:
            return
        delay -= temp
        # Repair Deathray if long rest at starbase 
        if origTime-delay >= 9.99 and game.condition == "docked":
            game.damage[DDRAY] = 0.0
        # leave if quadrant supernovas
        if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
            break
    game.resting = False
    game.optime = 0

def nova(nov):
    "Star goes nova." 
    course = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
    newc = coord(); neighbor = coord(); bump = coord(0, 0)
    if withprob(0.05):
        # Wow! We've supernova'ed 
        supernova(game.quadrant)
        return
    # handle initial nova 
    game.quad[nov.i][nov.j] = IHDOT
    prout(crmena(False, IHSTAR, "sector", nov) + _(" novas."))
    game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
    game.state.starkl += 1
    # Set up queue to recursively trigger adjacent stars 
    hits = [nov]
    kount = 0
    while hits:
        offset = coord()
        start = hits.pop()
        for offset.i in range(-1, 1+1):
            for offset.j in range(-1, 1+1):
                if offset.j==0 and offset.i==0:
                    continue
                neighbor = start + offset
                if not neighbor.valid_sector():
                    continue
                iquad = game.quad[neighbor.i][neighbor.j]
                # Empty space ends reaction
                if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB):
                    pass
                elif iquad == IHSTAR: # Affect another star 
                    if withprob(0.05):
                        # This star supernovas 
                        supernova(game.quadrant)
                        return
                    else:
                        hits.append(neighbor)
                        game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
                        game.state.starkl += 1
                        proutn(crmena(True, IHSTAR, "sector", neighbor))
                        prout(_(" novas."))
                        game.quad[neighbor.i][neighbor.j] = IHDOT
                        kount += 1
                elif iquad in (IHP, IHW): # Destroy planet 
                    game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
                    if iquad == IHP:
                        game.state.nplankl += 1
                    else:
                        game.state.worldkl += 1
                    prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
                    game.iplnet.pclass = "destroyed"
                    game.iplnet = None
                    game.plnet.invalidate()
                    if game.landed:
                        finish(FPNOVA)
                        return
                    game.quad[neighbor.i][neighbor.j] = IHDOT
                elif iquad == IHB: # Destroy base 
                    game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase = False
                    game.state.baseq = filter(lambda x: x!= game.quadrant, game.state.baseq)
                    game.base.invalidate()
                    game.state.basekl += 1
                    newcnd()
                    prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
                    game.quad[neighbor.i][neighbor.j] = IHDOT
                elif iquad in (IHE, IHF): # Buffet ship 
                    prout(_("***Starship buffeted by nova."))
                    if game.shldup:
                        if game.shield >= 2000.0:
                            game.shield -= 2000.0
                        else:
                            diff = 2000.0 - game.shield
                            game.energy -= diff
                            game.shield = 0.0
                            game.shldup = False
                            prout(_("***Shields knocked out."))
                            game.damage[DSHIELD] += 0.005*game.damfac*randreal()*diff
                    else:
                        game.energy -= 2000.0
                    if game.energy <= 0:
                        finish(FNOVA)
                        return
                    # add in course nova contributes to kicking starship
                    bump += (game.sector-hits[mm]).sgn()
                elif iquad == IHK: # kill klingon 
                    deadkl(neighbor, iquad, neighbor)
                elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies 
                    for ll in range(len(game.enemies)):
                        if game.enemies[ll].kloc == neighbor:
                            break
                    game.enemies[ll].kpower -= 800.0 # If firepower is lost, die 
                    if game.enemies[ll].kpower <= 0.0:
                        deadkl(neighbor, iquad, neighbor)
                        break
                    newc = neighbor + neighbor - hits[mm]
                    proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
                    if not newc.valid_sector():
                        # can't leave quadrant 
                        skip(1)
                        break
                    iquad1 = game.quad[newc.i][newc.j]
                    if iquad1 == IHBLANK:
                        proutn(_(", blasted into ") + crmena(False, IHBLANK, "sector", newc))
                        skip(1)
                        deadkl(neighbor, iquad, newc)
                        break
                    if iquad1 != IHDOT:
                        # can't move into something else 
                        skip(1)
                        break
                    proutn(_(", buffeted to Sector %s") % newc)
                    game.quad[neighbor.i][neighbor.j] = IHDOT
                    game.quad[newc.i][newc.j] = iquad
                    game.enemies[ll].move(newc)
    # Starship affected by nova -- kick it away. 
    dist = kount*0.1
    direc = course[3*(bump.i+1)+bump.j+2]
    if direc == 0.0:
        dist = 0.0
    if dist == 0.0:
        return
    course = course(bearing=direc, distance=dist)
    game.optime = course.time(warp=4)
    skip(1)
    prout(_("Force of nova displaces starship."))
    imove(course, novapush=True)
    game.optime = course.time(warp=4)
    return
        
def supernova(w):
    "Star goes supernova."
    num = 0; npdead = 0
    if w != None: 
        nq = copy.copy(w)
    else:
        # Scheduled supernova -- select star at random. 
        stars = 0
        nq = coord()
        for nq.i in range(GALSIZE):
            for nq.j in range(GALSIZE):
                stars += game.state.galaxy[nq.i][nq.j].stars
        if stars == 0:
            return # nothing to supernova exists 
        num = randrange(stars) + 1
        for nq.i in range(GALSIZE):
            for nq.j in range(GALSIZE):
                num -= game.state.galaxy[nq.i][nq.j].stars
                if num <= 0:
                    break
            if num <=0:
                break
        if idebug:
            proutn("=== Super nova here?")
            if ja() == True:
                nq = game.quadrant
    if not nq == game.quadrant or game.justin:
        # it isn't here, or we just entered (treat as enroute) 
        if communicating():
            skip(1)
            prout(_("Message from Starfleet Command       Stardate %.2f") % game.state.date)
            prout(_("     Supernova in Quadrant %s; caution advised.") % nq)
    else:
        ns = coord()
        # we are in the quadrant! 
        num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
        for ns.i in range(QUADSIZE):
            for ns.j in range(QUADSIZE):
                if game.quad[ns.i][ns.j]==IHSTAR:
                    num -= 1
                    if num==0:
                        break
            if num==0:
                break
        skip(1)
        prouts(_("***RED ALERT!  RED ALERT!"))
        skip(1)
        prout(_("***Incipient supernova detected at Sector %s") % ns)
        if (ns.i-game.sector.i)**2 + (ns.j-game.sector.j)**2 <= 2.1:
            proutn(_("Emergency override attempts t"))
            prouts("***************")
            skip(1)
            stars()
            game.alldone = True
    # destroy any Klingons in supernovaed quadrant
    kldead = game.state.galaxy[nq.i][nq.j].klingons
    game.state.galaxy[nq.i][nq.j].klingons = 0
    if nq == game.state.kscmdr:
        # did in the Supercommander! 
        game.state.nscrem = game.state.kscmdr.i = game.state.kscmdr.j = game.isatb =  0
        game.iscate = False
        unschedule(FSCMOVE)
        unschedule(FSCDBAS)
    survivors = filter(lambda w: w != nq, game.state.kcmdr)
    comkills = len(game.state.kcmdr) - len(survivors)
    game.state.kcmdr = survivors
    kldead -= comkills
    if not game.state.kcmdr:
        unschedule(FTBEAM)
    game.state.remkl -= kldead
    # destroy Romulans and planets in supernovaed quadrant 
    nrmdead = game.state.galaxy[nq.i][nq.j].romulans
    game.state.galaxy[nq.i][nq.j].romulans = 0
    game.state.nromrem -= nrmdead
    # Destroy planets 
    for loop in range(game.inplan):
        if game.state.planets[loop].quadrant == nq:
            game.state.planets[loop].pclass = "destroyed"
            npdead += 1
    # Destroy any base in supernovaed quadrant
    game.state.baseq = filter(lambda x: x != nq, game.state.baseq)
    # If starship caused supernova, tally up destruction 
    if w != None:
        game.state.starkl += game.state.galaxy[nq.i][nq.j].stars
        game.state.basekl += game.state.galaxy[nq.i][nq.j].starbase
        game.state.nplankl += npdead
    # mark supernova in galaxy and in star chart 
    if game.quadrant == nq or communicating():
        game.state.galaxy[nq.i][nq.j].supernova = True
    # If supernova destroys last Klingons give special message 
    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0 and not nq == game.quadrant:
        skip(2)
        if w == None:
            prout(_("Lucky you!"))
        proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq)
        finish(FWON)
        return
    # if some Klingons remain, continue or die in supernova 
    if game.alldone:
        finish(FSNOVAED)
    return

# Code from finish.c ends here.

def selfdestruct():
    "Self-destruct maneuver. Finish with a BANG!" 
    scanner.chew()
    if damaged(DCOMPTR):
        prout(_("Computer damaged; cannot execute destruct sequence."))
        return
    prouts(_("---WORKING---")); skip(1)
    prouts(_("SELF-DESTRUCT-SEQUENCE-ACTIVATED")); skip(1)
    prouts("   10"); skip(1)
    prouts("       9"); skip(1)
    prouts("          8"); skip(1)
    prouts("             7"); skip(1)
    prouts("                6"); skip(1)
    skip(1)
    prout(_("ENTER-CORRECT-PASSWORD-TO-CONTINUE-"))
    skip(1)
    prout(_("SELF-DESTRUCT-SEQUENCE-OTHERWISE-"))
    skip(1)
    prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED"))
    skip(1)
    scanner.next()
    scanner.chew()
    if game.passwd != scanner.token:
        prouts(_("PASSWORD-REJECTED;"))
        skip(1)
        prouts(_("CONTINUITY-EFFECTED"))
        skip(2)
        return
    prouts(_("PASSWORD-ACCEPTED")); skip(1)
    prouts("                   5"); skip(1)
    prouts("                      4"); skip(1)
    prouts("                         3"); skip(1)
    prouts("                            2"); skip(1)
    prouts("                              1"); skip(1)
    if withprob(0.15):
        prouts(_("GOODBYE-CRUEL-WORLD"))
        skip(1)
    kaboom()

def kaboom():
    stars()
    if game.ship==IHE:
        prouts("***")
    prouts(_("********* Entropy of %s maximized *********") % crmshp())
    skip(1)
    stars()
    skip(1)
    if len(game.enemies) != 0:
        whammo = 25.0 * game.energy
        l=1
        while l <= len(game.enemies):
            if game.enemies[l].kpower*game.enemies[l].kdist <= whammo: 
                deadkl(game.enemies[l].kloc, game.quad[game.enemies[l].kloc.i][game.enemies[l].kloc.j], game.enemies[l].kloc)
            l += 1
    finish(FDILITHIUM)
                                
def killrate():
    "Compute our rate of kils over time."
    elapsed = game.state.date - game.indate
    if elapsed == 0:    # Avoid divide-by-zero error if calculated on turn 0
        return 0
    else:
        starting = (game.inkling + game.incom + game.inscom)
        remaining = (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)
        return (starting - remaining)/elapsed

def badpoints():
    "Compute demerits."
    badpt = 5.0*game.state.starkl + \
            game.casual + \
            10.0*game.state.nplankl + \
            300*game.state.nworldkl + \
            45.0*game.nhelp +\
            100.0*game.state.basekl +\
            3.0*game.abandoned
    if game.ship == IHF:
        badpt += 100.0
    elif game.ship == None:
        badpt += 200.0
    return badpt

def finish(ifin):
    # end the game, with appropriate notfications 
    igotit = False
    game.alldone = True
    skip(3)
    prout(_("It is stardate %.1f.") % game.state.date)
    skip(1)
    if ifin == FWON: # Game has been won
        if game.state.nromrem != 0:
            prout(_("The remaining %d Romulans surrender to Starfleet Command.") %
                  game.state.nromrem)

        prout(_("You have smashed the Klingon invasion fleet and saved"))
        prout(_("the Federation."))
        game.gamewon = True
        if game.alive:
            badpt = badpoints()
            if badpt < 100.0:
                badpt = 0.0     # Close enough!
            # killsPerDate >= RateMax
            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 idebug:
                        prout(_("You cannot get a citation, so..."))
                    else:
                        proutn(_("Do you want your Commodore Emeritus Citation printed? "))
                        scanner.chew()
                        if ja() == True:
                            igotit = True
            # Only grant long life if alive (original didn't!)
            skip(1)
            prout(_("LIVE LONG AND PROSPER."))
        score()
        if igotit:
            plaque()        
        return
    elif ifin == FDEPLETE: # Federation Resources Depleted
        prout(_("Your time has run out and the Federation has been"))
        prout(_("conquered.  Your starship is now Klingon property,"))
        prout(_("and you are put on trial as a war criminal.  On the"))
        proutn(_("basis of your record, you are "))
        if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom):
            prout(_("acquitted."))
            skip(1)
            prout(_("LIVE LONG AND PROSPER."))
        else:
            prout(_("found guilty and"))
            prout(_("sentenced to death by slow torture."))
            game.alive = False
        score()
        return
    elif ifin == FLIFESUP:
        prout(_("Your life support reserves have run out, and"))
        prout(_("you die of thirst, starvation, and asphyxiation."))
        prout(_("Your starship is a derelict in space."))
    elif ifin == FNRG:
        prout(_("Your energy supply is exhausted."))
        skip(1)
        prout(_("Your starship is a derelict in space."))
    elif ifin == FBATTLE:
        prout(_("The %s has been destroyed in battle.") % crmshp())
        skip(1)
        prout(_("Dulce et decorum est pro patria mori."))
    elif ifin == FNEG3:
        prout(_("You have made three attempts to cross the negative energy"))
        prout(_("barrier which surrounds the galaxy."))
        skip(1)
        prout(_("Your navigation is abominable."))
        score()
    elif ifin == FNOVA:
        prout(_("Your starship has been destroyed by a nova."))
        prout(_("That was a great shot."))
        skip(1)
    elif ifin == FSNOVAED:
        prout(_("The %s has been fried by a supernova.") % crmshp())
        prout(_("...Not even cinders remain..."))
    elif ifin == FABANDN:
        prout(_("You have been captured by the Klingons. If you still"))
        prout(_("had a starbase to be returned to, you would have been"))
        prout(_("repatriated and given another chance. Since you have"))
        prout(_("no starbases, you will be mercilessly tortured to death."))
    elif ifin == FDILITHIUM:
        prout(_("Your starship is now an expanding cloud of subatomic particles"))
    elif ifin == FMATERIALIZE:
        prout(_("Starbase was unable to re-materialize your starship."))
        prout(_("Sic transit gloria mundi"))
    elif ifin == FPHASER:
        prout(_("The %s has been cremated by its own phasers.") % crmshp())
    elif ifin == FLOST:
        prout(_("You and your landing party have been"))
        prout(_("converted to energy, disipating through space."))
    elif ifin == FMINING:
        prout(_("You are left with your landing party on"))
        prout(_("a wild jungle planet inhabited by primitive cannibals."))
        skip(1)
        prout(_("They are very fond of \"Captain Kirk\" soup."))
        skip(1)
        prout(_("Without your leadership, the %s is destroyed.") % crmshp())
    elif ifin == FDPLANET:
        prout(_("You and your mining party perish."))
        skip(1)
        prout(_("That was a great shot."))
        skip(1)
    elif ifin == FSSC:
        prout(_("The Galileo is instantly annihilated by the supernova."))
        prout(_("You and your mining party are atomized."))
        skip(1)
        prout(_("Mr. Spock takes command of the %s and") % crmshp())
        prout(_("joins the Romulans, wreaking terror on the Federation."))
    elif ifin == FPNOVA:
        prout(_("You and your mining party are atomized."))
        skip(1)
        prout(_("Mr. Spock takes command of the %s and") % crmshp())
        prout(_("joins the Romulans, wreaking terror on the Federation."))
    elif ifin == FSTRACTOR:
        prout(_("The shuttle craft Galileo is also caught,"))
        prout(_("and breaks up under the strain."))
        skip(1)
        prout(_("Your debris is scattered for millions of miles."))
        prout(_("Without your leadership, the %s is destroyed.") % crmshp())
    elif ifin == FDRAY:
        prout(_("The mutants attack and kill Spock."))
        prout(_("Your ship is captured by Klingons, and"))
        prout(_("your crew is put on display in a Klingon zoo."))
    elif ifin == FTRIBBLE:
        prout(_("Tribbles consume all remaining water,"))
        prout(_("food, and oxygen on your ship."))
        skip(1)
        prout(_("You die of thirst, starvation, and asphyxiation."))
        prout(_("Your starship is a derelict in space."))
    elif ifin == FHOLE:
        prout(_("Your ship is drawn to the center of the black hole."))
        prout(_("You are crushed into extremely dense matter."))
    elif ifin == FCREW:
        prout(_("Your last crew member has died."))
    if game.ship == IHF:
        game.ship = None
    elif game.ship == IHE:
        game.ship = IHF
    game.alive = False
    if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
        goodies = game.state.remres/game.inresor
        baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom)
        if goodies/baddies >= randreal(1.0, 1.5):
            prout(_("As a result of your actions, a treaty with the Klingon"))
            prout(_("Empire has been signed. The terms of the treaty are"))
            if goodies/baddies >= randreal(3.0):
                prout(_("favorable to the Federation."))
                skip(1)
                prout(_("Congratulations!"))
            else:
                prout(_("highly unfavorable to the Federation."))
        else:
            prout(_("The Federation will be destroyed."))
    else:
        prout(_("Since you took the last Klingon with you, you are a"))
        prout(_("martyr and a hero. Someday maybe they'll erect a"))
        prout(_("statue in your memory. Rest in peace, and try not"))
        prout(_("to think about pigeons."))
        game.gamewon = True
    score()

def score():
    "Compute player's score."
    timused = game.state.date - game.indate
    iskill = game.skill
    if (timused == 0 or (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0:
        timused = 5.0
    perdate = killrate()
    ithperd = 500*perdate + 0.5
    iwon = 0
    if game.gamewon:
        iwon = 100*game.skill
    if game.ship == IHE: 
        klship = 0
    elif game.ship == IHF: 
        klship = 1
    else:
        klship = 2
    if not game.gamewon:
        game.state.nromrem = 0 # None captured if no win
    iscore = 10*(game.inkling - game.state.remkl) \
             + 50*(game.incom - len(game.state.kcmdr)) \
             + ithperd + iwon \
             + 20*(game.inrom - game.state.nromrem) \
             + 200*(game.inscom - game.state.nscrem) \
             - game.state.nromrem \
             - badpoints()
    if not game.alive:
        iscore -= 200
    skip(2)
    prout(_("Your score --"))
    if game.inrom - game.state.nromrem:
        prout(_("%6d Romulans destroyed                 %5d") %
              (game.inrom - game.state.nromrem, 20*(game.inrom - game.state.nromrem)))
    if game.state.nromrem:
        prout(_("%6d Romulans captured                  %5d") %
              (game.state.nromrem, game.state.nromrem))
    if game.inkling - game.state.remkl:
        prout(_("%6d ordinary Klingons destroyed        %5d") %
              (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl)))
    if game.incom - len(game.state.kcmdr):
        prout(_("%6d Klingon commanders destroyed       %5d") %
              (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr))))
    if game.inscom - game.state.nscrem:
        prout(_("%6d Super-Commander destroyed          %5d") %
              (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
    if ithperd:
        prout(_("%6.2f Klingons per stardate              %5d") %
              (perdate, ithperd))
    if game.state.starkl:
        prout(_("%6d stars destroyed by your action     %5d") %
              (game.state.starkl, -5*game.state.starkl))
    if game.state.nplankl:
        prout(_("%6d planets destroyed by your action   %5d") %
              (game.state.nplankl, -10*game.state.nplankl))
    if (game.options & OPTION_WORLDS) and game.state.nworldkl:
        prout(_("%6d inhabited planets destroyed by your action   %5d") %
              (game.state.nplankl, -300*game.state.nworldkl))
    if game.state.basekl:
        prout(_("%6d bases destroyed by your action     %5d") %
              (game.state.basekl, -100*game.state.basekl))
    if game.nhelp:
        prout(_("%6d calls for help from starbase       %5d") %
              (game.nhelp, -45*game.nhelp))
    if game.casual:
        prout(_("%6d casualties incurred                %5d") %
              (game.casual, -game.casual))
    if game.abandoned:
        prout(_("%6d crew abandoned in space            %5d") %
              (game.abandoned, -3*game.abandoned))
    if klship:
        prout(_("%6d ship(s) lost or destroyed          %5d") %
              (klship, -100*klship))
    if not game.alive:
        prout(_("Penalty for getting yourself killed        -200"))
    if game.gamewon:
        proutn(_("Bonus for winning "))
        if game.skill   == SKILL_NOVICE:        proutn(_("Novice game  "))
        elif game.skill == SKILL_FAIR:          proutn(_("Fair game    "))
        elif game.skill ==  SKILL_GOOD:         proutn(_("Good game    "))
        elif game.skill ==  SKILL_EXPERT:       proutn(_("Expert game  "))
        elif game.skill ==  SKILL_EMERITUS:     proutn(_("Emeritus game"))
        prout("           %5d" % iwon)
    skip(1)
    prout(_("TOTAL SCORE                               %5d") % iscore)

def plaque():
    "Emit winner's commemmorative plaque." 
    skip(2)
    while True:
        proutn(_("File or device name for your plaque: "))
        winner = cgetline()
        try:
            fp = open(winner, "w")
            break
        except IOError:
            prout(_("Invalid name."))

    proutn(_("Enter name to go on plaque (up to 30 characters): "))
    winner = cgetline()
    # The 38 below must be 64 for 132-column paper 
    nskip = 38 - len(winner)/2
    fp.write("\n\n\n\n")
    # --------DRAW ENTERPRISE PICTURE. 
    fp.write("                                       EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n" )
    fp.write("                                      EEE                      E  : :                                         :  E\n" )
    fp.write("                                    EE   EEE                   E  : :                   NCC-1701              :  E\n")
    fp.write("EEEEEEEEEEEEEEEE        EEEEEEEEEEEEEEE  : :                              : E\n")
    fp.write(" E                                     EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n")
    fp.write("                      EEEEEEEEE               EEEEEEEEEEEEE                 E  E\n")
    fp.write("                               EEEEEEE   EEEEE    E          E              E  E\n")
    fp.write("                                      EEE           E          E            E  E\n")
    fp.write("                                                       E         E          E  E\n")
    fp.write("                                                         EEEEEEEEEEEEE      E  E\n")
    fp.write("                                                      EEE :           EEEEEEE  EEEEEEEE\n")
    fp.write("                                                    :E    :                 EEEE       E\n")
    fp.write("                                                   .-E   -:-----                       E\n")
    fp.write("                                                    :E    :                            E\n")
    fp.write("                                                      EE  :                    EEEEEEEE\n")
    fp.write("                                                       EEEEEEEEEEEEEEEEEEEEEEE\n")
    fp.write("\n\n\n")
    fp.write(_("                                                       U. S. S. ENTERPRISE\n"))
    fp.write("\n\n\n\n")
    fp.write(_("                                  For demonstrating outstanding ability as a starship captain\n"))
    fp.write("\n")
    fp.write(_("                                                Starfleet Command bestows to you\n"))
    fp.write("\n")
    fp.write("%*s%s\n\n" % (nskip, "", winner))
    fp.write(_("                                                           the rank of\n\n"))
    fp.write(_("                                                       \"Commodore Emeritus\"\n\n"))
    fp.write("                                                          ")
    if game.skill ==  SKILL_EXPERT:
        fp.write(_(" Expert level\n\n"))
    elif game.skill == SKILL_EMERITUS:
        fp.write(_("Emeritus level\n\n"))
    else:
        fp.write(_(" Cheat level\n\n"))
    timestring = time.ctime()
    fp.write(_("                                                 This day of %.6s %.4s, %.8s\n\n") %
                    (timestring+4, timestring+20, timestring+11))
    fp.write(_("                                                        Your score:  %d\n\n") % iscore)
    fp.write(_("                                                    Klingons per stardate:  %.2f\n") % perdate)
    fp.close()

# Code from io.c begins here

rows = linecount = 0    # for paging 
stdscr = None
replayfp = None
fullscreen_window = None
srscan_window     = None
report_window     = None
status_window     = None
lrscan_window     = None
message_window    = None
prompt_window     = None
curwnd = None

def iostart():
    global stdscr, rows
    gettext.bindtextdomain("sst", "/usr/local/share/locale")
    gettext.textdomain("sst")
    if not (game.options & OPTION_CURSES):
        ln_env = os.getenv("LINES")
        if ln_env:
            rows = ln_env
        else:
            rows = 25
    else:
        stdscr = curses.initscr()
        stdscr.keypad(True)
        curses.nonl()
        curses.cbreak()
        global fullscreen_window, srscan_window, report_window, status_window
        global lrscan_window, message_window, prompt_window
        (rows, columns)   = stdscr.getmaxyx()
        fullscreen_window = stdscr
        srscan_window     = curses.newwin(12, 25, 0,       0)
        report_window     = curses.newwin(11, 0,  1,       25)
        status_window     = curses.newwin(10, 0,  1,       39)
        lrscan_window     = curses.newwin(5,  0,  0,       64) 
        message_window    = curses.newwin(0,  0,  12,      0)
        prompt_window     = curses.newwin(1,  0,  rows-2,  0) 
        message_window.scrollok(True)
        setwnd(fullscreen_window)

def ioend():
    "Wrap up I/O."
    if game.options & OPTION_CURSES:
        stdscr.keypad(False)
        curses.echo()
        curses.nocbreak()
        curses.endwin()

def waitfor():
    "Wait for user action -- OK to do nothing if on a TTY"
    if game.options & OPTION_CURSES:
        stdscr.getch()

def announce():
    skip(1)
    prouts(_("[ANNOUNCEMENT ARRIVING...]"))
    skip(1)

def pause_game():
    if game.skill > SKILL_FAIR:
        prompt = _("[CONTINUE?]")
    else:
        prompt = _("[PRESS ENTER TO CONTINUE]")

    if game.options & OPTION_CURSES:
        drawmaps(0)
        setwnd(prompt_window)
        prompt_window.clear()
        prompt_window.addstr(prompt)
        prompt_window.getstr()
        prompt_window.clear()
        prompt_window.refresh()
        setwnd(message_window)
    else:
        global linecount
        sys.stdout.write('\n')
        proutn(prompt)
        raw_input()
        for j in range(rows):
            sys.stdout.write('\n')
        linecount = 0

def skip(i):
    "Skip i lines.  Pause game if this would cause a scrolling event."
    for dummy in range(i):
        if game.options & OPTION_CURSES:
            (y, x) = curwnd.getyx()
            (my, mx) = curwnd.getmaxyx()
            if curwnd == message_window and y >= my - 3:
                pause_game()
                clrscr()
            else:
                try:
                    curwnd.move(y+1, 0)
                except curses.error:
                    pass
        else:
            global linecount
            linecount += 1
            if rows and linecount >= rows:
                pause_game()
            else:
                sys.stdout.write('\n')

def proutn(line):
    "Utter a line with no following line feed."
    if game.options & OPTION_CURSES:
        curwnd.addstr(line)
        curwnd.refresh()
    else:
        sys.stdout.write(line)
        sys.stdout.flush()

def prout(line):
    proutn(line)
    skip(1)

def prouts(line):
    "Emit slowly!" 
    for c in line:
        if not replayfp or replayfp.closed:     # Don't slow down replays
            time.sleep(0.03)
        proutn(c)
        if game.options & OPTION_CURSES:
            curwnd.refresh()
        else:
            sys.stdout.flush()
    if not replayfp or replayfp.closed:
        time.sleep(0.03)

def cgetline():
    "Get a line of input."
    if game.options & OPTION_CURSES:
        line = curwnd.getstr() + "\n"
        curwnd.refresh()
    else:
        if replayfp and not replayfp.closed:
            while True:
                line = replayfp.readline()
                proutn(line)
                if line == '':
                    prout("*** Replay finished")
                    replayfp.close()
                    break
                elif line[0] != "#":
                    break
        else:
            line = raw_input() + "\n"
    if logfp:
        logfp.write(line)
    return line

def setwnd(wnd):
    "Change windows -- OK for this to be a no-op in tty mode."
    global curwnd
    if game.options & OPTION_CURSES:
        curwnd = wnd
        curses.curs_set(wnd == fullscreen_window or wnd == message_window or wnd == prompt_window)

def clreol():
    "Clear to end of line -- can be a no-op in tty mode" 
    if game.options & OPTION_CURSES:
        curwnd.clrtoeol()
        curwnd.refresh()

def clrscr():
    "Clear screen -- can be a no-op in tty mode."
    global linecount
    if game.options & OPTION_CURSES:
       curwnd.clear()
       curwnd.move(0, 0)
       curwnd.refresh()
    linecount = 0
    
def highvideo():
    "Set highlight video, if this is reasonable."
    if game.options & OPTION_CURSES:
        curwnd.attron(curses.A_REVERSE)
 
#
# Things past this point have policy implications.
# 

def drawmaps(mode):
    "Hook to be called after moving to redraw maps."
    if game.options & OPTION_CURSES:
        if mode == 1:
            sensor()
        setwnd(srscan_window)
        curwnd.move(0, 0)
        srscan()
        if mode != 2:
            setwnd(status_window)
            status_window.clear()
            status_window.move(0, 0)
            setwnd(report_window)
            report_window.clear()
            report_window.move(0, 0)
            status()
            setwnd(lrscan_window)
            lrscan_window.clear()
            lrscan_window.move(0, 0)
            lrscan(silent=False)

def put_srscan_sym(w, sym):
    "Emit symbol for short-range scan."
    srscan_window.move(w.i+1, w.j*2+2)
    srscan_window.addch(sym)
    srscan_window.refresh()

def boom(w):
    "Enemy fall down, go boom."  
    if game.options & OPTION_CURSES:
        drawmaps(2)
        setwnd(srscan_window)
        srscan_window.attron(curses.A_REVERSE)
        put_srscan_sym(w, game.quad[w.i][w.j])
        #sound(500)
        #time.sleep(1.0)
        #nosound()
        srscan_window.attroff(curses.A_REVERSE)
        put_srscan_sym(w, game.quad[w.i][w.j])
        curses.delay_output(500)
        setwnd(message_window) 

def warble():
    "Sound and visual effects for teleportation."
    if game.options & OPTION_CURSES:
        drawmaps(2)
        setwnd(message_window)
        #sound(50)
    prouts("     . . . . .     ")
    if game.options & OPTION_CURSES:
        #curses.delay_output(1000)
        #nosound()
        pass

def tracktorpedo(origin, w, step, i, n, iquad):
    "Torpedo-track animation." 
    if not game.options & OPTION_CURSES:
        if step == 1:
            if n != 1:
                skip(1)
                proutn(_("Track for torpedo number %d-  ") % (i+1))
            else:
                skip(1)
                proutn(_("Torpedo track- "))
        elif step==4 or step==9: 
            skip(1)
        proutn("%s   " % w)
    else:
        if not damaged(DSRSENS) or game.condition=="docked":
            if i != 0 and step == 1:
                drawmaps(2)
                time.sleep(0.4)
            if (iquad==IHDOT) or (iquad==IHBLANK):
                put_srscan_sym(w, '+')
                #sound(step*10)
                #time.sleep(0.1)
                #nosound()
                put_srscan_sym(w, iquad)
            else:
                curwnd.attron(curses.A_REVERSE)
                put_srscan_sym(w, iquad)
                #sound(500)
                #time.sleep(1.0)
                #nosound()
                curwnd.attroff(curses.A_REVERSE)
                put_srscan_sym(w, iquad)
        else:
            proutn("%s   " % w)

def makechart():
    "Display the current galaxy chart."
    if game.options & OPTION_CURSES:
        setwnd(message_window)
        message_window.clear()
    chart()
    if game.options & OPTION_TTY:
        skip(1)

NSYM    = 14

def prstat(txt, data):
    proutn(txt)
    if game.options & OPTION_CURSES:
        skip(1)
        setwnd(status_window)
    else:
        proutn(" " * (NSYM - len(txt)))
    proutn(data)
    skip(1)
    if game.options & OPTION_CURSES:
        setwnd(report_window)

# Code from moving.c begins here

def imove(course=None, novapush=False):
    "Movement execution for warp, impulse, supernova, and tractor-beam events."
    w = coord(); final = coord()
    trbeam = False

    def no_quad_change():
        # No quadrant change -- compute new average enemy distances 
        game.quad[game.sector.i][game.sector.j] = game.ship
        if game.enemies:
            for enemy in game.enemies:
                finald = (w-enemy.kloc).distance()
                enemy.kavgd = 0.5 * (finald + enemy.kdist)
                enemy.kdist = finald
            game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
            if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
                attack(torps_ok=False)
            for enemy in game.enemies:
                enemy.kavgd = enemy.kdist
        newcnd()
        drawmaps(0)
        setwnd(message_window)
    w.i = w.j = 0
    if game.inorbit:
        prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
        game.inorbit = False
    angle = ((15.0 - course.bearing) * 0.5235988)
    deltax = -math.sin(angle)
    deltay = math.cos(angle)
    if math.fabs(deltax) > math.fabs(deltay):
        bigger = math.fabs(deltax)
    else:
        bigger = math.fabs(deltay)
    deltay /= bigger
    deltax /= bigger
    # If tractor beam is to occur, don't move full distance 
    if game.state.date+game.optime >= scheduled(FTBEAM):
        trbeam = True
        game.condition = "red"
        course.distance = course.distance*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1
        game.optime = scheduled(FTBEAM) - game.state.date + 1e-5
    # Move within the quadrant 
    game.quad[game.sector.i][game.sector.j] = IHDOT
    x = game.sector.i
    y = game.sector.j
    for m in range(course.moves):
        x += deltax
        y += deltay
        w.i = int(round(x))
        w.j = int(round(y))
        if not w.valid_sector():
            # Leaving quadrant -- allow final enemy attack 
            # Don't do it if being pushed by Nova 
            if len(game.enemies) != 0 and not novapush:
                newcnd()
                for enemy in game.enemies:
                    finald = (w - enemy.kloc).distance()
                    enemy.kavgd = 0.5 * (finald + enemy.kdist)
                #
                # Stas Sergeev added the condition
                # that attacks only happen if Klingons
                # are present and your skill is good.
                # 
                if game.skill > SKILL_GOOD and game.klhere > 0 and not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
                    attack(torps_ok=False)
                if game.alldone:
                    return
            # check for edge of galaxy 
            w = course.final
            kinks = 0
            while True:
                kink = False
                if w.i < 0:
                    w.i = -w.i
                    kink = True
                if w.j < 0:
                    w.j = -w.j
                    kink = True
                if w.i >= GALSIZE*QUADSIZE:
                    w.i = (GALSIZE*QUADSIZE*2) - w.i
                    kink = True
                if w.j >= GALSIZE*QUADSIZE:
                    w.j = (GALSIZE*QUADSIZE*2) - w.j
                    kink = True
                if kink:
                    kinks += 1
                else:
                    break
            if kinks:
                game.nkinks += 1
                if game.nkinks == 3:
                    # Three strikes -- you're out! 
                    finish(FNEG3)
                    return
                skip(1)
                prout(_("YOU HAVE ATTEMPTED TO CROSS THE NEGATIVE ENERGY BARRIER"))
                prout(_("AT THE EDGE OF THE GALAXY.  THE THIRD TIME YOU TRY THIS,"))
                prout(_("YOU WILL BE DESTROYED."))
            # Compute final position in new quadrant 
            if trbeam: # Don't bother if we are to be beamed 
                return
            game.quadrant.i = w.i/QUADSIZE
            game.quadrant.j = w.j/QUADSIZE
            game.sector.i = w.i - (QUADSIZE*game.quadrant.i)
            game.sector.j = w.j - (QUADSIZE*game.quadrant.j)
            skip(1)
            prout(_("Entering Quadrant %s.") % game.quadrant)
            game.quad[game.sector.i][game.sector.j] = game.ship
            newqad()
            if game.skill>SKILL_NOVICE:
                attack(torps_ok=False)  
            return
        iquad = game.quad[w.i][w.j]
        if iquad != IHDOT:
            # object encountered in flight path 
            stopegy = 50.0*course.distance/game.optime
            course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
            if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST):
                game.sector = w
                for enemy in game.enemies:
                    if enemy.kloc == game.sector:
                        break
                collision(rammed=False, enemy=enemy)
                final = game.sector
            elif iquad == IHBLANK:
                skip(1)
                prouts(_("***RED ALERT!  RED ALERT!"))
                skip(1)
                proutn("***" + crmshp())
                proutn(_(" pulled into black hole at Sector %s") % w)
                # Getting pulled into a black hole was certain
                # death in Almy's original.  Stas Sergeev added a
                # possibility that you'll get timewarped instead.
                n=0
                for m in range(NDEVICES):
                    if game.damage[m]>0: 
                        n += 1
                probf=math.pow(1.4,(game.energy+game.shield)/5000.0-1.0)*math.pow(1.3,1.0/(n+1)-1.0)
                if (game.options & OPTION_BLKHOLE) and withprob(1-probf): 
                    timwrp()
                else: 
                    finish(FHOLE)
                return
            else:
                # something else 
                skip(1)
                proutn(crmshp())
                if iquad == IHWEB:
                    prout(_(" encounters Tholian web at %s;") % w)
                else:
                    prout(_(" blocked by object at %s;") % w)
                proutn(_("Emergency stop required "))
                prout(_("%2d units of energy.") % int(stopegy))
                game.energy -= stopegy
                final.i = int(round(deltax))
                final.j = int(round(deltay))
                game.sector = final
                if game.energy <= 0:
                    finish(FNRG)
                    return
            # We're here!
            no_quad_change()
            return
        course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
        game.sector = w
    final = game.sector
    no_quad_change()
    return

def dock(verbose):
    "Dock our ship at a starbase."
    scanner.chew()
    if game.condition == "docked" and verbose:
        prout(_("Already docked."))
        return
    if game.inorbit:
        prout(_("You must first leave standard orbit."))
        return
    if not game.base.is_valid() or abs(game.sector.i-game.base.i) > 1 or abs(game.sector.j-game.base.j) > 1:
        prout(crmshp() + _(" not adjacent to base."))
        return
    game.condition = "docked"
    if "verbose":
        prout(_("Docked."))
    game.ididit = True
    if game.energy < game.inenrg:
        game.energy = game.inenrg
    game.shield = game.inshld
    game.torps = game.intorps
    game.lsupres = game.inlsr
    game.state.crew = FULLCREW
    if not damaged(DRADIO) and \
        ((is_scheduled(FCDBAS) or game.isatb == 1) and not game.iseenit):
        # get attack report from base 
        prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\""))
        attackreport(False)
        game.iseenit = True
 
# This program originally required input in terms of a (clock)
# direction and distance. Somewhere in history, it was changed to
# cartesian coordinates. So we need to convert.  Probably
# "manual" input should still be done this way -- it's a real
# pain if the computer isn't working! Manual mode is still confusing
# because it involves giving x and y motions, yet the coordinates
# are always displayed y - x, where +y is downward!

def cartesian(loc1=None, loc2=None):
    if loc1 is None:
        return game.quadrant * QUADSIZE + game.sector
    elif loc2 is None:
        return game.quadrant * QUADSIZE + loc1
    else:
        return loc1 * QUADSIZE + loc2

def getcourse(isprobe):
    "Get a course and distance from the user."
    key = 0
    dquad = copy.copy(game.quadrant)
    navmode = "unspecified"
    itemp = "curt"
    dsect = coord()
    iprompt = False
    if game.landed and not isprobe:
        prout(_("Dummy! You can't leave standard orbit until you"))
        proutn(_("are back aboard the ship."))
        scanner.chew()
        raise TrekError
    while navmode == "unspecified":
        if damaged(DNAVSYS):
            if isprobe:
                prout(_("Computer damaged; manual navigation only"))
            else:
                prout(_("Computer damaged; manual movement only"))
            scanner.chew()
            navmode = "manual"
            key = "IHEOL"
            break
        key = scanner.next()
        if key == "IHEOL":
            proutn(_("Manual or automatic- "))
            iprompt = True
            scanner.chew()
        elif key == "IHALPHA":
            if scanner.sees("manual"):
                navmode = "manual"
                key = scanner.next()
                break
            elif scanner.sees("automatic"):
                navmode = "automatic"
                key = scanner.next()
                break
            else:
                huh()
                scanner.chew()
                raise TrekError
        else: # numeric 
            if isprobe:
                prout(_("(Manual navigation assumed.)"))
            else:
                prout(_("(Manual movement assumed.)"))
            navmode = "manual"
            break
    delta = coord()
    if navmode == "automatic":
        while key == "IHEOL":
            if isprobe:
                proutn(_("Target quadrant or quadrant&sector- "))
            else:
                proutn(_("Destination sector or quadrant&sector- "))
            scanner.chew()
            iprompt = True
            key = scanner.next()
        if key != "IHREAL":
            huh()
            raise TrekError
        xi = int(round(scanner.real))-1
        key = scanner.next()
        if key != "IHREAL":
            huh()
            raise TrekError
        xj = int(round(scanner.real))-1
        key = scanner.next()
        if key == "IHREAL":
            # both quadrant and sector specified 
            xk = int(round(scanner.real))-1
            key = scanner.next()