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