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