src/sst.py

   1 #!/usr/bin/env python
   2 """
   3 sst.py =-- Super Star Trek in Python
   4
   5 This code 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.
   8
   9 Dave Matuszek says:
  10
  11 SRSCAN, MOVE, PHASERS, CALL, STATUS, IMPULSE, PHOTONS, ABANDON,
  12 LRSCAN, WARP, SHIELDS, DESTRUCT, CHART, REST, DOCK, QUIT, and DAMAGE
  13 were in the original non-"super" version of UT FORTRAN Star Trek.
  14
  15 Tholians were not in the original. Dave is dubious about their merits.
  16 (They are now controlled by OPTION_THOLIAN and turned off if the game
  17 type is "plain".)
  18
  19 Planets and dilithium crystals were not in the original.  Dave is OK
  20 with this idea. (It's now controlled by OPTION_PLANETS and turned
  21 off if the game type is "plain".)
  22
  23 Dave says the bit about the Galileo getting turned into a
  24 McDonald's is "consistant with our original vision".  (This has been
  25 left permanently enabled, as it can only happen if OPTION_PLANETS
  26 is on.)
  27
  28 Dave also says the Space Thingy should not be preserved across saved
  29 games, so you can't prove to others that you've seen it.  He says it
  30 shouldn't fire back, either.  It should do nothing except scream and
  31 disappear when hit by photon torpedos.  It's OK that it may move
  32 when attacked, but it didn't in the original.  (Whether the Thingy
  33 can fire back is now controlled by OPTION_THINGY and turned off if the
  34 game type is "plain" or "almy".  The no-save behavior has been restored.)
  35
  36 The Faerie Queen, black holes, and time warping were in the original.
  37
  38 Here are Tom Almy's changes:
  39
  40 In early 1997, I got the bright idea to look for references to
  41 "Super Star Trek" on the World Wide Web. There weren't many hits,
  42 but there was one that came up with 1979 Fortran sources! This
  43 version had a few additional features that mine didn't have,
  44 however mine had some feature it didn't have. So I merged its
  45 features that I liked. I also took a peek at the DECUS version (a
  46 port, less sources, to the PDP-10), and some other variations.
  47
  48 1, Compared to the original UT version, I've changed the "help"
  49 command to "call" and the "terminate" command to "quit" to better
  50 match user expectations. The DECUS version apparently made those
  51 changes as well as changing "freeze" to "save". However I like
  52 "freeze".  (Both "freeze" and "save" work in SST2K.)
  53
  54 2. The experimental deathray originally had only a 5% chance of
  55 success, but could be used repeatedly. I guess after a couple
  56 years of use, it was less "experimental" because the 1979
  57 version had a 70% success rate. However it was prone to breaking
  58 after use. I upgraded the deathray, but kept the original set of
  59 failure modes (great humor!).  (Now controlled by OPTION_DEATHRAY
  60 and turned off if game type is "plain".)
  61
  62 3. The 1979 version also mentions srscan and lrscan working when
  63 docked (using the starbase's scanners), so I made some changes here
  64 to do this (and indicating that fact to the player), and then realized
  65 the base would have a subspace radio as well -- doing a Chart when docked
  66 updates the star chart, and all radio reports will be heard. The Dock
  67 command will also give a report if a base is under attack.
  68
  69 4. Tholian Web from the 1979 version.  (Now controlled by
  70 OPTION_THOLIAN and turned off if game type is "plain".)
  71
  72 5. Enemies can ram the Enterprise. (Now controlled by OPTION_RAMMING
  73 and turned off if game type is "plain".)
  74
  75 6. Regular Klingons and Romulans can move in Expert and Emeritus games.
  76 This code could use improvement. (Now controlled by OPTION_MVBADDY
  77 and turned off if game type is "plain".)
  78
  79 7. The deep-space probe feature from the DECUS version.  (Now controlled
  80 by OPTION_PROBE and turned off if game type is "plain").
  81
  82 8. 'emexit' command from the 1979 version.
  83
  84 9. Bugfix: Klingon commander movements are no longer reported if long-range
  85 sensors are damaged.
  86
  87 10. Bugfix: Better base positioning at startup (more spread out).
  88 That made sense to add because most people abort games with
  89 bad base placement.
  90
  91 In June 2002, I fixed two known bugs and a documentation typo.
  92 In June 2004 I fixed a number of bugs involving: 1) parsing invalid
  93 numbers, 2) manual phasers when SR scan is damaged and commander is
  94 present, 3) time warping into the future, 4) hang when moving
  95 klingons in crowded quadrants.  (These fixes are in SST2K.)
  96
  97 Here are Stas Sergeev's changes:
  98
  99 1. The Space Thingy can be shoved, if you ram it, and can fire back if
 100 fired upon. (Now controlled by OPTION_THINGY and turned off if game
 101 type is "plain" or "almy".)
 102
 103 2. When you are docked, base covers you with an almost invincible shield.
 104 (A commander can still ram you, or a Romulan can destroy the base,
 105 or a SCom can even succeed with direct attack IIRC, but this rarely
 106 happens.)  (Now controlled by OPTION_BASE and turned off if game
 107 type is "plain" or "almy".)
 108
 109 3. Ramming a black hole is no longer instant death.  There is a
 110 chance you might get timewarped instead. (Now controlled by
 111 OPTION_BLKHOLE and turned off if game type is "plain" or "almy".)
 112
 113 4. The Tholian can be hit with phasers.
 114
 115 5. SCom can't escape from you if no more enemies remain
 116 (without this, chasing SCom can take an eternity).
 117
 118 6. Probe target you enter is now the destination quadrant. Before I don't
 119 remember what it was, but it was something I had difficulty using.
 120
 121 7. Secret password is now autogenerated.
 122
 123 8. "Plaque" is adjusted for A4 paper :-)
 124
 125 9. Phasers now tells you how much energy needed, but only if the computer
 126 is alive.
 127
 128 10. Planets are auto-scanned when you enter the quadrant.
 129
 130 11. Mining or using crystals in presense of enemy now yields an attack.
 131 There are other minor adjustments to what yields an attack
 132 and what does not.
 133
 134 12. "freeze" command reverts to "save", most people will understand this
 135 better anyway. (SST2K recognizes both.)
 136
 137 13. Screen-oriented interface, with sensor scans always up.  (SST2K
 138 supports both screen-oriented and TTY modes.)
 139
 140 Eric Raymond's changes:
 141
 142 Mainly, I translated this C code out of FORTRAN into C -- created #defines
 143 for a lot of magic numbers and refactored the heck out of it.
 144
 145 1. "sos" and "call" becomes "mayday", "freeze" and "save" are both good.
 146
 147 2. Status report now indicates when dilithium crystals are on board.
 148
 149 3. Per Dave Matuszek's remarks, Thingy state is never saved across games.
 150
 151 4. Added game option selection so you can play a close (but not bug-for-
 152 bug identical) approximation of older versions.
 153
 154 5. Half the quadrants now have inhabited planets, from which one
 155 cannot mine dilithium (there will still be the same additional number
 156 of dilithium-bearing planets).  Torpedoing an inhabited world is *bad*.
 157 There is BSD-Trek-like logic for Klingons to attack and enslave
 158 inhabited worlds, producing more ships (only is skill is 'good' or
 159 better). (Controlled by OPTION_WORLDS and turned off if game
 160 type is "plain" or "almy".)
 161
 162 6. User input is now logged so we can do regression testing.
 163
 164 7. More BSD-Trek features: You can now lose if your entire crew
 165 dies in battle.  When abandoning ship in a game with inhabited
 166 worlds enabled, they must have one in the quadrant to beam down
 167 to; otherwise they die in space and this counts heavily against
 168 your score.  Docking at a starbase replenishes your crew.
 169
 170 8. Still more BSD-Trek: we now have a weighted damage table.
 171 Also, the nav subsystem (enabling automatic course
 172 setting) can be damaged separately from the main computer (which
 173 handles weapons targeting, ETA calculation, and self-destruct).
 174
 175 After these features were added, I translated this into Python and added
 176 more:
 177
 178 9. A long-range scan is done silently whenever you call CHART; thus
 179 the LRSCAN command is no longer needed.  (Controlled by OPTION_AUTOSCAN
 180 and turned off if game type is "plain" or "almy".)
 181 """
 182 import os, sys, math, curses, time, readline, cPickle, random, copy, gettext
 183
 184 SSTDOC          = "/usr/share/doc/sst/sst.doc"
 185 DOC_NAME        = "sst.doc"
 186
 187 def _(str): return gettext.gettext(str)
 188
 189 PHASEFAC        = 2.0
 190 GALSIZE         = 8
 191 NINHAB          = (GALSIZE * GALSIZE / 2)
 192 MAXUNINHAB      = 10
 193 PLNETMAX        = (NINHAB + MAXUNINHAB)
 194 QUADSIZE        = 10
 195 BASEMIN         = 2
 196 BASEMAX         = (GALSIZE * GALSIZE / 12)
 197 MAXKLGAME       = 127
 198 MAXKLQUAD       = 9
 199 FULLCREW        = 428   # BSD Trek was 387, that's wrong
 200 FOREVER         = 1e30
 201 MAXBURST        = 3
 202 MINCMDR         = 10
 203
 204 # How to represent features
 205 IHR = 'R',
 206 IHK = 'K',
 207 IHC = 'C',
 208 IHS = 'S',
 209 IHSTAR = '*',
 210 IHP = 'P',
 211 IHW = '@',
 212 IHB = 'B',
 213 IHBLANK = ' ',
 214 IHDOT = '.',
 215 IHQUEST = '?',
 216 IHE = 'E',
 217 IHF = 'F',
 218 IHT = 'T',
 219 IHWEB = '#',
 220 IHMATER0 = '-',
 221 IHMATER1 = 'o',
 222 IHMATER2 = '0'
 223
 224 class TrekError:
 225     pass
 226
 227 class coord:
 228     def __init__(self, x=None, y=None):
 229         self.i = x
 230         self.j = y
 231     def valid_quadrant(self):
 232         return self.i>=0 and self.i<GALSIZE and self.j>=0 and self.j<GALSIZE
 233     def valid_sector(self):
 234         return self.i>=0 and self.i<QUADSIZE and self.j>=0 and self.j<QUADSIZE
 235     def invalidate(self):
 236         self.i = self.j = None
 237     def is_valid(self):
 238         return self.i != None and self.j != None
 239     def __eq__(self, other):
 240         return other != None and self.i == other.i and self.j == other.j
 241     def __ne__(self, other):
 242         return other == None or self.i != other.i or self.j != other.j
 243     def __add__(self, other):
 244         return coord(self.i+other.i, self.j+other.j)
 245     def __sub__(self, other):
 246         return coord(self.i-other.i, self.j-other.j)
 247     def __mul__(self, other):
 248         return coord(self.i*other, self.j*other)
 249     def __rmul__(self, other):
 250         return coord(self.i*other, self.j*other)
 251     def __div__(self, other):
 252         return coord(self.i/other, self.j/other)
 253     def __mod__(self, other):
 254         return coord(self.i % other, self.j % other)
 255     def __rdiv__(self, other):
 256         return coord(self.i/other, self.j/other)
 257     def roundtogrid(self):
 258         return coord(int(round(self.i)), int(round(self.j)))
 259     def distance(self, other=None):
 260         if not other: other = coord(0, 0)
 261         return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
 262     def bearing(self, other=None):
 263         if not other: other = coord(0, 0)
 264         return 1.90985*math.atan2(self.j-other.j, self.i-other.i)
 265     def sgn(self):
 266         s = coord()
 267         if self.i == 0:
 268             s.i = 0
 269         else:
 270             s.i = self.i / abs(self.i)
 271         if self.j == 0:
 272             s.j = 0
 273         else:
 274             s.j = self.j / abs(self.j)
 275         return s
 276     def quadrant(self):
 277         #print "Location %s -> %s" % (self, (self / QUADSIZE).roundtogrid())
 278         return self.roundtogrid() / QUADSIZE
 279     def sector(self):
 280         return self.roundtogrid() % QUADSIZE
 281     def scatter(self):
 282         s = coord()
 283         s.i = self.i + randrange(-1, 2)
 284         s.j = self.j + randrange(-1, 2)
 285         return s
 286     def __str__(self):
 287         if self.i == None or self.j == None:
 288             return "Nowhere"
 289         return "%s - %s" % (self.i+1, self.j+1)
 290     __repr__ = __str__
 291
 292 class planet:
 293     def __init__(self):
 294         self.name = None        # string-valued if inhabited
 295         self.quadrant = coord() # quadrant located
 296         self.pclass = None      # could be ""M", "N", "O", or "destroyed"
 297         self.crystals = "absent"# could be "mined", "present", "absent"
 298         self.known = "unknown"  # could be "unknown", "known", "shuttle_down"
 299         self.inhabited = False  # is it inhabites?
 300     def __str__(self):
 301         return self.name
 302
 303 class quadrant:
 304     def __init__(self):
 305         self.stars = 0
 306         self.planet = None
 307         self.starbase = False
 308         self.klingons = 0
 309         self.romulans = 0
 310         self.supernova = False
 311         self.charted = False
 312         self.status = "secure"  # Could be "secure", "distressed", "enslaved"
 313
 314 class page:
 315     def __init__(self):
 316         self.stars = None
 317         self.starbase = None
 318         self.klingons = None
 319
 320 def fill2d(size, fillfun):
 321     "Fill an empty list in 2D."
 322     lst = []
 323     for i in range(size):
 324         lst.append([])
 325         for j in range(size):
 326             lst[i].append(fillfun(i, j))
 327     return lst
 328
 329 class snapshot:
 330     def __init__(self):
 331         self.snap = False       # snapshot taken
 332         self.crew = 0           # crew complement
 333         self.remkl = 0          # remaining klingons
 334         self.nscrem = 0         # remaining super commanders
 335         self.starkl = 0         # destroyed stars
 336         self.basekl = 0         # destroyed bases
 337         self.nromrem = 0        # Romulans remaining
 338         self.nplankl = 0        # destroyed uninhabited planets
 339         self.nworldkl = 0       # destroyed inhabited planets
 340         self.planets = []       # Planet information
 341         self.date = 0.0         # stardate
 342         self.remres = 0         # remaining resources
 343         self.remtime = 0        # remaining time
 344         self.baseq = []         # Base quadrant coordinates
 345         self.kcmdr = []         # Commander quadrant coordinates
 346         self.kscmdr = coord()   # Supercommander quadrant coordinates
 347         # the galaxy
 348         self.galaxy = fill2d(GALSIZE, lambda i, j: quadrant())
 349         # the starchart
 350         self.chart = fill2d(GALSIZE, lambda i, j: page())
 351
 352 class event:
 353     def __init__(self):
 354         self.date = None        # A real number
 355         self.quadrant = None    # A coord structure
 356
 357 # game options
 358 OPTION_ALL      = 0xffffffff
 359 OPTION_TTY      = 0x00000001    # old interface
 360 OPTION_CURSES   = 0x00000002    # new interface
 361 OPTION_IOMODES  = 0x00000003    # cover both interfaces
 362 OPTION_PLANETS  = 0x00000004    # planets and mining
 363 OPTION_THOLIAN  = 0x00000008    # Tholians and their webs (UT 1979 version)
 364 OPTION_THINGY   = 0x00000010    # Space Thingy can shoot back (Stas, 2005)
 365 OPTION_PROBE    = 0x00000020    # deep-space probes (DECUS version, 1980)
 366 OPTION_SHOWME   = 0x00000040    # bracket Enterprise in chart
 367 OPTION_RAMMING  = 0x00000080    # enemies may ram Enterprise (Almy)
 368 OPTION_MVBADDY  = 0x00000100    # more enemies can move (Almy)
 369 OPTION_BLKHOLE  = 0x00000200    # black hole may timewarp you (Stas, 2005)
 370 OPTION_BASE     = 0x00000400    # bases have good shields (Stas, 2005)
 371 OPTION_WORLDS   = 0x00000800    # logic for inhabited worlds (ESR, 2006)
 372 OPTION_AUTOSCAN = 0x00001000    # automatic LRSCAN before CHART (ESR, 2006)
 373 OPTION_PLAIN    = 0x01000000    # user chose plain game
 374 OPTION_ALMY     = 0x02000000    # user chose Almy variant
 375
 376 # Define devices
 377 DSRSENS = 0
 378 DLRSENS = 1
 379 DPHASER = 2
 380 DPHOTON = 3
 381 DLIFSUP = 4
 382 DWARPEN = 5
 383 DIMPULS = 6
 384 DSHIELD = 7
 385 DRADIO  = 0
 386 DSHUTTL = 9
 387 DCOMPTR = 10
 388 DNAVSYS = 11
 389 DTRANSP = 12
 390 DSHCTRL = 13
 391 DDRAY   = 14
 392 DDSP    = 15
 393 NDEVICES= 16    # Number of devices
 394
 395 SKILL_NONE      = 0
 396 SKILL_NOVICE    = 1
 397 SKILL_FAIR      = 2
 398 SKILL_GOOD      = 3
 399 SKILL_EXPERT    = 4
 400 SKILL_EMERITUS  = 5
 401
 402 def damaged(dev):       return (game.damage[dev] != 0.0)
 403 def communicating():    return not damaged(DRADIO) or game.condition=="docked"
 404
 405 # Define future events
 406 FSPY    = 0     # Spy event happens always (no future[] entry)
 407                 # can cause SC to tractor beam Enterprise
 408 FSNOVA  = 1     # Supernova
 409 FTBEAM  = 2     # Commander tractor beams Enterprise
 410 FSNAP   = 3     # Snapshot for time warp
 411 FBATTAK = 4     # Commander attacks base
 412 FCDBAS  = 5     # Commander destroys base
 413 FSCMOVE = 6     # Supercommander moves (might attack base)
 414 FSCDBAS = 7     # Supercommander destroys base
 415 FDSPROB = 8     # Move deep space probe
 416 FDISTR  = 9     # Emit distress call from an inhabited world
 417 FENSLV  = 10    # Inhabited word is enslaved */
 418 FREPRO  = 11    # Klingons build a ship in an enslaved system
 419 NEVENTS = 12
 420
 421 #
 422 # abstract out the event handling -- underlying data structures will change
 423 # when we implement stateful events
 424 #
 425 def findevent(evtype):  return game.future[evtype]
 426
 427 class enemy:
 428     def __init__(self, type=None, loc=None, power=None):
 429         self.type = type
 430         self.kloc = coord()
 431         if loc:
 432             self.move(loc)
 433         self.kpower = power     # enemy energy level
 434         game.enemies.append(self)
 435     def move(self, loc):
 436         motion = (loc != self.kloc)
 437         if self.kloc.i is not None and self.kloc.j is not None:
 438             if motion:
 439                 if self.type == IHT:
 440                     game.quad[self.kloc.i][self.kloc.j] = IHWEB
 441                 else:
 442                     game.quad[self.kloc.i][self.kloc.j] = IHDOT
 443         if loc:
 444             self.kloc = copy.copy(loc)
 445             game.quad[self.kloc.i][self.kloc.j] = self.type
 446             self.kdist = self.kavgd = (game.sector - loc).distance()
 447         else:
 448             self.kloc = coord()
 449             self.kdist = self.kavgd = None
 450             game.enemies.remove(self)
 451         return motion
 452     def __repr__(self):
 453         return "<%s,%s.%f>" % (self.type, self.kloc, self.kpower)       # For debugging
 454
 455 class gamestate:
 456     def __init__(self):
 457         self.options = None     # Game options
 458         self.state = snapshot() # A snapshot structure
 459         self.snapsht = snapshot()       # Last snapshot taken for time-travel purposes
 460         self.quad = None        # contents of our quadrant
 461         self.damage = [0.0] * NDEVICES  # damage encountered
 462         self.future = []                # future events
 463         for i in range(NEVENTS):
 464             self.future.append(event())
 465         self.passwd  = None;            # Self Destruct password
 466         self.enemies = []
 467         self.quadrant = None    # where we are in the large
 468         self.sector = None      # where we are in the small
 469         self.tholian = None     # Tholian enemy object
 470         self.base = None        # position of base in current quadrant
 471         self.battle = None      # base coordinates being attacked
 472         self.plnet = None       # location of planet in quadrant
 473         self.gamewon = False    # Finished!
 474         self.ididit = False     # action taken -- allows enemy to attack
 475         self.alive = False      # we are alive (not killed)
 476         self.justin = False     # just entered quadrant
 477         self.shldup = False     # shields are up
 478         self.shldchg = False    # shield is changing (affects efficiency)
 479         self.iscate = False     # super commander is here
 480         self.ientesc = False    # attempted escape from supercommander
 481         self.resting = False    # rest time
 482         self.icraft = False     # Kirk in Galileo
 483         self.landed = False     # party on planet (true), on ship (false)
 484         self.alldone = False    # game is now finished
 485         self.neutz = False      # Romulan Neutral Zone
 486         self.isarmed = False    # probe is armed
 487         self.inorbit = False    # orbiting a planet
 488         self.imine = False      # mining
 489         self.icrystl = False    # dilithium crystals aboard
 490         self.iseenit = False    # seen base attack report
 491         self.thawed = False     # thawed game
 492         self.condition = None   # "green", "yellow", "red", "docked", "dead"
 493         self.iscraft = None     # "onship", "offship", "removed"
 494         self.skill = None       # Player skill level
 495         self.inkling = 0        # initial number of klingons
 496         self.inbase = 0         # initial number of bases
 497         self.incom = 0          # initial number of commanders
 498         self.inscom = 0         # initial number of commanders
 499         self.inrom = 0          # initial number of commanders
 500         self.instar = 0         # initial stars
 501         self.intorps = 0        # initial/max torpedoes
 502         self.torps = 0          # number of torpedoes
 503         self.ship = 0           # ship type -- 'E' is Enterprise
 504         self.abandoned = 0      # count of crew abandoned in space
 505         self.length = 0         # length of game
 506         self.klhere = 0         # klingons here
 507         self.casual = 0         # causalties
 508         self.nhelp = 0          # calls for help
 509         self.nkinks = 0         # count of energy-barrier crossings
 510         self.iplnet = None      # planet # in quadrant
 511         self.inplan = 0         # initial planets
 512         self.irhere = 0         # Romulans in quadrant
 513         self.isatb = 0          # =1 if super commander is attacking base
 514         self.tourn = None       # tournament number
 515         self.nprobes = 0        # number of probes available
 516         self.inresor = 0.0      # initial resources
 517         self.intime = 0.0       # initial time
 518         self.inenrg = 0.0       # initial/max energy
 519         self.inshld = 0.0       # initial/max shield
 520         self.inlsr = 0.0        # initial life support resources
 521         self.indate = 0.0       # initial date
 522         self.energy = 0.0       # energy level
 523         self.shield = 0.0       # shield level
 524         self.warpfac = 0.0      # warp speed
 525         self.wfacsq = 0.0       # squared warp factor
 526         self.lsupres = 0.0      # life support reserves
 527         self.optime = 0.0       # time taken by current operation
 528         self.docfac = 0.0       # repair factor when docking (constant?)
 529         self.damfac = 0.0       # damage factor
 530         self.lastchart = 0.0    # time star chart was last updated
 531         self.cryprob = 0.0      # probability that crystal will work
 532         self.probe = None       # object holding probe course info
 533         self.height = 0.0       # height of orbit around planet
 534     def recompute(self):
 535         # Stas thinks this should be (C expression):
 536         # game.state.remkl + len(game.state.kcmdr) > 0 ?
 537         #       game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) : 99
 538         # He says the existing expression is prone to divide-by-zero errors
 539         # after killing the last klingon when score is shown -- perhaps also
 540         # if the only remaining klingon is SCOM.
 541         game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr))
 542
 543 IHR = 'R'
 544 IHK = 'K'
 545 IHC = 'C'
 546 IHS = 'S'
 547 IHSTAR = '*'
 548 IHP = 'P'
 549 IHW = '@'
 550 IHB = 'B'
 551 IHBLANK = ' '
 552 IHDOT = '.'
 553 IHQUEST = '?'
 554 IHE = 'E'
 555 IHF = 'F'
 556 IHT = 'T'
 557 IHWEB = '#'
 558 IHMATER0 = '-'
 559 IHMATER1 = 'o'
 560 IHMATER2 = '0'
 561
 562 FWON = 0
 563 FDEPLETE = 1
 564 FLIFESUP = 2
 565 FNRG = 3
 566 FBATTLE = 4
 567 FNEG3 = 5
 568 FNOVA = 6
 569 FSNOVAED = 7
 570 FABANDN = 8
 571 FDILITHIUM = 9
 572 FMATERIALIZE = 10
 573 FPHASER = 11
 574 FLOST = 12
 575 FMINING = 13
 576 FDPLANET = 14
 577 FPNOVA = 15
 578 FSSC = 16
 579 FSTRACTOR = 17
 580 FDRAY = 18
 581 FTRIBBLE = 19
 582 FHOLE = 20
 583 FCREW = 21
 584
 585 def withprob(p):
 586     v = random.random()
 587     #logfp.write("# withprob(%s) -> %f (%s) at %s\n" % (p, v, v<p, traceback.extract_stack()[-2][1:]))
 588     return v < p
 589
 590 def randrange(*args):
 591     v = random.randrange(*args)
 592     #logfp.write("# randrange%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
 593     return v
 594
 595 def randreal(*args):
 596     v = random.random()
 597     if len(args) == 1:
 598         v *= args[0]            # returns from [0, args[0])
 599     elif len(args) == 2:
 600         v = args[0] + v*(args[1]-args[0])       # returns from [args[0], args[1])
 601     #logfp.write("# randreal%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
 602     return v
 603
 604 # Code from ai.c begins here
 605
 606 def welcoming(iq):
 607     "Would this quadrant welcome another Klingon?"
 608     return iq.valid_quadrant() and \
 609         not game.state.galaxy[iq.i][iq.j].supernova and \
 610         game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD
 611
 612 def tryexit(enemy, look, irun):
 613     "A bad guy attempts to bug out."
 614     iq = coord()
 615     iq.i = game.quadrant.i+(look.i+(QUADSIZE-1))/QUADSIZE - 1
 616     iq.j = game.quadrant.j+(look.j+(QUADSIZE-1))/QUADSIZE - 1
 617     if not welcoming(iq):
 618         return False;
 619     if enemy.type == IHR:
 620         return False; # Romulans cannot escape!
 621     if not irun:
 622         # avoid intruding on another commander's territory
 623         if enemy.type == IHC:
 624             if iq in game.state.kcmdr:
 625                 return False
 626             # refuse to leave if currently attacking starbase
 627             if game.battle == game.quadrant:
 628                 return False
 629         # don't leave if over 1000 units of energy
 630         if enemy.kpower > 1000.0:
 631             return False
 632     # emit escape message and move out of quadrant.
 633     # we know this if either short or long range sensors are working
 634     if not damaged(DSRSENS) or not damaged(DLRSENS) or \
 635         game.condition == "docked":
 636         prout(crmena(True, enemy.type, "sector", enemy.kloc) + \
 637               (_(" escapes to Quadrant %s (and regains strength).") % q))
 638     # handle local matters related to escape
 639     enemy.move(None)
 640     game.klhere -= 1
 641     if game.condition != "docked":
 642         newcnd()
 643     # Handle global matters related to escape
 644     game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
 645     game.state.galaxy[iq.i][iq.j].klingons += 1
 646     if enemy.type==IHS:
 647         game.iscate = False
 648         game.ientesc = False
 649         game.isatb = 0
 650         schedule(FSCMOVE, 0.2777)
 651         unschedule(FSCDBAS)
 652         game.state.kscmdr=iq
 653     else:
 654         for cmdr in game.state.kcmdr:
 655             if cmdr == game.quadrant:
 656                 game.state.kcmdr[n] = iq
 657                 break
 658     return True; # success
 659
 660 # The bad-guy movement algorithm:
 661 #
 662 # 1. Enterprise has "force" based on condition of phaser and photon torpedoes.
 663 # If both are operating full strength, force is 1000. If both are damaged,
 664 # force is -1000. Having shields down subtracts an additional 1000.
 665 #
 666 # 2. Enemy has forces equal to the energy of the attacker plus
 667 # 100*(K+R) + 500*(C+S) - 400 for novice through good levels OR
 668 # 346*K + 400*R + 500*(C+S) - 400 for expert and emeritus.
 669 #
 670 # Attacker Initial energy levels (nominal):
 671 # Klingon   Romulan   Commander   Super-Commander
 672 # Novice    400        700        1200
 673 # Fair      425        750        1250
 674 # Good      450        800        1300        1750
 675 # Expert    475        850        1350        1875
 676 # Emeritus  500        900        1400        2000
 677 # VARIANCE   75        200         200         200
 678 #
 679 # Enemy vessels only move prior to their attack. In Novice - Good games
 680 # only commanders move. In Expert games, all enemy vessels move if there
 681 # is a commander present. In Emeritus games all enemy vessels move.
 682 #
 683 # 3. If Enterprise is not docked, an aggressive action is taken if enemy
 684 # forces are 1000 greater than Enterprise.
 685 #
 686 # Agressive action on average cuts the distance between the ship and
 687 # the enemy to 1/4 the original.
 688 #
 689 # 4.  At lower energy advantage, movement units are proportional to the
 690 # advantage with a 650 advantage being to hold ground, 800 to move forward
 691 # 1, 950 for two, 150 for back 4, etc. Variance of 100.
 692 #
 693 # If docked, is reduced by roughly 1.75*game.skill, generally forcing a
 694 # retreat, especially at high skill levels.
 695 #
 696 # 5.  Motion is limited to skill level, except for SC hi-tailing it out.
 697
 698 def movebaddy(enemy):
 699     "Tactical movement for the bad guys."
 700     next = coord(); look = coord()
 701     irun = False
 702     # This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
 703     if game.skill >= SKILL_EXPERT:
 704         nbaddys = (((game.quadrant in game.state.kcmdr)*2 + (game.state.kscmdr==game.quadrant)*2+game.klhere*1.23+game.irhere*1.5)/2.0)
 705     else:
 706         nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
 707     dist1 = enemy.kdist
 708     mdist = int(dist1 + 0.5); # Nearest integer distance
 709     # If SC, check with spy to see if should hi-tail it
 710     if enemy.type==IHS and \
 711         (enemy.kpower <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
 712         irun = True
 713         motion = -QUADSIZE
 714     else:
 715         # decide whether to advance, retreat, or hold position
 716         forces = enemy.kpower+100.0*len(game.enemies)+400*(nbaddys-1)
 717         if not game.shldup:
 718             forces += 1000; # Good for enemy if shield is down!
 719         if not damaged(DPHASER) or not damaged(DPHOTON):
 720             if damaged(DPHASER): # phasers damaged
 721                 forces += 300.0
 722             else:
 723                 forces -= 0.2*(game.energy - 2500.0)
 724             if damaged(DPHOTON): # photon torpedoes damaged
 725                 forces += 300.0
 726             else:
 727                 forces -= 50.0*game.torps
 728         else:
 729             # phasers and photon tubes both out!
 730             forces += 1000.0
 731         motion = 0
 732         if forces <= 1000.0 and game.condition != "docked": # Typical situation
 733             motion = ((forces + randreal(200))/150.0) - 5.0
 734         else:
 735             if forces > 1000.0: # Very strong -- move in for kill
 736                 motion = (1.0 - randreal())**2 * dist1 + 1.0
 737             if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off !
 738                 motion -= game.skill*(2.0-randreal()**2)
 739         if idebug:
 740             proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces))
 741         # don't move if no motion
 742         if motion==0:
 743             return
 744         # Limit motion according to skill
 745         if abs(motion) > game.skill:
 746             if motion < 0:
 747                 motion = -game.skill
 748             else:
 749                 motion = game.skill
 750     # calculate preferred number of steps
 751     nsteps = abs(int(motion))
 752     if motion > 0 and nsteps > mdist:
 753         nsteps = mdist; # don't overshoot
 754     if nsteps > QUADSIZE:
 755         nsteps = QUADSIZE; # This shouldn't be necessary
 756     if nsteps < 1:
 757         nsteps = 1; # This shouldn't be necessary
 758     if idebug:
 759         proutn("NSTEPS = %d:" % nsteps)
 760     # Compute preferred values of delta X and Y
 761     m = game.sector - enemy.kloc
 762     if 2.0 * abs(m.i) < abs(m.j):
 763         m.i = 0
 764     if 2.0 * abs(m.j) < abs(game.sector.i-enemy.kloc.i):
 765         m.j = 0
 766     m = (motion * m).sgn()
 767     next = enemy.kloc
 768     # main move loop
 769     for ll in range(nsteps):
 770         if idebug:
 771             proutn(" %d" % (ll+1))
 772         # Check if preferred position available
 773         look = next + m
 774         if m.i < 0:
 775             krawli = 1
 776         else:
 777             krawli = -1
 778         if m.j < 0:
 779             krawlj = 1
 780         else:
 781             krawlj = -1
 782         success = False
 783         attempts = 0; # Settle mysterious hang problem
 784         while attempts < 20 and not success:
 785             attempts += 1
 786             if look.i < 0 or look.i >= QUADSIZE:
 787                 if motion < 0 and tryexit(enemy, look, irun):
 788                     return
 789                 if krawli == m.i or m.j == 0:
 790                     break
 791                 look.i = next.i + krawli
 792                 krawli = -krawli
 793             elif look.j < 0 or look.j >= QUADSIZE:
 794                 if motion < 0 and tryexit(enemy, look, irun):
 795                     return
 796                 if krawlj == m.j or m.i == 0:
 797                     break
 798                 look.j = next.j + krawlj
 799                 krawlj = -krawlj
 800             elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != IHDOT:
 801                 # See if enemy should ram ship
 802                 if game.quad[look.i][look.j] == game.ship and \
 803                     (enemy.type == IHC or enemy.type == IHS):
 804                     collision(rammed=True, enemy=enemy)
 805                     return
 806                 if krawli != m.i and m.j != 0:
 807                     look.i = next.i + krawli
 808                     krawli = -krawli
 809                 elif krawlj != m.j and m.i != 0:
 810                     look.j = next.j + krawlj
 811                     krawlj = -krawlj
 812                 else:
 813                     break; # we have failed
 814             else:
 815                 success = True
 816         if success:
 817             next = look
 818             if idebug:
 819                 proutn(`next`)
 820         else:
 821             break; # done early
 822     if idebug:
 823         skip(1)
 824     if enemy.move(next):
 825         if not damaged(DSRSENS) or game.condition == "docked":
 826             proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.kloc))
 827             if enemy.kdist < dist1:
 828                 proutn(_(" advances to "))
 829             else:
 830                 proutn(_(" retreats to "))
 831             prout("Sector %s." % next)
 832
 833 def moveklings():
 834     "Sequence Klingon tactical movement."
 835     if idebug:
 836         prout("== MOVCOM")
 837     # Figure out which Klingon is the commander (or Supercommander)
 838     # and do move
 839     if game.quadrant in game.state.kcmdr:
 840         for enemy in game.enemies:
 841             if enemy.type == IHC:
 842                 movebaddy(enemy)
 843     if game.state.kscmdr==game.quadrant:
 844         for enemy in game.enemies:
 845             if enemy.type == IHS:
 846                 movebaddy(enemy)
 847                 break
 848     # If skill level is high, move other Klingons and Romulans too!
 849     # Move these last so they can base their actions on what the
 850     # commander(s) do.
 851     if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
 852         for enemy in game.enemies:
 853             if enemy.type in (IHK, IHR):
 854                 movebaddy(enemy)
 855     game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
 856
 857 def movescom(iq, avoid):
 858     "Commander movement helper."
 859     # Avoid quadrants with bases if we want to avoid Enterprise
 860     if not welcoming(iq) or (avoid and iq in game.state.baseq):
 861         return False
 862     if game.justin and not game.iscate:
 863         return False
 864     # do the move
 865     game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons -= 1
 866     game.state.kscmdr = iq
 867     game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons += 1
 868     if game.state.kscmdr==game.quadrant:
 869         # SC has scooted, Remove him from current quadrant
 870         game.iscate=False
 871         game.isatb=0
 872         game.ientesc = False
 873         unschedule(FSCDBAS)
 874         for enemy in game.enemies:
 875             if enemy.type == IHS:
 876                 break
 877         enemy.move(None)
 878         game.klhere -= 1
 879         if game.condition != "docked":
 880             newcnd()
 881         game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
 882     # check for a helpful planet
 883     for i in range(game.inplan):
 884         if game.state.planets[i].quadrant == game.state.kscmdr and \
 885             game.state.planets[i].crystals == "present":
 886             # destroy the planet
 887             game.state.planets[i].pclass = "destroyed"
 888             game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].planet = None
 889             if communicating():
 890                 announce()
 891                 prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
 892                 proutn(_("   a planet in Quadrant %s has been destroyed") % game.state.kscmdr)
 893                 prout(_("   by the Super-commander.\""))
 894             break
 895     return True; # looks good!
 896
 897 def supercommander():
 898     "Move the Super Commander."
 899     iq = coord(); sc = coord(); ibq = coord(); idelta = coord()
 900     basetbl = []
 901     if idebug:
 902         prout("== SUPERCOMMANDER")
 903     # Decide on being active or passive
 904     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 \
 905             (game.state.date-game.indate) < 3.0)
 906     if not game.iscate and avoid:
 907         # compute move away from Enterprise
 908         idelta = game.state.kscmdr-game.quadrant
 909         if idelta.distance() > 2.0:
 910             # circulate in space
 911             idelta.i = game.state.kscmdr.j-game.quadrant.j
 912             idelta.j = game.quadrant.i-game.state.kscmdr.i
 913     else:
 914         # compute distances to starbases
 915         if not game.state.baseq:
 916             # nothing left to do
 917             unschedule(FSCMOVE)
 918             return
 919         sc = game.state.kscmdr
 920         for base in game.state.baseq:
 921             basetbl.append((i, (base - sc).distance()))
 922         if game.state.baseq > 1:
 923             basetbl.sort(lambda x, y: cmp(x[1]. y[1]))
 924         # look for nearest base without a commander, no Enterprise, and
 925         # without too many Klingons, and not already under attack.
 926         ifindit = iwhichb = 0
 927         for (i2, base) in enumerate(game.state.baseq):
 928             i = basetbl[i2][0]; # bug in original had it not finding nearest
 929             if base==game.quadrant or base==game.battle or not welcoming(base):
 930                 continue
 931             # if there is a commander, and no other base is appropriate,
 932             # we will take the one with the commander
 933             for cmdr in game.state.kcmdr:
 934                 if base == cmdr and ifindit != 2:
 935                     ifindit = 2
 936                     iwhichb = i
 937                     break
 938             else:       # no commander -- use this one
 939                 ifindit = 1
 940                 iwhichb = i
 941                 break
 942         if ifindit==0:
 943             return # Nothing suitable -- wait until next time
 944         ibq = game.state.baseq[iwhichb]
 945         # decide how to move toward base
 946         idelta = ibq - game.state.kscmdr
 947     # Maximum movement is 1 quadrant in either or both axes
 948     idelta = idelta.sgn()
 949     # try moving in both x and y directions
 950     # there was what looked like a bug in the Almy C code here,
 951     # but it might be this translation is just wrong.
 952     iq = game.state.kscmdr + idelta
 953     if not movescom(iq, avoid):
 954         # failed -- try some other maneuvers
 955         if idelta.i==0 or idelta.j==0:
 956             # attempt angle move
 957             if idelta.i != 0:
 958                 iq.j = game.state.kscmdr.j + 1
 959                 if not movescom(iq, avoid):
 960                     iq.j = game.state.kscmdr.j - 1
 961                     movescom(iq, avoid)
 962             elif idelta.j != 0:
 963                 iq.i = game.state.kscmdr.i + 1
 964                 if not movescom(iq, avoid):
 965                     iq.i = game.state.kscmdr.i - 1
 966                     movescom(iq, avoid)
 967         else:
 968             # try moving just in x or y
 969             iq.j = game.state.kscmdr.j
 970             if not movescom(iq, avoid):
 971                 iq.j = game.state.kscmdr.j + idelta.j
 972                 iq.i = game.state.kscmdr.i
 973                 movescom(iq, avoid)
 974     # check for a base
 975     if len(game.state.baseq) == 0:
 976         unschedule(FSCMOVE)
 977     else:
 978         for ibq in game.state.baseq:
 979             if ibq == game.state.kscmdr and game.state.kscmdr == game.battle:
 980                 # attack the base
 981                 if avoid:
 982                     return # no, don't attack base!
 983                 game.iseenit = False
 984                 game.isatb = 1
 985                 schedule(FSCDBAS, randreal(1.0, 3.0))
 986                 if is_scheduled(FCDBAS):
 987                     postpone(FSCDBAS, scheduled(FCDBAS)-game.state.date)
 988                 if not communicating():
 989                     return # no warning
 990                 game.iseenit = True
 991                 announce()
 992                 prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") \
 993                       % game.state.kscmdr)
 994                 prout(_("   reports that it is under attack from the Klingon Super-commander."))
 995                 proutn(_("   It can survive until stardate %d.\"") \
 996                        % int(scheduled(FSCDBAS)))
 997                 if not game.resting:
 998                     return
 999                 prout(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
1000                 if ja() == False:
1001                     return
1002                 game.resting = False
1003                 game.optime = 0.0; # actually finished
1004                 return
1005     # Check for intelligence report
1006     if not idebug and \
1007         (withprob(0.8) or \
1008          (not communicating()) or \
1009          not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].charted):
1010         return
1011     announce()
1012     prout(_("Lt. Uhura-  \"Captain, Starfleet Intelligence reports"))
1013     proutn(_("   the Super-commander is in Quadrant %s,") % game.state.kscmdr)
1014     return
1015
1016 def movetholian():
1017     "Move the Tholian."
1018     if not game.tholian or game.justin:
1019         return
1020     id = coord()
1021     if game.tholian.kloc.i == 0 and game.tholian.kloc.j == 0:
1022         id.i = 0; id.j = QUADSIZE-1
1023     elif game.tholian.kloc.i == 0 and game.tholian.kloc.j == QUADSIZE-1:
1024         id.i = QUADSIZE-1; id.j = QUADSIZE-1
1025     elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == QUADSIZE-1:
1026         id.i = QUADSIZE-1; id.j = 0
1027     elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == 0:
1028         id.i = 0; id.j = 0
1029     else:
1030         # something is wrong!
1031         game.tholian.move(None)
1032         prout("***Internal error: Tholian in a bad spot.")
1033         return
1034     # do nothing if we are blocked
1035     if game.quad[id.i][id.j] not in (IHDOT, IHWEB):
1036         return
1037     here = copy.copy(game.tholian.kloc)
1038     delta = (id - game.tholian.kloc).sgn()
1039     # move in x axis
1040     while here.i != id.i:
1041         here.i += delta.i
1042         if game.quad[here.i][here.j]==IHDOT:
1043             game.tholian.move(here)
1044     # move in y axis
1045     while here.j != id.j:
1046         here.j += delta.j
1047         if game.quad[here.i][here.j]==IHDOT:
1048             game.tholian.move(here)
1049     # check to see if all holes plugged
1050     for i in range(QUADSIZE):
1051         if game.quad[0][i]!=IHWEB and game.quad[0][i]!=IHT:
1052             return
1053         if game.quad[QUADSIZE-1][i]!=IHWEB and game.quad[QUADSIZE-1][i]!=IHT:
1054             return
1055         if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT:
1056             return
1057         if game.quad[i][QUADSIZE-1]!=IHWEB and game.quad[i][QUADSIZE-1]!=IHT:
1058             return
1059     # All plugged up -- Tholian splits
1060     game.quad[game.tholian.kloc.i][game.tholian.kloc.j]=IHWEB
1061     dropin(IHBLANK)
1062     prout(crmena(True, IHT, "sector", game.tholian) + _(" completes web."))
1063     game.tholian.move(None)
1064     return
1065
1066 # Code from battle.c begins here
1067
1068 def doshield(shraise):
1069     "Change shield status."
1070     action = "NONE"
1071     game.ididit = False
1072     if shraise:
1073         action = "SHUP"
1074     else:
1075         key = scanner.next()
1076         if key == "IHALPHA":
1077             if scanner.sees("transfer"):
1078                 action = "NRG"
1079             else:
1080                 if damaged(DSHIELD):
1081                     prout(_("Shields damaged and down."))
1082                     return
1083                 if scanner.sees("up"):
1084                     action = "SHUP"
1085                 elif scanner.sees("down"):
1086                     action = "SHDN"
1087         if action=="NONE":
1088             proutn(_("Do you wish to change shield energy? "))
1089             if ja() == True:
1090                 proutn(_("Energy to transfer to shields- "))
1091                 action = "NRG"
1092             elif damaged(DSHIELD):
1093                 prout(_("Shields damaged and down."))
1094                 return
1095             elif game.shldup:
1096                 proutn(_("Shields are up. Do you want them down? "))
1097                 if ja() == True:
1098                     action = "SHDN"
1099                 else:
1100                     scanner.chew()
1101                     return
1102             else:
1103                 proutn(_("Shields are down. Do you want them up? "))
1104                 if ja() == True:
1105                     action = "SHUP"
1106                 else:
1107                     scanner.chew()
1108                     return
1109     if action == "SHUP": # raise shields
1110         if game.shldup:
1111             prout(_("Shields already up."))
1112             return
1113         game.shldup = True
1114         game.shldchg = True
1115         if game.condition != "docked":
1116             game.energy -= 50.0
1117         prout(_("Shields raised."))
1118         if game.energy <= 0:
1119             skip(1)
1120             prout(_("Shields raising uses up last of energy."))
1121             finish(FNRG)
1122             return
1123         game.ididit=True
1124         return
1125     elif action == "SHDN":
1126         if not game.shldup:
1127             prout(_("Shields already down."))
1128             return
1129         game.shldup=False
1130         game.shldchg=True
1131         prout(_("Shields lowered."))
1132         game.ididit = True
1133         return
1134     elif action == "NRG":
1135         while scanner.next() != "IHREAL":
1136             scanner.chew()
1137             proutn(_("Energy to transfer to shields- "))
1138         scanner.chew()
1139         if scanner.real == 0:
1140             return
1141         if scanner.real > game.energy:
1142             prout(_("Insufficient ship energy."))
1143             return
1144         game.ididit = True
1145         if game.shield+scanner.real >= game.inshld:
1146             prout(_("Shield energy maximized."))
1147             if game.shield+scanner.real > game.inshld:
1148                 prout(_("Excess energy requested returned to ship energy"))
1149             game.energy -= game.inshld-game.shield
1150             game.shield = game.inshld
1151             return
1152         if scanner.real < 0.0 and game.energy-scanner.real > game.inenrg:
1153             # Prevent shield drain loophole
1154             skip(1)
1155             prout(_("Engineering to bridge--"))
1156             prout(_("  Scott here. Power circuit problem, Captain."))
1157             prout(_("  I can't drain the shields."))
1158             game.ididit = False
1159             return
1160         if game.shield+scanner.real < 0:
1161             prout(_("All shield energy transferred to ship."))
1162             game.energy += game.shield
1163             game.shield = 0.0
1164             return
1165         proutn(_("Scotty- \""))
1166         if scanner.real > 0:
1167             prout(_("Transferring energy to shields.\""))
1168         else:
1169             prout(_("Draining energy from shields.\""))
1170         game.shield += scanner.real
1171         game.energy -= scanner.real
1172         return
1173
1174 def randdevice():
1175     "Choose a device to damage, at random."
1176     # Quoth Eric Allman in the code of BSD-Trek:
1177     # "Under certain conditions you can get a critical hit.  This
1178     # sort of hit damages devices.  The probability that a given
1179     # device is damaged depends on the device.  Well protected
1180     # devices (such as the computer, which is in the core of the
1181     # ship and has considerable redundancy) almost never get
1182     # damaged, whereas devices which are exposed (such as the
1183     # warp engines) or which are particularly delicate (such as
1184     # the transporter) have a much higher probability of being
1185     # damaged."
1186     #
1187     # This is one place where OPTION_PLAIN does not restore the
1188     # original behavior, which was equiprobable damage across
1189     # all devices.  If we wanted that, we'd return randrange(NDEVICES)
1190     # and have done with it.  Also, in the original game, DNAVYS
1191     # and DCOMPTR were the same device.
1192     #
1193     # Instead, we use a table of weights similar to the one from BSD Trek.
1194     # BSD doesn't have the shuttle, shield controller, death ray, or probes.
1195     # We don't have a cloaking device.  The shuttle got the allocation
1196     # for the cloaking device, then we shaved a half-percent off
1197     # everything to have some weight to give DSHCTRL/DDRAY/DDSP.
1198     weights = (
1199         105,    # DSRSENS: short range scanners 10.5%
1200         105,    # DLRSENS: long range scanners          10.5%
1201         120,    # DPHASER: phasers                      12.0%
1202         120,    # DPHOTON: photon torpedoes             12.0%
1203         25,     # DLIFSUP: life support          2.5%
1204         65,     # DWARPEN: warp drive                    6.5%
1205         70,     # DIMPULS: impulse engines               6.5%
1206         145,    # DSHIELD: deflector shields            14.5%
1207         30,     # DRADIO:  subspace radio                3.0%
1208         45,     # DSHUTTL: shuttle                       4.5%
1209         15,     # DCOMPTR: computer                      1.5%
1210         20,     # NAVCOMP: navigation system             2.0%
1211         75,     # DTRANSP: transporter                   7.5%
1212         20,     # DSHCTRL: high-speed shield controller 2.0%
1213         10,     # DDRAY: death ray                       1.0%
1214         30,     # DDSP: deep-space probes                3.0%
1215     )
1216     idx = randrange(1000)       # weights must sum to 1000
1217     sum = 0
1218     for (i, w) in enumerate(weights):
1219         sum += w
1220         if idx < sum:
1221             return i
1222     return None;        # we should never get here
1223
1224 def collision(rammed, enemy):
1225     "Collision handling fot rammong events."
1226     prouts(_("***RED ALERT!  RED ALERT!"))
1227     skip(1)
1228     prout(_("***COLLISION IMMINENT."))
1229     skip(2)
1230     proutn("***")
1231     proutn(crmshp())
1232     hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0)
1233     if rammed:
1234         proutn(_(" rammed by "))
1235     else:
1236         proutn(_(" rams "))
1237     proutn(crmena(False, enemy.type, "sector", enemy.kloc))
1238     if rammed:
1239         proutn(_(" (original position)"))
1240     skip(1)
1241     deadkl(enemy.kloc, enemy.type, game.sector)
1242     proutn("***" + crmship() + " heavily damaged.")
1243     icas = randrange(10, 30)
1244     prout(_("***Sickbay reports %d casualties"), icas)
1245     game.casual += icas
1246     game.state.crew -= icas
1247     # In the pre-SST2K version, all devices got equiprobably damaged,
1248     # which was silly.  Instead, pick up to half the devices at
1249     # random according to our weighting table,
1250     ncrits = randrange(NDEVICES/2)
1251     for m in range(ncrits):
1252         dev = randdevice()
1253         if game.damage[dev] < 0:
1254             continue
1255         extradm = (10.0*hardness*randreal()+1.0)*game.damfac
1256         # Damage for at least time of travel!
1257         game.damage[dev] += game.optime + extradm
1258     game.shldup = False
1259     prout(_("***Shields are down."))
1260     if game.state.remkl + len(game.state.kcmdr) + game.state.nscrem:
1261         announce()
1262         damagereport()
1263     else:
1264         finish(FWON)
1265     return
1266
1267 def torpedo(origin, bearing, dispersion, number, nburst):
1268     "Let a photon torpedo fly"
1269     if not damaged(DSRSENS) or game.condition=="docked":
1270         setwnd(srscan_window)
1271     else:
1272         setwnd(message_window)
1273     ac = bearing + 0.25*dispersion      # dispersion is a random variable
1274     bullseye = (15.0 - bearing)*0.5235988
1275     track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin))
1276     bumpto = coord(0, 0)
1277     # Loop to move a single torpedo
1278     setwnd(message_window)
1279     for step in range(1, QUADSIZE*2):
1280         track.next()
1281         w = track.sector()
1282         if not w.valid_sector():
1283             break
1284         iquad=game.quad[w.i][w.j]
1285         tracktorpedo(origin, w, step, number, nburst, iquad)
1286         if iquad==IHDOT:
1287             continue
1288         # hit something
1289         if not damaged(DSRSENS) or game.condition == "docked":
1290             skip(1);    # start new line after text track
1291         if iquad in (IHE, IHF): # Hit our ship
1292             skip(1)
1293             prout(_("Torpedo hits %s.") % crmshp())
1294             hit = 700.0 + randreal(100) - \
1295                 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
1296             newcnd(); # we're blown out of dock
1297             if game.landed or game.condition=="docked":
1298                 return hit # Cheat if on a planet
1299             ang = track.angle + 2.5*(randreal()-0.5)
1300             temp = math.fabs(math.sin(ang))
1301             if math.fabs(math.cos(ang)) > temp:
1302                 temp = math.fabs(math.cos(ang))
1303             xx = -math.sin(ang)/temp
1304             yy = math.cos(ang)/temp
1305             bumpto.i = int(w.i+xx+0.5)
1306             bumpto.j = int(w.j+yy+0.5)
1307             if not bumpto.valid_sector():
1308                 return hit
1309             if game.quad[bumpto.i][bumpto.j]==IHBLANK:
1310                 finish(FHOLE)
1311                 return hit
1312             if game.quad[bumpto.i][bumpto.j]!=IHDOT:
1313                 # can't move into object
1314                 return hit
1315             game.sector = bumpto
1316             proutn(crmshp())
1317             game.quad[w.i][w.j]=IHDOT
1318             game.quad[bumpto.i][bumpto.j]=iquad
1319             prout(_(" displaced by blast to Sector %s ") % bumpto)
1320             for enemy in game.enemies:
1321                 enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
1322             game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
1323             return None
1324         elif iquad in (IHC, IHS, IHR, IHK): # Hit a regular enemy
1325             # find the enemy
1326             if iquad in (IHC, IHS) and withprob(0.05):
1327                 prout(crmena(True, iquad, "sector", w) + _(" uses anti-photon device;"))
1328                 prout(_("   torpedo neutralized."))
1329                 return None
1330             for enemy in game.enemies:
1331                 if w == enemy.kloc:
1332                     break
1333             kp = math.fabs(enemy.kpower)
1334             h1 = 700.0 + randrange(100) - \
1335                 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
1336             h1 = math.fabs(h1)
1337             if kp < h1:
1338                 h1 = kp
1339             if enemy.kpower < 0:
1340                 enemy.kpower -= -h1
1341             else:
1342                 enemy.kpower -= h1
1343             if enemy.kpower == 0:
1344                 deadkl(w, iquad, w)
1345                 return None
1346             proutn(crmena(True, iquad, "sector", w))
1347             # If enemy damaged but not destroyed, try to displace
1348             ang = track.angle + 2.5*(randreal()-0.5)
1349             temp = math.fabs(math.sin(ang))
1350             if math.fabs(math.cos(ang)) > temp:
1351                 temp = math.fabs(math.cos(ang))
1352             xx = -math.sin(ang)/temp
1353             yy = math.cos(ang)/temp
1354             bumpto.i = int(w.i+xx+0.5)
1355             bumpto.j = int(w.j+yy+0.5)
1356             if not bumpto.valid_sector():
1357                 prout(_(" damaged but not destroyed."))
1358                 return
1359             if game.quad[bumpto.i][bumpto.j] == IHBLANK:
1360                 prout(_(" buffeted into black hole."))
1361                 deadkl(w, iquad, bumpto)
1362             if game.quad[bumpto.i][bumpto.j] != IHDOT:
1363                 prout(_(" damaged but not destroyed."))
1364             else:
1365                 prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
1366                 enemy.kloc = bumpto
1367                 game.quad[w.i][w.j]=IHDOT
1368                 game.quad[bumpto.i][bumpto.j]=iquad
1369                 for enemy in game.enemies:
1370                     enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
1371                 game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
1372             return None
1373         elif iquad == IHB: # Hit a base
1374             skip(1)
1375             prout(_("***STARBASE DESTROYED.."))
1376             game.state.baseq = filter(lambda x: x != game.quadrant, game.state.baseq)
1377             game.quad[w.i][w.j]=IHDOT
1378             game.base.invalidate()
1379             game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase -= 1
1380             game.state.chart[game.quadrant.i][game.quadrant.j].starbase -= 1
1381             game.state.basekl += 1
1382             newcnd()
1383             return None
1384         elif iquad == IHP: # Hit a planet
1385             prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
1386             game.state.nplankl += 1
1387             game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
1388             game.iplnet.pclass = "destroyed"
1389             game.iplnet = None
1390             game.plnet.invalidate()
1391             game.quad[w.i][w.j] = IHDOT
1392             if game.landed:
1393                 # captain perishes on planet
1394                 finish(FDPLANET)
1395             return None
1396         elif iquad == IHW: # Hit an inhabited world -- very bad!
1397             prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
1398             game.state.nworldkl += 1
1399             game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
1400             game.iplnet.pclass = "destroyed"
1401             game.iplnet = None
1402             game.plnet.invalidate()
1403             game.quad[w.i][w.j] = IHDOT
1404             if game.landed:
1405                 # captain perishes on planet
1406                 finish(FDPLANET)
1407             prout(_("You have just destroyed an inhabited planet."))
1408             prout(_("Celebratory rallies are being held on the Klingon homeworld."))
1409             return None
1410         elif iquad == IHSTAR: # Hit a star
1411             if withprob(0.9):
1412                 nova(w)
1413             else:
1414                 prout(crmena(True, IHSTAR, "sector", w) + _(" unaffected by photon blast."))
1415             return None
1416         elif iquad == IHQUEST: # Hit a thingy
1417             if not (game.options & OPTION_THINGY) or withprob(0.3):
1418                 skip(1)
1419                 prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
1420                 skip(1)
1421                 prouts(_("    HACK!     HACK!    HACK!        *CHOKE!*  "))
1422                 skip(1)
1423                 proutn(_("Mr. Spock-"))
1424                 prouts(_("  \"Fascinating!\""))
1425                 skip(1)
1426                 deadkl(w, iquad, w)
1427             else:
1428                 # Stas Sergeev added the possibility that
1429                 # you can shove the Thingy and piss it off.
1430                 # It then becomes an enemy and may fire at you.
1431                 thing.angry = True
1432                 shoved = True
1433             return None
1434         elif iquad == IHBLANK: # Black hole
1435             skip(1)
1436             prout(crmena(True, IHBLANK, "sector", w) + _(" swallows torpedo."))
1437             return None
1438         elif iquad == IHWEB: # hit the web
1439             skip(1)
1440             prout(_("***Torpedo absorbed by Tholian web."))
1441             return None
1442         elif iquad == IHT:  # Hit a Tholian
1443             h1 = 700.0 + randrange(100) - \
1444                 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
1445             h1 = math.fabs(h1)
1446             if h1 >= 600:
1447                 game.quad[w.i][w.j] = IHDOT
1448                 deadkl(w, iquad, w)
1449                 game.tholian = None
1450                 return None
1451             skip(1)
1452             proutn(crmena(True, IHT, "sector", w))
1453             if withprob(0.05):
1454                 prout(_(" survives photon blast."))
1455                 return None
1456             prout(_(" disappears."))
1457             game.tholian.move(None)
1458             game.quad[w.i][w.j] = IHWEB
1459             dropin(IHBLANK)
1460             return None
1461         else: # Problem!
1462             skip(1)
1463             proutn("Don't know how to handle torpedo collision with ")
1464             proutn(crmena(True, iquad, "sector", w))
1465             skip(1)
1466             return None
1467         break
1468     skip(1)
1469     prout(_("Torpedo missed."))
1470     return None;
1471
1472 def fry(hit):
1473     "Critical-hit resolution."
1474     if hit < (275.0-25.0*game.skill)*randreal(1.0, 1.5):
1475         return
1476     ncrit = int(1.0 + hit/(500.0+randreal(100)))
1477     proutn(_("***CRITICAL HIT--"))
1478     # Select devices and cause damage
1479     cdam = []
1480     for loop1 in range(ncrit):
1481         while True:
1482             j = randdevice()
1483             # Cheat to prevent shuttle damage unless on ship
1484             if not (game.damage[j]<0.0 or (j==DSHUTTL and game.iscraft != "onship")):
1485                 break
1486         cdam.append(j)
1487         extradm = (hit*game.damfac)/(ncrit*randreal(75, 100))
1488         game.damage[j] += extradm
1489     skipcount = 0
1490     for (i, j) in enumerate(cdam):
1491         proutn(device[j])
1492         if skipcount % 3 == 2 and i < len(cdam)-1:
1493             skip(1)
1494         skipcount += 1
1495         if i < len(cdam)-1:
1496             proutn(_(" and "))
1497     prout(_(" damaged."))
1498     if damaged(DSHIELD) and game.shldup:
1499         prout(_("***Shields knocked down."))
1500         game.shldup=False
1501
1502 def attack(torps_ok):
1503     # bad guy attacks us
1504     # torps_ok == False forces use of phasers in an attack
1505     # game could be over at this point, check
1506     if game.alldone:
1507         return
1508     attempt = False; ihurt = False;
1509     hitmax=0.0; hittot=0.0; chgfac=1.0
1510     where = "neither"
1511     if idebug:
1512         prout("=== ATTACK!")
1513     # Tholian gets to move before attacking
1514     if game.tholian:
1515         movetholian()
1516     # if you have just entered the RNZ, you'll get a warning
1517     if game.neutz: # The one chance not to be attacked
1518         game.neutz = False
1519         return
1520     # commanders get a chance to tac-move towards you
1521     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:
1522         moveklings()
1523     # if no enemies remain after movement, we're done
1524     if len(game.enemies)==0 or (len(game.enemies)==1 and thing == game.quadrant and not thing.angry):
1525         return
1526     # set up partial hits if attack happens during shield status change
1527     pfac = 1.0/game.inshld
1528     if game.shldchg:
1529         chgfac = 0.25 + randreal(0.5)
1530     skip(1)
1531     # message verbosity control
1532     if game.skill <= SKILL_FAIR:
1533         where = "sector"
1534     for enemy in game.enemies:
1535         if enemy.kpower < 0:
1536             continue;   # too weak to attack
1537         # compute hit strength and diminish shield power
1538         r = randreal()
1539         # Increase chance of photon torpedos if docked or enemy energy is low
1540         if game.condition == "docked":
1541             r *= 0.25
1542         if enemy.kpower < 500:
1543             r *= 0.25;
1544         if enemy.type==IHT or (enemy.type==IHQUEST and not thing.angry):
1545             continue
1546         # different enemies have different probabilities of throwing a torp
1547         usephasers = not torps_ok or \
1548             (enemy.type == IHK and r > 0.0005) or \
1549             (enemy.type==IHC and r > 0.015) or \
1550             (enemy.type==IHR and r > 0.3) or \
1551             (enemy.type==IHS and r > 0.07) or \
1552             (enemy.type==IHQUEST and r > 0.05)
1553         if usephasers:      # Enemy uses phasers
1554             if game.condition == "docked":
1555                 continue; # Don't waste the effort!
1556             attempt = True; # Attempt to attack
1557             dustfac = randreal(0.8, 0.85)
1558             hit = enemy.kpower*math.pow(dustfac,enemy.kavgd)
1559             enemy.kpower *= 0.75
1560         else: # Enemy uses photon torpedo
1561             # We should be able to make the bearing() method work here
1562             course = 1.90985*math.atan2(game.sector.j-enemy.kloc.j, enemy.kloc.i-game.sector.i)
1563             hit = 0
1564             proutn(_("***TORPEDO INCOMING"))
1565             if not damaged(DSRSENS):
1566                 proutn(_(" From ") + crmena(False, enemy.type, where, enemy.kloc))
1567             attempt = True
1568             prout("  ")
1569             dispersion = (randreal()+randreal())*0.5 - 0.5
1570             dispersion += 0.002*enemy.kpower*dispersion
1571             hit = torpedo(enemy.kloc, course, dispersion, number=1, nburst=1)
1572             if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
1573                 finish(FWON); # Klingons did themselves in!
1574             if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone:
1575                 return # Supernova or finished
1576             if hit == None:
1577                 continue
1578         # incoming phaser or torpedo, shields may dissipate it
1579         if game.shldup or game.shldchg or game.condition=="docked":
1580             # shields will take hits
1581             propor = pfac * game.shield
1582             if game.condition =="docked":
1583                 propr *= 2.1
1584             if propor < 0.1:
1585                 propor = 0.1
1586             hitsh = propor*chgfac*hit+1.0
1587             absorb = 0.8*hitsh
1588             if absorb > game.shield:
1589                 absorb = game.shield
1590             game.shield -= absorb
1591             hit -= hitsh
1592             # taking a hit blasts us out of a starbase dock
1593             if game.condition == "docked":
1594                 dock(False)
1595             # but the shields may take care of it
1596             if propor > 0.1 and hit < 0.005*game.energy:
1597                 continue
1598         # hit from this opponent got through shields, so take damage
1599         ihurt = True
1600         proutn(_("%d unit hit") % int(hit))
1601         if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR:
1602             proutn(_(" on the ") + crmshp())
1603         if not damaged(DSRSENS) and usephasers:
1604             prout(_(" from ") + crmena(False, enemy.type, where, enemy.kloc))
1605         skip(1)
1606         # Decide if hit is critical
1607         if hit > hitmax:
1608             hitmax = hit
1609         hittot += hit
1610         fry(hit)
1611         game.energy -= hit
1612     if game.energy <= 0:
1613         # Returning home upon your shield, not with it...
1614         finish(FBATTLE)
1615         return
1616     if not attempt and game.condition == "docked":
1617         prout(_("***Enemies decide against attacking your ship."))
1618     percent = 100.0*pfac*game.shield+0.5
1619     if not ihurt:
1620         # Shields fully protect ship
1621         proutn(_("Enemy attack reduces shield strength to "))
1622     else:
1623         # Emit message if starship suffered hit(s)
1624         skip(1)
1625         proutn(_("Energy left %2d    shields ") % int(game.energy))
1626         if game.shldup:
1627             proutn(_("up "))
1628         elif not damaged(DSHIELD):
1629             proutn(_("down "))
1630         else:
1631             proutn(_("damaged, "))
1632     prout(_("%d%%,   torpedoes left %d") % (percent, game.torps))
1633     # Check if anyone was hurt
1634     if hitmax >= 200 or hittot >= 500:
1635         icas = randrange(int(hittot * 0.015))
1636         if icas >= 2:
1637             skip(1)
1638             prout(_("Mc Coy-  \"Sickbay to bridge.  We suffered %d casualties") % icas)
1639             prout(_("   in that last attack.\""))
1640             game.casual += icas
1641             game.state.crew -= icas
1642     # After attack, reset average distance to enemies
1643     for enemy in game.enemies:
1644         enemy.kavgd = enemy.kdist
1645     game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
1646     return
1647
1648 def deadkl(w, type, mv):
1649     "Kill a Klingon, Tholian, Romulan, or Thingy."
1650     # Added mv to allow enemy to "move" before dying
1651     proutn(crmena(True, type, "sector", mv))
1652     # Decide what kind of enemy it is and update appropriately
1653     if type == IHR:
1654         # Chalk up a Romulan
1655         game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans -= 1
1656         game.irhere -= 1
1657         game.state.nromrem -= 1
1658     elif type == IHT:
1659         # Killed a Tholian
1660         game.tholian = None
1661     elif type == IHQUEST:
1662         # Killed a Thingy
1663         global thing
1664         thing = None
1665     else:
1666         # Killed some type of Klingon
1667         game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
1668         game.klhere -= 1
1669         if type == IHC:
1670             game.state.kcmdr.remove(game.quadrant)
1671             unschedule(FTBEAM)
1672             if game.state.kcmdr:
1673                 schedule(FTBEAM, expran(1.0*game.incom/len(game.state.kcmdr)))
1674             if is_scheduled(FCDBAS) and game.battle == game.quadrant:
1675                 unschedule(FCDBAS)
1676         elif type ==  IHK:
1677             game.state.remkl -= 1
1678         elif type ==  IHS:
1679             game.state.nscrem -= 1
1680             game.state.kscmdr.invalidate()
1681             game.isatb = 0
1682             game.iscate = False
1683             unschedule(FSCMOVE)
1684             unschedule(FSCDBAS)
1685     # For each kind of enemy, finish message to player
1686     prout(_(" destroyed."))
1687     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
1688         return
1689     game.recompute()
1690     # Remove enemy ship from arrays describing local conditions
1691     for e in game.enemies:
1692         if e.kloc == w:
1693             e.move(None)
1694             break
1695     return
1696
1697 def targetcheck(w):
1698     "Return None if target is invalid, otherwise return a course angle."
1699     if not w.valid_sector():
1700         huh()
1701         return None
1702     delta = coord()
1703     # FIXME: C code this was translated from is wacky -- why the sign reversal?
1704     delta.j = (w.j - game.sector.j);
1705     delta.i = (game.sector.i - w.i);
1706     if delta == coord(0, 0):
1707         skip(1)
1708         prout(_("Spock-  \"Bridge to sickbay.  Dr. McCoy,"))
1709         prout(_("  I recommend an immediate review of"))
1710         prout(_("  the Captain's psychological profile.\""))
1711         scanner.chew()
1712         return None
1713     return delta.bearing()
1714
1715 def photon():
1716     "Launch photon torpedo."
1717     course = []
1718     game.ididit = False
1719     if damaged(DPHOTON):
1720         prout(_("Photon tubes damaged."))
1721         scanner.chew()
1722         return
1723     if game.torps == 0:
1724         prout(_("No torpedoes left."))
1725         scanner.chew()
1726         return
1727     # First, get torpedo count
1728     while True:
1729         scanner.next()
1730         if scanner.token == "IHALPHA":
1731             huh()
1732             return
1733         elif scanner.token == "IHEOL" or not scanner.waiting():
1734             prout(_("%d torpedoes left.") % game.torps)
1735             scanner.chew()
1736             proutn(_("Number of torpedoes to fire- "))
1737             continue    # Go back around to get a number
1738         else: # key == "IHREAL"
1739             n = scanner.int()
1740             if n <= 0: # abort command
1741                 scanner.chew()
1742                 return
1743             if n > MAXBURST:
1744                 scanner.chew()
1745                 prout(_("Maximum of %d torpedoes per burst.") % MAXBURST)
1746                 return
1747             if n > game.torps:
1748                 scanner.chew()  # User requested more torps than available
1749                 continue        # Go back around
1750             break       # All is good, go to next stage
1751     # Next, get targets
1752     target = []
1753     for i in range(n):
1754         key = scanner.next()
1755         if i==0 and key == "IHEOL":
1756             break;      # no coordinate waiting, we will try prompting
1757         if i==1 and key == "IHEOL":
1758             # direct all torpedoes at one target
1759             while i < n:
1760                 target.append(target[0])
1761                 course.append(course[0])
1762                 i += 1
1763             break
1764         scanner.push(scanner.token)
1765         target.append(scanner.getcoord())
1766         if target[-1] == None:
1767             return
1768         course.append(targetcheck(target[-1]))
1769         if course[-1] == None:
1770             return
1771     scanner.chew()
1772     if len(target) == 0:
1773         # prompt for each one
1774         for i in range(n):
1775             proutn(_("Target sector for torpedo number %d- ") % (i+1))
1776             scanner.chew()
1777             target.append(scanner.getcoord())
1778             if target[-1] == None:
1779                 return
1780             course.append(targetcheck(target[-1]))
1781             if course[-1] == None:
1782                 return
1783     game.ididit = True
1784     # Loop for moving <n> torpedoes
1785     for i in range(n):
1786         if game.condition != "docked":
1787             game.torps -= 1
1788         dispersion = (randreal()+randreal())*0.5 -0.5
1789         if math.fabs(dispersion) >= 0.47:
1790             # misfire!
1791             dispersion *= randreal(1.2, 2.2)
1792             if n > 0:
1793                 prouts(_("***TORPEDO NUMBER %d MISFIRES") % (i+1))
1794             else:
1795                 prouts(_("***TORPEDO MISFIRES."))
1796             skip(1)
1797             if i < n:
1798                 prout(_("  Remainder of burst aborted."))
1799             if withprob(0.2):
1800                 prout(_("***Photon tubes damaged by misfire."))
1801                 game.damage[DPHOTON] = game.damfac * randreal(1.0, 3.0)
1802             break
1803         if game.shldup or game.condition == "docked":
1804             dispersion *= 1.0 + 0.0001*game.shield
1805         torpedo(game.sector, course[i], dispersion, number=i, nburst=n)
1806         if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
1807             return
1808     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
1809         finish(FWON);
1810
1811 def overheat(rpow):
1812     "Check for phasers overheating."
1813     if rpow > 1500:
1814         checkburn = (rpow-1500.0)*0.00038
1815         if withprob(checkburn):
1816             prout(_("Weapons officer Sulu-  \"Phasers overheated, sir.\""))
1817             game.damage[DPHASER] = game.damfac* randreal(1.0, 2.0) * (1.0+checkburn)
1818
1819 def checkshctrl(rpow):
1820     "Check shield control."
1821     skip(1)
1822     if withprob(0.998):
1823         prout(_("Shields lowered."))
1824         return False
1825     # Something bad has happened
1826     prouts(_("***RED ALERT!  RED ALERT!"))
1827     skip(2)
1828     hit = rpow*game.shield/game.inshld
1829     game.energy -= rpow+hit*0.8
1830     game.shield -= hit*0.2
1831     if game.energy <= 0.0:
1832         prouts(_("Sulu-  \"Captain! Shield malf***********************\""))
1833         skip(1)
1834         stars()
1835         finish(FPHASER)
1836         return True
1837     prouts(_("Sulu-  \"Captain! Shield malfunction! Phaser fire contained!\""))
1838     skip(2)
1839     prout(_("Lt. Uhura-  \"Sir, all decks reporting damage.\""))
1840     icas = randrange(int(hit*0.012))
1841     skip(1)
1842     fry(0.8*hit)
1843     if icas:
1844         skip(1)
1845         prout(_("McCoy to bridge- \"Severe radiation burns, Jim."))
1846         prout(_("  %d casualties so far.\"") % icas)
1847         game.casual += icas
1848         game.state.crew -= icas
1849     skip(1)
1850     prout(_("Phaser energy dispersed by shields."))
1851     prout(_("Enemy unaffected."))
1852     overheat(rpow)
1853     return True;
1854
1855 def hittem(hits):
1856     "Register a phaser hit on Klingons and Romulans."
1857     nenhr2 = len(game.enemies); kk=0
1858     w = coord()
1859     skip(1)
1860     for (k, wham) in enumerate(hits):
1861         if wham==0:
1862             continue
1863         dustfac = randreal(0.9, 1.0)
1864         hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
1865         kpini = game.enemies[kk].kpower
1866         kp = math.fabs(kpini)
1867         if PHASEFAC*hit < kp:
1868             kp = PHASEFAC*hit
1869         if game.enemies[kk].kpower < 0:
1870             game.enemies[kk].kpower -= -kp
1871         else:
1872             game.enemies[kk].kpower -= kp
1873         kpow = game.enemies[kk].kpower
1874         w = game.enemies[kk].kloc
1875         if hit > 0.005:
1876             if not damaged(DSRSENS):
1877                 boom(w)
1878             proutn(_("%d unit hit on ") % int(hit))
1879         else:
1880             proutn(_("Very small hit on "))
1881         ienm = game.quad[w.i][w.j]
1882         if ienm==IHQUEST:
1883             thing.angry = True
1884         proutn(crmena(False, ienm, "sector", w))
1885         skip(1)
1886         if kpow == 0:
1887             deadkl(w, ienm, w)
1888             if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
1889                 finish(FWON);
1890             if game.alldone:
1891                 return
1892             kk -= 1     # don't do the increment
1893             continue
1894         else: # decide whether or not to emasculate klingon
1895             if kpow>0 and withprob(0.9) and kpow <= randreal(0.4, 0.8)*kpini:
1896                 prout(_("***Mr. Spock-  \"Captain, the vessel at Sector %s")%w)
1897                 prout(_("   has just lost its firepower.\""))
1898                 game.enemies[kk].kpower = -kpow
1899         kk += 1
1900     return
1901
1902 def phasers():
1903     "Fire phasers at bad guys."
1904     hits = []
1905     kz = 0; k = 1; irec=0 # Cheating inhibitor
1906     ifast = False; no = False; itarg = True; msgflag = True; rpow=0
1907     automode = "NOTSET"
1908     key=0
1909     skip(1)
1910     # SR sensors and Computer are needed for automode
1911     if damaged(DSRSENS) or damaged(DCOMPTR):
1912         itarg = False
1913     if game.condition == "docked":
1914         prout(_("Phasers can't be fired through base shields."))
1915         scanner.chew()
1916         return
1917     if damaged(DPHASER):
1918         prout(_("Phaser control damaged."))
1919         scanner.chew()
1920         return
1921     if game.shldup:
1922         if damaged(DSHCTRL):
1923             prout(_("High speed shield control damaged."))
1924             scanner.chew()
1925             return
1926         if game.energy <= 200.0:
1927             prout(_("Insufficient energy to activate high-speed shield control."))
1928             scanner.chew()
1929             return
1930         prout(_("Weapons Officer Sulu-  \"High-speed shield control enabled, sir.\""))
1931         ifast = True
1932     # Original code so convoluted, I re-did it all
1933     # (That was Tom Almy talking about the C code, I think -- ESR)
1934     while automode=="NOTSET":
1935         key=scanner.next()
1936         if key == "IHALPHA":
1937             if scanner.sees("manual"):
1938                 if len(game.enemies)==0:
1939                     prout(_("There is no enemy present to select."))
1940                     scanner.chew()
1941                     key = "IHEOL"
1942                     automode="AUTOMATIC"
1943                 else:
1944                     automode = "MANUAL"
1945                     key = scanner.next()
1946             elif scanner.sees("automatic"):
1947                 if (not itarg) and len(game.enemies) != 0:
1948                     automode = "FORCEMAN"
1949                 else:
1950                     if len(game.enemies)==0:
1951                         prout(_("Energy will be expended into space."))
1952                     automode = "AUTOMATIC"
1953                     key = scanner.next()
1954             elif scanner.sees("no"):
1955                 no = True
1956             else:
1957                 huh()
1958                 return
1959         elif key == "IHREAL":
1960             if len(game.enemies)==0:
1961                 prout(_("Energy will be expended into space."))
1962                 automode = "AUTOMATIC"
1963             elif not itarg:
1964                 automode = "FORCEMAN"
1965             else:
1966                 automode = "AUTOMATIC"
1967         else:
1968             # "IHEOL"
1969             if len(game.enemies)==0:
1970                 prout(_("Energy will be expended into space."))
1971                 automode = "AUTOMATIC"
1972             elif not itarg:
1973                 automode = "FORCEMAN"
1974             else:
1975                 proutn(_("Manual or automatic? "))
1976                 scanner.chew()
1977     avail = game.energy
1978     if ifast:
1979         avail -= 200.0
1980     if automode == "AUTOMATIC":
1981         if key == "IHALPHA" and scanner.sees("no"):
1982             no = True
1983             key = scanner.next()
1984         if key != "IHREAL" and len(game.enemies) != 0:
1985             prout(_("Phasers locked on target. Energy available: %.2f")%avail)
1986         irec=0
1987         while True:
1988             scanner.chew()
1989             if not kz:
1990                 for i in range(len(game.enemies)):
1991                     irec += math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
1992             kz=1
1993             proutn(_("%d units required. ") % irec)
1994             scanner.chew()
1995             proutn(_("Units to fire= "))
1996             key = scanner.next()
1997             if key!="IHREAL":
1998                 return
1999             rpow = scanner.real
2000             if rpow > avail:
2001                 proutn(_("Energy available= %.2f") % avail)
2002                 skip(1)
2003                 key = "IHEOL"
2004             if not rpow > avail:
2005                 break
2006         if rpow<=0:
2007             # chicken out
2008             scanner.chew()
2009             return
2010         key=scanner.next()
2011         if key == "IHALPHA" and scanner.sees("no"):
2012             no = True
2013         if ifast:
2014             game.energy -= 200; # Go and do it!
2015             if checkshctrl(rpow):
2016                 return
2017         scanner.chew()
2018         game.energy -= rpow
2019         extra = rpow
2020         if len(game.enemies):
2021             extra = 0.0
2022             powrem = rpow
2023             for i in range(len(game.enemies)):
2024                 hits.append(0.0)
2025                 if powrem <= 0:
2026                     continue
2027                 hits[i] = math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
2028                 over = randreal(1.01, 1.06) * hits[i]
2029                 temp = powrem
2030                 powrem -= hits[i] + over
2031                 if powrem <= 0 and temp < hits[i]:
2032                     hits[i] = temp
2033                 if powrem <= 0:
2034                     over = 0.0
2035                 extra += over
2036             if powrem > 0.0:
2037                 extra += powrem
2038             hittem(hits)
2039             game.ididit = True
2040         if extra > 0 and not game.alldone:
2041             if game.tholian:
2042                 proutn(_("*** Tholian web absorbs "))
2043                 if len(game.enemies)>0:
2044                     proutn(_("excess "))
2045                 prout(_("phaser energy."))
2046             else:
2047                 prout(_("%d expended on empty space.") % int(extra))
2048     elif automode == "FORCEMAN":
2049         scanner.chew()
2050         key = "IHEOL"
2051         if damaged(DCOMPTR):
2052             prout(_("Battle computer damaged, manual fire only."))
2053         else:
2054             skip(1)
2055             prouts(_("---WORKING---"))
2056             skip(1)
2057             prout(_("Short-range-sensors-damaged"))
2058             prout(_("Insufficient-data-for-automatic-phaser-fire"))
2059             prout(_("Manual-fire-must-be-used"))
2060             skip(1)
2061     elif automode == "MANUAL":
2062         rpow = 0.0
2063         for k in range(len(game.enemies)):
2064             aim = game.enemies[k].kloc
2065             ienm = game.quad[aim.i][aim.j]
2066             if msgflag:
2067                 proutn(_("Energy available= %.2f") % (avail-0.006))
2068                 skip(1)
2069                 msgflag = False
2070                 rpow = 0.0
2071             if damaged(DSRSENS) and \
2072                not game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS):
2073                 prout(cramen(ienm) + _(" can't be located without short range scan."))
2074                 scanner.chew()
2075                 key = "IHEOL"
2076                 hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko
2077                 k += 1
2078                 continue
2079             if key == "IHEOL":
2080                 scanner.chew()
2081                 if itarg and k > kz:
2082                     irec=(abs(game.enemies[k].kpower)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) * randreal(1.01, 1.06) + 1.0
2083                 kz = k
2084                 proutn("(")
2085                 if not damaged(DCOMPTR):
2086                     proutn("%d" % irec)
2087                 else:
2088                     proutn("??")
2089                 proutn(")  ")
2090                 proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))
2091                 key = scanner.next()
2092             if key == "IHALPHA" and scanner.sees("no"):
2093                 no = True
2094                 key = scanner.next()
2095                 continue
2096             if key == "IHALPHA":
2097                 huh()
2098                 return
2099             if key == "IHEOL":
2100                 if k==1: # Let me say I'm baffled by this
2101                     msgflag = True
2102                 continue
2103             if scanner.real < 0:
2104                 # abort out
2105                 scanner.chew()
2106                 return
2107             hits[k] = scanner.real
2108             rpow += scanner.real
2109             # If total requested is too much, inform and start over
2110             if rpow > avail:
2111                 prout(_("Available energy exceeded -- try again."))
2112                 scanner.chew()
2113                 return
2114             key = scanner.next(); # scan for next value
2115             k += 1
2116         if rpow == 0.0:
2117             # zero energy -- abort
2118             scanner.chew()
2119             return
2120         if key == "IHALPHA" and scanner.sees("no"):
2121             no = True
2122         game.energy -= rpow
2123         scanner.chew()
2124         if ifast:
2125             game.energy -= 200.0
2126             if checkshctrl(rpow):
2127                 return
2128         hittem(hits)
2129         game.ididit = True
2130      # Say shield raised or malfunction, if necessary
2131     if game.alldone:
2132         return
2133     if ifast:
2134         skip(1)
2135         if no == 0:
2136             if withprob(0.01):
2137                 prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
2138                 prouts(_("         CLICK   CLICK   POP  . . ."))
2139                 prout(_(" No response, sir!"))
2140                 game.shldup = False
2141             else:
2142                 prout(_("Shields raised."))
2143         else:
2144             game.shldup = False
2145     overheat(rpow);
2146
2147 # Code from events,c begins here.
2148
2149 # This isn't a real event queue a la BSD Trek yet -- you can only have one
2150 # event of each type active at any given time.  Mostly these means we can
2151 # only have one FDISTR/FENSLV/FREPRO sequence going at any given time
2152 # BSD Trek, from which we swiped the idea, can have up to 5.
2153
2154 def unschedule(evtype):
2155     "Remove an event from the schedule."
2156     game.future[evtype].date = FOREVER
2157     return game.future[evtype]
2158
2159 def is_scheduled(evtype):
2160     "Is an event of specified type scheduled."
2161     return game.future[evtype].date != FOREVER
2162
2163 def scheduled(evtype):
2164     "When will this event happen?"
2165     return game.future[evtype].date
2166
2167 def schedule(evtype, offset):
2168     "Schedule an event of specified type."
2169     game.future[evtype].date = game.state.date + offset
2170     return game.future[evtype]
2171
2172 def postpone(evtype, offset):
2173     "Postpone a scheduled event."
2174     game.future[evtype].date += offset
2175
2176 def cancelrest():
2177     "Rest period is interrupted by event."
2178     if game.resting:
2179         skip(1)
2180         proutn(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
2181         if ja() == True:
2182             game.resting = False
2183             game.optime = 0.0
2184             return True
2185     return False
2186
2187 def events():
2188     "Run through the event queue looking for things to do."
2189     i=0
2190     fintim = game.state.date + game.optime; yank=0
2191     ictbeam = False; istract = False
2192     w = coord(); hold = coord()
2193     ev = event(); ev2 = event()
2194
2195     def tractorbeam(yank):
2196         "Tractor-beaming cases merge here."
2197         announce()
2198         game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5)
2199         skip(1)
2200         prout("***" + crmshp() + _(" caught in long range tractor beam--"))
2201         # If Kirk & Co. screwing around on planet, handle
2202         atover(True) # atover(true) is Grab
2203         if game.alldone:
2204             return
2205         if game.icraft: # Caught in Galileo?
2206             finish(FSTRACTOR)
2207             return
2208         # Check to see if shuttle is aboard
2209         if game.iscraft == "offship":
2210             skip(1)
2211             if withprob(0.5):
2212                 prout(_("Galileo, left on the planet surface, is captured"))
2213                 prout(_("by aliens and made into a flying McDonald's."))
2214                 game.damage[DSHUTTL] = -10
2215                 game.iscraft = "removed"
2216             else:
2217                 prout(_("Galileo, left on the planet surface, is well hidden."))
2218         if evcode == FSPY:
2219             game.quadrant = game.state.kscmdr
2220         else:
2221             game.quadrant = game.state.kcmdr[i]
2222         game.sector = randplace(QUADSIZE)
2223         prout(crmshp() + _(" is pulled to Quadrant %s, Sector %s") \
2224                % (game.quadrant, game.sector))
2225         if game.resting:
2226             prout(_("(Remainder of rest/repair period cancelled.)"))
2227             game.resting = False
2228         if not game.shldup:
2229             if not damaged(DSHIELD) and game.shield > 0:
2230                 doshield(shraise=True) # raise shields
2231                 game.shldchg = False
2232             else:
2233                 prout(_("(Shields not currently useable.)"))
2234         newqad()
2235         # Adjust finish time to time of tractor beaming
2236         fintim = game.state.date+game.optime
2237         attack(torps_ok=False)
2238         if not game.state.kcmdr:
2239             unschedule(FTBEAM)
2240         else:
2241             schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr)))
2242
2243     def destroybase():
2244         "Code merges here for any commander destroying a starbase."
2245         # Not perfect, but will have to do
2246         # Handle case where base is in same quadrant as starship
2247         if game.battle == game.quadrant:
2248             game.state.chart[game.battle.i][game.battle.j].starbase = False
2249             game.quad[game.base.i][game.base.j] = IHDOT
2250             game.base.invalidate()
2251             newcnd()
2252             skip(1)
2253             prout(_("Spock-  \"Captain, I believe the starbase has been destroyed.\""))
2254         elif game.state.baseq and communicating():
2255             # Get word via subspace radio
2256             announce()
2257             skip(1)
2258             prout(_("Lt. Uhura-  \"Captain, Starfleet Command reports that"))
2259             proutn(_("   the starbase in Quadrant %s has been destroyed by") % game.battle)
2260             if game.isatb == 2:
2261                 prout(_("the Klingon Super-Commander"))
2262             else:
2263                 prout(_("a Klingon Commander"))
2264             game.state.chart[game.battle.i][game.battle.j].starbase = False
2265         # Remove Starbase from galaxy
2266         game.state.galaxy[game.battle.i][game.battle.j].starbase = False
2267         game.state.baseq = filter(lambda x: x != game.battle, game.state.baseq)
2268         if game.isatb == 2:
2269             # reinstate a commander's base attack
2270             game.battle = hold
2271             game.isatb = 0
2272         else:
2273             game.battle.invalidate()
2274     if idebug:
2275         prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
2276         for i in range(1, NEVENTS):
2277             if   i == FSNOVA:  proutn("=== Supernova       ")
2278             elif i == FTBEAM:  proutn("=== T Beam          ")
2279             elif i == FSNAP:   proutn("=== Snapshot        ")
2280             elif i == FBATTAK: proutn("=== Base Attack     ")
2281             elif i == FCDBAS:  proutn("=== Base Destroy    ")
2282             elif i == FSCMOVE: proutn("=== SC Move         ")
2283             elif i == FSCDBAS: proutn("=== SC Base Destroy ")
2284             elif i == FDSPROB: proutn("=== Probe Move      ")
2285             elif i == FDISTR:  proutn("=== Distress Call   ")
2286             elif i == FENSLV:  proutn("=== Enslavement     ")
2287             elif i == FREPRO:  proutn("=== Klingon Build   ")
2288             if is_scheduled(i):
2289                 prout("%.2f" % (scheduled(i)))
2290             else:
2291                 prout("never")
2292     radio_was_broken = damaged(DRADIO)
2293     hold.i = hold.j = 0
2294     while True:
2295         # Select earliest extraneous event, evcode==0 if no events
2296         evcode = FSPY
2297         if game.alldone:
2298             return
2299         datemin = fintim
2300         for l in range(1, NEVENTS):
2301             if game.future[l].date < datemin:
2302                 evcode = l
2303                 if idebug:
2304                     prout("== Event %d fires" % evcode)
2305                 datemin = game.future[l].date
2306         xtime = datemin-game.state.date
2307         game.state.date = datemin
2308         # Decrement Federation resources and recompute remaining time
2309         game.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime
2310         game.recompute()
2311         if game.state.remtime <=0:
2312             finish(FDEPLETE)
2313             return
2314         # Any crew left alive?
2315         if game.state.crew <=0:
2316             finish(FCREW)
2317             return
2318         # Is life support adequate?
2319         if damaged(DLIFSUP) and game.condition != "docked":
2320             if game.lsupres < xtime and game.damage[DLIFSUP] > game.lsupres:
2321                 finish(FLIFESUP)
2322                 return
2323             game.lsupres -= xtime
2324             if game.damage[DLIFSUP] <= xtime:
2325                 game.lsupres = game.inlsr
2326         # Fix devices
2327         repair = xtime
2328         if game.condition == "docked":
2329             repair /= game.docfac
2330         # Don't fix Deathray here
2331         for l in range(NDEVICES):
2332             if game.damage[l] > 0.0 and l != DDRAY:
2333                 if game.damage[l]-repair > 0.0:
2334                     game.damage[l] -= repair
2335                 else:
2336                     game.damage[l] = 0.0
2337         # If radio repaired, update star chart and attack reports
2338         if radio_was_broken and not damaged(DRADIO):
2339             prout(_("Lt. Uhura- \"Captain, the sub-space radio is working and"))
2340             prout(_("   surveillance reports are coming in."))
2341             skip(1)
2342             if not game.iseenit:
2343                 attackreport(False)
2344                 game.iseenit = True
2345             rechart()
2346             prout(_("   The star chart is now up to date.\""))
2347             skip(1)
2348         # Cause extraneous event EVCODE to occur
2349         game.optime -= xtime
2350         if evcode == FSNOVA: # Supernova
2351             announce()
2352             supernova(None)
2353             schedule(FSNOVA, expran(0.5*game.intime))
2354             if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
2355                 return
2356         elif evcode == FSPY: # Check with spy to see if SC should tractor beam
2357             if game.state.nscrem == 0 or \
2358                 ictbeam or istract or \
2359                 game.condition=="docked" or game.isatb==1 or game.iscate:
2360                 return
2361             if game.ientesc or \
2362                 (game.energy<2000 and game.torps<4 and game.shield < 1250) or \
2363                 (damaged(DPHASER) and (damaged(DPHOTON) or game.torps<4)) or \
2364                 (damaged(DSHIELD) and \
2365                  (game.energy < 2500 or damaged(DPHASER)) and \
2366                  (game.torps < 5 or damaged(DPHOTON))):
2367                 # Tractor-beam her!
2368                 istract = ictbeam = True
2369                 tractorbeam((game.state.kscmdr-game.quadrant).distance())
2370             else:
2371                 return
2372         elif evcode == FTBEAM: # Tractor beam
2373             if not game.state.kcmdr:
2374                 unschedule(FTBEAM)
2375                 continue
2376             i = randrange(len(game.state.kcmdr))
2377             yank = (game.state.kcmdr[i]-game.quadrant).distance()
2378             if istract or game.condition == "docked" or yank == 0:
2379                 # Drats! Have to reschedule
2380                 schedule(FTBEAM,
2381                          game.optime + expran(1.5*game.intime/len(game.state.kcmdr)))
2382                 continue
2383             ictbeam = True
2384             tractorbeam(yank)
2385         elif evcode == FSNAP: # Snapshot of the universe (for time warp)
2386             game.snapsht = copy.deepcopy(game.state)
2387             game.state.snap = True
2388             schedule(FSNAP, expran(0.5 * game.intime))
2389         elif evcode == FBATTAK: # Commander attacks starbase
2390             if not game.state.kcmdr or not game.state.baseq:
2391                 # no can do
2392                 unschedule(FBATTAK)
2393                 unschedule(FCDBAS)
2394                 continue
2395             try:
2396                 for ibq in game.state.baseq:
2397                    for cmdr in game.state.kcmdr:
2398                        if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
2399                            raise ibq
2400                 else:
2401                     # no match found -- try later
2402                     schedule(FBATTAK, expran(0.3*game.intime))
2403                     unschedule(FCDBAS)
2404                     continue
2405             except coord:
2406                 pass
2407             # commander + starbase combination found -- launch attack
2408             game.battle = ibq
2409             schedule(FCDBAS, randreal(1.0, 4.0))
2410             if game.isatb: # extra time if SC already attacking
2411                 postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date)
2412             game.future[FBATTAK].date = game.future[FCDBAS].date + expran(0.3*game.intime)
2413             game.iseenit = False
2414             if not communicating():
2415                 continue # No warning :-(
2416             game.iseenit = True
2417             announce()
2418             skip(1)
2419             prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") % game.battle)
2420             prout(_("   reports that it is under attack and that it can"))
2421             prout(_("   hold out only until stardate %d.\"") % (int(scheduled(FCDBAS))))
2422             if cancelrest():
2423                 return
2424         elif evcode == FSCDBAS: # Supercommander destroys base
2425             unschedule(FSCDBAS)
2426             game.isatb = 2
2427             if not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].starbase:
2428                 continue # WAS RETURN!
2429             hold = game.battle
2430             game.battle = game.state.kscmdr
2431             destroybase()
2432         elif evcode == FCDBAS: # Commander succeeds in destroying base
2433             if evcode==FCDBAS:
2434                 unschedule(FCDBAS)
2435                 if not game.state.baseq() \
2436                        or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
2437                     game.battle.invalidate()
2438                     continue
2439                 # find the lucky pair
2440                 for cmdr in game.state.kcmdr:
2441                     if cmdr == game.battle:
2442                         break
2443                 else:
2444                     # No action to take after all
2445                     continue
2446             destroybase()
2447         elif evcode == FSCMOVE: # Supercommander moves
2448             schedule(FSCMOVE, 0.2777)
2449             if not game.ientesc and not istract and game.isatb != 1 and \
2450                    (not game.iscate or not game.justin):
2451                 supercommander()
2452         elif evcode == FDSPROB: # Move deep space probe
2453             schedule(FDSPROB, 0.01)
2454             if game.probe.next(grain=QUADSIZE):
2455                 if not game.probe.quadrant().valid_quadrant() or \
2456                     game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova:
2457                     # Left galaxy or ran into supernova
2458                     if communicating():
2459                         announce()
2460                         skip(1)
2461                         proutn(_("Lt. Uhura-  \"The deep space probe "))
2462                         if not game.probe.quadrant().valid_quadrant():
2463                             prout(_("has left the galaxy.\""))
2464                         else:
2465                             prout(_("is no longer transmitting.\""))
2466                     unschedule(FDSPROB)
2467                     continue
2468                 if communicating():
2469                     #announce()
2470                     skip(1)
2471                     prout(_("Lt. Uhura-  \"The deep space probe is now in Quadrant %s.\"") % game.probe.quadrant())
2472             pdest = game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j]
2473             if communicating():
2474                 chp = game.state.chart[game.probe.quadrant().i][game.probe.quadrant().j]
2475                 chp.klingons = pdest.klingons
2476                 chp.starbase = pdest.starbase
2477                 chp.stars = pdest.stars
2478                 pdest.charted = True
2479             game.probe.moves -= 1 # One less to travel
2480             if game.probe.moves == 0 and game.isarmed and pdest.stars:
2481                 supernova(game.probe)           # fire in the hole!
2482                 unschedule(FDSPROB)
2483                 if game.state.galaxy[game.quadrant().i][game.quadrant().j].supernova:
2484                     return
2485         elif evcode == FDISTR: # inhabited system issues distress call
2486             unschedule(FDISTR)
2487             # try a whole bunch of times to find something suitable
2488             for i in range(100):
2489                 # need a quadrant which is not the current one,
2490                 # which has some stars which are inhabited and
2491                 # not already under attack, which is not
2492                 # supernova'ed, and which has some Klingons in it
2493                 w = randplace(GALSIZE)
2494                 q = game.state.galaxy[w.i][w.j]
2495                 if not (game.quadrant == w or q.planet == None or \
2496                       not q.planet.inhabited or \
2497                       q.supernova or q.status!="secure" or q.klingons<=0):
2498                     break
2499             else:
2500                 # can't seem to find one; ignore this call
2501                 if idebug:
2502                     prout("=== Couldn't find location for distress event.")
2503                 continue
2504             # got one!!  Schedule its enslavement
2505             ev = schedule(FENSLV, expran(game.intime))
2506             ev.quadrant = w
2507             q.status = "distressed"
2508             # tell the captain about it if we can
2509             if communicating():
2510                 prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \
2511                         % (q.planet, `w`))
2512                 prout(_("by a Klingon invasion fleet."))
2513                 if cancelrest():
2514                     return
2515         elif evcode == FENSLV:          # starsystem is enslaved
2516             ev = unschedule(FENSLV)
2517             # see if current distress call still active
2518             q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
2519             if q.klingons <= 0:
2520                 q.status = "secure"
2521                 continue
2522             q.status = "enslaved"
2523
2524             # play stork and schedule the first baby
2525             ev2 = schedule(FREPRO, expran(2.0 * game.intime))
2526             ev2.quadrant = ev.quadrant
2527
2528             # report the disaster if we can
2529             if communicating():
2530                 prout(_("Uhura- We've lost contact with starsystem %s") % \
2531                         q.planet)
2532                 prout(_("in Quadrant %s.\n") % ev.quadrant)
2533         elif evcode == FREPRO:          # Klingon reproduces
2534             # If we ever switch to a real event queue, we'll need to
2535             # explicitly retrieve and restore the x and y.
2536             ev = schedule(FREPRO, expran(1.0 * game.intime))
2537             # see if current distress call still active
2538             q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
2539             if q.klingons <= 0:
2540                 q.status = "secure"
2541                 continue
2542             if game.state.remkl >=MAXKLGAME:
2543                 continue                # full right now
2544             # reproduce one Klingon
2545             w = ev.quadrant
2546             m = coord()
2547             if game.klhere >= MAXKLQUAD:
2548                 try:
2549                     # this quadrant not ok, pick an adjacent one
2550                     for m.i in range(w.i - 1, w.i + 2):
2551                         for m.j in range(w.j - 1, w.j + 2):
2552                             if not m.valid_quadrant():
2553                                 continue
2554                             q = game.state.galaxy[m.i][m.j]
2555                             # check for this quad ok (not full & no snova)
2556                             if q.klingons >= MAXKLQUAD or q.supernova:
2557                                 continue
2558                             raise "FOUNDIT"
2559                     else:
2560                         continue        # search for eligible quadrant failed
2561                 except "FOUNDIT":
2562                     w = m
2563             # deliver the child
2564             game.state.remkl += 1
2565             q.klingons += 1
2566             if game.quadrant == w:
2567                 game.klhere += 1
2568                 game.enemies.append(newkling())
2569             # recompute time left
2570             game.recompute()
2571             if communicating():
2572                 if game.quadrant == w:
2573                     prout(_("Spock- sensors indicate the Klingons have"))
2574                     prout(_("launched a warship from %s.") % q.planet)
2575                 else:
2576                     prout(_("Uhura- Starfleet reports increased Klingon activity"))
2577                     if q.planet != None:
2578                         proutn(_("near %s") % q.planet)
2579                     prout(_("in Quadrant %s.") % w)
2580
2581 def wait():
2582     "Wait on events."
2583     game.ididit = False
2584     while True:
2585         key = scanner.next()
2586         if key  != "IHEOL":
2587             break
2588         proutn(_("How long? "))
2589     scanner.chew()
2590     if key != "IHREAL":
2591         huh()
2592         return
2593     origTime = delay = scanner.real
2594     if delay <= 0.0:
2595         return
2596     if delay >= game.state.remtime or len(game.enemies) != 0:
2597         proutn(_("Are you sure? "))
2598         if ja() == False:
2599             return
2600     # Alternate resting periods (events) with attacks
2601     game.resting = True
2602     while True:
2603         if delay <= 0:
2604             game.resting = False
2605         if not game.resting:
2606             prout(_("%d stardates left.") % int(game.state.remtime))
2607             return
2608         temp = game.optime = delay
2609         if len(game.enemies):
2610             rtime = randreal(1.0, 2.0)
2611             if rtime < temp:
2612                 temp = rtime
2613             game.optime = temp
2614         if game.optime < delay:
2615             attack(torps_ok=False)
2616         if game.alldone:
2617             return
2618         events()
2619         game.ididit = True
2620         if game.alldone:
2621             return
2622         delay -= temp
2623         # Repair Deathray if long rest at starbase
2624         if origTime-delay >= 9.99 and game.condition == "docked":
2625             game.damage[DDRAY] = 0.0
2626         # leave if quadrant supernovas
2627         if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
2628             break
2629     game.resting = False
2630     game.optime = 0
2631
2632 def nova(nov):
2633     "Star goes nova."
2634     course = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
2635     newc = coord(); neighbor = coord(); bump = coord(0, 0)
2636     if withprob(0.05):
2637         # Wow! We've supernova'ed
2638         supernova(game.quadrant)
2639         return
2640     # handle initial nova
2641     game.quad[nov.i][nov.j] = IHDOT
2642     prout(crmena(False, IHSTAR, "sector", nov) + _(" novas."))
2643     game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
2644     game.state.starkl += 1
2645     # Set up queue to recursively trigger adjacent stars
2646     hits = [nov]
2647     kount = 0
2648     while hits:
2649         offset = coord()
2650         start = hits.pop()
2651         for offset.i in range(-1, 1+1):
2652             for offset.j in range(-1, 1+1):
2653                 if offset.j==0 and offset.i==0:
2654                     continue
2655                 neighbor = start + offset
2656                 if not neighbor.valid_sector():
2657                     continue
2658                 iquad = game.quad[neighbor.i][neighbor.j]
2659                 # Empty space ends reaction
2660                 if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB):
2661                     pass
2662                 elif iquad == IHSTAR: # Affect another star
2663                     if withprob(0.05):
2664                         # This star supernovas
2665                         supernova(game.quadrant)
2666                         return
2667                     else:
2668                         hits.append(neighbor)
2669                         game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
2670                         game.state.starkl += 1
2671                         proutn(crmena(True, IHSTAR, "sector", neighbor))
2672                         prout(_(" novas."))
2673                         game.quad[neighbor.i][neighbor.j] = IHDOT
2674                         kount += 1
2675                 elif iquad in (IHP, IHW): # Destroy planet
2676                     game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
2677                     if iquad == IHP:
2678                         game.state.nplankl += 1
2679                     else:
2680                         game.state.worldkl += 1
2681                     prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
2682                     game.iplnet.pclass = "destroyed"
2683                     game.iplnet = None
2684                     game.plnet.invalidate()
2685                     if game.landed:
2686                         finish(FPNOVA)
2687                         return
2688                     game.quad[neighbor.i][neighbor.j] = IHDOT
2689                 elif iquad == IHB: # Destroy base
2690                     game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase = False
2691                     game.state.baseq = filter(lambda x: x!= game.quadrant, game.state.baseq)
2692                     game.base.invalidate()
2693                     game.state.basekl += 1
2694                     newcnd()
2695                     prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
2696                     game.quad[neighbor.i][neighbor.j] = IHDOT
2697                 elif iquad in (IHE, IHF): # Buffet ship
2698                     prout(_("***Starship buffeted by nova."))
2699                     if game.shldup:
2700                         if game.shield >= 2000.0:
2701                             game.shield -= 2000.0
2702                         else:
2703                             diff = 2000.0 - game.shield
2704                             game.energy -= diff
2705                             game.shield = 0.0
2706                             game.shldup = False
2707                             prout(_("***Shields knocked out."))
2708                             game.damage[DSHIELD] += 0.005*game.damfac*randreal()*diff
2709                     else:
2710                         game.energy -= 2000.0
2711                     if game.energy <= 0:
2712                         finish(FNOVA)
2713                         return
2714                     # add in course nova contributes to kicking starship
2715                     bump += (game.sector-hits[mm]).sgn()
2716                 elif iquad == IHK: # kill klingon
2717                     deadkl(neighbor, iquad, neighbor)
2718                 elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies
2719                     for ll in range(len(game.enemies)):
2720                         if game.enemies[ll].kloc == neighbor:
2721                             break
2722                     game.enemies[ll].kpower -= 800.0 # If firepower is lost, die
2723                     if game.enemies[ll].kpower <= 0.0:
2724                         deadkl(neighbor, iquad, neighbor)
2725                         break
2726                     newc = neighbor + neighbor - hits[mm]
2727                     proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
2728                     if not newc.valid_sector():
2729                         # can't leave quadrant
2730                         skip(1)
2731                         break
2732                     iquad1 = game.quad[newc.i][newc.j]
2733                     if iquad1 == IHBLANK:
2734                         proutn(_(", blasted into ") + crmena(False, IHBLANK, "sector", newc))
2735                         skip(1)
2736                         deadkl(neighbor, iquad, newc)
2737                         break
2738                     if iquad1 != IHDOT:
2739                         # can't move into something else
2740                         skip(1)
2741                         break
2742                     proutn(_(", buffeted to Sector %s") % newc)
2743                     game.quad[neighbor.i][neighbor.j] = IHDOT
2744                     game.quad[newc.i][newc.j] = iquad
2745                     game.enemies[ll].move(newc)
2746     # Starship affected by nova -- kick it away.
2747     dist = kount*0.1
2748     direc = course[3*(bump.i+1)+bump.j+2]
2749     if direc == 0.0:
2750         dist = 0.0
2751     if dist == 0.0:
2752         return
2753     course = course(bearing=direc, distance=dist)
2754     game.optime = course.time(warp=4)
2755     skip(1)
2756     prout(_("Force of nova displaces starship."))
2757     imove(course, novapush=True)
2758     game.optime = course.time(warp=4)
2759     return
2760
2761 def supernova(w):
2762     "Star goes supernova."
2763     num = 0; npdead = 0
2764     if w != None:
2765         nq = copy.copy(w)
2766     else:
2767         # Scheduled supernova -- select star at random.
2768         stars = 0
2769         nq = coord()
2770         for nq.i in range(GALSIZE):
2771             for nq.j in range(GALSIZE):
2772                 stars += game.state.galaxy[nq.i][nq.j].stars
2773         if stars == 0:
2774             return # nothing to supernova exists
2775         num = randrange(stars) + 1
2776         for nq.i in range(GALSIZE):
2777             for nq.j in range(GALSIZE):
2778                 num -= game.state.galaxy[nq.i][nq.j].stars
2779                 if num <= 0:
2780                     break
2781             if num <=0:
2782                 break
2783         if idebug:
2784             proutn("=== Super nova here?")
2785             if ja() == True:
2786                 nq = game.quadrant
2787     if not nq == game.quadrant or game.justin:
2788         # it isn't here, or we just entered (treat as enroute)
2789         if communicating():
2790             skip(1)
2791             prout(_("Message from Starfleet Command       Stardate %.2f") % game.state.date)
2792             prout(_("     Supernova in Quadrant %s; caution advised.") % nq)
2793     else:
2794         ns = coord()
2795         # we are in the quadrant!
2796         num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
2797         for ns.i in range(QUADSIZE):
2798             for ns.j in range(QUADSIZE):
2799                 if game.quad[ns.i][ns.j]==IHSTAR:
2800                     num -= 1
2801                     if num==0:
2802                         break
2803             if num==0:
2804                 break
2805         skip(1)
2806         prouts(_("***RED ALERT!  RED ALERT!"))
2807         skip(1)
2808         prout(_("***Incipient supernova detected at Sector %s") % ns)
2809         if (ns.i-game.sector.i)**2 + (ns.j-game.sector.j)**2 <= 2.1:
2810             proutn(_("Emergency override attempts t"))
2811             prouts("***************")
2812             skip(1)
2813             stars()
2814             game.alldone = True
2815     # destroy any Klingons in supernovaed quadrant
2816     kldead = game.state.galaxy[nq.i][nq.j].klingons
2817     game.state.galaxy[nq.i][nq.j].klingons = 0
2818     if nq == game.state.kscmdr:
2819         # did in the Supercommander!
2820         game.state.nscrem = game.state.kscmdr.i = game.state.kscmdr.j = game.isatb =  0
2821         game.iscate = False
2822         unschedule(FSCMOVE)
2823         unschedule(FSCDBAS)
2824     survivors = filter(lambda w: w != nq, game.state.kcmdr)
2825     comkills = len(game.state.kcmdr) - len(survivors)
2826     game.state.kcmdr = survivors
2827     kldead -= comkills
2828     if not game.state.kcmdr:
2829         unschedule(FTBEAM)
2830     game.state.remkl -= kldead
2831     # destroy Romulans and planets in supernovaed quadrant
2832     nrmdead = game.state.galaxy[nq.i][nq.j].romulans
2833     game.state.galaxy[nq.i][nq.j].romulans = 0
2834     game.state.nromrem -= nrmdead
2835     # Destroy planets
2836     for loop in range(game.inplan):
2837         if game.state.planets[loop].quadrant == nq:
2838             game.state.planets[loop].pclass = "destroyed"
2839             npdead += 1
2840     # Destroy any base in supernovaed quadrant
2841     game.state.baseq = filter(lambda x: x != nq, game.state.baseq)
2842     # If starship caused supernova, tally up destruction
2843     if w != None:
2844         game.state.starkl += game.state.galaxy[nq.i][nq.j].stars
2845         game.state.basekl += game.state.galaxy[nq.i][nq.j].starbase
2846         game.state.nplankl += npdead
2847     # mark supernova in galaxy and in star chart
2848     if game.quadrant == nq or communicating():
2849         game.state.galaxy[nq.i][nq.j].supernova = True
2850     # If supernova destroys last Klingons give special message
2851     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0 and not nq == game.quadrant:
2852         skip(2)
2853         if w == None:
2854             prout(_("Lucky you!"))
2855         proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq)
2856         finish(FWON)
2857         return
2858     # if some Klingons remain, continue or die in supernova
2859     if game.alldone:
2860         finish(FSNOVAED)
2861     return
2862
2863 # Code from finish.c ends here.
2864
2865 def selfdestruct():
2866     "Self-destruct maneuver. Finish with a BANG!"
2867     scanner.chew()
2868     if damaged(DCOMPTR):
2869         prout(_("Computer damaged; cannot execute destruct sequence."))
2870         return
2871     prouts(_("---WORKING---")); skip(1)
2872     prouts(_("SELF-DESTRUCT-SEQUENCE-ACTIVATED")); skip(1)
2873     prouts("   10"); skip(1)
2874     prouts("       9"); skip(1)
2875     prouts("          8"); skip(1)
2876     prouts("             7"); skip(1)
2877     prouts("                6"); skip(1)
2878     skip(1)
2879     prout(_("ENTER-CORRECT-PASSWORD-TO-CONTINUE-"))
2880     skip(1)
2881     prout(_("SELF-DESTRUCT-SEQUENCE-OTHERWISE-"))
2882     skip(1)
2883     prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED"))
2884     skip(1)
2885     scanner.next()
2886     scanner.chew()
2887     if game.passwd != scanner.token:
2888         prouts(_("PASSWORD-REJECTED;"))
2889         skip(1)
2890         prouts(_("CONTINUITY-EFFECTED"))
2891         skip(2)
2892         return
2893     prouts(_("PASSWORD-ACCEPTED")); skip(1)
2894     prouts("                   5"); skip(1)
2895     prouts("                      4"); skip(1)
2896     prouts("                         3"); skip(1)
2897     prouts("                            2"); skip(1)
2898     prouts("                              1"); skip(1)
2899     if withprob(0.15):
2900         prouts(_("GOODBYE-CRUEL-WORLD"))
2901         skip(1)
2902     kaboom()
2903
2904 def kaboom():
2905     stars()
2906     if game.ship==IHE:
2907         prouts("***")
2908     prouts(_("********* Entropy of %s maximized *********") % crmshp())
2909     skip(1)
2910     stars()
2911     skip(1)
2912     if len(game.enemies) != 0:
2913         whammo = 25.0 * game.energy
2914         l=1
2915         while l <= len(game.enemies):
2916             if game.enemies[l].kpower*game.enemies[l].kdist <= whammo:
2917                 deadkl(game.enemies[l].kloc, game.quad[game.enemies[l].kloc.i][game.enemies[l].kloc.j], game.enemies[l].kloc)
2918             l += 1
2919     finish(FDILITHIUM)
2920
2921 def killrate():
2922     "Compute our rate of kils over time."
2923     elapsed = game.state.date - game.indate
2924     if elapsed == 0:    # Avoid divide-by-zero error if calculated on turn 0
2925         return 0
2926     else:
2927         starting = (game.inkling + game.incom + game.inscom)
2928         remaining = (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)
2929         return (starting - remaining)/elapsed
2930
2931 def badpoints():
2932     "Compute demerits."
2933     badpt = 5.0*game.state.starkl + \
2934             game.casual + \
2935             10.0*game.state.nplankl + \
2936             300*game.state.nworldkl + \
2937             45.0*game.nhelp +\
2938             100.0*game.state.basekl +\
2939             3.0*game.abandoned
2940     if game.ship == IHF:
2941         badpt += 100.0
2942     elif game.ship == None:
2943         badpt += 200.0
2944     return badpt
2945
2946 def finish(ifin):
2947     # end the game, with appropriate notfications
2948     igotit = False
2949     game.alldone = True
2950     skip(3)
2951     prout(_("It is stardate %.1f.") % game.state.date)
2952     skip(1)
2953     if ifin == FWON: # Game has been won
2954         if game.state.nromrem != 0:
2955             prout(_("The remaining %d Romulans surrender to Starfleet Command.") %
2956                   game.state.nromrem)
2957
2958         prout(_("You have smashed the Klingon invasion fleet and saved"))
2959         prout(_("the Federation."))
2960         game.gamewon = True
2961         if game.alive:
2962             badpt = badpoints()
2963             if badpt < 100.0:
2964                 badpt = 0.0     # Close enough!
2965             # killsPerDate >= RateMax
2966             if game.state.date-game.indate < 5.0 or \
2967                 killrate() >= 0.1*game.skill*(game.skill+1.0) + 0.1 + 0.008*badpt:
2968                 skip(1)
2969                 prout(_("In fact, you have done so well that Starfleet Command"))
2970                 if game.skill == SKILL_NOVICE:
2971                     prout(_("promotes you one step in rank from \"Novice\" to \"Fair\"."))
2972                 elif game.skill == SKILL_FAIR:
2973                     prout(_("promotes you one step in rank from \"Fair\" to \"Good\"."))
2974                 elif game.skill == SKILL_GOOD:
2975                     prout(_("promotes you one step in rank from \"Good\" to \"Expert\"."))
2976                 elif game.skill == SKILL_EXPERT:
2977                     prout(_("promotes you to Commodore Emeritus."))
2978                     skip(1)
2979                     prout(_("Now that you think you're really good, try playing"))
2980                     prout(_("the \"Emeritus\" game. It will splatter your ego."))
2981                 elif game.skill == SKILL_EMERITUS:
2982                     skip(1)
2983                     proutn(_("Computer-  "))
2984                     prouts(_("ERROR-ERROR-ERROR-ERROR"))
2985                     skip(2)
2986                     prouts(_("  YOUR-SKILL-HAS-EXCEEDED-THE-CAPACITY-OF-THIS-PROGRAM"))
2987                     skip(1)
2988                     prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
2989                     skip(1)
2990                     prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
2991                     skip(1)
2992                     prouts(_("  THIS-PROGRAM-MUST-SURVIVE"))
2993                     skip(1)
2994                     prouts(_("  THIS-PROGRAM-MUST?- MUST ? - SUR? ? -?  VI"))
2995                     skip(2)
2996                     prout(_("Now you can retire and write your own Star Trek game!"))
2997                     skip(1)
2998                 elif game.skill >= SKILL_EXPERT:
2999                     if game.thawed and not idebug:
3000                         prout(_("You cannot get a citation, so..."))
3001                     else:
3002                         proutn(_("Do you want your Commodore Emeritus Citation printed? "))
3003                         scanner.chew()
3004                         if ja() == True:
3005                             igotit = True
3006             # Only grant long life if alive (original didn't!)
3007             skip(1)
3008             prout(_("LIVE LONG AND PROSPER."))
3009         score()
3010         if igotit:
3011             plaque()
3012         return
3013     elif ifin == FDEPLETE: # Federation Resources Depleted
3014         prout(_("Your time has run out and the Federation has been"))
3015         prout(_("conquered.  Your starship is now Klingon property,"))
3016         prout(_("and you are put on trial as a war criminal.  On the"))
3017         proutn(_("basis of your record, you are "))
3018         if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom):
3019             prout(_("acquitted."))
3020             skip(1)
3021             prout(_("LIVE LONG AND PROSPER."))
3022         else:
3023             prout(_("found guilty and"))
3024             prout(_("sentenced to death by slow torture."))
3025             game.alive = False
3026         score()
3027         return
3028     elif ifin == FLIFESUP:
3029         prout(_("Your life support reserves have run out, and"))
3030         prout(_("you die of thirst, starvation, and asphyxiation."))
3031         prout(_("Your starship is a derelict in space."))
3032     elif ifin == FNRG:
3033         prout(_("Your energy supply is exhausted."))
3034         skip(1)
3035         prout(_("Your starship is a derelict in space."))
3036     elif ifin == FBATTLE:
3037         prout(_("The %s has been destroyed in battle.") % crmshp())
3038         skip(1)
3039         prout(_("Dulce et decorum est pro patria mori."))
3040     elif ifin == FNEG3:
3041         prout(_("You have made three attempts to cross the negative energy"))
3042         prout(_("barrier which surrounds the galaxy."))
3043         skip(1)
3044         prout(_("Your navigation is abominable."))
3045         score()
3046     elif ifin == FNOVA:
3047         prout(_("Your starship has been destroyed by a nova."))
3048         prout(_("That was a great shot."))
3049         skip(1)
3050     elif ifin == FSNOVAED:
3051         prout(_("The %s has been fried by a supernova.") % crmshp())
3052         prout(_("...Not even cinders remain..."))
3053     elif ifin == FABANDN:
3054         prout(_("You have been captured by the Klingons. If you still"))
3055         prout(_("had a starbase to be returned to, you would have been"))
3056         prout(_("repatriated and given another chance. Since you have"))
3057         prout(_("no starbases, you will be mercilessly tortured to death."))
3058     elif ifin == FDILITHIUM:
3059         prout(_("Your starship is now an expanding cloud of subatomic particles"))
3060     elif ifin == FMATERIALIZE:
3061         prout(_("Starbase was unable to re-materialize your starship."))
3062         prout(_("Sic transit gloria mundi"))
3063     elif ifin == FPHASER:
3064         prout(_("The %s has been cremated by its own phasers.") % crmshp())
3065     elif ifin == FLOST:
3066         prout(_("You and your landing party have been"))
3067         prout(_("converted to energy, disipating through space."))
3068     elif ifin == FMINING:
3069         prout(_("You are left with your landing party on"))
3070         prout(_("a wild jungle planet inhabited by primitive cannibals."))
3071         skip(1)
3072         prout(_("They are very fond of \"Captain Kirk\" soup."))
3073         skip(1)
3074         prout(_("Without your leadership, the %s is destroyed.") % crmshp())
3075     elif ifin == FDPLANET:
3076         prout(_("You and your mining party perish."))
3077         skip(1)
3078         prout(_("That was a great shot."))
3079         skip(1)
3080     elif ifin == FSSC:
3081         prout(_("The Galileo is instantly annihilated by the supernova."))
3082         prout(_("You and your mining party are atomized."))
3083         skip(1)
3084         prout(_("Mr. Spock takes command of the %s and") % crmshp())
3085         prout(_("joins the Romulans, wreaking terror on the Federation."))
3086     elif ifin == FPNOVA:
3087         prout(_("You and your mining party are atomized."))
3088         skip(1)
3089         prout(_("Mr. Spock takes command of the %s and") % crmshp())
3090         prout(_("joins the Romulans, wreaking terror on the Federation."))
3091     elif ifin == FSTRACTOR:
3092         prout(_("The shuttle craft Galileo is also caught,"))
3093         prout(_("and breaks up under the strain."))
3094         skip(1)
3095         prout(_("Your debris is scattered for millions of miles."))
3096         prout(_("Without your leadership, the %s is destroyed.") % crmshp())
3097     elif ifin == FDRAY:
3098         prout(_("The mutants attack and kill Spock."))
3099         prout(_("Your ship is captured by Klingons, and"))
3100         prout(_("your crew is put on display in a Klingon zoo."))
3101     elif ifin == FTRIBBLE:
3102         prout(_("Tribbles consume all remaining water,"))
3103         prout(_("food, and oxygen on your ship."))
3104         skip(1)
3105         prout(_("You die of thirst, starvation, and asphyxiation."))
3106         prout(_("Your starship is a derelict in space."))
3107     elif ifin == FHOLE:
3108         prout(_("Your ship is drawn to the center of the black hole."))
3109         prout(_("You are crushed into extremely dense matter."))
3110     elif ifin == FCREW:
3111         prout(_("Your last crew member has died."))
3112     if game.ship == IHF:
3113         game.ship = None
3114     elif game.ship == IHE:
3115         game.ship = IHF
3116     game.alive = False
3117     if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
3118         goodies = game.state.remres/game.inresor
3119         baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom)
3120         if goodies/baddies >= randreal(1.0, 1.5):
3121             prout(_("As a result of your actions, a treaty with the Klingon"))
3122             prout(_("Empire has been signed. The terms of the treaty are"))
3123             if goodies/baddies >= randreal(3.0):
3124                 prout(_("favorable to the Federation."))
3125                 skip(1)
3126                 prout(_("Congratulations!"))
3127             else:
3128                 prout(_("highly unfavorable to the Federation."))
3129         else:
3130             prout(_("The Federation will be destroyed."))
3131     else:
3132         prout(_("Since you took the last Klingon with you, you are a"))
3133         prout(_("martyr and a hero. Someday maybe they'll erect a"))
3134         prout(_("statue in your memory. Rest in peace, and try not"))
3135         prout(_("to think about pigeons."))
3136         game.gamewon = True
3137     score()
3138
3139 def score():
3140     "Compute player's score."
3141     timused = game.state.date - game.indate
3142     iskill = game.skill
3143     if (timused == 0 or (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0:
3144         timused = 5.0
3145     perdate = killrate()
3146     ithperd = 500*perdate + 0.5
3147     iwon = 0
3148     if game.gamewon:
3149         iwon = 100*game.skill
3150     if game.ship == IHE:
3151         klship = 0
3152     elif game.ship == IHF:
3153         klship = 1
3154     else:
3155         klship = 2
3156     if not game.gamewon:
3157         game.state.nromrem = 0 # None captured if no win
3158     iscore = 10*(game.inkling - game.state.remkl) \
3159              + 50*(game.incom - len(game.state.kcmdr)) \
3160              + ithperd + iwon \
3161              + 20*(game.inrom - game.state.nromrem) \
3162              + 200*(game.inscom - game.state.nscrem) \
3163              - game.state.nromrem \
3164              - badpoints()
3165     if not game.alive:
3166         iscore -= 200
3167     skip(2)
3168     prout(_("Your score --"))
3169     if game.inrom - game.state.nromrem:
3170         prout(_("%6d Romulans destroyed                 %5d") %
3171               (game.inrom - game.state.nromrem, 20*(game.inrom - game.state.nromrem)))
3172     if game.state.nromrem:
3173         prout(_("%6d Romulans captured                  %5d") %
3174               (game.state.nromrem, game.state.nromrem))
3175     if game.inkling - game.state.remkl:
3176         prout(_("%6d ordinary Klingons destroyed        %5d") %
3177               (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl)))
3178     if game.incom - len(game.state.kcmdr):
3179         prout(_("%6d Klingon commanders destroyed       %5d") %
3180               (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr))))
3181     if game.inscom - game.state.nscrem:
3182         prout(_("%6d Super-Commander destroyed          %5d") %
3183               (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
3184     if ithperd:
3185         prout(_("%6.2f Klingons per stardate              %5d") %
3186               (perdate, ithperd))
3187     if game.state.starkl:
3188         prout(_("%6d stars destroyed by your action     %5d") %
3189               (game.state.starkl, -5*game.state.starkl))
3190     if game.state.nplankl:
3191         prout(_("%6d planets destroyed by your action   %5d") %
3192               (game.state.nplankl, -10*game.state.nplankl))
3193     if (game.options & OPTION_WORLDS) and game.state.nworldkl:
3194         prout(_("%6d inhabited planets destroyed by your action   %5d") %
3195               (game.state.nplankl, -300*game.state.nworldkl))
3196     if game.state.basekl:
3197         prout(_("%6d bases destroyed by your action     %5d") %
3198               (game.state.basekl, -100*game.state.basekl))
3199     if game.nhelp:
3200         prout(_("%6d calls for help from starbase       %5d") %
3201               (game.nhelp, -45*game.nhelp))
3202     if game.casual:
3203         prout(_("%6d casualties incurred                %5d") %
3204               (game.casual, -game.casual))
3205     if game.abandoned:
3206         prout(_("%6d crew abandoned in space            %5d") %
3207               (game.abandoned, -3*game.abandoned))
3208     if klship:
3209         prout(_("%6d ship(s) lost or destroyed          %5d") %
3210               (klship, -100*klship))
3211     if not game.alive:
3212         prout(_("Penalty for getting yourself killed        -200"))
3213     if game.gamewon:
3214         proutn(_("Bonus for winning "))
3215         if game.skill   == SKILL_NOVICE:        proutn(_("Novice game  "))
3216         elif game.skill == SKILL_FAIR:          proutn(_("Fair game    "))
3217         elif game.skill ==  SKILL_GOOD:         proutn(_("Good game    "))
3218         elif game.skill ==  SKILL_EXPERT:       proutn(_("Expert game  "))
3219         elif game.skill ==  SKILL_EMERITUS:     proutn(_("Emeritus game"))
3220         prout("           %5d" % iwon)
3221     skip(1)
3222     prout(_("TOTAL SCORE                               %5d") % iscore)
3223
3224 def plaque():
3225     "Emit winner's commemmorative plaque."
3226     skip(2)
3227     while True:
3228         proutn(_("File or device name for your plaque: "))
3229         winner = cgetline()
3230         try:
3231             fp = open(winner, "w")
3232             break
3233         except IOError:
3234             prout(_("Invalid name."))
3235
3236     proutn(_("Enter name to go on plaque (up to 30 characters): "))
3237     winner = cgetline()
3238     # The 38 below must be 64 for 132-column paper
3239     nskip = 38 - len(winner)/2
3240     fp.write("\n\n\n\n")
3241     # --------DRAW ENTERPRISE PICTURE.
3242     fp.write("                                       EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n" )
3243     fp.write("                                      EEE                      E  : :                                         :  E\n" )
3244     fp.write("                                    EE   EEE                   E  : :                   NCC-1701              :  E\n")
3245     fp.write("EEEEEEEEEEEEEEEE        EEEEEEEEEEEEEEE  : :                              : E\n")
3246     fp.write(" E                                     EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n")
3247     fp.write("                      EEEEEEEEE               EEEEEEEEEEEEE                 E  E\n")
3248     fp.write("                               EEEEEEE   EEEEE    E          E              E  E\n")
3249     fp.write("                                      EEE           E          E            E  E\n")
3250     fp.write("                                                       E         E          E  E\n")
3251     fp.write("                                                         EEEEEEEEEEEEE      E  E\n")
3252     fp.write("                                                      EEE :           EEEEEEE  EEEEEEEE\n")
3253     fp.write("                                                    :E    :                 EEEE       E\n")
3254     fp.write("                                                   .-E   -:-----                       E\n")
3255     fp.write("                                                    :E    :                            E\n")
3256     fp.write("                                                      EE  :                    EEEEEEEE\n")
3257     fp.write("                                                       EEEEEEEEEEEEEEEEEEEEEEE\n")
3258     fp.write("\n\n\n")
3259     fp.write(_("                                                       U. S. S. ENTERPRISE\n"))
3260     fp.write("\n\n\n\n")
3261     fp.write(_("                                  For demonstrating outstanding ability as a starship captain\n"))
3262     fp.write("\n")
3263     fp.write(_("                                                Starfleet Command bestows to you\n"))
3264     fp.write("\n")
3265     fp.write("%*s%s\n\n" % (nskip, "", winner))
3266     fp.write(_("                                                           the rank of\n\n"))
3267     fp.write(_("                                                       \"Commodore Emeritus\"\n\n"))
3268     fp.write("                                                          ")
3269     if game.skill ==  SKILL_EXPERT:
3270         fp.write(_(" Expert level\n\n"))
3271     elif game.skill == SKILL_EMERITUS:
3272         fp.write(_("Emeritus level\n\n"))
3273     else:
3274         fp.write(_(" Cheat level\n\n"))
3275     timestring = time.ctime()
3276     fp.write(_("                                                 This day of %.6s %.4s, %.8s\n\n") %
3277                     (timestring+4, timestring+20, timestring+11))
3278     fp.write(_("                                                        Your score:  %d\n\n") % iscore)
3279     fp.write(_("                                                    Klingons per stardate:  %.2f\n") % perdate)
3280     fp.close()
3281
3282 # Code from io.c begins here
3283
3284 rows = linecount = 0    # for paging
3285 stdscr = None
3286 replayfp = None
3287 fullscreen_window = None
3288 srscan_window     = None
3289 report_window     = None
3290 status_window     = None
3291 lrscan_window     = None
3292 message_window    = None
3293 prompt_window     = None
3294 curwnd = None
3295