sst.py

   1 #!/usr/bin/env python
   2 """
   3 sst.py -- Super Star Trek 2K
   4
   5 SST2K is a Python translation of a C translation of a FORTRAN
   6 original dating back to 1973.  Beautiful Python it is not, but it
   7 works.  Translation by Eric S. Raymond; original game by David Matuszek
   8 and Paul Reynolds, with modifications by Don Smith, Tom Almy,
   9 Stas Sergeev, and Eric S. Raymond.
  10
  11 See the doc/HACKING file in the distribution for designers notes and advice
  12 on how to modify (and how not to modify!) this code.
  13 """
  14 import os, sys, math, curses, time, readline, cPickle, random, copy, gettext, getpass
  15
  16 version="2.0"
  17
  18 docpath         = (".", "../doc", "/usr/share/doc/sst")
  19
  20 def _(str): return gettext.gettext(str)
  21
  22 GALSIZE         = 8             # Galaxy size in quadrants
  23 NINHAB          = (GALSIZE * GALSIZE / 2)       # Number of inhabited worlds
  24 MAXUNINHAB      = 10            # Maximum uninhabited worlds
  25 QUADSIZE        = 10            # Quadrant size in sectors
  26 BASEMIN         = 2                             # Minimum starbases
  27 BASEMAX         = (GALSIZE * GALSIZE / 12)      # Maximum starbases
  28 MAXKLGAME       = 127           # Maximum Klingons per game
  29 MAXKLQUAD       = 9             # Maximum Klingons per quadrant
  30 FULLCREW        = 428           # Crew size. BSD Trek was 387, that's wrong
  31 FOREVER         = 1e30          # Time for the indefinite future
  32 MAXBURST        = 3             # Max # of torps you can launch in one turn
  33 MINCMDR         = 10            # Minimum number of Klingon commanders
  34 DOCKFAC         = 0.25          # Repair faster when docked
  35 PHASEFAC        = 2.0           # Unclear what this is, it was in the C version
  36
  37 DEFAULT      = -1
  38 BLACK        = 0
  39 BLUE         = 1
  40 GREEN        = 2
  41 CYAN         = 3
  42 RED          = 4
  43 MAGENTA      = 5
  44 BROWN        = 6
  45 LIGHTGRAY    = 7
  46 DARKGRAY     = 8
  47 LIGHTBLUE    = 9
  48 LIGHTGREEN   = 10
  49 LIGHTCYAN    = 11
  50 LIGHTRED     = 12
  51 LIGHTMAGENTA = 13
  52 YELLOW       = 14
  53 WHITE        = 15
  54
  55 class TrekError(Exception):
  56     pass
  57
  58 class JumpOut(Exception):
  59     pass
  60
  61 class Coord:
  62     def __init__(self, x=None, y=None):
  63         self.i = x
  64         self.j = y
  65     def valid_quadrant(self):
  66         return self.i>=0 and self.i<GALSIZE and self.j>=0 and self.j<GALSIZE
  67     def valid_sector(self):
  68         return self.i>=0 and self.i<QUADSIZE and self.j>=0 and self.j<QUADSIZE
  69     def invalidate(self):
  70         self.i = self.j = None
  71     def is_valid(self):
  72         return self.i != None and self.j != None
  73     def __eq__(self, other):
  74         return other != None and self.i == other.i and self.j == other.j
  75     def __ne__(self, other):
  76         return other == None or self.i != other.i or self.j != other.j
  77     def __add__(self, other):
  78         return Coord(self.i+other.i, self.j+other.j)
  79     def __sub__(self, other):
  80         return Coord(self.i-other.i, self.j-other.j)
  81     def __mul__(self, other):
  82         return Coord(self.i*other, self.j*other)
  83     def __rmul__(self, other):
  84         return Coord(self.i*other, self.j*other)
  85     def __div__(self, other):
  86         return Coord(self.i/other, self.j/other)
  87     def __mod__(self, other):
  88         return Coord(self.i % other, self.j % other)
  89     def __rdiv__(self, other):
  90         return Coord(self.i/other, self.j/other)
  91     def roundtogrid(self):
  92         return Coord(int(round(self.i)), int(round(self.j)))
  93     def distance(self, other=None):
  94         if not other: other = Coord(0, 0)
  95         return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
  96     def bearing(self):
  97         return 1.90985*math.atan2(self.j, self.i)
  98     def sgn(self):
  99         s = Coord()
 100         if self.i == 0:
 101             s.i = 0
 102         else:
 103             s.i = self.i / abs(self.i)
 104         if self.j == 0:
 105             s.j = 0
 106         else:
 107             s.j = self.j / abs(self.j)
 108         return s
 109     def quadrant(self):
 110         #print "Location %s -> %s" % (self, (self / QUADSIZE).roundtogrid())
 111         return self.roundtogrid() / QUADSIZE
 112     def sector(self):
 113         return self.roundtogrid() % QUADSIZE
 114     def scatter(self):
 115         s = Coord()
 116         s.i = self.i + randrange(-1, 2)
 117         s.j = self.j + randrange(-1, 2)
 118         return s
 119     def __str__(self):
 120         if self.i == None or self.j == None:
 121             return "Nowhere"
 122         return "%s - %s" % (self.i+1, self.j+1)
 123     __repr__ = __str__
 124
 125 class Planet:
 126     def __init__(self):
 127         self.name = None        # string-valued if inhabited
 128         self.quadrant = Coord() # quadrant located
 129         self.pclass = None      # could be ""M", "N", "O", or "destroyed"
 130         self.crystals = "absent"# could be "mined", "present", "absent"
 131         self.known = "unknown"  # could be "unknown", "known", "shuttle_down"
 132         self.inhabited = False  # is it inhabites?
 133     def __str__(self):
 134         return self.name
 135
 136 class Quadrant:
 137     def __init__(self):
 138         self.stars = 0
 139         self.planet = None
 140         self.starbase = False
 141         self.klingons = 0
 142         self.romulans = 0
 143         self.supernova = False
 144         self.charted = False
 145         self.status = "secure"  # Could be "secure", "distressed", "enslaved"
 146
 147 class Page:
 148     def __init__(self):
 149         self.stars = None
 150         self.starbase = None
 151         self.klingons = None
 152
 153 def fill2d(size, fillfun):
 154     "Fill an empty list in 2D."
 155     lst = []
 156     for i in range(size):
 157         lst.append([])
 158         for j in range(size):
 159             lst[i].append(fillfun(i, j))
 160     return lst
 161
 162 class Snapshot:
 163     def __init__(self):
 164         self.snap = False       # snapshot taken
 165         self.crew = 0           # crew complement
 166         self.remkl = 0          # remaining klingons
 167         self.nscrem = 0         # remaining super commanders
 168         self.starkl = 0         # destroyed stars
 169         self.basekl = 0         # destroyed bases
 170         self.nromrem = 0        # Romulans remaining
 171         self.nplankl = 0        # destroyed uninhabited planets
 172         self.nworldkl = 0       # destroyed inhabited planets
 173         self.planets = []       # Planet information
 174         self.date = 0.0         # stardate
 175         self.remres = 0         # remaining resources
 176         self.remtime = 0        # remaining time
 177         self.baseq = []         # Base quadrant coordinates
 178         self.kcmdr = []         # Commander quadrant coordinates
 179         self.kscmdr = Coord()   # Supercommander quadrant coordinates
 180         # the galaxy
 181         self.galaxy = fill2d(GALSIZE, lambda i_unused, j_unused: Quadrant())
 182         # the starchart
 183         self.chart = fill2d(GALSIZE, lambda i_unused, j_unused: Page())
 184
 185 class Event:
 186     def __init__(self):
 187         self.date = None        # A real number
 188         self.quadrant = None    # A coord structure
 189
 190 # game options
 191 OPTION_ALL      = 0xffffffff
 192 OPTION_TTY      = 0x00000001    # old interface
 193 OPTION_CURSES   = 0x00000002    # new interface
 194 OPTION_IOMODES  = 0x00000003    # cover both interfaces
 195 OPTION_PLANETS  = 0x00000004    # planets and mining
 196 OPTION_THOLIAN  = 0x00000008    # Tholians and their webs (UT 1979 version)
 197 OPTION_THINGY   = 0x00000010    # Space Thingy can shoot back (Stas, 2005)
 198 OPTION_PROBE    = 0x00000020    # deep-space probes (DECUS version, 1980)
 199 OPTION_SHOWME   = 0x00000040    # bracket Enterprise in chart
 200 OPTION_RAMMING  = 0x00000080    # enemies may ram Enterprise (Almy)
 201 OPTION_MVBADDY  = 0x00000100    # more enemies can move (Almy)
 202 OPTION_BLKHOLE  = 0x00000200    # black hole may timewarp you (Stas, 2005)
 203 OPTION_BASE     = 0x00000400    # bases have good shields (Stas, 2005)
 204 OPTION_WORLDS   = 0x00000800    # logic for inhabited worlds (ESR, 2006)
 205 OPTION_AUTOSCAN = 0x00001000    # automatic LRSCAN before CHART (ESR, 2006)
 206 OPTION_PLAIN    = 0x01000000    # user chose plain game
 207 OPTION_ALMY     = 0x02000000    # user chose Almy variant
 208 OPTION_COLOR    = 0x04000000    # enable color display (experimental, ESR, 2010)
 209
 210 # Define devices
 211 DSRSENS = 0
 212 DLRSENS = 1
 213 DPHASER = 2
 214 DPHOTON = 3
 215 DLIFSUP = 4
 216 DWARPEN = 5
 217 DIMPULS = 6
 218 DSHIELD = 7
 219 DRADIO  = 0
 220 DSHUTTL = 9
 221 DCOMPTR = 10
 222 DNAVSYS = 11
 223 DTRANSP = 12
 224 DSHCTRL = 13
 225 DDRAY   = 14
 226 DDSP    = 15
 227 NDEVICES= 16    # Number of devices
 228
 229 SKILL_NONE      = 0
 230 SKILL_NOVICE    = 1
 231 SKILL_FAIR      = 2
 232 SKILL_GOOD      = 3
 233 SKILL_EXPERT    = 4
 234 SKILL_EMERITUS  = 5
 235
 236 def damaged(dev):       return (game.damage[dev] != 0.0)
 237 def communicating():    return not damaged(DRADIO) or game.condition=="docked"
 238
 239 # Define future events
 240 FSPY    = 0     # Spy event happens always (no future[] entry)
 241                 # can cause SC to tractor beam Enterprise
 242 FSNOVA  = 1     # Supernova
 243 FTBEAM  = 2     # Commander tractor beams Enterprise
 244 FSNAP   = 3     # Snapshot for time warp
 245 FBATTAK = 4     # Commander attacks base
 246 FCDBAS  = 5     # Commander destroys base
 247 FSCMOVE = 6     # Supercommander moves (might attack base)
 248 FSCDBAS = 7     # Supercommander destroys base
 249 FDSPROB = 8     # Move deep space probe
 250 FDISTR  = 9     # Emit distress call from an inhabited world
 251 FENSLV  = 10    # Inhabited word is enslaved */
 252 FREPRO  = 11    # Klingons build a ship in an enslaved system
 253 NEVENTS = 12
 254
 255 # Abstract out the event handling -- underlying data structures will change
 256 # when we implement stateful events
 257 def findevent(evtype):  return game.future[evtype]
 258
 259 class Enemy:
 260     def __init__(self, type=None, loc=None, power=None):
 261         self.type = type
 262         self.location = Coord()
 263         if loc:
 264             self.move(loc)
 265         self.power = power      # enemy energy level
 266         game.enemies.append(self)
 267     def move(self, loc):
 268         motion = (loc != self.location)
 269         if self.location.i is not None and self.location.j is not None:
 270             if motion:
 271                 if self.type == 'T':
 272                     game.quad[self.location.i][self.location.j] = '#'
 273                 else:
 274                     game.quad[self.location.i][self.location.j] = '.'
 275         if loc:
 276             self.location = copy.copy(loc)
 277             game.quad[self.location.i][self.location.j] = self.type
 278             self.kdist = self.kavgd = (game.sector - loc).distance()
 279         else:
 280             self.location = Coord()
 281             self.kdist = self.kavgd = None
 282             game.enemies.remove(self)
 283         return motion
 284     def __repr__(self):
 285         return "<%s,%s.%f>" % (self.type, self.location, self.power)    # For debugging
 286
 287 class Gamestate:
 288     def __init__(self):
 289         self.options = None     # Game options
 290         self.state = Snapshot() # A snapshot structure
 291         self.snapsht = Snapshot()       # Last snapshot taken for time-travel purposes
 292         self.quad = None        # contents of our quadrant
 293         self.damage = [0.0] * NDEVICES  # damage encountered
 294         self.future = []        # future events
 295         i = NEVENTS
 296         while i > 0:
 297             i -= 1
 298             self.future.append(Event())
 299         self.passwd  = None;            # Self Destruct password
 300         self.enemies = []
 301         self.quadrant = None    # where we are in the large
 302         self.sector = None      # where we are in the small
 303         self.tholian = None     # Tholian enemy object
 304         self.base = None        # position of base in current quadrant
 305         self.battle = None      # base coordinates being attacked
 306         self.plnet = None       # location of planet in quadrant
 307         self.gamewon = False    # Finished!
 308         self.ididit = False     # action taken -- allows enemy to attack
 309         self.alive = False      # we are alive (not killed)
 310         self.justin = False     # just entered quadrant
 311         self.shldup = False     # shields are up
 312         self.shldchg = False    # shield is changing (affects efficiency)
 313         self.iscate = False     # super commander is here
 314         self.ientesc = False    # attempted escape from supercommander
 315         self.resting = False    # rest time
 316         self.icraft = False     # Kirk in Galileo
 317         self.landed = False     # party on planet (true), on ship (false)
 318         self.alldone = False    # game is now finished
 319         self.neutz = False      # Romulan Neutral Zone
 320         self.isarmed = False    # probe is armed
 321         self.inorbit = False    # orbiting a planet
 322         self.imine = False      # mining
 323         self.icrystl = False    # dilithium crystals aboard
 324         self.iseenit = False    # seen base attack report
 325         self.thawed = False     # thawed game
 326         self.condition = None   # "green", "yellow", "red", "docked", "dead"
 327         self.iscraft = None     # "onship", "offship", "removed"
 328         self.skill = None       # Player skill level
 329         self.inkling = 0        # initial number of klingons
 330         self.inbase = 0         # initial number of bases
 331         self.incom = 0          # initial number of commanders
 332         self.inscom = 0         # initial number of commanders
 333         self.inrom = 0          # initial number of commanders
 334         self.instar = 0         # initial stars
 335         self.intorps = 0        # initial/max torpedoes
 336         self.torps = 0          # number of torpedoes
 337         self.ship = 0           # ship type -- 'E' is Enterprise
 338         self.abandoned = 0      # count of crew abandoned in space
 339         self.length = 0         # length of game
 340         self.klhere = 0         # klingons here
 341         self.casual = 0         # causalties
 342         self.nhelp = 0          # calls for help
 343         self.nkinks = 0         # count of energy-barrier crossings
 344         self.iplnet = None      # planet # in quadrant
 345         self.inplan = 0         # initial planets
 346         self.irhere = 0         # Romulans in quadrant
 347         self.isatb = 0          # =2 if super commander is attacking base
 348         self.tourn = None       # tournament number
 349         self.nprobes = 0        # number of probes available
 350         self.inresor = 0.0      # initial resources
 351         self.intime = 0.0       # initial time
 352         self.inenrg = 0.0       # initial/max energy
 353         self.inshld = 0.0       # initial/max shield
 354         self.inlsr = 0.0        # initial life support resources
 355         self.indate = 0.0       # initial date
 356         self.energy = 0.0       # energy level
 357         self.shield = 0.0       # shield level
 358         self.warpfac = 0.0      # warp speed
 359         self.lsupres = 0.0      # life support reserves
 360         self.optime = 0.0       # time taken by current operation
 361         self.damfac = 0.0       # damage factor
 362         self.lastchart = 0.0    # time star chart was last updated
 363         self.cryprob = 0.0      # probability that crystal will work
 364         self.probe = None       # object holding probe course info
 365         self.height = 0.0       # height of orbit around planet
 366         self.score = 0.0        # overall score
 367         self.perdate = 0.0      # rate of kills
 368         self.idebug = False     # Debugging instrumentation enabled?
 369     def recompute(self):
 370         # Stas thinks this should be (C expression):
 371         # game.state.remkl + len(game.state.kcmdr) > 0 ?
 372         #       game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) : 99
 373         # He says the existing expression is prone to divide-by-zero errors
 374         # after killing the last klingon when score is shown -- perhaps also
 375         # if the only remaining klingon is SCOM.
 376         game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr))
 377
 378 FWON = 0
 379 FDEPLETE = 1
 380 FLIFESUP = 2
 381 FNRG = 3
 382 FBATTLE = 4
 383 FNEG3 = 5
 384 FNOVA = 6
 385 FSNOVAED = 7
 386 FABANDN = 8
 387 FDILITHIUM = 9
 388 FMATERIALIZE = 10
 389 FPHASER = 11
 390 FLOST = 12
 391 FMINING = 13
 392 FDPLANET = 14
 393 FPNOVA = 15
 394 FSSC = 16
 395 FSTRACTOR = 17
 396 FDRAY = 18
 397 FTRIBBLE = 19
 398 FHOLE = 20
 399 FCREW = 21
 400
 401 def withprob(p):
 402     return random.random() < p
 403
 404 def randrange(*args):
 405     return random.randrange(*args)
 406
 407 def randreal(*args):
 408     v = random.random()
 409     if len(args) == 1:
 410         v *= args[0]            # from [0, args[0])
 411     elif len(args) == 2:
 412         v = args[0] + v*(args[1]-args[0])       # from [args[0], args[1])
 413     return v
 414
 415 # Code from ai.c begins here
 416
 417 def welcoming(iq):
 418     "Would this quadrant welcome another Klingon?"
 419     return iq.valid_quadrant() and \
 420         not game.state.galaxy[iq.i][iq.j].supernova and \
 421         game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD
 422
 423 def tryexit(enemy, look, irun):
 424     "A bad guy attempts to bug out."
 425     iq = Coord()
 426     iq.i = game.quadrant.i+(look.i+(QUADSIZE-1))/QUADSIZE - 1
 427     iq.j = game.quadrant.j+(look.j+(QUADSIZE-1))/QUADSIZE - 1
 428     if not welcoming(iq):
 429         return False;
 430     if enemy.type == 'R':
 431         return False; # Romulans cannot escape!
 432     if not irun:
 433         # avoid intruding on another commander's territory
 434         if enemy.type == 'C':
 435             if iq in game.state.kcmdr:
 436                 return False
 437             # refuse to leave if currently attacking starbase
 438             if game.battle == game.quadrant:
 439                 return False
 440         # don't leave if over 1000 units of energy
 441         if enemy.power > 1000.0:
 442             return False
 443     # emit escape message and move out of quadrant.
 444     # we know this if either short or long range sensors are working
 445     if not damaged(DSRSENS) or not damaged(DLRSENS) or \
 446         game.condition == "docked":
 447         prout(crmena(True, enemy.type, "sector", enemy.location) + \
 448               (_(" escapes to Quadrant %s (and regains strength).") % iq))
 449     # handle local matters related to escape
 450     enemy.move(None)
 451     game.klhere -= 1
 452     if game.condition != "docked":
 453         newcnd()
 454     # Handle global matters related to escape
 455     game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
 456     game.state.galaxy[iq.i][iq.j].klingons += 1
 457     if enemy.type=='S':
 458         game.iscate = False
 459         game.ientesc = False
 460         game.isatb = 0
 461         schedule(FSCMOVE, 0.2777)
 462         unschedule(FSCDBAS)
 463         game.state.kscmdr=iq
 464     else:
 465         for cmdr in game.state.kcmdr:
 466             if cmdr == game.quadrant:
 467                 game.state.kcmdr.append(iq)
 468                 break
 469     return True; # success
 470
 471 # The bad-guy movement algorithm:
 472 #
 473 # 1. Enterprise has "force" based on condition of phaser and photon torpedoes.
 474 # If both are operating full strength, force is 1000. If both are damaged,
 475 # force is -1000. Having shields down subtracts an additional 1000.
 476 #
 477 # 2. Enemy has forces equal to the energy of the attacker plus
 478 # 100*(K+R) + 500*(C+S) - 400 for novice through good levels OR
 479 # 346*K + 400*R + 500*(C+S) - 400 for expert and emeritus.
 480 #
 481 # Attacker Initial energy levels (nominal):
 482 # Klingon   Romulan   Commander   Super-Commander
 483 # Novice    400        700        1200
 484 # Fair      425        750        1250
 485 # Good      450        800        1300        1750
 486 # Expert    475        850        1350        1875
 487 # Emeritus  500        900        1400        2000
 488 # VARIANCE   75        200         200         200
 489 #
 490 # Enemy vessels only move prior to their attack. In Novice - Good games
 491 # only commanders move. In Expert games, all enemy vessels move if there
 492 # is a commander present. In Emeritus games all enemy vessels move.
 493 #
 494 # 3. If Enterprise is not docked, an aggressive action is taken if enemy
 495 # forces are 1000 greater than Enterprise.
 496 #
 497 # Agressive action on average cuts the distance between the ship and
 498 # the enemy to 1/4 the original.
 499 #
 500 # 4.  At lower energy advantage, movement units are proportional to the
 501 # advantage with a 650 advantage being to hold ground, 800 to move forward
 502 # 1, 950 for two, 150 for back 4, etc. Variance of 100.
 503 #
 504 # If docked, is reduced by roughly 1.75*game.skill, generally forcing a
 505 # retreat, especially at high skill levels.
 506 #
 507 # 5.  Motion is limited to skill level, except for SC hi-tailing it out.
 508
 509 def movebaddy(enemy):
 510     "Tactical movement for the bad guys."
 511     goto = Coord(); look = Coord()
 512     irun = False
 513     # This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
 514     if game.skill >= SKILL_EXPERT:
 515         nbaddys = (((game.quadrant in game.state.kcmdr)*2 + (game.state.kscmdr==game.quadrant)*2+game.klhere*1.23+game.irhere*1.5)/2.0)
 516     else:
 517         nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
 518     dist1 = enemy.kdist
 519     mdist = int(dist1 + 0.5); # Nearest integer distance
 520     # If SC, check with spy to see if should hi-tail it
 521     if enemy.type=='S' and \
 522         (enemy.power <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
 523         irun = True
 524         motion = -QUADSIZE
 525     else:
 526         # decide whether to advance, retreat, or hold position
 527         forces = enemy.power+100.0*len(game.enemies)+400*(nbaddys-1)
 528         if not game.shldup:
 529             forces += 1000; # Good for enemy if shield is down!
 530         if not damaged(DPHASER) or not damaged(DPHOTON):
 531             if damaged(DPHASER): # phasers damaged
 532                 forces += 300.0
 533             else:
 534                 forces -= 0.2*(game.energy - 2500.0)
 535             if damaged(DPHOTON): # photon torpedoes damaged
 536                 forces += 300.0
 537             else:
 538                 forces -= 50.0*game.torps
 539         else:
 540             # phasers and photon tubes both out!
 541             forces += 1000.0
 542         motion = 0
 543         if forces <= 1000.0 and game.condition != "docked": # Typical situation
 544             motion = ((forces + randreal(200))/150.0) - 5.0
 545         else:
 546             if forces > 1000.0: # Very strong -- move in for kill
 547                 motion = (1.0 - randreal())**2 * dist1 + 1.0
 548             if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off !
 549                 motion -= game.skill*(2.0-randreal()**2)
 550         if game.idebug:
 551             proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces))
 552         # don't move if no motion
 553         if motion==0:
 554             return
 555         # Limit motion according to skill
 556         if abs(motion) > game.skill:
 557             if motion < 0:
 558                 motion = -game.skill
 559             else:
 560                 motion = game.skill
 561     # calculate preferred number of steps
 562     nsteps = abs(int(motion))
 563     if motion > 0 and nsteps > mdist:
 564         nsteps = mdist; # don't overshoot
 565     if nsteps > QUADSIZE:
 566         nsteps = QUADSIZE; # This shouldn't be necessary
 567     if nsteps < 1:
 568         nsteps = 1; # This shouldn't be necessary
 569     if game.idebug:
 570         proutn("NSTEPS = %d:" % nsteps)
 571     # Compute preferred values of delta X and Y
 572     m = game.sector - enemy.location
 573     if 2.0 * abs(m.i) < abs(m.j):
 574         m.i = 0
 575     if 2.0 * abs(m.j) < abs(game.sector.i-enemy.location.i):
 576         m.j = 0
 577     m = (motion * m).sgn()
 578     goto = enemy.location
 579     # main move loop
 580     for ll in range(nsteps):
 581         if game.idebug:
 582             proutn(" %d" % (ll+1))
 583         # Check if preferred position available
 584         look = goto + m
 585         if m.i < 0:
 586             krawli = 1
 587         else:
 588             krawli = -1
 589         if m.j < 0:
 590             krawlj = 1
 591         else:
 592             krawlj = -1
 593         success = False
 594         attempts = 0; # Settle mysterious hang problem
 595         while attempts < 20 and not success:
 596             attempts += 1
 597             if look.i < 0 or look.i >= QUADSIZE:
 598                 if motion < 0 and tryexit(enemy, look, irun):
 599                     return
 600                 if krawli == m.i or m.j == 0:
 601                     break
 602                 look.i = goto.i + krawli
 603                 krawli = -krawli
 604             elif look.j < 0 or look.j >= QUADSIZE:
 605                 if motion < 0 and tryexit(enemy, look, irun):
 606                     return
 607                 if krawlj == m.j or m.i == 0:
 608                     break
 609                 look.j = goto.j + krawlj
 610                 krawlj = -krawlj
 611             elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != '.':
 612                 # See if enemy should ram ship
 613                 if game.quad[look.i][look.j] == game.ship and \
 614                     (enemy.type == 'C' or enemy.type == 'S'):
 615                     collision(rammed=True, enemy=enemy)
 616                     return
 617                 if krawli != m.i and m.j != 0:
 618                     look.i = goto.i + krawli
 619                     krawli = -krawli
 620                 elif krawlj != m.j and m.i != 0:
 621                     look.j = goto.j + krawlj
 622                     krawlj = -krawlj
 623                 else:
 624                     break; # we have failed
 625             else:
 626                 success = True
 627         if success:
 628             goto = look
 629             if game.idebug:
 630                 proutn(`goto`)
 631         else:
 632             break; # done early
 633     if game.idebug:
 634         skip(1)
 635     if enemy.move(goto):
 636         if not damaged(DSRSENS) or game.condition == "docked":
 637             proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.location))
 638             if enemy.kdist < dist1:
 639                 proutn(_(" advances to "))
 640             else:
 641                 proutn(_(" retreats to "))
 642             prout("Sector %s." % goto)
 643
 644 def moveklings():
 645     "Sequence Klingon tactical movement."
 646     if game.idebug:
 647         prout("== MOVCOM")
 648     # Figure out which Klingon is the commander (or Supercommander)
 649     # and do move
 650     if game.quadrant in game.state.kcmdr:
 651         for enemy in game.enemies:
 652             if enemy.type == 'C':
 653                 movebaddy(enemy)
 654     if game.state.kscmdr==game.quadrant:
 655         for enemy in game.enemies:
 656             if enemy.type == 'S':
 657                 movebaddy(enemy)
 658                 break
 659     # If skill level is high, move other Klingons and Romulans too!
 660     # Move these last so they can base their actions on what the
 661     # commander(s) do.
 662     if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
 663         for enemy in game.enemies:
 664             if enemy.type in ('K', 'R'):
 665                 movebaddy(enemy)
 666     sortenemies()
 667
 668 def movescom(iq, avoid):
 669     "Commander movement helper."
 670     # Avoid quadrants with bases if we want to avoid Enterprise
 671     if not welcoming(iq) or (avoid and iq in game.state.baseq):
 672         return False
 673     if game.justin and not game.iscate:
 674         return False
 675     # do the move
 676     game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons -= 1
 677     game.state.kscmdr = iq
 678     game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons += 1
 679     if game.state.kscmdr==game.quadrant:
 680         # SC has scooted, remove him from current quadrant
 681         game.iscate=False
 682         game.isatb=0
 683         game.ientesc = False
 684         unschedule(FSCDBAS)
 685         for enemy in game.enemies:
 686             if enemy.type == 'S':
 687                 break
 688         enemy.move(None)
 689         game.klhere -= 1
 690         if game.condition != "docked":
 691             newcnd()
 692         sortenemies()
 693     # check for a helpful planet
 694     for i in range(game.inplan):
 695         if game.state.planets[i].quadrant == game.state.kscmdr and \
 696             game.state.planets[i].crystals == "present":
 697             # destroy the planet
 698             game.state.planets[i].pclass = "destroyed"
 699             game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].planet = None
 700             if communicating():
 701                 announce()
 702                 prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
 703                 proutn(_("   a planet in Quadrant %s has been destroyed") % game.state.kscmdr)
 704                 prout(_("   by the Super-commander.\""))
 705             break
 706     return True; # looks good!
 707
 708 def supercommander():
 709     "Move the Super Commander."
 710     iq = Coord(); sc = Coord(); ibq = Coord(); idelta = Coord()
 711     basetbl = []
 712     if game.idebug:
 713         prout("== SUPERCOMMANDER")
 714     # Decide on being active or passive
 715     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 \
 716             (game.state.date-game.indate) < 3.0)
 717     if not game.iscate and avoid:
 718         # compute move away from Enterprise
 719         idelta = game.state.kscmdr-game.quadrant
 720         if idelta.distance() > 2.0:
 721             # circulate in space
 722             idelta.i = game.state.kscmdr.j-game.quadrant.j
 723             idelta.j = game.quadrant.i-game.state.kscmdr.i
 724     else:
 725         # compute distances to starbases
 726         if not game.state.baseq:
 727             # nothing left to do
 728             unschedule(FSCMOVE)
 729             return
 730         sc = game.state.kscmdr
 731         for (i, base) in enumerate(game.state.baseq):
 732             basetbl.append((i, (base - sc).distance()))
 733         if game.state.baseq > 1:
 734             basetbl.sort(lambda x, y: cmp(x[1], y[1]))
 735         # look for nearest base without a commander, no Enterprise, and
 736         # without too many Klingons, and not already under attack.
 737         ifindit = iwhichb = 0
 738         for (i2, base) in enumerate(game.state.baseq):
 739             i = basetbl[i2][0]; # bug in original had it not finding nearest
 740             if base==game.quadrant or base==game.battle or not welcoming(base):
 741                 continue
 742             # if there is a commander, and no other base is appropriate,
 743             # we will take the one with the commander
 744             for cmdr in game.state.kcmdr:
 745                 if base == cmdr and ifindit != 2:
 746                     ifindit = 2
 747                     iwhichb = i
 748                     break
 749             else:       # no commander -- use this one
 750                 ifindit = 1
 751                 iwhichb = i
 752                 break
 753         if ifindit==0:
 754             return # Nothing suitable -- wait until next time
 755         ibq = game.state.baseq[iwhichb]
 756         # decide how to move toward base
 757         idelta = ibq - game.state.kscmdr
 758     # Maximum movement is 1 quadrant in either or both axes
 759     idelta = idelta.sgn()
 760     # try moving in both x and y directions
 761     # there was what looked like a bug in the Almy C code here,
 762     # but it might be this translation is just wrong.
 763     iq = game.state.kscmdr + idelta
 764     if not movescom(iq, avoid):
 765         # failed -- try some other maneuvers
 766         if idelta.i==0 or idelta.j==0:
 767             # attempt angle move
 768             if idelta.i != 0:
 769                 iq.j = game.state.kscmdr.j + 1
 770                 if not movescom(iq, avoid):
 771                     iq.j = game.state.kscmdr.j - 1
 772                     movescom(iq, avoid)
 773             elif idelta.j != 0:
 774                 iq.i = game.state.kscmdr.i + 1
 775                 if not movescom(iq, avoid):
 776                     iq.i = game.state.kscmdr.i - 1
 777                     movescom(iq, avoid)
 778         else:
 779             # try moving just in x or y
 780             iq.j = game.state.kscmdr.j
 781             if not movescom(iq, avoid):
 782                 iq.j = game.state.kscmdr.j + idelta.j
 783                 iq.i = game.state.kscmdr.i
 784                 movescom(iq, avoid)
 785     # check for a base
 786     if len(game.state.baseq) == 0:
 787         unschedule(FSCMOVE)
 788     else:
 789         for ibq in game.state.baseq:
 790             if ibq == game.state.kscmdr and game.state.kscmdr == game.battle:
 791                 # attack the base
 792                 if avoid:
 793                     return # no, don't attack base!
 794                 game.iseenit = False
 795                 game.isatb = 1
 796                 schedule(FSCDBAS, randreal(1.0, 3.0))
 797                 if is_scheduled(FCDBAS):
 798                     postpone(FSCDBAS, scheduled(FCDBAS)-game.state.date)
 799                 if not communicating():
 800                     return # no warning
 801                 game.iseenit = True
 802                 announce()
 803                 prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") \
 804                       % game.state.kscmdr)
 805                 prout(_("   reports that it is under attack from the Klingon Super-commander."))
 806                 proutn(_("   It can survive until stardate %d.\"") \
 807                        % int(scheduled(FSCDBAS)))
 808                 if not game.resting:
 809                     return
 810                 prout(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
 811                 if not ja():
 812                     return
 813                 game.resting = False
 814                 game.optime = 0.0; # actually finished
 815                 return
 816     # Check for intelligence report
 817     if not game.idebug and \
 818         (withprob(0.8) or \
 819          (not communicating()) or \
 820          not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].charted):
 821         return
 822     announce()
 823     prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
 824     proutn(_("   the Super-commander is in Quadrant %s,") % game.state.kscmdr)
 825     return
 826
 827 def movetholian():
 828     "Move the Tholian."
 829     if not game.tholian or game.justin:
 830         return
 831     tid = Coord()
 832     if game.tholian.location.i == 0 and game.tholian.location.j == 0:
 833         tid.i = 0; tid.j = QUADSIZE-1
 834     elif game.tholian.location.i == 0 and game.tholian.location.j == QUADSIZE-1:
 835         tid.i = QUADSIZE-1; tid.j = QUADSIZE-1
 836     elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == QUADSIZE-1:
 837         tid.i = QUADSIZE-1; tid.j = 0
 838     elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == 0:
 839         tid.i = 0; tid.j = 0
 840     else:
 841         # something is wrong!
 842         game.tholian.move(None)
 843         prout("***Internal error: Tholian in a bad spot.")
 844         return
 845     # do nothing if we are blocked
 846     if game.quad[tid.i][tid.j] not in ('.', '#'):
 847         return
 848     here = copy.copy(game.tholian.location)
 849     delta = (tid - game.tholian.location).sgn()
 850     # move in x axis
 851     while here.i != tid.i:
 852         here.i += delta.i
 853         if game.quad[here.i][here.j]=='.':
 854             game.tholian.move(here)
 855     # move in y axis
 856     while here.j != tid.j:
 857         here.j += delta.j
 858         if game.quad[here.i][here.j]=='.':
 859             game.tholian.move(here)
 860     # check to see if all holes plugged
 861     for i in range(QUADSIZE):
 862         if game.quad[0][i]!='#' and game.quad[0][i]!='T':
 863             return
 864         if game.quad[QUADSIZE-1][i]!='#' and game.quad[QUADSIZE-1][i]!='T':
 865             return
 866         if game.quad[i][0]!='#' and game.quad[i][0]!='T':
 867             return
 868         if game.quad[i][QUADSIZE-1]!='#' and game.quad[i][QUADSIZE-1]!='T':
 869             return
 870     # All plugged up -- Tholian splits
 871     game.quad[game.tholian.location.i][game.tholian.location.j]='#'
 872     dropin(' ')
 873     prout(crmena(True, 'T', "sector", game.tholian) + _(" completes web."))
 874     game.tholian.move(None)
 875     return
 876
 877 # Code from battle.c begins here
 878
 879 def doshield(shraise):
 880     "Change shield status."
 881     action = "NONE"
 882     game.ididit = False
 883     if shraise:
 884         action = "SHUP"
 885     else:
 886         key = scanner.next()
 887         if key == "IHALPHA":
 888             if scanner.sees("transfer"):
 889                 action = "NRG"
 890             else:
 891                 if damaged(DSHIELD):
 892                     prout(_("Shields damaged and down."))
 893                     return
 894                 if scanner.sees("up"):
 895                     action = "SHUP"
 896                 elif scanner.sees("down"):
 897                     action = "SHDN"
 898         if action=="NONE":
 899             proutn(_("Do you wish to change shield energy? "))
 900             if ja():
 901                 action = "NRG"
 902             elif damaged(DSHIELD):
 903                 prout(_("Shields damaged and down."))
 904                 return
 905             elif game.shldup:
 906                 proutn(_("Shields are up. Do you want them down? "))
 907                 if ja():
 908                     action = "SHDN"
 909                 else:
 910                     scanner.chew()
 911                     return
 912             else:
 913                 proutn(_("Shields are down. Do you want them up? "))
 914                 if ja():
 915                     action = "SHUP"
 916                 else:
 917                     scanner.chew()
 918                     return
 919     if action == "SHUP": # raise shields
 920         if game.shldup:
 921             prout(_("Shields already up."))
 922             return
 923         game.shldup = True
 924         game.shldchg = True
 925         if game.condition != "docked":
 926             game.energy -= 50.0
 927         prout(_("Shields raised."))
 928         if game.energy <= 0:
 929             skip(1)
 930             prout(_("Shields raising uses up last of energy."))
 931             finish(FNRG)
 932             return
 933         game.ididit=True
 934         return
 935     elif action == "SHDN":
 936         if not game.shldup:
 937             prout(_("Shields already down."))
 938             return
 939         game.shldup=False
 940         game.shldchg=True
 941         prout(_("Shields lowered."))
 942         game.ididit = True
 943         return
 944     elif action == "NRG":
 945         while scanner.next() != "IHREAL":
 946             scanner.chew()
 947             proutn(_("Energy to transfer to shields- "))
 948         nrg = scanner.real
 949         scanner.chew()
 950         if nrg == 0:
 951             return
 952         if nrg > game.energy:
 953             prout(_("Insufficient ship energy."))
 954             return
 955         game.ididit = True
 956         if game.shield+nrg >= game.inshld:
 957             prout(_("Shield energy maximized."))
 958             if game.shield+nrg > game.inshld:
 959                 prout(_("Excess energy requested returned to ship energy"))
 960             game.energy -= game.inshld-game.shield
 961             game.shield = game.inshld
 962             return
 963         if nrg < 0.0 and game.energy-nrg > game.inenrg:
 964             # Prevent shield drain loophole
 965             skip(1)
 966             prout(_("Engineering to bridge--"))
 967             prout(_("  Scott here. Power circuit problem, Captain."))
 968             prout(_("  I can't drain the shields."))
 969             game.ididit = False
 970             return
 971         if game.shield+nrg < 0:
 972             prout(_("All shield energy transferred to ship."))
 973             game.energy += game.shield
 974             game.shield = 0.0
 975             return
 976         proutn(_("Scotty- \""))
 977         if nrg > 0:
 978             prout(_("Transferring energy to shields.\""))
 979         else:
 980             prout(_("Draining energy from shields.\""))
 981         game.shield += nrg
 982         game.energy -= nrg
 983         return
 984
 985 def randdevice():
 986     "Choose a device to damage, at random."
 987     weights = (
 988         105,    # DSRSENS: short range scanners 10.5%
 989         105,    # DLRSENS: long range scanners          10.5%
 990         120,    # DPHASER: phasers                      12.0%
 991         120,    # DPHOTON: photon torpedoes             12.0%
 992         25,     # DLIFSUP: life support                  2.5%
 993         65,     # DWARPEN: warp drive                    6.5%
 994         70,     # DIMPULS: impulse engines               6.5%
 995         145,    # DSHIELD: deflector shields            14.5%
 996         30,     # DRADIO:  subspace radio                3.0%
 997         45,     # DSHUTTL: shuttle                       4.5%
 998         15,     # DCOMPTR: computer                      1.5%
 999         20,     # NAVCOMP: navigation system             2.0%
1000         75,     # DTRANSP: transporter                   7.5%
1001         20,     # DSHCTRL: high-speed shield controller  2.0%
1002         10,     # DDRAY: death ray                       1.0%
1003         30,     # DDSP: deep-space probes                3.0%
1004     )
1005     assert(sum(weights) == 1000)
1006     idx = randrange(1000)
1007     wsum = 0
1008     for (i, w) in enumerate(weights):
1009         wsum += w
1010         if idx < wsum:
1011             return i
1012     return None;        # we should never get here
1013
1014 def collision(rammed, enemy):
1015     "Collision handling fot rammong events."
1016     prouts(_("***RED ALERT!  RED ALERT!"))
1017     skip(1)
1018     prout(_("***COLLISION IMMINENT."))
1019     skip(2)
1020     proutn("***")
1021     proutn(crmshp())
1022     hardness = {'R':1.5, 'C':2.0, 'S':2.5, 'T':0.5, '?':4.0}.get(enemy.type, 1.0)
1023     if rammed:
1024         proutn(_(" rammed by "))
1025     else:
1026         proutn(_(" rams "))
1027     proutn(crmena(False, enemy.type, "sector", enemy.location))
1028     if rammed:
1029         proutn(_(" (original position)"))
1030     skip(1)
1031     deadkl(enemy.location, enemy.type, game.sector)
1032     proutn("***" + crmshp() + " heavily damaged.")
1033     icas = randrange(10, 30)
1034     prout(_("***Sickbay reports %d casualties") % icas)
1035     game.casual += icas
1036     game.state.crew -= icas
1037     # In the pre-SST2K version, all devices got equiprobably damaged,
1038     # which was silly.  Instead, pick up to half the devices at
1039     # random according to our weighting table,
1040     ncrits = randrange(NDEVICES/2)
1041     while ncrits > 0:
1042         ncrits -= 1
1043         dev = randdevice()
1044         if game.damage[dev] < 0:
1045             continue
1046         extradm = (10.0*hardness*randreal()+1.0)*game.damfac
1047         # Damage for at least time of travel!
1048         game.damage[dev] += game.optime + extradm
1049     game.shldup = False
1050     prout(_("***Shields are down."))
1051     if game.state.remkl + len(game.state.kcmdr) + game.state.nscrem:
1052         announce()
1053         damagereport()
1054     else:
1055         finish(FWON)
1056     return
1057
1058 def torpedo(origin, bearing, dispersion, number, nburst):
1059     "Let a photon torpedo fly"
1060     if not damaged(DSRSENS) or game.condition=="docked":
1061         setwnd(srscan_window)
1062     else:
1063         setwnd(message_window)
1064     ac = bearing + 0.25*dispersion      # dispersion is a random variable
1065     bullseye = (15.0 - bearing)*0.5235988
1066     track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin))
1067     bumpto = Coord(0, 0)
1068     # Loop to move a single torpedo
1069     setwnd(message_window)
1070     for step in range(1, QUADSIZE*2):
1071         if not track.next(): break
1072         w = track.sector()
1073         if not w.valid_sector():
1074             break
1075         iquad=game.quad[w.i][w.j]
1076         tracktorpedo(w, step, number, nburst, iquad)
1077         if iquad=='.':
1078             continue
1079         # hit something
1080         if not damaged(DSRSENS) or game.condition == "docked":
1081             skip(1);    # start new line after text track
1082         if iquad in ('E', 'F'): # Hit our ship
1083             skip(1)
1084             prout(_("Torpedo hits %s.") % crmshp())
1085             hit = 700.0 + randreal(100) - \
1086                 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
1087             newcnd(); # we're blown out of dock
1088             if game.landed or game.condition=="docked":
1089                 return hit # Cheat if on a planet
1090             # In the C/FORTRAN version, dispersion was 2.5 radians, which
1091             # is 143 degrees, which is almost exactly 4.8 clockface units
1092             displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5)
1093             displacement.next()
1094             bumpto = displacement.sector()
1095             if not bumpto.valid_sector():
1096                 return hit
1097             if game.quad[bumpto.i][bumpto.j]==' ':
1098                 finish(FHOLE)
1099                 return hit
1100             if game.quad[bumpto.i][bumpto.j]!='.':
1101                 # can't move into object
1102                 return hit
1103             game.sector = bumpto
1104             proutn(crmshp())
1105             game.quad[w.i][w.j]='.'
1106             game.quad[bumpto.i][bumpto.j]=iquad
1107             prout(_(" displaced by blast to Sector %s ") % bumpto)
1108             for enemy in game.enemies:
1109                 enemy.kdist = enemy.kavgd = (game.sector-enemy.location).distance()
1110             sortenemies()
1111             return None
1112         elif iquad in ('C', 'S', 'R', 'K'): # Hit a regular enemy
1113             # find the enemy
1114             if iquad in ('C', 'S') and withprob(0.05):
1115                 prout(crmena(True, iquad, "sector", w) + _(" uses anti-photon device;"))
1116                 prout(_("   torpedo neutralized."))
1117                 return None
1118             for enemy in game.enemies:
1119                 if w == enemy.location:
1120                     break
1121             kp = math.fabs(enemy.power)
1122             h1 = 700.0 + randrange(100) - \
1123                 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
1124             h1 = math.fabs(h1)
1125             if kp < h1:
1126                 h1 = kp
1127             if enemy.power < 0:
1128                 enemy.power -= -h1
1129             else:
1130                 enemy.power -= h1
1131             if enemy.power == 0:
1132                 deadkl(w, iquad, w)
1133                 return None
1134             proutn(crmena(True, iquad, "sector", w))
1135             displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5)
1136             displacement.next()
1137             bumpto = displacement.sector()
1138             if not bumpto.valid_sector():
1139                 prout(_(" damaged but not destroyed."))
1140                 return
1141             if game.quad[bumpto.i][bumpto.j] == ' ':
1142                 prout(_(" buffeted into black hole."))
1143                 deadkl(w, iquad, bumpto)
1144             if game.quad[bumpto.i][bumpto.j] != '.':
1145                 prout(_(" damaged but not destroyed."))
1146             else:
1147                 prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
1148                 enemy.location = bumpto
1149                 game.quad[w.i][w.j]='.'
1150                 game.quad[bumpto.i][bumpto.j]=iquad
1151                 for enemy in game.enemies:
1152                     enemy.kdist = enemy.kavgd = (game.sector-enemy.location).distance()
1153                 sortenemies()
1154             return None
1155         elif iquad == 'B': # Hit a base
1156             skip(1)
1157             prout(_("***STARBASE DESTROYED.."))
1158             game.state.baseq = filter(lambda x: x != game.quadrant, game.state.baseq)
1159             game.quad[w.i][w.j]='.'
1160             game.base.invalidate()
1161             game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase -= 1
1162             game.state.chart[game.quadrant.i][game.quadrant.j].starbase -= 1
1163             game.state.basekl += 1
1164             newcnd()
1165             return None
1166         elif iquad == 'P': # Hit a planet
1167             prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
1168             game.state.nplankl += 1
1169             game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
1170             game.iplnet.pclass = "destroyed"
1171             game.iplnet = None
1172             game.plnet.invalidate()
1173             game.quad[w.i][w.j] = '.'
1174             if game.landed:
1175                 # captain perishes on planet
1176                 finish(FDPLANET)
1177             return None
1178         elif iquad == '@': # Hit an inhabited world -- very bad!
1179             prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
1180             game.state.nworldkl += 1
1181             game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
1182             game.iplnet.pclass = "destroyed"
1183             game.iplnet = None
1184             game.plnet.invalidate()
1185             game.quad[w.i][w.j] = '.'
1186             if game.landed:
1187                 # captain perishes on planet
1188                 finish(FDPLANET)
1189             prout(_("The torpedo destroyed an inhabited planet."))
1190             return None
1191         elif iquad == '*': # Hit a star
1192             if withprob(0.9):
1193                 nova(w)
1194             else:
1195                 prout(crmena(True, '*', "sector", w) + _(" unaffected by photon blast."))
1196             return None
1197         elif iquad == '?': # Hit a thingy
1198             if not (game.options & OPTION_THINGY) or withprob(0.3):
1199                 skip(1)
1200                 prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
1201                 skip(1)
1202                 prouts(_("    HACK!     HACK!    HACK!        *CHOKE!*  "))
1203                 skip(1)
1204                 proutn(_("Mr. Spock-"))
1205                 prouts(_("  \"Fascinating!\""))
1206                 skip(1)
1207                 deadkl(w, iquad, w)
1208             else:
1209                 # Stas Sergeev added the possibility that
1210                 # you can shove the Thingy and piss it off.
1211                 # It then becomes an enemy and may fire at you.
1212                 thing.angry = True
1213             return None
1214         elif iquad == ' ': # Black hole
1215             skip(1)
1216             prout(crmena(True, ' ', "sector", w) + _(" swallows torpedo."))
1217             return None
1218         elif iquad == '#': # hit the web
1219             skip(1)
1220             prout(_("***Torpedo absorbed by Tholian web."))
1221             return None
1222         elif iquad == 'T':  # Hit a Tholian
1223             h1 = 700.0 + randrange(100) - \
1224                 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
1225             h1 = math.fabs(h1)
1226             if h1 >= 600:
1227                 game.quad[w.i][w.j] = '.'
1228                 deadkl(w, iquad, w)
1229                 game.tholian = None
1230                 return None
1231             skip(1)
1232             proutn(crmena(True, 'T', "sector", w))
1233             if withprob(0.05):
1234                 prout(_(" survives photon blast."))
1235                 return None
1236             prout(_(" disappears."))
1237             game.tholian.move(None)
1238             game.quad[w.i][w.j] = '#'
1239             dropin(' ')
1240             return None
1241         else: # Problem!
1242             skip(1)
1243             proutn("Don't know how to handle torpedo collision with ")
1244             proutn(crmena(True, iquad, "sector", w))
1245             skip(1)
1246             return None
1247         break
1248     skip(1)
1249     prout(_("Torpedo missed."))
1250     return None;
1251
1252 def fry(hit):
1253     "Critical-hit resolution."
1254     if hit < (275.0-25.0*game.skill)*randreal(1.0, 1.5):
1255         return
1256     ncrit = int(1.0 + hit/(500.0+randreal(100)))
1257     proutn(_("***CRITICAL HIT--"))
1258     # Select devices and cause damage
1259     cdam = []
1260     while ncrit > 0:
1261         ncrit -= 1
1262         while True:
1263             j = randdevice()
1264             # Cheat to prevent shuttle damage unless on ship
1265             if not (game.damage[j]<0.0 or (j==DSHUTTL and game.iscraft != "onship")):
1266                 break
1267         cdam.append(j)
1268         extradm = (hit*game.damfac)/(ncrit*randreal(75, 100))
1269         game.damage[j] += extradm
1270     skipcount = 0
1271     for (i, j) in enumerate(cdam):
1272         proutn(device[j])
1273         if skipcount % 3 == 2 and i < len(cdam)-1:
1274             skip(1)
1275         skipcount += 1
1276         if i < len(cdam)-1:
1277             proutn(_(" and "))
1278     prout(_(" damaged."))
1279     if damaged(DSHIELD) and game.shldup:
1280         prout(_("***Shields knocked down."))
1281         game.shldup=False
1282
1283 def attack(torps_ok):
1284     # bad guy attacks us
1285     # torps_ok == False forces use of phasers in an attack
1286     # game could be over at this point, check
1287     if game.alldone:
1288         return
1289     attempt = False; ihurt = False;
1290     hitmax=0.0; hittot=0.0; chgfac=1.0
1291     where = "neither"
1292     if game.idebug:
1293         prout("=== ATTACK!")
1294     # Tholian gets to move before attacking
1295     if game.tholian:
1296         movetholian()
1297     # if you have just entered the RNZ, you'll get a warning
1298     if game.neutz: # The one chance not to be attacked
1299         game.neutz = False
1300         return
1301     # commanders get a chance to tac-move towards you
1302     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:
1303         moveklings()
1304     # if no enemies remain after movement, we're done
1305     if len(game.enemies)==0 or (len(game.enemies)==1 and thing == game.quadrant and not thing.angry):
1306         return
1307     # set up partial hits if attack happens during shield status change
1308     pfac = 1.0/game.inshld
1309     if game.shldchg:
1310         chgfac = 0.25 + randreal(0.5)
1311     skip(1)
1312     # message verbosity control
1313     if game.skill <= SKILL_FAIR:
1314         where = "sector"
1315     for enemy in game.enemies:
1316         if enemy.power < 0:
1317             continue;   # too weak to attack
1318         # compute hit strength and diminish shield power
1319         r = randreal()
1320         # Increase chance of photon torpedos if docked or enemy energy is low
1321         if game.condition == "docked":
1322             r *= 0.25
1323         if enemy.power < 500:
1324             r *= 0.25;
1325         if enemy.type=='T' or (enemy.type=='?' and not thing.angry):
1326             continue
1327         # different enemies have different probabilities of throwing a torp
1328         usephasers = not torps_ok or \
1329             (enemy.type == 'K' and r > 0.0005) or \
1330             (enemy.type=='C' and r > 0.015) or \
1331             (enemy.type=='R' and r > 0.3) or \
1332             (enemy.type=='S' and r > 0.07) or \
1333             (enemy.type=='?' and r > 0.05)
1334         if usephasers:      # Enemy uses phasers
1335             if game.condition == "docked":
1336                 continue; # Don't waste the effort!
1337             attempt = True; # Attempt to attack
1338             dustfac = randreal(0.8, 0.85)
1339             hit = enemy.power*math.pow(dustfac,enemy.kavgd)
1340             enemy.power *= 0.75
1341         else: # Enemy uses photon torpedo
1342             # We should be able to make the bearing() method work here
1343             pcourse = 1.90985*math.atan2(game.sector.j-enemy.location.j, enemy.location.i-game.sector.i)
1344             hit = 0
1345             proutn(_("***TORPEDO INCOMING"))
1346             if not damaged(DSRSENS):
1347                 proutn(_(" From ") + crmena(False, enemy.type, where, enemy.location))
1348             attempt = True
1349             prout("  ")
1350             dispersion = (randreal()+randreal())*0.5 - 0.5
1351             dispersion += 0.002*enemy.power*dispersion
1352             hit = torpedo(enemy.location, pcourse, dispersion, number=1, nburst=1)
1353             if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
1354                 finish(FWON); # Klingons did themselves in!
1355             if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone:
1356                 return # Supernova or finished
1357             if hit == None:
1358                 continue
1359         # incoming phaser or torpedo, shields may dissipate it
1360         if game.shldup or game.shldchg or game.condition=="docked":
1361             # shields will take hits
1362             propor = pfac * game.shield
1363             if game.condition =="docked":
1364                 propor *= 2.1
1365             if propor < 0.1:
1366                 propor = 0.1
1367             hitsh = propor*chgfac*hit+1.0
1368             absorb = 0.8*hitsh
1369             if absorb > game.shield:
1370                 absorb = game.shield
1371             game.shield -= absorb
1372             hit -= hitsh
1373             # taking a hit blasts us out of a starbase dock
1374             if game.condition == "docked":
1375                 dock(False)
1376             # but the shields may take care of it
1377             if propor > 0.1 and hit < 0.005*game.energy:
1378                 continue
1379         # hit from this opponent got through shields, so take damage
1380         ihurt = True
1381         proutn(_("%d unit hit") % int(hit))
1382         if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR:
1383             proutn(_(" on the ") + crmshp())
1384         if not damaged(DSRSENS) and usephasers:
1385             prout(_(" from ") + crmena(False, enemy.type, where, enemy.location))
1386         skip(1)
1387         # Decide if hit is critical
1388         if hit > hitmax:
1389             hitmax = hit
1390         hittot += hit
1391         fry(hit)
1392         game.energy -= hit
1393     if game.energy <= 0:
1394         # Returning home upon your shield, not with it...
1395         finish(FBATTLE)
1396         return
1397     if not attempt and game.condition == "docked":
1398         prout(_("***Enemies decide against attacking your ship."))
1399     percent = 100.0*pfac*game.shield+0.5
1400     if not ihurt:
1401         # Shields fully protect ship
1402         proutn(_("Enemy attack reduces shield strength to "))
1403     else:
1404         # Emit message if starship suffered hit(s)
1405         skip(1)
1406         proutn(_("Energy left %2d    shields ") % int(game.energy))
1407         if game.shldup:
1408             proutn(_("up "))
1409         elif not damaged(DSHIELD):
1410             proutn(_("down "))
1411         else:
1412             proutn(_("damaged, "))
1413     prout(_("%d%%,   torpedoes left %d") % (percent, game.torps))
1414     # Check if anyone was hurt
1415     if hitmax >= 200 or hittot >= 500:
1416         icas = randrange(int(hittot * 0.015))
1417         if icas >= 2:
1418             skip(1)
1419             prout(_("Mc Coy-  \"Sickbay to bridge.  We suffered %d casualties") % icas)
1420             prout(_("   in that last attack.\""))
1421             game.casual += icas
1422             game.state.crew -= icas
1423     # After attack, reset average distance to enemies
1424     for enemy in game.enemies:
1425         enemy.kavgd = enemy.kdist
1426     sortenemies()
1427     return
1428
1429 def deadkl(w, type, mv):
1430     "Kill a Klingon, Tholian, Romulan, or Thingy."
1431     # Added mv to allow enemy to "move" before dying
1432     proutn(crmena(True, type, "sector", mv))
1433     # Decide what kind of enemy it is and update appropriately
1434     if type == 'R':
1435         # Chalk up a Romulan
1436         game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans -= 1
1437         game.irhere -= 1
1438         game.state.nromrem -= 1
1439     elif type == 'T':
1440         # Killed a Tholian
1441         game.tholian = None
1442     elif type == '?':
1443         # Killed a Thingy
1444         global thing
1445         thing = None
1446     else:
1447         # Killed some type of Klingon
1448         game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
1449         game.klhere -= 1
1450         if type == 'C':
1451             game.state.kcmdr.remove(game.quadrant)
1452             unschedule(FTBEAM)
1453             if game.state.kcmdr:
1454                 schedule(FTBEAM, expran(1.0*game.incom/len(game.state.kcmdr)))
1455             if is_scheduled(FCDBAS) and game.battle == game.quadrant:
1456                 unschedule(FCDBAS)
1457         elif type ==  'K':
1458             game.state.remkl -= 1
1459         elif type ==  'S':
1460             game.state.nscrem -= 1
1461             game.state.kscmdr.invalidate()
1462             game.isatb = 0
1463             game.iscate = False
1464             unschedule(FSCMOVE)
1465             unschedule(FSCDBAS)
1466     # For each kind of enemy, finish message to player
1467     prout(_(" destroyed."))
1468     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
1469         return
1470     game.recompute()
1471     # Remove enemy ship from arrays describing local conditions
1472     for e in game.enemies:
1473         if e.location == w:
1474             e.move(None)
1475             break
1476     return
1477
1478 def targetcheck(w):
1479     "Return None if target is invalid, otherwise return a course angle."
1480     if not w.valid_sector():
1481         huh()
1482         return None
1483     delta = Coord()
1484     # FIXME: C code this was translated from is wacky -- why the sign reversal?
1485     delta.j = (w.j - game.sector.j);
1486     delta.i = (game.sector.i - w.i);
1487     if delta == Coord(0, 0):
1488         skip(1)
1489         prout(_("Spock-  \"Bridge to sickbay.  Dr. McCoy,"))
1490         prout(_("  I recommend an immediate review of"))
1491         prout(_("  the Captain's psychological profile.\""))
1492         scanner.chew()
1493         return None
1494     return delta.bearing()
1495
1496 def torps():
1497     "Launch photon torpedo salvo."
1498     tcourse = []
1499     game.ididit = False
1500     if damaged(DPHOTON):
1501         prout(_("Photon tubes damaged."))
1502         scanner.chew()
1503         return
1504     if game.torps == 0:
1505         prout(_("No torpedoes left."))
1506         scanner.chew()
1507         return
1508     # First, get torpedo count
1509     while True:
1510         scanner.next()
1511         if scanner.token == "IHALPHA":
1512             huh()
1513             return
1514         elif scanner.token == "IHEOL" or not scanner.waiting():
1515             prout(_("%d torpedoes left.") % game.torps)
1516             scanner.chew()
1517             proutn(_("Number of torpedoes to fire- "))
1518             continue    # Go back around to get a number
1519         else: # key == "IHREAL"
1520             n = scanner.int()
1521             if n <= 0: # abort command
1522                 scanner.chew()
1523                 return
1524             if n > MAXBURST:
1525                 scanner.chew()
1526                 prout(_("Maximum of %d torpedoes per burst.") % MAXBURST)
1527                 return
1528             if n > game.torps:
1529                 scanner.chew()  # User requested more torps than available
1530                 continue        # Go back around
1531             break       # All is good, go to next stage
1532     # Next, get targets
1533     target = []
1534     for i in range(n):
1535         key = scanner.next()
1536         if i==0 and key == "IHEOL":
1537             break;      # no coordinate waiting, we will try prompting
1538         if i==1 and key == "IHEOL":
1539             # direct all torpedoes at one target
1540             while i < n:
1541                 target.append(target[0])
1542                 tcourse.append(tcourse[0])
1543                 i += 1
1544             break
1545         scanner.push(scanner.token)
1546         target.append(scanner.getcoord())
1547         if target[-1] == None:
1548             return
1549         tcourse.append(targetcheck(target[-1]))
1550         if tcourse[-1] == None:
1551             return
1552     scanner.chew()
1553     if len(target) == 0:
1554         # prompt for each one
1555         for i in range(n):
1556             proutn(_("Target sector for torpedo number %d- ") % (i+1))
1557             scanner.chew()
1558             target.append(scanner.getcoord())
1559             if target[-1] == None:
1560                 return
1561             tcourse.append(targetcheck(target[-1]))
1562             if tcourse[-1] == None:
1563                 return
1564     game.ididit = True
1565     # Loop for moving <n> torpedoes
1566     for i in range(n):
1567         if game.condition != "docked":
1568             game.torps -= 1
1569         dispersion = (randreal()+randreal())*0.5 -0.5
1570         if math.fabs(dispersion) >= 0.47:
1571             # misfire!
1572             dispersion *= randreal(1.2, 2.2)
1573             if n > 0:
1574                 prouts(_("***TORPEDO NUMBER %d MISFIRES") % (i+1))
1575             else:
1576                 prouts(_("***TORPEDO MISFIRES."))
1577             skip(1)
1578             if i < n:
1579                 prout(_("  Remainder of burst aborted."))
1580             if withprob(0.2):
1581                 prout(_("***Photon tubes damaged by misfire."))
1582                 game.damage[DPHOTON] = game.damfac * randreal(1.0, 3.0)
1583             break
1584         if game.shldup or game.condition == "docked":
1585             dispersion *= 1.0 + 0.0001*game.shield
1586         torpedo(game.sector, tcourse[i], dispersion, number=i, nburst=n)
1587         if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
1588             return
1589     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)<=0:
1590         finish(FWON);
1591
1592 def overheat(rpow):
1593     "Check for phasers overheating."
1594     if rpow > 1500:
1595         checkburn = (rpow-1500.0)*0.00038
1596         if withprob(checkburn):
1597             prout(_("Weapons officer Sulu-  \"Phasers overheated, sir.\""))
1598             game.damage[DPHASER] = game.damfac* randreal(1.0, 2.0) * (1.0+checkburn)
1599
1600 def checkshctrl(rpow):
1601     "Check shield control."
1602     skip(1)
1603     if withprob(0.998):
1604         prout(_("Shields lowered."))
1605         return False
1606     # Something bad has happened
1607     prouts(_("***RED ALERT!  RED ALERT!"))
1608     skip(2)
1609     hit = rpow*game.shield/game.inshld
1610     game.energy -= rpow+hit*0.8
1611     game.shield -= hit*0.2
1612     if game.energy <= 0.0:
1613         prouts(_("Sulu-  \"Captain! Shield malf***********************\""))
1614         skip(1)
1615         stars()
1616         finish(FPHASER)
1617         return True
1618     prouts(_("Sulu-  \"Captain! Shield malfunction! Phaser fire contained!\""))
1619     skip(2)
1620     prout(_("Lt. Uhura-  \"Sir, all decks reporting damage.\""))
1621     icas = randrange(int(hit*0.012))
1622     skip(1)
1623     fry(0.8*hit)
1624     if icas:
1625         skip(1)
1626         prout(_("McCoy to bridge- \"Severe radiation burns, Jim."))
1627         prout(_("  %d casualties so far.\"") % icas)
1628         game.casual += icas
1629         game.state.crew -= icas
1630     skip(1)
1631     prout(_("Phaser energy dispersed by shields."))
1632     prout(_("Enemy unaffected."))
1633     overheat(rpow)
1634     return True;
1635
1636 def hittem(hits):
1637     "Register a phaser hit on Klingons and Romulans."
1638     kk = 0
1639     w = Coord()
1640     skip(1)
1641     for (k, wham) in enumerate(hits):
1642         if wham==0:
1643             continue
1644         dustfac = randreal(0.9, 1.0)
1645         hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
1646         kpini = game.enemies[kk].power
1647         kp = math.fabs(kpini)
1648         if PHASEFAC*hit < kp:
1649             kp = PHASEFAC*hit
1650         if game.enemies[kk].power < 0:
1651             game.enemies[kk].power -= -kp
1652         else:
1653             game.enemies[kk].power -= kp
1654         kpow = game.enemies[kk].power
1655         w = game.enemies[kk].location
1656         if hit > 0.005:
1657             if not damaged(DSRSENS):
1658                 boom(w)
1659             proutn(_("%d unit hit on ") % int(hit))
1660         else:
1661             proutn(_("Very small hit on "))
1662         ienm = game.quad[w.i][w.j]
1663         if ienm=='?':
1664             thing.angry = True
1665         proutn(crmena(False, ienm, "sector", w))
1666         skip(1)
1667         if kpow == 0:
1668             deadkl(w, ienm, w)
1669             if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
1670                 finish(FWON);
1671             if game.alldone:
1672                 return
1673             kk -= 1     # don't do the increment
1674             continue
1675         else: # decide whether or not to emasculate klingon
1676             if kpow>0 and withprob(0.9) and kpow <= randreal(0.4, 0.8)*kpini:
1677                 prout(_("***Mr. Spock-  \"Captain, the vessel at Sector %s")%w)
1678                 prout(_("   has just lost its firepower.\""))
1679                 game.enemies[kk].power = -kpow
1680         kk += 1
1681     return
1682
1683 def phasers():
1684     "Fire phasers at bad guys."
1685     hits = []
1686     kz = 0; k = 1; irec=0 # Cheating inhibitor
1687     ifast = False; no = False; itarg = True; msgflag = True; rpow=0
1688     automode = "NOTSET"
1689     key=0
1690     skip(1)
1691     # SR sensors and Computer are needed for automode
1692     if damaged(DSRSENS) or damaged(DCOMPTR):
1693         itarg = False
1694     if game.condition == "docked":
1695         prout(_("Phasers can't be fired through base shields."))
1696         scanner.chew()
1697         return
1698     if damaged(DPHASER):
1699         prout(_("Phaser control damaged."))
1700         scanner.chew()
1701         return
1702     if game.shldup:
1703         if damaged(DSHCTRL):
1704             prout(_("High speed shield control damaged."))
1705             scanner.chew()
1706             return
1707         if game.energy <= 200.0:
1708             prout(_("Insufficient energy to activate high-speed shield control."))
1709             scanner.chew()
1710             return
1711         prout(_("Weapons Officer Sulu-  \"High-speed shield control enabled, sir.\""))
1712         ifast = True
1713     # Original code so convoluted, I re-did it all
1714     # (That was Tom Almy talking about the C code, I think -- ESR)
1715     while automode=="NOTSET":
1716         key=scanner.next()
1717         if key == "IHALPHA":
1718             if scanner.sees("manual"):
1719                 if len(game.enemies)==0:
1720                     prout(_("There is no enemy present to select."))
1721                     scanner.chew()
1722                     key = "IHEOL"
1723                     automode="AUTOMATIC"
1724                 else:
1725                     automode = "MANUAL"
1726                     key = scanner.next()
1727             elif scanner.sees("automatic"):
1728                 if (not itarg) and len(game.enemies) != 0:
1729                     automode = "FORCEMAN"
1730                 else:
1731                     if len(game.enemies)==0:
1732                         prout(_("Energy will be expended into space."))
1733                     automode = "AUTOMATIC"
1734                     key = scanner.next()
1735             elif scanner.sees("no"):
1736                 no = True
1737             else:
1738                 huh()
1739                 return
1740         elif key == "IHREAL":
1741             if len(game.enemies)==0:
1742                 prout(_("Energy will be expended into space."))
1743                 automode = "AUTOMATIC"
1744             elif not itarg:
1745                 automode = "FORCEMAN"
1746             else:
1747                 automode = "AUTOMATIC"
1748         else:
1749             # "IHEOL"
1750             if len(game.enemies)==0:
1751                 prout(_("Energy will be expended into space."))
1752                 automode = "AUTOMATIC"
1753             elif not itarg:
1754                 automode = "FORCEMAN"
1755             else:
1756                 proutn(_("Manual or automatic? "))
1757                 scanner.chew()
1758     avail = game.energy
1759     if ifast:
1760         avail -= 200.0
1761     if automode == "AUTOMATIC":
1762         if key == "IHALPHA" and scanner.sees("no"):
1763             no = True
1764             key = scanner.next()
1765         if key != "IHREAL" and len(game.enemies) != 0:
1766             prout(_("Phasers locked on target. Energy available: %.2f")%avail)
1767         irec=0
1768         while True:
1769             scanner.chew()
1770             if not kz:
1771                 for i in range(len(game.enemies)):
1772                     irec += math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
1773             kz=1
1774             proutn(_("%d units required. ") % irec)
1775             scanner.chew()
1776             proutn(_("Units to fire= "))
1777             key = scanner.next()
1778             if key!="IHREAL":
1779                 return
1780             rpow = scanner.real
1781             if rpow > avail:
1782                 proutn(_("Energy available= %.2f") % avail)
1783                 skip(1)
1784                 key = "IHEOL"
1785             if not rpow > avail:
1786                 break
1787         if rpow<=0:
1788             # chicken out
1789             scanner.chew()
1790             return
1791         key=scanner.next()
1792         if key == "IHALPHA" and scanner.sees("no"):
1793             no = True
1794         if ifast:
1795             game.energy -= 200; # Go and do it!
1796             if checkshctrl(rpow):
1797                 return
1798         scanner.chew()
1799         game.energy -= rpow
1800         extra = rpow
1801         if len(game.enemies):
1802             extra = 0.0
1803             powrem = rpow
1804             for i in range(len(game.enemies)):
1805                 hits.append(0.0)
1806                 if powrem <= 0:
1807                     continue
1808                 hits[i] = math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
1809                 over = randreal(1.01, 1.06) * hits[i]
1810                 temp = powrem
1811                 powrem -= hits[i] + over
1812                 if powrem <= 0 and temp < hits[i]:
1813                     hits[i] = temp
1814                 if powrem <= 0:
1815                     over = 0.0
1816                 extra += over
1817             if powrem > 0.0:
1818                 extra += powrem
1819             hittem(hits)
1820             game.ididit = True
1821         if extra > 0 and not game.alldone:
1822             if game.tholian:
1823                 proutn(_("*** Tholian web absorbs "))
1824                 if len(game.enemies)>0:
1825                     proutn(_("excess "))
1826                 prout(_("phaser energy."))
1827             else:
1828                 prout(_("%d expended on empty space.") % int(extra))
1829     elif automode == "FORCEMAN":
1830         scanner.chew()
1831         key = "IHEOL"
1832         if damaged(DCOMPTR):
1833             prout(_("Battle computer damaged, manual fire only."))
1834         else:
1835             skip(1)
1836             prouts(_("---WORKING---"))
1837             skip(1)
1838             prout(_("Short-range-sensors-damaged"))
1839             prout(_("Insufficient-data-for-automatic-phaser-fire"))
1840             prout(_("Manual-fire-must-be-used"))
1841             skip(1)
1842     elif automode == "MANUAL":
1843         rpow = 0.0
1844         for k in range(len(game.enemies)):
1845             aim = game.enemies[k].location
1846             ienm = game.quad[aim.i][aim.j]
1847             if msgflag:
1848                 proutn(_("Energy available= %.2f") % (avail-0.006))
1849                 skip(1)
1850                 msgflag = False
1851                 rpow = 0.0
1852             if damaged(DSRSENS) and \
1853                not game.sector.distance(aim)<2**0.5 and ienm in ('C', 'S'):
1854                 prout(cramen(ienm) + _(" can't be located without short range scan."))
1855                 scanner.chew()
1856                 key = "IHEOL"
1857                 hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko
1858                 k += 1
1859                 continue
1860             if key == "IHEOL":
1861                 scanner.chew()
1862                 if itarg and k > kz:
1863                     irec=(abs(game.enemies[k].power)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) *  randreal(1.01, 1.06) + 1.0
1864                 kz = k
1865                 proutn("(")
1866                 if not damaged(DCOMPTR):
1867                     proutn("%d" % irec)
1868                 else:
1869                     proutn("??")
1870                 proutn(")  ")
1871                 proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))
1872                 key = scanner.next()
1873             if key == "IHALPHA" and scanner.sees("no"):
1874                 no = True
1875                 key = scanner.next()
1876                 continue
1877             if key == "IHALPHA":
1878                 huh()
1879                 return
1880             if key == "IHEOL":
1881                 if k==1: # Let me say I'm baffled by this
1882                     msgflag = True
1883                 continue
1884             if scanner.real < 0:
1885                 # abort out
1886                 scanner.chew()
1887                 return
1888             hits[k] = scanner.real
1889             rpow += scanner.real
1890             # If total requested is too much, inform and start over
1891             if rpow > avail:
1892                 prout(_("Available energy exceeded -- try again."))
1893                 scanner.chew()
1894                 return
1895             key = scanner.next(); # scan for next value
1896             k += 1
1897         if rpow == 0.0:
1898             # zero energy -- abort
1899             scanner.chew()
1900             return
1901         if key == "IHALPHA" and scanner.sees("no"):
1902             no = True
1903         game.energy -= rpow
1904         scanner.chew()
1905         if ifast:
1906             game.energy -= 200.0
1907             if checkshctrl(rpow):
1908                 return
1909         hittem(hits)
1910         game.ididit = True
1911      # Say shield raised or malfunction, if necessary
1912     if game.alldone:
1913         return
1914     if ifast:
1915         skip(1)
1916         if no == 0:
1917             if withprob(0.01):
1918                 prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
1919                 prouts(_("         CLICK   CLICK   POP  . . ."))
1920                 prout(_(" No response, sir!"))
1921                 game.shldup = False
1922             else:
1923                 prout(_("Shields raised."))
1924         else:
1925             game.shldup = False
1926     overheat(rpow);
1927
1928 # Code from events,c begins here.
1929
1930 # This isn't a real event queue a la BSD Trek yet -- you can only have one
1931 # event of each type active at any given time.  Mostly these means we can
1932 # only have one FDISTR/FENSLV/FREPRO sequence going at any given time
1933 # BSD Trek, from which we swiped the idea, can have up to 5.
1934
1935 def unschedule(evtype):
1936     "Remove an event from the schedule."
1937     game.future[evtype].date = FOREVER
1938     return game.future[evtype]
1939
1940 def is_scheduled(evtype):
1941     "Is an event of specified type scheduled."
1942     return game.future[evtype].date != FOREVER
1943
1944 def scheduled(evtype):
1945     "When will this event happen?"
1946     return game.future[evtype].date
1947
1948 def schedule(evtype, offset):
1949     "Schedule an event of specified type."
1950     game.future[evtype].date = game.state.date + offset
1951     return game.future[evtype]
1952
1953 def postpone(evtype, offset):
1954     "Postpone a scheduled event."
1955     game.future[evtype].date += offset
1956
1957 def cancelrest():
1958     "Rest period is interrupted by event."
1959     if game.resting:
1960         skip(1)
1961         proutn(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
1962         if ja():
1963             game.resting = False
1964             game.optime = 0.0
1965             return True
1966     return False
1967
1968 def events():
1969     "Run through the event queue looking for things to do."
1970     i=0
1971     fintim = game.state.date + game.optime; yank=0
1972     ictbeam = False; istract = False
1973     w = Coord(); hold = Coord()
1974     ev = Event(); ev2 = Event()
1975
1976     def tractorbeam(yank):
1977         "Tractor-beaming cases merge here."
1978         announce()
1979         game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5)
1980         skip(1)
1981         prout("***" + crmshp() + _(" caught in long range tractor beam--"))
1982         # If Kirk & Co. screwing around on planet, handle
1983         atover(True) # atover(true) is Grab
1984         if game.alldone:
1985             return
1986         if game.icraft: # Caught in Galileo?
1987             finish(FSTRACTOR)
1988             return
1989         # Check to see if shuttle is aboard
1990         if game.iscraft == "offship":
1991             skip(1)
1992             if withprob(0.5):
1993                 prout(_("Galileo, left on the planet surface, is captured"))
1994                 prout(_("by aliens and made into a flying McDonald's."))
1995                 game.damage[DSHUTTL] = -10
1996                 game.iscraft = "removed"
1997             else:
1998                 prout(_("Galileo, left on the planet surface, is well hidden."))
1999         if evcode == FSPY:
2000             game.quadrant = game.state.kscmdr
2001         else:
2002             game.quadrant = game.state.kcmdr[i]
2003         game.sector = randplace(QUADSIZE)
2004         prout(crmshp() + _(" is pulled to Quadrant %s, Sector %s") \
2005                % (game.quadrant, game.sector))
2006         if game.resting:
2007             prout(_("(Remainder of rest/repair period cancelled.)"))
2008             game.resting = False
2009         if not game.shldup:
2010             if not damaged(DSHIELD) and game.shield > 0:
2011                 doshield(shraise=True) # raise shields
2012                 game.shldchg = False
2013             else:
2014                 prout(_("(Shields not currently useable.)"))
2015         newqad()
2016         # Adjust finish time to time of tractor beaming
2017         fintim = game.state.date+game.optime
2018         attack(torps_ok=False)
2019         if not game.state.kcmdr:
2020             unschedule(FTBEAM)
2021         else:
2022             schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr)))
2023
2024     def destroybase():
2025         "Code merges here for any commander destroying a starbase."
2026         # Not perfect, but will have to do
2027         # Handle case where base is in same quadrant as starship
2028         if game.battle == game.quadrant:
2029             game.state.chart[game.battle.i][game.battle.j].starbase = False
2030             game.quad[game.base.i][game.base.j] = '.'
2031             game.base.invalidate()
2032             newcnd()
2033             skip(1)
2034             prout(_("Spock-  \"Captain, I believe the starbase has been destroyed.\""))
2035         elif game.state.baseq and communicating():
2036             # Get word via subspace radio
2037             announce()
2038             skip(1)
2039             prout(_("Lt. Uhura-  \"Captain, Starfleet Command reports that"))
2040             proutn(_("   the starbase in Quadrant %s has been destroyed by") % game.battle)
2041             if game.isatb == 2:
2042                 prout(_("the Klingon Super-Commander"))
2043             else:
2044                 prout(_("a Klingon Commander"))
2045             game.state.chart[game.battle.i][game.battle.j].starbase = False
2046         # Remove Starbase from galaxy
2047         game.state.galaxy[game.battle.i][game.battle.j].starbase = False
2048         game.state.baseq = filter(lambda x: x != game.battle, game.state.baseq)
2049         if game.isatb == 2:
2050             # reinstate a commander's base attack
2051             game.battle = hold
2052             game.isatb = 0
2053         else:
2054             game.battle.invalidate()
2055     if game.idebug:
2056         prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
2057         for i in range(1, NEVENTS):
2058             if   i == FSNOVA:  proutn("=== Supernova       ")
2059             elif i == FTBEAM:  proutn("=== T Beam          ")
2060             elif i == FSNAP:   proutn("=== Snapshot        ")
2061             elif i == FBATTAK: proutn("=== Base Attack     ")
2062             elif i == FCDBAS:  proutn("=== Base Destroy    ")
2063             elif i == FSCMOVE: proutn("=== SC Move         ")
2064             elif i == FSCDBAS: proutn("=== SC Base Destroy ")
2065             elif i == FDSPROB: proutn("=== Probe Move      ")
2066             elif i == FDISTR:  proutn("=== Distress Call   ")
2067             elif i == FENSLV:  proutn("=== Enslavement     ")
2068             elif i == FREPRO:  proutn("=== Klingon Build   ")
2069             if is_scheduled(i):
2070                 prout("%.2f" % (scheduled(i)))
2071             else:
2072                 prout("never")
2073     radio_was_broken = damaged(DRADIO)
2074     hold.i = hold.j = 0
2075     while True:
2076         # Select earliest extraneous event, evcode==0 if no events
2077         evcode = FSPY
2078         if game.alldone:
2079             return
2080         datemin = fintim
2081         for l in range(1, NEVENTS):
2082             if game.future[l].date < datemin:
2083                 evcode = l
2084                 if game.idebug:
2085                     prout("== Event %d fires" % evcode)
2086                 datemin = game.future[l].date
2087         xtime = datemin-game.state.date
2088         game.state.date = datemin
2089         # Decrement Federation resources and recompute remaining time
2090         game.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime
2091         game.recompute()
2092         if game.state.remtime <=0:
2093             finish(FDEPLETE)
2094             return
2095         # Any crew left alive?
2096         if game.state.crew <=0:
2097             finish(FCREW)
2098             return
2099         # Is life support adequate?
2100         if damaged(DLIFSUP) and game.condition != "docked":
2101             if game.lsupres < xtime and game.damage[DLIFSUP] > game.lsupres:
2102                 finish(FLIFESUP)
2103                 return
2104             game.lsupres -= xtime
2105             if game.damage[DLIFSUP] <= xtime:
2106                 game.lsupres = game.inlsr
2107         # Fix devices
2108         repair = xtime
2109         if game.condition == "docked":
2110             repair /= DOCKFAC
2111         # Don't fix Deathray here
2112         for l in range(NDEVICES):
2113             if game.damage[l] > 0.0 and l != DDRAY:
2114                 if game.damage[l]-repair > 0.0:
2115                     game.damage[l] -= repair
2116                 else:
2117                     game.damage[l] = 0.0
2118         # If radio repaired, update star chart and attack reports
2119         if radio_was_broken and not damaged(DRADIO):
2120             prout(_("Lt. Uhura- \"Captain, the sub-space radio is working and"))
2121             prout(_("   surveillance reports are coming in."))
2122             skip(1)
2123             if not game.iseenit:
2124                 attackreport(False)
2125                 game.iseenit = True
2126             rechart()
2127             prout(_("   The star chart is now up to date.\""))
2128             skip(1)
2129         # Cause extraneous event EVCODE to occur
2130         game.optime -= xtime
2131         if evcode == FSNOVA: # Supernova
2132             announce()
2133             supernova(None)
2134             schedule(FSNOVA, expran(0.5*game.intime))
2135             if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
2136                 return
2137         elif evcode == FSPY: # Check with spy to see if SC should tractor beam
2138             if game.state.nscrem == 0 or \
2139                 ictbeam or istract or \
2140                 game.condition=="docked" or game.isatb==1 or game.iscate:
2141                 return
2142             if game.ientesc or \
2143                 (game.energy<2000 and game.torps<4 and game.shield < 1250) or \
2144                 (damaged(DPHASER) and (damaged(DPHOTON) or game.torps<4)) or \
2145                 (damaged(DSHIELD) and \
2146                  (game.energy < 2500 or damaged(DPHASER)) and \
2147                  (game.torps < 5 or damaged(DPHOTON))):
2148                 # Tractor-beam her!
2149                 istract = ictbeam = True
2150                 tractorbeam((game.state.kscmdr-game.quadrant).distance())
2151             else:
2152                 return
2153         elif evcode == FTBEAM: # Tractor beam
2154             if not game.state.kcmdr:
2155                 unschedule(FTBEAM)
2156                 continue
2157             i = randrange(len(game.state.kcmdr))
2158             yank = (game.state.kcmdr[i]-game.quadrant).distance()
2159             if istract or game.condition == "docked" or yank == 0:
2160                 # Drats! Have to reschedule
2161                 schedule(FTBEAM,
2162                          game.optime + expran(1.5*game.intime/len(game.state.kcmdr)))
2163                 continue
2164             ictbeam = True
2165             tractorbeam(yank)
2166         elif evcode == FSNAP: # Snapshot of the universe (for time warp)
2167             game.snapsht = copy.deepcopy(game.state)
2168             game.state.snap = True
2169             schedule(FSNAP, expran(0.5 * game.intime))
2170         elif evcode == FBATTAK: # Commander attacks starbase
2171             if not game.state.kcmdr or not game.state.baseq:
2172                 # no can do
2173                 unschedule(FBATTAK)
2174                 unschedule(FCDBAS)
2175                 continue
2176             try:
2177                 for ibq in game.state.baseq:
2178                    for cmdr in game.state.kcmdr:
2179                        if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
2180                            raise JumpOut
2181                 else:
2182                     # no match found -- try later
2183                     schedule(FBATTAK, expran(0.3*game.intime))
2184                     unschedule(FCDBAS)
2185                     continue
2186             except JumpOut:
2187                 pass
2188             # commander + starbase combination found -- launch attack
2189             game.battle = ibq
2190             schedule(FCDBAS, randreal(1.0, 4.0))
2191             if game.isatb: # extra time if SC already attacking
2192                 postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date)
2193             game.future[FBATTAK].date = game.future[FCDBAS].date + expran(0.3*game.intime)
2194             game.iseenit = False
2195             if not communicating():
2196                 continue # No warning :-(
2197             game.iseenit = True
2198             announce()
2199             skip(1)
2200             prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") % game.battle)
2201             prout(_("   reports that it is under attack and that it can"))
2202             prout(_("   hold out only until stardate %d.\"") % (int(scheduled(FCDBAS))))
2203             if cancelrest():
2204                 return
2205         elif evcode == FSCDBAS: # Supercommander destroys base
2206             unschedule(FSCDBAS)
2207             game.isatb = 2
2208             if not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].starbase:
2209                 continue # WAS RETURN!
2210             hold = game.battle
2211             game.battle = game.state.kscmdr
2212             destroybase()
2213         elif evcode == FCDBAS: # Commander succeeds in destroying base
2214             if evcode==FCDBAS:
2215                 unschedule(FCDBAS)
2216                 if not game.state.baseq() \
2217                        or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
2218                     game.battle.invalidate()
2219                     continue
2220                 # find the lucky pair
2221                 for cmdr in game.state.kcmdr:
2222                     if cmdr == game.battle:
2223                         break
2224                 else:
2225                     # No action to take after all
2226                     continue
2227             destroybase()
2228         elif evcode == FSCMOVE: # Supercommander moves
2229             schedule(FSCMOVE, 0.2777)
2230             if not game.ientesc and not istract and game.isatb != 1 and \
2231                    (not game.iscate or not game.justin):
2232                 supercommander()
2233         elif evcode == FDSPROB: # Move deep space probe
2234             schedule(FDSPROB, 0.01)
2235             if not game.probe.next():
2236                 if not game.probe.quadrant().valid_quadrant() or \
2237                     game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova:
2238                     # Left galaxy or ran into supernova
2239                     if communicating():
2240                         announce()
2241                         skip(1)
2242                         proutn(_("Lt. Uhura-  \"The deep space probe "))
2243                         if not game.probe.quadrant().valid_quadrant():
2244                             prout(_("has left the galaxy.\""))
2245                         else:
2246                             prout(_("is no longer transmitting.\""))
2247                     unschedule(FDSPROB)
2248                     continue
2249                 if communicating():
2250                     #announce()
2251                     skip(1)
2252                     prout(_("Lt. Uhura-  \"The deep space probe is now in Quadrant %s.\"") % game.probe.quadrant())
2253             pdest = game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j]
2254             if communicating():
2255                 chp = game.state.chart[game.probe.quadrant().i][game.probe.quadrant().j]
2256                 chp.klingons = pdest.klingons
2257                 chp.starbase = pdest.starbase
2258                 chp.stars = pdest.stars
2259                 pdest.charted = True
2260             game.probe.moves -= 1 # One less to travel
2261             if game.probe.arrived() and game.isarmed and pdest.stars:
2262                 supernova(game.probe)           # fire in the hole!
2263                 unschedule(FDSPROB)
2264                 if game.state.galaxy[game.quadrant().i][game.quadrant().j].supernova:
2265                     return
2266         elif evcode == FDISTR: # inhabited system issues distress call
2267             unschedule(FDISTR)
2268             # try a whole bunch of times to find something suitable
2269             for i in range(100):
2270                 # need a quadrant which is not the current one,
2271                 # which has some stars which are inhabited and
2272                 # not already under attack, which is not
2273                 # supernova'ed, and which has some Klingons in it
2274                 w = randplace(GALSIZE)
2275                 q = game.state.galaxy[w.i][w.j]
2276                 if not (game.quadrant == w or q.planet == None or \
2277                       not q.planet.inhabited or \
2278                       q.supernova or q.status!="secure" or q.klingons<=0):
2279                     break
2280             else:
2281                 # can't seem to find one; ignore this call
2282                 if game.idebug:
2283                     prout("=== Couldn't find location for distress event.")
2284                 continue
2285             # got one!!  Schedule its enslavement
2286             ev = schedule(FENSLV, expran(game.intime))
2287             ev.quadrant = w
2288             q.status = "distressed"
2289             # tell the captain about it if we can
2290             if communicating():
2291                 prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \
2292                         % (q.planet, `w`))
2293                 prout(_("by a Klingon invasion fleet."))
2294                 if cancelrest():
2295                     return
2296         elif evcode == FENSLV:          # starsystem is enslaved
2297             ev = unschedule(FENSLV)
2298             # see if current distress call still active
2299             q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
2300             if q.klingons <= 0:
2301                 q.status = "secure"
2302                 continue
2303             q.status = "enslaved"
2304
2305             # play stork and schedule the first baby
2306             ev2 = schedule(FREPRO, expran(2.0 * game.intime))
2307             ev2.quadrant = ev.quadrant
2308
2309             # report the disaster if we can
2310             if communicating():
2311                 prout(_("Uhura- We've lost contact with starsystem %s") % \
2312                         q.planet)
2313                 prout(_("in Quadrant %s.\n") % ev.quadrant)
2314         elif evcode == FREPRO:          # Klingon reproduces
2315             # If we ever switch to a real event queue, we'll need to
2316             # explicitly retrieve and restore the x and y.
2317             ev = schedule(FREPRO, expran(1.0 * game.intime))
2318             # see if current distress call still active
2319             q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
2320             if q.klingons <= 0:
2321                 q.status = "secure"
2322                 continue
2323             if game.state.remkl >=MAXKLGAME:
2324                 continue                # full right now
2325             # reproduce one Klingon
2326             w = ev.quadrant
2327             m = Coord()
2328             if game.klhere >= MAXKLQUAD:
2329                 try:
2330                     # this quadrant not ok, pick an adjacent one
2331                     for m.i in range(w.i - 1, w.i + 2):
2332                         for m.j in range(w.j - 1, w.j + 2):
2333                             if not m.valid_quadrant():
2334                                 continue
2335                             q = game.state.galaxy[m.i][m.j]
2336                             # check for this quad ok (not full & no snova)
2337                             if q.klingons >= MAXKLQUAD or q.supernova:
2338                                 continue
2339                             raise JumpOut
2340                     else:
2341                         continue        # search for eligible quadrant failed
2342                 except JumpOut:
2343                     w = m
2344             # deliver the child
2345             game.state.remkl += 1
2346             q.klingons += 1
2347             if game.quadrant == w:
2348                 game.klhere += 1
2349                 game.enemies.append(newkling())
2350             # recompute time left
2351             game.recompute()
2352             if communicating():
2353                 if game.quadrant == w:
2354                     prout(_("Spock- sensors indicate the Klingons have"))
2355                     prout(_("launched a warship from %s.") % q.planet)
2356                 else:
2357                     prout(_("Uhura- Starfleet reports increased Klingon activity"))
2358                     if q.planet != None:
2359                         proutn(_("near %s ") % q.planet)
2360                     prout(_("in Quadrant %s.") % w)
2361
2362 def wait():
2363     "Wait on events."
2364     game.ididit = False
2365     while True:
2366         key = scanner.next()
2367         if key  != "IHEOL":
2368             break
2369         proutn(_("How long? "))
2370     scanner.chew()
2371     if key != "IHREAL":
2372         huh()
2373         return
2374     origTime = delay = scanner.real
2375     if delay <= 0.0:
2376         return
2377     if delay >= game.state.remtime or len(game.enemies) != 0:
2378         proutn(_("Are you sure? "))
2379         if not ja():
2380             return
2381     # Alternate resting periods (events) with attacks
2382     game.resting = True
2383     while True:
2384         if delay <= 0:
2385             game.resting = False
2386         if not game.resting:
2387             prout(_("%d stardates left.") % int(game.state.remtime))
2388             return
2389         temp = game.optime = delay
2390         if len(game.enemies):
2391             rtime = randreal(1.0, 2.0)
2392             if rtime < temp:
2393                 temp = rtime
2394             game.optime = temp
2395         if game.optime < delay:
2396             attack(torps_ok=False)
2397         if game.alldone:
2398             return
2399         events()
2400         game.ididit = True
2401         if game.alldone:
2402             return
2403         delay -= temp
2404         # Repair Deathray if long rest at starbase
2405         if origTime-delay >= 9.99 and game.condition == "docked":
2406             game.damage[DDRAY] = 0.0
2407         # leave if quadrant supernovas
2408         if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
2409             break
2410     game.resting = False
2411     game.optime = 0
2412
2413 def nova(nov):
2414     "Star goes nova."
2415     ncourse = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
2416     newc = Coord(); neighbor = Coord(); bump = Coord(0, 0)
2417     if withprob(0.05):
2418         # Wow! We've supernova'ed
2419         supernova(game.quadrant)
2420         return
2421     # handle initial nova
2422     game.quad[nov.i][nov.j] = '.'
2423     prout(crmena(False, '*', "sector", nov) + _(" novas."))
2424     game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
2425     game.state.starkl += 1
2426     # Set up queue to recursively trigger adjacent stars
2427     hits = [nov]
2428     kount = 0
2429     while hits:
2430         offset = Coord()
2431         start = hits.pop()
2432         for offset.i in range(-1, 1+1):
2433             for offset.j in range(-1, 1+1):
2434                 if offset.j==0 and offset.i==0:
2435                     continue
2436                 neighbor = start + offset
2437                 if not neighbor.valid_sector():
2438                     continue
2439                 iquad = game.quad[neighbor.i][neighbor.j]
2440                 # Empty space ends reaction
2441                 if iquad in ('.', '?', ' ', 'T', '#'):
2442                     pass
2443                 elif iquad == '*': # Affect another star
2444                     if withprob(0.05):
2445                         # This star supernovas
2446                         supernova(game.quadrant)
2447                         return
2448                     else:
2449                         hits.append(neighbor)
2450                         game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
2451                         game.state.starkl += 1
2452                         proutn(crmena(True, '*', "sector", neighbor))
2453                         prout(_(" novas."))
2454                         game.quad[neighbor.i][neighbor.j] = '.'
2455                         kount += 1
2456                 elif iquad in ('P', '@'): # Destroy planet
2457                     game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
2458                     if iquad == 'P':
2459                         game.state.nplankl += 1
2460                     else:
2461                         game.state.worldkl += 1
2462                     prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
2463                     game.iplnet.pclass = "destroyed"
2464                     game.iplnet = None
2465                     game.plnet.invalidate()
2466                     if game.landed:
2467                         finish(FPNOVA)
2468                         return
2469                     game.quad[neighbor.i][neighbor.j] = '.'
2470                 elif iquad == 'B': # Destroy base
2471                     game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase = False
2472                     game.state.baseq = filter(lambda x: x!= game.quadrant, game.state.baseq)
2473                     game.base.invalidate()
2474                     game.state.basekl += 1
2475                     newcnd()
2476                     prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
2477                     game.quad[neighbor.i][neighbor.j] = '.'
2478                 elif iquad in ('E', 'F'): # Buffet ship
2479                     prout(_("***Starship buffeted by nova."))
2480                     if game.shldup:
2481                         if game.shield >= 2000.0:
2482                             game.shield -= 2000.0
2483                         else:
2484                             diff = 2000.0 - game.shield
2485                             game.energy -= diff
2486                             game.shield = 0.0
2487                             game.shldup = False
2488                             prout(_("***Shields knocked out."))
2489                             game.damage[DSHIELD] += 0.005*game.damfac*randreal()*diff
2490                     else:
2491                         game.energy -= 2000.0
2492                     if game.energy <= 0:
2493                         finish(FNOVA)
2494                         return
2495                     # add in course nova contributes to kicking starship
2496                     bump += (game.sector-hits[-1]).sgn()
2497                 elif iquad == 'K': # kill klingon
2498                     deadkl(neighbor, iquad, neighbor)
2499                 elif iquad in ('C','S','R'): # Damage/destroy big enemies
2500                     for ll in range(len(game.enemies)):
2501                         if game.enemies[ll].location == neighbor:
2502                             break
2503                     game.enemies[ll].power -= 800.0 # If firepower is lost, die
2504                     if game.enemies[ll].power <= 0.0:
2505                         deadkl(neighbor, iquad, neighbor)
2506                         break
2507                     newc = neighbor + neighbor - hits[-1]
2508                     proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
2509                     if not newc.valid_sector():
2510                         # can't leave quadrant
2511                         skip(1)
2512                         break
2513                     iquad1 = game.quad[newc.i][newc.j]
2514                     if iquad1 == ' ':
2515                         proutn(_(", blasted into ") + crmena(False, ' ', "sector", newc))
2516                         skip(1)
2517                         deadkl(neighbor, iquad, newc)
2518                         break
2519                     if iquad1 != '.':
2520                         # can't move into something else
2521                         skip(1)
2522                         break
2523                     proutn(_(", buffeted to Sector %s") % newc)
2524                     game.quad[neighbor.i][neighbor.j] = '.'
2525                     game.quad[newc.i][newc.j] = iquad
2526                     game.enemies[ll].move(newc)
2527     # Starship affected by nova -- kick it away.
2528     dist = kount*0.1
2529     direc = ncourse[3*(bump.i+1)+bump.j+2]
2530     if direc == 0.0:
2531         dist = 0.0
2532     if dist == 0.0:
2533         return
2534     scourse = course(bearing=direc, distance=dist)
2535     game.optime = scourse.time(warp=4)
2536     skip(1)
2537     prout(_("Force of nova displaces starship."))
2538     imove(scourse, noattack=True)
2539     game.optime = scourse.time(warp=4)
2540     return
2541
2542 def supernova(w):
2543     "Star goes supernova."
2544     num = 0; npdead = 0
2545     if w != None:
2546         nq = copy.copy(w)
2547     else:
2548         # Scheduled supernova -- select star at random.
2549         stars = 0
2550         nq = Coord()
2551         for nq.i in range(GALSIZE):
2552             for nq.j in range(GALSIZE):
2553                 stars += game.state.galaxy[nq.i][nq.j].stars
2554         if stars == 0:
2555             return # nothing to supernova exists
2556         num = randrange(stars) + 1
2557         for nq.i in range(GALSIZE):
2558             for nq.j in range(GALSIZE):
2559                 num -= game.state.galaxy[nq.i][nq.j].stars
2560                 if num <= 0:
2561                     break
2562             if num <=0:
2563                 break
2564         if game.idebug:
2565             proutn("=== Super nova here?")
2566             if ja():
2567                 nq = game.quadrant
2568     if not nq == game.quadrant or game.justin:
2569         # it isn't here, or we just entered (treat as enroute)
2570         if communicating():
2571             skip(1)
2572             prout(_("Message from Starfleet Command       Stardate %.2f") % game.state.date)
2573             prout(_("     Supernova in Quadrant %s; caution advised.") % nq)
2574     else:
2575         ns = Coord()
2576         # we are in the quadrant!
2577         num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
2578         for ns.i in range(QUADSIZE):
2579             for ns.j in range(QUADSIZE):
2580                 if game.quad[ns.i][ns.j]=='*':
2581                     num -= 1
2582                     if num==0:
2583                         break
2584             if num==0:
2585                 break
2586         skip(1)
2587         prouts(_("***RED ALERT!  RED ALERT!"))
2588         skip(1)
2589         prout(_("***Incipient supernova detected at Sector %s") % ns)
2590         if (ns.i-game.sector.i)**2 + (ns.j-game.sector.j)**2 <= 2.1:
2591             proutn(_("Emergency override attempts t"))
2592             prouts("***************")
2593             skip(1)
2594             stars()
2595             game.alldone = True
2596     # destroy any Klingons in supernovaed quadrant
2597     kldead = game.state.galaxy[nq.i][nq.j].klingons
2598     game.state.galaxy[nq.i][nq.j].klingons = 0
2599     if nq == game.state.kscmdr:
2600         # did in the Supercommander!
2601         game.state.nscrem = game.state.kscmdr.i = game.state.kscmdr.j = game.isatb =  0
2602         game.iscate = False
2603         unschedule(FSCMOVE)
2604         unschedule(FSCDBAS)
2605     survivors = filter(lambda w: w != nq, game.state.kcmdr)
2606     comkills = len(game.state.kcmdr) - len(survivors)
2607     game.state.kcmdr = survivors
2608     kldead -= comkills
2609     if not game.state.kcmdr:
2610         unschedule(FTBEAM)
2611     game.state.remkl -= kldead
2612     # destroy Romulans and planets in supernovaed quadrant
2613     nrmdead = game.state.galaxy[nq.i][nq.j].romulans
2614     game.state.galaxy[nq.i][nq.j].romulans = 0
2615     game.state.nromrem -= nrmdead
2616     # Destroy planets
2617     for loop in range(game.inplan):
2618         if game.state.planets[loop].quadrant == nq:
2619             game.state.planets[loop].pclass = "destroyed"
2620             npdead += 1
2621     # Destroy any base in supernovaed quadrant
2622     game.state.baseq = filter(lambda x: x != nq, game.state.baseq)
2623     # If starship caused supernova, tally up destruction
2624     if w != None:
2625         game.state.starkl += game.state.galaxy[nq.i][nq.j].stars
2626         game.state.basekl += game.state.galaxy[nq.i][nq.j].starbase
2627         game.state.nplankl += npdead
2628     # mark supernova in galaxy and in star chart
2629     if game.quadrant == nq or communicating():
2630         game.state.galaxy[nq.i][nq.j].supernova = True
2631     # If supernova destroys last Klingons give special message
2632     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0 and not nq == game.quadrant:
2633         skip(2)
2634         if w == None:
2635             prout(_("Lucky you!"))
2636         proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq)
2637         finish(FWON)
2638         return
2639     # if some Klingons remain, continue or die in supernova
2640     if game.alldone:
2641         finish(FSNOVAED)
2642     return
2643
2644 # Code from finish.c ends here.
2645
2646 def selfdestruct():
2647     "Self-destruct maneuver. Finish with a BANG!"
2648     scanner.chew()
2649     if damaged(DCOMPTR):
2650         prout(_("Computer damaged; cannot execute destruct sequence."))
2651         return
2652     prouts(_("---WORKING---")); skip(1)
2653     prouts(_("SELF-DESTRUCT-SEQUENCE-ACTIVATED")); skip(1)
2654     prouts("   10"); skip(1)
2655     prouts("       9"); skip(1)
2656     prouts("          8"); skip(1)
2657     prouts("             7"); skip(1)
2658     prouts("                6"); skip(1)
2659     skip(1)
2660     prout(_("ENTER-CORRECT-PASSWORD-TO-CONTINUE-"))
2661     skip(1)
2662     prout(_("SELF-DESTRUCT-SEQUENCE-OTHERWISE-"))
2663     skip(1)
2664     prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED"))
2665     skip(1)
2666     scanner.next()
2667     scanner.chew()
2668     if game.passwd != scanner.token:
2669         prouts(_("PASSWORD-REJECTED;"))
2670         skip(1)
2671         prouts(_("CONTINUITY-EFFECTED"))
2672         skip(2)
2673         return
2674     prouts(_("PASSWORD-ACCEPTED")); skip(1)
2675     prouts("                   5"); skip(1)
2676     prouts("                      4"); skip(1)
2677     prouts("                         3"); skip(1)
2678     prouts("                            2"); skip(1)
2679     prouts("                              1"); skip(1)
2680     if withprob(0.15):
2681         prouts(_("GOODBYE-CRUEL-WORLD"))
2682         skip(1)
2683     kaboom()
2684
2685 def kaboom():
2686     stars()
2687     if game.ship=='E':
2688         prouts("***")
2689     prouts(_("********* Entropy of %s maximized *********") % crmshp())
2690     skip(1)
2691     stars()
2692     skip(1)
2693     if len(game.enemies) != 0:
2694         whammo = 25.0 * game.energy
2695         for l in range(len(game.enemies)):
2696             if game.enemies[l].power*game.enemies[l].kdist <= whammo:
2697                 deadkl(game.enemies[l].location, game.quad[game.enemies[l].location.i][game.enemies[l].location.j], game.enemies[l].location)
2698     finish(FDILITHIUM)
2699
2700 def killrate():
2701     "Compute our rate of kils over time."
2702     elapsed = game.state.date - game.indate
2703     if elapsed == 0:    # Avoid divide-by-zero error if calculated on turn 0
2704         return 0
2705     else:
2706         starting = (game.inkling + game.incom + game.inscom)
2707         remaining = (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)
2708         return (starting - remaining)/elapsed
2709
2710 def badpoints():
2711     "Compute demerits."
2712     badpt = 5.0*game.state.starkl + \
2713             game.casual + \
2714             10.0*game.state.nplankl + \
2715             300*game.state.nworldkl + \
2716             45.0*game.nhelp +\
2717             100.0*game.state.basekl +\
2718             3.0*game.abandoned
2719     if game.ship == 'F':
2720         badpt += 100.0
2721     elif game.ship == None:
2722         badpt += 200.0
2723     return badpt
2724
2725 def finish(ifin):
2726     # end the game, with appropriate notfications
2727     igotit = False
2728     game.alldone = True
2729     skip(3)
2730     prout(_("It is stardate %.1f.") % game.state.date)
2731     skip(1)
2732     if ifin == FWON: # Game has been won
2733         if game.state.nromrem != 0:
2734             prout(_("The remaining %d Romulans surrender to Starfleet Command.") %
2735                   game.state.nromrem)
2736
2737         prout(_("You have smashed the Klingon invasion fleet and saved"))
2738         prout(_("the Federation."))
2739         game.gamewon = True
2740         if game.alive:
2741             badpt = badpoints()
2742             if badpt < 100.0:
2743                 badpt = 0.0     # Close enough!
2744             # killsPerDate >= RateMax
2745             if game.state.date-game.indate < 5.0 or \
2746                 killrate() >= 0.1*game.skill*(game.skill+1.0) + 0.1 + 0.008*badpt:
2747                 skip(1)
2748                 prout(_("In fact, you have done so well that Starfleet Command"))
2749                 if game.skill == SKILL_NOVICE:
2750                     prout(_("promotes you one step in rank from \"Novice\" to \"Fair\"."))
2751                 elif game.skill == SKILL_FAIR:
2752                     prout(_("promotes you one step in rank from \"Fair\" to \"Good\"."))
2753                 elif game.skill == SKILL_GOOD:
2754                     prout(_("promotes you one step in rank from \"Good\" to \"Expert\"."))
2755                 elif game.skill == SKILL_EXPERT:
2756                     prout(_("promotes you to Commodore Emeritus."))
2757                     skip(1)
2758                     prout(_("Now that you think you're really good, try playing"))
2759                     prout(_("the \"Emeritus\" game. It will splatter your ego."))
2760                 elif game.skill == SKILL_EMERITUS:
2761                     skip(1)
2762                     proutn(_("Computer-  "))
2763                     prouts(_("ERROR-ERROR-ERROR-ERROR"))
2764                     skip(2)
2765                     prouts(_("  YOUR-SKILL-HAS-EXCEEDED-THE-CAPACITY-OF-THIS-PROGRAM"))
2766                     skip(1)
2767                     prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
2768                     skip(1)
2769                     prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
2770                     skip(1)
2771                     prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
2772                     skip(1)
2773                     prouts(_("  THIS-PROGRAM-MUST?- MUST ? - SUR? ? -?  VI"))
2774                     skip(2)
2775                     prout(_("Now you can retire and write your own Star Trek game!"))
2776                     skip(1)
2777                 elif game.skill >= SKILL_EXPERT:
2778                     if game.thawed and not game.idebug:
2779                         prout(_("You cannot get a citation, so..."))
2780                     else:
2781                         proutn(_("Do you want your Commodore Emeritus Citation printed? "))
2782                         scanner.chew()
2783                         if ja():
2784                             igotit = True
2785             # Only grant long life if alive (original didn't!)
2786             skip(1)
2787             prout(_("LIVE LONG AND PROSPER."))
2788         score()
2789         if igotit:
2790             plaque()
2791         return
2792     elif ifin == FDEPLETE: # Federation Resources Depleted
2793         prout(_("Your time has run out and the Federation has been"))
2794         prout(_("conquered.  Your starship is now Klingon property,"))
2795         prout(_("and you are put on trial as a war criminal.  On the"))
2796         proutn(_("basis of your record, you are "))
2797         if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom):
2798             prout(_("acquitted."))
2799             skip(1)
2800             prout(_("LIVE LONG AND PROSPER."))
2801         else:
2802             prout(_("found guilty and"))
2803             prout(_("sentenced to death by slow torture."))
2804             game.alive = False
2805         score()
2806         return
2807     elif ifin == FLIFESUP:
2808         prout(_("Your life support reserves have run out, and"))
2809         prout(_("you die of thirst, starvation, and asphyxiation."))
2810         prout(_("Your starship is a derelict in space."))
2811     elif ifin == FNRG:
2812         prout(_("Your energy supply is exhausted."))
2813         skip(1)
2814         prout(_("Your starship is a derelict in space."))
2815     elif ifin == FBATTLE:
2816         prout(_("The %s has been destroyed in battle.") % crmshp())
2817         skip(1)
2818         prout(_("Dulce et decorum est pro patria mori."))
2819     elif ifin == FNEG3:
2820         prout(_("You have made three attempts to cross the negative energy"))
2821         prout(_("barrier which surrounds the galaxy."))
2822         skip(1)
2823         prout(_("Your navigation is abominable."))
2824         score()
2825     elif ifin == FNOVA:
2826         prout(_("Your starship has been destroyed by a nova."))
2827         prout(_("That was a great shot."))
2828         skip(1)
2829     elif ifin == FSNOVAED:
2830         prout(_("The %s has been fried by a supernova.") % crmshp())
2831         prout(_("...Not even cinders remain..."))
2832     elif ifin == FABANDN:
2833         prout(_("You have been captured by the Klingons. If you still"))
2834         prout(_("had a starbase to be returned to, you would have been"))
2835         prout(_("repatriated and given another chance. Since you have"))
2836         prout(_("no starbases, you will be mercilessly tortured to death."))
2837     elif ifin == FDILITHIUM:
2838         prout(_("Your starship is now an expanding cloud of subatomic particles"))
2839     elif ifin == FMATERIALIZE:
2840         prout(_("Starbase was unable to re-materialize your starship."))
2841         prout(_("Sic transit gloria mundi"))
2842     elif ifin == FPHASER:
2843         prout(_("The %s has been cremated by its own phasers.") % crmshp())
2844     elif ifin == FLOST:
2845         prout(_("You and your landing party have been"))
2846         prout(_("converted to energy, disipating through space."))
2847     elif ifin == FMINING:
2848         prout(_("You are left with your landing party on"))
2849         prout(_("a wild jungle planet inhabited by primitive cannibals."))
2850         skip(1)
2851         prout(_("They are very fond of \"Captain Kirk\" soup."))
2852         skip(1)
2853         prout(_("Without your leadership, the %s is destroyed.") % crmshp())
2854     elif ifin == FDPLANET:
2855         prout(_("You and your mining party perish."))
2856         skip(1)
2857         prout(_("That was a great shot."))
2858         skip(1)
2859     elif ifin == FSSC:
2860         prout(_("The Galileo is instantly annihilated by the supernova."))
2861         prout(_("You and your mining party are atomized."))
2862         skip(1)
2863         prout(_("Mr. Spock takes command of the %s and") % crmshp())
2864         prout(_("joins the Romulans, wreaking terror on the Federation."))
2865     elif ifin == FPNOVA:
2866         prout(_("You and your mining party are atomized."))
2867         skip(1)
2868         prout(_("Mr. Spock takes command of the %s and") % crmshp())
2869         prout(_("joins the Romulans, wreaking terror on the Federation."))
2870     elif ifin == FSTRACTOR:
2871         prout(_("The shuttle craft Galileo is also caught,"))
2872         prout(_("and breaks up under the strain."))
2873         skip(1)
2874         prout(_("Your debris is scattered for millions of miles."))
2875         prout(_("Without your leadership, the %s is destroyed.") % crmshp())
2876     elif ifin == FDRAY:
2877         prout(_("The mutants attack and kill Spock."))
2878         prout(_("Your ship is captured by Klingons, and"))
2879         prout(_("your crew is put on display in a Klingon zoo."))
2880     elif ifin == FTRIBBLE:
2881         prout(_("Tribbles consume all remaining water,"))
2882         prout(_("food, and oxygen on your ship."))
2883         skip(1)
2884         prout(_("You die of thirst, starvation, and asphyxiation."))
2885         prout(_("Your starship is a derelict in space."))
2886     elif ifin == FHOLE:
2887         prout(_("Your ship is drawn to the center of the black hole."))
2888         prout(_("You are crushed into extremely dense matter."))
2889     elif ifin == FCREW:
2890         prout(_("Your last crew member has died."))
2891     if game.ship == 'F':
2892         game.ship = None
2893     elif game.ship == 'E':
2894         game.ship = 'F'
2895     game.alive = False
2896     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
2897         goodies = game.state.remres/game.inresor
2898         baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom)
2899         if goodies/baddies >= randreal(1.0, 1.5):
2900             prout(_("As a result of your actions, a treaty with the Klingon"))
2901             prout(_("Empire has been signed. The terms of the treaty are"))
2902             if goodies/baddies >= randreal(3.0):
2903                 prout(_("favorable to the Federation."))
2904                 skip(1)
2905                 prout(_("Congratulations!"))
2906             else:
2907                 prout(_("highly unfavorable to the Federation."))
2908         else:
2909             prout(_("The Federation will be destroyed."))
2910     else:
2911         prout(_("Since you took the last Klingon with you, you are a"))
2912         prout(_("martyr and a hero. Someday maybe they'll erect a"))
2913         prout(_("statue in your memory. Rest in peace, and try not"))
2914         prout(_("to think about pigeons."))
2915         game.gamewon = True
2916     score()
2917
2918 def score():
2919     "Compute player's score."
2920     timused = game.state.date - game.indate
2921     if (timused == 0 or (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0:
2922         timused = 5.0
2923     game.perdate = killrate()
2924     ithperd = 500*game.perdate + 0.5
2925     iwon = 0
2926     if game.gamewon:
2927         iwon = 100*game.skill
2928     if game.ship == 'E':
2929         klship = 0
2930     elif game.ship == 'F':
2931         klship = 1
2932     else:
2933         klship = 2
2934     game.score = 10*(game.inkling - game.state.remkl) \
2935              + 50*(game.incom - len(game.state.kcmdr)) \
2936              + ithperd + iwon \
2937              + 20*(game.inrom - game.state.nromrem) \
2938              + 200*(game.inscom - game.state.nscrem) \
2939              - game.state.nromrem \
2940              - badpoints()
2941     if not game.alive:
2942         game.score -= 200
2943     skip(2)
2944     prout(_("Your score --"))
2945     if game.inrom - game.state.nromrem:
2946         prout(_("%6d Romulans destroyed                 %5d") %
2947               (game.inrom - game.state.nromrem, 20*(game.inrom - game.state.nromrem)))
2948     if game.state.nromrem and game.gamewon:
2949         prout(_("%6d Romulans captured                  %5d") %
2950               (game.state.nromrem, game.state.nromrem))
2951     if game.inkling - game.state.remkl:
2952         prout(_("%6d ordinary Klingons destroyed        %5d") %
2953               (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl)))
2954     if game.incom - len(game.state.kcmdr):
2955         prout(_("%6d Klingon commanders destroyed       %5d") %
2956               (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr))))
2957     if game.inscom - game.state.nscrem:
2958         prout(_("%6d Super-Commander destroyed          %5d") %
2959               (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
2960     if ithperd:
2961         prout(_("%6.2f Klingons per stardate              %5d") %
2962               (game.perdate, ithperd))
2963     if game.state.starkl:
2964         prout(_("%6d stars destroyed by your action     %5d") %
2965               (game.state.starkl, -5*game.state.starkl))
2966     if game.state.nplankl:
2967         prout(_("%6d planets destroyed by your action   %5d") %
2968               (game.state.nplankl, -10*game.state.nplankl))
2969     if (game.options & OPTION_WORLDS) and game.state.nworldkl:
2970         prout(_("%6d inhabited planets destroyed by your action   %5d") %
2971               (game.state.nworldkl, -300*game.state.nworldkl))
2972     if game.state.basekl:
2973         prout(_("%6d bases destroyed by your action     %5d") %
2974               (game.state.basekl, -100*game.state.basekl))
2975     if game.nhelp:
2976         prout(_("%6d calls for help from starbase       %5d") %
2977               (game.nhelp, -45*game.nhelp))
2978     if game.casual:
2979         prout(_("%6d casualties incurred                %5d") %
2980               (game.casual, -game.casual))
2981     if game.abandoned:
2982         prout(_("%6d crew abandoned in space            %5d") %
2983               (game.abandoned, -3*game.abandoned))
2984     if klship:
2985         prout(_("%6d ship(s) lost or destroyed          %5d") %
2986               (klship, -100*klship))
2987     if not game.alive:
2988         prout(_("Penalty for getting yourself killed        -200"))
2989     if game.gamewon:
2990         proutn(_("Bonus for winning "))
2991         if game.skill   == SKILL_NOVICE:        proutn(_("Novice game  "))
2992         elif game.skill == SKILL_FAIR:          proutn(_("Fair game    "))
2993         elif game.skill ==  SKILL_GOOD:         proutn(_("Good game    "))
2994         elif game.skill ==  SKILL_EXPERT:       proutn(_("Expert game  "))
2995         elif game.skill ==  SKILL_EMERITUS:     proutn(_("Emeritus game"))
2996         prout("           %5d" % iwon)
2997     skip(1)
2998     prout(_("TOTAL SCORE                               %5d") % game.score)
2999
3000 def plaque():
3001     "Emit winner's commemmorative plaque."
3002     skip(2)
3003     while True:
3004         proutn(_("File or device name for your plaque: "))
3005         winner = cgetline()
3006         try:
3007             fp = open(winner, "w")
3008             break
3009         except IOError:
3010             prout(_("Invalid name."))
3011
3012     proutn(_("Enter name to go on plaque (up to 30 characters): "))
3013     winner = cgetline()
3014     # The 38 below must be 64 for 132-column paper
3015     nskip = 38 - len(winner)/2
3016     fp.write("\n\n\n\n")
3017     # --------DRAW ENTERPRISE PICTURE.
3018     fp.write("                                       EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n" )
3019     fp.write("                                      EEE                      E  : :                                         :  E\n" )
3020     fp.write("                                    EE   EEE                   E  : :                   NCC-1701              :  E\n")
3021     fp.write("EEEEEEEEEEEEEEEE        EEEEEEEEEEEEEEE  : :                              : E\n")
3022     fp.write(" E                                     EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n")
3023     fp.write("                      EEEEEEEEE               EEEEEEEEEEEEE                 E  E\n")
3024     fp.write("                               EEEEEEE   EEEEE    E          E              E  E\n")
3025     fp.write("                                      EEE           E          E            E  E\n")
3026     fp.write("                                                       E         E          E  E\n")
3027     fp.write("                                                         EEEEEEEEEEEEE      E  E\n")
3028     fp.write("                                                      EEE :           EEEEEEE  EEEEEEEE\n")
3029     fp.write("                                                    :E    :                 EEEE       E\n")
3030     fp.write("                                                   .-E   -:-----                       E\n")
3031     fp.write("                                                    :E    :                            E\n")
3032     fp.write("                                                      EE  :                    EEEEEEEE\n")
3033     fp.write("                                                       EEEEEEEEEEEEEEEEEEEEEEE\n")
3034     fp.write("\n\n\n")
3035     fp.write(_("                                                       U. S. S. ENTERPRISE\n"))
3036     fp.write("\n\n\n\n")
3037     fp.write(_("                                  For demonstrating outstanding ability as a starship captain\n"))
3038     fp.write("\n")
3039     fp.write(_("                                                Starfleet Command bestows to you\n"))
3040     fp.write("\n")
3041     fp.write("%*s%s\n\n" % (nskip, "", winner))
3042     fp.write(_("                                                           the rank of\n\n"))
3043     fp.write(_("                                                       \"Commodore Emeritus\"\n\n"))
3044     fp.write("                                                          ")
3045     if game.skill ==  SKILL_EXPERT:
3046         fp.write(_(" Expert level\n\n"))
3047     elif game.skill == SKILL_EMERITUS:
3048         fp.write(_("Emeritus level\n\n"))
3049     else:
3050         fp.write(_(" Cheat level\n\n"))
3051     timestring = time.ctime()
3052     fp.write(_("                                                 This day of %.6s %.4s, %.8s\n\n") %
3053                     (timestring+4, timestring+20, timestring+11))
3054     fp.write(_("                                                        Your score:  %d\n\n") % game.score)
3055     fp.write(_("                                                    Klingons per stardate:  %.2f\n") % game.perdate)
3056     fp.close()
3057
3058 # Code from io.c begins here
3059
3060 rows = linecount = 0    # for paging
3061 stdscr = None
3062 replayfp = None
3063 fullscreen_window = None
3064 srscan_window     = None
3065 report_window     = None
3066 status_window     = None
3067 lrscan_window     = None
3068 message_window    = None
3069 prompt_window     = None
3070 curwnd = None
3071
3072 def iostart():
3073     global stdscr, rows
3074     "for some recent versions of python2, the following enables UTF8"
3075     "for the older ones we probably need to set C locale, and the python3"
3076     "has no problems at all"
3077     if sys.version_info[0] < 3:
3078         import locale
3079         locale.setlocale(locale.LC_ALL, "")
3080     gettext.bindtextdomain("sst", "/usr/local/share/locale")
3081     gettext.textdomain("sst")
3082     if not (game.options & OPTION_CURSES):
3083         ln_env = os.getenv("LINES")
3084         if ln_env:
3085             rows = ln_env
3086         else:
3087             rows = 25
3088     else:
3089         stdscr = curses.initscr()
3090         stdscr.keypad(True)
3091         curses.nonl()
3092         curses.cbreak()
3093         if game.options & OPTION_COLOR:
3094             curses.start_color();
3095             curses.use_default_colors()
3096             curses.init_pair(curses.COLOR_BLACK,   curses.COLOR_BLACK, -1);
3097             curses.init_pair(curses.COLOR_GREEN,   curses.COLOR_GREEN, -1);
3098             curses.init_pair(curses.COLOR_RED,     curses.COLOR_RED, -1);
3099             curses.init_pair(curses.COLOR_CYAN,    curses.COLOR_CYAN, -1);
3100             curses.init_pair(curses.COLOR_WHITE,   curses.COLOR_WHITE, -1);
3101             curses.init_pair(curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, -1);
3102             curses.init_pair(curses.COLOR_BLUE,    curses.COLOR_BLUE, -1);
3103             curses.init_pair(curses.COLOR_YELLOW,  curses.COLOR_YELLOW, -1);
3104         global fullscreen_window, srscan_window, report_window, status_window
3105         global lrscan_window, message_window, prompt_window
3106         (rows, columns)   = stdscr.getmaxyx()
3107         fullscreen_window = stdscr
3108         srscan_window     = curses.newwin(12, 25, 0,       0)
3109         report_window     = curses.newwin(11, 0,  1,       25)
3110         status_window     = curses.newwin(10, 0,  1,       39)
3111         lrscan_window     = curses.newwin(5,  0,  0,       64)
3112         message_window    = curses.newwin(0,  0,  12,      0)
3113         prompt_window     = curses.newwin(1,  0,  rows-2,  0)
3114         message_window.scrollok(True)
3115         setwnd(fullscreen_window)
3116
3117 def ioend():
3118     "Wrap up I/O."
3119     if game.options & OPTION_CURSES:
3120         stdscr.keypad(False)
3121         curses.echo()
3122         curses.nocbreak()
3123         curses.endwin()
3124
3125 def waitfor():
3126     "Wait for user action -- OK to do nothing if on a TTY"
3127     if game.options & OPTION_CURSES:
3128         stdscr.getch()
3129
3130 def announce():
3131     skip(1)
3132     prouts(_("[ANNOUNCEMENT ARRIVING...]"))
3133     skip(1)
3134
3135 def pause_game():
3136     if game.skill > SKILL_FAIR:
3137         prompt = _("[CONTINUE?]")
3138     else:
3139         prompt = _("[PRESS ENTER TO CONTINUE]")
3140
3141     if game.options & OPTION_CURSES:
3142         drawmaps(0)
3143         setwnd(prompt_window)
3144         prompt_window.clear()
3145         prompt_window.addstr(prompt)
3146         prompt_window.getstr()
3147         prompt_window.clear()
3148         prompt_window.refresh()
3149         setwnd(message_window)
3150     else:
3151         global linecount
3152         sys.stdout.write('\n')
3153         proutn(prompt)
3154         raw_input()
3155         sys.stdout.write('\n' * rows)
3156         linecount = 0
3157
3158 def skip(i):
3159     "Skip i lines.  Pause game if this would cause a scrolling event."
3160     for dummy in range(i):
3161         if game.options & OPTION_CURSES:
3162             (y, x) = curwnd.getyx()
3163             try:
3164                 curwnd.move(y+1, 0)
3165             except curses.error:
3166                 pass
3167         else:
3168             global linecount
3169             linecount += 1
3170             if rows and linecount >= rows:
3171                 pause_game()
3172             else:
3173                 sys.stdout.write('\n')
3174
3175 def proutn(line):
3176     "Utter a line with no following line feed."
3177     if game.options & OPTION_CURSES:
3178         (y, x) = curwnd.getyx()
3179         (my, mx) = curwnd.getmaxyx()
3180         if curwnd == message_window and y >= my - 2:
3181             pause_game()
3182             clrscr()
3183         curwnd.addstr(line)
3184         curwnd.refresh()
3185     else:
3186         sys.stdout.write(line)
3187         sys.stdout.flush()
3188
3189 def prout(line):
3190     proutn(line)
3191     skip(1)
3192
3193 def prouts(line):
3194     "Emit slowly!"
3195     for c in line:
3196         if not replayfp or replayfp.closed:     # Don't slow down replays
3197             time.sleep(0.03)
3198         proutn(c)
3199         if game.options & OPTION_CURSES:
3200             curwnd.refresh()
3201         else:
3202             sys.stdout.flush()
3203     if not replayfp or replayfp.closed:
3204         time.sleep(0.03)
3205
3206 def cgetline():
3207     "Get a line of input."
3208     if game.options & OPTION_CURSES:
3209         line = curwnd.getstr() + "\n"
3210         curwnd.refresh()
3211     else:
3212         if replayfp and not replayfp.closed:
3213             while True:
3214                 line = replayfp.readline()
3215                 proutn(line)
3216                 if line == '':
3217                     prout("*** Replay finished")
3218                     replayfp.close()
3219                     break
3220                 elif line[0] != "#":
3221                     break
3222         else:
3223             line = raw_input() + "\n"
3224     if logfp:
3225         logfp.write(line)
3226     return line
3227
3228 def setwnd(wnd):
3229     "Change windows -- OK for this to be a no-op in tty mode."
3230     global curwnd
3231     if game.options & OPTION_CURSES:
3232         curwnd = wnd
3233         curses.curs_set(wnd == fullscreen_window or wnd == message_window or wnd == prompt_window)
3234
3235 def clreol():
3236     "Clear to end of line -- can be a no-op in tty mode"
3237     if game.options & OPTION_CURSES:
3238         curwnd.clrtoeol()
3239         curwnd.refresh()
3240
3241 def clrscr():
3242     "Clear screen -- can be a no-op in tty mode."
3243     global linecount
3244     if game.options & OPTION_CURSES:
3245        curwnd.clear()
3246        curwnd.move(0, 0)
3247        curwnd.refresh()
3248     linecount = 0
3249
3250 def textcolor(color=DEFAULT):
3251     if game.options & OPTION_COLOR:
3252         if color == DEFAULT:
3253             curwnd.attrset(0);
3254         elif color ==  BLACK:
3255             curwnd.attron(curses.color_pair(curses.COLOR_BLACK));
3256         elif color ==  BLUE:
3257             curwnd.attron(curses.color_pair(curses.COLOR_BLUE));
3258         elif color ==  GREEN:
3259             curwnd.attron(curses.color_pair(curses.COLOR_GREEN));
3260         elif color ==  CYAN:
3261             curwnd.attron(curses.color_pair(curses.COLOR_CYAN));
3262         elif color ==  RED:
3263             curwnd.attron(curses.color_pair(curses.COLOR_RED));
3264         elif color ==  MAGENTA:
3265             curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA));
3266         elif color ==  BROWN:
3267             curwnd.attron(curses.color_pair(curses.COLOR_YELLOW));
3268         elif color ==  LIGHTGRAY:
3269             curwnd.attron(curses.color_pair(curses.COLOR_WHITE));
3270         elif color ==  DARKGRAY:
3271             curwnd.attron(curses.color_pair(curses.COLOR_BLACK) | curses.A_BOLD);
3272         elif color ==  LIGHTBLUE:
3273             curwnd.attron(curses.color_pair(curses.COLOR_BLUE) | curses.A_BOLD);
3274         elif color ==  LIGHTGREEN:
3275             curwnd.attron(curses.color_pair(curses.COLOR_GREEN) | curses.A_BOLD);
3276         elif color ==  LIGHTCYAN:
3277             curwnd.attron(curses.color_pair(curses.COLOR_CYAN) | curses.A_BOLD);
3278         elif color ==  LIGHTRED:
3279             curwnd.attron(curses.color_pair(curses.COLOR_RED) | curses.A_BOLD);
3280         elif color ==  LIGHTMAGENTA:
3281             curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA) | curses.A_BOLD);
3282         elif color ==  YELLOW:
3283             curwnd.attron(curses.color_pair(curses.COLOR_YELLOW) | curses.A_BOLD);
3284         elif color ==  WHITE:
3285             curwnd.attron(curses.color_pair(curses.COLOR_WHITE) | curses.A_BOLD);
3286
3287 def highvideo():
3288     if game.options & OPTION_COLOR:
3289         curwnd.attron(curses.A_REVERSE)
3290
3291 #
3292 # Things past this point have policy implications.
3293 #
3294
3295 def drawmaps(mode):
3296     "Hook to be called after moving to redraw maps."
3297     if game.options & OPTION_CURSES:
3298         if mode == 1:
3299             sensor()
3300         setwnd(srscan_window)
3301         curwnd.move(0, 0)
3302         srscan()
3303         if mode != 2:
3304             setwnd(status_window)
3305             status_window.clear()
3306             status_window.move(0, 0)
3307             setwnd(report_window)
3308             report_window.clear()
3309             report_window.move(0, 0)
3310             status()
3311             setwnd(lrscan_window)
3312             lrscan_window.clear()
3313             lrscan_window.move(0, 0)
3314             lrscan(silent=False)
3315
3316 def put_srscan_sym(w, sym):
3317     "Emit symbol for short-range scan."
3318     srscan_window.move(w.i+1, w.j*2+2)
3319     srscan_window.addch(sym)
3320     srscan_window.refresh()
3321
3322 def boom(w):
3323     "Enemy fall down, go boom."
3324     if game.options & OPTION_CURSES:
3325         drawmaps(2)
3326         setwnd(srscan_window)
3327         srscan_window.attron(curses.A_REVERSE)
3328         put_srscan_sym(w, game.quad[w.i][w.j])
3329         #sound(500)
3330         #time.sleep(1.0)
3331         #nosound()
3332         srscan_window.attroff(curses.A_REVERSE)
3333         put_srscan_sym(w, game.quad[w.i][w.j])
3334         curses.delay_output(500)
3335         setwnd(message_window)
3336
3337 def warble():
3338     "Sound and visual effects for teleportation."
3339     if game.options & OPTION_CURSES:
3340         drawmaps(2)
3341         setwnd(message_window)
3342         #sound(50)
3343     prouts("     . . . . .     ")
3344     if game.options & OPTION_CURSES:
3345         #curses.delay_output(1000)
3346         #nosound()
3347         pass
3348
3349 def tracktorpedo(w, step, i, n, iquad):
3350     "Torpedo-track animation."
3351     if not game.options & OPTION_CURSES:
3352         if step == 1:
3353             if n != 1:
3354                 skip(1)
3355                 proutn(_("Track for torpedo number %d-  ") % (i+1))
3356             else:
3357                 skip(1)
3358                 proutn(_("Torpedo track- "))
3359         elif step==4 or step==9:
3360             skip(1)
3361         proutn("%s   " % w)
3362     else:
3363         if not damaged(DSRSENS) or game.condition=="docked":
3364             if i != 0 and step == 1:
3365                 drawmaps(2)
3366                 time.sleep(0.4)
3367             if (iquad=='.') or (iquad==' '):
3368                 put_srscan_sym(w, '+')
3369                 #sound(step*10)
3370                 #time.sleep(0.1)
3371                 #nosound()
3372                 put_srscan_sym(w, iquad)
3373             else:
3374                 curwnd.attron(curses.A_REVERSE)
3375                 put_srscan_sym(w, iquad)
3376                 #sound(500)
3377                 #time.sleep(1.0)
3378                 #nosound()
3379                 curwnd.attroff(curses.A_REVERSE)
3380                 put_srscan_sym(w, iquad)
3381         else:
3382             proutn("%s   " % w)
3383
3384 def makechart():
3385     "Display the current galaxy chart."
3386     if game.options & OPTION_CURSES:
3387         setwnd(message_window)
3388         message_window.clear()
3389     chart()
3390     if game.options & OPTION_TTY:
3391         skip(1)
3392
3393 NSYM    = 14
3394
3395 def prstat(txt, data):
3396     proutn(txt)
3397     if game.options & OPTION_CURSES:
3398         skip(1)
3399         setwnd(status_window)
3400     else:
3401         proutn(" " * (NSYM - len(txt)))
3402     proutn(data)
3403     skip(1)
3404     if game.options & OPTION_CURSES:
3405         setwnd(report_window)
3406
3407 # Code from moving.c begins here
3408
3409 def imove(icourse=None, noattack=False):
3410     "Movement execution for warp, impulse, supernova, and tractor-beam events."
3411     w = Coord()
3412
3413     def newquadrant(noattack):
3414         # Leaving quadrant -- allow final enemy attack
3415         # Don't do it if being pushed by Nova
3416         if len(game.enemies) != 0 and not noattack:
3417             newcnd()
3418             for enemy in game.enemies:
3419                 finald = (w - enemy.location).distance()
3420                 enemy.kavgd = 0.5 * (finald + enemy.kdist)
3421             # Stas Sergeev added the condition
3422             # that attacks only happen if Klingons
3423             # are present and your skill is good.
3424             if game.skill > SKILL_GOOD and game.klhere > 0 and not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
3425                 attack(torps_ok=False)
3426             if game.alldone:
3427                 return
3428         # check for edge of galaxy
3429         kinks = 0
3430         while True:
3431             kink = False
3432             if icourse.final.i < 0:
3433                 icourse.final.i = -icourse.final.i
3434                 kink = True
3435             if icourse.final.j < 0:
3436                 icourse.final.j = -icourse.final.j
3437                 kink = True
3438             if icourse.final.i >= GALSIZE*QUADSIZE:
3439                 icourse.final.i = (GALSIZE*QUADSIZE*2) - icourse.final.i
3440                 kink = True
3441             if icourse.final.j >= GALSIZE*QUADSIZE:
3442                 icourse.final.j = (GALSIZE*QUADSIZE*2) - icourse.final.j
3443                 kink = True
3444             if kink:
3445                 kinks += 1
3446             else:
3447                 break
3448         if kinks:
3449             game.nkinks += 1
3450             if game.nkinks == 3:
3451                 # Three strikes -- you're out!
3452                 finish(FNEG3)
3453                 return
3454             skip(1)
3455             prout(_("YOU HAVE ATTEMPTED TO CROSS THE NEGATIVE ENERGY BARRIER"))
3456             prout(_("AT THE EDGE OF THE GALAXY.  THE THIRD TIME YOU TRY THIS,"))
3457             prout(_("YOU WILL BE DESTROYED."))
3458         # Compute final position in new quadrant
3459         if trbeam: # Don't bother if we are to be beamed
3460             return
3461         game.quadrant = icourse.final.quadrant()
3462         game.sector = icourse.final.sector()
3463         skip(1)
3464         prout(_("Entering Quadrant %s.") % game.quadrant)
3465         game.quad[game.sector.i][game.sector.j] = game.ship
3466         newqad()
3467         if game.skill>SKILL_NOVICE:
3468             attack(torps_ok=False)
3469
3470     def check_collision(h):
3471         iquad = game.quad[h.i][h.j]
3472         if iquad != '.':
3473             # object encountered in flight path
3474             stopegy = 50.0*icourse.distance/game.optime
3475             if iquad in ('T', 'K', 'C', 'S', 'R', '?'):
3476                 for enemy in game.enemies:
3477                     if enemy.location == game.sector:
3478                         break
3479                 collision(rammed=False, enemy=enemy)
3480                 return True
3481             elif iquad == ' ':
3482                 skip(1)
3483                 prouts(_("***RED ALERT!  RED ALERT!"))
3484                 skip(1)
3485                 proutn("***" + crmshp())
3486                 proutn(_(" pulled into black hole at Sector %s") % h)
3487                 # Getting pulled into a black hole was certain
3488                 # death in Almy's original.  Stas Sergeev added a
3489                 # possibility that you'll get timewarped instead.
3490                 n=0
3491                 for m in range(NDEVICES):
3492                     if game.damage[m]>0:
3493                         n += 1
3494                 probf=math.pow(1.4,(game.energy+game.shield)/5000.0-1.0)*math.pow(1.3,1.0/(n+1)-1.0)
3495                 if (game.options & OPTION_BLKHOLE) and withprob(1-probf):
3496                     timwrp()
3497                 else:
3498                     finish(FHOLE)
3499                 return True
3500             else:
3501                 # something else
3502                 skip(1)
3503                 proutn(crmshp())
3504                 if iquad == '#':
3505                     prout(_(" encounters Tholian web at %s;") % h)
3506                 else:
3507                     prout(_(" blocked by object at %s;") % h)
3508                 proutn(_("Emergency stop required "))
3509                 prout(_("%2d units of energy.") % int(stopegy))
3510                 game.energy -= stopegy
3511                 if game.energy <= 0:
3512                     finish(FNRG)
3513                 return True
3514         return False
3515
3516     trbeam = False
3517     if game.inorbit:
3518         prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
3519         game.inorbit = False
3520     # If tractor beam is to occur, don't move full distance
3521     if game.state.date+game.optime >= scheduled(FTBEAM):
3522         trbeam = True
3523         game.condition = "red"
3524         icourse.distance = icourse.distance*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1
3525         game.optime = scheduled(FTBEAM) - game.state.date + 1e-5
3526     # Move out
3527     game.quad[game.sector.i][game.sector.j] = '.'
3528     for m in range(icourse.moves):
3529         icourse.next()
3530         w = icourse.sector()
3531         if icourse.origin.quadrant() != icourse.location.quadrant():
3532             newquadrant(noattack)
3533             break
3534         elif check_collision(icourse, w):
3535             print "Collision detected"
3536             break
3537         else:
3538             game.sector = w
3539     # We're in destination quadrant -- compute new average enemy distances
3540     game.quad[game.sector.i][game.sector.j] = game.ship
3541     if game.enemies:
3542         for enemy in game.enemies:
3543             finald = (w-enemy.location).distance()
3544             enemy.kavgd = 0.5 * (finald + enemy.kdist)
3545             enemy.kdist = finald
3546         sortenemies()
3547         if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
3548             attack(torps_ok=False)
3549         for enemy in game.enemies:
3550             enemy.kavgd = enemy.kdist
3551     newcnd()
3552     drawmaps(0)
3553     setwnd(message_window)
3554     return
3555
3556 def dock(verbose):
3557     "Dock our ship at a starbase."
3558     scanner.chew()
3559     if game.condition == "docked" and verbose:
3560         prout(_("Already docked."))
3561         return
3562     if game.inorbit:
3563         prout(_("You must first leave standard orbit."))
3564         return
3565     if not game.base.is_valid() or abs(game.sector.i-game.base.i) > 1 or abs(game.sector.j-game.base.j) > 1:
3566         prout(crmshp() + _(" not adjacent to base."))
3567         return
3568     game.condition = "docked"
3569     if "verbose":
3570         prout(_("Docked."))
3571     game.ididit = True
3572     if game.energy < game.inenrg:
3573         game.energy = game.inenrg
3574     game.shield = game.inshld
3575     game.torps = game.intorps
3576     game.lsupres = game.inlsr
3577     game.state.crew = FULLCREW
3578     if not damaged(DRADIO) and \
3579         ((is_scheduled(FCDBAS) or game.isatb == 1) and not game.iseenit):
3580         # get attack report from base
3581         prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\""))
3582         attackreport(False)
3583         game.iseenit = True
3584
3585 def cartesian(loc1=None, loc2=None):
3586     if loc1 is None:
3587         return game.quadrant * QUADSIZE + game.sector
3588     elif loc2 is None:
3589         return game.quadrant * QUADSIZE + loc1
3590     else:
3591         return loc1 * QUADSIZE + loc2
3592
3593 def getcourse(isprobe):
3594     "Get a course and distance from the user."
3595     key = 0
3596     dquad = copy.copy(game.quadrant)
3597     navmode = "unspecified"
3598     itemp = "curt"
3599     dsect = Coord()
3600     iprompt = False
3601     if game.landed and not isprobe:
3602         prout(_("Dummy! You can't leave standard orbit until you"))
3603         proutn(_("are back aboard the ship."))
3604         scanner.chew()
3605         raise TrekError
3606     while navmode == "unspecified":
3607         if damaged(DNAVSYS):
3608             if isprobe:
3609                 prout(_("Computer damaged; manual navigation only"))
3610             else:
3611                 prout(_("Computer damaged; manual movement only"))
3612             scanner.chew()
3613             navmode = "manual"
3614             key = "IHEOL"
3615             break
3616         key = scanner.next()
3617         if key == "IHEOL":
3618             proutn(_("Manual or automatic- "))
3619             iprompt = True
3620             scanner.chew()
3621         elif key == "IHALPHA":
3622             if scanner.sees("manual"):
3623                 navmode = "manual"
3624                 key = scanner.next()
3625                 break
3626             elif scanner.sees("automatic"):
3627                 navmode = "automatic"
3628                 key = scanner.next()
3629                 break
3630             else:
3631                 huh()
3632                 scanner.chew()
3633                 raise TrekError
3634         else: # numeric
3635             if isprobe:
3636                 prout(_("(Manual navigation assumed.)"))
3637             else:
3638                 prout(_("(Manual movement assumed.)"))
3639             navmode = "manual"
3640             break
3641     delta = Coord()
3642     if navmode == "automatic":
3643         while key == "IHEOL":
3644             if isprobe:
3645                 proutn(_("Target quadrant or quadrant&sector- "))
3646             else:
3647                 proutn(_("Destination sector or quadrant&sector- "))
3648             scanner.chew()
3649             iprompt = True
3650             key = scanner.next()
3651         if key != "IHREAL":
3652             huh()
3653             raise TrekError
3654         xi = int(round(scanner.real))-1
3655         key = scanner.next()
3656         if key != "IHREAL":
3657             huh()
3658             raise TrekError
3659         xj = int(round(scanner.real))-1
3660         key = scanner.next()
3661         if key == "IHREAL":
3662             # both quadrant and sector specified
3663             xk = int(round(scanner.real))-1
3664             key = scanner.next()
3665             if key != "IHREAL":
3666                 huh()
3667                 raise TrekError
3668             xl = int(round(scanner.real))-1
3669             dquad.i = xi
3670             dquad.j = xj
3671             dsect.i = xk
3672             dsect.j = xl
3673         else:
3674             # only one pair of numbers was specified
3675             if isprobe:
3676                 # only quadrant specified -- go to center of dest quad
3677                 dquad.i = xi
3678                 dquad.j = xj
3679                 dsect.j = dsect.i = 4   # preserves 1-origin behavior
3680             else:
3681                 # only sector specified
3682                 dsect.i = xi
3683                 dsect.j = xj
3684             itemp = "normal"
3685         if not dquad.valid_quadrant() or not dsect.valid_sector():
3686             huh()
3687             raise TrekError
3688         skip(1)
3689         if not isprobe:
3690             if itemp > "curt":
3691                 if iprompt:
3692                     prout(_("Helmsman Sulu- \"Course locked in for Sector %s.\"") % dsect)
3693             else:
3694                 prout(_("Ensign Chekov- \"Course laid in, Captain.\""))
3695         # the actual deltas get computed here
3696         delta.j = dquad.j-game.quadrant.j + (dsect.j-game.sector.j)/(QUADSIZE*1.0)
3697         delta.i = game.quadrant.i-dquad.i + (game.sector.i-dsect.i)/(QUADSIZE*1.0)
3698     else: # manual
3699         while key == "IHEOL":
3700             proutn(_("X and Y displacements- "))
3701             scanner.chew()
3702             iprompt = True
3703             key = scanner.next()
3704         itemp = "verbose"
3705         if key != "IHREAL":
3706             huh()
3707             raise TrekError
3708         delta.j = scanner.real
3709         key = scanner.next()
3710         if key != "IHREAL":
3711             huh()
3712             raise TrekError
3713         delta.i = scanner.real
3714     # Check for zero movement
3715     if delta.i == 0 and delta.j == 0:
3716         scanner.chew()
3717         raise TrekError
3718     if itemp == "verbose" and not isprobe:
3719         skip(1)
3720         prout(_("Helmsman Sulu- \"Aye, Sir.\""))
3721     scanner.chew()
3722     return course(bearing=delta.bearing(), distance=delta.distance())
3723
3724 class course:
3725     def __init__(self, bearing, distance, origin=None):
3726         self.distance = distance
3727         self.bearing = bearing
3728         if origin is None:
3729             self.origin = cartesian(game.quadrant, game.sector)
3730         else:
3731             self.origin = origin
3732         # The bearing() code we inherited from FORTRAN is actually computing
3733         # clockface directions!
3734         if self.bearing < 0.0:
3735             self.bearing += 12.0
3736         self.angle = ((15.0 - self.bearing) * 0.5235988)
3737         if origin is None:
3738             self.origin = cartesian(game.quadrant, game.sector)
3739         else:
3740             self.origin = cartesian(game.quadrant, origin)
3741         self.increment = Coord(-math.sin(self.angle), math.cos(self.angle))
3742         bigger = max(abs(self.increment.i), abs(self.increment.j))
3743         self.increment /= bigger
3744         self.moves = int(round(10*self.distance*bigger))
3745         self.reset()
3746         self.final = (self.location + self.moves*self.increment).roundtogrid()
3747     def reset(self):
3748         self.location = self.origin
3749         self.step = 0
3750     def arrived(self):
3751         return self.location.roundtogrid() == self.final
3752     def next(self):
3753         "Next step on course."
3754         self.step += 1
3755         self.nextlocation = self.location + self.increment
3756         samequad = (self.location.quadrant() == self.nextlocation.quadrant())
3757         self.location = self.nextlocation
3758         return samequad
3759     def quadrant(self):
3760         return self.location.quadrant()
3761     def sector(self):
3762         return self.location.sector()
3763     def power(self, warp):
3764         return self.distance*(warp**3)*(game.shldup+1)
3765     def time(self, warp):
3766         return 10.0*self.distance/warp**2
3767
3768 def impulse():
3769     "Move under impulse power."
3770     game.ididit = False
3771     if damaged(DIMPULS):
3772         scanner.chew()
3773         skip(1)
3774         prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\""))
3775         return
3776     if game.energy > 30.0:
3777         try:
3778             course = getcourse(isprobe=False)
3779         except TrekError:
3780             return
3781         power = 20.0 + 100.0*course.distance
3782     else:
3783         power = 30.0
3784     if power >= game.energy:
3785         # Insufficient power for trip
3786         skip(1)
3787         prout(_("First Officer Spock- \"Captain, the impulse engines"))
3788         prout(_("require 20.0 units to engage, plus 100.0 units per"))
3789         if game.energy > 30:
3790             proutn(_("quadrant.  We can go, therefore, a maximum of %d") %
3791                      int(0.01 * (game.energy-20.0)-0.05))
3792             prout(_(" quadrants.\""))
3793         else:
3794             prout(_("quadrant.  They are, therefore, useless.\""))
3795         scanner.chew()
3796         return
3797     # Make sure enough time is left for the trip
3798     game.optime = course.dist/0.095
3799     if game.optime >= game.state.remtime:
3800         prout(_("First Officer Spock- \"Captain, our speed under impulse"))
3801         prout(_("power is only 0.95 sectors per stardate. Are you sure"))
3802         proutn(_("we dare spend the time?\" "))
3803         if not ja():
3804             return
3805     # Activate impulse engines and pay the cost
3806     imove(course, noattack=False)
3807     game.ididit = True
3808     if game.alldone:
3809         return
3810     power = 20.0 + 100.0*course.dist
3811     game.energy -= power
3812     game.optime = course.dist/0.095
3813     if game.energy <= 0:
3814         finish(FNRG)
3815     return
3816
3817 def warp(wcourse, involuntary):
3818     "ove under warp drive."
3819     blooey = False; twarp = False
3820     if not involuntary: # Not WARPX entry
3821         game.ididit = False
3822         if game.damage[DWARPEN] > 10.0:
3823             scanner.chew()
3824             skip(1)
3825             prout(_("Engineer Scott- \"The warp engines are damaged, Sir.\""))
3826             return
3827         if damaged(DWARPEN) and game.warpfac > 4.0:
3828             scanner.chew()
3829             skip(1)
3830             prout(_("Engineer Scott- \"Sorry, Captain. Until this damage"))
3831             prout(_("  is repaired, I can only give you warp 4.\""))
3832             return
3833         # Read in course and distance
3834         if wcourse==None:
3835             try:
3836                 wcourse = getcourse(isprobe=False)
3837             except TrekError:
3838                 return
3839         # Make sure starship has enough energy for the trip
3840         # Note: this formula is slightly different from the C version,
3841         # and lets you skate a bit closer to the edge.
3842         if wcourse.power(game.warpfac) >= game.energy:
3843             # Insufficient power for trip
3844             game.ididit = False
3845             skip(1)
3846             prout(_("Engineering to bridge--"))
3847             if not game.shldup or 0.5*wcourse.power(game.warpfac) > game.energy:
3848                 iwarp = (game.energy/(wcourse.dist+0.05)) ** 0.333333333
3849                 if iwarp <= 0:
3850                     prout(_("We can't do it, Captain. We don't have enough energy."))
3851                 else:
3852                     proutn(_("We don't have enough energy, but we could do it at warp %d") % iwarp)
3853                     if game.shldup:
3854                         prout(",")
3855                         prout(_("if you'll lower the shields."))
3856                     else:
3857                         prout(".")
3858             else:
3859                 prout(_("We haven't the energy to go that far with the shields up."))
3860             return
3861         # Make sure enough time is left for the trip
3862         game.optime = wcourse.time(game.warpfac)
3863         if game.optime >= 0.8*game.state.remtime:
3864             skip(1)
3865             prout(_("First Officer Spock- \"Captain, I compute that such"))
3866             proutn(_("  a trip would require approximately %2.0f") %
3867                    (100.0*game.optime/game.state.remtime))
3868             prout(_(" percent of our"))
3869             proutn(_("  remaining time.  Are you sure this is wise?\" "))
3870             if not ja():
3871                 game.ididit = False
3872                 game.optime=0
3873                 return
3874     # Entry WARPX
3875     if game.warpfac > 6.0:
3876         # Decide if engine damage will occur
3877         # ESR: Seems wrong. Probability of damage goes *down* with distance?
3878         prob = wcourse.distance*(6.0-game.warpfac)**2/66.666666666
3879         if prob > randreal():
3880             blooey = True
3881             wcourse.distance = randreal(wcourse.distance)
3882         # Decide if time warp will occur
3883         if 0.5*wcourse.distance*math.pow(7.0,game.warpfac-10.0) > randreal():
3884             twarp = True
3885         if game.idebug and game.warpfac==10 and not twarp:
3886             blooey = False
3887             proutn("=== Force time warp? ")
3888             if ja():
3889                 twarp = True
3890         if blooey or twarp:
3891             # If time warp or engine damage, check path
3892             # If it is obstructed, don't do warp or damage
3893             look = wcourse.moves
3894             while look > 0:
3895                 look -= 1
3896                 wcourse.next()
3897                 w = wcourse.sector()
3898                 if not w.valid_sector():
3899                     break
3900                 if game.quad[w.i][w.j] != '.':
3901                     blooey = False
3902                     twarp = False
3903             wcourse.reset()
3904     # Activate Warp Engines and pay the cost
3905     imove(course, noattack=False)
3906     if game.alldone:
3907         return
3908     game.energy -= wcourse.power(game.warpfac)
3909     if game.energy <= 0:
3910         finish(FNRG)
3911     game.optime = wcourse.time(game.warpfac)
3912     if twarp:
3913         timwrp()
3914     if blooey:
3915         game.damage[DWARPEN] = game.damfac * randreal(1.0, 4.0)
3916         skip(1)
3917         prout(_("Engineering to bridge--"))
3918         prout(_("  Scott here.  The warp engines are damaged."))
3919         prout(_("  We'll have to reduce speed to warp 4."))
3920     game.ididit = True
3921     return
3922
3923 def setwarp():
3924     "Change the warp factor."
3925     while True:
3926         key=scanner.next()
3927         if key != "IHEOL":
3928             break
3929         scanner.chew()
3930         proutn(_("Warp factor- "))
3931     if key != "IHREAL":
3932         huh()
3933         return
3934     if game.damage[DWARPEN] > 10.0:
3935         prout(_("Warp engines inoperative."))
3936         return
3937     if damaged(DWARPEN) and scanner.real > 4.0:
3938         prout(_("Engineer Scott- \"I'm doing my best, Captain,"))
3939         prout(_("  but right now we can only go warp 4.\""))
3940         return
3941     if scanner.real > 10.0:
3942         prout(_("Helmsman Sulu- \"Our top speed is warp 10, Captain.\""))
3943         return
3944     if scanner.real < 1.0:
3945         prout(_("Helmsman Sulu- \"We can't go below warp 1, Captain.\""))
3946         return
3947     oldfac = game.warpfac
3948     game.warpfac = scanner.real
3949     if game.warpfac <= oldfac or game.warpfac <= 6.0:
3950         prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") %
3951                int(game.warpfac))
3952         return
3953     if game.warpfac < 8.00:
3954         prout(_("Engineer Scott- \"Aye, but our maximum safe speed is warp 6.\""))
3955         return
3956     if game.warpfac == 10.0:
3957         prout(_("Engineer Scott- \"Aye, Captain, we'll try it.\""))
3958         return
3959     prout(_("Engineer Scott- \"Aye, Captain, but our engines may not take it.\""))
3960     return
3961
3962 def atover(igrab):
3963     "Cope with being tossed out of quadrant by supernova or yanked by beam."
3964     scanner.chew()
3965     # is captain on planet?
3966     if game.landed:
3967         if damaged(DTRANSP):
3968             finish(FPNOVA)
3969             return
3970         prout(_("Scotty rushes to the transporter controls."))
3971         if game.shldup:
3972             prout(_("But with the shields up it's hopeless."))
3973             finish(FPNOVA)
3974         prouts(_("His desperate attempt to rescue you . . ."))
3975         if withprob(0.5):
3976             prout(_("fails."))
3977             finish(FPNOVA)
3978             return
3979         prout(_("SUCCEEDS!"))
3980         if game.imine:
3981             game.imine = False
3982             proutn(_("The crystals mined were "))
3983             if withprob(0.25):
3984                 prout(_("lost."))
3985             else:
3986                 prout(_("saved."))
3987                 game.icrystl = True
3988     if igrab:
3989         return
3990     # Check to see if captain in shuttle craft
3991     if game.icraft:
3992         finish(FSTRACTOR)
3993     if game.alldone:
3994         return
3995     # Inform captain of attempt to reach safety
3996     skip(1)
3997     while True:
3998         if game.justin:
3999             prouts(_("***RED ALERT!  RED ALERT!"))
4000             skip(1)
4001             proutn(_("The %s has stopped in a quadrant containing") % crmshp())
4002             prouts(_("   a supernova."))
4003             skip(2)
4004         prout(_("***Emergency automatic override attempts to hurl ")+crmshp())
4005         prout(_("safely out of quadrant."))
4006         if not damaged(DRADIO):
4007             game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True
4008         # Try to use warp engines
4009         if damaged(DWARPEN):
4010             skip(1)
4011             prout(_("Warp engines damaged."))
4012             finish(FSNOVAED)
4013             return
4014         game.warpfac = randreal(6.0, 8.0)
4015         prout(_("Warp factor set to %d") % int(game.warpfac))
4016         power = 0.75*game.energy
4017         dist = power/(game.warpfac*game.warpfac*game.warpfac*(game.shldup+1))
4018         dist = max(dist, randreal(math.sqrt(2)))
4019         bugout = course(bearing=randreal(12), distance=dist)    # How dumb!
4020         game.optime = bugout.time(game.warpfac)
4021         game.justin = False
4022         game.inorbit = False
4023         warp(bugout, involuntary=True)
4024         if not game.justin:
4025             # This is bad news, we didn't leave quadrant.
4026             if game.alldone:
4027                 return
4028             skip(1)
4029             prout(_("Insufficient energy to leave quadrant."))
4030             finish(FSNOVAED)
4031             return
4032         # Repeat if another snova
4033         if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
4034             break
4035     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
4036         finish(FWON) # Snova killed remaining enemy.
4037
4038 def timwrp():
4039     "Let's do the time warp again."
4040     prout(_("***TIME WARP ENTERED."))
4041     if game.state.snap and withprob(0.5):
4042         # Go back in time
4043         prout(_("You are traveling backwards in time %d stardates.") %
4044               int(game.state.date-game.snapsht.date))
4045         game.state = game.snapsht
4046         game.state.snap = False
4047         if len(game.state.kcmdr):
4048             schedule(FTBEAM, expran(game.intime/len(game.state.kcmdr)))
4049             schedule(FBATTAK, expran(0.3*game.intime))
4050         schedule(FSNOVA, expran(0.5*game.intime))
4051         # next snapshot will be sooner
4052         schedule(FSNAP, expran(0.25*game.state.remtime))
4053
4054         if game.state.nscrem:
4055             schedule(FSCMOVE, 0.2777)
4056         game.isatb = 0
4057         unschedule(FCDBAS)
4058         unschedule(FSCDBAS)
4059         game.battle.invalidate()
4060         # Make sure Galileo is consistant -- Snapshot may have been taken
4061         # when on planet, which would give us two Galileos!
4062         gotit = False
4063         for l in range(game.inplan):
4064             if game.state.planets[l].known == "shuttle_down":
4065                 gotit = True
4066                 if game.iscraft == "onship" and game.ship=='E':
4067                     prout(_("Chekov-  \"Security reports the Galileo has disappeared, Sir!"))
4068                     game.iscraft = "offship"
4069         # Likewise, if in the original time the Galileo was abandoned, but
4070         # was on ship earlier, it would have vanished -- let's restore it.
4071         if game.iscraft == "offship" and not gotit and game.damage[DSHUTTL] >= 0.0:
4072             prout(_("Chekov-  \"Security reports the Galileo has reappeared in the dock!\""))
4073             game.iscraft = "onship"
4074         # There used to be code to do the actual reconstrction here,
4075         # but the starchart is now part of the snapshotted galaxy state.
4076         prout(_("Spock has reconstructed a correct star chart from memory"))
4077     else:
4078         # Go forward in time
4079         game.optime = expran(0.5*game.intime)
4080         prout(_("You are traveling forward in time %d stardates.") % int(game.optime))
4081         # cheat to make sure no tractor beams occur during time warp
4082         postpone(FTBEAM, game.optime)
4083         game.damage[DRADIO] += game.optime
4084     newqad()
4085     events()    # Stas Sergeev added this -- do pending events
4086
4087 def probe():
4088     "Launch deep-space probe."
4089     # New code to launch a deep space probe
4090     if game.nprobes == 0:
4091         scanner.chew()
4092         skip(1)
4093         if game.ship == 'E':
4094             prout(_("Engineer Scott- \"We have no more deep space probes, Sir.\""))
4095         else:
4096             prout(_("Ye Faerie Queene has no deep space probes."))
4097         return
4098     if damaged(DDSP):
4099         scanner.chew()
4100         skip(1)
4101         prout(_("Engineer Scott- \"The probe launcher is damaged, Sir.\""))
4102         return
4103     if is_scheduled(FDSPROB):
4104         scanner.chew()
4105         skip(1)
4106         if damaged(DRADIO) and game.condition != "docked":
4107             prout(_("Spock-  \"Records show the previous probe has not yet"))
4108             prout(_("   reached its destination.\""))
4109         else:
4110             prout(_("Uhura- \"The previous probe is still reporting data, Sir.\""))
4111         return
4112     key = scanner.next()
4113     if key == "IHEOL":
4114         if game.nprobes == 1:
4115             prout(_("1 probe left."))
4116         else:
4117             prout(_("%d probes left") % game.nprobes)
4118         proutn(_("Are you sure you want to fire a probe? "))
4119         if not ja():
4120             return
4121     game.isarmed = False
4122     if key == "IHALPHA" and scanner.token == "armed":
4123         game.isarmed = True
4124         key = scanner.next()
4125     elif key == "IHEOL":
4126         proutn(_("Arm NOVAMAX warhead? "))
4127         game.isarmed = ja()
4128     elif key == "IHREAL":               # first element of course
4129         scanner.push(scanner.token)
4130     try:
4131         game.probe = getcourse(isprobe=True)
4132     except TrekError:
4133         return
4134     game.nprobes -= 1
4135     schedule(FDSPROB, 0.01) # Time to move one sector
4136     prout(_("Ensign Chekov-  \"The deep space probe is launched, Captain.\""))
4137     game.ididit = True
4138     return
4139
4140 def mayday():
4141     "Yell for help from nearest starbase."
4142     # There's more than one way to move in this game!
4143     scanner.chew()
4144     # Test for conditions which prevent calling for help
4145     if game.condition == "docked":
4146         prout(_("Lt. Uhura-  \"But Captain, we're already docked.\""))
4147         return
4148     if damaged(DRADIO):
4149         prout(_("Subspace radio damaged."))
4150         return
4151     if not game.state.baseq:
4152         prout(_("Lt. Uhura-  \"Captain, I'm not getting any response from Starbase.\""))
4153         return
4154     if game.landed:
4155         prout(_("You must be aboard the %s.") % crmshp())
4156         return
4157     # OK -- call for help from nearest starbase
4158     game.nhelp += 1
4159     if game.base.i!=0:
4160         # There's one in this quadrant
4161         ddist = (game.base - game.sector).distance()
4162     else:
4163         ddist = FOREVER
4164         for ibq in game.state.baseq:
4165             xdist = QUADSIZE * (ibq - game.quadrant).distance()
4166             if xdist < ddist:
4167                 ddist = xdist
4168         # Since starbase not in quadrant, set up new quadrant
4169         game.quadrant = ibq
4170         newqad()
4171     # dematerialize starship
4172     game.quad[game.sector.i][game.sector.j]='.'
4173     proutn(_("Starbase in Quadrant %s responds--%s dematerializes") \
4174            % (game.quadrant, crmshp()))
4175     game.sector.invalidate()
4176     for m in range(1, 5+1):
4177         w = game.base.scatter()
4178         if w.valid_sector() and game.quad[w.i][w.j]=='.':
4179             # found one -- finish up
4180             game.sector = w
4181             break
4182     if not game.sector.is_valid():
4183         prout(_("You have been lost in space..."))
4184         finish(FMATERIALIZE)
4185         return
4186     # Give starbase three chances to rematerialize starship
4187     probf = math.pow((1.0 - math.pow(0.98,ddist)), 0.33333333)
4188     for m in range(1, 3+1):
4189         if m == 1: proutn(_("1st"))
4190         elif m == 2: proutn(_("2nd"))
4191         elif m == 3: proutn(_("3rd"))
4192         proutn(_(" attempt to re-materialize ") + crmshp())
4193         game.quad[game.sector.i][game.sector.j]=('-','o','O')[m-1]
4194         textcolor(RED)
4195         warble()
4196         if randreal() > probf:
4197             break
4198         prout(_("fails."))
4199         textcolor(DEFAULT)
4200         curses.delay_output(500)
4201     if m > 3:
4202         game.quad[game.sector.i][game.sector.j]='?'
4203         game.alive = False
4204         drawmaps(1)
4205         setwnd(message_window)
4206         finish(FMATERIALIZE)
4207         return
4208     game.quad[game.sector.i][game.sector.j]=game.ship
4209     textcolor(GREEN);
4210     prout(_("succeeds."))
4211     textcolor(DEFAULT);
4212     dock(False)
4213     skip(1)
4214     prout(_("Lt. Uhura-  \"Captain, we made it!\""))
4215
4216 def abandon():
4217     "Abandon ship."
4218     scanner.chew()
4219     if game.condition=="docked":
4220         if game.ship!='E':
4221             prout(_("You cannot abandon Ye Faerie Queene."))
4222             return
4223     else:
4224         # Must take shuttle craft to exit
4225         if game.damage[DSHUTTL]==-1:
4226             prout(_("Ye Faerie Queene has no shuttle craft."))
4227             return
4228         if game.damage[DSHUTTL]<0:
4229             prout(_("Shuttle craft now serving Big Macs."))
4230             return
4231         if game.damage[DSHUTTL]>0:
4232             prout(_("Shuttle craft damaged."))
4233             return
4234         if game.landed:
4235             prout(_("You must be aboard the ship."))
4236             return
4237         if game.iscraft != "onship":
4238             prout(_("Shuttle craft not currently available."))
4239             return
4240         # Emit abandon ship messages
4241         skip(1)
4242         prouts(_("***ABANDON SHIP!  ABANDON SHIP!"))
4243         skip(1)
4244         prouts(_("***ALL HANDS ABANDON SHIP!"))
4245         skip(2)
4246         prout(_("Captain and crew escape in shuttle craft."))
4247         if not game.state.baseq:
4248             # Oops! no place to go...
4249             finish(FABANDN)
4250             return
4251         q = game.state.galaxy[game.quadrant.i][game.quadrant.j]
4252         # Dispose of crew
4253         if not (game.options & OPTION_WORLDS) and not damaged(DTRANSP):
4254             prout(_("Remainder of ship's complement beam down"))
4255             prout(_("to nearest habitable planet."))
4256         elif q.planet != None and not damaged(DTRANSP):
4257             prout(_("Remainder of ship's complement beam down to %s.") %
4258                     q.planet)
4259         else:
4260             prout(_("Entire crew of %d left to die in outer space.") %
4261                     game.state.crew)
4262             game.casual += game.state.crew
4263             game.abandoned += game.state.crew
4264         # If at least one base left, give 'em the Faerie Queene
4265         skip(1)
4266         game.icrystl = False # crystals are lost
4267         game.nprobes = 0 # No probes
4268         prout(_("You are captured by Klingons and released to"))
4269         prout(_("the Federation in a prisoner-of-war exchange."))
4270         nb = randrange(len(game.state.baseq))
4271         # Set up quadrant and position FQ adjacient to base
4272         if not game.quadrant == game.state.baseq[nb]:
4273             game.quadrant = game.state.baseq[nb]
4274             game.sector.i = game.sector.j = 5
4275             newqad()
4276         while True:
4277             # position next to base by trial and error
4278             game.quad[game.sector.i][game.sector.j] = '.'
4279             for l in range(QUADSIZE):
4280                 game.sector = game.base.scatter()
4281                 if game.sector.valid_sector() and \
4282                        game.quad[game.sector.i][game.sector.j] == '.':
4283                     break
4284             if l < QUADSIZE+1:
4285                 break # found a spot
4286             game.sector.i=QUADSIZE/2
4287             game.sector.j=QUADSIZE/2
4288             newqad()
4289     # Get new commission
4290     game.quad[game.sector.i][game.sector.j] = game.ship = 'F'
4291     game.state.crew = FULLCREW
4292     prout(_("Starfleet puts you in command of another ship,"))
4293     prout(_("the Faerie Queene, which is antiquated but,"))
4294     prout(_("still useable."))
4295     if game.icrystl:
4296         prout(_("The dilithium crystals have been moved."))
4297     game.imine = False
4298     game.iscraft = "offship" # Galileo disappears
4299     # Resupply ship
4300     game.condition="docked"
4301     for l in range(NDEVICES):
4302         game.damage[l] = 0.0
4303     game.damage[DSHUTTL] = -1
4304     game.energy = game.inenrg = 3000.0
4305     game.shield = game.inshld = 1250.0
4306     game.torps = game.intorps = 6
4307     game.lsupres=game.inlsr=3.0
4308     game.shldup=False
4309     game.warpfac=5.0
4310     return
4311
4312 # Code from planets.c begins here.
4313
4314 def consumeTime():
4315     "Abort a lengthy operation if an event interrupts it."
4316     game.ididit = True
4317     events()
4318     if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.justin:
4319         return True
4320     return False
4321
4322 def survey():
4323     "Report on (uninhabited) planets in the galaxy."
4324     iknow = False
4325     skip(1)
4326     scanner.chew()
4327     prout(_("Spock-  \"Planet report follows, Captain.\""))
4328     skip(1)
4329     for i in range(game.inplan):
4330         if game.state.planets[i].pclass == "destroyed":
4331             continue
4332         if (game.state.planets[i].known != "unknown" \
4333             and not game.state.planets[i].inhabited) \
4334             or game.idebug:
4335             iknow = True
4336             if game.idebug and game.state.planets[i].known=="unknown":
4337                 proutn("(Unknown) ")
4338             proutn(_("Quadrant %s") % game.state.planets[i].quadrant)
4339             proutn(_("   class "))
4340             proutn(game.state.planets[i].pclass)
4341             proutn("   ")
4342             if game.state.planets[i].crystals != "present":
4343                 proutn(_("no "))
4344             prout(_("dilithium crystals present."))
4345             if game.state.planets[i].known=="shuttle_down":
4346                 prout(_("    Shuttle Craft Galileo on surface."))
4347     if not iknow:
4348         prout(_("No information available."))
4349
4350 def orbit():
4351     "Enter standard orbit."
4352     skip(1)
4353     scanner.chew()
4354     if game.inorbit:
4355         prout(_("Already in standard orbit."))
4356         return
4357     if damaged(DWARPEN) and damaged(DIMPULS):
4358         prout(_("Both warp and impulse engines damaged."))
4359         return
4360     if not game.plnet.is_valid():
4361         prout("There is no planet in this sector.")
4362         return
4363     if abs(game.sector.i-game.plnet.i)>1 or abs(game.sector.j-game.plnet.j)>1:
4364         prout(crmshp() + _(" not adjacent to planet."))
4365         skip(1)
4366         return
4367     game.optime = randreal(0.02, 0.05)
4368     prout(_("Helmsman Sulu-  \"Entering standard orbit, Sir.\""))
4369     newcnd()
4370     if consumeTime():
4371         return
4372     game.height = randreal(1400, 8600)
4373     prout(_("Sulu-  \"Entered orbit at altitude %.2f kilometers.\"") % game.height)
4374     game.inorbit = True
4375     game.ididit = True
4376
4377 def sensor():
4378     "Examine planets in this quadrant."
4379     if damaged(DSRSENS):
4380         if game.options & OPTION_TTY:
4381             prout(_("Short range sensors damaged."))
4382         return
4383     if game.iplnet == None:
4384         if game.options & OPTION_TTY:
4385             prout(_("Spock- \"No planet in this quadrant, Captain.\""))
4386         return
4387     if game.iplnet.known == "unknown":
4388         prout(_("Spock-  \"Sensor scan for Quadrant %s-") % game.quadrant)
4389         skip(1)
4390         prout(_("         Planet at Sector %s is of class %s.") %
4391               (game.plnet, game.iplnet.pclass))
4392         if game.iplnet.known=="shuttle_down":
4393             prout(_("         Sensors show Galileo still on surface."))
4394         proutn(_("         Readings indicate"))
4395         if game.iplnet.crystals != "present":
4396             proutn(_(" no"))
4397         prout(_(" dilithium crystals present.\""))
4398         if game.iplnet.known == "unknown":
4399             game.iplnet.known = "known"
4400     elif game.iplnet.inhabited:
4401         prout(_("Spock-  \"The inhabited planet %s ") % game.iplnet.name)
4402         prout(_("        is located at Sector %s, Captain.\"") % game.plnet)
4403
4404 def beam():
4405     "Use the transporter."
4406     nrgneed = 0
4407     scanner.chew()
4408     skip(1)
4409     if damaged(DTRANSP):
4410         prout(_("Transporter damaged."))
4411         if not damaged(DSHUTTL) and (game.iplnet.known=="shuttle_down" or game.iscraft == "onship"):
4412             skip(1)
4413             proutn(_("Spock-  \"May I suggest the shuttle craft, Sir?\" "))
4414             if ja():
4415                 shuttle()
4416         return
4417     if not game.inorbit:
4418         prout(crmshp() + _(" not in standard orbit."))
4419         return
4420     if game.shldup:
4421         prout(_("Impossible to transport through shields."))
4422         return
4423     if game.iplnet.known=="unknown":
4424         prout(_("Spock-  \"Captain, we have no information on this planet"))
4425         prout(_("  and Starfleet Regulations clearly state that in this situation"))
4426         prout(_("  you may not go down.\""))
4427         return
4428     if not game.landed and game.iplnet.crystals=="absent":
4429         prout(_("Spock-  \"Captain, I fail to see the logic in"))
4430         prout(_("  exploring a planet with no dilithium crystals."))
4431         proutn(_("  Are you sure this is wise?\" "))
4432         if not ja():
4433             scanner.chew()
4434             return
4435     if not (game.options & OPTION_PLAIN):
4436         nrgneed = 50 * game.skill + game.height / 100.0
4437         if nrgneed > game.energy:
4438             prout(_("Engineering to bridge--"))
4439             prout(_("  Captain, we don't have enough energy for transportation."))
4440             return
4441         if not game.landed and nrgneed * 2 > game.energy:
4442             prout(_("Engineering to bridge--"))
4443             prout(_("  Captain, we have enough energy only to transport you down to"))
4444             prout(_("  the planet, but there wouldn't be an energy for the trip back."))
4445             if game.iplnet.known == "shuttle_down":
4446                 prout(_("  Although the Galileo shuttle craft may still be on a surface."))
4447             proutn(_("  Are you sure this is wise?\" "))
4448             if not ja():
4449                 scanner.chew()
4450                 return
4451     if game.landed:
4452         # Coming from planet
4453         if game.iplnet.known=="shuttle_down":
4454             proutn(_("Spock-  \"Wouldn't you rather take the Galileo?\" "))
4455             if ja():
4456                 scanner.chew()
4457                 return
4458             prout(_("Your crew hides the Galileo to prevent capture by aliens."))
4459         prout(_("Landing party assembled, ready to beam up."))
4460         skip(1)
4461         prout(_("Kirk whips out communicator..."))
4462         prouts(_("BEEP  BEEP  BEEP"))
4463         skip(2)
4464         prout(_("\"Kirk to enterprise-  Lock on coordinates...energize.\""))
4465     else:
4466         # Going to planet
4467         prout(_("Scotty-  \"Transporter room ready, Sir.\""))
4468         skip(1)
4469         prout(_("Kirk and landing party prepare to beam down to planet surface."))
4470         skip(1)
4471         prout(_("Kirk-  \"Energize.\""))
4472     game.ididit = True
4473     skip(1)
4474     prouts("WWHOOOIIIIIRRRRREEEE.E.E.  .  .  .  .   .    .")
4475     skip(2)
4476     if withprob(0.98):
4477         prouts("BOOOIIIOOOIIOOOOIIIOIING . . .")
4478         skip(2)
4479         prout(_("Scotty-  \"Oh my God!  I've lost them.\""))
4480         finish(FLOST)
4481         return
4482     prouts(".    .   .  .  .  .  .E.E.EEEERRRRRIIIIIOOOHWW")
4483     game.landed = not game.landed
4484     game.energy -= nrgneed
4485     skip(2)
4486     prout(_("Transport complete."))
4487     if game.landed and game.iplnet.known=="shuttle_down":
4488         prout(_("The shuttle craft Galileo is here!"))
4489     if not game.landed and game.imine:
4490         game.icrystl = True
4491         game.cryprob = 0.05
4492     game.imine = False
4493     return
4494
4495 def mine():
4496     "Strip-mine a world for dilithium."
4497     skip(1)
4498     scanner.chew()
4499     if not game.landed:
4500         prout(_("Mining party not on planet."))
4501         return
4502     if game.iplnet.crystals == "mined":
4503         prout(_("This planet has already been strip-mined for dilithium."))
4504         return
4505     elif game.iplnet.crystals == "absent":
4506         prout(_("No dilithium crystals on this planet."))
4507         return
4508     if game.imine:
4509         prout(_("You've already mined enough crystals for this trip."))
4510         return
4511     if game.icrystl and game.cryprob == 0.05:
4512         prout(_("With all those fresh crystals aboard the ") + crmshp())
4513         prout(_("there's no reason to mine more at this time."))
4514         return
4515     game.optime = randreal(0.1, 0.3)*(ord(game.iplnet.pclass)-ord("L"))
4516     if consumeTime():
4517         return
4518     prout(_("Mining operation complete."))
4519     game.iplnet.crystals = "mined"
4520     game.imine = game.ididit = True
4521
4522 def usecrystals():
4523     "Use dilithium crystals."
4524     game.ididit = False
4525     skip(1)
4526     scanner.chew()
4527     if not game.icrystl:
4528         prout(_("No dilithium crystals available."))
4529         return
4530     if game.energy >= 1000:
4531         prout(_("Spock-  \"Captain, Starfleet Regulations prohibit such an operation"))
4532         prout(_("  except when Condition Yellow exists."))
4533         return
4534     prout(_("Spock- \"Captain, I must warn you that loading"))
4535     prout(_("  raw dilithium crystals into the ship's power"))
4536     prout(_("  system may risk a severe explosion."))
4537     proutn(_("  Are you sure this is wise?\" "))
4538     if not ja():
4539         scanner.chew()
4540         return
4541     skip(1)
4542     prout(_("Engineering Officer Scott-  \"(GULP) Aye Sir."))
4543     prout(_("  Mr. Spock and I will try it.\""))
4544     skip(1)
4545     prout(_("Spock-  \"Crystals in place, Sir."))
4546     prout(_("  Ready to activate circuit.\""))
4547     skip(1)
4548     prouts(_("Scotty-  \"Keep your fingers crossed, Sir!\""))
4549     skip(1)
4550     if withprob(game.cryprob):
4551         prouts(_("  \"Activating now! - - No good!  It's***"))
4552         skip(2)
4553         prouts(_("***RED ALERT!  RED A*L********************************"))
4554         skip(1)
4555         stars()
4556         prouts(_("******************   KA-BOOM!!!!   *******************"))
4557         skip(1)
4558         kaboom()
4559         return
4560     game.energy += randreal(5000.0, 5500.0)
4561     prouts(_("  \"Activating now! - - "))
4562     prout(_("The instruments"))
4563     prout(_("   are going crazy, but I think it's"))
4564     prout(_("   going to work!!  Congratulations, Sir!\""))
4565     game.cryprob *= 2.0
4566     game.ididit = True
4567
4568 def shuttle():
4569     "Use shuttlecraft for planetary jaunt."
4570     scanner.chew()
4571     skip(1)
4572     if damaged(DSHUTTL):
4573         if game.damage[DSHUTTL] == -1.0:
4574             if game.inorbit and game.iplnet.known == "shuttle_down":
4575                 prout(_("Ye Faerie Queene has no shuttle craft bay to dock it at."))
4576             else:
4577                 prout(_("Ye Faerie Queene had no shuttle craft."))
4578         elif game.damage[DSHUTTL] > 0:
4579             prout(_("The Galileo is damaged."))
4580         else: # game.damage[DSHUTTL] < 0
4581             prout(_("Shuttle craft is now serving Big Macs."))
4582         return
4583     if not game.inorbit:
4584         prout(crmshp() + _(" not in standard orbit."))
4585         return
4586     if (game.iplnet.known != "shuttle_down") and game.iscraft != "onship":
4587         prout(_("Shuttle craft not currently available."))
4588         return
4589     if not game.landed and game.iplnet.known=="shuttle_down":
4590         prout(_("You will have to beam down to retrieve the shuttle craft."))
4591         return
4592     if game.shldup or game.condition == "docked":
4593         prout(_("Shuttle craft cannot pass through shields."))
4594         return
4595     if game.iplnet.known=="unknown":
4596         prout(_("Spock-  \"Captain, we have no information on this planet"))
4597         prout(_("  and Starfleet Regulations clearly state that in this situation"))
4598         prout(_("  you may not fly down.\""))
4599         return
4600     game.optime = 3.0e-5*game.height
4601     if game.optime >= 0.8*game.state.remtime:
4602         prout(_("First Officer Spock-  \"Captain, I compute that such"))
4603         proutn(_("  a maneuver would require approximately %2d%% of our") % \
4604                int(100*game.optime/game.state.remtime))
4605         prout(_("remaining time."))
4606         proutn(_("Are you sure this is wise?\" "))
4607         if not ja():
4608             game.optime = 0.0
4609             return
4610     if game.landed:
4611         # Kirk on planet
4612         if game.iscraft == "onship":
4613             # Galileo on ship!
4614             if not damaged(DTRANSP):
4615                 proutn(_("Spock-  \"Would you rather use the transporter?\" "))
4616                 if ja():
4617                     beam()
4618                     return
4619                 proutn(_("Shuttle crew"))
4620             else:
4621                 proutn(_("Rescue party"))
4622             prout(_(" boards Galileo and swoops toward planet surface."))
4623             game.iscraft = "offship"
4624             skip(1)
4625             if consumeTime():
4626                 return
4627             game.iplnet.known="shuttle_down"
4628             prout(_("Trip complete."))
4629             return
4630         else:
4631             # Ready to go back to ship
4632             prout(_("You and your mining party board the"))
4633             prout(_("shuttle craft for the trip back to the Enterprise."))
4634             skip(1)
4635             prouts(_("The short hop begins . . ."))
4636             skip(1)
4637             game.iplnet.known="known"
4638             game.icraft = True
4639             skip(1)
4640             game.landed = False
4641             if consumeTime():
4642                 return
4643             game.iscraft = "onship"
4644             game.icraft = False
4645             if game.imine:
4646                 game.icrystl = True
4647                 game.cryprob = 0.05
4648             game.imine = False
4649             prout(_("Trip complete."))
4650             return
4651     else:
4652         # Kirk on ship and so is Galileo
4653         prout(_("Mining party assembles in the hangar deck,"))
4654         prout(_("ready to board the shuttle craft \"Galileo\"."))
4655         skip(1)
4656         prouts(_("The hangar doors open; the trip begins."))
4657         skip(1)
4658         game.icraft = True
4659         game.iscraft = "offship"
4660         if consumeTime():
4661             return
4662         game.iplnet.known = "shuttle_down"
4663         game.landed = True
4664         game.icraft = False
4665         prout(_("Trip complete."))
4666         return
4667
4668 def deathray():
4669     "Use the big zapper."
4670     game.ididit = False
4671     skip(1)
4672     scanner.chew()
4673     if game.ship != 'E':
4674         prout(_("Ye Faerie Queene has no death ray."))
4675         return
4676     if len(game.enemies)==0:
4677         prout(_("Sulu-  \"But Sir, there are no enemies in this quadrant.\""))
4678         return
4679     if damaged(DDRAY):
4680         prout(_("Death Ray is damaged."))
4681         return
4682     prout(_("Spock-  \"Captain, the 'Experimental Death Ray'"))
4683     prout(_("  is highly unpredictible.  Considering the alternatives,"))
4684     proutn(_("  are you sure this is wise?\" "))
4685     if not ja():
4686         return
4687     prout(_("Spock-  \"Acknowledged.\""))
4688     skip(1)
4689     game.ididit = True
4690     prouts(_("WHOOEE ... WHOOEE ... WHOOEE ... WHOOEE"))
4691     skip(1)
4692     prout(_("Crew scrambles in emergency preparation."))
4693     prout(_("Spock and Scotty ready the death ray and"))
4694     prout(_("prepare to channel all ship's power to the device."))
4695     skip(1)
4696     prout(_("Spock-  \"Preparations complete, sir.\""))
4697     prout(_("Kirk-  \"Engage!\""))
4698     skip(1)
4699     prouts(_("WHIRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR"))
4700     skip(1)
4701     dprob = 0.30
4702     if game.options & OPTION_PLAIN:
4703         dprob = 0.5
4704     r = randreal()
4705     if r > dprob:
4706         prouts(_("Sulu- \"Captain!  It's working!\""))
4707         skip(2)
4708         while len(game.enemies) > 0:
4709             deadkl(game.enemies[1].location, game.quad[game.enemies[1].location.i][game.enemies[1].location.j],game.enemies[1].location)
4710         prout(_("Ensign Chekov-  \"Congratulations, Captain!\""))
4711         if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
4712             finish(FWON)
4713         if (game.options & OPTION_PLAIN) == 0:
4714             prout(_("Spock-  \"Captain, I believe the `Experimental Death Ray'"))
4715             if withprob(0.05):
4716                 prout(_("   is still operational.\""))
4717             else:
4718                 prout(_("   has been rendered nonfunctional.\""))
4719                 game.damage[DDRAY] = 39.95
4720         return
4721     r = randreal()      # Pick failure method
4722     if r <= 0.30:
4723         prouts(_("Sulu- \"Captain!  It's working!\""))
4724         skip(1)
4725         prouts(_("***RED ALERT!  RED ALERT!"))
4726         skip(1)
4727         prout(_("***MATTER-ANTIMATTER IMPLOSION IMMINENT!"))
4728         skip(1)
4729         prouts(_("***RED ALERT!  RED A*L********************************"))
4730         skip(1)
4731         stars()
4732         prouts(_("******************   KA-BOOM!!!!   *******************"))
4733         skip(1)
4734         kaboom()
4735         return
4736     if r <= 0.55:
4737         prouts(_("Sulu- \"Captain!  Yagabandaghangrapl, brachriigringlanbla!\""))
4738         skip(1)
4739         prout(_("Lt. Uhura-  \"Graaeek!  Graaeek!\""))
4740         skip(1)
4741         prout(_("Spock-  \"Fascinating!  . . . All humans aboard"))
4742         prout(_("  have apparently been transformed into strange mutations."))
4743         prout(_("  Vulcans do not seem to be affected."))
4744         skip(1)
4745         prout(_("Kirk-  \"Raauch!  Raauch!\""))
4746         finish(FDRAY)
4747         return
4748     if r <= 0.75:
4749         prouts(_("Sulu- \"Captain!  It's   --WHAT?!?!\""))
4750         skip(2)
4751         proutn(_("Spock-  \"I believe the word is"))
4752         prouts(_(" *ASTONISHING*"))
4753         prout(_(" Mr. Sulu."))
4754         for i in range(QUADSIZE):
4755             for j in range(QUADSIZE):
4756                 if game.quad[i][j] == '.':
4757                     game.quad[i][j] = '?'
4758         prout(_("  Captain, our quadrant is now infested with"))
4759         prouts(_(" - - - - - -  *THINGS*."))
4760         skip(1)
4761         prout(_("  I have no logical explanation.\""))
4762         return
4763     prouts(_("Sulu- \"Captain!  The Death Ray is creating tribbles!\""))
4764     skip(1)
4765     prout(_("Scotty-  \"There are so many tribbles down here"))
4766     prout(_("  in Engineering, we can't move for 'em, Captain.\""))
4767     finish(FTRIBBLE)
4768     return
4769
4770 # Code from reports.c begins here
4771
4772 def attackreport(curt):
4773     "eport status of bases under attack."
4774     if not curt:
4775         if is_scheduled(FCDBAS):
4776             prout(_("Starbase in Quadrant %s is currently under Commander attack.") % game.battle)
4777             prout(_("It can hold out until Stardate %d.") % int(scheduled(FCDBAS)))
4778         elif game.isatb == 1:
4779             prout(_("Starbase in Quadrant %s is under Super-commander attack.") % game.state.kscmdr)
4780             prout(_("It can hold out until Stardate %d.") % int(scheduled(FSCDBAS)))
4781         else:
4782             prout(_("No Starbase is currently under attack."))
4783     else:
4784         if is_scheduled(FCDBAS):
4785             proutn(_("Base in %s attacked by C. Alive until %.1f") % (game.battle, scheduled(FCDBAS)))
4786         if game.isatb:
4787             proutn(_("Base in %s attacked by S. Alive until %.1f") % (game.state.kscmdr, scheduled(FSCDBAS)))
4788         clreol()
4789
4790 def report():
4791     # report on general game status
4792     scanner.chew()
4793     s1 = (game.thawed and _("thawed ")) or ""
4794     s2 = {1:"short", 2:"medium", 4:"long"}[game.length]
4795     s3 = (None, _("novice"), _("fair"),
4796           _("good"), _("expert"), _("emeritus"))[game.skill]
4797     prout(_("You %s a %s%s %s game.") % ((_("were playing"), _("are playing"))[game.alldone], s1, s2, s3))
4798     if game.skill>SKILL_GOOD and game.thawed and not game.alldone:
4799         prout(_("No plaque is allowed."))
4800     if game.tourn:
4801         prout(_("This is tournament game %d.") % game.tourn)
4802     prout(_("Your secret password is \"%s\"") % game.passwd)
4803     proutn(_("%d of %d Klingons have been killed") % (((game.inkling + game.incom + game.inscom) - (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)),
4804            (game.inkling + game.incom + game.inscom)))
4805     if game.incom - len(game.state.kcmdr):
4806         prout(_(", including %d Commander%s.") % (game.incom - len(game.state.kcmdr), (_("s"), "")[(game.incom - len(game.state.kcmdr))==1]))
4807     elif game.inkling - game.state.remkl + (game.inscom - game.state.nscrem) > 0:
4808         prout(_(", but no Commanders."))
4809     else:
4810         prout(".")
4811     if game.skill > SKILL_FAIR:
4812         prout(_("The Super Commander has %sbeen destroyed.") % ("", _("not "))[game.state.nscrem])
4813     if len(game.state.baseq) != game.inbase:
4814         proutn(_("There "))
4815         if game.inbase-len(game.state.baseq)==1:
4816             proutn(_("has been 1 base"))
4817         else:
4818             proutn(_("have been %d bases") % (game.inbase-len(game.state.baseq)))
4819         prout(_(" destroyed, %d remaining.") % len(game.state.baseq))
4820     else:
4821         prout(_("There are %d bases.") % game.inbase)
4822     if communicating() or game.iseenit:
4823         # Don't report this if not seen and
4824         # either the radio is dead or not at base!
4825         attackreport(False)
4826         game.iseenit = True
4827     if game.casual:
4828         prout(_("%d casualt%s suffered so far.") % (game.casual, ("y", "ies")[game.casual!=1]))
4829     if game.nhelp:
4830         prout(_("There were %d call%s for help.") % (game.nhelp,  ("" , _("s"))[game.nhelp!=1]))
4831     if game.ship == 'E':
4832         proutn(_("You have "))
4833         if game.nprobes:
4834             proutn("%d" % (game.nprobes))
4835         else:
4836             proutn(_("no"))
4837         proutn(_(" deep space probe"))
4838         if game.nprobes!=1:
4839             proutn(_("s"))
4840         prout(".")
4841     if communicating() and is_scheduled(FDSPROB):
4842         if game.isarmed:
4843             proutn(_("An armed deep space probe is in "))
4844         else:
4845             proutn(_("A deep space probe is in "))
4846         prout("Quadrant %s." % game.probec)
4847     if game.icrystl:
4848         if game.cryprob <= .05:
4849             prout(_("Dilithium crystals aboard ship... not yet used."))
4850         else:
4851             i=0
4852             ai = 0.05
4853             while game.cryprob > ai:
4854                 ai *= 2.0
4855                 i += 1
4856             prout(_("Dilithium crystals have been used %d time%s.") % \
4857                   (i, (_("s"), "")[i==1]))
4858     skip(1)
4859
4860 def lrscan(silent):
4861     "Long-range sensor scan."
4862     if damaged(DLRSENS):
4863         # Now allow base's sensors if docked
4864         if game.condition != "docked":
4865             if not silent:
4866                 prout(_("LONG-RANGE SENSORS DAMAGED."))
4867             return
4868         if not silent:
4869             prout(_("Starbase's long-range scan"))
4870     elif not silent:
4871         prout(_("Long-range scan"))
4872     for x in range(game.quadrant.i-1, game.quadrant.i+2):
4873         if not silent:
4874             proutn(" ")
4875         for y in range(game.quadrant.j-1, game.quadrant.j+2):
4876             if not Coord(x, y).valid_quadrant():
4877                 if not silent:
4878                     proutn("  -1")
4879             else:
4880                 if not damaged(DRADIO):
4881                     game.state.galaxy[x][y].charted = True
4882                 game.state.chart[x][y].klingons = game.state.galaxy[x][y].klingons
4883                 game.state.chart[x][y].starbase = game.state.galaxy[x][y].starbase
4884                 game.state.chart[x][y].stars = game.state.galaxy[x][y].stars
4885                 if not silent and game.state.galaxy[x][y].supernova:
4886                     proutn(" ***")
4887                 elif not silent:
4888                     proutn(" %3d" % (game.state.chart[x][y].klingons*100 + game.state.chart[x][y].starbase * 10 + game.state.chart[x][y].stars))
4889         if not silent:
4890             prout(" ")
4891
4892 def damagereport():
4893     "Damage report."
4894     jdam = False
4895     scanner.chew()
4896     for i in range(NDEVICES):
4897         if damaged(i):
4898             if not jdam:
4899                 prout(_("\tDEVICE\t\t\t-REPAIR TIMES-"))
4900                 prout(_("\t\t\tIN FLIGHT\t\tDOCKED"))
4901                 jdam = True
4902             prout("  %-26s\t%8.2f\t\t%8.2f" % (device[i],
4903                                                game.damage[i]+0.05,
4904                                                DOCKFAC*game.damage[i]+0.005))
4905     if not jdam:
4906         prout(_("All devices functional."))
4907
4908 def rechart():
4909     "Update the chart in the Enterprise's computer from galaxy data."
4910     game.lastchart = game.state.date
4911     for i in range(GALSIZE):
4912         for j in range(GALSIZE):
4913             if game.state.galaxy[i][j].charted:
4914                 game.state.chart[i][j].klingons = game.state.galaxy[i][j].klingons
4915                 game.state.chart[i][j].starbase = game.state.galaxy[i][j].starbase
4916                 game.state.chart[i][j].stars = game.state.galaxy[i][j].stars
4917
4918 def chart():
4919     "Display the star chart."
4920     scanner.chew()
4921     if (game.options & OPTION_AUTOSCAN):
4922         lrscan(silent=True)
4923     if not damaged(DRADIO):
4924         rechart()
4925     if game.lastchart < game.state.date and game.condition == "docked":
4926         prout(_("Spock-  \"I revised the Star Chart from the starbase's records.\""))
4927         rechart()
4928     prout(_("       STAR CHART FOR THE KNOWN GALAXY"))
4929     if game.state.date > game.lastchart:
4930         prout(_("(Last surveillance update %d stardates ago).") % ((int)(game.state.date-game.lastchart)))
4931     prout("      1    2    3    4    5    6    7    8")
4932     for i in range(GALSIZE):
4933         proutn("%d |" % (i+1))
4934         for j in range(GALSIZE):
4935             if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j:
4936                 proutn("<")
4937             else:
4938                 proutn(" ")
4939             if game.state.galaxy[i][j].supernova:
4940                 show = "***"
4941             elif not game.state.galaxy[i][j].charted and game.state.galaxy[i][j].starbase:
4942                 show = ".1."
4943             elif game.state.galaxy[i][j].charted:
4944                 show = "%3d" % (game.state.chart[i][j].klingons*100 + game.state.chart[i][j].starbase * 10 + game.state.chart[i][j].stars)
4945             else:
4946                 show = "..."
4947             proutn(show)
4948             if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j:
4949                 proutn(">")
4950             else:
4951                 proutn(" ")
4952         proutn("  |")
4953         if i<GALSIZE:
4954             skip(1)
4955
4956 def sectscan(goodScan, i, j):
4957     "Light up an individual dot in a sector."
4958     if goodScan or (abs(i-game.sector.i)<= 1 and abs(j-game.sector.j) <= 1):
4959         textcolor({"green":GREEN,
4960                    "yellow":YELLOW,
4961                    "red":RED,
4962                    "docked":CYAN,
4963                    "dead":BROWN}[game.condition])
4964         if game.quad[i][j] != game.ship:
4965             highvideo();
4966         proutn("%c " % game.quad[i][j])
4967         textcolor(DEFAULT)
4968     else:
4969         proutn("- ")
4970
4971 def status(req=0):
4972     "Emit status report lines"
4973     if not req or req == 1:
4974         prstat(_("Stardate"), _("%.1f, Time Left %.2f") \
4975                % (game.state.date, game.state.remtime))
4976     if not req or req == 2:
4977         if game.condition != "docked":
4978             newcnd()
4979         prstat(_("Condition"), _("%s, %i DAMAGES") % \
4980                (game.condition.upper(), sum(map(lambda x: x > 0, game.damage))))
4981     if not req or req == 3:
4982         prstat(_("Position"), "%s , %s" % (game.quadrant, game.sector))
4983     if not req or req == 4:
4984         if damaged(DLIFSUP):
4985             if game.condition == "docked":
4986                 s = _("DAMAGED, Base provides")
4987             else:
4988                 s = _("DAMAGED, reserves=%4.2f") % game.lsupres
4989         else:
4990             s = _("ACTIVE")
4991         prstat(_("Life Support"), s)
4992     if not req or req == 5:
4993         prstat(_("Warp Factor"), "%.1f" % game.warpfac)
4994     if not req or req == 6:
4995         extra = ""
4996         if game.icrystl and (game.options & OPTION_SHOWME):
4997             extra = _(" (have crystals)")
4998         prstat(_("Energy"), "%.2f%s" % (game.energy, extra))
4999     if not req or req == 7:
5000         prstat(_("Torpedoes"), "%d" % (game.torps))
5001     if not req or req == 8:
5002         if damaged(DSHIELD):
5003             s = _("DAMAGED,")
5004         elif game.shldup:
5005             s = _("UP,")
5006         else:
5007             s = _("DOWN,")
5008         data = _(" %d%% %.1f units") \
5009                % (int((100.0*game.shield)/game.inshld + 0.5), game.shield)
5010         prstat(_("Shields"), s+data)
5011     if not req or req == 9:
5012         prstat(_("Klingons Left"), "%d" \
5013                % (game.state.remkl+len(game.state.kcmdr)+game.state.nscrem))
5014     if not req or req == 10:
5015         if game.options & OPTION_WORLDS:
5016             plnet = game.state.galaxy[game.quadrant.i][game.quadrant.j].planet
5017             if plnet and plnet.inhabited:
5018                 prstat(_("Major system"), plnet.name)
5019             else:
5020                 prout(_("Sector is uninhabited"))
5021     elif not req or req == 11:
5022         attackreport(not req)
5023
5024 def request():
5025     "Request specified status data, a historical relic from slow TTYs."
5026     requests = ("da","co","po","ls","wa","en","to","sh","kl","sy", "ti")
5027     while scanner.next() == "IHEOL":
5028         proutn(_("Information desired? "))
5029     scanner.chew()
5030     if scanner.token in requests:
5031         status(requests.index(scanner.token))
5032     else:
5033         prout(_("UNRECOGNIZED REQUEST. Legal requests are:"))
5034         prout(("  date, condition, position, lsupport, warpfactor,"))
5035         prout(("  energy, torpedoes, shields, klingons, system, time."))
5036
5037 def srscan():
5038     "Short-range scan."
5039     goodScan=True
5040     if damaged(DSRSENS):
5041         # Allow base's sensors if docked
5042         if game.condition != "docked":
5043             prout(_("   S.R. SENSORS DAMAGED!"))
5044             goodScan=False
5045         else:
5046             prout(_("  [Using Base's sensors]"))
5047     else:
5048         prout(_("     Short-range scan"))
5049     if goodScan and not damaged(DRADIO):
5050         game.state.chart[game.quadrant.i][game.quadrant.j].klingons = game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons
5051         game.state.chart[game.quadrant.i][game.quadrant.j].starbase = game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase
5052         game.state.chart[game.quadrant.i][game.quadrant.j].stars = game.state.galaxy[game.quadrant.i][game.quadrant.j].stars
5053         game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True
5054     prout("    1 2 3 4 5 6 7 8 9 10")
5055     if game.condition != "docked":
5056         newcnd()
5057     for i in range(QUADSIZE):
5058         proutn("%2d  " % (i+1))
5059         for j in range(QUADSIZE):
5060             sectscan(goodScan, i, j)
5061         skip(1)
5062
5063 def eta():
5064     "Use computer to get estimated time of arrival for a warp jump."
5065     w1 = Coord(); w2 = Coord()
5066     prompt = False
5067     if damaged(DCOMPTR):
5068         prout(_("COMPUTER DAMAGED, USE A POCKET CALCULATOR."))
5069         skip(1)
5070         return
5071     if scanner.next() != "IHREAL":
5072         prompt = True
5073         scanner.chew()
5074         proutn(_("Destination quadrant and/or sector? "))
5075         if scanner.next()!="IHREAL":
5076             huh()
5077             return
5078     w1.j = int(scanner.real-0.5)
5079     if scanner.next() != "IHREAL":
5080         huh()
5081         return
5082     w1.i = int(scanner.real-0.5)
5083     if scanner.next() == "IHREAL":
5084         w2.j = int(scanner.real-0.5)
5085         if scanner.next() != "IHREAL":
5086             huh()
5087             return
5088         w2.i = int(scanner.real-0.5)
5089     else:
5090         if game.quadrant.j>w1.i:
5091             w2.i = 0
5092         else:
5093             w2.i=QUADSIZE-1
5094         if game.quadrant.i>w1.j:
5095             w2.j = 0
5096         else:
5097             w2.j=QUADSIZE-1
5098     if not w1.valid_quadrant() or not w2.valid_sector():
5099         huh()
5100         return
5101     dist = math.sqrt((w1.j-game.quadrant.j+(w2.j-game.sector.j)/(QUADSIZE*1.0))**2+
5102                 (w1.i-game.quadrant.i+(w2.i-game.sector.i)/(QUADSIZE*1.0))**2)
5103     wfl = False
5104     if prompt:
5105         prout(_("Answer \"no\" if you don't know the value:"))
5106     while True:
5107         scanner.chew()
5108         proutn(_("Time or arrival date? "))
5109         if scanner.next()=="IHREAL":
5110             ttime = scanner.real
5111             if ttime > game.state.date:
5112                 ttime -= game.state.date # Actually a star date
5113             twarp=(math.floor(math.sqrt((10.0*dist)/ttime)*10.0)+1.0)/10.0
5114             if ttime <= 1e-10 or twarp > 10:
5115                 prout(_("We'll never make it, sir."))
5116                 scanner.chew()
5117                 return
5118             if twarp < 1.0:
5119                 twarp = 1.0
5120             break
5121         scanner.chew()
5122         proutn(_("Warp factor? "))
5123         if scanner.next()== "IHREAL":
5124             wfl = True
5125             twarp = scanner.real
5126             if twarp<1.0 or twarp > 10.0:
5127                 huh()
5128                 return
5129             break
5130         prout(_("Captain, certainly you can give me one of these."))
5131     while True:
5132         scanner.chew()
5133         ttime = (10.0*dist)/twarp**2
5134         tpower = dist*twarp*twarp*twarp*(game.shldup+1)
5135         if tpower >= game.energy:
5136             prout(_("Insufficient energy, sir."))
5137             if not game.shldup or tpower > game.energy*2.0:
5138                 if not wfl:
5139                     return
5140                 proutn(_("New warp factor to try? "))
5141                 if scanner.next() == "IHREAL":
5142                     wfl = True
5143                     twarp = scanner.real
5144                     if twarp<1.0 or twarp > 10.0:
5145                         huh()
5146                         return
5147                     continue
5148                 else:
5149                     scanner.chew()
5150                     skip(1)
5151                     return
5152             prout(_("But if you lower your shields,"))
5153             proutn(_("remaining"))
5154             tpower /= 2
5155         else:
5156             proutn(_("Remaining"))
5157         prout(_(" energy will be %.2f.") % (game.energy-tpower))
5158         if wfl:
5159             prout(_("And we will arrive at stardate %.2f.") % (game.state.date+ttime))
5160         elif twarp==1.0:
5161             prout(_("Any warp speed is adequate."))
5162         else:
5163             prout(_("Minimum warp needed is %.2f,") % (twarp))
5164             prout(_("and we will arrive at stardate %.2f.") % (game.state.date+ttime))
5165         if game.state.remtime < ttime:
5166             prout(_("Unfortunately, the Federation will be destroyed by then."))
5167         if twarp > 6.0:
5168             prout(_("You'll be taking risks at that speed, Captain"))
5169         if (game.isatb==1 and game.state.kscmdr == w1 and \
5170              scheduled(FSCDBAS)< ttime+game.state.date) or \
5171             (scheduled(FCDBAS)<ttime+game.state.date and game.battle == w1):
5172             prout(_("The starbase there will be destroyed by then."))
5173         proutn(_("New warp factor to try? "))
5174         if scanner.next() == "IHREAL":
5175             wfl = True
5176             twarp = scanner.real
5177             if twarp<1.0 or twarp > 10.0:
5178                 huh()
5179                 return
5180         else:
5181             scanner.chew()
5182             skip(1)
5183             return
5184
5185 # Code from setup.c begins here
5186
5187 def prelim():
5188     "Issue a historically correct banner."
5189     skip(2)
5190     prout(_("-SUPER- STAR TREK"))
5191     skip(1)
5192 # From the FORTRAN original
5193 #    prout(_("Latest update-21 Sept 78"))
5194 #    skip(1)
5195
5196 def freeze(boss):
5197     "Save game."
5198     if boss:
5199         scanner.push("emsave.trk")
5200     key = scanner.next()
5201     if key == "IHEOL":
5202         proutn(_("File name: "))
5203         key = scanner.next()
5204     if key != "IHALPHA":
5205         huh()
5206         return
5207     scanner.chew()
5208     if '.' not in scanner.token:
5209         scanner.token += ".trk"
5210     try:
5211         fp = open(scanner.token, "wb")
5212     except IOError:
5213         prout(_("Can't freeze game as file %s") % scanner.token)
5214         return
5215     cPickle.dump(game, fp)
5216     fp.close()
5217
5218 def thaw():
5219     "Retrieve saved game."
5220     global game
5221     game.passwd[0] = '\0'
5222     key = scanner.next()
5223     if key == "IHEOL":
5224         proutn(_("File name: "))
5225         key = scanner.next()
5226     if key != "IHALPHA":
5227         huh()
5228         return True
5229     scanner.chew()
5230     if '.' not in scanner.token:
5231         scanner.token += ".trk"
5232     try:
5233         fp = open(scanner.token, "rb")
5234     except IOError:
5235         prout(_("Can't thaw game in %s") % scanner.token)
5236         return
5237     game = cPickle.load(fp)
5238     fp.close()
5239     return False
5240
5241 # I used <http://www.memory-alpha.org> to find planets
5242 # with references in ST:TOS.  Earth and the Alpha Centauri
5243 # Colony have been omitted.
5244 #
5245 # Some planets marked Class G and P here will be displayed as class M
5246 # because of the way planets are generated. This is a known bug.
5247 systnames = (
5248     # Federation Worlds
5249     _("Andoria (Fesoan)"),      # several episodes
5250     _("Tellar Prime (Miracht)"),        # TOS: "Journey to Babel"
5251     _("Vulcan (T'Khasi)"),      # many episodes
5252     _("Medusa"),                # TOS: "Is There in Truth No Beauty?"
5253     _("Argelius II (Nelphia)"), # TOS: "Wolf in the Fold" ("IV" in BSD)
5254     _("Ardana"),                # TOS: "The Cloud Minders"
5255     _("Catulla (Cendo-Prae)"),  # TOS: "The Way to Eden"
5256     _("Gideon"),                # TOS: "The Mark of Gideon"
5257     _("Aldebaran III"),         # TOS: "The Deadly Years"
5258     _("Alpha Majoris I"),       # TOS: "Wolf in the Fold"
5259     _("Altair IV"),             # TOS: "Amok Time
5260     _("Ariannus"),              # TOS: "Let That Be Your Last Battlefield"
5261     _("Benecia"),               # TOS: "The Conscience of the King"
5262     _("Beta Niobe I (Sarpeidon)"),      # TOS: "All Our Yesterdays"
5263     _("Alpha Carinae II"),      # TOS: "The Ultimate Computer"
5264     _("Capella IV (Kohath)"),   # TOS: "Friday's Child" (Class G)
5265     _("Daran V"),               # TOS: "For the World is Hollow and I Have Touched the Sky"
5266     _("Deneb II"),              # TOS: "Wolf in the Fold" ("IV" in BSD)
5267     _("Eminiar VII"),           # TOS: "A Taste of Armageddon"
5268     _("Gamma Canaris IV"),      # TOS: "Metamorphosis"
5269     _("Gamma Tranguli VI (Vaalel)"),    # TOS: "The Apple"
5270     _("Ingraham B"),            # TOS: "Operation: Annihilate"
5271     _("Janus IV"),              # TOS: "The Devil in the Dark"
5272     _("Makus III"),             # TOS: "The Galileo Seven"
5273     _("Marcos XII"),            # TOS: "And the Children Shall Lead",
5274     _("Omega IV"),              # TOS: "The Omega Glory"
5275     _("Regulus V"),             # TOS: "Amok Time
5276     _("Deneva"),                # TOS: "Operation -- Annihilate!"
5277     # Worlds from BSD Trek
5278     _("Rigel II"),              # TOS: "Shore Leave" ("III" in BSD)
5279     _("Beta III"),              # TOS: "The Return of the Archons"
5280     _("Triacus"),               # TOS: "And the Children Shall Lead",
5281     _("Exo III"),               # TOS: "What Are Little Girls Made Of?" (Class P)
5282 #       # Others
5283 #    _("Hansen's Planet"),      # TOS: "The Galileo Seven"
5284 #    _("Taurus IV"),            # TOS: "The Galileo Seven" (class G)
5285 #    _("Antos IV (Doraphane)"), # TOS: "Whom Gods Destroy", "Who Mourns for Adonais?"
5286 #    _("Izar"),                 # TOS: "Whom Gods Destroy"
5287 #    _("Tiburon"),              # TOS: "The Way to Eden"
5288 #    _("Merak II"),             # TOS: "The Cloud Minders"
5289 #    _("Coridan (Desotriana)"), # TOS: "Journey to Babel"
5290 #    _("Iotia"),                # TOS: "A Piece of the Action"
5291 )
5292
5293 device = (
5294         _("S. R. Sensors"), \
5295         _("L. R. Sensors"), \
5296         _("Phasers"), \
5297         _("Photon Tubes"), \
5298         _("Life Support"), \
5299         _("Warp Engines"), \
5300         _("Impulse Engines"), \
5301         _("Shields"), \
5302         _("Subspace Radio"), \
5303         _("Shuttle Craft"), \
5304         _("Computer"), \
5305         _("Navigation System"), \
5306         _("Transporter"), \
5307         _("Shield Control"), \
5308         _("Death Ray"), \
5309         _("D. S. Probe"), \
5310 )
5311
5312 def setup():
5313     "Prepare to play, set up cosmos."
5314     w = Coord()
5315     #  Decide how many of everything
5316     if choose():
5317         return # frozen game
5318     # Prepare the Enterprise
5319     game.alldone = game.gamewon = game.shldchg = game.shldup = False
5320     game.ship = 'E'
5321     game.state.crew = FULLCREW
5322     game.energy = game.inenrg = 5000.0
5323     game.shield = game.inshld = 2500.0
5324     game.inlsr = 4.0
5325     game.lsupres = 4.0
5326     game.quadrant = randplace(GALSIZE)
5327     game.sector = randplace(QUADSIZE)
5328     game.torps = game.intorps = 10
5329     game.nprobes = randrange(2, 5)
5330     game.warpfac = 5.0
5331     for i in range(NDEVICES):
5332         game.damage[i] = 0.0
5333     # Set up assorted game parameters
5334     game.battle = Coord()
5335     game.state.date = game.indate = 100.0 * randreal(20, 51)
5336     game.nkinks = game.nhelp = game.casual = game.abandoned = 0
5337     game.iscate = game.resting = game.imine = game.icrystl = game.icraft = False
5338     game.isatb = game.state.nplankl = 0
5339     game.state.starkl = game.state.basekl = 0
5340     game.iscraft = "onship"
5341     game.landed = False
5342     game.alive = True
5343     # Starchart is functional but we've never seen it
5344     game.lastchart = FOREVER
5345     # Put stars in the galaxy
5346     game.instar = 0
5347     for i in range(GALSIZE):
5348         for j in range(GALSIZE):
5349             k = randrange(1, QUADSIZE**2/10+1)
5350             game.instar += k
5351             game.state.galaxy[i][j].stars = k
5352     # Locate star bases in galaxy
5353     for i in range(game.inbase):
5354         while True:
5355             while True:
5356                 w = randplace(GALSIZE)
5357                 if not game.state.galaxy[w.i][w.j].starbase:
5358                     break
5359             contflag = False
5360             # C version: for (j = i-1; j > 0; j--)
5361             # so it did them in the opposite order.
5362             for j in range(1, i):
5363                 # Improved placement algorithm to spread out bases
5364                 distq = (w - game.state.baseq[j]).distance()
5365                 if distq < 6.0*(BASEMAX+1-game.inbase) and withprob(0.75):
5366                     contflag = True
5367                     if game.idebug:
5368                         prout("=== Abandoning base #%d at %s" % (i, w))
5369                     break
5370                 elif distq < 6.0 * (BASEMAX+1-game.inbase):
5371                     if game.idebug:
5372                         prout("=== Saving base #%d, close to #%d" % (i, j))
5373             if not contflag:
5374                 break
5375         game.state.baseq.append(w)
5376         game.state.galaxy[w.i][w.j].starbase = game.state.chart[w.i][w.j].starbase = True
5377     # Position ordinary Klingon Battle Cruisers
5378     krem = game.inkling
5379     klumper = 0.25*game.skill*(9.0-game.length)+1.0
5380     if klumper > MAXKLQUAD:
5381         klumper = MAXKLQUAD
5382     while True:
5383         r = randreal()
5384         klump = (1.0 - r*r)*klumper
5385         if klump > krem:
5386             klump = krem
5387         krem -= klump
5388         while True:
5389             w = randplace(GALSIZE)
5390             if not game.state.galaxy[w.i][w.j].supernova and \
5391                game.state.galaxy[w.i][w.j].klingons + klump <= MAXKLQUAD:
5392                 break
5393         game.state.galaxy[w.i][w.j].klingons += int(klump)
5394         if krem <= 0:
5395             break
5396     # Position Klingon Commander Ships
5397     for i in range(game.incom):
5398         while True:
5399             w = randplace(GALSIZE)
5400             if not welcoming(w) or w in game.state.kcmdr:
5401                 continue
5402             if (game.state.galaxy[w.i][w.j].klingons or withprob(0.25)):
5403                 break
5404         game.state.galaxy[w.i][w.j].klingons += 1
5405         game.state.kcmdr.append(w)
5406     # Locate planets in galaxy
5407     for i in range(game.inplan):
5408         while True:
5409             w = randplace(GALSIZE)
5410             if game.state.galaxy[w.i][w.j].planet == None:
5411                 break
5412         new = Planet()
5413         new.quadrant = w
5414         new.crystals = "absent"
5415         if (game.options & OPTION_WORLDS) and i < NINHAB:
5416             new.pclass = "M"    # All inhabited planets are class M
5417             new.crystals = "absent"
5418             new.known = "known"
5419             new.name = systnames[i]
5420             new.inhabited = True
5421         else:
5422             new.pclass = ("M", "N", "O")[randrange(0, 3)]
5423             if withprob(0.33):
5424                 new.crystals = "present"
5425             new.known = "unknown"
5426             new.inhabited = False
5427         game.state.galaxy[w.i][w.j].planet = new
5428         game.state.planets.append(new)
5429     # Locate Romulans
5430     for i in range(game.state.nromrem):
5431         w = randplace(GALSIZE)
5432         game.state.galaxy[w.i][w.j].romulans += 1
5433     # Place the Super-Commander if needed
5434     if game.state.nscrem > 0:
5435         while True:
5436             w = randplace(GALSIZE)
5437             if welcoming(w):
5438                 break
5439         game.state.kscmdr = w
5440         game.state.galaxy[w.i][w.j].klingons += 1
5441     # Initialize times for extraneous events
5442     schedule(FSNOVA, expran(0.5 * game.intime))
5443     schedule(FTBEAM, expran(1.5 * (game.intime / len(game.state.kcmdr))))
5444     schedule(FSNAP, randreal(1.0, 2.0)) # Force an early snapshot
5445     schedule(FBATTAK, expran(0.3*game.intime))
5446     unschedule(FCDBAS)
5447     if game.state.nscrem:
5448         schedule(FSCMOVE, 0.2777)
5449     else:
5450         unschedule(FSCMOVE)
5451     unschedule(FSCDBAS)
5452     unschedule(FDSPROB)
5453     if (game.options & OPTION_WORLDS) and game.skill >= SKILL_GOOD:
5454         schedule(FDISTR, expran(1.0 + game.intime))
5455     else:
5456         unschedule(FDISTR)
5457     unschedule(FENSLV)
5458     unschedule(FREPRO)
5459     # Place thing (in tournament game, we don't want one!)
5460     # New in SST2K: never place the Thing near a starbase.
5461     # This makes sense and avoids a special case in the old code.
5462     global thing
5463     if game.tourn is None:
5464         while True:
5465             thing = randplace(GALSIZE)
5466             if thing not in game.state.baseq:
5467                 break
5468     skip(2)
5469     game.state.snap = False
5470     if game.skill == SKILL_NOVICE:
5471         prout(_("It is stardate %d. The Federation is being attacked by") % int(game.state.date))
5472         prout(_("a deadly Klingon invasion force. As captain of the United"))
5473         prout(_("Starship U.S.S. Enterprise, it is your mission to seek out"))
5474         prout(_("and destroy this invasion force of %d battle cruisers.") % ((game.inkling + game.incom + game.inscom)))
5475         prout(_("You have an initial allotment of %d stardates to complete") % int(game.intime))
5476         prout(_("your mission.  As you proceed you may be given more time."))
5477         skip(1)
5478         prout(_("You will have %d supporting starbases.") % (game.inbase))
5479         proutn(_("Starbase locations-  "))
5480     else:
5481         prout(_("Stardate %d.") % int(game.state.date))
5482         skip(1)
5483         prout(_("%d Klingons.") % (game.inkling + game.incom + game.inscom))
5484         prout(_("An unknown number of Romulans."))
5485         if game.state.nscrem:
5486             prout(_("And one (GULP) Super-Commander."))
5487         prout(_("%d stardates.") % int(game.intime))
5488         proutn(_("%d starbases in ") % game.inbase)
5489     for i in range(game.inbase):
5490         proutn(`game.state.baseq[i]`)
5491         proutn("  ")
5492     skip(2)
5493     proutn(_("The Enterprise is currently in Quadrant %s") % game.quadrant)
5494     proutn(_(" Sector %s") % game.sector)
5495     skip(2)
5496     prout(_("Good Luck!"))
5497     if game.state.nscrem:
5498         prout(_("  YOU'LL NEED IT."))
5499     waitfor()
5500     newqad()
5501     if len(game.enemies) - (thing == game.quadrant) - (game.tholian != None):
5502         game.shldup = True
5503     if game.neutz:      # bad luck to start in a Romulan Neutral Zone
5504         attack(torps_ok=False)
5505
5506 def choose():
5507     "Choose your game type."
5508     while True:
5509         game.tourn = game.length = 0
5510         game.thawed = False
5511         game.skill = SKILL_NONE
5512         if not scanner.inqueue: # Can start with command line options
5513             proutn(_("Would you like a regular, tournament, or saved game? "))
5514         scanner.next()
5515         if scanner.sees("tournament"):
5516             while scanner.next() == "IHEOL":
5517                 proutn(_("Type in tournament number-"))
5518             if scanner.real == 0:
5519                 scanner.chew()
5520                 continue # We don't want a blank entry
5521             game.tourn = int(round(scanner.real))
5522             random.seed(scanner.real)
5523             if logfp:
5524                 logfp.write("# random.seed(%d)\n" % scanner.real)
5525             break
5526         if scanner.sees("saved") or scanner.sees("frozen"):
5527             if thaw():
5528                 continue
5529             scanner.chew()
5530             if game.passwd == None:
5531                 continue
5532             if not game.alldone:
5533                 game.thawed = True # No plaque if not finished
5534             report()
5535             waitfor()
5536             return True
5537         if scanner.sees("regular"):
5538             break
5539         proutn(_("What is \"%s\"?") % scanner.token)
5540         scanner.chew()
5541     while game.length==0 or game.skill==SKILL_NONE:
5542         if scanner.next() == "IHALPHA":
5543             if scanner.sees("short"):
5544                 game.length = 1
5545             elif scanner.sees("medium"):
5546                 game.length = 2
5547             elif scanner.sees("long"):
5548                 game.length = 4
5549             elif scanner.sees("novice"):
5550                 game.skill = SKILL_NOVICE
5551             elif scanner.sees("fair"):
5552                 game.skill = SKILL_FAIR
5553             elif scanner.sees("good"):
5554                 game.skill = SKILL_GOOD
5555             elif scanner.sees("expert"):
5556                 game.skill = SKILL_EXPERT
5557             elif scanner.sees("emeritus"):
5558                 game.skill = SKILL_EMERITUS
5559             else:
5560                 proutn(_("What is \""))
5561                 proutn(scanner.token)
5562                 prout("\"?")
5563         else:
5564             scanner.chew()
5565             if game.length==0:
5566                 proutn(_("Would you like a Short, Medium, or Long game? "))
5567             elif game.skill == SKILL_NONE:
5568                 proutn(_("Are you a Novice, Fair, Good, Expert, or Emeritus player? "))
5569     # Choose game options -- added by ESR for SST2K
5570     if scanner.next() != "IHALPHA":
5571         scanner.chew()
5572         proutn(_("Choose your game style (plain, almy, fancy or just press enter): "))
5573         scanner.next()
5574     if scanner.sees("plain"):
5575         # Approximates the UT FORTRAN version.
5576         game.options &=~ (OPTION_THOLIAN | OPTION_PLANETS | OPTION_THINGY | OPTION_PROBE | OPTION_RAMMING | OPTION_MVBADDY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS)
5577         game.options |= OPTION_PLAIN
5578     elif scanner.sees("almy"):
5579         # Approximates Tom Almy's version.
5580         game.options &=~ (OPTION_THINGY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS)
5581         game.options |= OPTION_ALMY
5582     elif scanner.sees("fancy") or scanner.sees("\n"):
5583         pass
5584     elif len(scanner.token):
5585         proutn(_("What is \"%s\"?") % scanner.token)
5586     game.options &=~ OPTION_COLOR
5587     setpassword()
5588     if game.passwd == "debug":
5589         game.idebug = True
5590         prout("=== Debug mode enabled.")
5591     # Use parameters to generate initial values of things
5592     game.damfac = 0.5 * game.skill
5593     game.inbase = randrange(BASEMIN, BASEMAX+1)
5594     game.inplan = 0
5595     if game.options & OPTION_PLANETS:
5596         game.inplan += randrange(MAXUNINHAB/2, MAXUNINHAB+1)
5597     if game.options & OPTION_WORLDS:
5598         game.inplan += int(NINHAB)
5599     game.state.nromrem = game.inrom = randrange(2 *game.skill)
5600     game.state.nscrem = game.inscom = (game.skill > SKILL_FAIR)
5601     game.state.remtime = 7.0 * game.length
5602     game.intime = game.state.remtime
5603     game.state.remkl = game.inkling = 2.0*game.intime*((game.skill+1 - 2*randreal())*game.skill*0.1+.15)
5604     game.incom = min(MINCMDR, int(game.skill + 0.0625*game.inkling*randreal()))
5605     game.state.remres = (game.inkling+4*game.incom)*game.intime
5606     game.inresor = game.state.remres
5607     if game.inkling > 50:
5608         game.state.inbase += 1
5609     return False
5610
5611 def dropin(iquad=None):
5612     "Drop a feature on a random dot in the current quadrant."
5613     while True:
5614         w = randplace(QUADSIZE)
5615         if game.quad[w.i][w.j] == '.':
5616             break
5617     if iquad is not None:
5618         game.quad[w.i][w.j] = iquad
5619     return w
5620
5621 def newcnd():
5622     "Update our alert status."
5623     game.condition = "green"
5624     if game.energy < 1000.0:
5625         game.condition = "yellow"
5626     if game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons or game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans:
5627         game.condition = "red"
5628     if not game.alive:
5629         game.condition="dead"
5630
5631 def newkling():
5632     "Drop new Klingon into current quadrant."
5633     return Enemy('K', loc=dropin(), power=randreal(300,450)+25.0*game.skill)
5634
5635 def sortenemies():
5636     "Sort enemies by distance so 'nearest' is meaningful."
5637     game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
5638
5639 def newqad():
5640     "Set up a new state of quadrant, for when we enter or re-enter it."
5641     game.justin = True
5642     game.iplnet = None
5643     game.neutz = game.inorbit = game.landed = False
5644     game.ientesc = game.iseenit = False
5645     # Create a blank quadrant
5646     game.quad = fill2d(QUADSIZE, lambda i, j: '.')
5647     if game.iscate:
5648         # Attempt to escape Super-commander, so tbeam back!
5649         game.iscate = False
5650         game.ientesc = True
5651     q = game.state.galaxy[game.quadrant.i][game.quadrant.j]
5652     # cope with supernova
5653     if q.supernova:
5654         return
5655     game.klhere = q.klingons
5656     game.irhere = q.romulans
5657     # Position Starship
5658     game.quad[game.sector.i][game.sector.j] = game.ship
5659     game.enemies = []
5660     if q.klingons:
5661         # Position ordinary Klingons
5662         for i in range(game.klhere):
5663             newkling()
5664         # If we need a commander, promote a Klingon
5665         for cmdr in game.state.kcmdr:
5666             if cmdr == game.quadrant:
5667                 e = game.enemies[game.klhere-1]
5668                 game.quad[e.location.i][e.location.j] = 'C'
5669                 e.power = randreal(950,1350) + 50.0*game.skill
5670                 break
5671         # If we need a super-commander, promote a Klingon
5672         if game.quadrant == game.state.kscmdr:
5673             e = game.enemies[0]
5674             game.quad[e.location.i][e.location.j] = 'S'
5675             e.power = randreal(1175.0,  1575.0) + 125.0*game.skill
5676             game.iscate = (game.state.remkl > 1)
5677     # Put in Romulans if needed
5678     for i in range(q.romulans):
5679         Enemy('R', loc=dropin(), power=randreal(400.0,850.0)+50.0*game.skill)
5680     # If quadrant needs a starbase, put it in
5681     if q.starbase:
5682         game.base = dropin('B')
5683     # If quadrant needs a planet, put it in
5684     if q.planet:
5685         game.iplnet = q.planet
5686         if not q.planet.inhabited:
5687             game.plnet = dropin('P')
5688         else:
5689             game.plnet = dropin('@')
5690     # Check for condition
5691     newcnd()
5692     # Check for RNZ
5693     if game.irhere > 0 and game.klhere == 0:
5694         game.neutz = True
5695         if not damaged(DRADIO):
5696             skip(1)
5697             prout(_("LT. Uhura- \"Captain, an urgent message."))
5698             prout(_("  I'll put it on audio.\"  CLICK"))
5699             skip(1)
5700             prout(_("INTRUDER! YOU HAVE VIOLATED THE ROMULAN NEUTRAL ZONE."))
5701             prout(_("LEAVE AT ONCE, OR YOU WILL BE DESTROYED!"))
5702     # Put in THING if needed
5703     if thing == game.quadrant:
5704         Enemy(type='?', loc=dropin(),
5705                   power=randreal(6000,6500.0)+250.0*game.skill)
5706         if not damaged(DSRSENS):
5707             skip(1)
5708             prout(_("Mr. Spock- \"Captain, this is most unusual."))
5709             prout(_("    Please examine your short-range scan.\""))
5710     # Decide if quadrant needs a Tholian; lighten up if skill is low
5711     if game.options & OPTION_THOLIAN:
5712         if (game.skill < SKILL_GOOD and withprob(0.02)) or \
5713             (game.skill == SKILL_GOOD and withprob(0.05)) or \
5714             (game.skill > SKILL_GOOD and withprob(0.08)):
5715             w = Coord()
5716             while True:
5717                 w.i = withprob(0.5) * (QUADSIZE-1)
5718                 w.j = withprob(0.5) * (QUADSIZE-1)
5719                 if game.quad[w.i][w.j] == '.':
5720                     break
5721             game.tholian = Enemy(type='T', loc=w,
5722                                  power=randrange(100, 500) + 25.0*game.skill)
5723             # Reserve unoccupied corners
5724             if game.quad[0][0]=='.':
5725                 game.quad[0][0] = 'X'
5726             if game.quad[0][QUADSIZE-1]=='.':
5727                 game.quad[0][QUADSIZE-1] = 'X'
5728             if game.quad[QUADSIZE-1][0]=='.':
5729                 game.quad[QUADSIZE-1][0] = 'X'
5730             if game.quad[QUADSIZE-1][QUADSIZE-1]=='.':
5731                 game.quad[QUADSIZE-1][QUADSIZE-1] = 'X'
5732     sortenemies()
5733     # And finally the stars
5734     for i in range(q.stars):
5735         dropin('*')
5736     # Put in a few black holes
5737     for i in range(1, 3+1):
5738         if withprob(0.5):
5739             dropin(' ')
5740     # Take out X's in corners if Tholian present
5741     if game.tholian:
5742         if game.quad[0][0]=='X':
5743             game.quad[0][0] = '.'
5744         if game.quad[0][QUADSIZE-1]=='X':
5745             game.quad[0][QUADSIZE-1] = '.'
5746         if game.quad[QUADSIZE-1][0]=='X':
5747             game.quad[QUADSIZE-1][0] = '.'
5748         if game.quad[QUADSIZE-1][QUADSIZE-1]=='X':
5749             game.quad[QUADSIZE-1][QUADSIZE-1] = '.'
5750
5751 def setpassword():
5752     "Set the self-destruct password."
5753     if game.options & OPTION_PLAIN:
5754         while True:
5755             scanner.chew()
5756             proutn(_("Please type in a secret password- "))
5757             scanner.next()
5758             game.passwd = scanner.token
5759             if game.passwd != None:
5760                 break
5761     else:
5762         game.passwd = ""
5763         game.passwd += chr(ord('a')+randrange(26))
5764         game.passwd += chr(ord('a')+randrange(26))
5765         game.passwd += chr(ord('a')+randrange(26))
5766
5767 # Code from sst.c begins here
5768
5769 commands = {
5770     "SRSCAN":           OPTION_TTY,
5771     "STATUS":           OPTION_TTY,
5772     "REQUEST":          OPTION_TTY,
5773     "LRSCAN":           OPTION_TTY,
5774     "PHASERS":          0,
5775     "TORPEDO":          0,
5776     "PHOTONS":          0,
5777     "MOVE":             0,
5778     "SHIELDS":          0,
5779     "DOCK":             0,
5780     "DAMAGES":          0,
5781     "CHART":            0,
5782     "IMPULSE":          0,
5783     "REST":             0,
5784     "WARP":             0,
5785     "SCORE":            0,
5786     "SENSORS":          OPTION_PLANETS,
5787     "ORBIT":            OPTION_PLANETS,
5788     "TRANSPORT":        OPTION_PLANETS,
5789     "MINE":             OPTION_PLANETS,
5790     "CRYSTALS":         OPTION_PLANETS,
5791     "SHUTTLE":          OPTION_PLANETS,
5792     "PLANETS":          OPTION_PLANETS,
5793     "REPORT":           0,
5794     "COMPUTER":         0,
5795     "COMMANDS":         0,
5796     "EMEXIT":           0,
5797     "PROBE":            OPTION_PROBE,
5798     "SAVE":             0,
5799     "FREEZE":           0,      # Synonym for SAVE
5800     "ABANDON":          0,
5801     "DESTRUCT":         0,
5802     "DEATHRAY":         0,
5803     "DEBUG":            0,
5804     "MAYDAY":           0,
5805     "SOS":              0,      # Synonym for MAYDAY
5806     "CALL":             0,      # Synonym for MAYDAY
5807     "QUIT":             0,
5808     "HELP":             0,
5809 }
5810
5811 def listCommands():
5812     "Generate a list of legal commands."
5813     prout(_("LEGAL COMMANDS ARE:"))
5814     emitted = 0
5815     for key in commands:
5816         if not commands[key] or (commands[key] & game.options):
5817             proutn("%-12s " % key)
5818             emitted += 1
5819             if emitted % 5 == 4:
5820                 skip(1)
5821     skip(1)
5822
5823 def helpme():
5824     "Browse on-line help."
5825     key = scanner.next()
5826     while True:
5827         if key == "IHEOL":
5828             setwnd(prompt_window)
5829             proutn(_("Help on what command? "))
5830             key = scanner.next()
5831         setwnd(message_window)
5832         if key == "IHEOL":
5833             return
5834         if scanner.token.upper() in commands or scanner.token == "ABBREV":
5835             break
5836         skip(1)
5837         listCommands()
5838         key = "IHEOL"
5839         scanner.chew()
5840         skip(1)
5841     cmd = scanner.token.upper()
5842     for directory in docpath:
5843         try:
5844             fp = open(os.path.join(directory, "sst.doc"), "r")
5845             break
5846         except IOError:
5847             pass
5848     else:
5849         prout(_("Spock-  \"Captain, that information is missing from the"))
5850         prout(_("   computer. You need to find sst.doc and put it somewhere"))
5851         proutn(_("   in these directories: %s") % ":".join(docpath))
5852         prout(".\"")
5853         # This used to continue: "You need to find SST.DOC and put
5854         # it in the current directory."
5855         return
5856     while True:
5857         linebuf = fp.readline()
5858         if linebuf == '':
5859             prout(_("Spock- \"Captain, there is no information on that command.\""))
5860             fp.close()
5861             return
5862         if linebuf[0] == '%' and linebuf[1] == '%' and linebuf[2] == ' ':
5863             linebuf = linebuf[3:].strip()
5864             if cmd.upper() == linebuf:
5865                 break
5866     skip(1)
5867     prout(_("Spock- \"Captain, I've found the following information:\""))
5868     skip(1)
5869     while True:
5870         linebuf = fp.readline()
5871         if "******" in linebuf:
5872             break
5873         proutn(linebuf)
5874     fp.close()
5875
5876 def makemoves():
5877     "Command-interpretation loop."
5878     clrscr()
5879     setwnd(message_window)
5880     while True:         # command loop
5881         drawmaps(1)
5882         while True:     # get a command
5883             hitme = False
5884             game.optime = game.justin = False
5885             scanner.chew()
5886             setwnd(prompt_window)
5887             clrscr()
5888             proutn("COMMAND> ")
5889             if scanner.next() == "IHEOL":
5890                 if game.options & OPTION_CURSES:
5891                     makechart()
5892                 continue
5893             elif scanner.token == "":
5894                 continue
5895             game.ididit = False
5896             clrscr()
5897             setwnd(message_window)
5898             clrscr()
5899             candidates = filter(lambda x: x.startswith(scanner.token.upper()),
5900                                 commands)
5901             if len(candidates) == 1:
5902                 cmd = candidates[0]
5903                 break
5904             elif candidates and not (game.options & OPTION_PLAIN):
5905                 prout("Commands with prefix '%s': %s" % (scanner.token, " ".join(candidates)))
5906             else:
5907                 listCommands()
5908                 continue
5909         if cmd == "SRSCAN":             # srscan
5910             srscan()
5911         elif cmd == "STATUS":           # status
5912             status()
5913         elif cmd == "REQUEST":          # status request
5914             request()
5915         elif cmd == "LRSCAN":           # long range scan
5916             lrscan(silent=False)
5917         elif cmd == "PHASERS":          # phasers
5918             phasers()
5919             if game.ididit:
5920                 hitme = True
5921         elif cmd in ("TORPEDO", "PHOTONS"):     # photon torpedos
5922             torps()
5923             if game.ididit:
5924                 hitme = True
5925         elif cmd == "MOVE":             # move under warp
5926             warp(wcourse=None, involuntary=False)
5927         elif cmd == "SHIELDS":          # shields
5928             doshield(shraise=False)
5929             if game.ididit:
5930                 hitme = True
5931                 game.shldchg = False
5932         elif cmd == "DOCK":             # dock at starbase
5933             dock(True)
5934             if game.ididit:
5935                 attack(torps_ok=False)
5936         elif cmd == "DAMAGES":          # damage reports
5937             damagereport()
5938         elif cmd == "CHART":            # chart
5939             makechart()
5940         elif cmd == "IMPULSE":          # impulse
5941             impulse()
5942         elif cmd == "REST":             # rest
5943             wait()
5944             if game.ididit:
5945                 hitme = True
5946         elif cmd == "WARP":             # warp
5947             setwarp()
5948         elif cmd == "SCORE":            # score
5949             score()
5950         elif cmd == "SENSORS":          # sensors
5951             sensor()
5952         elif cmd == "ORBIT":            # orbit
5953             orbit()
5954             if game.ididit:
5955                 hitme = True
5956         elif cmd == "TRANSPORT":                # transport "beam"
5957             beam()
5958         elif cmd == "MINE":             # mine
5959             mine()
5960             if game.ididit:
5961                 hitme = True
5962         elif cmd == "CRYSTALS":         # crystals
5963             usecrystals()
5964             if game.ididit:
5965                 hitme = True
5966         elif cmd == "SHUTTLE":          # shuttle
5967             shuttle()
5968             if game.ididit:
5969                 hitme = True
5970         elif cmd == "PLANETS":          # Planet list
5971             survey()
5972         elif cmd == "REPORT":           # Game Report
5973             report()
5974         elif cmd == "COMPUTER":         # use COMPUTER!
5975             eta()
5976         elif cmd == "COMMANDS":
5977             listCommands()
5978         elif cmd == "EMEXIT":           # Emergency exit
5979             clrscr()                    # Hide screen
5980             freeze(True)                # forced save
5981             raise SystemExit,1          # And quick exit
5982         elif cmd == "PROBE":
5983             probe()                     # Launch probe
5984             if game.ididit:
5985                 hitme = True
5986         elif cmd == "ABANDON":          # Abandon Ship
5987             abandon()
5988         elif cmd == "DESTRUCT":         # Self Destruct
5989             selfdestruct()
5990         elif cmd == "SAVE":             # Save Game
5991             freeze(False)
5992             clrscr()
5993             if game.skill > SKILL_GOOD:
5994                 prout(_("WARNING--Saved games produce no plaques!"))
5995         elif cmd == "DEATHRAY":         # Try a desparation measure
5996             deathray()
5997             if game.ididit:
5998                 hitme = True
5999         elif cmd == "DEBUGCMD":         # What do we want for debug???
6000             debugme()
6001         elif cmd == "MAYDAY":           # Call for help
6002             mayday()
6003             if game.ididit:
6004                 hitme = True
6005         elif cmd == "QUIT":
6006             game.alldone = True         # quit the game
6007         elif cmd == "HELP":
6008             helpme()                    # get help
6009         while True:
6010             if game.alldone:
6011                 break           # Game has ended
6012             if game.optime != 0.0:
6013                 events()
6014                 if game.alldone:
6015                     break       # Events did us in
6016             if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
6017                 atover(False)
6018                 continue
6019             if hitme and not game.justin:
6020                 attack(torps_ok=True)
6021                 if game.alldone:
6022                     break
6023                 if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
6024                     atover(False)
6025                     hitme = True
6026                     continue
6027             break
6028         if game.alldone:
6029             break
6030     if game.idebug:
6031         prout("=== Ending")
6032
6033 def cramen(type):
6034     "Emit the name of an enemy or feature."
6035     if   type == 'R': s = _("Romulan")
6036     elif type == 'K': s = _("Klingon")
6037     elif type == 'C': s = _("Commander")
6038     elif type == 'S': s = _("Super-commander")
6039     elif type == '*': s = _("Star")
6040     elif type == 'P': s = _("Planet")
6041     elif type == 'B': s = _("Starbase")
6042     elif type == ' ': s = _("Black hole")
6043     elif type == 'T': s = _("Tholian")
6044     elif type == '#': s = _("Tholian web")
6045     elif type == '?': s = _("Stranger")
6046     elif type == '@': s = _("Inhabited World")
6047     else: s = "Unknown??"
6048     return s
6049
6050 def crmena(stars, enemy, loctype, w):
6051     "Emit the name of an enemy and his location."
6052     buf = ""
6053     if stars:
6054         buf += "***"
6055     buf += cramen(enemy) + _(" at ")
6056     if loctype == "quadrant":
6057         buf += _("Quadrant ")
6058     elif loctype == "sector":
6059         buf += _("Sector ")
6060     return buf + `w`
6061
6062 def crmshp():
6063     "Emit our ship name."
6064     return{'E':_("Enterprise"),'F':_("Faerie Queene")}.get(game.ship,"Ship???")
6065
6066 def stars():
6067     "Emit a line of stars"
6068     prouts("******************************************************")
6069     skip(1)
6070
6071 def expran(avrage):
6072     return -avrage*math.log(1e-7 + randreal())
6073
6074 def randplace(size):
6075     "Choose a random location."
6076     w = Coord()
6077     w.i = randrange(size)
6078     w.j = randrange(size)
6079     return w
6080
6081 class sstscanner:
6082     def __init__(self):
6083         self.type = None
6084         self.token = None
6085         self.real = 0.0
6086         self.inqueue = []
6087     def next(self):
6088         # Get a token from the user
6089         self.real = 0.0
6090         self.token = ''
6091         # Fill the token quue if nothing here
6092         while not self.inqueue:
6093             line = cgetline()
6094             if curwnd==prompt_window:
6095                 clrscr()
6096                 setwnd(message_window)
6097                 clrscr()
6098             if line == '':
6099                 return None
6100             if not line:
6101                 continue
6102             else:
6103                 self.inqueue = line.lstrip().split() + ["\n"]
6104         # From here on in it's all looking at the queue
6105         self.token = self.inqueue.pop(0)
6106         if self.token == "\n":
6107             self.type = "IHEOL"
6108             return "IHEOL"
6109         try:
6110             self.real = float(self.token)
6111             self.type = "IHREAL"
6112             return "IHREAL"
6113         except ValueError:
6114             pass
6115         # Treat as alpha
6116         self.token = self.token.lower()
6117         self.type = "IHALPHA"
6118         self.real = None
6119         return "IHALPHA"
6120     def append(self, tok):
6121         self.inqueue.append(tok)
6122     def push(self, tok):
6123         self.inqueue.insert(0, tok)
6124     def waiting(self):
6125         return self.inqueue
6126     def chew(self):
6127         # Demand input for next scan
6128         self.inqueue = []
6129         self.real = self.token = None
6130     def sees(self, s):
6131         # compares s to item and returns true if it matches to the length of s
6132         return s.startswith(self.token)
6133     def int(self):
6134         # Round token value to nearest integer
6135         return int(round(scanner.real))
6136     def getcoord(self):
6137         s = Coord()
6138         scanner.next()
6139         if scanner.type != "IHREAL":
6140             huh()
6141             return None
6142         s.i = scanner.int()-1
6143         scanner.next()
6144         if scanner.type != "IHREAL":
6145             huh()
6146             return None
6147         s.j = scanner.int()-1
6148         return s
6149     def __repr__(self):
6150         return "<sstcanner: token=%s, type=%s, queue=%s>" % (scanner.token, scanner.type, scanner.inqueue)
6151
6152 def ja():
6153     "Yes-or-no confirmation."
6154     scanner.chew()
6155     while True:
6156         scanner.next()
6157         if scanner.token == 'y':
6158             return True
6159         if scanner.token == 'n':
6160             return False
6161         scanner.chew()
6162         proutn(_("Please answer with \"y\" or \"n\": "))
6163
6164 def huh():
6165     "Complain about unparseable input."
6166     scanner.chew()
6167     skip(1)
6168     prout(_("Beg your pardon, Captain?"))
6169
6170 def debugme():
6171     "Access to the internals for debugging."
6172     proutn("Reset levels? ")
6173     if ja():
6174         if game.energy < game.inenrg:
6175             game.energy = game.inenrg
6176         game.shield = game.inshld
6177         game.torps = game.intorps
6178         game.lsupres = game.inlsr
6179     proutn("Reset damage? ")
6180     if ja():
6181         for i in range(NDEVICES):
6182             if game.damage[i] > 0.0:
6183                 game.damage[i] = 0.0
6184     proutn("Toggle debug flag? ")
6185     if ja():
6186         game.idebug = not game.idebug
6187         if game.idebug:
6188             prout("Debug output ON")
6189         else:
6190             prout("Debug output OFF")
6191     proutn("Cause selective damage? ")
6192     if ja():
6193         for i in range(NDEVICES):
6194             proutn("Kill %s?" % device[i])
6195             scanner.chew()
6196             key = scanner.next()
6197             if key == "IHALPHA" and scanner.sees("y"):
6198                 game.damage[i] = 10.0
6199     proutn("Examine/change events? ")
6200     if ja():
6201         ev = Event()
6202         w = Coord()
6203         legends = {
6204             FSNOVA:  "Supernova       ",
6205             FTBEAM:  "T Beam          ",
6206             FSNAP:   "Snapshot        ",
6207             FBATTAK: "Base Attack     ",
6208             FCDBAS:  "Base Destroy    ",
6209             FSCMOVE: "SC Move         ",
6210             FSCDBAS: "SC Base Destroy ",
6211             FDSPROB: "Probe Move      ",
6212             FDISTR:  "Distress Call   ",
6213             FENSLV:  "Enslavement     ",
6214             FREPRO:  "Klingon Build   ",
6215         }
6216         for i in range(1, NEVENTS):
6217             proutn(legends[i])
6218             if is_scheduled(i):
6219                 proutn("%.2f" % (scheduled(i)-game.state.date))
6220                 if i == FENSLV or i == FREPRO:
6221                     ev = findevent(i)
6222                     proutn(" in %s" % ev.quadrant)
6223             else:
6224                 proutn("never")
6225             proutn("? ")
6226             scanner.chew()
6227             key = scanner.next()
6228             if key == 'n':
6229                 unschedule(i)
6230                 scanner.chew()
6231             elif key == "IHREAL":
6232                 ev = schedule(i, scanner.real)
6233                 if i == FENSLV or i == FREPRO:
6234                     scanner.chew()
6235                     proutn("In quadrant- ")
6236                     key = scanner.next()
6237                     # "IHEOL" says to leave coordinates as they are
6238                     if key != "IHEOL":
6239                         if key != "IHREAL":
6240                             prout("Event %d canceled, no x coordinate." % (i))
6241                             unschedule(i)
6242                             continue
6243                         w.i = int(round(scanner.real))
6244                         key = scanner.next()
6245                         if key != "IHREAL":
6246                             prout("Event %d canceled, no y coordinate." % (i))
6247                             unschedule(i)
6248                             continue
6249                         w.j = int(round(scanner.real))
6250                         ev.quadrant = w
6251         scanner.chew()
6252     proutn("Induce supernova here? ")
6253     if ja():
6254         game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova = True
6255         atover(True)
6256
6257 if __name__ == '__main__':
6258     import getopt, socket
6259     try:
6260         global line, thing, game
6261         game = None
6262         thing = Coord()
6263         thing.angry = False
6264         game = Gamestate()
6265         game.options = OPTION_ALL &~ (OPTION_IOMODES | OPTION_PLAIN | OPTION_ALMY)
6266         if os.getenv("TERM"):
6267             game.options |= OPTION_CURSES
6268         else:
6269             game.options |= OPTION_TTY
6270         seed = int(time.time())
6271         (options, arguments) = getopt.getopt(sys.argv[1:], "r:s:txV")
6272         for (switch, val) in options:
6273             if switch == '-r':
6274                 try:
6275                     replayfp = open(val, "r")
6276                 except IOError:
6277                     sys.stderr.write("sst: can't open replay file %s\n" % val)
6278                     raise SystemExit, 1
6279                 try:
6280                     line = replayfp.readline().strip()
6281                     (leader, key, seed) = line.split()
6282                     seed = eval(seed)
6283                     sys.stderr.write("sst2k: seed set to %s\n" % seed)
6284                     line = replayfp.readline().strip()
6285                     arguments += line.split()[2:]
6286                 except ValueError:
6287                     sys.stderr.write("sst: replay file %s is ill-formed\n"% val)
6288                     raise SystemExit(1)
6289                 game.options |= OPTION_TTY
6290                 game.options &=~ OPTION_CURSES
6291             elif switch == '-s':
6292                 seed = int(val)
6293             elif switch == '-t':
6294                 game.options |= OPTION_TTY
6295                 game.options &=~ OPTION_CURSES
6296             elif switch == '-x':
6297                 game.idebug = True
6298             elif switch == '-V':
6299                 print "SST2K", version
6300                 raise SystemExit, 0
6301             else:
6302                 sys.stderr.write("usage: sst [-t] [-x] [startcommand...].\n")
6303                 raise SystemExit, 1
6304         # where to save the input in case of bugs
6305         if "TMPDIR" in os.environ:
6306             tmpdir = os.environ['TMPDIR']
6307         else:
6308             tmpdir = "/tmp"
6309         try:
6310             logfp = open(os.path.join(tmpdir, "sst-input.log"), "w")
6311         except IOError:
6312             sys.stderr.write("sst: warning, can't open logfile\n")
6313             sys.exit(1)
6314         if logfp:
6315             logfp.write("# seed %s\n" % seed)
6316             logfp.write("# options %s\n" % " ".join(arguments))
6317             logfp.write("# recorded by %s@%s on %s\n" % \
6318                     (getpass.getuser(),socket.gethostname(),time.ctime()))
6319         random.seed(seed)
6320         scanner = sstscanner()
6321         map(scanner.append, arguments)
6322         try:
6323             iostart()
6324             while True: # Play a game
6325                 setwnd(fullscreen_window)
6326                 clrscr()
6327                 prelim()
6328                 setup()
6329                 if game.alldone:
6330                     score()
6331                     game.alldone = False
6332                 else:
6333                     makemoves()
6334                 skip(1)
6335                 stars()
6336                 skip(1)
6337                 if game.tourn and game.alldone:
6338                     proutn(_("Do you want your score recorded?"))
6339                     if ja():
6340                         scanner.chew()
6341                         scanner.push("\n")
6342                         freeze(False)
6343                 scanner.chew()
6344                 proutn(_("Do you want to play again? "))
6345                 if not ja():
6346                     break
6347             skip(1)
6348             prout(_("May the Great Bird of the Galaxy roost upon your home planet."))
6349         finally:
6350             ioend()
6351         raise SystemExit, 0
6352     except KeyboardInterrupt:
6353         if logfp:
6354             logfp.close()
6355         print ""