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