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