X-Git-Url: https://jxself.org/git/?p=super-star-trek.git;a=blobdiff_plain;f=src%2Fsst.py;h=3f37ea35b92f1265a942347f5347b90fbec9c152;hp=76fa31a6a911303b02f8141927cdd6907b4730fd;hb=22f7cb3bfdf2e4759470f5decce4dba8c306e139;hpb=c16dbbf0caf5f0c5f1a7fb9059db7953d9616d0e diff --git a/src/sst.py b/src/sst.py index 76fa31a..3f37ea3 100644 --- a/src/sst.py +++ b/src/sst.py @@ -1,192 +1,22 @@ #!/usr/bin/env python """ -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 a lot of -parallel arrays where a more modern language would use structures -or objects. (However, 1-origin array indexing was fixed.) - -Dave Matuszek says: - -SRSCAN, MOVE, PHASERS, CALL, STATUS, IMPULSE, PHOTONS, ABANDON, -LRSCAN, WARP, SHIELDS, DESTRUCT, CHART, REST, DOCK, QUIT, and DAMAGE -were in the original non-"super" version of UT FORTRAN Star Trek. - -Tholians were not in the original. Dave is dubious about their merits. -(They are now controlled by OPTION_THOLIAN and turned off if the game -type is "plain".) - -Planets and dilithium crystals were not in the original. Dave is OK -with this idea. (It's now controlled by OPTION_PLANETS and turned -off if the game type is "plain".) +sst.py -- Super Star Trek 2K -Dave says the bit about the Galileo getting turned into a -McDonald's is "consistant with our original vision". (This has been -left permanently enabled, as it can only happen if OPTION_PLANETS -is on.) +SST2K is a Python translation of a C translation of a FORTRAN +original dating back to 1973. Beautiful Python it is not, but it +works. Translation by Eric S. Raymond; original game by David Matuszek +and Paul Reynolds, with modifications by Don Smith, Tom Almy, +Stas Sergeev, and Eric S. Raymond. -Dave also says the Space Thingy should not be preserved across saved -games, so you can't prove to others that you've seen it. He says it -shouldn't fire back, either. It should do nothing except scream and -disappear when hit by photon torpedos. It's OK that it may move -when attacked, but it didn't in the original. (Whether the Thingy -can fire back is now controlled by OPTION_THINGY and turned off if the -game type is "plain" or "almy". The no-save behavior has been restored.) - -The Faerie Queen, black holes, and time warping were in the original. - -Here are Tom Almy's changes: - -In early 1997, I got the bright idea to look for references to -"Super Star Trek" on the World Wide Web. There weren't many hits, -but there was one that came up with 1979 Fortran sources! This -version had a few additional features that mine didn't have, -however mine had some feature it didn't have. So I merged its -features that I liked. I also took a peek at the DECUS version (a -port, less sources, to the PDP-10), and some other variations. - -1, Compared to the original UT version, I've changed the "help" command to -"call" and the "terminate" command to "quit" to better match -user expectations. The DECUS version apparently made those changes -as well as changing "freeze" to "save". However I like "freeze". -(Both "freeze" and "save" work in SST2K.) - -2. The experimental deathray originally had only a 5% chance of -success, but could be used repeatedly. I guess after a couple -years of use, it was less "experimental" because the 1979 -version had a 70% success rate. However it was prone to breaking -after use. I upgraded the deathray, but kept the original set of -failure modes (great humor!). (Now controlled by OPTION_DEATHRAY -and turned off if game type is "plain".) - -3. The 1979 version also mentions srscan and lrscan working when -docked (using the starbase's scanners), so I made some changes here -to do this (and indicating that fact to the player), and then realized -the base would have a subspace radio as well -- doing a Chart when docked -updates the star chart, and all radio reports will be heard. The Dock -command will also give a report if a base is under attack. - -4. Tholian Web from the 1979 version. (Now controlled by -OPTION_THOLIAN and turned off if game type is "plain".) - -5. Enemies can ram the Enterprise. (Now controlled by OPTION_RAMMING -and turned off if game type is "plain".) - -6. Regular Klingons and Romulans can move in Expert and Emeritus games. -This code could use improvement. (Now controlled by OPTION_MVBADDY -and turned off if game type is "plain".) - -7. The deep-space probe feature from the DECUS version. (Now controlled -by OPTION_PROBE and turned off if game type is "plain"). - -8. 'emexit' command from the 1979 version. - -9. Bugfix: Klingon commander movements are no longer reported if long-range -sensors are damaged. - -10. Bugfix: Better base positioning at startup (more spread out). -That made sense to add because most people abort games with -bad base placement. - -In June 2002, I fixed two known bugs and a documentation typo. -In June 2004 I fixed a number of bugs involving: 1) parsing invalid -numbers, 2) manual phasers when SR scan is damaged and commander is -present, 3) time warping into the future, 4) hang when moving -klingons in crowded quadrants. (These fixes are in SST2K.) - -Here are Stas Sergeev's changes: - -1. The Space Thingy can be shoved, if you ram it, and can fire back if -fired upon. (Now controlled by OPTION_THINGY and turned off if game -type is "plain" or "almy".) - -2. When you are docked, base covers you with an almost invincible shield. -(A commander can still ram you, or a Romulan can destroy the base, -or a SCom can even succeed with direct attack IIRC, but this rarely -happens.) (Now controlled by OPTION_BASE and turned off if game -type is "plain" or "almy".) - -3. Ramming a black hole is no longer instant death. There is a -chance you might get timewarped instead. (Now controlled by -OPTION_BLKHOLE and turned off if game type is "plain" or "almy".) - -4. The Tholian can be hit with phasers. - -5. SCom can't escape from you if no more enemies remain -(without this, chasing SCom can take an eternity). - -6. Probe target you enter is now the destination quadrant. Before I don't -remember what it was, but it was something I had difficulty using. - -7. Secret password is now autogenerated. - -8. "Plaque" is adjusted for A4 paper :-) - -9. Phasers now tells you how much energy needed, but only if the computer -is alive. - -10. Planets are auto-scanned when you enter the quadrant. - -11. Mining or using crystals in presense of enemy now yields an attack. -There are other minor adjustments to what yields an attack -and what does not. - -12. "freeze" command reverts to "save", most people will understand this -better anyway. (SST2K recognizes both.) - -13. Screen-oriented interface, with sensor scans always up. (SST2K -supports both screen-oriented and TTY modes.) - -Eric Raymond's changes: - -Mainly, I translated this C code out of FORTRAN into C -- created #defines -for a lot of magic numbers and refactored the heck out of it. - -1. "sos" and "call" becomes "mayday", "freeze" and "save" are both good. - -2. Status report now indicates when dilithium crystals are on board. - -3. Per Dave Matuszek's remarks, Thingy state is never saved across games. - -4. Added game option selection so you can play a close (but not bug-for- -bug identical) approximation of older versions. - -5. Half the quadrants now have inhabited planets, from which one -cannot mine dilithium (there will still be the same additional number -of dilithium-bearing planets). Torpedoing an inhabited world is *bad*. -There is BSD-Trek-like logic for Klingons to attack and enslave -inhabited worlds, producing more ships (only is skill is 'good' or -better). (Controlled by OPTION_WORLDS and turned off if game -type is "plain" or "almy".) - -6. User input is now logged so we can do regression testing. - -7. More BSD-Trek features: You can now lose if your entire crew -dies in battle. When abandoning ship in a game with inhabited -worlds enabled, they must have one in the quadrant to beam down -to; otherwise they die in space and this counts heavily against -your score. Docking at a starbase replenishes your crew. - -8. Still more BSD-Trek: we now have a weighted damage table. -Also, the nav subsystem (enabling automatic course -setting) can be damaged separately from the main computer (which -handles weapons targeting, ETA calculation, and self-destruct). - -After these features were added, I translated this into Python and added -more: - -9. A long-range scan is done silently whenever you call CHART; thus -the LRSCAN command is no longer needed. (Controlled by OPTION_AUTOSCAN -and turned off if game type is "plain" or "almy".) +See the doc/HACKING file in the distribution for designers notes and advice +ion how to modify (and how not to modify!) this code. """ -import os,sys,math,curses,time,atexit,readline,cPickle,random,getopt,copy +import os, sys, math, curses, time, readline, cPickle, random, copy, gettext SSTDOC = "/usr/share/doc/sst/sst.doc" DOC_NAME = "sst.doc" -# Stub to be replaced -def _(str): return str +def _(str): return gettext.gettext(str) PHASEFAC = 2.0 GALSIZE = 8 @@ -200,15 +30,8 @@ MAXKLGAME = 127 MAXKLQUAD = 9 FULLCREW = 428 # BSD Trek was 387, that's wrong FOREVER = 1e30 - -# These functions hide the difference between 0-origin and 1-origin addressing. -def VALID_QUADRANT(x, y): return ((x)>=0 and (x)=0 and (y)=0 and (x)=0 and (y)=0 and self.i=0 and self.j=0 and self.i=0 and self.j %s" % (self, (self / QUADSIZE).roundtogrid()) + return self.roundtogrid() / QUADSIZE + def sector(self): + return self.roundtogrid() % QUADSIZE def scatter(self): s = coord() - s.x = self.x + randrange(-1, 2) - s.y = self.y + randrange(-1, 2) + s.i = self.i + randrange(-1, 2) + s.j = self.j + randrange(-1, 2) return s - def __hash__(self): - return hash((x, y)) def __str__(self): - if self.x == None or self.y == None: + if self.i == None or self.j == None: return "Nowhere" - return "%s - %s" % (self.x+1, self.y+1) + return "%s - %s" % (self.i+1, self.j+1) __repr__ = __str__ class planet: def __init__(self): self.name = None # string-valued if inhabited - self.w = coord() # quadrant located + self.quadrant = coord() # quadrant located self.pclass = None # could be ""M", "N", "O", or "destroyed" self.crystals = "absent"# could be "mined", "present", "absent" self.known = "unknown" # could be "unknown", "known", "shuttle_down" @@ -287,14 +133,14 @@ class planet: class quadrant: def __init__(self): - self.stars = None + self.stars = 0 self.planet = None - self.starbase = None - self.klingons = None - self.romulans = None - self.supernova = None - self.charted = None - self.status = None # Could be "secure", "distressed", "enslaved" + self.starbase = False + self.klingons = 0 + self.romulans = 0 + self.supernova = False + self.charted = False + self.status = "secure" # Could be "secure", "distressed", "enslaved" class page: def __init__(self): @@ -316,9 +162,7 @@ class snapshot: self.snap = False # snapshot taken self.crew = 0 # crew complement self.remkl = 0 # remaining klingons - self.remcom = 0 # remaining commanders self.nscrem = 0 # remaining super commanders - self.rembase = 0 # remaining bases self.starkl = 0 # destroyed stars self.basekl = 0 # destroyed bases self.nromrem = 0 # Romulans remaining @@ -329,15 +173,11 @@ class snapshot: self.remres = 0 # remaining resources self.remtime = 0 # remaining time self.baseq = [] # Base quadrant coordinates - for i in range(BASEMAX): - self.baseq.append(coord()) self.kcmdr = [] # Commander quadrant coordinates - for i in range(QUADSIZE): - self.kcmdr.append(coord()) self.kscmdr = coord() # Supercommander quadrant coordinates - # the galaxy (subscript 0 not used) + # the galaxy self.galaxy = fill2d(GALSIZE, lambda i, j: quadrant()) - # the starchart (subscript 0 not used) + # the starchart self.chart = fill2d(GALSIZE, lambda i, j: page()) class event: @@ -424,25 +264,31 @@ class enemy: self.kpower = power # enemy energy level game.enemies.append(self) def move(self, loc): - if self.kloc.x is not None and self.kloc.y is not None: - game.quad[self.kloc.x][self.kloc.y] = IHDOT + motion = (loc != self.kloc) + if self.kloc.i is not None and self.kloc.j is not None: + if motion: + if self.type == IHT: + game.quad[self.kloc.i][self.kloc.j] = IHWEB + else: + game.quad[self.kloc.i][self.kloc.j] = IHDOT if loc: - self.kloc = loc - game.quad[self.kloc.x][self.kloc.y] = self.type - self.kdist = self.kavgd = distance(game.sector, loc) + self.kloc = copy.copy(loc) + game.quad[self.kloc.i][self.kloc.j] = self.type + self.kdist = self.kavgd = (game.sector - loc).distance() else: - self.kloc = coord() # enemy sector location + self.kloc = coord() self.kdist = self.kavgd = None game.enemies.remove(self) + return motion def __repr__(self): - return "<%s=%f>" % (self.kloc, self.kpower) # For debugging + return "<%s,%s.%f>" % (self.type, self.kloc, self.kpower) # For debugging class gamestate: def __init__(self): self.options = None # Game options self.state = snapshot() # A snapshot structure self.snapsht = snapshot() # Last snapshot taken for time-travel purposes - self.quad = fill2d(QUADSIZE, lambda i, j: IHDOT) # contents of our quadrant + self.quad = None # contents of our quadrant self.damage = [0.0] * NDEVICES # damage encountered self.future = [] # future events for i in range(NEVENTS): @@ -455,15 +301,12 @@ class gamestate: self.base = None # position of base in current quadrant self.battle = None # base coordinates being attacked self.plnet = None # location of planet in quadrant - self.probec = None # current probe quadrant self.gamewon = False # Finished! self.ididit = False # action taken -- allows enemy to attack self.alive = False # we are alive (not killed) self.justin = False # just entered quadrant self.shldup = False # shields are up self.shldchg = False # shield is changing (affects efficiency) - self.comhere = False # commander here - self.ishere = False # super-commander in quadrant self.iscate = False # super commander is here self.ientesc = False # attempted escape from supercommander self.resting = False # rest time @@ -500,7 +343,6 @@ class gamestate: self.irhere = 0 # Romulans in quadrant self.isatb = 0 # =1 if super commander is attacking base self.tourn = None # tournament number - self.proben = 0 # number of moves for probe self.nprobes = 0 # number of probes available self.inresor = 0.0 # initial resources self.intime = 0.0 # initial time @@ -513,27 +355,22 @@ class gamestate: self.warpfac = 0.0 # warp speed self.wfacsq = 0.0 # squared warp factor self.lsupres = 0.0 # life support reserves - self.dist = 0.0 # movement distance - self.direc = 0.0 # movement direction self.optime = 0.0 # time taken by current operation self.docfac = 0.0 # repair factor when docking (constant?) self.damfac = 0.0 # damage factor self.lastchart = 0.0 # time star chart was last updated self.cryprob = 0.0 # probability that crystal will work - self.probex = 0.0 # location of probe - self.probey = 0.0 # - self.probeinx = 0.0 # probe x,y increment - self.probeiny = 0.0 # + self.probe = None # object holding probe course info 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 + # game.state.remkl + len(game.state.kcmdr) > 0 ? + # game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) : 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' + game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr)) + IHR = 'R' IHK = 'K' IHC = 'C' @@ -553,8 +390,6 @@ IHMATER0 = '-' IHMATER1 = 'o' IHMATER2 = '0' - -# From enumerated type 'FINTYPE' FWON = 0 FDEPLETE = 1 FLIFESUP = 2 @@ -578,29 +413,6 @@ FTRIBBLE = 19 FHOLE = 20 FCREW = 21 -# From enumerated type 'COLORS' -DEFAULT = 0 -BLACK = 1 -BLUE = 2 -GREEN = 3 -CYAN = 4 -RED = 5 -MAGENTA = 6 -BROWN = 7 -LIGHTGRAY = 8 -DARKGRAY = 9 -LIGHTBLUE = 10 -LIGHTGREEN = 11 -LIGHTCYAN = 12 -LIGHTRED = 13 -LIGHTMAGENTA = 14 -YELLOW = 15 -WHITE = 16 - -# Log the results of pulling random numbers so we can check determinism. - -import traceback - def withprob(p): v = random.random() #logfp.write("# withprob(%s) -> %f (%s) at %s\n" % (p, v, v %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:])) return v # Code from ai.c begins here +def welcoming(iq): + "Would this quadrant welcome another Klingon?" + return iq.valid_quadrant() and \ + not game.state.galaxy[iq.i][iq.j].supernova and \ + game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD + def tryexit(enemy, look, irun): - # a bad guy attempts to bug out + "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 \ - game.state.galaxy[iq.x][iq.y].supernova or \ - game.state.galaxy[iq.x][iq.y].klingons > MAXKLQUAD-1: - return False; # no can do -- neg energy, supernovae, or >MAXKLQUAD-1 Klingons + iq.i = game.quadrant.i+(look.i+(QUADSIZE-1))/QUADSIZE - 1 + iq.j = game.quadrant.j+(look.j+(QUADSIZE-1))/QUADSIZE - 1 + if not welcoming(iq): + return False; if enemy.type == IHR: return False; # Romulans cannot escape! if not irun: # avoid intruding on another commander's territory if enemy.type == IHC: - for n in range(game.state.remcom): - if game.state.kcmdr[n] == iq: - return False + if iq in game.state.kcmdr: + return False # refuse to leave if currently attacking starbase if game.battle == game.quadrant: return False # don't leave if over 1000 units of energy if enemy.kpower > 1000.0: return False - # print escape message and move out of quadrant. + # emit escape message and move out of quadrant. # 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, enemy.type, "sector", enemy.kloc) - prout(_(" escapes to Quadrant %s (and regains strength).") % q) + prout(crmena(True, enemy.type, "sector", enemy.kloc) + \ + (_(" escapes to Quadrant %s (and regains strength).") % q)) # handle local matters related to escape enemy.move(None) game.klhere -= 1 if game.condition != "docked": newcnd() # Handle global matters related to escape - game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons -= 1 - game.state.galaxy[iq.x][iq.y].klingons += 1 + game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1 + game.state.galaxy[iq.i][iq.j].klingons += 1 if enemy.type==IHS: - game.ishere = False game.iscate = False game.ientesc = False game.isatb = 0 @@ -668,14 +482,12 @@ def tryexit(enemy, look, irun): unschedule(FSCDBAS) game.state.kscmdr=iq else: - for n in range(game.state.remcom): - if game.state.kcmdr[n] == game.quadrant: - game.state.kcmdr[n]=iq + for cmdr in game.state.kcmdr: + if cmdr == game.quadrant: + game.state.kcmdr[n] = iq break - game.comhere = False return True; # success -# # The bad-guy movement algorithm: # # 1. Enterprise has "force" based on condition of phaser and photon torpedoes. @@ -713,17 +525,16 @@ def tryexit(enemy, look, irun): # retreat, especially at high skill levels. # # 5. Motion is limited to skill level, except for SC hi-tailing it out. -# def movebaddy(enemy): - # tactical movement for the bad guys + "Tactical movement for the bad guys." next = coord(); look = coord() irun = False - # This should probably be just game.comhere + game.ishere + # This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant) if game.skill >= SKILL_EXPERT: - nbaddys = ((game.comhere*2 + game.ishere*2+game.klhere*1.23+game.irhere*1.5)/2.0) + nbaddys = (((game.quadrant in game.state.kcmdr)*2 + (game.state.kscmdr==game.quadrant)*2+game.klhere*1.23+game.irhere*1.5)/2.0) else: - nbaddys = game.comhere + game.ishere + nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant) dist1 = enemy.kdist mdist = int(dist1 + 0.5); # Nearest integer distance # If SC, check with spy to see if should hi-tail it @@ -753,9 +564,9 @@ def movebaddy(enemy): motion = ((forces + randreal(200))/150.0) - 5.0 else: if forces > 1000.0: # Very strong -- move in for kill - motion = (1.0-square(randreal()))*dist1 + 1.0 + motion = (1.0 - randreal())**2 * dist1 + 1.0 if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off ! - motion -= game.skill*(2.0-square(randreal())) + motion -= game.skill*(2.0-randreal()**2) if idebug: proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces)) # don't move if no motion @@ -768,10 +579,7 @@ def movebaddy(enemy): else: motion = game.skill # calculate preferred number of steps - if motion < 0: - nsteps = -motion - else: - nsteps = motion + nsteps = abs(int(motion)) if motion > 0 and nsteps > mdist: nsteps = mdist; # don't overshoot if nsteps > QUADSIZE: @@ -781,68 +589,57 @@ def movebaddy(enemy): if idebug: proutn("NSTEPS = %d:" % nsteps) # Compute preferred values of delta X and Y - mx = game.sector.x - enemy.kloc.x - my = game.sector.y - enemy.kloc.y - if 2.0 * abs(mx) < abs(my): - mx = 0 - if 2.0 * abs(my) < abs(game.sector.x-enemy.kloc.x): - my = 0 - if mx != 0: - if mx*motion < 0: - mx = -1 - else: - mx = 1 - if my != 0: - if my*motion < 0: - my = -1 - else: - my = 1 + m = game.sector - enemy.kloc + if 2.0 * abs(m.i) < abs(m.j): + m.i = 0 + if 2.0 * abs(m.j) < abs(game.sector.i-enemy.kloc.i): + m.j = 0 + m = (motion * m).sgn() next = enemy.kloc # main move loop for ll in range(nsteps): if idebug: proutn(" %d" % (ll+1)) # Check if preferred position available - look.x = next.x + mx - look.y = next.y + my - if mx < 0: - krawlx = 1 + look = next + m + if m.i < 0: + krawli = 1 else: - krawlx = -1 - if my < 0: - krawly = 1 + krawli = -1 + if m.j < 0: + krawlj = 1 else: - krawly = -1 + krawlj = -1 success = False attempts = 0; # Settle mysterious hang problem while attempts < 20 and not success: attempts += 1 - if look.x < 0 or look.x >= QUADSIZE: + if look.i < 0 or look.i >= QUADSIZE: if motion < 0 and tryexit(enemy, look, irun): return - if krawlx == mx or my == 0: + if krawli == m.i or m.j == 0: break - look.x = next.x + krawlx - krawlx = -krawlx - elif look.y < 0 or look.y >= QUADSIZE: + look.i = next.i + krawli + krawli = -krawli + elif look.j < 0 or look.j >= QUADSIZE: if motion < 0 and tryexit(enemy, look, irun): return - if krawly == my or mx == 0: + if krawlj == m.j or m.i == 0: break - look.y = next.y + krawly - krawly = -krawly - elif (game.options & OPTION_RAMMING) and game.quad[look.x][look.y] != IHDOT: + look.j = next.j + krawlj + krawlj = -krawlj + elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != IHDOT: # See if enemy should ram ship - if game.quad[look.x][look.y] == game.ship and \ + if game.quad[look.i][look.j] == game.ship and \ (enemy.type == IHC or enemy.type == IHS): collision(rammed=True, enemy=enemy) return - if krawlx != mx and my != 0: - look.x = next.x + krawlx - krawlx = -krawlx - elif krawly != my and mx != 0: - look.y = next.y + krawly - krawly = -krawly + if krawli != m.i and m.j != 0: + look.i = next.i + krawli + krawli = -krawli + elif krawlj != m.j and m.i != 0: + look.j = next.j + krawlj + krawlj = -krawlj else: break; # we have failed else: @@ -855,17 +652,9 @@ def movebaddy(enemy): break; # done early if idebug: skip(1) - # Put commander in place within same quadrant - game.quad[enemy.kloc.x][enemy.kloc.y] = IHDOT - game.quad[next.x][next.y] = enemy.type - if next != enemy.kloc: - # it moved - enemy.kloc = next - enemy.kdist = enemy.kavgd = distance(game.sector, next) + if enemy.move(next): if not damaged(DSRSENS) or game.condition == "docked": - proutn("***") - cramen(enemy.type) - proutn(_(" from Sector %s") % enemy.kloc) + proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.kloc)) if enemy.kdist < dist1: proutn(_(" advances to ")) else: @@ -873,16 +662,16 @@ def movebaddy(enemy): prout("Sector %s." % next) def moveklings(): - # Klingon tactical movement + "Sequence Klingon tactical movement." if idebug: prout("== MOVCOM") # Figure out which Klingon is the commander (or Supercommander) # and do move - if game.comhere: + if game.quadrant in game.state.kcmdr: for enemy in game.enemies: if enemy.type == IHC: movebaddy(enemy) - if game.ishere: + if game.state.kscmdr==game.quadrant: for enemy in game.enemies: if enemy.type == IHS: movebaddy(enemy) @@ -897,27 +686,20 @@ def moveklings(): game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist)) def movescom(iq, avoid): - # commander movement helper - if 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: - return 1 - if avoid: - # Avoid quadrants with bases if we want to avoid Enterprise - for i in range(game.state.rembase): - if game.state.baseq[i] == iq: - return True + "Commander movement helper." + # Avoid quadrants with bases if we want to avoid Enterprise + if not welcoming(iq) or (avoid and iq in game.state.baseq): + return False if game.justin and not game.iscate: - return True + return False # do the move - game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].klingons -= 1 + game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons -= 1 game.state.kscmdr = iq - game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].klingons += 1 - if game.ishere: + game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons += 1 + if game.state.kscmdr==game.quadrant: # SC has scooted, Remove him from current quadrant game.iscate=False game.isatb=0 - game.ishere = False game.ientesc = False unschedule(FSCDBAS) for enemy in game.enemies: @@ -930,64 +712,61 @@ def movescom(iq, avoid): game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist)) # check for a helpful planet for i in range(game.inplan): - if game.state.planets[i].w == game.state.kscmdr and \ + if game.state.planets[i].quadrant == game.state.kscmdr and \ game.state.planets[i].crystals == "present": # destroy the planet game.state.planets[i].pclass = "destroyed" - game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].planet = None + game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].planet = None if communicating(): announce() prout(_("Lt. Uhura- \"Captain, Starfleet Intelligence reports")) proutn(_(" a planet in Quadrant %s has been destroyed") % game.state.kscmdr) prout(_(" by the Super-commander.\"")) break - return False; # looks good! + return True; # looks good! def supercommander(): - # move the Super Commander + "Move the Super Commander." 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 \ + avoid = ((game.incom - len(game.state.kcmdr) + game.inkling - game.state.remkl)/(game.state.date+0.01-game.indate) < 0.1*game.skill*(game.skill+1.0) or \ (game.state.date-game.indate) < 3.0) if not game.iscate and avoid: # compute move away from Enterprise idelta = game.state.kscmdr-game.quadrant - if math.sqrt(idelta.x*idelta.x+idelta.y*idelta.y) > 2.0: + if idelta.distance() > 2.0: # circulate in space - idelta.x = game.state.kscmdr.y-game.quadrant.y - idelta.y = game.quadrant.x-game.state.kscmdr.x + idelta.i = game.state.kscmdr.j-game.quadrant.j + idelta.j = game.quadrant.i-game.state.kscmdr.i else: # compute distances to starbases - if game.state.rembase <= 0: + if not game.state.baseq: # nothing left to do unschedule(FSCMOVE) return sc = game.state.kscmdr - for i in range(game.state.rembase): - basetbl.append((i, distance(game.state.baseq[i], sc))) - if game.state.rembase > 1: + for base in game.state.baseq: + basetbl.append((i, (base - sc).distance())) + if game.state.baseq > 1: basetbl.sort(lambda x, y: cmp(x[1]. y[1])) # 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(game.state.rembase): + for (i2, base) in enumerate(game.state.baseq): i = basetbl[i2][0]; # bug in original had it not finding nearest - ibq = game.state.baseq[i] - if ibq == game.quadrant or ibq == game.battle or \ - game.state.galaxy[ibq.x][ibq.y].supernova or \ - game.state.galaxy[ibq.x][ibq.y].klingons > MAXKLQUAD-1: + if base==game.quadrant or base==game.battle or not welcoming(base): continue # if there is a commander, and no other base is appropriate, - # we will take the one with the commander - for j in range(game.state.remcom): - if ibq == game.state.kcmdr[j] and ifindit!= 2: + # we will take the one with the commander + for cmdr in game.state.kcmdr: + if base == cmdr and ifindit != 2: ifindit = 2 iwhichb = i break - if j > game.state.remcom: # no commander -- use this one + else: # no commander -- use this one ifindit = 1 iwhichb = i break @@ -1002,33 +781,32 @@ def supercommander(): # 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): + if not movescom(iq, avoid): # failed -- try some other maneuvers - if idelta.x==0 or idelta.y==0: + if idelta.i==0 or idelta.j==0: # attempt angle move - if idelta.x != 0: - iq.y = game.state.kscmdr.y + 1 - if movescom(iq, avoid): - iq.y = game.state.kscmdr.y - 1 + if idelta.i != 0: + iq.j = game.state.kscmdr.j + 1 + if not movescom(iq, avoid): + iq.j = game.state.kscmdr.j - 1 movescom(iq, avoid) - else: - iq.x = game.state.kscmdr.x + 1 - if movescom(iq, avoid): - iq.x = game.state.kscmdr.x - 1 + elif idelta.j != 0: + iq.i = game.state.kscmdr.i + 1 + if not movescom(iq, avoid): + iq.i = game.state.kscmdr.i - 1 movescom(iq, avoid) else: # try moving just in x or y - iq.y = game.state.kscmdr.y - if movescom(iq, avoid): - iq.y = game.state.kscmdr.y + idelta.y - iq.x = game.state.kscmdr.x + iq.j = game.state.kscmdr.j + if not movescom(iq, avoid): + iq.j = game.state.kscmdr.j + idelta.j + iq.i = game.state.kscmdr.i movescom(iq, avoid) # check for a base - if game.state.rembase == 0: + if len(game.state.baseq) == 0: unschedule(FSCMOVE) else: - for i in range(game.state.rembase): - ibq = game.state.baseq[i] + for ibq in game.state.baseq: if ibq == game.state.kscmdr and game.state.kscmdr == game.battle: # attack the base if avoid: @@ -1059,7 +837,7 @@ def supercommander(): if not idebug and \ (withprob(0.8) or \ (not communicating()) or \ - not game.state.galaxy[game.state.kscmdr.x][game.state.kscmdr.y].charted): + not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].charted): return announce() prout(_("Lt. Uhura- \"Captain, Starfleet Intelligence reports")) @@ -1067,80 +845,75 @@ def supercommander(): return def movetholian(): - # move the Tholian + "Move the Tholian." if not game.tholian or game.justin: return - if game.tholian.kloc.x == 0 and game.tholian.kloc.y == 0: - idx = 0; idy = QUADSIZE-1 - elif game.tholian.kloc.x == 0 and game.tholian.kloc.y == QUADSIZE-1: - idx = QUADSIZE-1; idy = QUADSIZE-1 - elif game.tholian.kloc.x == QUADSIZE-1 and game.tholian.kloc.y == QUADSIZE-1: - idx = QUADSIZE-1; idy = 0 - elif game.tholian.kloc.x == QUADSIZE-1 and game.tholian.kloc.y == 0: - idx = 0; idy = 0 + id = coord() + if game.tholian.kloc.i == 0 and game.tholian.kloc.j == 0: + id.i = 0; id.j = QUADSIZE-1 + elif game.tholian.kloc.i == 0 and game.tholian.kloc.j == QUADSIZE-1: + id.i = QUADSIZE-1; id.j = QUADSIZE-1 + elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == QUADSIZE-1: + id.i = QUADSIZE-1; id.j = 0 + elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == 0: + id.i = 0; id.j = 0 else: # something is wrong! - game.tholian = None + game.tholian.move(None) + prout("***Internal error: Tholian in a bad spot.") return # do nothing if we are blocked - if game.quad[idx][idy]!= IHDOT and game.quad[idx][idy]!= IHWEB: + if game.quad[id.i][id.j] not in (IHDOT, IHWEB): return - game.quad[game.tholian.kloc.x][game.tholian.kloc.y] = IHWEB - if game.tholian.kloc.x != idx: - # move in x axis - im = math.fabs(idx - game.tholian.kloc.x)*1.0/(idx - game.tholian.kloc.x) - while game.tholian.kloc.x != idx: - game.tholian.kloc.x += im - if game.quad[game.tholian.kloc.x][game.tholian.kloc.y]==IHDOT: - game.quad[game.tholian.kloc.x][game.tholian.kloc.y] = IHWEB - elif game.tholian.kloc.y != idy: - # move in y axis - im = math.fabs(idy - game.tholian.kloc.y)*1.0/(idy - game.tholian.kloc.y) - while game.tholian.kloc.y != idy: - game.tholian.kloc.y += im - if game.quad[game.tholian.kloc.x][game.tholian.kloc.y]==IHDOT: - game.quad[game.tholian.kloc.x][game.tholian.kloc.y] = IHWEB - game.quad[game.tholian.kloc.x][game.tholian.kloc.y] = IHT - #game.enemies[-1].kloc = game.tholian #FIXME + here = copy.copy(game.tholian.kloc) + delta = (id - game.tholian.kloc).sgn() + # move in x axis + while here.i != id.i: + here.i += delta.i + if game.quad[here.i][here.j]==IHDOT: + game.tholian.move(here) + # move in y axis + while here.j != id.j: + here.j += delta.j + if game.quad[here.i][here.j]==IHDOT: + game.tholian.move(here) # check to see if all holes plugged for i in range(QUADSIZE): if game.quad[0][i]!=IHWEB and game.quad[0][i]!=IHT: return - if game.quad[QUADSIZE][i]!=IHWEB and game.quad[QUADSIZE][i]!=IHT: + if game.quad[QUADSIZE-1][i]!=IHWEB and game.quad[QUADSIZE-1][i]!=IHT: return if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT: return - if game.quad[i][QUADSIZE]!=IHWEB and game.quad[i][QUADSIZE]!=IHT: + if game.quad[i][QUADSIZE-1]!=IHWEB and game.quad[i][QUADSIZE-1]!=IHT: return # All plugged up -- Tholian splits - game.quad[game.tholian.kloc.x][game.tholian.kloc.y]=IHWEB + game.quad[game.tholian.kloc.i][game.tholian.kloc.j]=IHWEB dropin(IHBLANK) - crmena(True, IHT, "sector", game.tholian) - prout(_(" completes web.")) + prout(crmena(True, IHT, "sector", game.tholian) + _(" completes web.")) game.tholian.move(None) return # Code from battle.c begins here def doshield(shraise): - # change shield status + "Change shield status." action = "NONE" game.ididit = False if shraise: action = "SHUP" else: - key = scan() - if key == IHALPHA: - if isit("transfer"): + key = scanner.next() + if key == "IHALPHA": + if scanner.sees("transfer"): action = "NRG" else: - chew() if damaged(DSHIELD): prout(_("Shields damaged and down.")) return - if isit("up"): + if scanner.sees("up"): action = "SHUP" - elif isit("down"): + elif scanner.sees("down"): action = "SHDN" if action=="NONE": proutn(_("Do you wish to change shield energy? ")) @@ -1155,14 +928,14 @@ def doshield(shraise): if ja() == True: action = "SHDN" else: - chew() + scanner.chew() return else: proutn(_("Shields are down. Do you want them up? ")) if ja() == True: action = "SHUP" else: - chew() + scanner.chew() return if action == "SHUP": # raise shields if game.shldup: @@ -1190,24 +963,24 @@ def doshield(shraise): game.ididit = True return elif action == "NRG": - while scan() != IHREAL: - chew() + while scanner.next() != "IHREAL": + scanner.chew() proutn(_("Energy to transfer to shields- ")) - chew() - if aaitem == 0: + scanner.chew() + if scanner.real == 0: return - if aaitem > game.energy: + if scanner.real > game.energy: prout(_("Insufficient ship energy.")) return game.ididit = True - if game.shield+aaitem >= game.inshld: + if game.shield+scanner.real >= game.inshld: prout(_("Shield energy maximized.")) - if game.shield+aaitem > game.inshld: + if game.shield+scanner.real > 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: + if scanner.real < 0.0 and game.energy-scanner.real > game.inenrg: # Prevent shield drain loophole skip(1) prout(_("Engineering to bridge--")) @@ -1215,23 +988,22 @@ def doshield(shraise): prout(_(" I can't drain the shields.")) game.ididit = False return - if game.shield+aaitem < 0: + if game.shield+scanner.real < 0: prout(_("All shield energy transferred to ship.")) game.energy += game.shield game.shield = 0.0 return proutn(_("Scotty- \"")) - if aaitem > 0: + if scanner.real > 0: prout(_("Transferring energy to shields.\"")) else: prout(_("Draining energy from shields.\"")) - game.shield += aaitem - game.energy -= aaitem + game.shield += scanner.real + game.energy -= scanner.real return def randdevice(): - # choose a device to damage, at random. - # + "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 @@ -1254,7 +1026,6 @@ def randdevice(): # 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% @@ -1282,35 +1053,31 @@ def randdevice(): return None; # we should never get here def collision(rammed, enemy): - # collision handling + "Collision handling fot rammong events." prouts(_("***RED ALERT! RED ALERT!")) skip(1) prout(_("***COLLISION IMMINENT.")) skip(2) proutn("***") - crmshp() + proutn(crmshp()) hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0) if rammed: proutn(_(" rammed by ")) else: proutn(_(" rams ")) - crmena(False, enemy.type, "sector", enemy.kloc) + proutn(crmena(False, enemy.type, "sector", enemy.kloc)) if rammed: proutn(_(" (original position)")) skip(1) deadkl(enemy.kloc, enemy.type, game.sector) - proutn("***") - crmshp() - prout(_(" heavily damaged.")) + proutn("***" + crmship() + " heavily damaged.") icas = randrange(10, 30) 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 = randrange(NDEVICES/2) for m in range(ncrits): dev = randdevice() @@ -1321,92 +1088,79 @@ def collision(rammed, enemy): game.damage[dev] += game.optime + extradm game.shldup = False prout(_("***Shields are down.")) - if game.state.remkl + game.state.remcom + game.state.nscrem: + if game.state.remkl + len(game.state.kcmdr) + 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 +def torpedo(origin, bearing, dispersion, number, nburst): + "Let a photon torpedo fly" if not damaged(DSRSENS) or game.condition=="docked": setwnd(srscan_window) else: setwnd(message_window) + ac = bearing + 0.25*dispersion # dispersion is a random variable + bullseye = (15.0 - bearing)*0.5235988 + track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin)) + bumpto = coord(0, 0) # Loop to move a single torpedo - for l in range(1, 15+1): - x += deltax - w.x = int(x + 0.5) - y += deltay - w.y = int(y + 0.5) - if not VALID_SECTOR(w.x, w.y): + setwnd(message_window) + for step in range(1, QUADSIZE*2): + if not track.next(): break + w = track.sector() + if not w.valid_sector(): break - iquad=game.quad[w.x][w.y] - tracktorpedo(w, l, i, n, iquad) + iquad=game.quad[w.i][w.j] + tracktorpedo(origin, w, step, number, nburst, iquad) if iquad==IHDOT: continue # hit something - setwnd(message_window) - if damaged(DSRSENS) and not game.condition=="docked": + if not damaged(DSRSENS) or 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(".") + prout(_("Torpedo hits %s.") % crmshp()) hit = 700.0 + randreal(100) - \ - 1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle)) + 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.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*(randreal()-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 = int(w.x+xx+0.5) - jw.y = int(w.y+yy+0.5) - if not VALID_SECTOR(jw.x, jw.y): + # In the C/FORTRAN version, dispersion was 2.5 radians, which + # is 143 degrees, which is almost exactly 4.8 clockface units + displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5) + displacement.next() + bumpto = displacement.sector() + if not bumpto.valid_sector(): return hit - if game.quad[jw.x][jw.y]==IHBLANK: + if game.quad[bumpto.i][bumpto.j]==IHBLANK: finish(FHOLE) return hit - if game.quad[jw.x][jw.y]!=IHDOT: + if game.quad[bumpto.i][bumpto.j]!=IHDOT: # can't move into object return hit - game.sector = jw - crmshp() - shoved = True - elif iquad in (IHC, IHS): # Hit a commander - if withprob(0.05): - crmena(True, iquad, "sector", w) - prout(_(" uses anti-photon device;")) + game.sector = bumpto + proutn(crmshp()) + game.quad[w.i][w.j]=IHDOT + game.quad[bumpto.i][bumpto.j]=iquad + prout(_(" displaced by blast to Sector %s ") % bumpto) + for enemy in game.enemies: + enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance() + game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist)) + return None + elif iquad in (IHC, IHS, IHR, IHK): # Hit a regular enemy + # find the enemy + if iquad in (IHC, IHS) and withprob(0.05): + prout(crmena(True, iquad, "sector", w) + _(" uses anti-photon device;")) prout(_(" torpedo neutralized.")) return None - elif iquad in (IHR, IHK): # Hit a regular enemy - # find the enemy for enemy in game.enemies: - if w == game.enemies[ll].kloc: + if w == enemy.kloc: break - kp = math.fabs(e.kpower) + kp = math.fabs(enemy.kpower) h1 = 700.0 + randrange(100) - \ - 1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle)) + 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle)) h1 = math.fabs(h1) if kp < h1: h1 = kp @@ -1417,80 +1171,68 @@ def torpedo(course, r, incoming, i, n): if enemy.kpower == 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*(randreal()-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): + proutn(crmena(True, iquad, "sector", w)) + displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5) + displacement.next() + bumpto = displacement.sector() + if not bumpto.valid_sector(): prout(_(" damaged but not destroyed.")) return - if game.quad[jw.x][jw.y]==IHBLANK: + if game.quad[bumpto.i][bumpto.j] == 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 + deadkl(w, iquad, bumpto) + if game.quad[bumpto.i][bumpto.j] != IHDOT: prout(_(" damaged but not destroyed.")) - return None - proutn(_(" damaged--")) - enemy.kloc = jw - shoved = True - break + else: + prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto) + enemy.kloc = bumpto + game.quad[w.i][w.j]=IHDOT + game.quad[bumpto.i][bumpto.j]=iquad + for enemy in game.enemies: + enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance() + game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist)) + return None elif iquad == IHB: # Hit a base skip(1) prout(_("***STARBASE DESTROYED..")) - for ll in range(game.state.rembase): - if 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.baseq = filter(lambda x: x != game.quadrant, game.state.baseq) + game.quad[w.i][w.j]=IHDOT + game.base.invalidate() + game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase -= 1 + game.state.chart[game.quadrant.i][game.quadrant.j].starbase -= 1 game.state.basekl += 1 newcnd() return None elif iquad == IHP: # Hit a planet - crmena(True, iquad, "sector", w) - prout(_(" destroyed.")) + prout(crmena(True, iquad, "sector", w) + _(" destroyed.")) game.state.nplankl += 1 - game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None + game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None game.iplnet.pclass = "destroyed" game.iplnet = None - invalidate(game.plnet) - game.quad[w.x][w.y] = IHDOT + game.plnet.invalidate() + game.quad[w.i][w.j] = 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.")) + prout(crmena(True, iquad, "sector", w) + _(" destroyed.")) game.state.nworldkl += 1 - game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None + game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None game.iplnet.pclass = "destroyed" game.iplnet = None - invalidate(game.plnet) - game.quad[w.x][w.y] = IHDOT + game.plnet.invalidate() + game.quad[w.i][w.j] = 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.")) + prout(_("The torpedo destroyed an inhabited planet.")) return None elif iquad == IHSTAR: # Hit a star if withprob(0.9): nova(w) else: - crmena(True, IHSTAR, "sector", w) - prout(_(" unaffected by photon blast.")) + prout(crmena(True, IHSTAR, "sector", w) + _(" unaffected by photon blast.")) return None elif iquad == IHQUEST: # Hit a thingy if not (game.options & OPTION_THINGY) or withprob(0.3): @@ -1504,18 +1246,15 @@ def torpedo(course, r, incoming, i, n): 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. - # thing.angry = True shoved = True return None elif iquad == IHBLANK: # Black hole skip(1) - crmena(True, IHBLANK, "sector", w) - prout(_(" swallows torpedo.")) + prout(crmena(True, IHBLANK, "sector", w) + _(" swallows torpedo.")) return None elif iquad == IHWEB: # hit the web skip(1) @@ -1523,46 +1262,36 @@ def torpedo(course, r, incoming, i, n): return None elif iquad == IHT: # Hit a Tholian h1 = 700.0 + randrange(100) - \ - 1000.0 * distance(w, incoming) * math.fabs(math.sin(bullseye-angle)) + 1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle)) h1 = math.fabs(h1) if h1 >= 600: - game.quad[w.x][w.y] = IHDOT + game.quad[w.i][w.j] = IHDOT deadkl(w, iquad, w) game.tholian = None return None skip(1) - crmena(True, IHT, "sector", w) + proutn(crmena(True, IHT, "sector", w)) if withprob(0.05): prout(_(" survives photon blast.")) return None prout(_(" disappears.")) game.tholian.move(None) - game.quad[w.x][w.y] = IHWEB + game.quad[w.i][w.j] = IHWEB dropin(IHBLANK) return None else: # Problem! skip(1) proutn("Don't know how to handle torpedo collision with ") - crmena(True, iquad, "sector", w) + proutn(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(len(game.enemies)): - game.enemies[ll].kdist = game.enemies[ll].kavgd = distance(game.sector,game.enemies[ll].kloc) - game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist)) - return None skip(1) prout(_("Torpedo missed.")) return None; def fry(hit): - # critical-hit resolution + "Critical-hit resolution." if hit < (275.0-25.0*game.skill)*randreal(1.0, 1.5): return ncrit = int(1.0 + hit/(500.0+randreal(100))) @@ -1582,7 +1311,7 @@ def fry(hit): for (i, j) in enumerate(cdam): proutn(device[j]) if skipcount % 3 == 2 and i < len(cdam)-1: - skip() + skip(1) skipcount += 1 if i < len(cdam)-1: proutn(_(" and ")) @@ -1594,12 +1323,12 @@ def fry(hit): def attack(torps_ok): # bad guy attacks us # torps_ok == False forces use of phasers in an attack + # game could be over at this point, check + if game.alldone: + return attempt = False; ihurt = False; hitmax=0.0; hittot=0.0; chgfac=1.0 where = "neither" - # game could be over at this point, check - if game.alldone: - return if idebug: prout("=== ATTACK!") # Tholian gets to move before attacking @@ -1610,7 +1339,7 @@ def attack(torps_ok): 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: + if (((game.quadrant in game.state.kcmdr or game.state.kscmdr==game.quadrant) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok: moveklings() # if no enemies remain after movement, we're done if len(game.enemies)==0 or (len(game.enemies)==1 and thing == game.quadrant and not thing.angry): @@ -1646,24 +1375,24 @@ def attack(torps_ok): if game.condition == "docked": continue; # Don't waste the effort! attempt = True; # Attempt to attack - dustfac = 0.8 + randreal(0.5) + dustfac = randreal(0.8, 0.85) hit = enemy.kpower*math.pow(dustfac,enemy.kavgd) enemy.kpower *= 0.75 else: # Enemy uses photon torpedo - course = 1.90985*math.atan2(game.sector.y-enemy.kloc.y, enemy.kloc.x-game.sector.x) + # We should be able to make the bearing() method work here + course = 1.90985*math.atan2(game.sector.j-enemy.kloc.j, enemy.kloc.i-game.sector.i) hit = 0 proutn(_("***TORPEDO INCOMING")) if not damaged(DSRSENS): - proutn(_(" From ")) - crmena(False, enemy.type, where, enemy.kloc) + proutn(_(" From ") + crmena(False, enemy.type, where, enemy.kloc)) attempt = True prout(" ") - r = (randreal()+randreal())*0.5 - 0.5 - r += 0.002*enemy.kpower*r - hit = torpedo(course, r, enemy.kloc, 1, 1) - if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + dispersion = (randreal()+randreal())*0.5 - 0.5 + dispersion += 0.002*enemy.kpower*dispersion + hit = torpedo(enemy.kloc, course, dispersion, number=1, nburst=1) + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0: finish(FWON); # Klingons did themselves in! - if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova or game.alldone: + if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone: return # Supernova or finished if hit == None: continue @@ -1691,11 +1420,9 @@ def attack(torps_ok): ihurt = True proutn(_("%d unit hit") % int(hit)) if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR: - proutn(_(" on the ")) - crmshp() + proutn(_(" on the ") + crmshp()) if not damaged(DSRSENS) and usephasers: - proutn(_(" from ")) - crmena(False, enemy.type, where, enemy.kloc) + prout(_(" from ") + crmena(False, enemy.type, where, enemy.kloc)) skip(1) # Decide if hit is critical if hit > hitmax: @@ -1714,7 +1441,7 @@ def attack(torps_ok): # Shields fully protect ship proutn(_("Enemy attack reduces shield strength to ")) else: - # Print message if starship suffered hit(s) + # Emit message if starship suffered hit(s) skip(1) proutn(_("Energy left %2d shields ") % int(game.energy)) if game.shldup: @@ -1726,7 +1453,7 @@ def attack(torps_ok): prout(_("%d%%, torpedoes left %d") % (percent, game.torps)) # Check if anyone was hurt if hitmax >= 200 or hittot >= 500: - icas = randrange(hittot * 0.015) + icas = randrange(int(hittot * 0.015)) if icas >= 2: skip(1) prout(_("Mc Coy- \"Sickbay to bridge. We suffered %d casualties") % icas) @@ -1740,13 +1467,13 @@ def attack(torps_ok): return def deadkl(w, type, mv): - # kill a Klingon, Tholian, Romulan, or Thingy + "Kill a Klingon, Tholian, Romulan, or Thingy." # Added mv to allow enemy to "move" before dying - crmena(True, type, "sector", mv) + proutn(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 + # Chalk up a Romulan + game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans -= 1 game.irhere -= 1 game.state.nromrem -= 1 elif type == IHT: @@ -1757,35 +1484,28 @@ def deadkl(w, type, mv): global thing thing = None else: - # Some type of a Klingon - game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons -= 1 + # Killed some type of Klingon + game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1 game.klhere -= 1 if type == IHC: - game.comhere = False - for i in range(game.state.remcom): - if 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 + game.state.kcmdr.remove(game.quadrant) unschedule(FTBEAM) - if game.state.remcom != 0: - schedule(FTBEAM, expran(1.0*game.incom/game.state.remcom)) + if game.state.kcmdr: + schedule(FTBEAM, expran(1.0*game.incom/len(game.state.kcmdr))) if is_scheduled(FCDBAS) and game.battle == game.quadrant: unschedule(FCDBAS) 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.state.kscmdr.invalidate() + game.isatb = 0 game.iscate = False unschedule(FSCMOVE) unschedule(FSCDBAS) # For each kind of enemy, finish message to player prout(_(" destroyed.")) - if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0: return game.recompute() # Remove enemy ship from arrays describing local conditions @@ -1795,108 +1515,101 @@ def deadkl(w, type, mv): break return -def targetcheck(x, y): - # Return None if target is invalid - if not VALID_SECTOR(x, y): +def targetcheck(w): + "Return None if target is invalid, otherwise return a course angle." + if not w.valid_sector(): huh() return None - deltx = 0.1*(y - game.sector.y) - delty = 0.1*(x - game.sector.x) - if deltx==0 and delty== 0: + delta = coord() + # FIXME: C code this was translated from is wacky -- why the sign reversal? + delta.j = (w.j - game.sector.j); + delta.i = (game.sector.i - w.i); + if delta == coord(0, 0): skip(1) prout(_("Spock- \"Bridge to sickbay. Dr. McCoy,")) prout(_(" I recommend an immediate review of")) prout(_(" the Captain's psychological profile.\"")) - chew() + scanner.chew() return None - return 1.90985932*math.atan2(deltx, delty) + return delta.bearing() def photon(): - # launch photon torpedo + "Launch photon torpedo." + course = [] game.ididit = False if damaged(DPHOTON): prout(_("Photon tubes damaged.")) - chew() + scanner.chew() return if game.torps == 0: prout(_("No torpedoes left.")) - chew() + scanner.chew() return - key = scan() + # First, get torpedo count while True: - if key == IHALPHA: + scanner.next() + if scanner.token == "IHALPHA": huh() return - elif key == IHEOL: + elif scanner.token == "IHEOL" or not scanner.waiting(): prout(_("%d torpedoes left.") % game.torps) + scanner.chew() proutn(_("Number of torpedoes to fire- ")) - key = scan() - else: # key == IHREAL { - n = aaitem + 0.5 + continue # Go back around to get a number + else: # key == "IHREAL" + n = scanner.int() if n <= 0: # abort command - chew() + scanner.chew() return - if n > 3: - chew() - prout(_("Maximum of 3 torpedoes per burst.")) - key = IHEOL + if n > MAXBURST: + scanner.chew() + prout(_("Maximum of %d torpedoes per burst.") % MAXBURST) 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: + if n > game.torps: + scanner.chew() # User requested more torps than available + continue # Go back around + break # All is good, go to next stage + # Next, get targets + target = [] + for i in range(n): + key = scanner.next() + if i==0 and key == "IHEOL": + break; # no coordinate waiting, we will try prompting + if i==1 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] + while i < n: + target.append(target[0]) + course.append(course[0]) 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: + scanner.push(scanner.token) + target.append(scanner.getcoord()) + if target[-1] == None: + return + course.append(targetcheck(target[-1])) + if course[-1] == None: return - chew() - if i == 1 and key == IHEOL: + scanner.chew() + if len(target) == 0: # 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] = int(aaitem-0.5) - key = scan() - if key != IHREAL: - huh() - return - targ[i][2] = int(aaitem-0.5) - chew() - course[i] = targetcheck(targ[i][1], targ[i][2]) - if course[i] == None: + for i in range(n): + proutn(_("Target sector for torpedo number %d- ") % (i+1)) + scanner.chew() + target.append(scanner.getcoord()) + if target[-1] == None: + return + course.append(targetcheck(target[-1])) + if course[-1] == None: return game.ididit = True # Loop for moving torpedoes for i in range(n): if game.condition != "docked": game.torps -= 1 - r = (randreal()+randreal())*0.5 -0.5 - if math.fabs(r) >= 0.47: + dispersion = (randreal()+randreal())*0.5 -0.5 + if math.fabs(dispersion) >= 0.47: # misfire! - r *= randreal(1.2, 2.2) + dispersion *= randreal(1.2, 2.2) if n > 0: prouts(_("***TORPEDO NUMBER %d MISFIRES") % (i+1)) else: @@ -1909,15 +1622,15 @@ def photon(): game.damage[DPHOTON] = game.damfac * randreal(1.0, 3.0) 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: + dispersion *= 1.0 + 0.0001*game.shield + torpedo(game.sector, course[i], dispersion, number=i, nburst=n) + if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova: return - if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0: finish(FWON); def overheat(rpow): - # check for phasers overheating + "Check for phasers overheating." if rpow > 1500: checkburn = (rpow-1500.0)*0.00038 if withprob(checkburn): @@ -1925,7 +1638,7 @@ def overheat(rpow): game.damage[DPHASER] = game.damfac* randreal(1.0, 2.0) * (1.0+checkburn) def checkshctrl(rpow): - # check shield control + "Check shield control." skip(1) if withprob(0.998): prout(_("Shields lowered.")) @@ -1945,7 +1658,7 @@ def checkshctrl(rpow): prouts(_("Sulu- \"Captain! Shield malfunction! Phaser fire contained!\"")) skip(2) prout(_("Lt. Uhura- \"Sir, all decks reporting damage.\"")) - icas = randrange(hit*0.012) + icas = randrange(int(hit*0.012)) skip(1) fry(0.8*hit) if icas: @@ -1961,8 +1674,8 @@ def checkshctrl(rpow): return True; def hittem(hits): - # register a phaser hit on Klingons and Romulans - nenhr2 = game.nenhere; kk=0 + "Register a phaser hit on Klingons and Romulans." + nenhr2 = len(game.enemies); kk=0 w = coord() skip(1) for (k, wham) in enumerate(hits): @@ -1986,14 +1699,14 @@ def hittem(hits): proutn(_("%d unit hit on ") % int(hit)) else: proutn(_("Very small hit on ")) - ienm = game.quad[w.x][w.y] + ienm = game.quad[w.i][w.j] if ienm==IHQUEST: thing.angry = True - crmena(False, ienm, "sector", w) + proutn(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: + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0: finish(FWON); if game.alldone: return @@ -2008,64 +1721,64 @@ def hittem(hits): return def phasers(): - # fire phasers + "Fire phasers at bad guys." hits = [] kz = 0; k = 1; irec=0 # Cheating inhibitor ifast = False; no = False; itarg = True; msgflag = True; rpow=0 automode = "NOTSET" key=0 skip(1) - # SR sensors and Computer are needed fopr automode + # SR sensors and Computer are needed for automode if damaged(DSRSENS) or damaged(DCOMPTR): itarg = False if game.condition == "docked": prout(_("Phasers can't be fired through base shields.")) - chew() + scanner.chew() return if damaged(DPHASER): prout(_("Phaser control damaged.")) - chew() + scanner.chew() return if game.shldup: if damaged(DSHCTRL): prout(_("High speed shield control damaged.")) - chew() + scanner.chew() return if game.energy <= 200.0: prout(_("Insufficient energy to activate high-speed shield control.")) - chew() + scanner.chew() return prout(_("Weapons Officer Sulu- \"High-speed shield control enabled, sir.\"")) ifast = True # Original code so convoluted, I re-did it all # (That was Tom Almy talking about the C code, I think -- ESR) while automode=="NOTSET": - key=scan() - if key == IHALPHA: - if isit("manual"): - if game.nenhere==0: + key=scanner.next() + if key == "IHALPHA": + if scanner.sees("manual"): + if len(game.enemies)==0: prout(_("There is no enemy present to select.")) - chew() - key = IHEOL + scanner.chew() + key = "IHEOL" automode="AUTOMATIC" else: automode = "MANUAL" - key = scan() - elif isit("automatic"): - if (not itarg) and game.nenhere != 0: + key = scanner.next() + elif scanner.sees("automatic"): + if (not itarg) and len(game.enemies) != 0: automode = "FORCEMAN" else: - if game.nenhere==0: + if len(game.enemies)==0: prout(_("Energy will be expended into space.")) automode = "AUTOMATIC" - key = scan() - elif isit("no"): + key = scanner.next() + elif scanner.sees("no"): no = True else: huh() return - elif key == IHREAL: - if game.nenhere==0: + elif key == "IHREAL": + if len(game.enemies)==0: prout(_("Energy will be expended into space.")) automode = "AUTOMATIC" elif not itarg: @@ -2073,62 +1786,62 @@ def phasers(): else: automode = "AUTOMATIC" else: - # IHEOL - if game.nenhere==0: + # "IHEOL" + if len(game.enemies)==0: prout(_("Energy will be expended into space.")) automode = "AUTOMATIC" elif not itarg: automode = "FORCEMAN" else: proutn(_("Manual or automatic? ")) - chew() + scanner.chew() avail = game.energy if ifast: avail -= 200.0 if automode == "AUTOMATIC": - if key == IHALPHA and isit("no"): + if key == "IHALPHA" and scanner.sees("no"): no = True - key = scan() - if key != IHREAL and game.nenhere != 0: + key = scanner.next() + if key != "IHREAL" and len(game.enemies) != 0: prout(_("Phasers locked on target. Energy available: %.2f")%avail) irec=0 while True: - chew() + scanner.chew() if not kz: - for i in range(game.nenhere): + for i in range(len(game.enemies)): irec += math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0 kz=1 proutn(_("%d units required. ") % irec) - chew() + scanner.chew() proutn(_("Units to fire= ")) - key = scan() - if key!=IHREAL: + key = scanner.next() + if key!="IHREAL": return - rpow = aaitem + rpow = scanner.real if rpow > avail: proutn(_("Energy available= %.2f") % avail) skip(1) - key = IHEOL + key = "IHEOL" if not rpow > avail: break if rpow<=0: # chicken out - chew() + scanner.chew() return - key=scan() - if key == IHALPHA and isit("no"): + key=scanner.next() + if key == "IHALPHA" and scanner.sees("no"): no = True if ifast: game.energy -= 200; # Go and do it! if checkshctrl(rpow): return - chew() + scanner.chew() game.energy -= rpow extra = rpow - if game.nenhere: + if len(game.enemies): extra = 0.0 powrem = rpow - for i in range(game.nenhere): + for i in range(len(game.enemies)): hits.append(0.0) if powrem <= 0: continue @@ -2148,14 +1861,14 @@ def phasers(): if extra > 0 and not game.alldone: if game.tholian: proutn(_("*** Tholian web absorbs ")) - if game.nenhere>0: + if len(game.enemies)>0: proutn(_("excess ")) prout(_("phaser energy.")) else: prout(_("%d expended on empty space.") % int(extra)) elif automode == "FORCEMAN": - chew() - key = IHEOL + scanner.chew() + key = "IHEOL" if damaged(DCOMPTR): prout(_("Battle computer damaged, manual fire only.")) else: @@ -2168,25 +1881,24 @@ def phasers(): skip(1) elif automode == "MANUAL": rpow = 0.0 - for k in range(game.nenhere): + for k in range(len(game.enemies)): aim = game.enemies[k].kloc - ienm = game.quad[aim.x][aim.y] + ienm = game.quad[aim.i][aim.j] 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 + if damaged(DSRSENS) and \ + not game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS): + prout(cramen(ienm) + _(" can't be located without short range scan.")) + scanner.chew() + key = "IHEOL" hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko k += 1 continue - if key == IHEOL: - chew() + if key == "IHEOL": + scanner.chew() if itarg and k > kz: irec=(abs(game.enemies[k].kpower)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) * randreal(1.01, 1.06) + 1.0 kz = k @@ -2196,42 +1908,40 @@ def phasers(): else: proutn("??") proutn(") ") - proutn(_("units to fire at ")) - crmena(False, ienm, "sector", aim) - proutn("- ") - key = scan() - if key == IHALPHA and isit("no"): + proutn(_("units to fire at %s- ") % crmena(False, ienm, "sector", aim)) + key = scanner.next() + if key == "IHALPHA" and scanner.sees("no"): no = True - key = scan() + key = scanner.next() continue - if key == IHALPHA: + if key == "IHALPHA": huh() return - if key == IHEOL: + if key == "IHEOL": if k==1: # Let me say I'm baffled by this msgflag = True continue - if aaitem < 0: + if scanner.real < 0: # abort out - chew() + scanner.chew() return - hits[k] = aaitem - rpow += aaitem + hits[k] = scanner.real + rpow += scanner.real # If total requested is too much, inform and start over if rpow > avail: prout(_("Available energy exceeded -- try again.")) - chew() + scanner.chew() return - key = scan(); # scan for next value + key = scanner.next(); # scan for next value k += 1 if rpow == 0.0: # zero energy -- abort - chew() + scanner.chew() return - if key == IHALPHA and isit("no"): + if key == "IHALPHA" and scanner.sees("no"): no = True game.energy -= rpow - chew() + scanner.chew() if ifast: game.energy -= 200.0 if checkshctrl(rpow): @@ -2244,7 +1954,7 @@ def phasers(): if ifast: skip(1) if no == 0: - if withprob(0.99): + if withprob(0.01): prout(_("Sulu- \"Sir, the high-speed shield control has malfunctioned . . .")) prouts(_(" CLICK CLICK POP . . .")) prout(_(" No response, sir!")) @@ -2263,29 +1973,29 @@ def phasers(): # BSD Trek, from which we swiped the idea, can have up to 5. def unschedule(evtype): - # remove an event from the schedule + "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 + "Is an event of specified type scheduled." return game.future[evtype].date != FOREVER def scheduled(evtype): - # when will this event happen? + "When will this event happen?" return game.future[evtype].date def schedule(evtype, offset): - # schedule an event of specified type + "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 + "Postpone a scheduled event." game.future[evtype].date += offset def cancelrest(): - # rest period is interrupted by event + "Rest period is interrupted by event." if game.resting: skip(1) proutn(_("Mr. Spock- \"Captain, shall we cancel the rest period?\"")) @@ -2296,7 +2006,7 @@ def cancelrest(): return False def events(): - # run through the event queue looking for things to do + "Run through the event queue looking for things to do." i=0 fintim = game.state.date + game.optime; yank=0 ictbeam = False; istract = False @@ -2304,13 +2014,11 @@ def events(): ev = event(); ev2 = event() def tractorbeam(yank): - # tractor beaming cases merge here + "Tractor-beaming cases merge here." 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--")) + prout("***" + crmshp() + _(" caught in long range tractor beam--")) # If Kirk & Co. screwing around on planet, handle atover(True) # atover(true) is Grab if game.alldone: @@ -2333,8 +2041,7 @@ def events(): else: game.quadrant = game.state.kcmdr[i] game.sector = randplace(QUADSIZE) - crmshp() - prout(_(" is pulled to Quadrant %s, Sector %s") \ + prout(crmshp() + _(" is pulled to Quadrant %s, Sector %s") \ % (game.quadrant, game.sector)) if game.resting: prout(_("(Remainder of rest/repair period cancelled.)")) @@ -2345,27 +2052,27 @@ def events(): game.shldchg = False else: prout(_("(Shields not currently useable.)")) - newqad(False) + newqad() # Adjust finish time to time of tractor beaming fintim = game.state.date+game.optime - attack(False) - if game.state.remcom <= 0: + attack(torps_ok=False) + if not game.state.kcmdr: unschedule(FTBEAM) else: - schedule(FTBEAM, game.optime+expran(1.5*game.intime/game.state.remcom)) + schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr))) def destroybase(): - # Code merges here for any commander destroying base + "Code merges here for any commander destroying a starbase." # Not perfect, but will have to do # Handle case where base is in same quadrant as starship if 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 + game.state.chart[game.battle.i][game.battle.j].starbase = False + game.quad[game.base.i][game.base.j] = IHDOT + game.base.invalidate() newcnd() skip(1) prout(_("Spock- \"Captain, I believe the starbase has been destroyed.\"")) - elif game.state.rembase != 1 and communicating(): + elif game.state.baseq and communicating(): # Get word via subspace radio announce() skip(1) @@ -2375,20 +2082,16 @@ def events(): prout(_("the Klingon Super-Commander")) else: prout(_("a Klingon Commander")) - game.state.chart[game.battle.x][game.battle.y].starbase = False + game.state.chart[game.battle.i][game.battle.j].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 game.state.baseq[i] == game.battle: - game.state.baseq[i] = game.state.baseq[game.state.rembase] - game.state.rembase -= 1 + game.state.galaxy[game.battle.i][game.battle.j].starbase = False + game.state.baseq = filter(lambda x: x != game.battle, game.state.baseq) if game.isatb == 2: # reinstate a commander's base attack game.battle = hold game.isatb = 0 else: - invalidate(game.battle) - + game.battle.invalidate() if idebug: prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim)) for i in range(1, NEVENTS): @@ -2408,7 +2111,7 @@ def events(): else: prout("never") radio_was_broken = damaged(DRADIO) - hold.x = hold.y = 0 + hold.i = hold.j = 0 while True: # Select earliest extraneous event, evcode==0 if no events evcode = FSPY @@ -2424,7 +2127,7 @@ def events(): 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.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime game.recompute() if game.state.remtime <=0: finish(FDEPLETE) @@ -2467,9 +2170,9 @@ def events(): game.optime -= xtime if evcode == FSNOVA: # Supernova announce() - supernova(False) + supernova(None) schedule(FSNOVA, expran(0.5*game.intime)) - if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova: return elif evcode == FSPY: # Check with spy to see if SC should tractor beam if game.state.nscrem == 0 or \ @@ -2484,19 +2187,19 @@ def events(): (game.torps < 5 or damaged(DPHOTON))): # Tractor-beam her! istract = ictbeam = True - tractorbeam(distance(game.state.kscmdr, game.quadrant)) + tractorbeam((game.state.kscmdr-game.quadrant).distance()) else: return elif evcode == FTBEAM: # Tractor beam - if game.state.remcom == 0: + if not game.state.kcmdr: unschedule(FTBEAM) continue - i = randrange(game.state.remcom) - yank = distance(game.state.kcmdr[i], game.quadrant) + i = randrange(len(game.state.kcmdr)) + yank = (game.state.kcmdr[i]-game.quadrant).distance() 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)) + game.optime + expran(1.5*game.intime/len(game.state.kcmdr))) continue ictbeam = True tractorbeam(yank) @@ -2505,27 +2208,25 @@ def events(): 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: + if not game.state.kcmdr or not game.state.baseq: # no can do unschedule(FBATTAK) unschedule(FCDBAS) continue - i = 0 - for j in range(game.state.rembase): - for k in range(game.state.remcom): - if game.state.baseq[j] == game.state.kcmdr[k] and \ - not game.state.baseq[j] == game.quadrant and \ - not 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 + try: + for ibq in game.state.baseq: + for cmdr in game.state.kcmdr: + if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr: + raise ibq + else: + # no match found -- try later + schedule(FBATTAK, expran(0.3*game.intime)) + unschedule(FCDBAS) + continue + except coord: + pass # commander + starbase combination found -- launch attack - game.battle = game.state.baseq[j] + game.battle = ibq schedule(FCDBAS, randreal(1.0, 4.0)) if game.isatb: # extra time if SC already attacking postpone(FCDBAS, scheduled(FSCDBAS)-game.state.date) @@ -2544,7 +2245,7 @@ def events(): 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: + if not game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].starbase: continue # WAS RETURN! hold = game.battle game.battle = game.state.kscmdr @@ -2552,14 +2253,16 @@ def events(): elif evcode == FCDBAS: # Commander succeeds in destroying base if evcode==FCDBAS: unschedule(FCDBAS) + if not game.state.baseq() \ + or not game.state.galaxy[game.battle.i][game.battle.j].starbase: + game.battle.invalidate() + continue # find the lucky pair - for i in range(game.state.remcom): - if game.state.kcmdr[i] == game.battle: + for cmdr in game.state.kcmdr: + if cmdr == 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: + else: # No action to take after all - invalidate(game.battle) continue destroybase() elif evcode == FSCMOVE: # Supercommander moves @@ -2569,45 +2272,36 @@ def events(): 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: + if not game.probe.next(): + if not game.probe.quadrant().valid_quadrant() or \ + game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova: # Left galaxy or ran into supernova - if comunicating(): + if communicating(): announce() skip(1) proutn(_("Lt. Uhura- \"The deep space probe ")) - if not VALID_QUADRANT(j, i): - proutn(_("has left the galaxy")) + if not game.probe.quadrant().valid_quadrant(): + prout(_("has left the galaxy.\"")) else: - proutn(_("is no longer transmitting")) - prout(".\"") + prout(_("is no longer transmitting.\"")) unschedule(FDSPROB) continue - if not communicating(): - announce() + if communicating(): + #announce() skip(1) - proutn(_("Lt. Uhura- \"The deep space probe is now in Quadrant %s.\"") % game.probec) - pdest = game.state.galaxy[game.probec.x][game.probec.y] - # Update star chart if Radio is working or have access to radio + prout(_("Lt. Uhura- \"The deep space probe is now in Quadrant %s.\"") % game.probe.quadrant()) + pdest = game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j] if communicating(): - chp = game.state.chart[game.probec.x][game.probec.y] + chp = game.state.chart[game.probe.quadrant().i][game.probe.quadrant().j] 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) + game.probe.moves -= 1 # One less to travel + if game.probe.arrived() and game.isarmed and pdest.stars: + supernova(game.probe) # fire in the hole! unschedule(FDSPROB) - if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + if game.state.galaxy[game.quadrant().i][game.quadrant().j].supernova: return elif evcode == FDISTR: # inhabited system issues distress call unschedule(FDISTR) @@ -2618,7 +2312,7 @@ def events(): # 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] + q = game.state.galaxy[w.i][w.j] if not (game.quadrant == w or q.planet == None or \ not q.planet.inhabited or \ q.supernova or q.status!="secure" or q.klingons<=0): @@ -2631,8 +2325,7 @@ def events(): # got one!! Schedule its enslavement ev = schedule(FENSLV, expran(game.intime)) ev.quadrant = w - q.status = distressed - + q.status = "distressed" # tell the captain about it if we can if communicating(): prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \ @@ -2643,7 +2336,7 @@ def events(): 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] + q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j] if q.klingons <= 0: q.status = "secure" continue @@ -2663,7 +2356,7 @@ def events(): # 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] + q = game.state.galaxy[ev.quadrant.i][ev.quadrant.j] if q.klingons <= 0: q.status = "secure" continue @@ -2671,14 +2364,15 @@ def events(): continue # full right now # reproduce one Klingon w = ev.quadrant + m = coord() 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): + for m.i in range(w.i - 1, w.i + 2): + for m.j in range(w.j - 1, w.j + 2): + if not m.valid_quadrant(): continue - q = game.state.galaxy[w.x][w.y] + q = game.state.galaxy[m.i][m.j] # check for this quad ok (not full & no snova) if q.klingons >= MAXKLQUAD or q.supernova: continue @@ -2686,8 +2380,7 @@ def events(): else: continue # search for eligible quadrant failed except "FOUNDIT": - w.x = i - w.y = j + w = m # deliver the child game.state.remkl += 1 q.klingons += 1 @@ -2696,7 +2389,6 @@ def events(): game.enemies.append(newkling()) # recompute time left game.recompute() - # report the disaster if we can if communicating(): if game.quadrant == w: prout(_("Spock- sensors indicate the Klingons have")) @@ -2708,21 +2400,21 @@ def events(): prout(_("in Quadrant %s.") % w) def wait(): - # wait on events + "Wait on events." game.ididit = False while True: - key = scan() - if key != IHEOL: + key = scanner.next() + if key != "IHEOL": break proutn(_("How long? ")) - chew() - if key != IHREAL: + scanner.chew() + if key != "IHREAL": huh() return - origTime = delay = aaitem + origTime = delay = scanner.real if delay <= 0.0: return - if delay >= game.state.remtime or game.nenhere != 0: + if delay >= game.state.remtime or len(game.enemies) != 0: proutn(_("Are you sure? ")) if ja() == False: return @@ -2735,13 +2427,13 @@ def wait(): prout(_("%d stardates left.") % int(game.state.remtime)) return temp = game.optime = delay - if game.nenhere: + if len(game.enemies): rtime = randreal(1.0, 2.0) if rtime < temp: temp = rtime game.optime = temp if game.optime < delay: - attack(False) + attack(torps_ok=False) if game.alldone: return events() @@ -2753,31 +2445,23 @@ def wait(): 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: + if game.state.galaxy[game.quadrant.i][game.quadrant.j].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 + "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(); neighbor = coord(); bump = coord(0, 0) if withprob(0.05): # Wow! We've supernova'ed - supernova(False, nov) + supernova(game.quadrant) 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.quad[nov.i][nov.j] = IHDOT + prout(crmena(False, IHSTAR, "sector", nov) + _(" novas.")) + game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1 game.state.starkl += 1 # Set up queue to recursively trigger adjacent stars hits = [nov] @@ -2785,58 +2469,52 @@ def nova(nov): while hits: offset = coord() start = hits.pop() - for offset.x in range(-1, 1+1): - for offset.y in range(-1, 1+1): - if offset.y==0 and offset.x==0: + for offset.i in range(-1, 1+1): + for offset.j in range(-1, 1+1): + if offset.j==0 and offset.i==0: continue neighbor = start + offset - if not VALID_SECTOR(neighbor.y, neighbor.x): + if not neighbor.valid_sector(): continue - iquad = game.quad[neighbor.x][neighbor.y] + iquad = game.quad[neighbor.i][neighbor.j] # Empty space ends reaction if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB): pass elif iquad == IHSTAR: # Affect another star if withprob(0.05): # This star supernovas - supernova(False) + supernova(game.quadrant) return else: hits.append(neighbor) - game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1 + game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1 game.state.starkl += 1 - crmena(True, IHSTAR, "sector", neighbor) + proutn(crmena(True, IHSTAR, "sector", neighbor)) prout(_(" novas.")) - game.quad[neighbor.x][neighbor.y] = IHDOT + game.quad[neighbor.i][neighbor.j] = IHDOT kount += 1 elif iquad in (IHP, IHW): # Destroy planet - game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None + game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None if iquad == IHP: game.state.nplankl += 1 else: game.state.worldkl += 1 - crmena(True, iquad, "sector", neighbor) - prout(_(" destroyed.")) + prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed.")) game.iplnet.pclass = "destroyed" game.iplnet = None - invalidate(game.plnet) + game.plnet.invalidate() if game.landed: finish(FPNOVA) return - game.quad[neighbor.x][neighbor.y] = IHDOT + game.quad[neighbor.i][neighbor.j] = IHDOT elif iquad == IHB: # Destroy base - game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase = False - for i in range(game.state.rembase): - if 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.galaxy[game.quadrant.i][game.quadrant.j].starbase = False + game.state.baseq = filter(lambda x: x!= game.quadrant, game.state.baseq) + game.base.invalidate() game.state.basekl += 1 newcnd() - crmena(True, IHB, "sector", neighbor) - prout(_(" destroyed.")) - game.quad[neighbor.x][neighbor.y] = IHDOT + prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed.")) + game.quad[neighbor.i][neighbor.j] = IHDOT elif iquad in (IHE, IHF): # Buffet ship prout(_("***Starship buffeted by nova.")) if game.shldup: @@ -2859,7 +2537,7 @@ def nova(nov): elif iquad == IHK: # kill klingon deadkl(neighbor, iquad, neighbor) elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies - for ll in range(game.nenhere): + for ll in range(len(game.enemies)): if game.enemies[ll].kloc == neighbor: break game.enemies[ll].kpower -= 800.0 # If firepower is lost, die @@ -2867,16 +2545,14 @@ def nova(nov): deadkl(neighbor, iquad, neighbor) break newc = neighbor + neighbor - hits[mm] - crmena(True, iquad, "sector", neighbor) - proutn(_(" damaged")) - if not VALID_SECTOR(newc.x, newc.y): + proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged")) + if not newc.valid_sector(): # can't leave quadrant skip(1) break - iquad1 = game.quad[newc.x][newc.y] + iquad1 = game.quad[newc.i][newc.j] if iquad1 == IHBLANK: - proutn(_(", blasted into ")) - crmena(False, IHBLANK, "sector", newc) + proutn(_(", blasted into ") + crmena(False, IHBLANK, "sector", newc)) skip(1) deadkl(neighbor, iquad, newc) break @@ -2885,43 +2561,42 @@ def nova(nov): skip(1) break proutn(_(", buffeted to Sector %s") % newc) - game.quad[neighbor.x][neighbor.y] = IHDOT - game.quad[newc.x][newc.y] = iquad + game.quad[neighbor.i][neighbor.j] = IHDOT + game.quad[newc.i][newc.j] = iquad game.enemies[ll].move(newc) # Starship affected by nova -- kick it away. - game.dist = kount*0.1 - game.direc = course[3*(bump.x+1)+bump.y+2] - if game.direc == 0.0: - game.dist = 0.0 - if game.dist == 0.0: + dist = kount*0.1 + direc = course[3*(bump.i+1)+bump.j+2] + if direc == 0.0: + dist = 0.0 + if dist == 0.0: return - game.optime = 10.0*game.dist/16.0 + course = course(bearing=direc, distance=dist) + game.optime = course.time(warp=4) skip(1) prout(_("Force of nova displaces starship.")) - imove(novapush=True) - game.optime = 10.0*game.dist/16.0 + imove(course, noattack=True) + game.optime = course.time(warp=4) return -def supernova(induced, w=None): - # star goes supernova +def supernova(w): + "Star goes supernova." num = 0; npdead = 0 - nq = coord() if w != None: - nq = w + nq = copy.copy(w) else: + # Scheduled supernova -- select star at random. 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(GALSIZE): - for nq.y in range(GALSIZE): - stars += game.state.galaxy[nq.x][nq.y].stars + nq = coord() + for nq.i in range(GALSIZE): + for nq.j in range(GALSIZE): + stars += game.state.galaxy[nq.i][nq.j].stars if stars == 0: return # nothing to supernova exists num = randrange(stars) + 1 - for nq.x in range(GALSIZE): - for nq.y in range(GALSIZE): - num -= game.state.galaxy[nq.x][nq.y].stars + for nq.i in range(GALSIZE): + for nq.j in range(GALSIZE): + num -= game.state.galaxy[nq.i][nq.j].stars if num <= 0: break if num <=0: @@ -2939,10 +2614,10 @@ def supernova(induced, w=None): else: ns = coord() # we are in the quadrant! - num = randrange(game.state.galaxy[nq.x][nq.y].stars) + 1 - for ns.x in range(QUADSIZE): - for ns.y in range(QUADSIZE): - if game.quad[ns.x][ns.y]==IHSTAR: + num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1 + for ns.i in range(QUADSIZE): + for ns.j in range(QUADSIZE): + if game.quad[ns.i][ns.j]==IHSTAR: num -= 1 if num==0: break @@ -2952,64 +2627,51 @@ def supernova(induced, w=None): 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: + if (ns.i-game.sector.i)**2 + (ns.j-game.sector.j)**2 <= 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 + # destroy any Klingons in supernovaed quadrant + kldead = game.state.galaxy[nq.i][nq.j].klingons + game.state.galaxy[nq.i][nq.j].klingons = 0 if nq == game.state.kscmdr: # did in the Supercommander! - game.state.nscrem = game.state.kscmdr.x = game.state.kscmdr.y = game.isatb = 0 + game.state.nscrem = game.state.kscmdr.i = game.state.kscmdr.j = game.isatb = 0 game.iscate = False unschedule(FSCMOVE) unschedule(FSCDBAS) - if game.state.remcom: - maxloop = game.state.remcom - for l in range(maxloop): - if 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 + survivors = filter(lambda w: w != nq, game.state.kcmdr) + comkills = len(game.state.kcmdr) - len(survivors) + game.state.kcmdr = survivors + kldead -= comkills + if not game.state.kcmdr: + unschedule(FTBEAM) 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 + nrmdead = game.state.galaxy[nq.i][nq.j].romulans + game.state.galaxy[nq.i][nq.j].romulans = 0 game.state.nromrem -= nrmdead # Destroy planets for loop in range(game.inplan): - if game.state.planets[loop].w == nq: + if game.state.planets[loop].quadrant == 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(maxloop): - if 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 + # Destroy any base in supernovaed quadrant + game.state.baseq = filter(lambda x: x != nq, game.state.baseq) # 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 + if w != None: + game.state.starkl += game.state.galaxy[nq.i][nq.j].stars + game.state.basekl += game.state.galaxy[nq.i][nq.j].starbase game.state.nplankl += npdead # mark supernova in galaxy and in star chart if game.quadrant == nq or communicating(): - game.state.galaxy[nq.x][nq.y].supernova = True + game.state.galaxy[nq.i][nq.j].supernova = True # If supernova destroys last Klingons give special message - if (game.state.remkl + game.state.remcom + game.state.nscrem)==0 and not nq == game.quadrant: + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0 and not nq == game.quadrant: skip(2) - if not induced: + if w == None: prout(_("Lucky you!")) proutn(_("A supernova in %s has just destroyed the last Klingons.") % nq) finish(FWON) @@ -3022,9 +2684,8 @@ def supernova(induced, w=None): # Code from finish.c ends here. def selfdestruct(): - # self-destruct maneuver - # Finish with a BANG! - chew() + "Self-destruct maneuver. Finish with a BANG!" + scanner.chew() if damaged(DCOMPTR): prout(_("Computer damaged; cannot execute destruct sequence.")) return @@ -3042,9 +2703,9 @@ def selfdestruct(): skip(1) prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED")) skip(1) - scan() - chew() - if game.passwd != citem: + scanner.next() + scanner.chew() + if game.passwd != scanner.token: prouts(_("PASSWORD-REJECTED;")) skip(1) prouts(_("CONTINUITY-EFFECTED")) @@ -3065,18 +2726,16 @@ def kaboom(): stars() if game.ship==IHE: prouts("***") - prouts(_("********* Entropy of ")) - crmshp() - prouts(_(" maximized *********")) + prouts(_("********* Entropy of %s maximized *********") % crmshp()) skip(1) stars() skip(1) - if game.nenhere != 0: + if len(game.enemies) != 0: whammo = 25.0 * game.energy l=1 - while l <= game.nenhere: + while l <= len(game.enemies): if game.enemies[l].kpower*game.enemies[l].kdist <= whammo: - deadkl(game.enemies[l].kloc, game.quad[game.enemies[l].kloc.x][game.enemies[l].kloc.y], game.enemies[l].kloc) + deadkl(game.enemies[l].kloc, game.quad[game.enemies[l].kloc.i][game.enemies[l].kloc.j], game.enemies[l].kloc) l += 1 finish(FDILITHIUM) @@ -3087,7 +2746,7 @@ def killrate(): return 0 else: starting = (game.inkling + game.incom + game.inscom) - remaining = (game.state.remkl + game.state.remcom + game.state.nscrem) + remaining = (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) return (starting - remaining)/elapsed def badpoints(): @@ -3162,7 +2821,7 @@ def finish(ifin): prout(_("You cannot get a citation, so...")) else: proutn(_("Do you want your Commodore Emeritus Citation printed? ")) - chew() + scanner.chew() if ja() == True: igotit = True # Only grant long life if alive (original didn't!) @@ -3177,7 +2836,7 @@ def finish(ifin): 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): + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)*3.0 > (game.inkling + game.incom + game.inscom): prout(_("acquitted.")) skip(1) prout(_("LIVE LONG AND PROSPER.")) @@ -3196,9 +2855,7 @@ def finish(ifin): skip(1) prout(_("Your starship is a derelict in space.")) elif ifin == FBATTLE: - proutn(_("The ")) - crmshp() - prout(_(" has been destroyed in battle.")) + prout(_("The %s has been destroyed in battle.") % crmshp()) skip(1) prout(_("Dulce et decorum est pro patria mori.")) elif ifin == FNEG3: @@ -3212,9 +2869,7 @@ def finish(ifin): prout(_("That was a great shot.")) skip(1) elif ifin == FSNOVAED: - proutn(_("The ")) - crmshp() - prout(_(" has been fried by a supernova.")) + prout(_("The %s has been fried by a supernova.") % crmshp()) prout(_("...Not even cinders remain...")) elif ifin == FABANDN: prout(_("You have been captured by the Klingons. If you still")) @@ -3227,9 +2882,7 @@ def finish(ifin): 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.")) + prout(_("The %s has been cremated by its own phasers.") % crmshp()) elif ifin == FLOST: prout(_("You and your landing party have been")) prout(_("converted to energy, disipating through space.")) @@ -3239,9 +2892,7 @@ def finish(ifin): skip(1) prout(_("They are very fond of \"Captain Kirk\" soup.")) skip(1) - proutn(_("Without your leadership, the ")) - crmshp() - prout(_(" is destroyed.")) + prout(_("Without your leadership, the %s is destroyed.") % crmshp()) elif ifin == FDPLANET: prout(_("You and your mining party perish.")) skip(1) @@ -3251,25 +2902,19 @@ def finish(ifin): 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.")) + prout(_("Mr. Spock takes command of the %s and") % crmshp()) + prout(_("joins the Romulans, wreaking 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.")) + prout(_("Mr. Spock takes command of the %s and") % crmshp()) + prout(_("joins the Romulans, wreaking 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.")) + prout(_("Without your leadership, the %s is destroyed.") % crmshp()) elif ifin == FDRAY: prout(_("The mutants attack and kill Spock.")) prout(_("Your ship is captured by Klingons, and")) @@ -3290,9 +2935,9 @@ def finish(ifin): elif game.ship == IHE: game.ship = IHF game.alive = False - if (game.state.remkl + game.state.remcom + game.state.nscrem) != 0: + if (game.state.remkl + len(game.state.kcmdr) + 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) + baddies = (game.state.remkl + 2.0*len(game.state.kcmdr))/(game.inkling+2.0*game.incom) if goodies/baddies >= randreal(1.0, 1.5): prout(_("As a result of your actions, a treaty with the Klingon")) prout(_("Empire has been signed. The terms of the treaty are")) @@ -3313,10 +2958,10 @@ def finish(ifin): score() def score(): - # compute player's 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: + if (timused == 0 or (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0: timused = 5.0 perdate = killrate() ithperd = 500*perdate + 0.5 @@ -3332,7 +2977,7 @@ def score(): 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) \ + + 50*(game.incom - len(game.state.kcmdr)) \ + ithperd + iwon \ + 20*(game.inrom - game.state.nromrem) \ + 200*(game.inscom - game.state.nscrem) \ @@ -3351,9 +2996,9 @@ def score(): 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: + if game.incom - len(game.state.kcmdr): prout(_("%6d Klingon commanders destroyed %5d") % - (game.incom - game.state.remcom, 50*(game.incom - game.state.remcom))) + (game.incom - len(game.state.kcmdr), 50*(game.incom - len(game.state.kcmdr)))) if game.inscom - game.state.nscrem: prout(_("%6d Super-Commander destroyed %5d") % (game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem))) @@ -3398,7 +3043,7 @@ def score(): prout(_("TOTAL SCORE %5d") % iscore) def plaque(): - # emit winner's commemmorative plaque + "Emit winner's commemmorative plaque." skip(2) while True: proutn(_("File or device name for your plaque: ")) @@ -3448,7 +3093,7 @@ def plaque(): fp.write(_("Emeritus level\n\n")) else: fp.write(_(" Cheat level\n\n")) - timestring = ctime() + timestring = time.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) @@ -3469,27 +3114,10 @@ message_window = None prompt_window = None curwnd = 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() - sys.stdout.write('\n') - if logfp: - logfp.close() - def iostart(): global stdscr, rows - #setlocale(LC_ALL, "") - #bindtextdomain(PACKAGE, LOCALEDIR) - #textdomain(PACKAGE) - if atexit.register(outro): - sys.stderr.write("Unable to register outro(), exiting...\n") - raise SysExit,1 + gettext.bindtextdomain("sst", "/usr/local/share/locale") + gettext.textdomain("sst") if not (game.options & OPTION_CURSES): ln_env = os.getenv("LINES") if ln_env: @@ -3499,21 +3127,11 @@ def iostart(): 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 + (rows, columns) = stdscr.getmaxyx() fullscreen_window = stdscr srscan_window = curses.newwin(12, 25, 0, 0) report_window = curses.newwin(11, 0, 1, 25) @@ -3523,19 +3141,23 @@ def iostart(): prompt_window = curses.newwin(1, 0, rows-2, 0) message_window.scrollok(True) setwnd(fullscreen_window) - textcolor(DEFAULT) + +def ioend(): + "Wrap up I/O." + if game.options & OPTION_CURSES: + stdscr.keypad(False) + curses.echo() + curses.nocbreak() + curses.endwin() def waitfor(): - "wait for user action -- OK to do nothing if on a TTY" + "Wait for user action -- OK to do nothing if on a TTY" if game.options & OPTION_CURSES: - stsdcr.getch() + stdscr.getch() def announce(): skip(1) - if game.skill > SKILL_FAIR: - prouts(_("[ANOUNCEMENT ARRIVING...]")) - else: - prouts(_("[IMPORTANT ANNOUNCEMENT ARRIVING -- PRESS ENTER TO CONTINUE]")) + prouts(_("[ANNOUNCEMENT ARRIVING...]")) skip(1) def pause_game(): @@ -3547,7 +3169,7 @@ def pause_game(): if game.options & OPTION_CURSES: drawmaps(0) setwnd(prompt_window) - prompt_window.wclear() + prompt_window.clear() prompt_window.addstr(prompt) prompt_window.getstr() prompt_window.clear() @@ -3572,7 +3194,10 @@ def skip(i): pause_game() clrscr() else: - proutn("\n") + try: + curwnd.move(y+1, 0) + except curses.error: + pass else: global linecount linecount += 1 @@ -3595,13 +3220,13 @@ def prout(line): skip(1) def prouts(line): - "print slowly!" + "Emit slowly!" for c in line: if not replayfp or replayfp.closed: # Don't slow down replays time.sleep(0.03) proutn(c) if game.options & OPTION_CURSES: - wrefresh(curwnd) + curwnd.refresh() else: sys.stdout.flush() if not replayfp or replayfp.closed: @@ -3639,8 +3264,8 @@ def setwnd(wnd): def clreol(): "Clear to end of line -- can be a no-op in tty mode" if game.options & OPTION_CURSES: - wclrtoeol(curwnd) - wrefresh(curwnd) + curwnd.clrtoeol() + curwnd.refresh() def clrscr(): "Clear screen -- can be a no-op in tty mode." @@ -3650,45 +3275,7 @@ def clrscr(): 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: @@ -3721,7 +3308,7 @@ def drawmaps(mode): def put_srscan_sym(w, sym): "Emit symbol for short-range scan." - srscan_window.move(w.x+1, w.y*2+2) + srscan_window.move(w.i+1, w.j*2+2) srscan_window.addch(sym) srscan_window.refresh() @@ -3731,12 +3318,12 @@ def boom(w): drawmaps(2) setwnd(srscan_window) srscan_window.attron(curses.A_REVERSE) - put_srscan_sym(w, game.quad[w.x][w.y]) + put_srscan_sym(w, game.quad[w.i][w.j]) #sound(500) #time.sleep(1.0) #nosound() srscan_window.attroff(curses.A_REVERSE) - put_srscan_sym(w, game.quad[w.x][w.y]) + put_srscan_sym(w, game.quad[w.i][w.j]) curses.delay_output(500) setwnd(message_window) @@ -3752,27 +3339,27 @@ def warble(): #nosound() pass -def tracktorpedo(w, l, i, n, iquad): +def tracktorpedo(origin, w, step, i, n, iquad): "Torpedo-track animation." if not game.options & OPTION_CURSES: - if l == 1: + if step == 1: if n != 1: skip(1) - proutn(_("Track for torpedo number %d- ") % i) + proutn(_("Track for torpedo number %d- ") % (i+1)) else: skip(1) proutn(_("Torpedo track- ")) - elif l==4 or l==9: + elif step==4 or step==9: skip(1) - proutn("%d - %d " % (w.x, w.y)) + proutn("%s " % w) else: if not damaged(DSRSENS) or game.condition=="docked": - if i != 1 and l == 1: + if i != 0 and step == 1: drawmaps(2) time.sleep(0.4) if (iquad==IHDOT) or (iquad==IHBLANK): put_srscan_sym(w, '+') - #sound(l*10) + #sound(step*10) #time.sleep(0.1) #nosound() put_srscan_sym(w, iquad) @@ -3785,7 +3372,7 @@ def tracktorpedo(w, l, i, n, iquad): curwnd.attroff(curses.A_REVERSE) put_srscan_sym(w, iquad) else: - proutn("%d - %d " % (w.x, w.y)) + proutn("%s " % w) def makechart(): "Display the current galaxy chart." @@ -3812,195 +3399,164 @@ def prstat(txt, data): # 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 imove(course=None, noattack=False): + "Movement execution for warp, impulse, supernova, and tractor-beam events." + w = coord() - def no_quad_change(): - # No quadrant change -- compute new average enemy distances - game.quad[game.sector.x][game.sector.y] = game.ship - if game.nenhere: - for m in range(game.nenhere): - finald = distance(w, game.enemies[m].kloc) - game.enemies[m].kavgd = 0.5 * (finald+game.enemies[m].kdist) - game.enemies[m].kdist = finald - game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist)) - if not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: - attack(False) - for m in range(game.nenhere): - game.enemies[m].kavgd = game.enemies[m].kdist - newcnd() - drawmaps(0) - setwnd(message_window) - w.x = w.y = 0 + def newquadrant(noattack): + # Leaving quadrant -- allow final enemy attack + # Don't do it if being pushed by Nova + if len(game.enemies) != 0 and not noattack: + newcnd() + for enemy in game.enemies: + finald = (w - enemy.kloc).distance() + enemy.kavgd = 0.5 * (finald + enemy.kdist) + # 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.i][game.quadrant.j].supernova: + attack(torps_ok=False) + if game.alldone: + return + # check for edge of galaxy + kinks = 0 + while True: + kink = False + if course.final.i < 0: + course.final.i = -course.final.i + kink = True + if course.final.j < 0: + course.final.j = -course.final.j + kink = True + if course.final.i >= GALSIZE*QUADSIZE: + course.final.i = (GALSIZE*QUADSIZE*2) - course.final.i + kink = True + if course.final.j >= GALSIZE*QUADSIZE: + course.final.j = (GALSIZE*QUADSIZE*2) - course.final.j + kink = True + if kink: + kinks += 1 + else: + 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 = course.final.quadrant() + game.sector = course.final.sector() + skip(1) + prout(_("Entering Quadrant %s.") % game.quadrant) + game.quad[game.sector.i][game.sector.j] = game.ship + newqad() + if game.skill>SKILL_NOVICE: + attack(torps_ok=False) + + def check_collision(h): + iquad = game.quad[h.i][h.j] + if iquad != IHDOT: + # object encountered in flight path + stopegy = 50.0*course.distance/game.optime + if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST): + for enemy in game.enemies: + if enemy.kloc == game.sector: + break + collision(rammed=False, enemy=enemy) + return True + elif iquad == IHBLANK: + skip(1) + prouts(_("***RED ALERT! RED ALERT!")) + skip(1) + proutn("***" + crmshp()) + proutn(_(" pulled into black hole at Sector %s") % h) + # 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(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 withprob(1-probf): + timwrp() + else: + finish(FHOLE) + return True + else: + # something else + skip(1) + proutn(crmshp()) + if iquad == IHWEB: + prout(_(" encounters Tholian web at %s;") % h) + else: + prout(_(" blocked by object at %s;") % h) + proutn(_("Emergency stop required ")) + prout(_("%2d units of energy.") % int(stopegy)) + game.energy -= stopegy + if game.energy <= 0: + finish(FNRG) + return True + return False + + trbeam = False 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 + course.distance = course.distance*(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 = int(10.0*game.dist*bigger+0.5) - if n > 0: - for m in range(1, n+1): - x += deltax - y += deltay - w.x = int(round(x)) - w.y = int(round(y)) - 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(game.nenhere): - finald = distance(w, game.enemies[m].kloc) - game.enemies[m].kavgd = 0.5 * (finald + game.enemies[m].kdist) - # - # 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)+game.sector.x - y = (QUADSIZE*game.quadrant.y)+game.sector.y - w.x = int(round(x+10.0*game.dist*bigger*deltax)) - w.y = int(round(y+10.0*game.dist*bigger*deltay)) - # check for edge of galaxy - kinks = 0 - while True: - kink = False - if w.x < 0: - w.x = -w.x - kink = True - if w.y < 0: - w.y = -w.y - kink = True - if w.x >= GALSIZE*QUADSIZE: - w.x = (GALSIZE*QUADSIZE*2) - w.x - kink = True - if w.y >= GALSIZE*QUADSIZE: - w.y = (GALSIZE*QUADSIZE*2) - w.y - kink = True - if kink: - kinks += 1 - else: - 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 - game.quadrant.y = w.y/QUADSIZE - game.sector.x = w.x - (QUADSIZE*game.quadrant.x) - game.sector.y = w.y - (QUADSIZE*game.quadrant.y) - 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, IHC, IHS, IHR, IHQUEST): - game.sector = w - for enemy in game.enemies: - if enemy.kloc == game.sector: - break - collision(rammed=False, enemy=enemy) - 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(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 withprob(1-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() + # Move out + game.quad[game.sector.i][game.sector.j] = IHDOT + for m in range(course.moves): + course.next() + w = course.sector() + if course.origin.quadrant() != course.location.quadrant(): + newquadrant(noattack) + break + elif check_collision(w): + print "Collision detected" + break + else: + game.sector = w + # We're in destination quadrant -- compute new average enemy distances + game.quad[game.sector.i][game.sector.j] = game.ship + if game.enemies: + for enemy in game.enemies: + finald = (w-enemy.kloc).distance() + enemy.kavgd = 0.5 * (finald + enemy.kdist) + enemy.kdist = finald + game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist)) + if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova: + attack(torps_ok=False) + for enemy in game.enemies: + enemy.kavgd = enemy.kdist + newcnd() + drawmaps(0) + setwnd(message_window) return def dock(verbose): - # dock our ship at a starbase - chew() + "Dock our ship at a starbase." + scanner.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.")) + if not game.base.is_valid() or abs(game.sector.i-game.base.i) > 1 or abs(game.sector.j-game.base.j) > 1: + prout(crmshp() + _(" not adjacent to base.")) return game.condition = "docked" if "verbose": @@ -4027,8 +3583,16 @@ def dock(verbose): # because it involves giving x and y motions, yet the coordinates # are always displayed y - x, where +y is downward! -def getcourse(isprobe, akey): - # get course and distance +def cartesian(loc1=None, loc2=None): + if loc1 is None: + return game.quadrant * QUADSIZE + game.sector + elif loc2 is None: + return game.quadrant * QUADSIZE + loc1 + else: + return loc1 * QUADSIZE + loc2 + +def getcourse(isprobe): + "Get a course and distance from the user." key = 0 dquad = copy.copy(game.quadrant) navmode = "unspecified" @@ -4038,41 +3602,36 @@ def getcourse(isprobe, akey): if game.landed and not isprobe: prout(_("Dummy! You can't leave standard orbit until you")) proutn(_("are back aboard the ship.")) - chew() - return False + scanner.chew() + raise TrekError while navmode == "unspecified": if damaged(DNAVSYS): if isprobe: prout(_("Computer damaged; manual navigation only")) else: prout(_("Computer damaged; manual movement only")) - chew() + scanner.chew() navmode = "manual" - key = IHEOL + 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: + key = scanner.next() + if key == "IHEOL": proutn(_("Manual or automatic- ")) iprompt = True - chew() - elif key == IHALPHA: - if isit("manual"): + scanner.chew() + elif key == "IHALPHA": + if scanner.sees("manual"): navmode = "manual" - key = scan() + key = scanner.next() break - elif isit("automatic"): + elif scanner.sees("automatic"): navmode = "automatic" - key = scan() + key = scanner.next() break else: huh() - chew() - return False + scanner.chew() + raise TrekError else: # numeric if isprobe: prout(_("(Manual navigation assumed.)")) @@ -4080,52 +3639,53 @@ def getcourse(isprobe, akey): prout(_("(Manual movement assumed.)")) navmode = "manual" break + delta = coord() if navmode == "automatic": - while key == IHEOL: + while key == "IHEOL": if isprobe: proutn(_("Target quadrant or quadrant§or- ")) else: proutn(_("Destination sector or quadrant§or- ")) - chew() + scanner.chew() iprompt = True - key = scan() - if key != IHREAL: + key = scanner.next() + if key != "IHREAL": huh() - return False - xi = int(round(aaitem))-1 - key = scan() - if key != IHREAL: + raise TrekError + xi = int(round(scanner.real))-1 + key = scanner.next() + if key != "IHREAL": huh() - return False - xj = int(round(aaitem))-1 - key = scan() - if key == IHREAL: + raise TrekError + xj = int(round(scanner.real))-1 + key = scanner.next() + if key == "IHREAL": # both quadrant and sector specified - xk = int(round(aaitem))-1 - key = scan() - if key != IHREAL: + xk = int(round(scanner.real))-1 + key = scanner.next() + if key != "IHREAL": huh() - return False - xl = int(round(aaitem))-1 - dquad.x = xi - dquad.y = xj - dsect.y = xk - dsect.x = xl + raise TrekError + xl = int(round(scanner.real))-1 + dquad.i = xi + dquad.j = xj + dsect.i = xk + dsect.j = xl else: # only one pair of numbers was specified if isprobe: # only quadrant specified -- go to center of dest quad - dquad.x = xi - dquad.y = xj - dsect.y = dsect.x = 4 # preserves 1-origin behavior + dquad.i = xi + dquad.j = xj + dsect.j = dsect.i = 4 # preserves 1-origin behavior else: # only sector specified - dsect.y = xi - dsect.x = xj + dsect.i = xi + dsect.j = xj itemp = "normal" - if not VALID_QUADRANT(dquad.y,dquad.x) or not VALID_SECTOR(dsect.x,dsect.y): + if not dquad.valid_quadrant() or not dsect.valid_sector(): huh() - return False + raise TrekError skip(1) if not isprobe: if itemp > "curt": @@ -4134,51 +3694,92 @@ def getcourse(isprobe, akey): else: prout(_("Ensign Chekov- \"Course laid in, Captain.\"")) # the actual deltas get computed here - deltax = dquad.y-game.quadrant.y + 0.1*(dsect.x-game.sector.y) - deltay = game.quadrant.x-dquad.x + 0.1*(game.sector.x-dsect.y) + delta.j = dquad.j-game.quadrant.j + (dsect.j-game.sector.j)/(QUADSIZE*1.0) + delta.i = game.quadrant.i-dquad.i + (game.sector.i-dsect.i)/(QUADSIZE*1.0) else: # manual - while key == IHEOL: + while key == "IHEOL": proutn(_("X and Y displacements- ")) - chew() + scanner.chew() iprompt = True - key = scan() + key = scanner.next() itemp = "verbose" - if key != IHREAL: + if key != "IHREAL": huh() - return False - deltax = aaitem - key = scan() - if key != IHREAL: + raise TrekError + delta.j = scanner.real + key = scanner.next() + if key != "IHREAL": huh() - return False - deltay = aaitem + raise TrekError + delta.i = scanner.real # Check for zero movement - if deltax == 0 and deltay == 0: - chew() - return False + if delta.i == 0 and delta.j == 0: + scanner.chew() + raise TrekError if itemp == "verbose" and not isprobe: skip(1) prout(_("Helmsman Sulu- \"Aye, Sir.\"")) - # Course actually laid in. - 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 True + scanner.chew() + return course(bearing=delta.bearing(), distance=delta.distance()) + +class course: + def __init__(self, bearing, distance, origin=None): + self.distance = distance + self.bearing = bearing + if origin is None: + self.origin = cartesian(game.quadrant, game.sector) + else: + self.origin = origin + # The bearing() code we inherited from FORTRAN is actually computing + # clockface directions! + if self.bearing < 0.0: + self.bearing += 12.0 + self.angle = ((15.0 - self.bearing) * 0.5235988) + if origin is None: + self.origin = cartesian(game.quadrant, game.sector) + else: + self.origin = cartesian(game.quadrant, origin) + self.increment = coord(-math.sin(self.angle), math.cos(self.angle)) + bigger = max(abs(self.increment.i), abs(self.increment.j)) + self.increment /= bigger + self.moves = int(round(10*self.distance*bigger)) + self.reset() + self.final = (self.location + self.moves*self.increment).roundtogrid() + def reset(self): + self.location = self.origin + self.step = 0 + def arrived(self): + return self.location.roundtogrid() == self.final + def next(self): + "Next step on course." + self.step += 1 + self.nextlocation = self.location + self.increment + samequad = (self.location.quadrant() == self.nextlocation.quadrant()) + self.location = self.nextlocation + return samequad + def quadrant(self): + return self.location.quadrant() + def sector(self): + return self.location.sector() + def power(self, warp): + return self.distance*(warp**3)*(game.shldup+1) + def time(self, warp): + return 10.0*self.distance/warp**2 def impulse(): - # move under impulse power + "Move under impulse power." game.ididit = False if damaged(DIMPULS): - chew() + scanner.chew() skip(1) prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\"")) return if game.energy > 30.0: - if not getcourse(isprobe=False, akey=0): + try: + course = getcourse(isprobe=False) + except TrekError: return - power = 20.0 + 100.0*game.dist + power = 20.0 + 100.0*course.distance else: power = 30.0 if power >= game.energy: @@ -4192,10 +3793,10 @@ def impulse(): prout(_(" quadrants.\"")) else: prout(_("quadrant. They are, therefore, useless.\"")) - chew() + scanner.chew() return # Make sure enough time is left for the trip - game.optime = game.dist/0.095 + game.optime = course.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")) @@ -4203,45 +3804,49 @@ def impulse(): if ja() == False: return # Activate impulse engines and pay the cost - imove(novapush=False) + imove(course, noattack=False) game.ididit = True if game.alldone: return - power = 20.0 + 100.0*game.dist + power = 20.0 + 100.0*course.dist game.energy -= power - game.optime = game.dist/0.095 + game.optime = course.dist/0.095 if game.energy <= 0: finish(FNRG) return -def warp(timewarp): - # move under warp drive +def warp(course, involuntary): + "ove under warp drive." blooey = False; twarp = False - if not timewarp: # Not WARPX entry + if not involuntary: # Not WARPX entry game.ididit = False if game.damage[DWARPEN] > 10.0: - chew() + scanner.chew() skip(1) - prout(_("Engineer Scott- \"The impulse engines are damaged, Sir.\"")) + prout(_("Engineer Scott- \"The warp engines are damaged, Sir.\"")) return if damaged(DWARPEN) and game.warpfac > 4.0: - chew() + scanner.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 - if not getcourse(isprobe=False, akey=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: + # Read in course and distance + if course==None: + try: + course = getcourse(isprobe=False) + except TrekError: + return + # Make sure starship has enough energy for the trip + # Note: this formula is slightly different from the C version, + # and lets you skate a bit closer to the edge. + if course.power(game.warpfac) >= 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) + iwarp = (game.energy/(course.dist+0.05)) ** 0.333333333 if iwarp <= 0: prout(_("We can't do it, Captain. We don't have enough energy.")) else: @@ -4253,10 +3858,9 @@ def warp(timewarp): prout(".") else: prout(_("We haven't the energy to go that far with the shields up.")) - return - + return # Make sure enough time is left for the trip - game.optime = 10.0*game.dist/game.wfacsq + game.optime = course.time(game.warpfac) if game.optime >= 0.8*game.state.remtime: skip(1) prout(_("First Officer Spock- \"Captain, I compute that such")) @@ -4272,12 +3876,12 @@ def warp(timewarp): if game.warpfac > 6.0: # Decide if engine damage will occur # ESR: Seems wrong. Probability of damage goes *down* with distance? - prob = game.dist*square(6.0-game.warpfac)/66.666666666 + prob = course.distance*(6.0-game.warpfac)**2/66.666666666 if prob > randreal(): blooey = True - game.dist = randreal(game.dist) + course.distance = randreal(course.distance) # Decide if time warp will occur - if 0.5*game.dist*math.pow(7.0,game.warpfac-10.0) > randreal(): + if 0.5*course.distance*math.pow(7.0,game.warpfac-10.0) > randreal(): twarp = True if idebug and game.warpfac==10 and not twarp: blooey = False @@ -4287,37 +3891,23 @@ def warp(timewarp): 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: + for m in range(course.moves): + course.next() + w = course.sector() + if not w.valid_sector(): + break + if game.quad[w.i][w.j] != IHDOT: blooey = False twarp = False + course.reset() # Activate Warp Engines and pay the cost - imove(novapush=False) + imove(course, noattack=False) if game.alldone: return - game.energy -= game.dist*game.warpfac*game.warpfac*game.warpfac*(game.shldup+1) + game.energy -= course.power(game.warpfac) if game.energy <= 0: finish(FNRG) - game.optime = 10.0*game.dist/game.wfacsq + game.optime = course.time(game.warpfac) if twarp: timwrp() if blooey: @@ -4330,33 +3920,32 @@ def warp(timewarp): return def setwarp(): - # change the warp factor + "Change the warp factor." while True: - key=scan() - if key != IHEOL: + key=scanner.next() + if key != "IHEOL": break - chew() + scanner.chew() proutn(_("Warp factor- ")) - chew() - if key != IHREAL: + scanner.chew() + if key != "IHREAL": huh() return if game.damage[DWARPEN] > 10.0: prout(_("Warp engines inoperative.")) return - if damaged(DWARPEN) and aaitem > 4.0: + if damaged(DWARPEN) and scanner.real > 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: + if scanner.real > 10.0: prout(_("Helmsman Sulu- \"Our top speed is warp 10, Captain.\"")) return - if aaitem < 1.0: + if scanner.real < 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 + game.warpfac = scanner.real if game.warpfac <= oldfac or game.warpfac <= 6.0: prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") % int(game.warpfac)) @@ -4371,8 +3960,8 @@ def setwarp(): return def atover(igrab): - # cope with being tossed out of quadrant by supernova or yanked by beam - chew() + "Cope with being tossed out of quadrant by supernova or yanked by beam." + scanner.chew() # is captain on planet? if game.landed: if damaged(DTRANSP): @@ -4409,17 +3998,13 @@ def atover(igrab): if game.justin: prouts(_("***RED ALERT! RED ALERT!")) skip(1) - proutn(_("The ")) - crmshp() - prout(_(" has stopped in a quadrant containing")) + proutn(_("The %s has stopped in a quadrant containing") % crmshp()) prouts(_(" a supernova.")) skip(2) - proutn(_("***Emergency automatic override attempts to hurl ")) - crmshp() - skip(1) + prout(_("***Emergency automatic override attempts to hurl ")+crmshp()) prout(_("safely out of quadrant.")) if not damaged(DRADIO): - game.state.galaxy[game.quadrant.x][game.quadrant.y].charted = True + game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True # Try to use warp engines if damaged(DWARPEN): skip(1) @@ -4427,18 +4012,15 @@ def atover(igrab): finish(FSNOVAED) return game.warpfac = randreal(6.0, 8.0) - 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 = randreal(math.sqrt(2)) - if distreq < game.dist: - game.dist = distreq - game.optime = 10.0*game.dist/game.wfacsq - game.direc = randreal(12) # How dumb! + dist = power/(game.warpfac*game.warpfac*game.warpfac*(game.shldup+1)) + dist = max(dist, randreal(math.sqrt(2))) + bugout = course(bearing=randreal(12), distance=dist) # How dumb! + game.optime = bugout.time(game.warpfac) game.justin = False game.inorbit = False - warp(True) + warp(bugout, involuntary=True) if not game.justin: # This is bad news, we didn't leave quadrant. if game.alldone: @@ -4448,13 +4030,13 @@ def atover(igrab): finish(FSNOVAED) return # Repeat if another snova - if not game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova: break - if (game.state.remkl + game.state.remcom + game.state.nscrem)==0: + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0: finish(FWON) # Snova killed remaining enemy. def timwrp(): - # let's do the time warp again + "Let's do the time warp again." prout(_("***TIME WARP ENTERED.")) if game.state.snap and withprob(0.5): # Go back in time @@ -4462,8 +4044,8 @@ def timwrp(): 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)) + if len(game.state.kcmdr): + schedule(FTBEAM, expran(game.intime/len(game.state.kcmdr))) schedule(FBATTAK, expran(0.3*game.intime)) schedule(FSNOVA, expran(0.5*game.intime)) # next snapshot will be sooner @@ -4474,8 +4056,7 @@ def timwrp(): game.isatb = 0 unschedule(FCDBAS) unschedule(FSCDBAS) - invalidate(game.battle) - + game.battle.invalidate() # Make sure Galileo is consistant -- Snapshot may have been taken # when on planet, which would give us two Galileos! gotit = False @@ -4490,10 +4071,8 @@ def timwrp(): 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. -# + # 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 @@ -4502,14 +4081,14 @@ def timwrp(): # cheat to make sure no tractor beams occur during time warp postpone(FTBEAM, game.optime) game.damage[DRADIO] += game.optime - newqad(False) + newqad() events() # Stas Sergeev added this -- do pending events def probe(): - # launch deep-space probe + "Launch deep-space probe." # New code to launch a deep space probe if game.nprobes == 0: - chew() + scanner.chew() skip(1) if game.ship == IHE: prout(_("Engineer Scott- \"We have no more deep space probes, Sir.\"")) @@ -4517,12 +4096,12 @@ def probe(): prout(_("Ye Faerie Queene has no deep space probes.")) return if damaged(DDSP): - chew() + scanner.chew() skip(1) prout(_("Engineer Scott- \"The probe launcher is damaged, Sir.\"")) return if is_scheduled(FDSPROB): - chew() + scanner.chew() skip(1) if damaged(DRADIO) and game.condition != "docked": prout(_("Spock- \"Records show the previous probe has not yet")) @@ -4530,9 +4109,8 @@ def probe(): 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 + key = scanner.next() + if key == "IHEOL": if game.nprobes == 1: prout(_("1 probe left.")) else: @@ -4541,55 +4119,28 @@ def probe(): if ja() == False: return game.isarmed = False - if key == IHALPHA and citem == "armed": + if key == "IHALPHA" and scanner.token == "armed": game.isarmed = True - key = scan() - elif key == IHEOL: + key = scanner.next() + elif key == "IHEOL": proutn(_("Arm NOVAMAX warhead? ")) game.isarmed = ja() - if not getcourse(isprobe=True, akey=key): - return + elif key == "IHREAL": # first element of course + scanner.push(scanner.token) + try: + game.probe = getcourse(isprobe=True) + except TrekError: + 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 + "Yell for help from nearest starbase." # There's more than one way to move in this game! - line = 0 - chew() + scanner.chew() # Test for conditions which prevent calling for help if game.condition == "docked": prout(_("Lt. Uhura- \"But Captain, we're already docked.\"")) @@ -4597,42 +4148,38 @@ def mayday(): if damaged(DRADIO): prout(_("Subspace radio damaged.")) return - if game.state.rembase==0: + if not game.state.baseq: prout(_("Lt. Uhura- \"Captain, I'm not getting any response from Starbase.\"")) return if game.landed: - proutn(_("You must be aboard the ")) - crmshp() - prout(".") + prout(_("You must be aboard the %s.") % crmshp()) return # OK -- call for help from nearest starbase game.nhelp += 1 - if game.base.x!=0: + if game.base.i!=0: # There's one in this quadrant - ddist = distance(game.base, game.sector) + ddist = (game.base - game.sector).distance() else: ddist = FOREVER - for m in range(game.state.rembase): - xdist = QUADSIZE * distance(game.state.baseq[m], game.quadrant) + for ibq in game.state.baseq: + xdist = QUADSIZE * (ibq - game.quadrant).distance() if xdist < ddist: ddist = xdist - line = m # Since starbase not in quadrant, set up new quadrant - game.quadrant = game.state.baseq[line] - newqad(True) + game.quadrant = ibq + newqad() # 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 + game.quad[game.sector.i][game.sector.j]=IHDOT + proutn(_("Starbase in Quadrant %s responds--%s dematerializes") \ + % (game.quadrant, crmshp())) + game.sector.invalidate() for m in range(1, 5+1): w = game.base.scatter() - if VALID_SECTOR(ix,iy) and game.quad[ix][iy]==IHDOT: + if w.valid_sector() and game.quad[w.i][w.j]==IHDOT: # found one -- finish up game.sector = w break - if not is_valid(game.sector): + if not game.sector.is_valid(): prout(_("You have been lost in space...")) finish(FMATERIALIZE) return @@ -4642,16 +4189,15 @@ def mayday(): if m == 1: proutn(_("1st")) elif m == 2: proutn(_("2nd")) elif m == 3: proutn(_("3rd")) - proutn(_(" attempt to re-materialize ")) - crmshp() + proutn(_(" attempt to re-materialize ") + crmshp()) game.quad[ix][iy]=(IHMATER0,IHMATER1,IHMATER2)[m-1] - textcolor(RED) + #textcolor("red") warble() if randreal() > probf: break prout(_("fails.")) curses.delay_output(500) - textcolor(DEFAULT) + #textcolor(None) if m > 3: game.quad[ix][iy]=IHQUEST game.alive = False @@ -4660,34 +4206,16 @@ def mayday(): finish(FMATERIALIZE) return game.quad[ix][iy]=game.ship - textcolor(GREEN) + #textcolor("green") prout(_("succeeds.")) - textcolor(DEFAULT) + #textcolor(None) 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() + "Abandon ship." + scanner.chew() if game.condition=="docked": if game.ship!=IHE: prout(_("You cannot abandon Ye Faerie Queene.")) @@ -4709,18 +4237,18 @@ def abandon(): if game.iscraft != "onship": prout(_("Shuttle craft not currently available.")) return - # Print abandon ship messages + # Emit 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: + if not game.state.baseq: # Oops! no place to go... finish(FABANDN) return - q = game.state.galaxy[game.quadrant.x][game.quadrant.y] + q = game.state.galaxy[game.quadrant.i][game.quadrant.j] # Dispose of crew if not (game.options & OPTION_WORLDS) and not damaged(DTRANSP): prout(_("Remainder of ship's complement beam down")) @@ -4733,34 +4261,33 @@ def abandon(): 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 = randrange(game.state.rembase) + nb = randrange(len(game.state.baseq)) # Set up quadrant and position FQ adjacient to base if not game.quadrant == game.state.baseq[nb]: game.quadrant = game.state.baseq[nb] - game.sector.x = game.sector.y = 5 - newqad(True) + game.sector.i = game.sector.j = 5 + newqad() while True: # position next to base by trial and error - game.quad[game.sector.x][game.sector.y] = IHDOT + game.quad[game.sector.i][game.sector.j] = IHDOT for l in range(QUADSIZE): game.sector = game.base.scatter() - if VALID_SECTOR(game.sector.x, game.sector.y) and \ - game.quad[game.sector.x][game.sector.y] == IHDOT: + if game.sector.valid_sector() and \ + game.quad[game.sector.i][game.sector.j] == IHDOT: break if l < QUADSIZE+1: break # found a spot - game.sector.x=QUADSIZE/2 - game.sector.y=QUADSIZE/2 - newqad(True) + game.sector.i=QUADSIZE/2 + game.sector.j=QUADSIZE/2 + newqad() # Get new commission - game.quad[game.sector.x][game.sector.y] = game.ship = IHF + game.quad[game.sector.i][game.sector.j] = game.ship = IHF game.state.crew = FULLCREW prout(_("Starfleet puts you in command of another ship,")) prout(_("the Faerie Queene, which is antiquated but,")) @@ -4780,24 +4307,23 @@ def abandon(): 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 + "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: + if game.alldone or game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.justin: return True return False def survey(): - # report on (uninhabited) planets in the galaxy + "Report on (uninhabited) planets in the galaxy." iknow = False skip(1) - chew() + scanner.chew() prout(_("Spock- \"Planet report follows, Captain.\"")) skip(1) for i in range(game.inplan): @@ -4809,7 +4335,7 @@ def survey(): iknow = True if idebug and game.state.planets[i].known=="unknown": proutn("(Unknown) ") - proutn(_("Quadrant %s") % game.state.planets[i].w) + proutn(_("Quadrant %s") % game.state.planets[i].quadrant) proutn(_(" class ")) proutn(game.state.planets[i].pclass) proutn(" ") @@ -4822,18 +4348,20 @@ def survey(): prout(_("No information available.")) def orbit(): - # enter standard orbit + "Enter standard orbit." skip(1) - chew() + scanner.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.")) + if not game.plnet.is_valid(): + prout("There is no planet in this sector.") + return + if abs(game.sector.i-game.plnet.i)>1 or abs(game.sector.j-game.plnet.j)>1: + prout(crmshp() + _(" not adjacent to planet.")) skip(1) return game.optime = randreal(0.02, 0.05) @@ -4847,7 +4375,7 @@ def orbit(): game.ididit = True def sensor(): - # examine planets in this quadrant + "Examine planets in this quadrant." if damaged(DSRSENS): if game.options & OPTION_TTY: prout(_("Short range sensors damaged.")) @@ -4874,9 +4402,9 @@ def sensor(): prout(_(" is located at Sector %s, Captain.\"") % game.plnet) def beam(): - # use the transporter + "Use the transporter." nrgneed = 0 - chew() + scanner.chew() skip(1) if damaged(DTRANSP): prout(_("Transporter damaged.")) @@ -4887,8 +4415,7 @@ def beam(): shuttle() return if not game.inorbit: - crmshp() - prout(_(" not in standard orbit.")) + prout(crmshp() + _(" not in standard orbit.")) return if game.shldup: prout(_("Impossible to transport through shields.")) @@ -4903,7 +4430,7 @@ def beam(): prout(_(" exploring a planet with no dilithium crystals.")) proutn(_(" Are you sure this is wise?\" ")) if ja() == False: - chew() + scanner.chew() return if not (game.options & OPTION_PLAIN): nrgneed = 50 * game.skill + game.height / 100.0 @@ -4919,14 +4446,14 @@ def beam(): prout(_(" Although the Galileo shuttle craft may still be on a surface.")) proutn(_(" Are you sure this is wise?\" ")) if ja() == False: - chew() + scanner.chew() return if game.landed: # Coming from planet if game.iplnet.known=="shuttle_down": proutn(_("Spock- \"Wouldn't you rather take the Galileo?\" ")) if ja() == True: - chew() + scanner.chew() return prout(_("Your crew hides the Galileo to prevent capture by aliens.")) prout(_("Landing party assembled, ready to beam up.")) @@ -4966,9 +4493,9 @@ def beam(): return def mine(): - # strip-mine a world for dilithium + "Strip-mine a world for dilithium." skip(1) - chew() + scanner.chew() if not game.landed: prout(_("Mining party not on planet.")) return @@ -4982,9 +4509,7 @@ def mine(): 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(_("With all those fresh crystals aboard the ") + crmshp()) prout(_("there's no reason to mine more at this time.")) return game.optime = randreal(0.1, 0.3)*(ord(game.iplnet.pclass)-ord("L")) @@ -4995,10 +4520,10 @@ def mine(): game.imine = game.ididit = True def usecrystals(): - # use dilithium crystals + "Use dilithium crystals." game.ididit = False skip(1) - chew() + scanner.chew() if not game.icrystl: prout(_("No dilithium crystals available.")) return @@ -5011,7 +4536,7 @@ def usecrystals(): prout(_(" system may risk a severe explosion.")) proutn(_(" Are you sure this is wise?\" ")) if ja() == False: - chew() + scanner.chew() return skip(1) prout(_("Engineering Officer Scott- \"(GULP) Aye Sir.")) @@ -5041,8 +4566,8 @@ def usecrystals(): game.ididit = True def shuttle(): - # use shuttlecraft for planetary jaunt - chew() + "Use shuttlecraft for planetary jaunt." + scanner.chew() skip(1) if damaged(DSHUTTL): if game.damage[DSHUTTL] == -1.0: @@ -5056,8 +4581,7 @@ def shuttle(): prout(_("Shuttle craft is now serving Big Macs.")) return if not game.inorbit: - crmshp() - prout(_(" not in standard orbit.")) + prout(crmshp() + _(" not in standard orbit.")) return if (game.iplnet.known != "shuttle_down") and game.iscraft != "onship": prout(_("Shuttle craft not currently available.")) @@ -5125,8 +4649,7 @@ def shuttle(): prout(_("Trip complete.")) return else: - # Kirk on ship - # and so is Galileo + # 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) @@ -5143,14 +4666,14 @@ def shuttle(): return def deathray(): - # use the big zapper + "Use the big zapper." game.ididit = False skip(1) - chew() + scanner.chew() if game.ship != IHE: prout(_("Ye Faerie Queene has no death ray.")) return - if game.nenhere==0: + if len(game.enemies)==0: prout(_("Sulu- \"But Sir, there are no enemies in this quadrant.\"")) return if damaged(DDRAY): @@ -5182,10 +4705,10 @@ def deathray(): if r > dprob: prouts(_("Sulu- \"Captain! It's working!\"")) skip(2) - while game.nenhere > 0: - deadkl(game.enemies[1].kloc, game.quad[game.enemies[1].kloc.x][game.enemies[1].kloc.y],game.enemies[1].kloc) + while len(game.enemies) > 0: + deadkl(game.enemies[1].kloc, game.quad[game.enemies[1].kloc.i][game.enemies[1].kloc.j],game.enemies[1].kloc) prout(_("Ensign Chekov- \"Congratulations, Captain!\"")) - if (game.state.remkl + game.state.remcom + game.state.nscrem) == 0: + if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0: finish(FWON) if (game.options & OPTION_PLAIN) == 0: prout(_("Spock- \"Captain, I believe the `Experimental Death Ray'")) @@ -5248,7 +4771,7 @@ def deathray(): # Code from reports.c begins here def attackreport(curt): - # report status of bases under attack + "eport status of bases under attack." if not curt: if is_scheduled(FCDBAS): prout(_("Starbase in Quadrant %s is currently under Commander attack.") % game.battle) @@ -5267,7 +4790,7 @@ def attackreport(curt): def report(): # report on general game status - chew() + scanner.chew() s1 = "" and game.thawed and _("thawed ") s2 = {1:"short", 2:"medium", 4:"long"}[game.length] s3 = (None, _("novice"). _("fair"), @@ -5278,23 +4801,23 @@ def report(): if game.tourn: prout(_("This is tournament game %d.") % game.tourn) prout(_("Your secret password is \"%s\"") % game.passwd) - proutn(_("%d of %d Klingons have been killed") % (((game.inkling + game.incom + game.inscom) - (game.state.remkl + game.state.remcom + game.state.nscrem)), + proutn(_("%d of %d Klingons have been killed") % (((game.inkling + game.incom + game.inscom) - (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)), (game.inkling + game.incom + game.inscom))) - if game.incom - game.state.remcom: - prout(_(", including %d Commander%s.") % (game.incom - game.state.remcom, (_("s"), "")[(game.incom - game.state.remcom)==1])) + if game.incom - len(game.state.kcmdr): + prout(_(", including %d Commander%s.") % (game.incom - len(game.state.kcmdr), (_("s"), "")[(game.incom - len(game.state.kcmdr))==1])) elif game.inkling - game.state.remkl + (game.inscom - game.state.nscrem) > 0: prout(_(", but no Commanders.")) else: prout(".") if game.skill > SKILL_FAIR: prout(_("The Super Commander has %sbeen destroyed.") % ("", _("not "))[game.state.nscrem]) - if game.state.rembase != game.inbase: + if len(game.state.baseq) != game.inbase: proutn(_("There ")) - if game.inbase-game.state.rembase==1: + if game.inbase-len(game.state.baseq)==1: proutn(_("has been 1 base")) else: - proutn(_("have been %d bases") % (game.inbase-game.state.rembase)) - prout(_(" destroyed, %d remaining.") % game.state.rembase) + proutn(_("have been %d bases") % (game.inbase-len(game.state.baseq))) + prout(_(" destroyed, %d remaining.") % len(game.state.baseq)) else: prout(_("There are %d bases.") % game.inbase) if communicating() or game.iseenit: @@ -5336,7 +4859,7 @@ def report(): skip(1) def lrscan(silent): - # long-range sensor scan + "Long-range sensor scan." if damaged(DLRSENS): # Now allow base's sensors if docked if game.condition != "docked": @@ -5347,11 +4870,11 @@ def lrscan(silent): prout(_("Starbase's long-range scan")) elif not silent: prout(_("Long-range scan")) - for x in range(game.quadrant.x-1, game.quadrant.x+2): + for x in range(game.quadrant.i-1, game.quadrant.i+2): if not silent: proutn(" ") - for y in range(game.quadrant.y-1, game.quadrant.y+2): - if not VALID_QUADRANT(x, y): + for y in range(game.quadrant.j-1, game.quadrant.j+2): + if not coord(x, y).valid_quadrant(): if not silent: proutn(" -1") else: @@ -5367,10 +4890,9 @@ def lrscan(silent): prout(" ") def damagereport(): - # damage report + "Damage report." jdam = False - chew() - + scanner.chew() for i in range(NDEVICES): if damaged(i): if not jdam: @@ -5384,7 +4906,7 @@ def damagereport(): prout(_("All devices functional.")) def rechart(): - # update the chart in the Enterprise's computer from galaxy data + "Update the chart in the Enterprise's computer from galaxy data." game.lastchart = game.state.date for i in range(GALSIZE): for j in range(GALSIZE): @@ -5394,8 +4916,8 @@ def rechart(): game.state.chart[i][j].stars = game.state.galaxy[i][j].stars def chart(): - # display the star chart - chew() + "Display the star chart." + scanner.chew() if (game.options & OPTION_AUTOSCAN): lrscan(silent=True) if not damaged(DRADIO): @@ -5403,7 +4925,6 @@ def chart(): if game.lastchart < game.state.date and game.condition == "docked": prout(_("Spock- \"I revised the Star Chart from the starbase's records.\"")) rechart() - prout(_(" STAR CHART FOR THE KNOWN GALAXY")) if game.state.date > game.lastchart: prout(_("(Last surveillance update %d stardates ago).") % ((int)(game.state.date-game.lastchart))) @@ -5411,7 +4932,7 @@ def chart(): for i in range(GALSIZE): proutn("%d |" % (i+1)) for j in range(GALSIZE): - if (game.options & OPTION_SHOWME) and i == game.quadrant.x and j == game.quadrant.y: + if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j: proutn("<") else: proutn(" ") @@ -5424,7 +4945,7 @@ def chart(): else: show = "..." proutn(show) - if (game.options & OPTION_SHOWME) and i == game.quadrant.x and j == game.quadrant.y: + if (game.options & OPTION_SHOWME) and i == game.quadrant.i and j == game.quadrant.j: proutn(">") else: proutn(" ") @@ -5433,35 +4954,31 @@ def chart(): skip(1) def sectscan(goodScan, i, j): - # light up an individual dot in a sector - if goodScan or (abs(i-game.sector.x)<= 1 and abs(j-game.sector.y) <= 1): + "Light up an individual dot in a sector." + if goodScan or (abs(i-game.sector.i)<= 1 and abs(j-game.sector.j) <= 1): if (game.quad[i][j]==IHMATER0) or (game.quad[i][j]==IHMATER1) or (game.quad[i][j]==IHMATER2) or (game.quad[i][j]==IHE) or (game.quad[i][j]==IHF): - if game.condition == "red": textcolor(RED) - elif game.condition == "green": textcolor(GREEN) - elif game.condition == "yellow": textcolor(YELLOW) - elif game.condition == "docked": textcolor(CYAN) - elif game.condition == "dead": textcolor(BROWN) + #if game.condition == "red": textcolor("red") + #elif game.condition == "green": textcolor("green") + #elif game.condition == "yellow": textcolor("yellow") + #elif game.condition == "docked": textcolor("cyan") + #elif game.condition == "dead": textcolor("brown") if game.quad[i][j] != game.ship: highvideo() proutn("%c " % game.quad[i][j]) - textcolor(DEFAULT) + #textcolor(None) else: proutn("- ") def status(req=0): - # print status report lines - + "Emit status report lines" if not req or req == 1: prstat(_("Stardate"), _("%.1f, Time Left %.2f") \ % (game.state.date, game.state.remtime)) if not req or req == 2: if game.condition != "docked": newcnd() - dam = 0 - for t in range(NDEVICES): - if game.damage[t]>0: - dam += 1 - prstat(_("Condition"), _("%s, %i DAMAGES") % (game.condition.upper(), dam)) + prstat(_("Condition"), _("%s, %i DAMAGES") % \ + (game.condition.upper(), sum(map(lambda x: x > 0, game.damage)))) if not req or req == 3: prstat(_("Position"), "%s , %s" % (game.quadrant, game.sector)) if not req or req == 4: @@ -5494,10 +5011,10 @@ def status(req=0): prstat(_("Shields"), s+data) if not req or req == 9: prstat(_("Klingons Left"), "%d" \ - % (game.state.remkl + game.state.remcom + game.state.nscrem)) + % (game.state.remkl+len(game.state.kcmdr)+game.state.nscrem)) if not req or req == 10: if game.options & OPTION_WORLDS: - plnet = game.state.galaxy[game.quadrant.x][game.quadrant.y].planet + plnet = game.state.galaxy[game.quadrant.i][game.quadrant.j].planet if plnet and plnet.inhabited: prstat(_("Major system"), plnet.name) else: @@ -5506,19 +5023,20 @@ def status(req=0): attackreport(not req) def request(): + "Request specified status data, a historical relic from slow TTYs." requests = ("da","co","po","ls","wa","en","to","sh","kl","sy", "ti") - while scan() == IHEOL: + while scanner.next() == "IHEOL": proutn(_("Information desired? ")) - chew() - if citem in requests: - status(requests.index(citem)) + scanner.chew() + if scanner.token in requests: + status(requests.index(scanner.token)) else: prout(_("UNRECOGNIZED REQUEST. Legal requests are:")) prout((" date, condition, position, lsupport, warpfactor,")) prout((" energy, torpedoes, shields, klingons, system, time.")) def srscan(): - # short-range scan + "Short-range scan." goodScan=True if damaged(DSRSENS): # Allow base's sensors if docked @@ -5530,10 +5048,10 @@ def srscan(): else: prout(_(" Short-range scan")) if goodScan and not damaged(DRADIO): - game.state.chart[game.quadrant.x][game.quadrant.y].klingons = game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons - game.state.chart[game.quadrant.x][game.quadrant.y].starbase = game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase - game.state.chart[game.quadrant.x][game.quadrant.y].stars = game.state.galaxy[game.quadrant.x][game.quadrant.y].stars - game.state.galaxy[game.quadrant.x][game.quadrant.y].charted = True + game.state.chart[game.quadrant.i][game.quadrant.j].klingons = game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons + game.state.chart[game.quadrant.i][game.quadrant.j].starbase = game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase + game.state.chart[game.quadrant.i][game.quadrant.j].stars = game.state.galaxy[game.quadrant.i][game.quadrant.j].stars + game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True prout(" 1 2 3 4 5 6 7 8 9 10") if game.condition != "docked": newcnd() @@ -5542,95 +5060,94 @@ def srscan(): for j in range(QUADSIZE): sectscan(goodScan, i, j) skip(1) - - + def eta(): - # use computer to get estimated time of arrival for a warp jump + "Use computer to get estimated time of arrival for a warp jump." w1 = coord(); w2 = coord() prompt = False if damaged(DCOMPTR): prout(_("COMPUTER DAMAGED, USE A POCKET CALCULATOR.")) skip(1) return - if scan() != IHREAL: + if scanner.next() != "IHREAL": prompt = True - chew() + scanner.chew() proutn(_("Destination quadrant and/or sector? ")) - if scan()!=IHREAL: + if scanner.next()!="IHREAL": huh() return - w1.y = int(aaitem-0.5) - if scan() != IHREAL: + w1.j = int(scanner.real-0.5) + if scanner.next() != "IHREAL": huh() return - w1.x = int(aaitem-0.5) - if scan() == IHREAL: - w2.y = int(aaitem-0.5) - if scan() != IHREAL: + w1.i = int(scanner.real-0.5) + if scanner.next() == "IHREAL": + w2.j = int(scanner.real-0.5) + if scanner.next() != "IHREAL": huh() return - w2.x = int(aaitem-0.5) + w2.i = int(scanner.real-0.5) else: - if game.quadrant.y>w1.x: - w2.x = 0 + if game.quadrant.j>w1.i: + w2.i = 0 else: - w2.x=QUADSIZE-1 - if game.quadrant.x>w1.y: - w2.y = 0 + w2.i=QUADSIZE-1 + if game.quadrant.i>w1.j: + w2.j = 0 else: - w2.y=QUADSIZE-1 - if not VALID_QUADRANT(w1.x, w1.y) or not VALID_SECTOR(w2.x, w2.y): + w2.j=QUADSIZE-1 + if not w1.valid_quadrant() or not w2.valid_sector(): huh() return - game.dist = math.sqrt(square(w1.y-game.quadrant.y+0.1*(w2.y-game.sector.y))+ - square(w1.x-game.quadrant.x+0.1*(w2.x-game.sector.x))) + dist = math.sqrt((w1.j-game.quadrant.j+(w2.j-game.sector.j)/(QUADSIZE*1.0))**2+ + (w1.i-game.quadrant.i+(w2.i-game.sector.i)/(QUADSIZE*1.0))**2) wfl = False if prompt: prout(_("Answer \"no\" if you don't know the value:")) while True: - chew() + scanner.chew() proutn(_("Time or arrival date? ")) - if scan()==IHREAL: - ttime = aaitem + if scanner.next()=="IHREAL": + ttime = scanner.real if ttime > game.state.date: ttime -= game.state.date # Actually a star date - twarp=(math.floor(math.sqrt((10.0*game.dist)/ttime)*10.0)+1.0)/10.0 + twarp=(math.floor(math.sqrt((10.0*dist)/ttime)*10.0)+1.0)/10.0 if ttime <= 1e-10 or twarp > 10: prout(_("We'll never make it, sir.")) - chew() + scanner.chew() return if twarp < 1.0: twarp = 1.0 break - chew() + scanner.chew() proutn(_("Warp factor? ")) - if scan()== IHREAL: + if scanner.next()== "IHREAL": wfl = True - twarp = aaitem + twarp = scanner.real if twarp<1.0 or twarp > 10.0: huh() return break prout(_("Captain, certainly you can give me one of these.")) while True: - chew() - ttime = (10.0*game.dist)/square(twarp) - tpower = game.dist*twarp*twarp*twarp*(game.shldup+1) + scanner.chew() + ttime = (10.0*dist)/twarp**2 + tpower = dist*twarp*twarp*twarp*(game.shldup+1) if tpower >= game.energy: prout(_("Insufficient energy, sir.")) if not game.shldup or tpower > game.energy*2.0: if not wfl: return proutn(_("New warp factor to try? ")) - if scan() == IHREAL: + if scanner.next() == "IHREAL": wfl = True - twarp = aaitem + twarp = scanner.real if twarp<1.0 or twarp > 10.0: huh() return continue else: - chew() + scanner.chew() skip(1) return prout(_("But if you lower your shields,")) @@ -5655,22 +5172,21 @@ def eta(): (scheduled(FCDBAS) 10.0: huh() return else: - chew() + scanner.chew() skip(1) return - # Code from setup.c begins here def prelim(): - # issue a historically correct banner + "Issue a historically correct banner." skip(2) prout(_("-SUPER- STAR TREK")) skip(1) @@ -5679,45 +5195,44 @@ def prelim(): # skip(1) def freeze(boss): - # save game + "Save game." if boss: - citem = "emsave.trk" - else: - key = scan() - if key == IHEOL: - proutn(_("File name: ")) - key = scan() - if key != IHALPHA: - huh() - return - chew() - if '.' not in citem: - citem += ".trk" + scanner.push("emsave.trk") + key = scanner.next() + if key == "IHEOL": + proutn(_("File name: ")) + key = scanner.next() + if key != "IHALPHA": + huh() + return + scanner.chew() + if '.' not in scanner.token: + scanner.token += ".trk" try: - fp = open(citem, "wb") + fp = open(scanner.token, "wb") except IOError: - prout(_("Can't freeze game as file %s") % citem) + prout(_("Can't freeze game as file %s") % scanner.token) return cPickle.dump(game, fp) fp.close() def thaw(): - # retrieve saved game + "Retrieve saved game." game.passwd[0] = '\0' - key = scan() - if key == IHEOL: + key = scanner.next() + if key == "IHEOL": proutn(_("File name: ")) - key = scan() - if key != IHALPHA: + key = scanner.next() + if key != "IHALPHA": huh() return True - chew() - if '.' not in citem: - citem += ".trk" + scanner.chew() + if '.' not in scanner.token: + scanner.token += ".trk" try: - fp = open(citem, "rb") + fp = open(scanner.token, "rb") except IOError: - prout(_("Can't thaw game in %s") % citem) + prout(_("Can't thaw game in %s") % scanner.token) return game = cPickle.load(fp) fp.close() @@ -5735,11 +5250,11 @@ systnames = ( _("Tellar Prime (Miracht)"), # TOS: "Journey to Babel" _("Vulcan (T'Khasi)"), # many episodes _("Medusa"), # TOS: "Is There in Truth No Beauty?" - _("Argelius II (Nelphia)"),# TOS: "Wolf in the Fold" ("IV" in BSD) + _("Argelius II (Nelphia)"), # TOS: "Wolf in the Fold" ("IV" in BSD) _("Ardana"), # TOS: "The Cloud Minders" _("Catulla (Cendo-Prae)"), # TOS: "The Way to Eden" _("Gideon"), # TOS: "The Mark of Gideon" - _("Aldebaran III"), # TOS: "The Deadly Years" + _("Aldebaran III"), # TOS: "The Deadly Years" _("Alpha Majoris I"), # TOS: "Wolf in the Fold" _("Altair IV"), # TOS: "Amok Time _("Ariannus"), # TOS: "Let That Be Your Last Battlefield" @@ -5794,20 +5309,18 @@ device = ( _("D. S. Probe"), \ ) -def setup(needprompt): - # prepare to play, set up cosmos +def setup(): + "Prepare to play, set up cosmos." w = coord() # Decide how many of everything - if choose(needprompt): + if choose(): return # frozen game # Prepare the Enterprise - game.alldone = game.gamewon = False + game.alldone = game.gamewon = game.shldchg = game.shldup = False game.ship = IHE game.state.crew = FULLCREW game.energy = game.inenrg = 5000.0 game.shield = game.inshld = 2500.0 - game.shldchg = False - game.shldup = False game.inlsr = 4.0 game.lsupres = 4.0 game.quadrant = randplace(GALSIZE) @@ -5815,7 +5328,6 @@ def setup(needprompt): game.torps = game.intorps = 10 game.nprobes = randrange(2, 5) game.warpfac = 5.0 - game.wfacsq = game.warpfac * game.warpfac for i in range(NDEVICES): game.damage[i] = 0.0 # Set up assorted game parameters @@ -5829,34 +5341,6 @@ def setup(needprompt): game.landed = False game.alive = True game.docfac = 0.25 - for i in range(GALSIZE): - for j in range(GALSIZE): - quad = game.state.galaxy[i][j] - quad.charted = 0 - quad.planet = None - quad.romulans = 0 - quad.klingons = 0 - quad.starbase = False - quad.supernova = False - quad.status = "secure" - # Initialize times for extraneous events - schedule(FSNOVA, expran(0.5 * game.intime)) - schedule(FTBEAM, expran(1.5 * (game.intime / game.state.remcom))) - schedule(FSNAP, randreal(1.0, 2.0)) # Force an early snapshot - schedule(FBATTAK, expran(0.3*game.intime)) - unschedule(FCDBAS) - if game.state.nscrem: - schedule(FSCMOVE, 0.2777) - else: - unschedule(FSCMOVE) - unschedule(FSCDBAS) - unschedule(FDSPROB) - if (game.options & OPTION_WORLDS) and game.skill >= SKILL_GOOD: - schedule(FDISTR, expran(1.0 + game.intime)) - else: - unschedule(FDISTR) - unschedule(FENSLV) - unschedule(FREPRO) # Starchart is functional but we've never seen it game.lastchart = FOREVER # Put stars in the galaxy @@ -5871,14 +5355,14 @@ def setup(needprompt): while True: while True: w = randplace(GALSIZE) - if not game.state.galaxy[w.x][w.y].starbase: + if not game.state.galaxy[w.i][w.j].starbase: break contflag = False # C version: for (j = i-1; j > 0; j--) # so it did them in the opposite order. for j in range(1, i): # Improved placement algorithm to spread out bases - distq = w.distance(game.state.baseq[j]) + distq = (w - game.state.baseq[j]).distance() if distq < 6.0*(BASEMAX+1-game.inbase) and withprob(0.75): contflag = True if idebug: @@ -5889,9 +5373,8 @@ def setup(needprompt): prout("=== Saving base #%d, close to #%d" % (i, j)) if not contflag: break - game.state.baseq[i] = w - game.state.galaxy[w.x][w.y].starbase = True - game.state.chart[w.x][w.y].starbase = True + game.state.baseq.append(w) + game.state.galaxy[w.i][w.j].starbase = game.state.chart[w.i][w.j].starbase = True # Position ordinary Klingon Battle Cruisers krem = game.inkling klumper = 0.25*game.skill*(9.0-game.length)+1.0 @@ -5905,31 +5388,30 @@ def setup(needprompt): krem -= klump while True: w = randplace(GALSIZE) - if not game.state.galaxy[w.x][w.y].supernova and \ - game.state.galaxy[w.x][w.y].klingons + klump <= MAXKLQUAD: + if not game.state.galaxy[w.i][w.j].supernova and \ + game.state.galaxy[w.i][w.j].klingons + klump <= MAXKLQUAD: break - game.state.galaxy[w.x][w.y].klingons += int(klump) + game.state.galaxy[w.i][w.j].klingons += int(klump) if krem <= 0: break # Position Klingon Commander Ships - for i in range(1, game.incom+1): + for i in range(game.incom): while True: w = randplace(GALSIZE) - if (game.state.galaxy[w.x][w.y].klingons or withprob(0.25)) and \ - not game.state.galaxy[w.x][w.y].supernova and \ - game.state.galaxy[w.x][w.y].klingons <= MAXKLQUAD-1 and \ - not w in game.state.kcmdr[:i]: + if not welcoming(w) or w in game.state.kcmdr: + continue + if (game.state.galaxy[w.i][w.j].klingons or withprob(0.25)): break - game.state.galaxy[w.x][w.y].klingons += 1 - game.state.kcmdr[i] = w + game.state.galaxy[w.i][w.j].klingons += 1 + game.state.kcmdr.append(w) # Locate planets in galaxy for i in range(game.inplan): while True: w = randplace(GALSIZE) - if game.state.galaxy[w.x][w.y].planet == None: + if game.state.galaxy[w.i][w.j].planet == None: break new = planet() - new.w = w + new.quadrant = w new.crystals = "absent" if (game.options & OPTION_WORLDS) and i < NINHAB: new.pclass = "M" # All inhabited planets are class M @@ -5943,24 +5425,47 @@ def setup(needprompt): new.crystals = "present" new.known = "unknown" new.inhabited = False - game.state.galaxy[w.x][w.y].planet = new + game.state.galaxy[w.i][w.j].planet = new game.state.planets.append(new) # Locate Romulans for i in range(game.state.nromrem): w = randplace(GALSIZE) - game.state.galaxy[w.x][w.y].romulans += 1 - # Locate the Super Commander + game.state.galaxy[w.i][w.j].romulans += 1 + # Place the Super-Commander if needed if game.state.nscrem > 0: while True: w = randplace(GALSIZE) - if not game.state.galaxy[w.x][w.y].supernova and game.state.galaxy[w.x][w.y].klingons <= MAXKLQUAD: + if welcoming(w): break game.state.kscmdr = w - game.state.galaxy[w.x][w.y].klingons += 1 + game.state.galaxy[w.i][w.j].klingons += 1 + # Initialize times for extraneous events + schedule(FSNOVA, expran(0.5 * game.intime)) + schedule(FTBEAM, expran(1.5 * (game.intime / len(game.state.kcmdr)))) + schedule(FSNAP, randreal(1.0, 2.0)) # Force an early snapshot + schedule(FBATTAK, expran(0.3*game.intime)) + unschedule(FCDBAS) + if game.state.nscrem: + schedule(FSCMOVE, 0.2777) + else: + unschedule(FSCMOVE) + unschedule(FSCDBAS) + unschedule(FDSPROB) + if (game.options & OPTION_WORLDS) and game.skill >= SKILL_GOOD: + schedule(FDISTR, expran(1.0 + game.intime)) + else: + unschedule(FDISTR) + unschedule(FENSLV) + unschedule(FREPRO) # Place thing (in tournament game, we don't want one!) + # New in SST2K: never place the Thing near a starbase. + # This makes sense and avoids a special case in the old code. global thing if game.tourn is None: - thing = randplace(GALSIZE) + while True: + thing = randplace(GALSIZE) + if thing not in game.state.baseq: + break skip(2) game.state.snap = False if game.skill == SKILL_NOVICE: @@ -5993,40 +5498,38 @@ def setup(needprompt): if game.state.nscrem: prout(_(" YOU'LL NEED IT.")) waitfor() - newqad(False) - if game.nenhere - (thing == game.quadrant) - (game.tholian != None): + newqad() + if len(game.enemies) - (thing == game.quadrant) - (game.tholian != None): game.shldup = True if game.neutz: # bad luck to start in a Romulan Neutral Zone - attack(False) + attack(torps_ok=False) -def choose(needprompt): - # choose your game type +def choose(): + "Choose your game type." global thing while True: game.tourn = 0 game.thawed = False game.skill = SKILL_NONE game.length = 0 - if needprompt: # Can start with command line options + if not scanner.inqueue: # Can start with command line options proutn(_("Would you like a regular, tournament, or saved game? ")) - scan() - if len(citem)==0: # Try again - continue - if isit("tournament"): - while scan() == IHEOL: + scanner.next() + if scanner.sees("tournament"): + while scanner.next() == "IHEOL": proutn(_("Type in tournament number-")) - if aaitem == 0: - chew() + if scanner.real == 0: + scanner.chew() continue # We don't want a blank entry - game.tourn = int(round(aaitem)) - random.seed(aaitem) + game.tourn = int(round(scanner.real)) + random.seed(scanner.real) if logfp: - logfp.write("# random.seed(%d)\n" % aaitem) + logfp.write("# random.seed(%d)\n" % scanner.real) break - if isit("saved") or isit("frozen"): + if scanner.sees("saved") or scanner.sees("frozen"): if thaw(): continue - chew() + scanner.chew() if game.passwd == None: continue if not game.alldone: @@ -6034,64 +5537,62 @@ def choose(needprompt): report() waitfor() return True - if isit("regular"): + if scanner.sees("regular"): break - proutn(_("What is \"%s\"?"), citem) - chew() + proutn(_("What is \"%s\"?") % scanner.token) + scanner.chew() while game.length==0 or game.skill==SKILL_NONE: - if scan() == IHALPHA: - if isit("short"): + if scanner.next() == "IHALPHA": + if scanner.sees("short"): game.length = 1 - elif isit("medium"): + elif scanner.sees("medium"): game.length = 2 - elif isit("long"): + elif scanner.sees("long"): game.length = 4 - elif isit("novice"): + elif scanner.sees("novice"): game.skill = SKILL_NOVICE - elif isit("fair"): + elif scanner.sees("fair"): game.skill = SKILL_FAIR - elif isit("good"): + elif scanner.sees("good"): game.skill = SKILL_GOOD - elif isit("expert"): + elif scanner.sees("expert"): game.skill = SKILL_EXPERT - elif isit("emeritus"): + elif scanner.sees("emeritus"): game.skill = SKILL_EMERITUS else: proutn(_("What is \"")) - proutn(citem) + proutn(scanner.token) prout("\"?") else: - chew() + scanner.chew() if game.length==0: proutn(_("Would you like a Short, Medium, or Long game? ")) elif game.skill == SKILL_NONE: proutn(_("Are you a Novice, Fair, Good, Expert, or Emeritus player? ")) # Choose game options -- added by ESR for SST2K - if scan() != IHALPHA: - chew() + if scanner.next() != "IHALPHA": + scanner.chew() proutn(_("Choose your game style (or just press enter): ")) - scan() - if isit("plain"): + scanner.next() + if scanner.sees("plain"): # Approximates the UT FORTRAN version. game.options &=~ (OPTION_THOLIAN | OPTION_PLANETS | OPTION_THINGY | OPTION_PROBE | OPTION_RAMMING | OPTION_MVBADDY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS) game.options |= OPTION_PLAIN - elif isit("almy"): + elif scanner.sees("almy"): # Approximates Tom Almy's version. game.options &=~ (OPTION_THINGY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS) game.options |= OPTION_ALMY - elif isit("fancy"): + elif scanner.sees("fancy") or scanner.sees("\n"): pass - elif len(citem): - proutn(_("What is \"%s\"?") % citem) + elif len(scanner.token): + proutn(_("What is \"%s\"?") % scanner.token) setpassword() if game.passwd == "debug": idebug = True - fputs("=== Debug mode enabled\n", sys.stdout) - + prout("=== Debug mode enabled.") # Use parameters to generate initial values of things game.damfac = 0.5 * game.skill - game.state.rembase = randrange(BASEMIN, BASEMAX+1) - game.inbase = game.state.rembase + game.inbase = randrange(BASEMIN, BASEMAX+1) game.inplan = 0 if game.options & OPTION_PLANETS: game.inplan += randrange(MAXUNINHAB/2, MAXUNINHAB+1) @@ -6102,91 +5603,77 @@ def choose(needprompt): game.state.remtime = 7.0 * game.length game.intime = game.state.remtime game.state.remkl = game.inkling = 2.0*game.intime*((game.skill+1 - 2*randreal())*game.skill*0.1+.15) - game.incom = int(game.skill + 0.0625*game.inkling*randreal()) - game.state.remcom = min(10, game.incom) - game.incom = game.state.remcom + game.incom = min(MINCMDR, int(game.skill + 0.0625*game.inkling*randreal())) game.state.remres = (game.inkling+4*game.incom)*game.intime game.inresor = game.state.remres if game.inkling > 50: - game.state.rembase += 1 - game.inbase = game.state.rembase + game.state.inbase += 1 return False def dropin(iquad=None): - # drop a feature on a random dot in the current quadrant - w = coord() + "Drop a feature on a random dot in the current quadrant." while True: w = randplace(QUADSIZE) - if game.quad[w.x][w.y] == IHDOT: + if game.quad[w.i][w.j] == IHDOT: break if iquad is not None: - game.quad[w.x][w.y] = iquad + game.quad[w.i][w.j] = iquad return w def newcnd(): - # update our alert status + "Update our alert status." game.condition = "green" if game.energy < 1000.0: game.condition = "yellow" - if game.state.galaxy[game.quadrant.x][game.quadrant.y].klingons or game.state.galaxy[game.quadrant.x][game.quadrant.y].romulans: + if game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons or game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans: game.condition = "red" if not game.alive: game.condition="dead" def newkling(): - # drop new Klingon into current quadrant + "Drop new Klingon into current quadrant." return enemy(IHK, loc=dropin(), power=randreal(300,450)+25.0*game.skill) -def newqad(shutup): - # set up a new state of quadrant, for when we enter or re-enter it - w = coord() +def newqad(): + "Set up a new state of quadrant, for when we enter or re-enter it." game.justin = True - game.klhere = 0 - game.comhere = False - game.ishere = False - game.irhere = 0 - game.iplnet = 0 - game.nenhere = 0 - game.neutz = False - game.inorbit = False - game.landed = False - game.ientesc = False - game.iseenit = False + game.iplnet = None + game.neutz = game.inorbit = game.landed = False + game.ientesc = game.iseenit = False + # Create a blank quadrant + game.quad = fill2d(QUADSIZE, lambda i, j: IHDOT) if game.iscate: # Attempt to escape Super-commander, so tbeam back! game.iscate = False game.ientesc = True - q = game.state.galaxy[game.quadrant.x][game.quadrant.y] + q = game.state.galaxy[game.quadrant.i][game.quadrant.j] # cope with supernova if q.supernova: return game.klhere = q.klingons game.irhere = q.romulans - game.nenhere = game.klhere + game.irhere # Position Starship - game.quad[game.sector.x][game.sector.y] = game.ship + game.quad[game.sector.i][game.sector.j] = game.ship game.enemies = [] if q.klingons: # Position ordinary Klingons for i in range(game.klhere): newkling() # If we need a commander, promote a Klingon - for i in range(game.state.remcom): - if game.state.kcmdr[i] == game.quadrant: + for cmdr in game.state.kcmdr: + if cmdr == game.quadrant: e = game.enemies[game.klhere-1] - game.quad[e.kloc.x][e.kloc.y] = IHC + game.quad[e.kloc.i][e.kloc.j] = IHC e.kpower = randreal(950,1350) + 50.0*game.skill - game.comhere = True break # If we need a super-commander, promote a Klingon if game.quadrant == game.state.kscmdr: e = game.enemies[0] - game.quad[e.kloc.x][e.kloc.y] = IHS + game.quad[e.kloc.i][e.kloc.j] = IHS e.kpower = randreal(1175.0, 1575.0) + 125.0*game.skill game.iscate = (game.state.remkl > 1) - game.ishere = True # Put in Romulans if needed - for i in range(game.klhere, game.nenhere): + for i in range(q.romulans): enemy(IHR, loc=dropin(), power=randreal(400.0,850.0)+50.0*game.skill) # If quadrant needs a starbase, put it in if q.starbase: @@ -6210,15 +5697,14 @@ def newqad(shutup): skip(1) prout(_("INTRUDER! YOU HAVE VIOLATED THE ROMULAN NEUTRAL ZONE.")) prout(_("LEAVE AT ONCE, OR YOU WILL BE DESTROYED!")) - if shutup==0: - # Put in THING if needed - if thing == game.quadrant: - enemy(symbol=IHQUEST, loc=dropin(), - power=randreal(6000,6500.0)+250.0*game.skill) - if not damaged(DSRSENS): - skip(1) - prout(_("Mr. Spock- \"Captain, this is most unusual.")) - prout(_(" Please examine your short-range scan.\"")) + # Put in THING if needed + if thing == game.quadrant: + enemy(type=IHQUEST, loc=dropin(), + power=randreal(6000,6500.0)+250.0*game.skill) + if not damaged(DSRSENS): + skip(1) + prout(_("Mr. Spock- \"Captain, this is most unusual.")) + prout(_(" Please examine your short-range scan.\"")) # Decide if quadrant needs a Tholian; lighten up if skill is low if game.options & OPTION_THOLIAN: if (game.skill < SKILL_GOOD and withprob(0.02)) or \ @@ -6226,11 +5712,11 @@ def newqad(shutup): (game.skill > SKILL_GOOD and withprob(0.08)): w = coord() while True: - w.x = withprob(0.5) * (QUADSIZE-1) - w.y = withprob(0.5) * (QUADSIZE-1) - if game.quad[w.x][w.y] == IHDOT: + w.i = withprob(0.5) * (QUADSIZE-1) + w.j = withprob(0.5) * (QUADSIZE-1) + if game.quad[w.i][w.j] == IHDOT: break - game.tholian = enemy(symbol=IHT, loc=w, + game.tholian = enemy(type=IHT, loc=w, power=randrange(100, 500) + 25.0*game.skill) # Reserve unoccupied corners if game.quad[0][0]==IHDOT: @@ -6261,18 +5747,18 @@ def newqad(shutup): game.quad[QUADSIZE-1][QUADSIZE-1] = IHDOT def setpassword(): - # set the self-destruct password + "Set the self-destruct password." if game.options & OPTION_PLAIN: while True: - chew() + scanner.chew() proutn(_("Please type in a secret password- ")) - scan() - game.passwd = citem + scanner.next() + game.passwd = scanner.token if game.passwd != None: break else: game.passwd = "" - for i in range(3): + for i in range(8): game.passwd += chr(ord('a')+randrange(26)) # Code from sst.c begins here @@ -6317,44 +5803,39 @@ commands = { "CALL": 0, # Synonym for MAYDAY "QUIT": 0, "HELP": 0, - "SEED": 0, - "VISUAL": 0, } -def ACCEPT(cmd): return (not commands[cmd] or (commands[cmd] & game.options)) - def listCommands(): - # generate a list of legal commands - k = 0 - proutn(_("LEGAL COMMANDS ARE:")) + "Generate a list of legal commands." + prout(_("LEGAL COMMANDS ARE:")) + emitted = 0 for key in commands: - if ACCEPT(key): - if k % 5 == 0: + if not commands[key] or (commands[key] & game.options): + proutn("%-12s " % key) + emitted += 1 + if emitted % 5 == 4: skip(1) - proutn("%-12s " % key) - k += 1 skip(1) def helpme(): - # browse on-line help - # Give help on commands - key = scan() + "Browse on-line help." + key = scanner.next() while True: - if key == IHEOL: + if key == "IHEOL": setwnd(prompt_window) proutn(_("Help on what command? ")) - key = scan() + key = scanner.next() setwnd(message_window) - if key == IHEOL: + if key == "IHEOL": return - if citem in commands or citem == "ABBREV": + if scanner.token in commands or scanner.token == "ABBREV": break skip(1) listCommands() - key = IHEOL - chew() + key = "IHEOL" + scanner.chew() skip(1) - cmd = citem.upper() + cmd = scanner.token.upper() try: fp = open(SSTDOC, "r") except IOError: @@ -6368,10 +5849,8 @@ def helpme(): proutn(_(" current directory or to ")) proutn(SSTDOC) prout(".\"") - # # This used to continue: "You need to find SST.DOC and put # it in the current directory." - # return while True: linebuf = fp.readline() @@ -6393,8 +5872,7 @@ def helpme(): fp.close() def makemoves(): - # command-interpretation loop - v = 0 + "Command-interpretation loop." clrscr() setwnd(message_window) while True: # command loop @@ -6403,25 +5881,27 @@ def makemoves(): hitme = False game.justin = False game.optime = 0.0 - chew() + scanner.chew() setwnd(prompt_window) clrscr() proutn("COMMAND> ") - if scan() == IHEOL: + if scanner.next() == "IHEOL": if game.options & OPTION_CURSES: makechart() continue + elif scanner.token == "": + continue game.ididit = False clrscr() setwnd(message_window) clrscr() - candidates = filter(lambda x: x.startswith(citem.upper()), + candidates = filter(lambda x: x.startswith(scanner.token.upper()), commands) if len(candidates) == 1: cmd = candidates[0] break elif candidates and not (game.options & OPTION_PLAIN): - prout("Commands with that prefix: " + " ".join(candidates)) + prout("Commands with prefix '%s': %s" % (scanner.token, " ".join(candidates))) else: listCommands() continue @@ -6442,7 +5922,7 @@ def makemoves(): if game.ididit: hitme = True elif cmd == "MOVE": # move under warp - warp(False) + warp(course=None, involuntary=False) elif cmd == "SHIELDS": # shields doshield(shraise=False) if game.ididit: @@ -6451,7 +5931,7 @@ def makemoves(): elif cmd == "DOCK": # dock at starbase dock(True) if game.ididit: - attack(False) + attack(torps_ok=False) elif cmd == "DAMAGES": # damage reports damagereport() elif cmd == "CHART": # chart @@ -6459,7 +5939,7 @@ def makemoves(): elif cmd == "IMPULSE": # impulse impulse() elif cmd == "REST": # rest - os.wait() + wait() if game.ididit: hitme = True elif cmd == "WARP": # warp @@ -6532,14 +6012,14 @@ def makemoves(): events() if game.alldone: break # Events did us in - if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova: atover(False) continue if hitme and not game.justin: - attack(True) + attack(torps_ok=True) if game.alldone: break - if game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova: + if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova: atover(False) hitme = True continue @@ -6549,48 +6029,41 @@ def makemoves(): if idebug: prout("=== Ending") -def cramen(cmd): - # return an enemy - if cmd == IHR: s = _("Romulan") - elif cmd == IHK: s = _("Klingon") - elif cmd == IHC: s = _("Commander") - elif cmd == IHS: s = _("Super-commander") - elif cmd == IHSTAR: s = _("Star") - elif cmd == IHP: s = _("Planet") - elif cmd == IHB: s = _("Starbase") - elif cmd == IHBLANK: s = _("Black hole") - elif cmd == IHT: s = _("Tholian") - elif cmd == IHWEB: s = _("Tholian web") - elif cmd == IHQUEST: s = _("Stranger") - elif cmd == IHW: s = _("Inhabited World") +def cramen(type): + "Emit the name of an enemy or feature." + if type == IHR: s = _("Romulan") + elif type == IHK: s = _("Klingon") + elif type == IHC: s = _("Commander") + elif type == IHS: s = _("Super-commander") + elif type == IHSTAR: s = _("Star") + elif type == IHP: s = _("Planet") + elif type == IHB: s = _("Starbase") + elif type == IHBLANK: s = _("Black hole") + elif type == IHT: s = _("Tholian") + elif type == IHWEB: s = _("Tholian web") + elif type == IHQUEST: s = _("Stranger") + elif type == IHW: s = _("Inhabited World") else: s = "Unknown??" - proutn(s) + return s def crmena(stars, enemy, loctype, w): - # print an enemy and his location - if stars: - proutn("***") - cramen(enemy) - proutn(_(" at ")) + "Emit the name of an enemy and his location." buf = "" + if stars: + buf += "***" + buf += cramen(enemy) + _(" at ") if loctype == "quadrant": - buf = _("Quadrant ") + buf += _("Quadrant ") elif loctype == "sector": - buf = _("Sector ") - proutn(buf + `w`) + buf += _("Sector ") + return buf + `w` def crmshp(): - # print our ship name - if game.ship == IHE: - s = _("Enterprise") - elif game.ship == IHF: - s = _("Faerie Queene") - else: - s = "Ship???" - proutn(s) + "Emit our ship name." + return{IHE:_("Enterprise"),IHF:_("Faerie Queene")}.get(game.ship,"Ship???") def stars(): - # print a line of stars + "Emit a line of stars" prouts("******************************************************") skip(1) @@ -6598,81 +6071,103 @@ def expran(avrage): return -avrage*math.log(1e-7 + randreal()) def randplace(size): - # choose a random location + "Choose a random location." w = coord() - w.x = randrange(size) - w.y = randrange(size) + w.i = randrange(size) + w.j = randrange(size) return w -def chew(): - # Demand input for next scan - global inqueue - inqueue = None - -def chew2(): - # return IHEOL next time - global inqueue - inqueue = [] - -def scan(): - # Get a token from the user - global inqueue, line, citem, aaitem - aaitem = 0.0 - citem = '' - - # Read a line if nothing here - if inqueue == None: - line = cgetline() - if curwnd==prompt_window: - clrscr() - setwnd(message_window) - clrscr() - # Skip leading white space - line = line.lstrip() - if line: - inqueue = line.split() - else: - inqueue = [] - return IHEOL - elif not inqueue: - return IHEOL - # From here on in it's all looking at the queue - citem = inqueue.pop(0) - if citem == IHEOL: - return IHEOL - try: - aaitem = float(citem) - return IHREAL - except ValueError: - pass - # Treat as alpha - citem = citem.lower() - return IHALPHA +class sstscanner: + def __init__(self): + self.type = None + self.token = None + self.real = 0.0 + self.inqueue = [] + def next(self): + # Get a token from the user + self.real = 0.0 + self.token = '' + # Fill the token quue if nothing here + while not self.inqueue: + line = cgetline() + if curwnd==prompt_window: + clrscr() + setwnd(message_window) + clrscr() + if line == '': + return None + if not line: + continue + else: + self.inqueue = line.lstrip().split() + ["\n"] + # From here on in it's all looking at the queue + self.token = self.inqueue.pop(0) + if self.token == "\n": + self.type = "IHEOL" + return "IHEOL" + try: + self.real = float(self.token) + self.type = "IHREAL" + return "IHREAL" + except ValueError: + pass + # Treat as alpha + self.token = self.token.lower() + self.type = "IHALPHA" + self.real = None + return "IHALPHA" + def append(self, tok): + self.inqueue.append(tok) + def push(self, tok): + self.inqueue.insert(0, tok) + def waiting(self): + return self.inqueue + def chew(self): + # Demand input for next scan + self.inqueue = [] + self.real = self.token = None + def sees(self, s): + # compares s to item and returns true if it matches to the length of s + return s.startswith(self.token) + def int(self): + # Round token value to nearest integer + return int(round(scanner.real)) + def getcoord(self): + s = coord() + scanner.next() + if scanner.type != "IHREAL": + huh() + return None + s.i = scanner.int()-1 + scanner.next() + if scanner.type != "IHREAL": + huh() + return None + s.j = scanner.int()-1 + return s + def __repr__(str): + return "" % (scanner.token, scanner.type, scanner.inqueue) def ja(): - # yes-or-no confirmation - chew() + "Yes-or-no confirmation." + scanner.chew() while True: - scan() - chew() - if citem == 'y': + scanner.next() + if scanner.token == 'y': return True - if citem == 'n': + if scanner.token == 'n': return False + scanner.chew() proutn(_("Please answer with \"y\" or \"n\": ")) def huh(): - # complain about unparseable input - chew() + "Complain about unparseable input." + scanner.chew() skip(1) prout(_("Beg your pardon, Captain?")) -def isit(s): - # compares s to citem and returns true if it matches to the length of s - return s.startswith(citem) - def debugme(): - # access to the internals for debugging + "Access to the internals for debugging." proutn("Reset levels? ") if ja() == True: if game.energy < game.inenrg: @@ -6695,12 +6190,10 @@ def debugme(): proutn("Cause selective damage? ") if ja() == True: for i in range(NDEVICES): - proutn("Kill ") - proutn(device[i]) - proutn("? ") - chew() - key = scan() - if key == IHALPHA and isit("y"): + proutn("Kill %s?" % device[i]) + scanner.chew() + key = scanner.next() + if key == "IHALPHA" and scanner.sees("y"): game.damage[i] = 10.0 proutn("Examine/change events? ") if ja() == True: @@ -6729,54 +6222,53 @@ def debugme(): else: proutn("never") proutn("? ") - chew() - key = scan() + scanner.chew() + key = scanner.next() if key == 'n': unschedule(i) - chew() - elif key == IHREAL: - ev = schedule(i, aaitem) + scanner.chew() + elif key == "IHREAL": + ev = schedule(i, scanner.real) if i == FENSLV or i == FREPRO: - chew() + scanner.chew() proutn("In quadrant- ") - key = scan() - # IHEOL says to leave coordinates as they are - if key != IHEOL: - if key != IHREAL: + key = scanner.next() + # "IHEOL" says to leave coordinates as they are + if key != "IHEOL": + if key != "IHREAL": prout("Event %d canceled, no x coordinate." % (i)) unschedule(i) continue - w.x = int(round(aaitem)) - key = scan() - if key != IHREAL: + w.i = int(round(scanner.real)) + key = scanner.next() + if key != "IHREAL": prout("Event %d canceled, no y coordinate." % (i)) unschedule(i) continue - w.y = int(round(aaitem)) + w.j = int(round(scanner.real)) ev.quadrant = w - chew() + scanner.chew() proutn("Induce supernova here? ") if ja() == True: - game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova = True + game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova = True atover(True) if __name__ == '__main__': + import getopt, socket try: global line, thing, game, idebug - game = citem = aaitem = inqueue = None - line = '' + game = None thing = coord() thing.angry = False game = gamestate() idebug = 0 game.options = OPTION_ALL &~ (OPTION_IOMODES | OPTION_PLAIN | OPTION_ALMY) - # Disable curses mode until the game logic is working. - # if os.getenv("TERM"): - # game.options |= OPTION_CURSES | OPTION_SHOWME - # else: - game.options |= OPTION_TTY + if os.getenv("TERM"): + game.options |= OPTION_CURSES + else: + game.options |= OPTION_TTY seed = int(time.time()) - (options, arguments) = getopt.getopt(sys.argv[1:], "r:tx") + (options, arguments) = getopt.getopt(sys.argv[1:], "r:s:tx") for (switch, val) in options: if switch == '-r': try: @@ -6796,6 +6288,8 @@ if __name__ == '__main__': raise SystemExit(1) game.options |= OPTION_TTY game.options &=~ OPTION_CURSES + elif switch == '-s': + seed = int(val) elif switch == '-t': game.options |= OPTION_TTY game.options &=~ OPTION_CURSES @@ -6812,37 +6306,42 @@ if __name__ == '__main__': if logfp: logfp.write("# seed %s\n" % seed) logfp.write("# options %s\n" % " ".join(arguments)) + logfp.write("# recorded by %s@%s on %s\n" % \ + (os.getenv("LOGNAME"),socket.gethostname(),time.ctime())) random.seed(seed) - iostart() - if arguments: - inqueue = arguments - else: - inqueue = None - while True: # Play a game - setwnd(fullscreen_window) - clrscr() - prelim() - setup(needprompt=not inqueue) - if game.alldone: - score() - game.alldone = False - else: - makemoves() - skip(1) - stars() + scanner = sstscanner() + map(scanner.append, arguments) + try: + iostart() + while True: # Play a game + setwnd(fullscreen_window) + clrscr() + prelim() + setup() + if game.alldone: + score() + game.alldone = False + else: + makemoves() + skip(1) + stars() + skip(1) + if game.tourn and game.alldone: + proutn(_("Do you want your score recorded?")) + if ja() == True: + scanner.chew() + scanner.push("\n") + freeze(False) + scanner.chew() + proutn(_("Do you want to play again? ")) + if not ja(): + break skip(1) - if game.tourn and game.alldone: - proutn(_("Do you want your score recorded?")) - if ja() == True: - chew2() - freeze(False) - chew() - proutn(_("Do you want to play again? ")) - if not ja(): - break - skip(1) - prout(_("May the Great Bird of the Galaxy roost upon your home planet.")) + prout(_("May the Great Bird of the Galaxy roost upon your home planet.")) + finally: + ioend() raise SystemExit, 0 except KeyboardInterrupt: - print"" - pass + if logfp: + logfp.close() + print ""