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