Fix bug in hittem().
[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 not kk < len(game.enemies):
1805             # Should never happen.
1806             break
1807         if wham == 0:
1808             continue
1809         dustfac = randreal(0.9, 1.0)
1810         hit = wham*math.pow(dustfac, game.enemies[kk].kdist)
1811         kpini = game.enemies[kk].power
1812         kp = math.fabs(kpini)
1813         if PHASEFAC*hit < kp:
1814             kp = PHASEFAC*hit
1815         if game.enemies[kk].power < 0:
1816             game.enemies[kk].power -= -kp
1817         else:
1818             game.enemies[kk].power -= kp
1819         kpow = game.enemies[kk].power
1820         w = game.enemies[kk].location
1821         if hit > 0.005:
1822             if not damaged(DSRSENS):
1823                 boom(w)
1824             proutn(_("%d unit hit on ") % int(hit))
1825         else:
1826             proutn(_("Very small hit on "))
1827         ienm = game.quad[w.i][w.j]
1828         if ienm == '?':
1829             thing.angry()
1830         proutn(crmena(False, ienm, "sector", w))
1831         skip(1)
1832         if kpow == 0:
1833             deadkl(w, ienm, w)
1834             if game.unwon()==0:
1835                 finish(FWON)
1836             if game.alldone:
1837                 return
1838             continue
1839         else: # decide whether or not to emasculate klingon
1840             if kpow > 0 and withprob(0.9) and kpow <= randreal(0.4, 0.8)*kpini:
1841                 prout(_("***Mr. Spock-  \"Captain, the vessel at Sector %s")%w)
1842                 prout(_("   has just lost its firepower.\""))
1843                 game.enemies[kk].power = -kpow
1844         kk += 1
1845     return
1846
1847 def phasers():
1848     "Fire phasers at bad guys."
1849     hits = []
1850     kz = 0
1851     k = 1
1852     irec = 0 # Cheating inhibitor
1853     ifast = False
1854     no = False
1855     itarg = True
1856     msgflag = True
1857     rpow = 0.0
1858     automode = "NOTSET"
1859     key = ""
1860     skip(1)
1861     # SR sensors and Computer are needed for automode
1862     if damaged(DSRSENS) or damaged(DCOMPTR):
1863         itarg = False
1864     if game.condition == "docked":
1865         prout(_("Phasers can't be fired through base shields."))
1866         scanner.chew()
1867         return
1868     if damaged(DPHASER):
1869         prout(_("Phaser control damaged."))
1870         scanner.chew()
1871         return
1872     if game.shldup:
1873         if damaged(DSHCTRL):
1874             prout(_("High speed shield control damaged."))
1875             scanner.chew()
1876             return
1877         if game.energy <= 200.0:
1878             prout(_("Insufficient energy to activate high-speed shield control."))
1879             scanner.chew()
1880             return
1881         prout(_("Weapons Officer Sulu-  \"High-speed shield control enabled, sir.\""))
1882         ifast = True
1883     # Original code so convoluted, I re-did it all
1884     # (That was Tom Almy talking about the C code, I think -- ESR)
1885     while automode == "NOTSET":
1886         key = scanner.nexttok()
1887         if key == "IHALPHA":
1888             if scanner.sees("manual"):
1889                 if len(game.enemies)==0:
1890                     prout(_("There is no enemy present to select."))
1891                     scanner.chew()
1892                     key = "IHEOL"
1893                     automode = "AUTOMATIC"
1894                 else:
1895                     automode = "MANUAL"
1896                     key = scanner.nexttok()
1897             elif scanner.sees("automatic"):
1898                 if (not itarg) and len(game.enemies) != 0:
1899                     automode = "FORCEMAN"
1900                 else:
1901                     if len(game.enemies)==0:
1902                         prout(_("Energy will be expended into space."))
1903                     automode = "AUTOMATIC"
1904                     key = scanner.nexttok()
1905             elif scanner.sees("no"):
1906                 no = True
1907             else:
1908                 huh()
1909                 return
1910         elif key == "IHREAL":
1911             if len(game.enemies)==0:
1912                 prout(_("Energy will be expended into space."))
1913                 automode = "AUTOMATIC"
1914             elif not itarg:
1915                 automode = "FORCEMAN"
1916             else:
1917                 automode = "AUTOMATIC"
1918         else:
1919             # "IHEOL"
1920             if len(game.enemies)==0:
1921                 prout(_("Energy will be expended into space."))
1922                 automode = "AUTOMATIC"
1923             elif not itarg:
1924                 automode = "FORCEMAN"
1925             else:
1926                 proutn(_("Manual or automatic? "))
1927                 scanner.chew()
1928     avail = game.energy
1929     if ifast:
1930         avail -= 200.0
1931     if automode == "AUTOMATIC":
1932         if key == "IHALPHA" and scanner.sees("no"):
1933             no = True
1934             key = scanner.nexttok()
1935         if key != "IHREAL" and len(game.enemies) != 0:
1936             prout(_("Phasers locked on target. Energy available: %.2f")%avail)
1937         irec = 0
1938         while True:
1939             scanner.chew()
1940             if not kz:
1941                 for i in range(len(game.enemies)):
1942                     irec += math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90, game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
1943             kz = 1
1944             proutn(_("%d units required. ") % irec)
1945             scanner.chew()
1946             proutn(_("Units to fire= "))
1947             key = scanner.nexttok()
1948             if key != "IHREAL":
1949                 return
1950             rpow = scanner.real
1951             if rpow > avail:
1952                 proutn(_("Energy available= %.2f") % avail)
1953                 skip(1)
1954                 key = "IHEOL"
1955             if not rpow > avail:
1956                 break
1957         if rpow <= 0:
1958             # chicken out
1959             scanner.chew()
1960             return
1961         key = scanner.nexttok()
1962         if key == "IHALPHA" and scanner.sees("no"):
1963             no = True
1964         if ifast:
1965             game.energy -= 200 # Go and do it!
1966             if checkshctrl(rpow):
1967                 return
1968         scanner.chew()
1969         game.energy -= rpow
1970         extra = rpow
1971         if len(game.enemies):
1972             extra = 0.0
1973             powrem = rpow
1974             for i in range(len(game.enemies)):
1975                 hits.append(0.0)
1976                 if powrem <= 0:
1977                     continue
1978                 hits[i] = math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90, game.enemies[i].kdist))
1979                 over = randreal(1.01, 1.06) * hits[i]
1980                 temp = powrem
1981                 powrem -= hits[i] + over
1982                 if powrem <= 0 and temp < hits[i]:
1983                     hits[i] = temp
1984                 if powrem <= 0:
1985                     over = 0.0
1986                 extra += over
1987             if powrem > 0.0:
1988                 extra += powrem
1989             hittem(hits)
1990             game.ididit = True
1991         if extra > 0 and not game.alldone:
1992             if game.tholian:
1993                 proutn(_("*** Tholian web absorbs "))
1994                 if len(game.enemies)>0:
1995                     proutn(_("excess "))
1996                 prout(_("phaser energy."))
1997             else:
1998                 prout(_("%d expended on empty space.") % int(extra))
1999     elif automode == "FORCEMAN":
2000         scanner.chew()
2001         key = "IHEOL"
2002         if damaged(DCOMPTR):
2003             prout(_("Battle computer damaged, manual fire only."))
2004         else:
2005             skip(1)
2006             prouts(_("---WORKING---"))
2007             skip(1)
2008             prout(_("Short-range-sensors-damaged"))
2009             prout(_("Insufficient-data-for-automatic-phaser-fire"))
2010             prout(_("Manual-fire-must-be-used"))
2011             skip(1)
2012     elif automode == "MANUAL":
2013         rpow = 0.0
2014         for k in range(len(game.enemies)):
2015             aim = game.enemies[k].location
2016             ienm = game.quad[aim.i][aim.j]
2017             if msgflag:
2018                 proutn(_("Energy available= %.2f") % (avail-0.006))
2019                 skip(1)
2020                 msgflag = False
2021                 rpow = 0.0
2022             if damaged(DSRSENS) and \
2023                not game.sector.distance(aim)<2**0.5 and ienm in ('C', 'S'):
2024                 prout(cramen(ienm) + _(" can't be located without short range scan."))
2025                 scanner.chew()
2026                 key = "IHEOL"
2027                 hits[k] = 0 # prevent overflow -- thanks to Alexei Voitenko
2028                 k += 1
2029                 continue
2030             if key == "IHEOL":
2031                 scanner.chew()
2032                 if itarg and k > kz:
2033                     irec = (abs(game.enemies[k].power)/(PHASEFAC*math.pow(0.9, game.enemies[k].kdist))) *        randreal(1.01, 1.06) + 1.0
2034                 kz = k
2035                 proutn("(")
2036                 if not damaged(DCOMPTR):
2037                     proutn("%d" % irec)
2038                 else:
2039                     proutn("??")
2040                 proutn(")  ")
2041                 proutn(_("units to fire at %s-  ") % crmena(False, ienm, "sector", aim))
2042                 key = scanner.nexttok()
2043             if key == "IHALPHA" and scanner.sees("no"):
2044                 no = True
2045                 key = scanner.nexttok()
2046                 continue
2047             if key == "IHALPHA":
2048                 huh()
2049                 return
2050             if key == "IHEOL":
2051                 if k == 1: # Let me say I'm baffled by this
2052                     msgflag = True
2053                 continue
2054             if scanner.real < 0:
2055                 # abort out
2056                 scanner.chew()
2057                 return
2058             hits[k] = scanner.real
2059             rpow += scanner.real
2060             # If total requested is too much, inform and start over
2061             if rpow > avail:
2062                 prout(_("Available energy exceeded -- try again."))
2063                 scanner.chew()
2064                 return
2065             key = scanner.nexttok() # scan for next value
2066             k += 1
2067         if rpow == 0.0:
2068             # zero energy -- abort
2069             scanner.chew()
2070             return
2071         if key == "IHALPHA" and scanner.sees("no"):
2072             no = True
2073         game.energy -= rpow
2074         scanner.chew()
2075         if ifast:
2076             game.energy -= 200.0
2077             if checkshctrl(rpow):
2078                 return
2079         hittem(hits)
2080         game.ididit = True
2081      # Say shield raised or malfunction, if necessary
2082     if game.alldone:
2083         return
2084     if ifast:
2085         skip(1)
2086         if no == 0:
2087             if withprob(0.01):
2088                 prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
2089                 prouts(_("         CLICK   CLICK   POP  . . ."))
2090                 prout(_(" No response, sir!"))
2091                 game.shldup = False
2092             else:
2093                 prout(_("Shields raised."))
2094         else:
2095             game.shldup = False
2096     overheat(rpow)
2097
2098
2099 def capture():
2100     game.ididit = False # Nothing if we fail
2101     game.optime = 0.0;
2102
2103     # Make sure there is room in the brig */
2104     if game.brigfree == 0:
2105         prout(_("Security reports the brig is already full."))
2106         return;
2107
2108     if damaged(DRADIO):
2109         prout(_("Uhura- \"We have no subspace radio communication, sir.\""))
2110         return
2111
2112     if damaged(DTRANSP):
2113         prout(_("Scotty- \"Transporter damaged, sir.\""))
2114         return
2115
2116     # find out if there are any at all
2117     if game.klhere < 1:
2118         prout(_("Uhura- \"Getting no response, sir.\""))
2119         return
2120
2121     # if there is more than one Klingon, find out which one */
2122     #   Cruddy, just takes one at random.  Should ask the captain.
2123     #   Nah, just select the weakest one since it is most likely to
2124     #   surrender (Tom Almy mod)
2125     klingons = [e for e in game.enemies if e.type == 'K']
2126     weakest = sorted(klingons, key=lambda e: e.power)[0]
2127     game.optime = 0.05          # This action will take some time
2128     game.ididit = True #  So any others can strike back
2129
2130     # check out that Klingon
2131     # The algorithm isn't that great and could use some more
2132     # intelligent design
2133     # x = 300 + 25*skill;
2134     x = game.energy / (weakest.power * len(klingons))
2135     #prout(_("Stats: energy = %s, kpower = %s, klingons = %s")
2136     #      % (game.energy, weakest.power, len(klingons))) 
2137     x *= 2.5  # would originally have been equivalent of 1.4,
2138                # but we want command to work more often, more humanely */
2139     #prout(_("Prob = %.4f" % x))
2140     #   x = 100; // For testing, of course!
2141     if x < randreal(100):
2142         # guess what, he surrendered!!! */
2143         prout(_("Klingon captain at %s surrenders.") % weakest.location)
2144         i = randreal(200)
2145         if i > 0:
2146             prout(_("%d Klingons commit suicide rather than be taken captive.") % (200 - i))
2147         if i > game.brigfree:
2148             prout(_("%d Klingons die because there is no room for them in the brig.") % (i-brigfree))
2149             i = game.brigfree
2150         game.brigfree -= i
2151         prout(_("%d captives taken") % i)
2152         deadkl(weakest.location, weakest.type, game.sector)
2153         if game.unwon()<=0:
2154             finish(FWON)
2155         return
2156
2157         # big surprise, he refuses to surrender */
2158     prout(_("Fat chance, captain!"))
2159
2160 # Code from events.c begins here.
2161
2162 # This isn't a real event queue a la BSD Trek yet -- you can only have one
2163 # event of each type active at any given time.  Mostly these means we can
2164 # only have one FDISTR/FENSLV/FREPRO sequence going at any given time
2165 # BSD Trek, from which we swiped the idea, can have up to 5.
2166
2167 def unschedule(evtype):
2168     "Remove an event from the schedule."
2169     game.future[evtype].date = FOREVER
2170     return game.future[evtype]
2171
2172 def is_scheduled(evtype):
2173     "Is an event of specified type scheduled."
2174     return game.future[evtype].date != FOREVER
2175
2176 def scheduled(evtype):
2177     "When will this event happen?"
2178     return game.future[evtype].date
2179
2180 def schedule(evtype, offset):
2181     "Schedule an event of specified type."
2182     game.future[evtype].date = game.state.date + offset
2183     return game.future[evtype]
2184
2185 def postpone(evtype, offset):
2186     "Postpone a scheduled event."
2187     game.future[evtype].date += offset
2188
2189 def cancelrest():
2190     "Rest period is interrupted by event."
2191     if game.resting:
2192         skip(1)
2193         proutn(_("Mr. Spock-  \"Captain, shall we cancel the rest period?\""))
2194         if ja():
2195             game.resting = False
2196             game.optime = 0.0
2197             return True
2198     return False
2199
2200 def events():
2201     "Run through the event queue looking for things to do."
2202     i = 0
2203     fintim = game.state.date + game.optime
2204     yank = 0
2205     ictbeam = False
2206     istract = False
2207     w = Coord()
2208     hold = Coord()
2209     ev = Event()
2210     ev2 = Event()
2211
2212     def tractorbeam(yank):
2213         "Tractor-beaming cases merge here."
2214         announce()
2215         game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5)
2216         skip(1)
2217         prout("***" + crmshp() + _(" caught in long range tractor beam--"))
2218         # If Kirk & Co. screwing around on planet, handle
2219         atover(True) # atover(true) is Grab
2220         if game.alldone:
2221             return
2222         if game.icraft: # Caught in Galileo?
2223             finish(FSTRACTOR)
2224             return
2225         # Check to see if shuttle is aboard
2226         if game.iscraft == "offship":
2227             skip(1)
2228             if withprob(0.5):
2229                 prout(_("Galileo, left on the planet surface, is captured"))
2230                 prout(_("by aliens and made into a flying McDonald's."))
2231                 game.damage[DSHUTTL] = -10
2232                 game.iscraft = "removed"
2233             else:
2234                 prout(_("Galileo, left on the planet surface, is well hidden."))
2235         if evcode == FSPY:
2236             game.quadrant = game.state.kscmdr
2237         else:
2238             game.quadrant = game.state.kcmdr[i]
2239         game.sector = randplace(QUADSIZE)
2240         prout(crmshp() + _(" is pulled to Quadrant %s, Sector %s") \
2241                % (game.quadrant, game.sector))
2242         if game.resting:
2243             prout(_("(Remainder of rest/repair period cancelled.)"))
2244             game.resting = False
2245         if not game.shldup:
2246             if not damaged(DSHIELD) and game.shield > 0:
2247                 doshield(shraise=True) # raise shields
2248                 game.shldchg = False
2249             else:
2250                 prout(_("(Shields not currently useable.)"))
2251         newqad()
2252         # Adjust finish time to time of tractor beaming?
2253         # fintim = game.state.date+game.optime
2254         attack(torps_ok=False)
2255         if not game.state.kcmdr:
2256             unschedule(FTBEAM)
2257         else:
2258             schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr)))
2259
2260     def destroybase():
2261         "Code merges here for any commander destroying a starbase."
2262         # Not perfect, but will have to do
2263         # Handle case where base is in same quadrant as starship
2264         if game.battle == game.quadrant:
2265             game.state.chart[game.battle.i][game.battle.j].starbase = False
2266             game.quad[game.base.i][game.base.j] = '.'
2267             game.base.invalidate()
2268             newcnd()
2269             skip(1)
2270             prout(_("Spock-  \"Captain, I believe the starbase has been destroyed.\""))
2271         elif game.state.baseq and communicating():
2272             # Get word via subspace radio
2273             announce()
2274             skip(1)
2275             prout(_("Lt. Uhura-  \"Captain, Starfleet Command reports that"))
2276             proutn(_("   the starbase in Quadrant %s has been destroyed by") % game.battle)
2277             if game.isatb == 2:
2278                 prout(_("the Klingon Super-Commander"))
2279             else:
2280                 prout(_("a Klingon Commander"))
2281             game.state.chart[game.battle.i][game.battle.j].starbase = False
2282         # Remove Starbase from galaxy
2283         game.state.galaxy[game.battle.i][game.battle.j].starbase = False
2284         game.state.baseq = [x for x in game.state.baseq if x != game.battle]
2285         if game.isatb == 2:
2286             # reinstate a commander's base attack
2287             game.battle = hold
2288             game.isatb = 0
2289         else:
2290             game.battle.invalidate()
2291     if game.idebug:
2292         prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
2293         for i in range(1, NEVENTS):
2294             if   i == FSNOVA:  proutn("=== Supernova       ")
2295             elif i == FTBEAM:  proutn("=== T Beam          ")
2296             elif i == FSNAP:   proutn("=== Snapshot        ")
2297             elif i == FBATTAK: proutn("=== Base Attack     ")
2298             elif i == FCDBAS:  proutn("=== Base Destroy    ")
2299             elif i == FSCMOVE: proutn("=== SC Move         ")
2300             elif i == FSCDBAS: proutn("=== SC Base Destroy ")
2301             elif i == FDSPROB: proutn("=== Probe Move      ")
2302             elif i == FDISTR:  proutn("=== Distress Call   ")
2303             elif i == FENSLV:  proutn("=== Enslavement     ")
2304             elif i == FREPRO:  proutn("=== Klingon Build   ")
2305             if is_scheduled(i):
2306                 prout("%.2f" % (scheduled(i)))
2307             else:
2308                 prout("never")
2309     radio_was_broken = damaged(DRADIO)
2310     hold.i = hold.j = 0
2311     while True:
2312         # Select earliest extraneous event, evcode==0 if no events
2313         evcode = FSPY
2314         if game.alldone:
2315             return
2316         datemin = fintim
2317         for l in range(1, NEVENTS):
2318             if game.future[l].date < datemin:
2319                 evcode = l
2320                 if game.idebug:
2321                     prout("== Event %d fires" % evcode)
2322                 datemin = game.future[l].date
2323         xtime = datemin-game.state.date
2324         if game.iscloaked:
2325             game.energy -= xtime*500.0
2326             if game.energy <= 0:
2327                 finish(FNRG)
2328                 return
2329         game.state.date = datemin
2330         # Decrement Federation resources and recompute remaining time
2331         game.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime
2332         game.recompute()
2333         if game.state.remtime <= 0:
2334             finish(FDEPLETE)
2335             return
2336         # Any crew left alive?
2337         if game.state.crew <= 0:
2338             finish(FCREW)
2339             return
2340         # Is life support adequate?
2341         if damaged(DLIFSUP) and game.condition != "docked":
2342             if game.lsupres < xtime and game.damage[DLIFSUP] > game.lsupres:
2343                 finish(FLIFESUP)
2344                 return
2345             game.lsupres -= xtime
2346             if game.damage[DLIFSUP] <= xtime:
2347                 game.lsupres = game.inlsr
2348         # Fix devices
2349         repair = xtime
2350         if game.condition == "docked":
2351             repair /= DOCKFAC
2352         # Don't fix Deathray here
2353         for l in range(NDEVICES):
2354             if game.damage[l] > 0.0 and l != DDRAY:
2355                 if game.damage[l]-repair > 0.0:
2356                     game.damage[l] -= repair
2357                 else:
2358                     game.damage[l] = 0.0
2359         # If radio repaired, update star chart and attack reports
2360         if radio_was_broken and not damaged(DRADIO):
2361             prout(_("Lt. Uhura- \"Captain, the sub-space radio is working and"))
2362             prout(_("   surveillance reports are coming in."))
2363             skip(1)
2364             if not game.iseenit:
2365                 attackreport(False)
2366                 game.iseenit = True
2367             rechart()
2368             prout(_("   The star chart is now up to date.\""))
2369             skip(1)
2370         # Cause extraneous event EVCODE to occur
2371         game.optime -= xtime
2372         if evcode == FSNOVA: # Supernova
2373             announce()
2374             supernova(None)
2375             schedule(FSNOVA, expran(0.5*game.intime))
2376             if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
2377                 return
2378         elif evcode == FSPY: # Check with spy to see if SC should tractor beam
2379             if game.state.nscrem == 0 or game.iscloaked or \
2380                 ictbeam or istract or \
2381                 game.condition == "docked" or game.isatb == 1 or game.iscate:
2382                 return
2383             if game.ientesc or \
2384                 (game.energy<2000 and game.torps<4 and game.shield < 1250) or \
2385                 (damaged(DPHASER) and (damaged(DPHOTON) or game.torps<4)) or \
2386                 (damaged(DSHIELD) and \
2387                  (game.energy < 2500 or damaged(DPHASER)) and \
2388                  (game.torps < 5 or damaged(DPHOTON))):
2389                 # Tractor-beam her!
2390                 istract = ictbeam = True
2391                 tractorbeam((game.state.kscmdr-game.quadrant).distance())
2392             else:
2393                 return
2394         elif evcode == FTBEAM: # Tractor beam
2395             if not game.state.kcmdr:
2396                 unschedule(FTBEAM)
2397                 continue
2398             i = randrange(len(game.state.kcmdr))
2399             yank = (game.state.kcmdr[i]-game.quadrant).distance()
2400             if istract or game.condition == "docked" or game.iscloaked or yank == 0:
2401                 # Drats! Have to reschedule
2402                 schedule(FTBEAM,
2403                          game.optime + expran(1.5*game.intime/len(game.state.kcmdr)))
2404                 continue
2405             ictbeam = True
2406             tractorbeam(yank)
2407         elif evcode == FSNAP: # Snapshot of the universe (for time warp)
2408             game.snapsht = copy.deepcopy(game.state)
2409             game.state.snap = True
2410             schedule(FSNAP, expran(0.5 * game.intime))
2411         elif evcode == FBATTAK: # Commander attacks starbase
2412             if not game.state.kcmdr or not game.state.baseq:
2413                 # no can do
2414                 unschedule(FBATTAK)
2415                 unschedule(FCDBAS)
2416                 continue
2417             ibq = None  # Force battle location to persist past loop
2418             try:
2419                 for ibq in game.state.baseq:
2420                     for cmdr in game.state.kcmdr:
2421                         if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
2422                             raise JumpOut
2423                 # no match found -- try later
2424                 schedule(FBATTAK, expran(0.3*game.intime))
2425                 unschedule(FCDBAS)
2426                 continue
2427             except JumpOut:
2428                 pass
2429             # commander + starbase combination found -- launch attack
2430             game.battle = ibq
2431             schedule(FCDBAS, randreal(1.0, 4.0))
2432             if game.isatb: # extra time if SC already attacking
2433                 postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date)
2434             game.future[FBATTAK].date = game.future[FCDBAS].date + expran(0.3*game.intime)
2435             game.iseenit = False
2436             if not communicating():
2437                 continue # No warning :-(
2438             game.iseenit = True
2439             announce()
2440             skip(1)
2441             prout(_("Lt. Uhura-  \"Captain, the starbase in Quadrant %s") % game.battle)
2442             prout(_("   reports that it is under attack and that it can"))
2443             prout(_("   hold out only until stardate %d.\"") % (int(scheduled(FCDBAS))))
2444             if cancelrest():
2445                 return
2446         elif evcode == FSCDBAS: # Supercommander destroys base
2447             unschedule(FSCDBAS)
2448             game.isatb = 2
2449             if not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].starbase:
2450                 continue # WAS RETURN!
2451             hold = game.battle
2452             game.battle = game.state.kscmdr
2453             destroybase()
2454         elif evcode == FCDBAS: # Commander succeeds in destroying base
2455             if evcode == FCDBAS:
2456                 unschedule(FCDBAS)
2457                 if not game.state.baseq() \
2458                        or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
2459                     game.battle.invalidate()
2460                     continue
2461                 # find the lucky pair
2462                 for cmdr in game.state.kcmdr:
2463                     if cmdr == game.battle:
2464                         break
2465                 else:
2466                     # No action to take after all
2467                     continue
2468             destroybase()
2469         elif evcode == FSCMOVE: # Supercommander moves
2470             schedule(FSCMOVE, 0.2777)
2471             if not game.ientesc and not istract and game.isatb != 1 and \
2472                    (not game.iscate or not game.justin):
2473                 supercommander()
2474         elif evcode == FDSPROB: # Move deep space probe
2475             schedule(FDSPROB, 0.01)
2476             if not game.probe.nexttok():
2477                 if not game.probe.quadrant().valid_quadrant() or \
2478                     game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova:
2479                     # Left galaxy or ran into supernova
2480                     if communicating():
2481                         announce()
2482                         skip(1)
2483                         proutn(_("Lt. Uhura-  \"The deep space probe "))
2484                         if not game.probe.quadrant().valid_quadrant():
2485                             prout(_("has left the galaxy.\""))
2486                         else:
2487                             prout(_("is no longer transmitting.\""))
2488                     unschedule(FDSPROB)
2489                     continue
2490                 if communicating():
2491                     #announce()
2492                     skip(1)
2493                     prout(_("Lt. Uhura-  \"The deep space probe is now in Quadrant %s.\"") % game.probe.quadrant())
2494             pquad = game.probe.quadrant()
2495             pdest = game.state.galaxy[pquad.i][pquad.j]
2496             if communicating():
2497                 game.state.chart[pquad.i][pquad.j].klingons = pdest.klingons
2498                 game.state.chart[pquad.i][pquad.j].starbase = pdest.starbase
2499                 game.state.chart[pquad.i][pquad.j].stars = pdest.stars
2500                 pdest.charted = True
2501             game.probe.moves -= 1 # One less to travel
2502             if game.probe.arrived() and game.isarmed and pdest.stars:
2503                 supernova(game.probe)                # fire in the hole!
2504                 unschedule(FDSPROB)
2505                 if game.state.galaxy[pquad.i][pquad.j].supernova:
2506                     return
2507         elif evcode == FDISTR: # inhabited system issues distress call
2508             unschedule(FDISTR)
2509             # try a whole bunch of times to find something suitable
2510             for i in range(100):
2511                 # need a quadrant which is not the current one,
2512                 # which has some stars which are inhabited and
2513                 # not already under attack, which is not
2514                 # supernova'ed, and which has some Klingons in it
2515                 w = randplace(GALSIZE)
2516                 q = game.state.galaxy[w.i][w.j]
2517                 if not (game.quadrant == w or q.planet is None or \
2518                       not q.planet.inhabited or \
2519                       q.supernova or q.status!="secure" or q.klingons<=0):
2520                     break
2521             else:
2522                 # can't seem to find one; ignore this call
2523                 if game.idebug:
2524                     prout("=== Couldn't find location for distress event.")
2525                 continue
2526             # got one!!  Schedule its enslavement
2527             ev = schedule(FENSLV, expran(game.intime))
2528             ev.quadrant = w
2529             q.status = "distressed"
2530             # tell the captain about it if we can
2531             if communicating():
2532                 prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \
2533                         % (q.planet, repr(w)))
2534                 prout(_("by a Klingon invasion fleet."))
2535                 if cancelrest():
2536                     return
2537         elif evcode == FENSLV:                # starsystem is enslaved
2538             ev = unschedule(FENSLV)
2539             # see if current distress call still active
2540             q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
2541             if q.klingons <= 0:
2542                 q.status = "secure"
2543                 continue
2544             q.status = "enslaved"
2545
2546             # play stork and schedule the first baby
2547             ev2 = schedule(FREPRO, expran(2.0 * game.intime))
2548             ev2.quadrant = ev.quadrant
2549
2550             # report the disaster if we can
2551             if communicating():
2552                 prout(_("Uhura- We've lost contact with starsystem %s") % \
2553                         q.planet)
2554                 prout(_("in Quadrant %s.\n") % ev.quadrant)
2555         elif evcode == FREPRO:                # Klingon reproduces
2556             # If we ever switch to a real event queue, we'll need to
2557             # explicitly retrieve and restore the x and y.
2558             ev = schedule(FREPRO, expran(1.0 * game.intime))
2559             # see if current distress call still active
2560             q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j]
2561             if q.klingons <= 0:
2562                 q.status = "secure"
2563                 continue
2564             if game.state.remkl >= MAXKLGAME:
2565                 continue                # full right now
2566             # reproduce one Klingon
2567             w = ev.quadrant
2568             m = Coord()
2569             if game.klhere >= MAXKLQUAD:
2570                 try:
2571                     # this quadrant not ok, pick an adjacent one
2572                     for m.i in range(w.i - 1, w.i + 2):
2573                         for m.j in range(w.j - 1, w.j + 2):
2574                             if not m.valid_quadrant():
2575                                 continue
2576                             q = game.state.galaxy[m.i][m.j]
2577                             # check for this quad ok (not full & no snova)
2578                             if q.klingons >= MAXKLQUAD or q.supernova:
2579                                 continue
2580                             raise JumpOut
2581                     # search for eligible quadrant failed
2582                     continue
2583                 except JumpOut:
2584                     w = m
2585             # deliver the child
2586             game.state.remkl += 1
2587             q.klingons += 1
2588             if game.quadrant == w:
2589                 game.klhere += 1
2590                 game.enemies.append(newkling())
2591             # recompute time left
2592             game.recompute()
2593             if communicating():
2594                 if game.quadrant == w:
2595                     prout(_("Spock- sensors indicate the Klingons have"))
2596                     prout(_("launched a warship from %s.") % q.planet)
2597                 else:
2598                     prout(_("Uhura- Starfleet reports increased Klingon activity"))
2599                     if q.planet != None:
2600                         proutn(_("near %s ") % q.planet)
2601                     prout(_("in Quadrant %s.") % w)
2602
2603 def wait():
2604     "Wait on events."
2605     game.ididit = False
2606     while True:
2607         key = scanner.nexttok()
2608         if key  != "IHEOL":
2609             break
2610         proutn(_("How long? "))
2611     scanner.chew()
2612     if key != "IHREAL":
2613         huh()
2614         return
2615     origTime = delay = scanner.real
2616     if delay <= 0.0:
2617         return
2618     if delay >= game.state.remtime or len(game.enemies) != 0:
2619         proutn(_("Are you sure? "))
2620         if not ja():
2621             return
2622     # Alternate resting periods (events) with attacks
2623     game.resting = True
2624     while True:
2625         if delay <= 0:
2626             game.resting = False
2627         if not game.resting:
2628             prout(_("%d stardates left.") % int(game.state.remtime))
2629             return
2630         temp = game.optime = delay
2631         if len(game.enemies):
2632             rtime = randreal(1.0, 2.0)
2633             if rtime < temp:
2634                 temp = rtime
2635             game.optime = temp
2636         if game.optime < delay:
2637             attack(torps_ok=False)
2638         if game.alldone:
2639             return
2640         events()
2641         game.ididit = True
2642         if game.alldone:
2643             return
2644         delay -= temp
2645         # Repair Deathray if long rest at starbase
2646         if origTime-delay >= 9.99 and game.condition == "docked":
2647             game.damage[DDRAY] = 0.0
2648         # leave if quadrant supernovas
2649         if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
2650             break
2651     game.resting = False
2652     game.optime = 0.0
2653
2654 def nova(nov):
2655     "Star goes nova."
2656     ncourse = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
2657     newc = Coord(); neighbor = Coord(); bump = Coord(0, 0)
2658     if withprob(0.05):
2659         # Wow! We've supernova'ed
2660         supernova(game.quadrant)
2661         return
2662     # handle initial nova
2663     game.quad[nov.i][nov.j] = '.'
2664     prout(crmena(False, '*', "sector", nov) + _(" novas."))
2665     game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
2666     game.state.starkl += 1
2667     # Set up queue to recursively trigger adjacent stars
2668     hits = [nov]
2669     kount = 0
2670     while hits:
2671         offset = Coord()
2672         start = hits.pop()
2673         for offset.i in range(-1, 1+1):
2674             for offset.j in range(-1, 1+1):
2675                 if offset.j == 0 and offset.i == 0:
2676                     continue
2677                 neighbor = start + offset
2678                 if not neighbor.valid_sector():
2679                     continue
2680                 iquad = game.quad[neighbor.i][neighbor.j]
2681                 # Empty space ends reaction
2682                 if iquad in ('.', '?', ' ', 'T', '#'):
2683                     pass
2684                 elif iquad == '*': # Affect another star
2685                     if withprob(0.05):
2686                         # This star supernovas
2687                         supernova(game.quadrant)
2688                         return
2689                     else:
2690                         hits.append(neighbor)
2691                         game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
2692                         game.state.starkl += 1
2693                         proutn(crmena(True, '*', "sector", neighbor))
2694                         prout(_(" novas."))
2695                         game.quad[neighbor.i][neighbor.j] = '.'
2696                         kount += 1
2697                 elif iquad in ('P', '@'): # Destroy planet
2698                     game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
2699                     if iquad == 'P':
2700                         game.state.nplankl += 1
2701                     else:
2702                         game.state.nworldkl += 1
2703                     prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
2704                     game.iplnet.pclass = "destroyed"
2705                     game.iplnet = None
2706                     game.plnet.invalidate()
2707                     if game.landed:
2708                         finish(FPNOVA)
2709                         return
2710                     game.quad[neighbor.i][neighbor.j] = '.'
2711                 elif iquad == 'B': # Destroy base
2712                     game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase = False
2713                     game.state.baseq = [x for x in game.state.baseq if x!= game.quadrant]
2714                     game.base.invalidate()
2715                     game.state.basekl += 1
2716                     newcnd()
2717                     prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
2718                     game.quad[neighbor.i][neighbor.j] = '.'
2719                 elif iquad in ('E', 'F'): # Buffet ship
2720                     prout(_("***Starship buffeted by nova."))
2721                     if game.shldup:
2722                         if game.shield >= 2000.0:
2723                             game.shield -= 2000.0
2724                         else:
2725                             diff = 2000.0 - game.shield
2726                             game.energy -= diff
2727                             game.shield = 0.0
2728                             game.shldup = False
2729                             prout(_("***Shields knocked out."))
2730                             game.damage[DSHIELD] += 0.005*game.damfac*randreal()*diff
2731                     else:
2732                         game.energy -= 2000.0
2733                     if game.energy <= 0:
2734                         finish(FNOVA)
2735                         return
2736                     # add in course nova contributes to kicking starship
2737                     bump += (game.sector-hits[-1]).sgn()
2738                 elif iquad == 'K': # kill klingon
2739                     deadkl(neighbor, iquad, neighbor)
2740                 elif iquad in ('C','S','R'): # Damage/destroy big enemies
2741                     target = None
2742                     for ll in range(len(game.enemies)):
2743                         if game.enemies[ll].location == neighbor:
2744                             target = game.enemies[ll]
2745                             break
2746                     if target is not None:
2747                         target.power -= 800.0 # If firepower is lost, die
2748                         if target.power <= 0.0:
2749                             deadkl(neighbor, iquad, neighbor)
2750                             continue    # neighbor loop
2751                         # Else enemy gets flung by the blast wave
2752                         newc = neighbor + neighbor - hits[-1]
2753                         proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
2754                         if not newc.valid_sector():
2755                             # can't leave quadrant
2756                             skip(1)
2757                             continue
2758                         iquad1 = game.quad[newc.i][newc.j]
2759                         if iquad1 == ' ':
2760                             proutn(_(", blasted into ") + crmena(False, ' ', "sector", newc))
2761                             skip(1)
2762                             deadkl(neighbor, iquad, newc)
2763                             continue
2764                         if iquad1 != '.':
2765                             # can't move into something else
2766                             skip(1)
2767                             continue
2768                         proutn(_(", buffeted to Sector %s") % newc)
2769                         game.quad[neighbor.i][neighbor.j] = '.'
2770                         game.quad[newc.i][newc.j] = iquad
2771                         target.move(newc)
2772     # Starship affected by nova -- kick it away.
2773     dist = kount*0.1
2774     direc = ncourse[3*(bump.i+1)+bump.j+2]
2775     if direc == 0.0:
2776         dist = 0.0
2777     if dist == 0.0:
2778         return
2779     scourse = course(bearing=direc, distance=dist)
2780     game.optime = scourse.time(w=4)
2781     skip(1)
2782     prout(_("Force of nova displaces starship."))
2783     imove(scourse, noattack=True)
2784     game.optime = scourse.time(w=4)
2785     return
2786
2787 def supernova(w):
2788     "Star goes supernova."
2789     num = 0; npdead = 0
2790     if w != None:
2791         nq = copy.copy(w)
2792     else:
2793         # Scheduled supernova -- select star at random.
2794         nstars = 0
2795         nq = Coord()
2796         for nq.i in range(GALSIZE):
2797             for nq.j in range(GALSIZE):
2798                 nstars += game.state.galaxy[nq.i][nq.j].stars
2799         if stars == 0:
2800             return # nothing to supernova exists
2801         num = randrange(nstars) + 1
2802         for nq.i in range(GALSIZE):
2803             for nq.j in range(GALSIZE):
2804                 num -= game.state.galaxy[nq.i][nq.j].stars
2805                 if num <= 0:
2806                     break
2807             if num <=0:
2808                 break
2809         if game.idebug:
2810             proutn("=== Super nova here?")
2811             if ja():
2812                 nq = game.quadrant
2813     if not nq == game.quadrant or game.justin:
2814         # it isn't here, or we just entered (treat as enroute)
2815         if communicating():
2816             skip(1)
2817             prout(_("Message from Starfleet Command       Stardate %.2f") % game.state.date)
2818             prout(_("     Supernova in Quadrant %s; caution advised.") % nq)
2819     else:
2820         ns = Coord()
2821         # we are in the quadrant!
2822         num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
2823         for ns.i in range(QUADSIZE):
2824             for ns.j in range(QUADSIZE):
2825                 if game.quad[ns.i][ns.j]=='*':
2826                     num -= 1
2827                     if num==0:
2828                         break
2829             if num==0:
2830                 break
2831         skip(1)
2832         prouts(_("***RED ALERT!  RED ALERT!"))
2833         skip(1)
2834         prout(_("***Incipient supernova detected at Sector %s") % ns)
2835         if (ns.i-game.sector.i)**2 + (ns.j-game.sector.j)**2 <= 2.1:
2836             proutn(_("Emergency override attempts t"))
2837             prouts("***************")
2838             skip(1)
2839             stars()
2840             game.alldone = True
2841     # destroy any Klingons in supernovaed quadrant
2842     kldead = game.state.galaxy[nq.i][nq.j].klingons
2843     game.state.galaxy[nq.i][nq.j].klingons = 0
2844     if nq == game.state.kscmdr:
2845         # did in the Supercommander!
2846         game.state.nscrem = game.state.kscmdr.i = game.state.kscmdr.j = game.isatb =  0
2847         game.iscate = False
2848         unschedule(FSCMOVE)
2849         unschedule(FSCDBAS)
2850     survivors = filter(lambda w: w != nq, game.state.kcmdr)
2851     comkills = len(game.state.kcmdr) - len(survivors)
2852     game.state.kcmdr = survivors
2853     kldead -= comkills
2854     if not game.state.kcmdr:
2855         unschedule(FTBEAM)
2856     game.state.remkl -= kldead
2857     # destroy Romulans and planets in supernovaed quadrant
2858     nrmdead = game.state.galaxy[nq.i][nq.j].romulans
2859     game.state.galaxy[nq.i][nq.j].romulans = 0
2860     game.state.nromrem -= nrmdead
2861     # Destroy planets
2862     for loop in range(game.inplan):
2863         if game.state.planets[loop].quadrant == nq:
2864             game.state.planets[loop].pclass = "destroyed"
2865             npdead += 1
2866     # Destroy any base in supernovaed quadrant
2867     game.state.baseq = [x for x in game.state.baseq if x != nq]
2868     # If starship caused supernova, tally up destruction
2869     if w != None:
2870         game.state.starkl += game.state.galaxy[nq.i][nq.j].stars
2871         game.state.basekl += game.state.galaxy[nq.i][nq.j].starbase
2872         game.state.nplankl += npdead
2873     # mark supernova in galaxy and in star chart
2874     if game.quadrant == nq or communicating():
2875         game.state.galaxy[nq.i][nq.j].supernova = True
2876     # If supernova destroys last Klingons give special message
2877     if game.unwon()==0 and not nq == game.quadrant:
2878         skip(2)
2879         if w is None:
2880             prout(_("Lucky you!"))
2881         proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq)
2882         finish(FWON)
2883         return
2884     # if some Klingons remain, continue or die in supernova
2885     if game.alldone:
2886         finish(FSNOVAED)
2887     return
2888
2889 # Code from finish.c ends here.
2890
2891 def selfdestruct():
2892     "Self-destruct maneuver. Finish with a BANG!"
2893     scanner.chew()
2894     if damaged(DCOMPTR):
2895         prout(_("Computer damaged; cannot execute destruct sequence."))
2896         return
2897     prouts(_("---WORKING---")); skip(1)
2898     prouts(_("SELF-DESTRUCT-SEQUENCE-ACTIVATED")); skip(1)
2899     prouts("   10"); skip(1)
2900     prouts("       9"); skip(1)
2901     prouts("          8"); skip(1)
2902     prouts("             7"); skip(1)
2903     prouts("                6"); skip(1)
2904     skip(1)
2905     prout(_("ENTER-CORRECT-PASSWORD-TO-CONTINUE-"))
2906     skip(1)
2907     prout(_("SELF-DESTRUCT-SEQUENCE-OTHERWISE-"))
2908     skip(1)
2909     prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED"))
2910     skip(1)
2911     scanner.nexttok()
2912     if game.passwd != scanner.token:
2913         prouts(_("PASSWORD-REJECTED;"))
2914         skip(1)
2915         prouts(_("CONTINUITY-EFFECTED"))
2916         skip(2)
2917         return
2918     prouts(_("PASSWORD-ACCEPTED")); skip(1)
2919     prouts("                   5"); skip(1)
2920     prouts("                      4"); skip(1)
2921     prouts("                         3"); skip(1)
2922     prouts("                            2"); skip(1)
2923     prouts("                              1"); skip(1)
2924     if withprob(0.15):
2925         prouts(_("GOODBYE-CRUEL-WORLD"))
2926         skip(1)
2927     kaboom()
2928
2929 def kaboom():
2930     stars()
2931     if game.ship=='E':
2932         prouts("***")
2933     prouts(_("********* Entropy of %s maximized *********") % crmshp())
2934     skip(1)
2935     stars()
2936     skip(1)
2937     if len(game.enemies) != 0:
2938         whammo = 25.0 * game.energy
2939         for l in range(len(game.enemies)):
2940             if game.enemies[l].power*game.enemies[l].kdist <= whammo:
2941                 deadkl(game.enemies[l].location, game.quad[game.enemies[l].location.i][game.enemies[l].location.j], game.enemies[l].location)
2942     finish(FDILITHIUM)
2943
2944 def killrate():
2945     "Compute our rate of kils over time."
2946     elapsed = game.state.date - game.indate
2947     if elapsed == 0:        # Avoid divide-by-zero error if calculated on turn 0
2948         return 0
2949     else:
2950         starting = (game.inkling + game.incom + game.inscom)
2951         remaining = game.unwon()
2952         return (starting - remaining)/elapsed
2953
2954 def badpoints():
2955     "Compute demerits."
2956     badpt = 5.0*game.state.starkl + \
2957             game.casual + \
2958             10.0*game.state.nplankl + \
2959             300*game.state.nworldkl + \
2960             45.0*game.nhelp +\
2961             100.0*game.state.basekl +\
2962             3.0*game.abandoned +\
2963             100*game.ncviol
2964     if game.ship == 'F':
2965         badpt += 100.0
2966     elif game.ship is None:
2967         badpt += 200.0
2968     return badpt
2969
2970 def finish(ifin):
2971     # end the game, with appropriate notifications
2972     igotit = False
2973     game.alldone = True
2974     skip(3)
2975     prout(_("It is stardate %.1f.") % game.state.date)
2976     skip(1)
2977     if ifin == FWON: # Game has been won
2978         if game.state.nromrem != 0:
2979             prout(_("The remaining %d Romulans surrender to Starfleet Command.") %
2980                   game.state.nromrem)
2981
2982         prout(_("You have smashed the Klingon invasion fleet and saved"))
2983         prout(_("the Federation."))
2984         if game.alive and game.brigcapacity-game.brigfree > 0:
2985             game.kcaptured += game.brigcapacity-game.brigfree
2986             prout(_("The %d captured Klingons are transferred to Star Fleet Command.") % (game.brigcapacity-game.brigfree))
2987         game.gamewon = True
2988         if game.alive:
2989             badpt = badpoints()
2990             if badpt < 100.0:
2991                 badpt = 0.0        # Close enough!
2992             # killsPerDate >= RateMax
2993             if game.state.date-game.indate < 5.0 or \
2994                 killrate() >= 0.1*game.skill*(game.skill+1.0) + 0.1 + 0.008*badpt:
2995                 skip(1)
2996                 prout(_("In fact, you have done so well that Starfleet Command"))
2997                 if game.skill == SKILL_NOVICE:
2998                     prout(_("promotes you one step in rank from \"Novice\" to \"Fair\"."))
2999                 elif game.skill == SKILL_FAIR:
3000                     prout(_("promotes you one step in rank from \"Fair\" to \"Good\"."))
3001                 elif game.skill == SKILL_GOOD:
3002                     prout(_("promotes you one step in rank from \"Good\" to \"Expert\"."))
3003                 elif game.skill == SKILL_EXPERT:
3004                     prout(_("promotes you to Commodore Emeritus."))
3005                     skip(1)
3006                     prout(_("Now that you think you're really good, try playing"))
3007                     prout(_("the \"Emeritus\" game. It will splatter your ego."))
3008                 elif game.skill == SKILL_EMERITUS:
3009                     skip(1)
3010                     proutn(_("Computer-  "))
3011                     prouts(_("ERROR-ERROR-ERROR-ERROR"))
3012                     skip(2)
3013                     prouts(_("  YOUR-SKILL-HAS-EXCEEDED-THE-CAPACITY-OF-THIS-PROGRAM"))
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-SURVIVE"))
3020                     skip(1)
3021                     prouts(_("  THIS-PROGRAM-MUST?- MUST ? - SUR? ? -?  VI"))
3022                     skip(2)
3023                     prout(_("Now you can retire and write your own Star Trek game!"))
3024                     skip(1)
3025                 elif game.skill >= SKILL_EXPERT:
3026                     if game.thawed and not game.idebug:
3027                         prout(_("You cannot get a citation, so..."))
3028                     else:
3029                         proutn(_("Do you want your Commodore Emeritus Citation printed? "))
3030                         scanner.chew()
3031                         if ja():
3032                             igotit = True
3033             # Only grant long life if alive (original didn't!)
3034             skip(1)
3035             prout(_("LIVE LONG AND PROSPER."))
3036         score()
3037         if igotit:
3038             plaque()
3039         return
3040     elif ifin == FDEPLETE: # Federation Resources Depleted
3041         prout(_("Your time has run out and the Federation has been"))
3042         prout(_("conquered.  Your starship is now Klingon property,"))
3043         prout(_("and you are put on trial as a war criminal.  On the"))
3044         proutn(_("basis of your record, you are "))
3045         if game.unwon()*3.0 > (game.inkling + game.incom + game.inscom):
3046             prout(_("acquitted."))
3047             skip(1)
3048             prout(_("LIVE LONG AND PROSPER."))
3049         else:
3050             prout(_("found guilty and"))
3051             prout(_("sentenced to death by slow torture."))
3052             game.alive = False
3053         score()
3054         return
3055     elif ifin == FLIFESUP:
3056         prout(_("Your life support reserves have run out, and"))
3057         prout(_("you die of thirst, starvation, and asphyxiation."))
3058         prout(_("Your starship is a derelict in space."))
3059     elif ifin == FNRG:
3060         prout(_("Your energy supply is exhausted."))
3061         skip(1)
3062         prout(_("Your starship is a derelict in space."))
3063     elif ifin == FBATTLE:
3064         prout(_("The %s has been destroyed in battle.") % crmshp())
3065         skip(1)
3066         prout(_("Dulce et decorum est pro patria mori."))
3067     elif ifin == FNEG3:
3068         prout(_("You have made three attempts to cross the negative energy"))
3069         prout(_("barrier which surrounds the galaxy."))
3070         skip(1)
3071         prout(_("Your navigation is abominable."))
3072         score()
3073     elif ifin == FNOVA:
3074         prout(_("Your starship has been destroyed by a nova."))
3075         prout(_("That was a great shot."))
3076         skip(1)
3077     elif ifin == FSNOVAED:
3078         prout(_("The %s has been fried by a supernova.") % crmshp())
3079         prout(_("...Not even cinders remain..."))
3080     elif ifin == FABANDN:
3081         prout(_("You have been captured by the Klingons. If you still"))
3082         prout(_("had a starbase to be returned to, you would have been"))
3083         prout(_("repatriated and given another chance. Since you have"))
3084         prout(_("no starbases, you will be mercilessly tortured to death."))
3085     elif ifin == FDILITHIUM:
3086         prout(_("Your starship is now an expanding cloud of subatomic particles"))
3087     elif ifin == FMATERIALIZE:
3088         prout(_("Starbase was unable to re-materialize your starship."))
3089         prout(_("Sic transit gloria mundi"))
3090     elif ifin == FPHASER:
3091         prout(_("The %s has been cremated by its own phasers.") % crmshp())
3092     elif ifin == FLOST:
3093         prout(_("You and your landing party have been"))
3094         prout(_("converted to energy, dissipating through space."))
3095     elif ifin == FMINING:
3096         prout(_("You are left with your landing party on"))
3097         prout(_("a wild jungle planet inhabited by primitive cannibals."))
3098         skip(1)
3099         prout(_("They are very fond of \"Captain Kirk\" soup."))
3100         skip(1)
3101         prout(_("Without your leadership, the %s is destroyed.") % crmshp())
3102     elif ifin == FDPLANET:
3103         prout(_("You and your mining party perish."))
3104         skip(1)
3105         prout(_("That was a great shot."))
3106         skip(1)
3107     elif ifin == FSSC:
3108         prout(_("The Galileo is instantly annihilated by the supernova."))
3109         prout(_("You and your mining party are atomized."))
3110         skip(1)
3111         prout(_("Mr. Spock takes command of the %s and") % crmshp())
3112         prout(_("joins the Romulans, wreaking terror on the Federation."))
3113     elif ifin == FPNOVA:
3114         prout(_("You and your mining party are atomized."))
3115         skip(1)
3116         prout(_("Mr. Spock takes command of the %s and") % crmshp())
3117         prout(_("joins the Romulans, wreaking terror on the Federation."))
3118     elif ifin == FSTRACTOR:
3119         prout(_("The shuttle craft Galileo is also caught,"))
3120         prout(_("and breaks up under the strain."))
3121         skip(1)
3122         prout(_("Your debris is scattered for millions of miles."))
3123         prout(_("Without your leadership, the %s is destroyed.") % crmshp())
3124     elif ifin == FDRAY:
3125         prout(_("The mutants attack and kill Spock."))
3126         prout(_("Your ship is captured by Klingons, and"))
3127         prout(_("your crew is put on display in a Klingon zoo."))
3128     elif ifin == FTRIBBLE:
3129         prout(_("Tribbles consume all remaining water,"))
3130         prout(_("food, and oxygen on your ship."))
3131         skip(1)
3132         prout(_("You die of thirst, starvation, and asphyxiation."))
3133         prout(_("Your starship is a derelict in space."))
3134     elif ifin == FHOLE:
3135         prout(_("Your ship is drawn to the center of the black hole."))
3136         prout(_("You are crushed into extremely dense matter."))
3137     elif ifin == FCLOAK:
3138         game.ncviol += 1
3139         prout(_("You have violated the Treaty of Algeron."))
3140         prout(_("The Romulan Empire can never trust you again."))
3141     elif ifin == FCREW:
3142         prout(_("Your last crew member has died."))
3143     if ifin != FWON and ifin != FCLOAK and game.iscloaked:
3144         prout(_("Your ship was cloaked so your subspace radio did not receive anything."))
3145         prout(_("You may have missed some warning messages."))
3146         skip(1)
3147     if game.ship == 'F':
3148         game.ship = None
3149     elif game.ship == 'E':
3150         game.ship = 'F'
3151     game.alive = False
3152     if game.unwon() != 0:
3153         goodies = game.state.remres/game.inresor
3154         baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom)
3155         if goodies/baddies >= randreal(1.0, 1.5):
3156             prout(_("As a result of your actions, a treaty with the Klingon"))
3157             prout(_("Empire has been signed. The terms of the treaty are"))
3158             if goodies/baddies >= randreal(3.0):
3159                 prout(_("favorable to the Federation."))
3160                 skip(1)
3161                 prout(_("Congratulations!"))
3162             else:
3163                 prout(_("highly unfavorable to the Federation."))
3164         else:
3165             prout(_("The Federation will be destroyed."))
3166     else:
3167         prout(_("Since you took the last Klingon with you, you are a"))
3168         prout(_("martyr and a hero. Someday maybe they'll erect a"))
3169         prout(_("statue in your memory. Rest in peace, and try not"))
3170         prout(_("to think about pigeons."))
3171         game.gamewon = True
3172     score()
3173     scanner.chew()      # Clean up leftovers
3174
3175 def score():
3176     "Compute player's score."
3177     timused = game.state.date - game.indate
3178     if (timused == 0 or game.unwon() != 0) and timused < 5.0:
3179         timused = 5.0
3180     game.perdate = killrate()
3181     ithperd = 500*game.perdate + 0.5
3182     iwon = 0
3183     if game.gamewon:
3184         iwon = 100*game.skill
3185     if game.ship == 'E':
3186         klship = 0
3187     elif game.ship == 'F':
3188         klship = 1
3189     else:
3190         klship = 2
3191     game.score = 10*(game.inkling - game.state.remkl) \
3192              + 50*(game.incom - len(game.state.kcmdr)) \
3193              + ithperd + iwon \
3194              + 20*(game.inrom - game.state.nromrem) \
3195              + 200*(game.inscom - game.state.nscrem) \
3196                  - game.state.nromrem \
3197              + 3 * game.kcaptured \
3198              - badpoints()
3199     if not game.alive:
3200         game.score -= 200
3201     skip(2)
3202     prout(_("Your score --"))
3203     if game.inrom - game.state.nromrem:
3204         prout(_("%6d Romulans destroyed                 %5d") %
3205               (game.inrom - game.state.nromrem, 20*(game.inrom - game.state.nromrem)))
3206     if game.state.nromrem and game.gamewon:
3207         prout(_("%6d Romulans captured                  %5d") %
3208               (game.state.nromrem, game.state.nromrem))
3209     if game.inkling - game.state.remkl:
3210         prout(_("%6d ordinary Klingons destroyed        %5d") %
3211               (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl)))
3212     if game.incom - len(game.state.kcmdr):
3213         prout(_("%6d Klingon commanders destroyed       %5d") %
3214               (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr))))
3215     if game.kcaptured:
3216         prout(_("%d Klingons captured                   %5d") %
3217               (game.kcaptured, 3 * game.kcaptured))
3218     if game.inscom - game.state.nscrem:
3219         prout(_("%6d Super-Commander destroyed          %5d") %
3220               (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
3221     if ithperd:
3222         prout(_("%6.2f Klingons per stardate              %5d") %
3223               (game.perdate, ithperd))
3224     if game.state.starkl:
3225         prout(_("%6d stars destroyed by your action     %5d") %
3226               (game.state.starkl, -5*game.state.starkl))
3227     if game.state.nplankl:
3228         prout(_("%6d planets destroyed by your action   %5d") %
3229               (game.state.nplankl, -10*game.state.nplankl))
3230     if (game.options & OPTION_WORLDS) and game.state.nworldkl:
3231         prout(_("%6d inhabited planets destroyed by your action   %5d") %
3232               (game.state.nworldkl, -300*game.state.nworldkl))
3233     if game.state.basekl:
3234         prout(_("%6d bases destroyed by your action     %5d") %
3235               (game.state.basekl, -100*game.state.basekl))
3236     if game.nhelp:
3237         prout(_("%6d calls for help from starbase       %5d") %
3238               (game.nhelp, -45*game.nhelp))
3239     if game.casual:
3240         prout(_("%6d casualties incurred                %5d") %
3241               (game.casual, -game.casual))
3242     if game.abandoned:
3243         prout(_("%6d crew abandoned in space            %5d") %
3244               (game.abandoned, -3*game.abandoned))
3245     if klship:
3246         prout(_("%6d ship(s) lost or destroyed          %5d") %
3247               (klship, -100*klship))
3248     if game.ncviol > 0:
3249         if ncviol == 1:
3250             prout(_("1 Treaty of Algeron violation          -100"))
3251         else:
3252             prout(_("%6d Treaty of Algeron violations       %5d\n") %
3253                   (ncviol, -100*ncviol))
3254     if not game.alive:
3255         prout(_("Penalty for getting yourself killed        -200"))
3256     if game.gamewon:
3257         proutn(_("Bonus for winning "))
3258         if game.skill   == SKILL_NOVICE:        proutn(_("Novice game  "))
3259         elif game.skill == SKILL_FAIR:          proutn(_("Fair game    "))
3260         elif game.skill ==  SKILL_GOOD:         proutn(_("Good game    "))
3261         elif game.skill ==  SKILL_EXPERT:        proutn(_("Expert game  "))
3262         elif game.skill ==  SKILL_EMERITUS:        proutn(_("Emeritus game"))
3263         prout("           %5d" % iwon)
3264     skip(1)
3265     prout(_("TOTAL SCORE                               %5d") % game.score)
3266
3267 def plaque():
3268     "Emit winner's commemmorative plaque."
3269     skip(2)
3270     while True:
3271         proutn(_("File or device name for your plaque: "))
3272         winner = cgetline()
3273         try:
3274             fp = open(winner, "w")
3275             break
3276         except IOError:
3277             prout(_("Invalid name."))
3278
3279     proutn(_("Enter name to go on plaque (up to 30 characters): "))
3280     winner = cgetline()
3281     # The 38 below must be 64 for 132-column paper
3282     nskip = 38 - len(winner)/2
3283     fp.write("\n\n\n\n")
3284     # --------DRAW ENTERPRISE PICTURE.
3285     fp.write("                                       EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n" )
3286     fp.write("                                      EEE                      E  : :                                         :  E\n" )
3287     fp.write("                                    EE   EEE                   E  : :                   NCC-1701              :  E\n")
3288     fp.write("EEEEEEEEEEEEEEEE        EEEEEEEEEEEEEEE  : :                              : E\n")
3289     fp.write(" E                                     EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n")
3290     fp.write("                      EEEEEEEEE               EEEEEEEEEEEEE                 E  E\n")
3291     fp.write("                               EEEEEEE   EEEEE    E          E              E  E\n")
3292     fp.write("                                      EEE           E          E            E  E\n")
3293     fp.write("                                                       E         E          E  E\n")
3294     fp.write("                                                         EEEEEEEEEEEEE      E  E\n")
3295     fp.write("                                                      EEE :           EEEEEEE  EEEEEEEE\n")
3296     fp.write("                                                    :E    :                 EEEE       E\n")
3297     fp.write("                                                   .-E   -:-----                       E\n")
3298     fp.write("                                                    :E    :                            E\n")
3299     fp.write("                                                      EE  :                    EEEEEEEE\n")
3300     fp.write("                                                       EEEEEEEEEEEEEEEEEEEEEEE\n")
3301     fp.write("\n\n\n")
3302     fp.write(_("                                                       U. S. S. ENTERPRISE\n"))
3303     fp.write("\n\n\n\n")
3304     fp.write(_("                                  For demonstrating outstanding ability as a starship captain\n"))
3305     fp.write("\n")
3306     fp.write(_("                                                Starfleet Command bestows to you\n"))
3307     fp.write("\n")
3308     fp.write("%*s%s\n\n" % (nskip, "", winner))
3309     fp.write(_("                                                           the rank of\n\n"))
3310     fp.write(_("