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