X-Git-Url: https://jxself.org/git/?p=super-star-trek.git;a=blobdiff_plain;f=src%2Fsst.py;h=a032cb7499fc9543ad0bcf6d93fc5cca6ed467b2;hp=c921a496098863855457b206a89607e40b35db9f;hb=76b6127e9fc107e3eb757b1f6764b9f4c960e066;hpb=933f68f408ae6ff5c04f55d41d43655d6f4fcdb6 diff --git a/src/sst.py b/src/sst.py index c921a49..a032cb7 100644 --- a/src/sst.py +++ b/src/sst.py @@ -1,8 +1,12 @@ """ sst.py =-- Super Star Trek in Python +This code is a Python translation of a C translation of a FORTRAN original. +The FORTRANness still shows in many ways, notably the use of 1-origin index +an a lot of parallel arrays where a more modern language would use structures +or objects. """ -import os, sys, math, curses +import os, sys, math, curses, time, atexit, readline SSTDOC = "/usr/share/doc/sst/sst.doc" @@ -30,6 +34,26 @@ def distance(c1, c2): return math.sqrt(square(c1.x - c2.x) + square(c1.y - c2.y) def invalidate(w): w.x = w.y = 0 def is_valid(w): return (w.x != 0 and w.y != 0) +# How to represent features +IHR = 'R', +IHK = 'K', +IHC = 'C', +IHS = 'S', +IHSTAR = '*', +IHP = 'P', +IHW = '@', +IHB = 'B', +IHBLANK = ' ', +IHDOT = '.', +IHQUEST = '?', +IHE = 'E', +IHF = 'F', +IHT = 'T', +IHWEB = '#', +IHMATER0 = '-', +IHMATER1 = 'o', +IHMATER2 = '0' + class coord: def __init(self, x=None, y=None): self.x = x @@ -60,26 +84,8 @@ class planet: self.pclass = None # could be ""M", "N", "O", or "destroyed" self.crystals = None # could be "mined", "present", "absent" self.known = None # could be "unknown", "known", "shuttle_down" - -# How to represent features -IHR = 'R', -IHK = 'K', -IHC = 'C', -IHS = 'S', -IHSTAR = '*', -IHP = 'P', -IHW = '@', -IHB = 'B', -IHBLANK = ' ', -IHDOT = '.', -IHQUEST = '?', -IHE = 'E', -IHF = 'F', -IHT = 'T', -IHWEB = '#', -IHMATER0 = '-', -IHMATER1 = 'o', -IHMATER2 = '0' + def __str__(self): + return self.name NOPLANET = None class quadrant: @@ -178,6 +184,13 @@ DDRAY = 14 DDSP = 15 NDEVICES= 16 # Number of devices +SKILL_NONE = 0 +SKILL_NOVICE = 1 +SKILL_FAIR = 2 +SKILL_GOOD = 3 +SKILL_EXPERT = 4 +SKILL_EMERITUS = 5 + def damaged(dev): return (game.damage[dev] != 0.0) # Define future events @@ -295,7 +308,14 @@ class gamestate: self.probeinx = 0.0 # probe x,y increment self.probeiny = 0.0 # self.height = 0.0 # height of orbit around planet - + def recompute(self): + # Stas thinks this should be (C expression): + # game.state.remkl + game.state.remcom > 0 ? + # game.state.remres/(game.state.remkl + 4*game.state.remcom) : 99 + # He says the existing expression is prone to divide-by-zero errors + # after killing the last klingon when score is shown -- perhaps also + # if the only remaining klingon is SCOM. + game.state.remtime = game.state.remres/(game.state.remkl + 4*game.state.remcom) # From enumerated type 'feature' IHR = 'R' IHK = 'K' @@ -365,7 +385,6 @@ WHITE = 16 def tryexit(look, ienm, loccom, irun): # a bad guy attempts to bug out iq = coord() - iq.x = game.quadrant.x+(look.x+(QUADSIZE-1))/QUADSIZE - 1 iq.y = game.quadrant.y+(look.y+(QUADSIZE-1))/QUADSIZE - 1 if not VALID_QUADRANT(iq.x,iq.y) or \ @@ -387,12 +406,11 @@ def tryexit(look, ienm, loccom, irun): if game.kpower[loccom] > 1000.0: return False # print escape message and move out of quadrant. - # We know this if either short or long range sensors are working + # we know this if either short or long range sensors are working if not damaged(DSRSENS) or not damaged(DLRSENS) or \ game.condition == docked: - crmena(True, ienm, sector, game.ks[loccom]) - prout(_(" escapes to %s (and regains strength)."), - cramlc(quadrant, iq)) + crmena(True, ienm, "sector", game.ks[loccom]) + prout(_(" escapes to Quadrant %s (and regains strength).") % q) # handle local matters related to escape game.quad[game.ks[loccom].x][game.ks[loccom].y] = IHDOT game.ks[loccom] = game.ks[game.nenhere] @@ -446,7 +464,7 @@ def tryexit(look, ienm, loccom, irun): # only commanders move. In Expert games, all enemy vessels move if there # is a commander present. In Emeritus games all enemy vessels move. # -# 3. If Enterprise is not docked, an agressive action is taken if enemy +# 3. If Enterprise is not docked, an aggressive action is taken if enemy # forces are 1000 greater than Enterprise. # # Agressive action on average cuts the distance between the ship and @@ -473,11 +491,11 @@ def movebaddy(com, loccom, ienm): nbaddys = game.comhere + game.ishere dist1 = game.kdist[loccom] - mdist = dist1 + 0.5; # Nearest integer distance + mdist = int(dist1 + 0.5); # Nearest integer distance # If SC, check with spy to see if should hi-tail it if ienm==IHS and \ - (game.kpower[loccom] <= 500.0 or (game.condition==docked and not damaged(DPHOTON))): + (game.kpower[loccom] <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))): irun = True motion = -QUADSIZE else: @@ -498,7 +516,7 @@ def movebaddy(com, loccom, ienm): # phasers and photon tubes both out! forces += 1000.0 motion = 0 - if forces <= 1000.0 and game.condition != docked: # Typical situation + if forces <= 1000.0 and game.condition != "docked": # Typical situation motion = ((forces+200.0*Rand())/150.0) - 5.0 else: if forces > 1000.0: # Very strong -- move in for kill @@ -506,7 +524,7 @@ def movebaddy(com, loccom, ienm): if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off ! motion -= game.skill*(2.0-square(Rand())) if idebug: - proutn("=== MOTION = %d, FORCES = %1.2f, ", motion, forces) + proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces)) # don't move if no motion if motion==0: return @@ -528,7 +546,7 @@ def movebaddy(com, loccom, ienm): if nsteps < 1: nsteps = 1; # This shouldn't be necessary if idebug: - proutn("NSTEPS = %d:", nsteps) + proutn("NSTEPS = %d:" % nsteps) # Compute preferred values of delta X and Y mx = game.sector.x - com.x my = game.sector.y - com.y @@ -550,7 +568,7 @@ def movebaddy(com, loccom, ienm): # main move loop for ll in range(nsteps): if idebug: - proutn(" %d", ll+1) + proutn(" %d" % (ll+1)) # Check if preferred position available look.x = next.x + mx look.y = next.y + my @@ -599,7 +617,7 @@ def movebaddy(com, loccom, ienm): if success: next = look if idebug: - proutn(cramlc(neither, next)) + proutn(`next`) else: break; # done early @@ -615,22 +633,19 @@ def movebaddy(com, loccom, ienm): if not damaged(DSRSENS) or game.condition == docked: proutn("***") cramen(ienm) - proutn(_(" from %s"), cramlc(2, com)) + proutn(_(" from Sector %s") % com) if game.kdist[loccom] < dist1: proutn(_(" advances to ")) else: proutn(_(" retreats to ")) - prout(cramlc(sector, next)) + prout("Sector %s." % next) def moveklings(): # Klingon tactical movement - w = coord(); - if idebug: prout("== MOVCOM") - # Figure out which Klingon is the commander (or Supercommander) - # and do move + # and do move if game.comhere: for i in range(1, game.nenhere+1): w = game.ks[i] @@ -643,7 +658,7 @@ def moveklings(): if game.quad[w.x][w.y] == IHS: movebaddy(w, i, IHS) break - # if skill level is high, move other Klingons and Romulans too! + # If skill level is high, move other Klingons and Romulans too! # Move these last so they can base their actions on what the # commander(s) do. if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY): @@ -655,7 +670,6 @@ def moveklings(): def movescom(iq, avoid): # commander movement helper - if same(iq, game.quadrant) or not VALID_QUADRANT(iq.x, iq.y) or \ game.state.galaxy[iq.x][iq.y].supernova or \ game.state.galaxy[iq.x][iq.y].klingons > MAXKLQUAD-1: @@ -699,34 +713,29 @@ def movescom(iq, avoid): game.state.planets[i].pclass = destroyed game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].planet = NOPLANET if not damaged(DRADIO) or game.condition == docked: - pause_game(True) + announce() prout(_("Lt. Uhura- \"Captain, Starfleet Intelligence reports")) - proutn(_(" a planet in ")) - proutn(cramlc(quadrant, game.state.kscmdr)) - prout(_(" has been destroyed")) + proutn(_(" a planet in Quadrant %s has been destroyed") % game.state.kscmdr) prout(_(" by the Super-commander.\"")) break return False; # looks good! def supercommander(): # move the Super Commander - iq = coord(); sc = coord(); ibq = coord() + iq = coord(); sc = coord(); ibq = coord(); idelta = coord() basetbl = [] - if idebug: prout("== SUPERCOMMANDER") - # Decide on being active or passive 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 \ (game.state.date-game.indate) < 3.0) if not game.iscate and avoid: # compute move away from Enterprise - ideltax = game.state.kscmdr.x-game.quadrant.x - ideltay = game.state.kscmdr.y-game.quadrant.y - if math.sqrt(ideltax*ideltax+ideltay*ideltay) > 2.0: + idelta = game.state.kscmdr-game.quadrant + if math.sqrt(idelta.x*idelta.x+idelta.y*idelta.y) > 2.0: # circulate in space - ideltax = game.state.kscmdr.y-game.quadrant.y - ideltay = game.quadrant.x-game.state.kscmdr.x + idelta.x = game.state.kscmdr.y-game.quadrant.y + idelta.y = game.quadrant.x-game.state.kscmdr.x else: # compute distances to starbases if game.state.rembase <= 0: @@ -741,7 +750,6 @@ def supercommander(): # look for nearest base without a commander, no Enterprise, and # without too many Klingons, and not already under attack. ifindit = iwhichb = 0 - for i2 in range(1, game.state.rembase+1): i = basetbl[i2][0]; # bug in original had it not finding nearest ibq = game.state.baseq[i] @@ -764,26 +772,18 @@ def supercommander(): return; # Nothing suitable -- wait until next time ibq = game.state.baseq[iwhichb] # decide how to move toward base - ideltax = ibq.x - game.state.kscmdr.x - ideltay = ibq.y - game.state.kscmdr.y - # Maximum movement is 1 quadrant in either or both axis - if ideltax > 1: - ideltax = 1 - if ideltax < -1: - ideltax = -1 - if ideltay > 1: - ideltay = 1 - if ideltay < -1: - ideltay = -1 - - # try moving in both x and y directions - iq.x = game.state.kscmdr.x + ideltax - iq.y = game.state.kscmdr.y + ideltax + idelta = ibq - game.state.kscmdr + # Maximum movement is 1 quadrant in either or both axes + idelta = idelta.sgn() + # try moving in both x and y directions + # there was what looked like a bug in the Almy C code here, + # but it might be this translation is just wrong. + iq = game.state.kscmdr + idelta if movescom(iq, avoid): # failed -- try some other maneuvers - if ideltax==0 or ideltay==0: + if idelta.x==0 or idelta.y==0: # attempt angle move - if ideltax != 0: + if idelta.x != 0: iq.y = game.state.kscmdr.y + 1 if movescom(iq, avoid): iq.y = game.state.kscmdr.y - 1 @@ -797,7 +797,7 @@ def supercommander(): # try moving just in x or y iq.y = game.state.kscmdr.y if movescom(iq, avoid): - iq.y = game.state.kscmdr.y + ideltay + iq.y = game.state.kscmdr.y + idelta.y iq.x = game.state.kscmdr.x movescom(iq, avoid) # check for a base @@ -818,13 +818,12 @@ def supercommander(): if damaged(DRADIO) and game.condition != docked: return; # no warning game.iseenit = True - pause_game(True) - proutn(_("Lt. Uhura- \"Captain, the starbase in ")) - proutn(cramlc(quadrant, game.state.kscmdr)) - skip(1) + announce() + prout(_("Lt. Uhura- \"Captain, the starbase in Quadrant %s") \ + % game.state.kscmdr) prout(_(" reports that it is under attack from the Klingon Super-commander.")) - proutn(_(" It can survive until stardate %d.\""), - int(scheduled(FSCDBAS))) + proutn(_(" It can survive until stardate %d.\"") \ + % int(scheduled(FSCDBAS))) if not game.resting: return prout(_("Mr. Spock- \"Captain, shall we cancel the rest period?\"")) @@ -839,11 +838,9 @@ def supercommander(): (damaged(DRADIO) and game.condition != docked) or \ not game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].charted): return - pause_game(True) + announce() prout(_("Lt. Uhura- \"Captain, Starfleet Intelligence reports")) - proutn(_(" the Super-commander is in ")) - proutn(cramlc(quadrant, game.state.kscmdr)) - prout(".\"") + proutn(_(" the Super-commander is in Quadrant %s,") % game.state.kscmdr) return; def movetholian(): @@ -899,8 +896,4219 @@ def movetholian(): # All plugged up -- Tholian splits game.quad[game.tholian.x][game.tholian.y]=IHWEB dropin(IHBLANK) - crmena(True, IHT, sector, game.tholian) + crmena(True, IHT, "sector", game.tholian) prout(_(" completes web.")) game.ithere = False game.nenhere -= 1 return + +# Code from battle.c begins here + +def doshield(shraise): + # change shield status + action = "NONE" + game.ididit = False + if shraise: + action = "SHUP" + else: + key = scan() + if key == IHALPHA: + if isit("transfer"): + action = "NRG" + else: + chew() + if damaged(DSHIELD): + prout(_("Shields damaged and down.")) + return + if isit("up"): + action = "SHUP" + elif isit("down"): + action = "SHDN" + if action=="NONE": + proutn(_("Do you wish to change shield energy? ")) + if ja() == True: + proutn(_("Energy to transfer to shields- ")) + action = "NRG" + elif damaged(DSHIELD): + prout(_("Shields damaged and down.")) + return + elif game.shldup: + proutn(_("Shields are up. Do you want them down? ")) + if ja() == True: + action = "SHDN" + else: + chew() + return + else: + proutn(_("Shields are down. Do you want them up? ")) + if ja() == True: + action = "SHUP" + else: + chew() + return + if action == "SHUP": # raise shields + if game.shldup: + prout(_("Shields already up.")) + return + game.shldup = True + game.shldchg = True + if game.condition != "docked": + game.energy -= 50.0 + prout(_("Shields raised.")) + if game.energy <= 0: + skip(1) + prout(_("Shields raising uses up last of energy.")) + finish(FNRG) + return + game.ididit=True + return + elif action == "SHDN": + if not game.shldup: + prout(_("Shields already down.")) + return + game.shldup=False + game.shldchg=True + prout(_("Shields lowered.")) + game.ididit = True + return + elif action == "NRG": + while scan() != IHREAL: + chew() + proutn(_("Energy to transfer to shields- ")) + chew() + if aaitem==0: + return + if aaitem > game.energy: + prout(_("Insufficient ship energy.")) + return + game.ididit = True + if game.shield+aaitem >= game.inshld: + prout(_("Shield energy maximized.")) + if game.shield+aaitem > game.inshld: + prout(_("Excess energy requested returned to ship energy")) + game.energy -= game.inshld-game.shield + game.shield = game.inshld + return + if aaitem < 0.0 and game.energy-aaitem > game.inenrg: + # Prevent shield drain loophole + skip(1) + prout(_("Engineering to bridge--")) + prout(_(" Scott here. Power circuit problem, Captain.")) + prout(_(" I can't drain the shields.")) + game.ididit = False + return + if game.shield+aaitem < 0: + prout(_("All shield energy transferred to ship.")) + game.energy += game.shield + game.shield = 0.0 + return + proutn(_("Scotty- \"")) + if aaitem > 0: + prout(_("Transferring energy to shields.\"")) + else: + prout(_("Draining energy from shields.\"")) + game.shield += aaitem + game.energy -= aaitem + return + +def randdevice(): + # choose a device to damage, at random. + # + # Quoth Eric Allman in the code of BSD-Trek: + # "Under certain conditions you can get a critical hit. This + # sort of hit damages devices. The probability that a given + # device is damaged depends on the device. Well protected + # devices (such as the computer, which is in the core of the + # ship and has considerable redundancy) almost never get + # damaged, whereas devices which are exposed (such as the + # warp engines) or which are particularly delicate (such as + # the transporter) have a much higher probability of being + # damaged." + # + # This is one place where OPTION_PLAIN does not restore the + # original behavior, which was equiprobable damage across + # all devices. If we wanted that, we'd return NDEVICES*Rand() + # and have done with it. Also, in the original game, DNAVYS + # and DCOMPTR were the same device. + # + # Instead, we use a table of weights similar to the one from BSD Trek. + # BSD doesn't have the shuttle, shield controller, death ray, or probes. + # We don't have a cloaking device. The shuttle got the allocation + # for the cloaking device, then we shaved a half-percent off + # everything to have some weight to give DSHCTRL/DDRAY/DDSP. + # + weights = ( + 105, # DSRSENS: short range scanners 10.5% + 105, # DLRSENS: long range scanners 10.5% + 120, # DPHASER: phasers 12.0% + 120, # DPHOTON: photon torpedoes 12.0% + 25, # DLIFSUP: life support 2.5% + 65, # DWARPEN: warp drive 6.5% + 70, # DIMPULS: impulse engines 6.5% + 145, # DSHIELD: deflector shields 14.5% + 30, # DRADIO: subspace radio 3.0% + 45, # DSHUTTL: shuttle 4.5% + 15, # DCOMPTR: computer 1.5% + 20, # NAVCOMP: navigation system 2.0% + 75, # DTRANSP: transporter 7.5% + 20, # DSHCTRL: high-speed shield controller 2.0% + 10, # DDRAY: death ray 1.0% + 30, # DDSP: deep-space probes 3.0% + ) + idx = Rand() * 1000.0 # weights must sum to 1000 + sum = 0 + for (i, w) in enumerate(weights): + sum += w + if idx < sum: + return i + return None; # we should never get here + +def ram(ibumpd, ienm, w): + # make our ship ram something + prouts(_("***RED ALERT! RED ALERT!")) + skip(1) + prout(_("***COLLISION IMMINENT.")) + skip(2) + proutn("***") + crmshp() + hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(ienm, 1.0) + if ibumpd: + proutn(_(" rammed by ")) + else: + proutn(_(" rams ")) + crmena(False, ienm, sector, w) + if ibumpd: + proutn(_(" (original position)")) + skip(1) + deadkl(w, ienm, game.sector) + proutn("***") + crmshp() + prout(_(" heavily damaged.")) + icas = 10.0+20.0*Rand() + prout(_("***Sickbay reports %d casualties"), icas) + game.casual += icas + game.state.crew -= icas + # + # In the pre-SST2K version, all devices got equiprobably damaged, + # which was silly. Instead, pick up to half the devices at + # random according to our weighting table, + # + ncrits = Rand() * (NDEVICES/2) + for m in range(ncrits): + dev = randdevice() + if game.damage[dev] < 0: + continue + extradm = (10.0*hardness*Rand()+1.0)*game.damfac + # Damage for at least time of travel! + game.damage[dev] += game.optime + extradm + game.shldup = False + prout(_("***Shields are down.")) + if game.state.remkl + game.state.remcom + game.state.nscrem: + announce() + damagereport() + else: + finish(FWON) + return; + +def torpedo(course, r, incoming, i, n): + # let a photon torpedo fly + iquad = 0 + shoved = False + ac = course + 0.25*r + angle = (15.0-ac)*0.5235988 + bullseye = (15.0 - course)*0.5235988 + deltax = -math.sin(angle); + deltay = math.cos(angle); + x = incoming.x; y = incoming.y + w = coord(); jw = coord() + w.x = w.y = jw.x = jw.y = 0 + bigger = max(math.fabs(deltax), math.fabs(deltay)) + deltax /= bigger + deltay /= bigger + if not damaged(DSRSENS) or game.condition=="docked": + setwnd(srscan_window) + else: + setwnd(message_window) + # Loop to move a single torpedo + for l in range(1, 15+1): + x += deltax + w.x = x + 0.5 + y += deltay + w.y = y + 0.5 + if not VALID_SECTOR(w.x, w.y): + break + iquad=game.quad[w.x][w.y] + tracktorpedo(w, l, i, n, iquad) + if iquad==IHDOT: + continue + # hit something + setwnd(message_window) + if damaged(DSRSENS) and not game.condition=="docked": + skip(1); # start new line after text track + if iquad in (IHE, IHF): # Hit our ship + skip(1) + proutn(_("Torpedo hits ")) + crmshp() + prout(".") + hit = 700.0 + 100.0*Rand() - \ + 1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle)) + newcnd(); # we're blown out of dock + # We may be displaced. + if game.landed or game.condition=="docked": + return hit # Cheat if on a planet + ang = angle + 2.5*(Rand()-0.5) + temp = math.fabs(math.sin(ang)) + if math.fabs(math.cos(ang)) > temp: + temp = math.fabs(math.cos(ang)) + xx = -math.sin(ang)/temp + yy = math.cos(ang)/temp + jw.x=w.x+xx+0.5 + jw.y=w.y+yy+0.5 + if not VALID_SECTOR(jw.x, jw.y): + return hit + if game.quad[jw.x][jw.y]==IHBLANK: + finish(FHOLE) + return hit + if game.quad[jw.x][jw.y]!=IHDOT: + # can't move into object + return hit + game.sector = jw + crmshp() + shoved = True + elif iquad in (IHC, IHS): # Hit a commander + if Rand() <= 0.05: + crmena(True, iquad, sector, w) + prout(_(" uses anti-photon device;")) + prout(_(" torpedo neutralized.")) + return None + elif iquad in (IHR, IHK): # Hit a regular enemy + # find the enemy + for ll in range(1, game.nenhere+1): + if same(w, game.ks[ll]): + break + kp = math.fabs(game.kpower[ll]) + h1 = 700.0 + 100.0*Rand() - \ + 1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle)) + h1 = math.fabs(h1) + if kp < h1: + h1 = kp + if game.kpower[ll] < 0: + game.kpower[ll] -= -h1 + else: + game.kpower[ll] -= h1 + if game.kpower[ll] == 0: + deadkl(w, iquad, w) + return None + crmena(True, iquad, "sector", w) + # If enemy damaged but not destroyed, try to displace + ang = angle + 2.5*(Rand()-0.5) + temp = math.fabs(math.sin(ang)) + if math.fabs(math.cos(ang)) > temp: + temp = math.fabs(math.cos(ang)) + xx = -math.sin(ang)/temp + yy = math.cos(ang)/temp + jw.x=w.x+xx+0.5 + jw.y=w.y+yy+0.5 + if not VALID_SECTOR(jw.x, jw.y): + prout(_(" damaged but not destroyed.")) + return + if game.quad[jw.x][jw.y]==IHBLANK: + prout(_(" buffeted into black hole.")) + deadkl(w, iquad, jw) + return None + if game.quad[jw.x][jw.y]!=IHDOT: + # can't move into object + prout(_(" damaged but not destroyed.")) + return None + proutn(_(" damaged--")) + game.ks[ll] = jw + shoved = True + break + elif iquad == IHB: # Hit a base + skip(1) + prout(_("***STARBASE DESTROYED..")) + for ll in range(1, game.state.rembase+1): + if same(game.state.baseq[ll], game.quadrant): + game.state.baseq[ll]=game.state.baseq[game.state.rembase] + break + game.quad[w.x][w.y]=IHDOT + game.state.rembase -= 1 + game.base.x=game.base.y=0 + game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase -= 1 + game.state.chart[game.quadrant.x][game.quadrant.y].starbase -= 1 + game.state.basekl += 1 + newcnd() + return None + elif iquad == IHP: # Hit a planet + crmena(True, iquad, sector, w) + prout(_(" destroyed.")) + game.state.nplankl += 1 + game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = NOPLANET + game.state.planets[game.iplnet].pclass = destroyed + game.iplnet = 0 + invalidate(game.plnet) + game.quad[w.x][w.y] = IHDOT + if game.landed: + # captain perishes on planet + finish(FDPLANET) + return None + elif iquad == IHW: # Hit an inhabited world -- very bad! + crmena(True, iquad, sector, w) + prout(_(" destroyed.")) + game.state.nworldkl += 1 + game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = NOPLANET + game.state.planets[game.iplnet].pclass = destroyed + game.iplnet = 0 + invalidate(game.plnet) + game.quad[w.x][w.y] = IHDOT + if game.landed: + # captain perishes on planet + finish(FDPLANET) + prout(_("You have just destroyed an inhabited planet.")) + prout(_("Celebratory rallies are being held on the Klingon homeworld.")) + return None + elif iquad == IHSTAR: # Hit a star + if Rand() > 0.10: + nova(w) + return None + crmena(True, IHSTAR, sector, w) + prout(_(" unaffected by photon blast.")) + return None + elif iquad == IHQUEST: # Hit a thingy + if not (game.options & OPTION_THINGY) or Rand()>0.7: + skip(1) + prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!")) + skip(1) + prouts(_(" HACK! HACK! HACK! *CHOKE!* ")) + skip(1) + proutn(_("Mr. Spock-")) + prouts(_(" \"Fascinating!\"")) + skip(1) + deadkl(w, iquad, w) + else: + # + # Stas Sergeev added the possibility that + # you can shove the Thingy and piss it off. + # It then becomes an enemy and may fire at you. + # + iqengry = True + shoved = True + return None + elif iquad == IHBLANK: # Black hole + skip(1) + crmena(True, IHBLANK, sector, w) + prout(_(" swallows torpedo.")) + return None + elif iquad == IHWEB: # hit the web + skip(1) + prout(_("***Torpedo absorbed by Tholian web.")) + return None + elif iquad == IHT: # Hit a Tholian + h1 = 700.0 + 100.0*Rand() - \ + 1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle)) + h1 = math.fabs(h1) + if h1 >= 600: + game.quad[w.x][w.y] = IHDOT + game.ithere = False + deadkl(w, iquad, w) + return None + skip(1) + crmena(True, IHT, sector, w) + if Rand() > 0.05: + prout(_(" survives photon blast.")) + return None + prout(_(" disappears.")) + game.quad[w.x][w.y] = IHWEB + game.ithere = False + game.nenhere -= 1 + dropin(IHBLANK) + return None + else: # Problem! + skip(1) + proutn("Don't know how to handle torpedo collision with ") + crmena(True, iquad, sector, w) + skip(1) + return None + break + if curwnd!=message_window: + setwnd(message_window) + if shoved: + game.quad[w.x][w.y]=IHDOT + game.quad[jw.x][jw.y]=iquad + prout(_(" displaced by blast to Sector %s ") % jw) + for ll in range(1, game.nenhere+1): + game.kdist[ll] = game.kavgd[ll] = distance(game.sector,game.ks[ll]) + sortklings() + return None + skip(1) + prout(_("Torpedo missed.")) + return None; + +def fry(hit): + # critical-hit resolution + ktr=1 + # a critical hit occured + if hit < (275.0-25.0*game.skill)*(1.0+0.5*Rand()): + return + + ncrit = 1.0 + hit/(500.0+100.0*Rand()) + proutn(_("***CRITICAL HIT--")) + # Select devices and cause damage + cdam = [] + for loop1 in range(ncrit): + while True: + j = randdevice() + # Cheat to prevent shuttle damage unless on ship + if not (game.damage[j]<0.0 or (j==DSHUTTL and game.iscraft != "onship")): + break + cdam.append(j) + extradm = (hit*game.damfac)/(ncrit*(75.0+25.0*Rand())) + game.damage[j] += extradm + if loop1 > 0: + for loop2 in range(loop1): + if j == cdam[loop2]: + break + if loop2 < loop1: + continue + ktr += 1 + if ktr==3: + skip(1) + proutn(_(" and ")) + proutn(device[j]) + prout(_(" damaged.")) + if damaged(DSHIELD) and game.shldup: + prout(_("***Shields knocked down.")) + game.shldup=False + +def attack(torps_ok): + # bad guy attacks us + # torps_ok == false forces use of phasers in an attack + atackd = False; attempt = False; ihurt = False; + hitmax=0.0; hittot=0.0; chgfac=1.0 + jay = coord() + where = "neither" + + # game could be over at this point, check + if game.alldone: + return + + if idebug: + prout("=== ATTACK!") + + # Tholian gewts to move before attacking + if game.ithere: + movetholian() + + # if you have just entered the RNZ, you'll get a warning + if game.neutz: # The one chance not to be attacked + game.neutz = False + return + + # commanders get a chance to tac-move towards you + if (((game.comhere or game.ishere) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok: + moveklings() + + # if no enemies remain after movement, we're done + if game.nenhere==0 or (game.nenhere==1 and iqhere and not iqengry): + return + + # set up partial hits if attack happens during shield status change + pfac = 1.0/game.inshld + if game.shldchg: + chgfac = 0.25+0.5*Rand() + + skip(1) + + # message verbosity control + if game.skill <= SKILL_FAIR: + where = "sector" + + for loop in range(1, game.nenhere+1): + if game.kpower[loop] < 0: + continue; # too weak to attack + # compute hit strength and diminish shield power + r = Rand() + # Increase chance of photon torpedos if docked or enemy energy low + if game.condition == "docked": + r *= 0.25 + if game.kpower[loop] < 500: + r *= 0.25; + jay = game.ks[loop] + iquad = game.quad[jay.x][jay.y] + if iquad==IHT or (iquad==IHQUEST and not iqengry): + continue + # different enemies have different probabilities of throwing a torp + usephasers = not torps_ok or \ + (iquad == IHK and r > 0.0005) or \ + (iquad==IHC and r > 0.015) or \ + (iquad==IHR and r > 0.3) or \ + (iquad==IHS and r > 0.07) or \ + (iquad==IHQUEST and r > 0.05) + if usephasers: # Enemy uses phasers + if game.condition == "docked": + continue; # Don't waste the effort! + attempt = True; # Attempt to attack + dustfac = 0.8+0.05*Rand() + hit = game.kpower[loop]*math.pow(dustfac,game.kavgd[loop]) + game.kpower[loop] *= 0.75 + else: # Enemy uses photon torpedo + course = 1.90985*math.atan2(game.sector.y-jay.y, jay.x-game.sector.x) + hit = 0 + proutn(_("***TORPEDO INCOMING")) + if not damaged(DSRSENS): + proutn(_(" From ")) + crmena(False, iquad, where, jay) + attempt = True + prout(" ") + r = (Rand()+Rand())*0.5 -0.5 + r += 0.002*game.kpower[loop]*r + hit = torpedo(course, r, jay, 1, 1) + if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + finish(FWON); # Klingons did themselves in! + if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova or game.alldone: + return; # Supernova or finished + if hit == None: + continue + # incoming phaser or torpedo, shields may dissipate it + if game.shldup or game.shldchg or game.condition=="docked": + # shields will take hits + propor = pfac * game.shield + if game.condition =="docked": + propr *= 2.1 + if propor < 0.1: + propor = 0.1 + hitsh = propor*chgfac*hit+1.0 + absorb = 0.8*hitsh + if absorb > game.shield: + absorb = game.shield + game.shield -= absorb + hit -= hitsh + # taking a hit blasts us out of a starbase dock + if game.condition == "docked": + dock(False) + # but the shields may take care of it + if propor > 0.1 and hit < 0.005*game.energy: + continue + # hit from this opponent got through shields, so take damage + ihurt = True + proutn(_("%d unit hit") % int(hit)) + if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR: + proutn(_(" on the ")) + crmshp() + if not damaged(DSRSENS) and usephasers: + proutn(_(" from ")) + crmena(False, iquad, where, jay) + skip(1) + # Decide if hit is critical + if hit > hitmax: + hitmax = hit + hittot += hit + fry(hit) + game.energy -= hit + if game.energy <= 0: + # Returning home upon your shield, not with it... + finish(FBATTLE) + return + if not attempt and game.condition == "docked": + prout(_("***Enemies decide against attacking your ship.")) + if not atackd: + return + percent = 100.0*pfac*game.shield+0.5 + if not ihurt: + # Shields fully protect ship + proutn(_("Enemy attack reduces shield strength to ")) + else: + # Print message if starship suffered hit(s) + skip(1) + proutn(_("Energy left %2d shields ") % int(game.energy)) + if game.shldup: + proutn(_("up ")) + elif not damaged(DSHIELD): + proutn(_("down ")) + else: + proutn(_("damaged, ")) + prout(_("%d%%, torpedoes left %d") % (percent, game.torps)) + # Check if anyone was hurt + if hitmax >= 200 or hittot >= 500: + icas= hittot*Rand()*0.015 + if icas >= 2: + skip(1) + prout(_("Mc Coy- \"Sickbay to bridge. We suffered %d casualties") % icas) + prout(_(" in that last attack.\"")) + game.casual += icas + game.state.crew -= icas + # After attack, reset average distance to enemies + for loop in range(1, game.nenhere+1): + game.kavgd[loop] = game.kdist[loop] + sortklings() + return; + +def deadkl(w, type, mv): + # kill a Klingon, Tholian, Romulan, or Thingy + # Added mv to allow enemy to "move" before dying + + crmena(True, type, sector, mv) + # Decide what kind of enemy it is and update appropriately + if type == IHR: + # chalk up a Romulan + game.state.galaxy[game.quadrant.x][game.quadrant.y].romulans -= 1 + game.irhere -= 1 + game.state.nromrem -= 1 + elif type == IHT: + # Killed a Tholian + game.ithere = False + elif type == IHQUEST: + # Killed a Thingy + iqhere = iqengry = False + invalidate(thing) + else: + # Some type of a Klingon + game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons -= 1 + game.klhere -= 1 + if type == IHC: + game.comhere = False + for i in range(1, game.state.remcom+1): + if same(game.state.kcmdr[i], game.quadrant): + break + game.state.kcmdr[i] = game.state.kcmdr[game.state.remcom] + game.state.kcmdr[game.state.remcom].x = 0 + game.state.kcmdr[game.state.remcom].y = 0 + game.state.remcom -= 1 + unschedule(FTBEAM) + if game.state.remcom != 0: + schedule(FTBEAM, expran(1.0*game.incom/game.state.remcom)) + elif type == IHK: + game.state.remkl -= 1 + elif type == IHS: + game.state.nscrem -= 1 + game.ishere = False + game.state.kscmdr.x = game.state.kscmdr.y = game.isatb = 0 + game.iscate = False + unschedule(FSCMOVE) + unschedule(FSCDBAS) + else: + prout("*** Internal error, deadkl() called on %s\n" % type) + + # For each kind of enemy, finish message to player + prout(_(" destroyed.")) + game.quad[w.x][w.y] = IHDOT + if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + return + game.recompute() + # Remove enemy ship from arrays describing local conditions + if is_scheduled(FCDBAS) and same(game.battle, game.quadrant) and type==IHC: + unschedule(FCDBAS) + for i in range(1, game.nenhere+1): + if same(game.ks[i], w): + break + game.nenhere -= 1 + if i <= game.nenhere: + for j in range(i, game.nenhere+1): + game.ks[j] = game.ks[j+1] + game.kpower[j] = game.kpower[j+1] + game.kavgd[j] = game.kdist[j] = game.kdist[j+1] + game.ks[game.nenhere+1].x = 0 + game.ks[game.nenhere+1].x = 0 + game.kdist[game.nenhere+1] = 0 + game.kavgd[game.nenhere+1] = 0 + game.kpower[game.nenhere+1] = 0 + return; + +def targetcheck(x, y): + # Return None if target is invalid + if not VALID_SECTOR(x, y): + huh() + return None + deltx = 0.1*(y - game.sector.y) + delty = 0.1*(x - game.sector.x) + if deltx==0 and delty== 0: + skip(1) + prout(_("Spock- \"Bridge to sickbay. Dr. McCoy,")) + prout(_(" I recommend an immediate review of")) + prout(_(" the Captain's psychological profile.\"")) + chew() + return None + return 1.90985932*math.atan2(deltx, delty) + +def photon(): + # launch photon torpedo + game.ididit = False + if damaged(DPHOTON): + prout(_("Photon tubes damaged.")) + chew() + return + if game.torps == 0: + prout(_("No torpedoes left.")) + chew() + return + key = scan() + while True: + if key == IHALPHA: + huh() + return + elif key == IHEOL: + prout(_("%d torpedoes left.") % game.torps) + proutn(_("Number of torpedoes to fire- ")) + key = scan() + else: # key == IHREAL { + n = aaitem + 0.5 + if n <= 0: # abort command + chew() + return + if n > 3: + chew() + prout(_("Maximum of 3 torpedoes per burst.")) + key = IHEOL + return + if n <= game.torps: + break + chew() + key = IHEOL + for i in range(1, n+1): + key = scan() + if i==1 and key == IHEOL: + break; # we will try prompting + if i==2 and key == IHEOL: + # direct all torpedoes at one target + while i <= n: + targ[i][1] = targ[1][1] + targ[i][2] = targ[1][2] + course[i] = course[1] + i += 1 + break + if key != IHREAL: + huh() + return + targ[i][1] = aaitem + key = scan() + if key != IHREAL: + huh() + return + targ[i][2] = aaitem + course[i] = targetcheck(targ[i][1], targ[i][2]) + if course[i] == None: + return + chew() + if i == 1 and key == IHEOL: + # prompt for each one + for i in range(1, n+1): + proutn(_("Target sector for torpedo number %d- ") % i) + key = scan() + if key != IHREAL: + huh() + return + targ[i][1] = aaitem + key = scan() + if key != IHREAL: + huh() + return + targ[i][2] = aaitem + chew() + course[i] = targetcheck(targ[i][1], targ[i][2]) + if course[i] == None: + return + game.ididit = True + # Loop for moving torpedoes + for i in range(1, n+1): + if game.condition != "docked": + game.torps -= 1 + r = (Rand()+Rand())*0.5 -0.5 + if math.fabs(r) >= 0.47: + # misfire! + r = (Rand()+1.2) * r + if n>1: + prouts(_("***TORPEDO NUMBER %d MISFIRES") % i) + else: + prouts(_("***TORPEDO MISFIRES.")) + skip(1) + if i < n: + prout(_(" Remainder of burst aborted.")) + if Rand() <= 0.2: + prout(_("***Photon tubes damaged by misfire.")) + game.damage[DPHOTON] = game.damfac*(1.0+2.0*Rand()) + break + if game.shldup or game.condition == "docked": + r *= 1.0 + 0.0001*game.shield + torpedo(course[i], r, game.sector, i, n) + if game.alldone or game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + return + if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + finish(FWON); + +def overheat(rpow): + # check for phasers overheating + if rpow > 1500: + chekbrn = (rpow-1500.)*0.00038 + if Rand() <= chekbrn: + prout(_("Weapons officer Sulu- \"Phasers overheated, sir.\"")) + game.damage[DPHASER] = game.damfac*(1.0 + Rand()) * (1.0+chekbrn) + +def checkshctrl(rpow): + # check shield control + + skip(1) + if Rand() < 0.998: + prout(_("Shields lowered.")) + return False + # Something bad has happened + prouts(_("***RED ALERT! RED ALERT!")) + skip(2) + hit = rpow*game.shield/game.inshld + game.energy -= rpow+hit*0.8 + game.shield -= hit*0.2 + if game.energy <= 0.0: + prouts(_("Sulu- \"Captain! Shield malf***********************\"")) + skip(1) + stars() + finish(FPHASER) + return True + prouts(_("Sulu- \"Captain! Shield malfunction! Phaser fire contained!\"")) + skip(2) + prout(_("Lt. Uhura- \"Sir, all decks reporting damage.\"")) + icas = hit*Rand()*0.012 + skip(1) + fry(0.8*hit) + if icas: + skip(1) + prout(_("McCoy to bridge- \"Severe radiation burns, Jim.")) + prout(_(" %d casualties so far.\"") % icas) + game.casual += icas + game.state.crew -= icas + skip(1) + prout(_("Phaser energy dispersed by shields.")) + prout(_("Enemy unaffected.")) + overheat(rpow) + return True; + +def hittem(doublehits): + # register a phaser hit on Klingons and Romulans + nenhr2=game.nenhere; kk=1 + w = coord() + skip(1) + for k in range(1, nenhr2+1): + wham = hits[k] + if wham==0: + continue + dustfac = 0.9 + 0.01*Rand() + hit = wham*math.pow(dustfac,game.kdist[kk]) + kpini = game.kpower[kk] + kp = math.fabs(kpini) + if PHASEFAC*hit < kp: + kp = PHASEFAC*hit + if game.kpower[kk] < 0: + game.kpower[kk] -= -kp + else: + game.kpower[kk] -= kp + kpow = game.kpower[kk] + w = game.ks[kk] + if hit > 0.005: + if not damaged(DSRSENS): + boom(w) + proutn(_("%d unit hit on ") % int(hit)) + else: + proutn(_("Very small hit on ")) + ienm = game.quad[w.x][w.y] + if ienm==IHQUEST: + iqengry = True + crmena(False, ienm, "sector", w) + skip(1) + if kpow == 0: + deadkl(w, ienm, w) + if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + finish(FWON); + if game.alldone: + return + kk -= 1; # don't do the increment + else: # decide whether or not to emasculate klingon + if kpow > 0 and Rand() >= 0.9 and \ + kpow <= ((0.4 + 0.4*Rand())*kpini): + prout(_("***Mr. Spock- \"Captain, the vessel at Sector %s"), w) + prout(_(" has just lost its firepower.\"")) + game.kpower[kk] = -kpow + kk += 1 + return; + +def phasers(): + # fire phasers + hits = []; rpow=0 + kz = 0; k = 1; irec=0 # Cheating inhibitor + ifast = False; no = False; itarg = True; msgflag = True + automode = "NOTSET" + key=0 + + skip(1) + # SR sensors and Computer are needed fopr automode + if damaged(DSRSENS) or damaged(DCOMPTR): + itarg = False + if game.condition == "docked": + prout(_("Phasers can't be fired through base shields.")) + chew() + return + if damaged(DPHASER): + prout(_("Phaser control damaged.")) + chew() + return + if game.shldup: + if damaged(DSHCTRL): + prout(_("High speed shield control damaged.")) + chew() + return + if game.energy <= 200.0: + prout(_("Insufficient energy to activate high-speed shield control.")) + chew() + return + prout(_("Weapons Officer Sulu- \"High-speed shield control enabled, sir.\"")) + ifast = True + + # Original code so convoluted, I re-did it all + while automode=="NOTSET": + key=scan() + if key == IHALPHA: + if isit("manual"): + if game.nenhere==0: + prout(_("There is no enemy present to select.")) + chew() + key = IHEOL + automode="AUTOMATIC" + else: + automode = "MANUAL" + key = scan() + elif isit("automatic"): + if (not itarg) and game.nenhere != 0: + automode = "FORCEMAN" + else: + if game.nenhere==0: + prout(_("Energy will be expended into space.")) + automode = "AUTOMATIC" + key = scan() + elif isit("no"): + no = True + else: + huh() + return + elif key == IHREAL: + if game.nenhere==0: + prout(_("Energy will be expended into space.")) + automode = "AUTOMATIC" + elif not itarg: + automode = "FORCEMAN" + else: + automode = "AUTOMATIC" + else: + # IHEOL + if game.nenhere==0: + prout(_("Energy will be expended into space.")) + automode = "AUTOMATIC" + elif not itarg: + automode = "FORCEMAN" + else: + proutn(_("Manual or automatic? ")) + avail = game.energy + if ifast: + avail -= 200.0 + if automode == "AUTOMATIC": + if key == IHALPHA and isit("no"): + no = True + key = scan() + if key != IHREAL and game.nenhere != 0: + prout(_("Phasers locked on target. Energy available: %.2f")%avail) + irec=0 + while True: + chew() + if not kz: + for i in range(1, game.nenhere+1): + irec += math.fabs(game.kpower[i])/(PHASEFAC*math.pow(0.90,game.kdist[i]))*(1.01+0.05*Rand()) + 1.0 + kz=1 + proutn(_("%d units required. ") % irec) + chew() + proutn(_("Units to fire= ")) + key = scan() + if key!=IHREAL: + return + rpow = aaitem + if rpow > avail: + proutn(_("Energy available= %.2f") % avail) + skip(1) + key = IHEOL + if not rpow > avail: + break + if rpow<=0: + # chicken out + chew() + return + key=scan() + if key == IHALPHA and isit("no"): + no = True + if ifast: + game.energy -= 200; # Go and do it! + if checkshctrl(rpow): + return + chew() + game.energy -= rpow + extra = rpow + if game.nenhere: + extra = 0.0 + powrem = rpow + for i in range(1, game.nenhere+1): + hits[i] = 0.0 + if powrem <= 0: + continue + hits[i] = math.fabs(game.kpower[i])/(PHASEFAC*math.pow(0.90,game.kdist[i])) + over = (0.01 + 0.05*Rand())*hits[i] + temp = powrem + powrem -= hits[i] + over + if powrem <= 0 and temp < hits[i]: + hits[i] = temp + if powrem <= 0: + over = 0.0 + extra += over + if powrem > 0.0: + extra += powrem + hittem(hits) + game.ididit = True + if extra > 0 and not game.alldone: + if game.ithere: + proutn(_("*** Tholian web absorbs ")) + if game.nenhere>0: + proutn(_("excess ")) + prout(_("phaser energy.")) + else: + prout(_("%d expended on empty space.") % int(extra)) + elif automode == "FORCEMAN": + chew() + key = IHEOL + if damaged(DCOMPTR): + prout(_("Battle computer damaged, manual fire only.")) + else: + skip(1) + prouts(_("---WORKING---")) + skip(1) + prout(_("Short-range-sensors-damaged")) + prout(_("Insufficient-data-for-automatic-phaser-fire")) + prout(_("Manual-fire-must-be-used")) + skip(1) + elif automode == "MANUAL": + rpow = 0.0 + for k in range(1, game.nenhere+1): + aim = game.ks[k] + ienm = game.quad[aim.x][aim.y] + if msgflag: + proutn(_("Energy available= %.2f") % (avail-0.006)) + skip(1) + msgflag = False + rpow = 0.0 + if damaged(DSRSENS) and not (abs(game.sector.x-aim.x) < 2 and abs(game.sector.y-aim.y) < 2) and \ + (ienm == IHC or ienm == IHS): + cramen(ienm) + prout(_(" can't be located without short range scan.")) + chew() + key = IHEOL + hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko + k += 1 + continue + if key == IHEOL: + chew() + if itarg and k > kz: + irec=(abs(game.kpower[k])/(PHASEFAC*math.pow(0.9,game.kdist[k]))) * (1.01+0.05*Rand()) + 1.0 + kz = k + proutn("(") + if not damaged(DCOMPTR): + proutn("%d" % irec) + else: + proutn("??") + proutn(") ") + proutn(_("units to fire at ")) + crmena(False, ienm, sector, aim) + proutn("- ") + key = scan() + if key == IHALPHA and isit("no"): + no = True + key = scan() + continue + if key == IHALPHA: + huh() + return + if key == IHEOL: + if k==1: # Let me say I'm baffled by this + msgflag = True + continue + if aaitem < 0: + # abort out + chew() + return + hits[k] = aaitem + rpow += aaitem + # If total requested is too much, inform and start over + if rpow > avail: + prout(_("Available energy exceeded -- try again.")) + chew() + return + key = scan(); # scan for next value + k += 1 + if rpow == 0.0: + # zero energy -- abort + chew() + return + if key == IHALPHA and isit("no"): + no = True + game.energy -= rpow + chew() + if ifast: + game.energy -= 200.0 + if checkshctrl(rpow): + return + hittem(hits) + game.ididit = True + # Say shield raised or malfunction, if necessary + if game.alldone: + return + if ifast: + skip(1) + if no == 0: + if Rand() >= 0.99: + prout(_("Sulu- \"Sir, the high-speed shield control has malfunctioned . . .")) + prouts(_(" CLICK CLICK POP . . .")) + prout(_(" No response, sir!")) + game.shldup = False + else: + prout(_("Shields raised.")) + else: + game.shldup = False + overheat(rpow); + +# Code from events,c begins here. + +# This isn't a real event queue a la BSD Trek yet -- you can only have one +# event of each type active at any given time. Mostly these means we can +# only have one FDISTR/FENSLV/FREPRO sequence going at any given time +# BSD Trek, from which we swiped the idea, can have up to 5. + +import math + +def unschedule(evtype): + # remove an event from the schedule + game.future[evtype].date = FOREVER + return game.future[evtype] + +def is_scheduled(evtype): + # is an event of specified type scheduled + return game.future[evtype].date != FOREVER + +def scheduled(evtype): + # when will this event happen? + return game.future[evtype].date + +def schedule(evtype, offset): + # schedule an event of specified type + game.future[evtype].date = game.state.date + offset + return game.future[evtype] + +def postpone(evtype, offset): + # postpone a scheduled event + game.future[evtype].date += offset + +def cancelrest(): + # rest period is interrupted by event + if game.resting: + skip(1) + proutn(_("Mr. Spock- \"Captain, shall we cancel the rest period?\"")) + if ja() == True: + game.resting = False + game.optime = 0.0 + return True + + return False + +def events(): + # run through the event queue looking for things to do + i=0 + fintim = game.state.date + game.optime; yank=0 + ictbeam = False; istract = False + w = coord(); hold = coord() + ev = event(); ev2 = event() + + def tractorbeam(): + # tractor beaming cases merge here + yank = math.sqrt(yank) + announce() + game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5) + skip(1) + proutn("***") + crmshp() + prout(_(" caught in long range tractor beam--")) + # If Kirk & Co. screwing around on planet, handle + atover(True) # atover(true) is Grab + if game.alldone: + return + if game.icraft: # Caught in Galileo? + finish(FSTRACTOR) + return + # Check to see if shuttle is aboard + if game.iscraft == "offship": + skip(1) + if Rand() > 0.5: + prout(_("Galileo, left on the planet surface, is captured")) + prout(_("by aliens and made into a flying McDonald's.")) + game.damage[DSHUTTL] = -10 + game.iscraft = "removed" + else: + prout(_("Galileo, left on the planet surface, is well hidden.")) + if evcode==0: + game.quadrant = game.state.kscmdr + else: + game.quadrant = game.state.kcmdr[i] + game.sector = randplace(QUADSIZE) + crmshp() + proutn(_(" is pulled to ")) + proutn(cramlc(quadrant, game.quadrant)) + proutn(", ") + prout(cramlc(sector, game.sector)) + if game.resting: + prout(_("(Remainder of rest/repair period cancelled.)")) + game.resting = False + if not game.shldup: + if not damaged(DSHIELD) and game.shield > 0: + doshield(True) # raise shields + game.shldchg=False + else: + prout(_("(Shields not currently useable.)")) + newqad(False) + # Adjust finish time to time of tractor beaming + fintim = game.state.date+game.optime + attack(False) + if game.state.remcom <= 0: + unschedule(FTBEAM) + else: + schedule(FTBEAM, game.optime+expran(1.5*game.intime/game.state.remcom)) + + def destroybase(): + # Code merges here for any commander destroying base + # Not perfect, but will have to do + # Handle case where base is in same quadrant as starship + if same(game.battle, game.quadrant): + game.state.chart[game.battle.x][game.battle.y].starbase = False + game.quad[game.base.x][game.base.y] = IHDOT + game.base.x=game.base.y=0 + newcnd() + skip(1) + prout(_("Spock- \"Captain, I believe the starbase has been destroyed.\"")) + elif game.state.rembase != 1 and \ + (not damaged(DRADIO) or game.condition == "docked"): + # Get word via subspace radio + announce() + skip(1) + prout(_("Lt. Uhura- \"Captain, Starfleet Command reports that")) + proutn(_(" the starbase in ")) + proutn(cramlc(quadrant, game.battle)) + prout(_(" has been destroyed by")) + if game.isatb == 2: + prout(_("the Klingon Super-Commander")) + else: + prout(_("a Klingon Commander")) + game.state.chart[game.battle.x][game.battle.y].starbase = False + # Remove Starbase from galaxy + game.state.galaxy[game.battle.x][game.battle.y].starbase = False + for i in range(1, game.state.rembase+1): + if same(game.state.baseq[i], game.battle): + game.state.baseq[i] = game.state.baseq[game.state.rembase] + game.state.rembase -= 1 + if game.isatb == 2: + # reinstate a commander's base attack + game.battle = hold + game.isatb = 0 + else: + invalidate(game.battle) + + if idebug: + prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim)) + for i in range(1, NEVENTS): + if i == FSNOVA: proutn("=== Supernova ") + elif i == FTBEAM: proutn("=== T Beam ") + elif i == FSNAP: proutn("=== Snapshot ") + elif i == FBATTAK: proutn("=== Base Attack ") + elif i == FCDBAS: proutn("=== Base Destroy ") + elif i == FSCMOVE: proutn("=== SC Move ") + elif i == FSCDBAS: proutn("=== SC Base Destroy ") + elif i == FDSPROB: proutn("=== Probe Move ") + elif i == FDISTR: proutn("=== Distress Call ") + elif i == FENSLV: proutn("=== Enslavement ") + elif i == FREPRO: proutn("=== Klingon Build ") + if is_scheduled(i): + prout("%.2f" % (scheduled(i))) + else: + prout("never") + radio_was_broken = damaged(DRADIO) + hold.x = hold.y = 0 + while True: + # Select earliest extraneous event, evcode==0 if no events + evcode = FSPY + if game.alldone: + return + datemin = fintim + for l in range(1, NEVENTS): + if game.future[l].date < datemin: + evcode = l + if idebug: + prout("== Event %d fires" % evcode) + datemin = game.future[l].date + xtime = datemin-game.state.date + game.state.date = datemin + # Decrement Federation resources and recompute remaining time + game.state.remres -= (game.state.remkl+4*game.state.remcom)*xtime + game.recompute() + if game.state.remtime <=0: + finish(FDEPLETE) + return + # Any crew left alive? + if game.state.crew <=0: + finish(FCREW) + return + # Is life support adequate? + if damaged(DLIFSUP) and game.condition != "docked": + if game.lsupres < xtime and game.damage[DLIFSUP] > game.lsupres: + finish(FLIFESUP) + return + game.lsupres -= xtime + if game.damage[DLIFSUP] <= xtime: + game.lsupres = game.inlsr + # Fix devices + repair = xtime + if game.condition == "docked": + repair /= game.docfac + # Don't fix Deathray here + for l in range(0, NDEVICES): + if game.damage[l] > 0.0 and l != DDRAY: + if game.damage[l]-repair > 0.0: + game.damage[l] -= repair + else: + game.damage[l] = 0.0 + # If radio repaired, update star chart and attack reports + if radio_was_broken and not damaged(DRADIO): + prout(_("Lt. Uhura- \"Captain, the sub-space radio is working and")) + prout(_(" surveillance reports are coming in.")) + skip(1) + if not game.iseenit: + attackreport(False) + game.iseenit = True + rechart() + prout(_(" The star chart is now up to date.\"")) + skip(1) + # Cause extraneous event EVCODE to occur + game.optime -= xtime + if evcode == FSNOVA: # Supernova + announce() + supernova(False) + schedule(FSNOVA, expran(0.5*game.intime)) + if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + return + elif evcode == FSPY: # Check with spy to see if SC should tractor beam + if game.state.nscrem == 0 or \ + ictbeam or istract or \ + game.condition=="docked" or game.isatb==1 or game.iscate: + return + if game.ientesc or \ + (game.energy<2000 and game.torps<4 and game.shield < 1250) or \ + (damaged(DPHASER) and (damaged(DPHOTON) or game.torps<4)) or \ + (damaged(DSHIELD) and \ + (game.energy < 2500 or damaged(DPHASER)) and \ + (game.torps < 5 or damaged(DPHOTON))): + # Tractor-beam her! + istract = True + yank = distance(game.state.kscmdr, game.quadrant) + ictbeam = True + tractorbeam() + else: + return + elif evcode == FTBEAM: # Tractor beam + if game.state.remcom == 0: + unschedule(FTBEAM) + continue + i = Rand()*game.state.remcom+1.0 + yank = square(game.state.kcmdr[i].x-game.quadrant.x) + square(game.state.kcmdr[i].y-game.quadrant.y) + if istract or game.condition == "docked" or yank == 0: + # Drats! Have to reschedule + schedule(FTBEAM, + game.optime + expran(1.5*game.intime/game.state.remcom)) + continue + ictbeam = True + tractorbeam() + elif evcode == FSNAP: # Snapshot of the universe (for time warp) + game.snapsht = game.state + game.state.snap = True + schedule(FSNAP, expran(0.5 * game.intime)) + elif evcode == FBATTAK: # Commander attacks starbase + if game.state.remcom==0 or game.state.rembase==0: + # no can do + unschedule(FBATTAK) + unschedule(FCDBAS) + continue + i = 0 + for j in range(1, game.state.rembase+1): + for k in range(1, game.state.remcom+1): + if same(game.state.baseq[j], game.state.kcmdr[k]) and \ + not same(game.state.baseq[j], game.quadrant) and \ + not same(game.state.baseq[j], game.state.kscmdr): + i = 1 + if i == 1: + continue + if j>game.state.rembase: + # no match found -- try later + schedule(FBATTAK, expran(0.3*game.intime)) + unschedule(FCDBAS) + continue + # commander + starbase combination found -- launch attack + game.battle = game.state.baseq[j] + schedule(FCDBAS, 1.0+3.0*Rand()) + if game.isatb: # extra time if SC already attacking + postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date) + game.future[FBATTAK].date = game.future[FCDBAS].date + expran(0.3*game.intime) + game.iseenit = False + if damaged(DRADIO) and game.condition != "docked": + continue # No warning :-( + game.iseenit = True + announce() + skip(1) + proutn(_("Lt. Uhura- \"Captain, the starbase in Quadrant %s") % game.battle) + prout(_(" reports that it is under attack and that it can")) + proutn(_(" hold out only until stardate %d") % (int(scheduled(FCDBAS)))) + prout(".\"") + if cancelrest(): + return + elif evcode == FSCDBAS: # Supercommander destroys base + unschedule(FSCDBAS) + game.isatb = 2 + if not game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].starbase: + continue # WAS RETURN! + hold = game.battle + game.battle = game.state.kscmdr + destroybase() + elif evcode == FCDBAS: # Commander succeeds in destroying base + if evcode==FCDBAS: + unschedule(FCDBAS) + # find the lucky pair + for i in range(1, game.state.remcom+1): + if same(game.state.kcmdr[i], game.battle): + break + if i > game.state.remcom or game.state.rembase == 0 or \ + not game.state.galaxy[game.battle.x][game.battle.y].starbase: + # No action to take after all + invalidate(game.battle) + continue + destroybase() + elif evcode == FSCMOVE: # Supercommander moves + schedule(FSCMOVE, 0.2777) + if not game.ientesc and not istract and game.isatb != 1 and \ + (not game.iscate or not game.justin): + supercommander() + elif evcode == FDSPROB: # Move deep space probe + schedule(FDSPROB, 0.01) + game.probex += game.probeinx + game.probey += game.probeiny + i = (int)(game.probex/QUADSIZE +0.05) + j = (int)(game.probey/QUADSIZE + 0.05) + if game.probec.x != i or game.probec.y != j: + game.probec.x = i + game.probec.y = j + if not VALID_QUADRANT(i, j) or \ + game.state.galaxy[game.probec.x][game.probec.y].supernova: + # Left galaxy or ran into supernova + if not damaged(DRADIO) or game.condition == "docked": + announce() + skip(1) + proutn(_("Lt. Uhura- \"The deep space probe ")) + if not VALID_QUADRANT(j, i): + proutn(_("has left the galaxy")) + else: + proutn(_("is no longer transmitting")) + prout(".\"") + unschedule(FDSPROB) + continue + if not damaged(DRADIO) or game.condition == "docked": + announce() + skip(1) + proutn(_("Lt. Uhura- \"The deep space probe is now in ")) + proutn(cramlc(quadrant, game.probec)) + prout(".\"") + pdest = game.state.galaxy[game.probec.x][game.probec.y] + # Update star chart if Radio is working or have access to radio + if not damaged(DRADIO) or game.condition == "docked": + chp = game.state.chart[game.probec.x][game.probec.y] + chp.klingons = pdest.klingons + chp.starbase = pdest.starbase + chp.stars = pdest.stars + pdest.charted = True + game.proben -= 1 # One less to travel + if game.proben == 0 and game.isarmed and pdest.stars: + # lets blow the sucker! + supernova(True, game.probec) + unschedule(FDSPROB) + if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + return + elif evcode == FDISTR: # inhabited system issues distress call + unschedule(FDISTR) + # try a whole bunch of times to find something suitable + for i in range(100): + # need a quadrant which is not the current one, + # which has some stars which are inhabited and + # not already under attack, which is not + # supernova'ed, and which has some Klingons in it + w = randplace(GALSIZE) + q = game.state.galaxy[w.x][w.y] + if not (same(game.quadrant, w) or q.planet == NOPLANET or \ + game.state.planets[q.planet].inhabited == UNINHABITED or \ + q.supernova or q.status!=secure or q.klingons<=0): + break + else: + # can't seem to find one; ignore this call + if idebug: + prout("=== Couldn't find location for distress event.") + continue + # got one!! Schedule its enslavement + ev = schedule(FENSLV, expran(game.intime)) + ev.quadrant = w + q.status = distressed + + # tell the captain about it if we can + if not damaged(DRADIO) or game.condition == "docked": + prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \ + % (q.planet, `w`)) + prout(_("by a Klingon invasion fleet.")) + if cancelrest(): + return + elif evcode == FENSLV: # starsystem is enslaved + ev = unschedule(FENSLV) + # see if current distress call still active + q = game.state.galaxy[ev.quadrant.x][ev.quadrant.y] + if q.klingons <= 0: + q.status = "secure" + continue + q.status = "enslaved" + + # play stork and schedule the first baby + ev2 = schedule(FREPRO, expran(2.0 * game.intime)) + ev2.quadrant = ev.quadrant + + # report the disaster if we can + if not damaged(DRADIO) or game.condition == "docked": + prout(_("Uhura- We've lost contact with starsystem %s") % \ + q.planet) + prout(_("in Quadrant %s.\n") % ev.quadrant) + elif evcode == FREPRO: # Klingon reproduces + # If we ever switch to a real event queue, we'll need to + # explicitly retrieve and restore the x and y. + ev = schedule(FREPRO, expran(1.0 * game.intime)) + # see if current distress call still active + q = game.state.galaxy[ev.quadrant.x][ev.quadrant.y] + if q.klingons <= 0: + q.status = "secure" + continue + if game.state.remkl >=MAXKLGAME: + continue # full right now + # reproduce one Klingon + w = ev.quadrant + if game.klhere >= MAXKLQUAD: + try: + # this quadrant not ok, pick an adjacent one + for i in range(w.x - 1, w.x + 2): + for j in range(w.y - 1, w.y + 2): + if not VALID_QUADRANT(i, j): + continue + q = game.state.galaxy[w.x][w.y] + # check for this quad ok (not full & no snova) + if q.klingons >= MAXKLQUAD or q.supernova: + continue + raise "FOUNDIT" + else: + continue # search for eligible quadrant failed + except "FOUNDIT": + w.x = i + w.y = j + # deliver the child + game.state.remkl += 1 + q.klingons += 1 + if same(game.quadrant, w): + newkling(++game.klhere) + + # recompute time left + game.recompute() + # report the disaster if we can + if not damaged(DRADIO) or game.condition == "docked": + if same(game.quadrant, w): + prout(_("Spock- sensors indicate the Klingons have")) + prout(_("launched a warship from %s.") % q.planet) + else: + prout(_("Uhura- Starfleet reports increased Klingon activity")) + if q.planet != NOPLANET: + proutn(_("near %s") % q.planet) + prout(_("in Quadrant %s.") % w) + +def wait(): + # wait on events + game.ididit = False + while True: + key = scan() + if key != IHEOL: + break + proutn(_("How long? ")) + chew() + if key != IHREAL: + huh() + return + origTime = delay = aaitem + if delay <= 0.0: + return + if delay >= game.state.remtime or game.nenhere != 0: + proutn(_("Are you sure? ")) + if ja() == False: + return + + # Alternate resting periods (events) with attacks + + game.resting = True + while True: + if delay <= 0: + game.resting = False + if not game.resting: + prout(_("%d stardates left.") % int(game.state.remtime)) + return + temp = game.optime = delay + if game.nenhere: + rtime = 1.0 + Rand() + if rtime < temp: + temp = rtime + game.optime = temp + if game.optime < delay: + attack(False) + if game.alldone: + return + events() + game.ididit = True + if game.alldone: + return + delay -= temp + # Repair Deathray if long rest at starbase + if origTime-delay >= 9.99 and game.condition == "docked": + game.damage[DDRAY] = 0.0 + # leave if quadrant supernovas + if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + break + game.resting = False + game.optime = 0 + +# A nova occurs. It is the result of having a star hit with a +# photon torpedo, or possibly of a probe warhead going off. +# Stars that go nova cause stars which surround them to undergo +# the same probabilistic process. Klingons next to them are +# destroyed. And if the starship is next to it, it gets zapped. +# If the zap is too much, it gets destroyed. + +def nova(nov): + # star goes nova + course = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5) + newc = coord(); scratch = coord() + + if Rand() < 0.05: + # Wow! We've supernova'ed + supernova(False, nov) + return + + # handle initial nova + game.quad[nov.x][nov.y] = IHDOT + crmena(False, IHSTAR, sector, nov) + prout(_(" novas.")) + game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1 + game.state.starkl += 1 + + # Set up stack to recursively trigger adjacent stars + bot = top = top2 = 1 + kount = 0 + icx = icy = 0 + hits[1][1] = nov.x + hits[1][2] = nov.y + while True: + for mm in range(bot, top+1): + for nn in range(1, 3+1): # nn,j represents coordinates around current + for j in range(1, 3+1): + if j==2 and nn== 2: + continue + scratch.x = hits[mm][1]+nn-2 + scratch.y = hits[mm][2]+j-2 + if not VALID_SECTOR(scratch.y, scratch.x): + continue + iquad = game.quad[scratch.x][scratch.y] + # Empty space ends reaction + if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB): + break + elif iquad == IHSTAR: # Affect another star + if Rand() < 0.05: + # This star supernovas + scratch = supernova(False) + return + top2 += 1 + hits[top2][1]=scratch.x + hits[top2][2]=scratch.y + game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1 + game.state.starkl += 1 + crmena(True, IHSTAR, sector, scratch) + prout(_(" novas.")) + game.quad[scratch.x][scratch.y] = IHDOT + elif iquad == IHP: # Destroy planet + game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = NOPLANET + game.state.nplankl += 1 + crmena(True, IHP, sector, scratch) + prout(_(" destroyed.")) + game.state.planets[game.iplnet].pclass = destroyed + game.iplnet = 0 + invalidate(game.plnet) + if game.landed: + finish(FPNOVA) + return + game.quad[scratch.x][scratch.y] = IHDOT + elif iquad == IHB: # Destroy base + game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase = False + for i in range(1, game.state.rembase+1): + if same(game.state.baseq[i], game.quadrant): + break + game.state.baseq[i] = game.state.baseq[game.state.rembase] + game.state.rembase -= 1 + invalidate(game.base) + game.state.basekl += 1 + newcnd() + crmena(True, IHB, sector, scratch) + prout(_(" destroyed.")) + game.quad[scratch.x][scratch.y] = IHDOT + elif iquad in (IHE, IHF): # Buffet ship + prout(_("***Starship buffeted by nova.")) + if game.shldup: + if game.shield >= 2000.0: + game.shield -= 2000.0 + else: + diff = 2000.0 - game.shield + game.energy -= diff + game.shield = 0.0 + game.shldup = False + prout(_("***Shields knocked out.")) + game.damage[DSHIELD] += 0.005*game.damfac*Rand()*diff + else: + game.energy -= 2000.0 + if game.energy <= 0: + finish(FNOVA) + return + # add in course nova contributes to kicking starship + icx += game.sector.x-hits[mm][1] + icy += game.sector.y-hits[mm][2] + kount += 1 + elif iquad == IHK: # kill klingon + deadkl(scratch,iquad, scratch) + elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies + for ll in range(1, game.nenhere+1): + if same(game.ks[ll], scratch): + break + game.kpower[ll] -= 800.0 # If firepower is lost, die + if game.kpower[ll] <= 0.0: + deadkl(scratch, iquad, scratch) + break + newc.x = scratch.x + scratch.x - hits[mm][1] + newc.y = scratch.y + scratch.y - hits[mm][2] + crmena(True, iquad, sector, scratch) + proutn(_(" damaged")) + if not VALID_SECTOR(newc.x, newc.y): + # can't leave quadrant + skip(1) + break + iquad1 = game.quad[newc.x][newc.y] + if iquad1 == IHBLANK: + proutn(_(", blasted into ")) + crmena(False, IHBLANK, sector, newc) + skip(1) + deadkl(scratch, iquad, newc) + break + if iquad1 != IHDOT: + # can't move into something else + skip(1) + break + proutn(_(", buffeted to ")) + proutn(cramlc(sector, newc)) + game.quad[scratch.x][scratch.y] = IHDOT + game.quad[newc.x][newc.y] = iquad + game.ks[ll] = newc + game.kdist[ll] = game.kavgd[ll] = distance(game.sector, newc) + skip(1) + if top == top2: + break + bot = top + 1 + top = top2 + if kount==0: + return + + # Starship affected by nova -- kick it away. + game.dist = kount*0.1 + icx = sgn(icx) + icy = sgn(icy) + game.direc = course[3*(icx+1)+icy+2] + if game.direc == 0.0: + game.dist = 0.0 + if game.dist == 0.0: + return + game.optime = 10.0*game.dist/16.0 + skip(1) + prout(_("Force of nova displaces starship.")) + imove(True) + game.optime = 10.0*game.dist/16.0 + return + +def supernova(induced, w=None): + # star goes supernova + num = 0; npdead = 0 + nq = coord() + + if w != None: + nq = w + else: + stars = 0 + # Scheduled supernova -- select star + # logic changed here so that we won't favor quadrants in top + # left of universe + for nq.x in range(1, GALSIZE+1): + for nq.y in range(1, GALSIZE+1): + stars += game.state.galaxy[nq.x][nq.y].stars + if stars == 0: + return # nothing to supernova exists + num = Rand()*stars + 1 + for nq.x in range(1, GALSIZE+1): + for nq.y in range(1, GALSIZE+1): + num -= game.state.galaxy[nq.x][nq.y].stars + if num <= 0: + break + if num <=0: + break + if idebug: + proutn("=== Super nova here?") + if ja() == True: + nq = game.quadrant + + if not same(nq, game.quadrant) or game.justin: + # it isn't here, or we just entered (treat as enroute) + if not damaged(DRADIO) or game.condition == "docked": + skip(1) + prout(_("Message from Starfleet Command Stardate %.2f") % game.state.date) + prout(_(" Supernova in Quadrant %s; caution advised.") % nq) + else: + ns = coord() + # we are in the quadrant! + num = Rand()* game.state.galaxy[nq.x][nq.y].stars + 1 + for ns.x in range(1, QUADSIZE+1): + for ns.y in range(1, QUADSIZE+1): + if game.quad[ns.x][ns.y]==IHSTAR: + num -= 1 + if num==0: + break + if num==0: + break + + skip(1) + prouts(_("***RED ALERT! RED ALERT!")) + skip(1) + prout(_("***Incipient supernova detected at Sector %s") % ns) + if square(ns.x-game.sector.x) + square(ns.y-game.sector.y) <= 2.1: + proutn(_("Emergency override attempts t")) + prouts("***************") + skip(1) + stars() + game.alldone = True + + # destroy any Klingons in supernovaed quadrant + kldead = game.state.galaxy[nq.x][nq.y].klingons + game.state.galaxy[nq.x][nq.y].klingons = 0 + if same(nq, game.state.kscmdr): + # did in the Supercommander! + game.state.nscrem = game.state.kscmdr.x = game.state.kscmdr.y = game.isatb = 0 + game.iscate = False + unschedule(FSCMOVE) + unschedule(FSCDBAS) + if game.state.remcom: + maxloop = game.state.remcom + for l in range(1, maxloop+1): + if same(game.state.kcmdr[l], nq): + game.state.kcmdr[l] = game.state.kcmdr[game.state.remcom] + invalidate(game.state.kcmdr[game.state.remcom]) + game.state.remcom -= 1 + kldead -= 1 + if game.state.remcom==0: + unschedule(FTBEAM) + break + game.state.remkl -= kldead + # destroy Romulans and planets in supernovaed quadrant + nrmdead = game.state.galaxy[nq.x][nq.y].romulans + game.state.galaxy[nq.x][nq.y].romulans = 0 + game.state.nromrem -= nrmdead + # Destroy planets + for loop in range(game.inplan): + if same(game.state.planets[loop].w, nq): + game.state.planets[loop].pclass = destroyed + npdead += 1 + # Destroy any base in supernovaed quadrant + if game.state.rembase: + maxloop = game.state.rembase + for loop in range(1, maxloop+1): + if same(game.state.baseq[loop], nq): + game.state.baseq[loop] = game.state.baseq[game.state.rembase] + invalidate(game.state.baseq[game.state.rembase]) + game.state.rembase -= 1 + break + # If starship caused supernova, tally up destruction + if induced: + game.state.starkl += game.state.galaxy[nq.x][nq.y].stars + game.state.basekl += game.state.galaxy[nq.x][nq.y].starbase + game.state.nplankl += npdead + # mark supernova in galaxy and in star chart + if same(game.quadrant, nq) or not damaged(DRADIO) or game.condition == "docked": + game.state.galaxy[nq.x][nq.y].supernova = True + # If supernova destroys last Klingons give special message + if (game.state.remkl + game.state.remcom + game.state.nscrem)==0 and not same(nq, game.quadrant): + skip(2) + if not induced: + prout(_("Lucky you!")) + proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq) + finish(FWON) + return + # if some Klingons remain, continue or die in supernova + if game.alldone: + finish(FSNOVAED) + return + +# Code from finish.c ends here. + +def selfdestruct(): + # self-destruct maneuver + # Finish with a BANG! + chew() + if damaged(DCOMPTR): + prout(_("Computer damaged; cannot execute destruct sequence.")) + return + prouts(_("---WORKING---")); skip(1) + prouts(_("SELF-DESTRUCT-SEQUENCE-ACTIVATED")); skip(1) + prouts(" 10"); skip(1) + prouts(" 9"); skip(1) + prouts(" 8"); skip(1) + prouts(" 7"); skip(1) + prouts(" 6"); skip(1) + skip(1) + prout(_("ENTER-CORRECT-PASSWORD-TO-CONTINUE-")) + skip(1) + prout(_("SELF-DESTRUCT-SEQUENCE-OTHERWISE-")) + skip(1) + prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED")) + skip(1) + scan() + chew() + if game.passwd != citem: + prouts(_("PASSWORD-REJECTED;")) + skip(1) + prouts(_("CONTINUITY-EFFECTED")) + skip(2) + return + prouts(_("PASSWORD-ACCEPTED")); skip(1) + prouts(" 5"); skip(1) + prouts(" 4"); skip(1) + prouts(" 3"); skip(1) + prouts(" 2"); skip(1) + prouts(" 1"); skip(1) + if Rand() < 0.15: + prouts(_("GOODBYE-CRUEL-WORLD")) + skip(1) + kaboom() + +def kaboom(): + stars() + if game.ship==IHE: + prouts("***") + prouts(_("********* Entropy of ")) + crmshp() + prouts(_(" maximized *********")) + skip(1) + stars() + skip(1) + if game.nenhere != 0: + whammo = 25.0 * game.energy + l=1 + while l <= game.nenhere: + if game.kpower[l]*game.kdist[l] <= whammo: + deadkl(game.ks[l], game.quad[game.ks[l].x][game.ks[l].y], game.ks[l]) + l += 1 + finish(FDILITHIUM) + +def killrate(): + "Compute our rate of kils over time." + return ((game.inkling + game.incom + game.inscom) - (game.state.remkl + game.state.remcom + game.state.nscrem))/(game.state.date-game.indate) + +def badpoints(): + "Compute demerits." + badpt = 5.0*game.state.starkl + \ + game.casual + \ + 10.0*game.state.nplankl + \ + 300*game.state.nworldkl + \ + 45.0*game.nhelp +\ + 100.0*game.state.basekl +\ + 3.0*game.abandoned + if game.ship == IHF: + badpt += 100.0 + elif game.ship == None: + badpt += 200.0 + return badpt + + +def finish(ifin): + # end the game, with appropriate notfications + igotit = False + game.alldone = True + skip(3) + prout(_("It is stardate %.1f.") % game.state.date) + skip(1) + if ifin == FWON: # Game has been won + if game.state.nromrem != 0: + prout(_("The remaining %d Romulans surrender to Starfleet Command.") % + game.state.nromrem) + + prout(_("You have smashed the Klingon invasion fleet and saved")) + prout(_("the Federation.")) + game.gamewon = True + if game.alive: + badpt = badpoints() + if badpt < 100.0: + badpt = 0.0 # Close enough! + # killsPerDate >= RateMax + if game.state.date-game.indate < 5.0 or \ + killrate() >= 0.1*game.skill*(game.skill+1.0) + 0.1 + 0.008*badpt: + skip(1) + prout(_("In fact, you have done so well that Starfleet Command")) + if game.skill == SKILL_NOVICE: + prout(_("promotes you one step in rank from \"Novice\" to \"Fair\".")) + elif game.skill == SKILL_FAIR: + prout(_("promotes you one step in rank from \"Fair\" to \"Good\".")) + elif game.skill == SKILL_GOOD: + prout(_("promotes you one step in rank from \"Good\" to \"Expert\".")) + elif game.skill == SKILL_EXPERT: + prout(_("promotes you to Commodore Emeritus.")) + skip(1) + prout(_("Now that you think you're really good, try playing")) + prout(_("the \"Emeritus\" game. It will splatter your ego.")) + elif game.skill == SKILL_EMERITUS: + skip(1) + proutn(_("Computer- ")) + prouts(_("ERROR-ERROR-ERROR-ERROR")) + skip(2) + prouts(_(" YOUR-SKILL-HAS-EXCEEDED-THE-CAPACITY-OF-THIS-PROGRAM")) + skip(1) + prouts(_(" THIS-PROGRAM-MUST-SURVIVE")) + skip(1) + prouts(_(" THIS-PROGRAM-MUST-SURVIVE")) + skip(1) + prouts(_(" THIS-PROGRAM-MUST-SURVIVE")) + skip(1) + prouts(_(" THIS-PROGRAM-MUST?- MUST ? - SUR? ? -? VI")) + skip(2) + prout(_("Now you can retire and write your own Star Trek game!")) + skip(1) + elif game.skill >= SKILL_EXPERT: + if game.thawed and not idebug: + prout(_("You cannot get a citation, so...")) + else: + proutn(_("Do you want your Commodore Emeritus Citation printed? ")) + chew() + if ja() == True: + igotit = True + # Only grant long life if alive (original didn't!) + skip(1) + prout(_("LIVE LONG AND PROSPER.")) + score() + if igotit: + plaque() + return + elif ifin == FDEPLETE: # Federation Resources Depleted + prout(_("Your time has run out and the Federation has been")) + prout(_("conquered. Your starship is now Klingon property,")) + prout(_("and you are put on trial as a war criminal. On the")) + proutn(_("basis of your record, you are ")) + if (game.state.remkl + game.state.remcom + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom): + prout(_("acquitted.")) + skip(1) + prout(_("LIVE LONG AND PROSPER.")) + else: + prout(_("found guilty and")) + prout(_("sentenced to death by slow torture.")) + game.alive = False + score() + return + elif ifin == FLIFESUP: + prout(_("Your life support reserves have run out, and")) + prout(_("you die of thirst, starvation, and asphyxiation.")) + prout(_("Your starship is a derelict in space.")) + elif ifin == FNRG: + prout(_("Your energy supply is exhausted.")) + skip(1) + prout(_("Your starship is a derelict in space.")) + elif ifin == FBATTLE: + proutn(_("The ")) + crmshp() + prout(_("has been destroyed in battle.")) + skip(1) + prout(_("Dulce et decorum est pro patria mori.")) + elif ifin == FNEG3: + prout(_("You have made three attempts to cross the negative energy")) + prout(_("barrier which surrounds the galaxy.")) + skip(1) + prout(_("Your navigation is abominable.")) + score() + elif ifin == FNOVA: + prout(_("Your starship has been destroyed by a nova.")) + prout(_("That was a great shot.")) + skip(1) + elif ifin == FSNOVAED: + proutn(_("The ")) + crmshp() + prout(_(" has been fried by a supernova.")) + prout(_("...Not even cinders remain...")) + elif ifin == FABANDN: + prout(_("You have been captured by the Klingons. If you still")) + prout(_("had a starbase to be returned to, you would have been")) + prout(_("repatriated and given another chance. Since you have")) + prout(_("no starbases, you will be mercilessly tortured to death.")) + elif ifin == FDILITHIUM: + prout(_("Your starship is now an expanding cloud of subatomic particles")) + elif ifin == FMATERIALIZE: + prout(_("Starbase was unable to re-materialize your starship.")) + prout(_("Sic transit gloria mundi")) + elif ifin == FPHASER: + proutn(_("The ")) + crmshp() + prout(_(" has been cremated by its own phasers.")) + elif ifin == FLOST: + prout(_("You and your landing party have been")) + prout(_("converted to energy, disipating through space.")) + elif ifin == FMINING: + prout(_("You are left with your landing party on")) + prout(_("a wild jungle planet inhabited by primitive cannibals.")) + skip(1) + prout(_("They are very fond of \"Captain Kirk\" soup.")) + skip(1) + proutn(_("Without your leadership, the ")) + crmshp() + prout(_(" is destroyed.")) + elif ifin == FDPLANET: + prout(_("You and your mining party perish.")) + skip(1) + prout(_("That was a great shot.")) + skip(1) + elif ifin == FSSC: + prout(_("The Galileo is instantly annihilated by the supernova.")) + prout(_("You and your mining party are atomized.")) + skip(1) + proutn(_("Mr. Spock takes command of the ")) + crmshp() + prout(_(" and")) + prout(_("joins the Romulans, reigning terror on the Federation.")) + elif ifin == FPNOVA: + prout(_("You and your mining party are atomized.")) + skip(1) + proutn(_("Mr. Spock takes command of the ")) + crmshp() + prout(_(" and")) + prout(_("joins the Romulans, reigning terror on the Federation.")) + elif ifin == FSTRACTOR: + prout(_("The shuttle craft Galileo is also caught,")) + prout(_("and breaks up under the strain.")) + skip(1) + prout(_("Your debris is scattered for millions of miles.")) + proutn(_("Without your leadership, the ")) + crmshp() + prout(_(" is destroyed.")) + elif ifin == FDRAY: + prout(_("The mutants attack and kill Spock.")) + prout(_("Your ship is captured by Klingons, and")) + prout(_("your crew is put on display in a Klingon zoo.")) + elif ifin == FTRIBBLE: + prout(_("Tribbles consume all remaining water,")) + prout(_("food, and oxygen on your ship.")) + skip(1) + prout(_("You die of thirst, starvation, and asphyxiation.")) + prout(_("Your starship is a derelict in space.")) + elif ifin == FHOLE: + prout(_("Your ship is drawn to the center of the black hole.")) + prout(_("You are crushed into extremely dense matter.")) + elif ifin == FCREW: + prout(_("Your last crew member has died.")) + if game.ship == IHF: + game.ship = None + elif game.ship == IHE: + game.ship = IHF + game.alive = False + if (game.state.remkl + game.state.remcom + game.state.nscrem) != 0: + goodies = game.state.remres/game.inresor + baddies = (game.state.remkl + 2.0*game.state.remcom)/(game.inkling+2.0*game.incom) + if goodies/baddies >= 1.0+0.5*Rand(): + prout(_("As a result of your actions, a treaty with the Klingon")) + prout(_("Empire has been signed. The terms of the treaty are")) + if goodies/baddies >= 3.0+Rand(): + prout(_("favorable to the Federation.")) + skip(1) + prout(_("Congratulations!")) + else: + prout(_("highly unfavorable to the Federation.")) + else: + prout(_("The Federation will be destroyed.")) + else: + prout(_("Since you took the last Klingon with you, you are a")) + prout(_("martyr and a hero. Someday maybe they'll erect a")) + prout(_("statue in your memory. Rest in peace, and try not")) + prout(_("to think about pigeons.")) + game.gamewon = True + score() + +def score(): + # compute player's score + timused = game.state.date - game.indate + + iskill = game.skill + if (timused == 0 or (game.state.remkl + game.state.remcom + game.state.nscrem) != 0) and timused < 5.0: + timused = 5.0 + perdate = killrate() + ithperd = 500*perdate + 0.5 + iwon = 0 + if game.gamewon: + iwon = 100*game.skill + if game.ship == IHE: + klship = 0 + elif game.ship == IHF: + klship = 1 + else: + klship = 2 + if not game.gamewon: + game.state.nromrem = 0 # None captured if no win + iscore = 10*(game.inkling - game.state.remkl) \ + + 50*(game.incom - game.state.remcom) \ + + ithperd + iwon \ + + 20*(game.inrom - game.state.nromrem) \ + + 200*(game.inscom - game.state.nscrem) \ + - game.state.nromrem \ + - badpoints() + if not game.alive: + iscore -= 200 + skip(2) + prout(_("Your score --")) + if game.inrom - game.state.nromrem: + prout(_("%6d Romulans destroyed %5d") % + (game.inrom - game.state.nromrem, 20*(game.inrom - game.state.nromrem))) + if game.state.nromrem: + prout(_("%6d Romulans captured %5d") % + (game.state.nromrem, game.state.nromrem)) + if game.inkling - game.state.remkl: + prout(_("%6d ordinary Klingons destroyed %5d") % + (game.inkling - game.state.remkl, 10*(game.inkling - game.state.remkl))) + if game.incom - game.state.remcom: + prout(_("%6d Klingon commanders destroyed %5d") % + (game.incom - game.state.remcom, 50*(game.incom - game.state.remcom))) + if game.inscom - game.state.nscrem: + prout(_("%6d Super-Commander destroyed %5d") % + (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem))) + if ithperd: + prout(_("%6.2f Klingons per stardate %5d") % + (perdate, ithperd)) + if game.state.starkl: + prout(_("%6d stars destroyed by your action %5d") % + (game.state.starkl, -5*game.state.starkl)) + if game.state.nplankl: + prout(_("%6d planets destroyed by your action %5d") % + (game.state.nplankl, -10*game.state.nplankl)) + if (game.options & OPTION_WORLDS) and game.state.nworldkl: + prout(_("%6d inhabited planets destroyed by your action %5d") % + (game.state.nplankl, -300*game.state.nworldkl)) + if game.state.basekl: + prout(_("%6d bases destroyed by your action %5d") % + (game.state.basekl, -100*game.state.basekl)) + if game.nhelp: + prout(_("%6d calls for help from starbase %5d") % + (game.nhelp, -45*game.nhelp)) + if game.casual: + prout(_("%6d casualties incurred %5d") % + (game.casual, -game.casual)) + if game.abandoned: + prout(_("%6d crew abandoned in space %5d") % + (game.abandoned, -3*game.abandoned)) + if klship: + prout(_("%6d ship(s) lost or destroyed %5d") % + (klship, -100*klship)) + if not game.alive: + prout(_("Penalty for getting yourself killed -200")) + if game.gamewon: + proutn(_("Bonus for winning ")) + if game.skill == SKILL_NOVICE: proutn(_("Novice game ")) + elif game.skill == SKILL_FAIR: proutn(_("Fair game ")) + elif game.skill == SKILL_GOOD: proutn(_("Good game ")) + elif game.skill == SKILL_EXPERT: proutn(_("Expert game ")) + elif game.skill == SKILL_EMERITUS: proutn(_("Emeritus game")) + prout(" %5d" % iwon) + skip(1) + prout(_("TOTAL SCORE %5d") % iscore) + +def plaque(): + # emit winner's commemmorative plaque + skip(2) + while True: + proutn(_("File or device name for your plaque: ")) + cgetline(winner, sizeof(winner)) + try: + fp = open(winner, "w") + break + except IOError: + prout(_("Invalid name.")) + + proutn(_("Enter name to go on plaque (up to 30 characters): ")) + cgetline(winner, sizeof(winner)) + # The 38 below must be 64 for 132-column paper + nskip = 38 - len(winner)/2 + + fp.write("\n\n\n\n") + # --------DRAW ENTERPRISE PICTURE. + fp.write(" EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n" ) + fp.write(" EEE E : : : E\n" ) + fp.write(" EE EEE E : : NCC-1701 : E\n") + fp.write("EEEEEEEEEEEEEEEE EEEEEEEEEEEEEEE : : : E\n") + fp.write(" E EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n") + fp.write(" EEEEEEEEE EEEEEEEEEEEEE E E\n") + fp.write(" EEEEEEE EEEEE E E E E\n") + fp.write(" EEE E E E E\n") + fp.write(" E E E E\n") + fp.write(" EEEEEEEEEEEEE E E\n") + fp.write(" EEE : EEEEEEE EEEEEEEE\n") + fp.write(" :E : EEEE E\n") + fp.write(" .-E -:----- E\n") + fp.write(" :E : E\n") + fp.write(" EE : EEEEEEEE\n") + fp.write(" EEEEEEEEEEEEEEEEEEEEEEE\n") + fp.write("\n\n\n") + fp.write(_(" U. S. S. ENTERPRISE\n")) + fp.write("\n\n\n\n") + fp.write(_(" For demonstrating outstanding ability as a starship captain\n")) + fp.write("\n") + fp.write(_(" Starfleet Command bestows to you\n")) + fp.write("\n") + fp.write("%*s%s\n\n" % (nskip, "", winner)) + fp.write(_(" the rank of\n\n")) + fp.write(_(" \"Commodore Emeritus\"\n\n")) + fp.write(" ") + if game.skill == SKILL_EXPERT: + fp.write(_(" Expert level\n\n")) + elif game.skill == SKILL_EMERITUS: + fp.write(_("Emeritus level\n\n")) + else: + fp.write(_(" Cheat level\n\n")) + timestring = ctime() + fp.write(_(" This day of %.6s %.4s, %.8s\n\n") % + (timestring+4, timestring+20, timestring+11)) + fp.write(_(" Your score: %d\n\n") % iscore) + fp.write(_(" Klingons per stardate: %.2f\n") % perdate) + fp.close() + +# Code from io.c begins here + +rows = linecount = 0 # for paging +stdscr = None +fullscreen_window = None +srscan_window = None +report_window = None +status_window = None +lrscan_window = None +message_window = None +prompt_window = None + +def outro(): + "wrap up, either normally or due to signal" + if game.options & OPTION_CURSES: + #clear() + #curs_set(1) + #refresh() + #resetterm() + #echo() + curses.endwin() + stdout.write('\n') + if logfp: + logfp.close() + +def iostart(): + global stdscr + #setlocale(LC_ALL, "") + #bindtextdomain(PACKAGE, LOCALEDIR) + #textdomain(PACKAGE) + if atexit.register(outro): + sys.stderr.write("Unable to register outro(), exiting...\n") + os.exit(1) + if not (game.options & OPTION_CURSES): + ln_env = os.getenv("LINES") + if ln_env: + rows = ln_env + else: + rows = 25 + else: + stdscr = curses.initscr() + stdscr.keypad(True) + #saveterm() + curses.nonl() + curses.cbreak() + curses.start_color() + curses.init_pair(curses.COLOR_BLACK, curses.COLOR_BLACK, curses.COLOR_BLACK) + curses.init_pair(curses.COLOR_GREEN, curses.COLOR_GREEN, curses.COLOR_BLACK) + curses.init_pair(curses.COLOR_RED, curses.COLOR_RED, curses.COLOR_BLACK) + curses.init_pair(curses.COLOR_CYAN, curses.COLOR_CYAN, curses.COLOR_BLACK) + curses.init_pair(curses.COLOR_WHITE, curses.COLOR_WHITE, curses.COLOR_BLACK) + curses.init_pair(curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, curses.COLOR_BLACK) + curses.init_pair(curses.COLOR_BLUE, curses.COLOR_BLUE, curses.COLOR_BLACK) + curses.init_pair(curses.COLOR_YELLOW, curses.COLOR_YELLOW, curses.COLOR_BLACK) + #noecho() + global fullscreen_window, srscan_window, report_window, status_window + global lrscan_window, message_window, prompt_window + fullscreen_window = stdscr + srscan_window = curses.newwin(12, 25, 0, 0) + report_window = curses.newwin(11, 0, 1, 25) + status_window = curses.newwin(10, 0, 1, 39) + lrscan_window = curses.newwin(5, 0, 0, 64) + message_window = curses.newwin(0, 0, 12, 0) + prompt_window = curses.newwin(1, 0, rows-2, 0) + message_window.scrollok(True) + setwnd(fullscreen_window) + textcolor(DEFAULT) + + +def waitfor(): + "wait for user action -- OK to do nothing if on a TTY" + if game.options & OPTION_CURSES: + stsdcr.getch() + +def announce(): + skip(1) + if game.skill > SKILL_FAIR: + prouts(_("[ANOUNCEMENT ARRIVING...]")) + else: + prouts(_("[IMPORTANT ANNOUNCEMENT ARRIVING -- PRESS ENTER TO CONTINUE]")) + skip(1) + +def pause_game(): + if game.skill > SKILL_FAIR: + prompt = _("[CONTINUE?]") + else: + prompt = _("[PRESS ENTER TO CONTINUE]") + + if game.options & OPTION_CURSES: + drawmaps(0) + setwnd(prompt_window) + prompt_window.wclear() + prompt_window.addstr(prompt) + prompt_window.getstr() + prompt_window.clear() + prompt_window.refresh() + setwnd(message_window) + else: + global linecount + stdout.write('\n') + proutn(prompt) + raw_input() + for j in range(0, rows): + stdout.write('\n') + linecount = 0 + +def skip(i): + "Skip i lines. Pause game if this would cause a scrolling event." + while dummy in range(i): + if game.options & OPTION_CURSES: + (y, x) = curwnd.getyx() + (my, mx) = curwnd.getmaxyx() + if curwnd == message_window and y >= my - 3: + pause_game() + clrscr() + else: + proutn("\n") + else: + global linecount + linecount += 1 + if linecount >= rows: + pause_game() + else: + stdout.write('\n') + +def proutn(line): + "Utter a line with no following line feed." + if game.options & OPTION_CURSES: + curwnd.addstr(line) + curwnd.refresh() + else: + stdout.write(line) + +def prout(line): + proutn(line) + skip(1) + +def prouts(line): + "print slowly!" + for c in line: + curses.delay_output(30) + proutn(c) + if game.options & OPTION_CURSES: + wrefresh(curwnd) + else: + sys.stdout.flush() + curses.delay_output(300) + +def cgetline(line, max): + "Get a line of input." + if game.options & OPTION_CURSES: + line = curwnd.getstr() + "\n" + curwnd.refresh() + else: + if replayfp and not replayfp.closed: + line = replayfp.readline() + else: + sys.stdin.readline() + if logfp: + logfp.write(line) + +def setwnd(wnd): + "Change windows -- OK for this to be a no-op in tty mode." + if game.options & OPTION_CURSES: + curwnd = wnd + curses.curs_set(wnd == fullscreen_window or wnd == message_window or wnd == prompt_window) + +def clreol(): + "Clear to end of line -- can be a no-op in tty mode" + if game.options & OPTION_CURSES: + wclrtoeol(curwnd) + wrefresh(curwnd) + +def clrscr(): + "Clear screen -- can be a no-op in tty mode." + global linecount + if game.options & OPTION_CURSES: + curwnd.clear() + curwnd.move(0, 0) + curwnd.refresh() + linecount = 0 + +def textcolor(color): + "Set the current text color" + if game.options & OPTION_CURSES: + if color == DEFAULT: + curwnd.attrset(0) + elif color == BLACK: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLACK)) + elif color == BLUE: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLUE)) + elif color == GREEN: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_GREEN)) + elif color == CYAN: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_CYAN)) + elif color == RED: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_RED)) + elif color == MAGENTA: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_MAGENTA)) + elif color == BROWN: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_YELLOW)) + elif color == LIGHTGRAY: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_WHITE)) + elif color == DARKGRAY: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLACK) | curses.A_BOLD) + elif color == LIGHTBLUE: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_BLUE) | curses.A_BOLD) + elif color == LIGHTGREEN: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_GREEN) | curses.A_BOLD) + elif color == LIGHTCYAN: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_CYAN) | curses.A_BOLD) + elif color == LIGHTRED: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_RED) | curses.A_BOLD) + elif color == LIGHTMAGENTA: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_MAGENTA) | curses.A_BOLD) + elif color == YELLOW: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_YELLOW) | curses.A_BOLD) + elif color == WHITE: + curwnd.attron(curses.COLOR_PAIR(curses.COLOR_WHITE) | curses.A_BOLD) + +def highvideo(): + "Set highlight video, if this is reasonable." + if game.options & OPTION_CURSES: + curwnd.attron(curses.A_REVERSE) + +def commandhook(cmd, before): + pass + +# +# Things past this point have policy implications. +# + +def drawmaps(mode): + "Hook to be called after moving to redraw maps." + if game.options & OPTION_CURSES: + if mode == 1: + sensor() + setwnd(srscan_window) + curwnd.move(0, 0) + srscan() + if mode != 2: + setwnd(status_window) + status_window.clear() + status_window.move(0, 0) + setwnd(report_window) + report_window.clear() + report_window.move(0, 0) + status(0) + setwnd(lrscan_window) + lrscan_window.clear() + lrscan_window.move(0, 0) + lrscan() + +def put_srscan_sym(w, sym): + "Emit symbol for short-range scan." + srscan_window.move(w.x+1, w.y*2+2) + srscan_window.addch(sym) + srscan_window.refresh() + +def boom(w): + "Enemy fall down, go boom." + if game.options & OPTION_CURSES: + drawmaps(2) + setwnd(srscan_window) + srscan_window.attron(curses.A_REVERSE) + put_srscan_sym(w, game.quad[w.x][w.y]) + #sound(500) + #delay(1000) + #nosound() + srscan_window.attroff(curses.A_REVERSE) + put_srscan_sym(w, game.quad[w.x][w.y]) + curses.delay_output(500) + setwnd(message_window) + +def warble(): + "Sound and visual effects for teleportation." + if game.options & OPTION_CURSES: + drawmaps(2) + setwnd(message_window) + #sound(50) + prouts(" . . . . . ") + if game.options & OPTION_CURSES: + #curses.delay_output(1000) + #nosound() + pass + +def tracktorpedo(w, l, i, n, iquad): + "Torpedo-track animation." + if not game.options & OPTION_CURSES: + if l == 1: + if n != 1: + skip(1) + proutn(_("Track for torpedo number %d- ") % i) + else: + skip(1) + proutn(_("Torpedo track- ")) + elif l==4 or l==9: + skip(1) + proutn("%d - %d " % (w.x, w.y)) + else: + if not damaged(DSRSENS) or game.condition=="docked": + if i != 1 and l == 1: + drawmaps(2) + curses.delay_output(400) + if (iquad==IHDOT) or (iquad==IHBLANK): + put_srscan_sym(w, '+') + #sound(l*10) + #curses.delay_output(100) + #nosound() + put_srscan_sym(w, iquad) + else: + curwnd.attron(curses.A_REVERSE) + put_srscan_sym(w, iquad) + #sound(500) + #curses.delay_output(1000) + #nosound() + curwnd.attroff(curses.A_REVERSE) + put_srscan_sym(w, iquad) + else: + proutn("%d - %d " % (w.x, w.y)) + +def makechart(): + "Display the current galaxy chart." + if game.options & OPTION_CURSES: + setwnd(message_window) + message_window.clear() + chart() + if game.options & OPTION_TTY: + skip(1) + +NSYM = 14 + +def prstat(txt, data): + proutn(txt) + if game.options & OPTION_CURSES: + skip(1) + setwnd(status_window) + else: + proutn(" " * NSYM - len(tx)) + vproutn(data) + skip(1) + if game.options & OPTION_CURSES: + setwnd(report_window) + +# Code from moving.c begins here + +def imove(novapush): + # movement execution for warp, impulse, supernova, and tractor-beam events + w = coord(); final = coord() + trbeam = False + + def no_quad_change(): + # No quadrant change -- compute new avg enemy distances + game.quad[game.sector.x][game.sector.y] = game.ship + if game.nenhere: + for m in range(1, game.nenhere+1): + finald = distance(w, game.ks[m]) + game.kavgd[m] = 0.5 * (finald+game.kdist[m]) + game.kdist[m] = finald + sortklings() + if not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + attack(False) + for m in range(1, game.nenhere+1): + game.kavgd[m] = game.kdist[m] + newcnd() + drawmaps(0) + setwnd(message_window) + + w.x = w.y = 0 + if game.inorbit: + prout(_("Helmsman Sulu- \"Leaving standard orbit.\"")) + game.inorbit = False + + angle = ((15.0 - game.direc) * 0.5235988) + deltax = -math.sin(angle) + deltay = math.cos(angle) + if math.fabs(deltax) > math.fabs(deltay): + bigger = math.fabs(deltax) + else: + bigger = math.fabs(deltay) + + deltay /= bigger + deltax /= bigger + + # If tractor beam is to occur, don't move full distance + if game.state.date+game.optime >= scheduled(FTBEAM): + trbeam = True + game.condition = "red" + game.dist = game.dist*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1 + game.optime = scheduled(FTBEAM) - game.state.date + 1e-5 + # Move within the quadrant + game.quad[game.sector.x][game.sector.y] = IHDOT + x = game.sector.x + y = game.sector.y + n = 10.0*game.dist*bigger+0.5 + + if n > 0: + for m in range(1, n+1): + x += deltax + y += deltay + w.x = x + 0.5 + w.y = y + 0.5 + if not VALID_SECTOR(w.x, w.y): + # Leaving quadrant -- allow final enemy attack + # Don't do it if being pushed by Nova + if game.nenhere != 0 and not novapush: + newcnd() + for m in range(1, game.nenhere+1): + finald = distance(w, game.ks[m]) + game.kavgd[m] = 0.5 * (finald + game.kdist[m]) + # + # Stas Sergeev added the condition + # that attacks only happen if Klingons + # are present and your skill is good. + # + if game.skill > SKILL_GOOD and game.klhere > 0 and not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + attack(False) + if game.alldone: + return + # compute final position -- new quadrant and sector + x = QUADSIZE*(game.quadrant.x-1)+game.sector.x + y = QUADSIZE*(game.quadrant.y-1)+game.sector.y + w.x = x+10.0*game.dist*bigger*deltax+0.5 + w.y = y+10.0*game.dist*bigger*deltay+0.5 + # check for edge of galaxy + kinks = 0 + while True: + kink = 0 + if w.x <= 0: + w.x = -w.x + 1 + kink = 1 + if w.y <= 0: + w.y = -w.y + 1 + kink = 1 + if w.x > GALSIZE*QUADSIZE: + w.x = (GALSIZE*QUADSIZE*2)+1 - w.x + kink = 1 + if w.y > GALSIZE*QUADSIZE: + w.y = (GALSIZE*QUADSIZE*2)+1 - w.y + kink = 1 + if kink: + kinks = 1 + if not kink: + break + + if kinks: + game.nkinks += 1 + if game.nkinks == 3: + # Three strikes -- you're out! + finish(FNEG3) + return + skip(1) + prout(_("YOU HAVE ATTEMPTED TO CROSS THE NEGATIVE ENERGY BARRIER")) + prout(_("AT THE EDGE OF THE GALAXY. THE THIRD TIME YOU TRY THIS,")) + prout(_("YOU WILL BE DESTROYED.")) + # Compute final position in new quadrant + if trbeam: # Don't bother if we are to be beamed + return + game.quadrant.x = (w.x+(QUADSIZE-1))/QUADSIZE + game.quadrant.y = (w.y+(QUADSIZE-1))/QUADSIZE + game.sector.x = w.x - QUADSIZE*(game.quadrant.x-1) + game.sector.y = w.y - QUADSIZE*(game.quadrant.y-1) + skip(1) + prout(_("Entering Quadrant %s.") % game.quadrant) + game.quad[game.sector.x][game.sector.y] = game.ship + newqad(False) + if game.skill>SKILL_NOVICE: + attack(False) + return + iquad = game.quad[w.x][w.y] + if iquad != IHDOT: + # object encountered in flight path + stopegy = 50.0*game.dist/game.optime + game.dist = distance(game.sector, w) / (QUADSIZE * 1.0) + if iquad in (IHT. IHK, OHC, IHS, IHR, IHQUEST): + game.sector = w + ram(False, iquad, game.sector) + final = game.sector + elif iquad == IHBLANK: + skip(1) + prouts(_("***RED ALERT! RED ALERT!")) + skip(1) + proutn("***") + crmshp() + proutn(_(" pulled into black hole at Sector %s") % w) + # + # Getting pulled into a black hole was certain + # death in Almy's original. Stas Sergeev added a + # possibility that you'll get timewarped instead. + # + n=0 + for m in range(0, NDEVICES): + if game.damage[m]>0: + n += 1 + probf=math.pow(1.4,(game.energy+game.shield)/5000.0-1.0)*math.pow(1.3,1.0/(n+1)-1.0) + if (game.options & OPTION_BLKHOLE) and Rand()>probf: + timwrp() + else: + finish(FHOLE) + return + else: + # something else + skip(1) + crmshp() + if iquad == IHWEB: + proutn(_(" encounters Tholian web at %s;") % w) + else: + proutn(_(" blocked by object at %s;") % w) + proutn(_("Emergency stop required ")) + prout(_("%2d units of energy.") % int(stopegy)) + game.energy -= stopegy + final.x = x-deltax+0.5 + final.y = y-deltay+0.5 + game.sector = final + if game.energy <= 0: + finish(FNRG) + return + # We're here! + no_quad_change() + return + game.dist = distance(game.sector, w) / (QUADSIZE * 1.0) + game.sector = w + final = game.sector + no_quad_change() + return + +def dock(verbose): + # dock our ship at a starbase + chew() + if game.condition == "docked" and verbose: + prout(_("Already docked.")) + return + if game.inorbit: + prout(_("You must first leave standard orbit.")) + return + if not is_valid(game.base) or abs(game.sector.x-game.base.x) > 1 or abs(game.sector.y-game.base.y) > 1: + crmshp() + prout(_(" not adjacent to base.")) + return + game.condition = "docked" + if "verbose": + prout(_("Docked.")) + game.ididit = True + if game.energy < game.inenrg: + game.energy = game.inenrg + game.shield = game.inshld + game.torps = game.intorps + game.lsupres = game.inlsr + game.state.crew = FULLCREW + if not damaged(DRADIO) and \ + ((is_scheduled(FCDBAS) or game.isatb == 1) and not game.iseenit): + # get attack report from base + prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\"")) + attackreport(False) + game.iseenit = True + +# +# This program originally required input in terms of a (clock) +# direction and distance. Somewhere in history, it was changed to +# cartesian coordinates. So we need to convert. Probably +# "manual" input should still be done this way -- it's a real +# pain if the computer isn't working! Manual mode is still confusing +# because it involves giving x and y motions, yet the coordinates +# are always displayed y - x, where +y is downward! +# + +def getcd(isprobe, akey): + # get course and distance + irowq=game.quadrant.x; icolq=game.quadrant.y; key=0 + navmode = "unspecified" + itemp = "curt" + incr = coord() + iprompt = False + + # Get course direction and distance. If user types bad values, return + # with DIREC = -1.0. + game.direc = -1.0 + + if game.landed and not isprobe: + prout(_("Dummy! You can't leave standard orbit until you")) + proutn(_("are back aboard the ship.")) + chew() + return + while navmode == "unspecified": + if damaged(DNAVSYS): + if isprobe: + prout(_("Computer damaged; manual navigation only")) + else: + prout(_("Computer damaged; manual movement only")) + chew() + navmode = "manual" + key = IHEOL + break + if isprobe and akey != -1: + # For probe launch, use pre-scanned value first time + key = akey + akey = -1 + else: + key = scan() + + if key == IHEOL: + proutn(_("Manual or automatic- ")) + iprompt = True + chew() + elif key == IHALPHA: + if isit("manual"): + navmode = "manual" + key = scan() + break + elif isit("automatic"): + navmode = "automatic" + key = scan() + break + else: + huh() + chew() + return + else: # numeric + if isprobe: + prout(_("(Manual navigation assumed.)")) + else: + prout(_("(Manual movement assumed.)")) + navmode = "manual" + break + + if navmode == "automatic": + while key == IHEOL: + if isprobe: + proutn(_("Target quadrant or quadrant§or- ")) + else: + proutn(_("Destination sector or quadrant§or- ")) + chew() + iprompt = True + key = scan() + + if key != IHREAL: + huh() + return + xi = aaitem + key = scan() + if key != IHREAL: + huh() + return + xj = aaitem + key = scan() + if key == IHREAL: + # both quadrant and sector specified + xk = aaitem + key = scan() + if key != IHREAL: + huh() + return + xl = aaitem + + irowq = xi + 0.5 + icolq = xj + 0.5 + incr.y = xk + 0.5 + incr.x = xl + 0.5 + else: + if isprobe: + # only quadrant specified -- go to center of dest quad + irowq = xi + 0.5 + icolq = xj + 0.5 + incr.y = incr.x = 5 + else: + incr.y = xi + 0.5 + incr.x = xj + 0.5 + itemp = "normal" + if not VALID_QUADRANT(icolq,irowq) or not VALID_SECTOR(incr.x,incr.y): + huh() + return + skip(1) + if not isprobe: + if itemp > "curt": + if iprompt: + prout(_("Helmsman Sulu- \"Course locked in for Sector %s.\"") % incr) + else: + prout(_("Ensign Chekov- \"Course laid in, Captain.\"")) + deltax = icolq - game.quadrant.y + 0.1*(incr.x-game.sector.y) + deltay = game.quadrant.x - irowq + 0.1*(game.sector.x-incr.y) + else: # manual + while key == IHEOL: + proutn(_("X and Y displacements- ")) + chew() + iprompt = True + key = scan() + itemp = "verbose" + if key != IHREAL: + huh() + return + deltax = aaitem + key = scan() + if key != IHREAL: + huh() + return + deltay = aaitem + # Check for zero movement + if deltax == 0 and deltay == 0: + chew() + return + if itemp == "verbose" and not isprobe: + skip(1) + prout(_("Helmsman Sulu- \"Aye, Sir.\"")) + game.dist = math.sqrt(deltax*deltax + deltay*deltay) + game.direc = math.atan2(deltax, deltay)*1.90985932 + if game.direc < 0.0: + game.direc += 12.0 + chew() + return + +def impulse(): + # move under impulse power + game.ididit = False + if damaged(DIMPULS): + chew() + skip(1) + prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\"")) + return + if game.energy > 30.0: + getcd(False, 0) + if game.direc == -1.0: + return + power = 20.0 + 100.0*game.dist + else: + power = 30.0 + + if power >= game.energy: + # Insufficient power for trip + skip(1) + prout(_("First Officer Spock- \"Captain, the impulse engines")) + prout(_("require 20.0 units to engage, plus 100.0 units per")) + if game.energy > 30: + proutn(_("quadrant. We can go, therefore, a maximum of %d") % + int(0.01 * (game.energy-20.0)-0.05)) + prout(_(" quadrants.\"")) + else: + prout(_("quadrant. They are, therefore, useless.\"")) + chew() + return + # Make sure enough time is left for the trip + game.optime = game.dist/0.095 + if game.optime >= game.state.remtime: + prout(_("First Officer Spock- \"Captain, our speed under impulse")) + prout(_("power is only 0.95 sectors per stardate. Are you sure")) + proutn(_("we dare spend the time?\" ")) + if ja() == False: + return + # Activate impulse engines and pay the cost + imove(False) + game.ididit = True + if game.alldone: + return + power = 20.0 + 100.0*game.dist + game.energy -= power + game.optime = game.dist/0.095 + if game.energy <= 0: + finish(FNRG) + return + +def warp(timewarp): + # move under warp drive + blooey = False; twarp = False + if not timewarp: # Not WARPX entry + game.ididit = False + if game.damage[DWARPEN] > 10.0: + chew() + skip(1) + prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\"")) + return + if damaged(DWARPEN) and game.warpfac > 4.0: + chew() + skip(1) + prout(_("Engineer Scott- \"Sorry, Captain. Until this damage")) + prout(_(" is repaired, I can only give you warp 4.\"")) + return + + # Read in course and distance + getcd(False, 0) + if game.direc == -1.0: + return + + # Make sure starship has enough energy for the trip + power = (game.dist+0.05)*game.warpfac*game.warpfac*game.warpfac*(game.shldup+1) + if power >= game.energy: + # Insufficient power for trip + game.ididit = False + skip(1) + prout(_("Engineering to bridge--")) + if not game.shldup or 0.5*power > game.energy: + iwarp = math.pow((game.energy/(game.dist+0.05)), 0.333333333) + if iwarp <= 0: + prout(_("We can't do it, Captain. We don't have enough energy.")) + else: + proutn(_("We don't have enough energy, but we could do it at warp %d") % iwarp) + if game.shldup: + prout(",") + prout(_("if you'll lower the shields.")) + else: + prout(".") + else: + prout(_("We haven't the energy to go that far with the shields up.")) + return + + # Make sure enough time is left for the trip + game.optime = 10.0*game.dist/game.wfacsq + if game.optime >= 0.8*game.state.remtime: + skip(1) + prout(_("First Officer Spock- \"Captain, I compute that such")) + proutn(_(" a trip would require approximately %2.0f") % + (100.0*game.optime/game.state.remtime)) + prout(_(" percent of our")) + proutn(_(" remaining time. Are you sure this is wise?\" ")) + if ja() == False: + game.ididit = False + game.optime=0 + return + # Entry WARPX + if game.warpfac > 6.0: + # Decide if engine damage will occur + prob = game.dist*(6.0-game.warpfac)*(6.0-game.warpfac)/66.666666666 + if prob > Rand(): + blooey = True + game.dist = Rand()*game.dist + # Decide if time warp will occur + if 0.5*game.dist*math.pow(7.0,game.warpfac-10.0) > Rand(): + twarp = True + if idebug and game.warpfac==10 and not twarp: + blooey = False + proutn("=== Force time warp? ") + if ja() == True: + twarp = True + if blooey or twarp: + # If time warp or engine damage, check path + # If it is obstructed, don't do warp or damage + angle = ((15.0-game.direc)*0.5235998) + deltax = -math.sin(angle) + deltay = math.cos(angle) + if math.fabs(deltax) > math.fabs(deltay): + bigger = math.fabs(deltax) + else: + bigger = math.fabs(deltay) + + deltax /= bigger + deltay /= bigger + n = 10.0 * game.dist * bigger +0.5 + x = game.sector.x + y = game.sector.y + for l in range(1, n+1): + x += deltax + ix = x + 0.5 + y += deltay + iy = y +0.5 + if not VALID_SECTOR(ix, iy): + break + if game.quad[ix][iy] != IHDOT: + blooey = False + twarp = False + + + # Activate Warp Engines and pay the cost + imove(False) + if game.alldone: + return + game.energy -= game.dist*game.warpfac*game.warpfac*game.warpfac*(game.shldup+1) + if game.energy <= 0: + finish(FNRG) + game.optime = 10.0*game.dist/game.wfacsq + if twarp: + timwrp() + if blooey: + game.damage[DWARPEN] = game.damfac*(3.0*Rand()+1.0) + skip(1) + prout(_("Engineering to bridge--")) + prout(_(" Scott here. The warp engines are damaged.")) + prout(_(" We'll have to reduce speed to warp 4.")) + game.ididit = True + return + +def setwarp(): + # change the warp factor + while True: + key=scan() + if key != IHEOL: + break + chew() + proutn(_("Warp factor- ")) + chew() + if key != IHREAL: + huh() + return + if game.damage[DWARPEN] > 10.0: + prout(_("Warp engines inoperative.")) + return + if damaged(DWARPEN) and aaitem > 4.0: + prout(_("Engineer Scott- \"I'm doing my best, Captain,")) + prout(_(" but right now we can only go warp 4.\"")) + return + if aaitem > 10.0: + prout(_("Helmsman Sulu- \"Our top speed is warp 10, Captain.\"")) + return + if aaitem < 1.0: + prout(_("Helmsman Sulu- \"We can't go below warp 1, Captain.\"")) + return + oldfac = game.warpfac + game.warpfac = aaitem + game.wfacsq=game.warpfac*game.warpfac + if game.warpfac <= oldfac or game.warpfac <= 6.0: + prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") % + int(game.warpfac)) + return + if game.warpfac < 8.00: + prout(_("Engineer Scott- \"Aye, but our maximum safe speed is warp 6.\"")) + return + if game.warpfac == 10.0: + prout(_("Engineer Scott- \"Aye, Captain, we'll try it.\"")) + return + prout(_("Engineer Scott- \"Aye, Captain, but our engines may not take it.\"")) + return + +def atover(igrab): + # cope with being tossed out of quadrant by supernova or yanked by beam + + chew() + # is captain on planet? + if game.landed: + if damaged(DTRANSP): + finish(FPNOVA) + return + prout(_("Scotty rushes to the transporter controls.")) + if game.shldup: + prout(_("But with the shields up it's hopeless.")) + finish(FPNOVA) + prouts(_("His desperate attempt to rescue you . . .")) + if Rand() <= 0.5: + prout(_("fails.")) + finish(FPNOVA) + return + prout(_("SUCCEEDS!")) + if game.imine: + game.imine = False + proutn(_("The crystals mined were ")) + if Rand() <= 0.25: + prout(_("lost.")) + else: + prout(_("saved.")) + game.icrystl = True + if igrab: + return + + # Check to see if captain in shuttle craft + if game.icraft: + finish(FSTRACTOR) + if game.alldone: + return + + # Inform captain of attempt to reach safety + skip(1) + while True: + if game.justin: + prouts(_("***RED ALERT! RED ALERT!")) + skip(1) + proutn(_("The ")) + crmshp() + prout(_(" has stopped in a quadrant containing")) + prouts(_(" a supernova.")) + skip(2) + proutn(_("***Emergency automatic override attempts to hurl ")) + crmshp() + skip(1) + prout(_("safely out of quadrant.")) + if not damaged(DRADIO): + game.state.galaxy[game.quadrant.x][game.quadrant.y].charted = True + # Try to use warp engines + if damaged(DWARPEN): + skip(1) + prout(_("Warp engines damaged.")) + finish(FSNOVAED) + return + game.warpfac = 6.0+2.0*Rand() + game.wfacsq = game.warpfac * game.warpfac + prout(_("Warp factor set to %d") % int(game.warpfac)) + power = 0.75*game.energy + game.dist = power/(game.warpfac*game.warpfac*game.warpfac*(game.shldup+1)) + distreq = 1.4142+Rand() + if distreq < game.dist: + game.dist = distreq + game.optime = 10.0*game.dist/game.wfacsq + game.direc = 12.0*Rand() # How dumb! + game.justin = False + game.inorbit = False + warp(True) + if not game.justin: + # This is bad news, we didn't leave quadrant. + if game.alldone: + return + skip(1) + prout(_("Insufficient energy to leave quadrant.")) + finish(FSNOVAED) + return + # Repeat if another snova + if not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + break + if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + finish(FWON) # Snova killed remaining enemy. + +def timwrp(): + # let's do the time warp again + prout(_("***TIME WARP ENTERED.")) + if game.state.snap and Rand() < 0.5: + # Go back in time + prout(_("You are traveling backwards in time %d stardates.") % + int(game.state.date-game.snapsht.date)) + game.state = game.snapsht + game.state.snap = False + if game.state.remcom: + schedule(FTBEAM, expran(game.intime/game.state.remcom)) + schedule(FBATTAK, expran(0.3*game.intime)) + schedule(FSNOVA, expran(0.5*game.intime)) + # next snapshot will be sooner + schedule(FSNAP, expran(0.25*game.state.remtime)) + + if game.state.nscrem: + schedule(FSCMOVE, 0.2777) + game.isatb = 0 + unschedule(FCDBAS) + unschedule(FSCDBAS) + invalidate(game.battle) + + # Make sure Galileo is consistant -- Snapshot may have been taken + # when on planet, which would give us two Galileos! + gotit = False + for l in range(game.inplan): + if game.state.planets[l].known == "shuttle_down": + gotit = True + if game.iscraft == "onship" and game.ship==IHE: + prout(_("Chekov- \"Security reports the Galileo has disappeared, Sir!")) + game.iscraft = "offship" + # Likewise, if in the original time the Galileo was abandoned, but + # was on ship earlier, it would have vanished -- let's restore it. + if game.iscraft == "offship" and not gotit and game.damage[DSHUTTL] >= 0.0: + prout(_("Checkov- \"Security reports the Galileo has reappeared in the dock!\"")) + game.iscraft = "onship" + # +# * There used to be code to do the actual reconstrction here, +# * but the starchart is now part of the snapshotted galaxy state. +# + prout(_("Spock has reconstructed a correct star chart from memory")) + else: + # Go forward in time + game.optime = -0.5*game.intime*math.log(Rand()) + prout(_("You are traveling forward in time %d stardates.") % int(game.optime)) + # cheat to make sure no tractor beams occur during time warp + postpone(FTBEAM, game.optime) + game.damage[DRADIO] += game.optime + newqad(False) + events() # Stas Sergeev added this -- do pending events + +def probe(): + # launch deep-space probe + # New code to launch a deep space probe + if game.nprobes == 0: + chew() + skip(1) + if game.ship == IHE: + prout(_("Engineer Scott- \"We have no more deep space probes, Sir.\"")) + else: + prout(_("Ye Faerie Queene has no deep space probes.")) + return + if damaged(DDSP): + chew() + skip(1) + prout(_("Engineer Scott- \"The probe launcher is damaged, Sir.\"")) + return + if is_scheduled(FDSPROB): + chew() + skip(1) + if damaged(DRADIO) and game.condition != "docked": + prout(_("Spock- \"Records show the previous probe has not yet")) + prout(_(" reached its destination.\"")) + else: + prout(_("Uhura- \"The previous probe is still reporting data, Sir.\"")) + return + key = scan() + + if key == IHEOL: + # slow mode, so let Kirk know how many probes there are left + if game.nprobes == 1: + prout(_("1 probe left.")) + else: + prout(_("%d probes left") % game.nprobes) + proutn(_("Are you sure you want to fire a probe? ")) + if ja() == False: + return + + game.isarmed = False + if key == IHALPHA and citem == "armed": + game.isarmed = True + key = scan() + elif key == IHEOL: + proutn(_("Arm NOVAMAX warhead? ")) + game.isarmed = ja() + getcd(True, key) + if game.direc == -1.0: + return + game.nprobes -= 1 + angle = ((15.0 - game.direc) * 0.5235988) + game.probeinx = -math.sin(angle) + game.probeiny = math.cos(angle) + if math.fabs(game.probeinx) > math.fabs(game.probeiny): + bigger = math.fabs(game.probeinx) + else: + bigger = math.fabs(game.probeiny) + + game.probeiny /= bigger + game.probeinx /= bigger + game.proben = 10.0*game.dist*bigger +0.5 + game.probex = game.quadrant.x*QUADSIZE + game.sector.x - 1 # We will use better packing than original + game.probey = game.quadrant.y*QUADSIZE + game.sector.y - 1 + game.probec = game.quadrant + schedule(FDSPROB, 0.01) # Time to move one sector + prout(_("Ensign Chekov- \"The deep space probe is launched, Captain.\"")) + game.ididit = True + return + +# Here's how the mayday code works: +# +# First, the closest starbase is selected. If there is a a starbase +# in your own quadrant, you are in good shape. This distance takes +# quadrant distances into account only. +# +# A magic number is computed based on the distance which acts as the +# probability that you will be rematerialized. You get three tries. +# +# When it is determined that you should be able to be rematerialized +# (i.e., when the probability thing mentioned above comes up +# positive), you are put into that quadrant (anywhere). Then, we try +# to see if there is a spot adjacent to the star- base. If not, you +# can't be rematerialized!!! Otherwise, it drops you there. It only +# tries five times to find a spot to drop you. After that, it's your +# problem. + +def mayday(): + # yell for help from nearest starbase + # There's more than one way to move in this game! + line = 0 + + chew() + # Test for conditions which prevent calling for help + if game.condition == "docked": + prout(_("Lt. Uhura- \"But Captain, we're already docked.\"")) + return + if damaged(DRADIO): + prout(_("Subspace radio damaged.")) + return + if game.state.rembase==0: + prout(_("Lt. Uhura- \"Captain, I'm not getting any response from Starbase.\"")) + return + if game.landed: + proutn(_("You must be aboard the ")) + crmshp() + prout(".") + return + # OK -- call for help from nearest starbase + game.nhelp += 1 + if game.base.x!=0: + # There's one in this quadrant + ddist = distance(game.base, game.sector) + else: + ddist = FOREVER + for m in range(1, game.state.rembase+1): + xdist = QUADSIZE * distance(game.state.baseq[m], game.quadrant) + if xdist < ddist: + ddist = xdist + line = m + # Since starbase not in quadrant, set up new quadrant + game.quadrant = game.state.baseq[line] + newqad(True) + # dematerialize starship + game.quad[game.sector.x][game.sector.y]=IHDOT + proutn(_("Starbase in Quadrant %s responds--") % game.quadrant) + crmshp() + prout(_(" dematerializes.")) + game.sector.x=0 + for m in range(1, 5+1): + ix = game.base.x+3.0*Rand()-1 + iy = game.base.y+3.0*Rand()-1 + if VALID_SECTOR(ix,iy) and game.quad[ix][iy]==IHDOT: + # found one -- finish up + game.sector.x=ix + game.sector.y=iy + break + if not is_valid(game.sector): + prout(_("You have been lost in space...")) + finish(FMATERIALIZE) + return + # Give starbase three chances to rematerialize starship + probf = math.pow((1.0 - math.pow(0.98,ddist)), 0.33333333) + for m in range(1, 3+1): + if m == 1: proutn(_("1st")) + elif m == 2: proutn(_("2nd")) + elif m == 3: proutn(_("3rd")) + proutn(_(" attempt to re-materialize ")) + crmshp() + game.quad[ix][iy]=(IHMATER0,IHMATER1,IHMATER2)[m-1] + textcolor(RED) + warble() + if Rand() > probf: + break + prout(_("fails.")) + curses.delay_output(500) + textcolor(DEFAULT) + if m > 3: + game.quad[ix][iy]=IHQUEST + game.alive = False + drawmaps(1) + setwnd(message_window) + finish(FMATERIALIZE) + return + game.quad[ix][iy]=game.ship + textcolor(GREEN) + prout(_("succeeds.")) + textcolor(DEFAULT) + dock(False) + skip(1) + prout(_("Lt. Uhura- \"Captain, we made it!\"")) + +# Abandon Ship (the BSD-Trek description) +# +# The ship is abandoned. If your current ship is the Faire +# Queene, or if your shuttlecraft is dead, you're out of +# luck. You need the shuttlecraft in order for the captain +# (that's you!!) to escape. +# +# Your crew can beam to an inhabited starsystem in the +# quadrant, if there is one and if the transporter is working. +# If there is no inhabited starsystem, or if the transporter +# is out, they are left to die in outer space. +# +# If there are no starbases left, you are captured by the +# Klingons, who torture you mercilessly. However, if there +# is at least one starbase, you are returned to the +# Federation in a prisoner of war exchange. Of course, this +# can't happen unless you have taken some prisoners. + +def abandon(): + # abandon ship + chew() + if game.condition=="docked": + if game.ship!=IHE: + prout(_("You cannot abandon Ye Faerie Queene.")) + return + else: + # Must take shuttle craft to exit + if game.damage[DSHUTTL]==-1: + prout(_("Ye Faerie Queene has no shuttle craft.")) + return + if game.damage[DSHUTTL]<0: + prout(_("Shuttle craft now serving Big Macs.")) + return + if game.damage[DSHUTTL]>0: + prout(_("Shuttle craft damaged.")) + return + if game.landed: + prout(_("You must be aboard the ship.")) + return + if game.iscraft != "onship": + prout(_("Shuttle craft not currently available.")) + return + # Print abandon ship messages + skip(1) + prouts(_("***ABANDON SHIP! ABANDON SHIP!")) + skip(1) + prouts(_("***ALL HANDS ABANDON SHIP!")) + skip(2) + prout(_("Captain and crew escape in shuttle craft.")) + if game.state.rembase==0: + # Oops! no place to go... + finish(FABANDN) + return + q = game.state.galaxy[game.quadrant.x][game.quadrant.y] + # Dispose of crew + if not (game.options & OPTION_WORLDS) and not damaged(DTRANSP): + prout(_("Remainder of ship's complement beam down")) + prout(_("to nearest habitable planet.")) + elif q.planet != NOPLANET and not damaged(DTRANSP): + prout(_("Remainder of ship's complement beam down to %s.") % + q.planet) + else: + prout(_("Entire crew of %d left to die in outer space.") % + game.state.crew) + game.casual += game.state.crew + game.abandoned += game.state.crew + + # If at least one base left, give 'em the Faerie Queene + skip(1) + game.icrystl = False # crystals are lost + game.nprobes = 0 # No probes + prout(_("You are captured by Klingons and released to")) + prout(_("the Federation in a prisoner-of-war exchange.")) + nb = Rand()*game.state.rembase+1 + # Set up quadrant and position FQ adjacient to base + if not same(game.quadrant, game.state.baseq[nb]): + game.quadrant = game.state.baseq[nb] + game.sector.x = game.sector.y = 5 + newqad(True) + while True: + # position next to base by trial and error + game.quad[game.sector.x][game.sector.y] = IHDOT + for l in range(1, QUADSIZE+1): + game.sector.x = 3.0*Rand() - 1.0 + game.base.x + game.sector.y = 3.0*Rand() - 1.0 + game.base.y + if VALID_SECTOR(game.sector.x, game.sector.y) and \ + game.quad[game.sector.x][game.sector.y] == IHDOT: + break + if l < QUADSIZE+1: + break # found a spot + game.sector.x=QUADSIZE/2 + game.sector.y=QUADSIZE/2 + newqad(True) + # Get new commission + game.quad[game.sector.x][game.sector.y] = game.ship = IHF + game.state.crew = FULLCREW + prout(_("Starfleet puts you in command of another ship,")) + prout(_("the Faerie Queene, which is antiquated but,")) + prout(_("still useable.")) + if game.icrystl: + prout(_("The dilithium crystals have been moved.")) + game.imine = False + game.iscraft = "offship" # Galileo disappears + # Resupply ship + game.condition="docked" + for l in range(0, NDEVICES): + game.damage[l] = 0.0 + game.damage[DSHUTTL] = -1 + game.energy = game.inenrg = 3000.0 + game.shield = game.inshld = 1250.0 + game.torps = game.intorps = 6 + game.lsupres=game.inlsr=3.0 + game.shldup=False + game.warpfac=5.0 + game.wfacsq=25.0 + return + +# Code from planets.c begins here. + +def consumeTime(): + # abort a lengthy operation if an event interrupts it + game.ididit = True + events() + if game.alldone or game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova or game.justin: + return True + return False + +def survey(): + # report on (uninhabited) planets in the galaxy + iknow = False + skip(1) + chew() + prout(_("Spock- \"Planet report follows, Captain.\"")) + skip(1) + for i in range(game.inplan): + if game.state.planets[i].pclass == destroyed: + continue + if (game.state.planets[i].known != "unknown" \ + and game.state.planets[i].inhabited == UNINHABITED) \ + or idebug: + iknow = True + if idebug and game.state.planets[i].known=="unknown": + proutn("(Unknown) ") + proutn(cramlc(quadrant, game.state.planets[i].w)) + proutn(_(" class ")) + proutn(game.state.planets[i].pclass) + proutn(" ") + if game.state.planets[i].crystals != present: + proutn(_("no ")) + prout(_("dilithium crystals present.")) + if game.state.planets[i].known=="shuttle_down": + prout(_(" Shuttle Craft Galileo on surface.")) + if not iknow: + prout(_("No information available.")) + +def orbit(): + # enter standard orbit + skip(1) + chew() + if game.inorbit: + prout(_("Already in standard orbit.")) + return + if damaged(DWARPEN) and damaged(DIMPULS): + prout(_("Both warp and impulse engines damaged.")) + return + if not is_valid(game.plnet) or abs(game.sector.x-game.plnet.x) > 1 or abs(game.sector.y-game.plnet.y) > 1: + crmshp() + prout(_(" not adjacent to planet.")) + skip(1) + return + game.optime = 0.02+0.03*Rand() + prout(_("Helmsman Sulu- \"Entering standard orbit, Sir.\"")) + newcnd() + if consumeTime(): + return + game.height = (1400.0+7200.0*Rand()) + prout(_("Sulu- \"Entered orbit at altitude %.2f kilometers.\"") % game.height) + game.inorbit = True + game.ididit = True + +def sensor(): + # examine planets in this quadrant + if damaged(DSRSENS): + if game.options & OPTION_TTY: + prout(_("Short range sensors damaged.")) + return + if not is_valid(game.plnet): + if game.options & OPTION_TTY: + prout(_("Spock- \"No planet in this quadrant, Captain.\"")) + return + if game.state.planets[game.iplnet].known == "unknown": + prout(_("Spock- \"Sensor scan for Quadrant %s-") % game.quadrant) + skip(1) + prout(_(" Planet at Sector %s is of class %s.") % + (sector,game.plnet, game.state.planets[game.iplnet])) + if game.state.planets[game.iplnet].known=="shuttle_down": + prout(_(" Sensors show Galileo still on surface.")) + proutn(_(" Readings indicate")) + if game.state.planets[game.iplnet].crystals != present: + proutn(_(" no")) + prout(_(" dilithium crystals present.\"")) + if game.state.planets[game.iplnet].known == "unknown": + game.state.planets[game.iplnet].known = "known" + +def beam(): + # use the transporter + nrgneed = 0 + chew() + skip(1) + if damaged(DTRANSP): + prout(_("Transporter damaged.")) + if not damaged(DSHUTTL) and (game.state.planets[game.iplnet].known=="shuttle_down" or game.iscraft == "onship"): + skip(1) + proutn(_("Spock- \"May I suggest the shuttle craft, Sir?\" ")) + if ja() == True: + shuttle() + return + if not game.inorbit: + crmshp() + prout(_(" not in standard orbit.")) + return + if game.shldup: + prout(_("Impossible to transport through shields.")) + return + if game.state.planets[game.iplnet].known=="unknown": + prout(_("Spock- \"Captain, we have no information on this planet")) + prout(_(" and Starfleet Regulations clearly state that in this situation")) + prout(_(" you may not go down.\"")) + return + if not game.landed and game.state.planets[game.iplnet].crystals==absent: + prout(_("Spock- \"Captain, I fail to see the logic in")) + prout(_(" exploring a planet with no dilithium crystals.")) + proutn(_(" Are you sure this is wise?\" ")) + if ja() == False: + chew() + return + if not (game.options & OPTION_PLAIN): + nrgneed = 50 * game.skill + game.height / 100.0 + if nrgneed > game.energy: + prout(_("Engineering to bridge--")) + prout(_(" Captain, we don't have enough energy for transportation.")) + return + if not game.landed and nrgneed * 2 > game.energy: + prout(_("Engineering to bridge--")) + prout(_(" Captain, we have enough energy only to transport you down to")) + prout(_(" the planet, but there wouldn't be an energy for the trip back.")) + if game.state.planets[game.iplnet].known == "shuttle_down": + prout(_(" Although the Galileo shuttle craft may still be on a surface.")) + proutn(_(" Are you sure this is wise?\" ")) + if ja() == False: + chew() + return + if game.landed: + # Coming from planet + if game.state.planets[game.iplnet].known=="shuttle_down": + proutn(_("Spock- \"Wouldn't you rather take the Galileo?\" ")) + if ja() == True: + chew() + return + prout(_("Your crew hides the Galileo to prevent capture by aliens.")) + prout(_("Landing party assembled, ready to beam up.")) + skip(1) + prout(_("Kirk whips out communicator...")) + prouts(_("BEEP BEEP BEEP")) + skip(2) + prout(_("\"Kirk to enterprise- Lock on coordinates...energize.\"")) + else: + # Going to planet + prout(_("Scotty- \"Transporter room ready, Sir.\"")) + skip(1) + prout(_("Kirk and landing party prepare to beam down to planet surface.")) + skip(1) + prout(_("Kirk- \"Energize.\"")) + game.ididit = True + skip(1) + prouts("WWHOOOIIIIIRRRRREEEE.E.E. . . . . . .") + skip(2) + if Rand() > 0.98: + prouts("BOOOIIIOOOIIOOOOIIIOIING . . .") + skip(2) + prout(_("Scotty- \"Oh my God! I've lost them.\"")) + finish(FLOST) + return + prouts(". . . . . . .E.E.EEEERRRRRIIIIIOOOHWW") + game.landed = not game.landed + game.energy -= nrgneed + skip(2) + prout(_("Transport complete.")) + if game.landed and game.state.planets[game.iplnet].known=="shuttle_down": + prout(_("The shuttle craft Galileo is here!")) + if not game.landed and game.imine: + game.icrystl = True + game.cryprob = 0.05 + game.imine = False + return + +def mine(): + # strip-mine a world for dilithium + skip(1) + chew() + if not game.landed: + prout(_("Mining party not on planet.")) + return + if game.state.planets[game.iplnet].crystals == mined: + prout(_("This planet has already been strip-mined for dilithium.")) + return + elif game.state.planets[game.iplnet].crystals == absent: + prout(_("No dilithium crystals on this planet.")) + return + if game.imine: + prout(_("You've already mined enough crystals for this trip.")) + return + if game.icrystl and game.cryprob == 0.05: + proutn(_("With all those fresh crystals aboard the ")) + crmshp() + skip(1) + prout(_("there's no reason to mine more at this time.")) + return + game.optime = (0.1+0.2*Rand())*game.state.planets[game.iplnet].pclass + if consumeTime(): + return + prout(_("Mining operation complete.")) + game.state.planets[game.iplnet].crystals = mined + game.imine = game.ididit = True + +def usecrystals(): + # use dilithium crystals + game.ididit = False + skip(1) + chew() + if not game.icrystl: + prout(_("No dilithium crystals available.")) + return + if game.energy >= 1000: + prout(_("Spock- \"Captain, Starfleet Regulations prohibit such an operation")) + prout(_(" except when Condition Yellow exists.")) + return + prout(_("Spock- \"Captain, I must warn you that loading")) + prout(_(" raw dilithium crystals into the ship's power")) + prout(_(" system may risk a severe explosion.")) + proutn(_(" Are you sure this is wise?\" ")) + if ja() == False: + chew() + return + skip(1) + prout(_("Engineering Officer Scott- \"(GULP) Aye Sir.")) + prout(_(" Mr. Spock and I will try it.\"")) + skip(1) + prout(_("Spock- \"Crystals in place, Sir.")) + prout(_(" Ready to activate circuit.\"")) + skip(1) + prouts(_("Scotty- \"Keep your fingers crossed, Sir!\"")) + skip(1) + if Rand() <= game.cryprob: + prouts(_(" \"Activating now! - - No good! It's***")) + skip(2) + prouts(_("***RED ALERT! RED A*L********************************")) + skip(1) + stars() + prouts(_("****************** KA-BOOM!!!! *******************")) + skip(1) + kaboom() + return + game.energy += 5000.0*(1.0 + 0.9*Rand()) + prouts(_(" \"Activating now! - - ")) + prout(_("The instruments")) + prout(_(" are going crazy, but I think it's")) + prout(_(" going to work!! Congratulations, Sir!\"")) + game.cryprob *= 2.0 + game.ididit = True + +def shuttle(): + # use shuttlecraft for planetary jaunt + chew() + skip(1) + if damaged(DSHUTTL): + if game.damage[DSHUTTL] == -1.0: + if game.inorbit and game.state.planets[game.iplnet].known == "shuttle_down": + prout(_("Ye Faerie Queene has no shuttle craft bay to dock it at.")) + else: + prout(_("Ye Faerie Queene had no shuttle craft.")) + elif game.damage[DSHUTTL] > 0: + prout(_("The Galileo is damaged.")) + else: # game.damage[DSHUTTL] < 0 + prout(_("Shuttle craft is now serving Big Macs.")) + return + if not game.inorbit: + crmshp() + prout(_(" not in standard orbit.")) + return + if (game.state.planets[game.iplnet].known != "shuttle_down") and game.iscraft != "onship": + prout(_("Shuttle craft not currently available.")) + return + if not game.landed and game.state.planets[game.iplnet].known=="shuttle_down": + prout(_("You will have to beam down to retrieve the shuttle craft.")) + return + if game.shldup or game.condition == "docked": + prout(_("Shuttle craft cannot pass through shields.")) + return + if game.state.planets[game.iplnet].known=="unknown": + prout(_("Spock- \"Captain, we have no information on this planet")) + prout(_(" and Starfleet Regulations clearly state that in this situation")) + prout(_(" you may not fly down.\"")) + return + game.optime = 3.0e-5*game.height + if game.optime >= 0.8*game.state.remtime: + prout(_("First Officer Spock- \"Captain, I compute that such")) + proutn(_(" a maneuver would require approximately %2d%% of our") % \ + int(100*game.optime/game.state.remtime)) + prout(_("remaining time.")) + proutn(_("Are you sure this is wise?\" ")) + if ja() == False: + game.optime = 0.0 + return + if game.landed: + # Kirk on planet + if game.iscraft == "onship": + # Galileo on ship! + if not damaged(DTRANSP): + proutn(_("Spock- \"Would you rather use the transporter?\" ")) + if ja() == True: + beam() + return + proutn(_("Shuttle crew")) + else: + proutn(_("Rescue party")) + prout(_(" boards Galileo and swoops toward planet surface.")) + game.iscraft = "offship" + skip(1) + if consumeTime(): + return + game.state.planets[game.iplnet].known="shuttle_down" + prout(_("Trip complete.")) + return + else: + # Ready to go back to ship + prout(_("You and your mining party board the")) + prout(_("shuttle craft for the trip back to the Enterprise.")) + skip(1) + prouts(_("The short hop begins . . .")) + skip(1) + game.state.planets[game.iplnet].known="known" + game.icraft = True + skip(1) + game.landed = False + if consumeTime(): + return + game.iscraft = "onship" + game.icraft = False + if game.imine: + game.icrystl = True + game.cryprob = 0.05 + game.imine = False + prout(_("Trip complete.")) + return + else: + # Kirk on ship + # and so is Galileo + prout(_("Mining party assembles in the hangar deck,")) + prout(_("ready to board the shuttle craft \"Galileo\".")) + skip(1) + prouts(_("The hangar doors open; the trip begins.")) + skip(1) + game.icraft = True + game.iscraft = "offship" + if consumeTime(): + return + game.state.planets[game.iplnet].known = "shuttle_down" + game.landed = True + game.icraft = False + prout(_("Trip complete.")) + return + +def deathray(): + # use the big zapper + r = Rand() + + game.ididit = False + skip(1) + chew() + if game.ship != IHE: + prout(_("Ye Faerie Queene has no death ray.")) + return + if game.nenhere==0: + prout(_("Sulu- \"But Sir, there are no enemies in this quadrant.\"")) + return + if damaged(DDRAY): + prout(_("Death Ray is damaged.")) + return + prout(_("Spock- \"Captain, the 'Experimental Death Ray'")) + prout(_(" is highly unpredictible. Considering the alternatives,")) + proutn(_(" are you sure this is wise?\" ")) + if ja() == False: + return + prout(_("Spock- \"Acknowledged.\"")) + skip(1) + game.ididit = True + prouts(_("WHOOEE ... WHOOEE ... WHOOEE ... WHOOEE")) + skip(1) + prout(_("Crew scrambles in emergency preparation.")) + prout(_("Spock and Scotty ready the death ray and")) + prout(_("prepare to channel all ship's power to the device.")) + skip(1) + prout(_("Spock- \"Preparations complete, sir.\"")) + prout(_("Kirk- \"Engage!\"")) + skip(1) + prouts(_("WHIRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR")) + skip(1) + dprob = .30 + if game.options & OPTION_PLAIN: + dprob = .5 + if r > dprob: + prouts(_("Sulu- \"Captain! It's working!\"")) + skip(2) + while game.nenhere > 0: + deadkl(game.ks[1], game.quad[game.ks[1].x][game.ks[1].y],game.ks[1]) + prout(_("Ensign Chekov- \"Congratulations, Captain!\"")) + if (game.state.remkl + game.state.remcom + game.state.nscrem) == 0: + finish(FWON) + if (game.options & OPTION_PLAIN) == 0: + prout(_("Spock- \"Captain, I believe the `Experimental Death Ray'")) + if Rand() <= 0.05: + prout(_(" is still operational.\"")) + else: + prout(_(" has been rendered nonfunctional.\"")) + game.damage[DDRAY] = 39.95 + return + r = Rand() # Pick failure method + if r <= .30: + prouts(_("Sulu- \"Captain! It's working!\"")) + skip(1) + prouts(_("***RED ALERT! RED ALERT!")) + skip(1) + prout(_("***MATTER-ANTIMATTER IMPLOSION IMMINENT!")) + skip(1) + prouts(_("***RED ALERT! RED A*L********************************")) + skip(1) + stars() + prouts(_("****************** KA-BOOM!!!! *******************")) + skip(1) + kaboom() + return + if r <= .55: + prouts(_("Sulu- \"Captain! Yagabandaghangrapl, brachriigringlanbla!\"")) + skip(1) + prout(_("Lt. Uhura- \"Graaeek! Graaeek!\"")) + skip(1) + prout(_("Spock- \"Fascinating! . . . All humans aboard")) + prout(_(" have apparently been transformed into strange mutations.")) + prout(_(" Vulcans do not seem to be affected.")) + skip(1) + prout(_("Kirk- \"Raauch! Raauch!\"")) + finish(FDRAY) + return + if r <= 0.75: + intj + prouts(_("Sulu- \"Captain! It's --WHAT?!?!\"")) + skip(2) + proutn(_("Spock- \"I believe the word is")) + prouts(_(" *ASTONISHING*")) + prout(_(" Mr. Sulu.")) + for i in range(1, QUADSIZE+1): + for j in range(1, QUADSIZE+1): + if game.quad[i][j] == IHDOT: + game.quad[i][j] = IHQUEST + prout(_(" Captain, our quadrant is now infested with")) + prouts(_(" - - - - - - *THINGS*.")) + skip(1) + prout(_(" I have no logical explanation.\"")) + return + prouts(_("Sulu- \"Captain! The Death Ray is creating tribbles!\"")) + skip(1) + prout(_("Scotty- \"There are so many tribbles down here")) + prout(_(" in Engineering, we can't move for 'em, Captain.\"")) + finish(FTRIBBLE) + return