#!/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, getpass
SSTDOC = "/usr/share/doc/sst/sst.doc"
DOC_NAME = "sst.doc"
-# Stub to be replaced
-def _(str): return str
-
-PHASEFAC = 2.0
-GALSIZE = 8
-NINHAB = (GALSIZE * GALSIZE / 2)
-MAXUNINHAB = 10
-PLNETMAX = (NINHAB + MAXUNINHAB)
-QUADSIZE = 10
-BASEMIN = 2
-BASEMAX = (GALSIZE * GALSIZE / 12)
-MAXKLGAME = 127
-MAXKLQUAD = 9
-FULLCREW = 428 # BSD Trek was 387, that's wrong
-FOREVER = 1e30
-MAXBURST = 3
-MINCMDR = 10
-
-# These functions hide the difference between 0-origin and 1-origin addressing.
-def VALID_QUADRANT(x, y): return ((x)>=0 and (x)<GALSIZE and (y)>=0 and (y)<GALSIZE)
-def VALID_SECTOR(x, y): return ((x)>=0 and (x)<QUADSIZE and (y)>=0 and (y)<QUADSIZE)
-
-# How to represent features
-IHR = 'R',
-IHK = 'K',
-IHC = 'C',
-IHS = 'S',
-IHSTAR = '*',
-IHP = 'P',
-IHW = '@',
-IHB = 'B',
-IHBLANK = ' ',
-IHDOT = '.',
-IHQUEST = '?',
-IHE = 'E',
-IHF = 'F',
-IHT = 'T',
-IHWEB = '#',
-IHMATER0 = '-',
-IHMATER1 = 'o',
-IHMATER2 = '0'
-
-IHEOL = '\n'
-IHREAL = 0.0
-IHALPHA = " "
+def _(str): return gettext.gettext(str)
+
+GALSIZE = 8 # Galaxy size in quadrants
+NINHAB = (GALSIZE * GALSIZE / 2) # Number of inhabited worlds
+MAXUNINHAB = 10 # Maximum uninhabited worlds
+QUADSIZE = 10 # Quadrant size in sectors
+BASEMIN = 2 # Minimum starbases
+BASEMAX = (GALSIZE * GALSIZE / 12) # Maximum starbases
+MAXKLGAME = 127 # Maximum Klingons per game
+MAXKLQUAD = 9 # Maximum Klingons per quadrant
+FULLCREW = 428 # Crew size. BSD Trek was 387, that's wrong
+FOREVER = 1e30 # Time for the indefinite future
+MAXBURST = 3 # Max # of torps you can launch in one turn
+MINCMDR = 10 # Minimum number of Klingon commanders
+DOCKFAC = 0.25 # Repair faster when docked
+PHASEFAC = 2.0 # Unclear what this is, it was in the C version
+
+class TrekError:
+ pass
class coord:
def __init__(self, x=None, y=None):
- self.x = x
- self.y = y
+ self.i = x
+ self.j = y
+ def valid_quadrant(self):
+ return self.i>=0 and self.i<GALSIZE and self.j>=0 and self.j<GALSIZE
+ def valid_sector(self):
+ return self.i>=0 and self.i<QUADSIZE and self.j>=0 and self.j<QUADSIZE
def invalidate(self):
- self.x = self.y = None
+ self.i = self.j = None
def is_valid(self):
- return self.x != None and self.y != None
+ return self.i != None and self.j != None
def __eq__(self, other):
- return other != None and self.x == other.y and self.x == other.y
+ return other != None and self.i == other.i and self.j == other.j
+ def __ne__(self, other):
+ return other == None or self.i != other.i or self.j != other.j
def __add__(self, other):
- return coord(self.x+self.x, self.y+self.y)
+ return coord(self.i+other.i, self.j+other.j)
def __sub__(self, other):
- return coord(self.x-other.x, self.y-other.y)
+ return coord(self.i-other.i, self.j-other.j)
def __mul__(self, other):
- return coord(self.x*other, self.y*other)
+ return coord(self.i*other, self.j*other)
def __rmul__(self, other):
- return coord(self.x*other, self.y*other)
+ return coord(self.i*other, self.j*other)
+ def __div__(self, other):
+ return coord(self.i/other, self.j/other)
+ def __mod__(self, other):
+ return coord(self.i % other, self.j % other)
+ def __rdiv__(self, other):
+ return coord(self.i/other, self.j/other)
+ def roundtogrid(self):
+ return coord(int(round(self.i)), int(round(self.j)))
def distance(self, other=None):
if not other: other = coord(0, 0)
- return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
- def bearing(self, other=None):
- if not other: other = coord(0, 0)
- return 1.90985*math.atan2(self.x-other.x, self.y-other.y)
+ return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
+ def bearing(self):
+ return 1.90985*math.atan2(self.j, self.i)
def sgn(self):
s = coord()
- if self.x == 0:
- s.x = 0
+ if self.i == 0:
+ s.i = 0
else:
- s.x = self.x / abs(self.x)
- if self.y == 0:
- s.y = 0
+ s.i = self.i / abs(self.i)
+ if self.j == 0:
+ s.j = 0
else:
- s.y = self.y / abs(self.y)
+ s.j = self.j / abs(self.j)
return s
+ def quadrant(self):
+ #print "Location %s -> %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:
self.baseq = [] # Base quadrant coordinates
self.kcmdr = [] # Commander quadrant coordinates
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:
FREPRO = 11 # Klingons build a ship in an enslaved system
NEVENTS = 12
-#
-# abstract out the event handling -- underlying data structures will change
-# when we implement stateful events
-#
+# Abstract out the event handling -- underlying data structures will change
+# when we implement stateful events
def findevent(evtype): return game.future[evtype]
class enemy:
def __init__(self, type=None, loc=None, power=None):
self.type = type
- self.kloc = coord()
+ self.location = coord()
if loc:
self.move(loc)
- self.kpower = power # enemy energy level
+ self.power = power # enemy energy level
game.enemies.append(self)
def move(self, loc):
- motion = (loc != self.kloc)
- if self.kloc.x is not None and self.kloc.y is not None:
+ motion = (loc != self.location)
+ if self.location.i is not None and self.location.j is not None:
if motion:
- if self.type == IHT:
- game.quad[self.kloc.x][self.kloc.y] = IHWEB
+ if self.type == 'T':
+ game.quad[self.location.i][self.location.j] = '#'
else:
- game.quad[self.kloc.x][self.kloc.y] = IHDOT
+ game.quad[self.location.i][self.location.j] = '.'
if loc:
- self.kloc = copy.copy(loc)
- game.quad[self.kloc.x][self.kloc.y] = self.type
+ self.location = copy.copy(loc)
+ game.quad[self.location.i][self.location.j] = self.type
self.kdist = self.kavgd = (game.sector - loc).distance()
else:
- self.kloc = coord()
+ self.location = 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.location, self.power) # For debugging
class gamestate:
def __init__(self):
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.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
self.energy = 0.0 # energy level
self.shield = 0.0 # shield level
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):
# 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*len(game.state.kcmdr))
-# From enumerated type 'feature'
-IHR = 'R'
-IHK = 'K'
-IHC = 'C'
-IHS = 'S'
-IHSTAR = '*'
-IHP = 'P'
-IHW = '@'
-IHB = 'B'
-IHBLANK = ' '
-IHDOT = '.'
-IHQUEST = '?'
-IHE = 'E'
-IHF = 'F'
-IHT = 'T'
-IHWEB = '#'
-IHMATER0 = '-'
-IHMATER1 = 'o'
-IHMATER2 = '0'
-
-
-# From enumerated type 'FINTYPE'
+
FWON = 0
FDEPLETE = 1
FLIFESUP = 2
FHOLE = 20
FCREW = 21
-# 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<p, traceback.extract_stack()[-2][1:]))
- return v < p
+ return random.random() < p
def randrange(*args):
- v = random.randrange(*args)
- #logfp.write("# randrange%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
- return v
+ return random.randrange(*args)
def randreal(*args):
v = random.random()
if len(args) == 1:
- v *= args[0] # returns from [0, args[0])
+ v *= args[0] # from [0, args[0])
elif len(args) == 2:
- v = args[0] + v*(args[1]-args[0]) # returns from [args[0], args[1])
- #logfp.write("# randreal%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
+ v = args[0] + v*(args[1]-args[0]) # from [args[0], args[1])
return v
# Code from ai.c begins here
def welcoming(iq):
- # Would this quadrant welcome another Klingon?
- return VALID_QUADRANT(iq.x,iq.y) and \
- not game.state.galaxy[iq.x][iq.y].supernova or \
- game.state.galaxy[iq.x][iq.y].klingons < MAXKLQUAD
-
+ "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
+ 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:
+ if enemy.type == 'R':
return False; # Romulans cannot escape!
if not irun:
# avoid intruding on another commander's territory
- if enemy.type == IHC:
+ if enemy.type == 'C':
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:
+ if enemy.power > 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.location) + \
+ (_(" 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
- if enemy.type==IHS:
+ game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
+ game.state.galaxy[iq.i][iq.j].klingons += 1
+ if enemy.type=='S':
game.iscate = False
game.ientesc = False
game.isatb = 0
break
return True; # success
-#
# The bad-guy movement algorithm:
#
# 1. Enterprise has "force" based on condition of phaser and photon torpedoes.
# 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.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
- if enemy.type==IHS and \
- (enemy.kpower <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
+ if enemy.type=='S' and \
+ (enemy.power <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
irun = True
motion = -QUADSIZE
else:
# decide whether to advance, retreat, or hold position
- forces = enemy.kpower+100.0*len(game.enemies)+400*(nbaddys-1)
+ forces = enemy.power+100.0*len(game.enemies)+400*(nbaddys-1)
if not game.shldup:
forces += 1000; # Good for enemy if shield is down!
if not damaged(DPHASER) or not damaged(DPHOTON):
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:
if idebug:
proutn("NSTEPS = %d:" % nsteps)
# Compute preferred values of delta X and Y
- m = game.sector - enemy.kloc
- if 2.0 * abs(m.x) < abs(m.y):
- m.x = 0
- if 2.0 * abs(m.y) < abs(game.sector.x-enemy.kloc.x):
- m.y = 0
- if m.x != 0:
- if m.x*motion < 0:
- m.x = -1
- else:
- m.x = 1
- if m.y != 0:
- if m.y*motion < 0:
- m.y = -1
- else:
- m.y = 1
- next = enemy.kloc
+ m = game.sector - enemy.location
+ if 2.0 * abs(m.i) < abs(m.j):
+ m.i = 0
+ if 2.0 * abs(m.j) < abs(game.sector.i-enemy.location.i):
+ m.j = 0
+ m = (motion * m).sgn()
+ next = enemy.location
# main move loop
for ll in range(nsteps):
if idebug:
proutn(" %d" % (ll+1))
# Check if preferred position available
look = next + m
- if m.x < 0:
- krawlx = 1
+ if m.i < 0:
+ krawli = 1
else:
- krawlx = -1
- if m.y < 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 == m.x or m.y == 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 == m.y or m.x == 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] != '.':
# See if enemy should ram ship
- if game.quad[look.x][look.y] == game.ship and \
- (enemy.type == IHC or enemy.type == IHS):
+ if game.quad[look.i][look.j] == game.ship and \
+ (enemy.type == 'C' or enemy.type == 'S'):
collision(rammed=True, enemy=enemy)
return
- if krawlx != m.x and m.y != 0:
- look.x = next.x + krawlx
- krawlx = -krawlx
- elif krawly != m.y and m.x != 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:
skip(1)
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.location))
if enemy.kdist < dist1:
proutn(_(" advances to "))
else:
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.quadrant in game.state.kcmdr:
for enemy in game.enemies:
- if enemy.type == IHC:
+ if enemy.type == 'C':
movebaddy(enemy)
if game.state.kscmdr==game.quadrant:
for enemy in game.enemies:
- if enemy.type == IHS:
+ if enemy.type == 'S':
movebaddy(enemy)
break
# If skill level is high, move other Klingons and Romulans too!
# commander(s) do.
if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
for enemy in game.enemies:
- if enemy.type in (IHK, IHR):
+ if enemy.type in ('K', 'R'):
movebaddy(enemy)
game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
def movescom(iq, avoid):
- # commander movement helper
+ "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 True
+ 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
+ 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.ientesc = False
unschedule(FSCDBAS)
for enemy in game.enemies:
- if enemy.type == IHS:
+ if enemy.type == 'S':
break
enemy.move(None)
game.klhere -= 1
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:
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 not game.state.baseq:
# 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 len(game.state.baseq) == 0:
unschedule(FSCMOVE)
else:
- for (i, ibq) in enumerate(game.state.baseq):
+ for ibq in game.state.baseq:
if ibq == game.state.kscmdr and game.state.kscmdr == game.battle:
# attack the base
if avoid:
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"))
return
def movetholian():
- # move the Tholian
+ "Move the Tholian."
if not game.tholian or game.justin:
return
id = coord()
- if game.tholian.kloc.x == 0 and game.tholian.kloc.y == 0:
- id.x = 0; id.y = QUADSIZE-1
- elif game.tholian.kloc.x == 0 and game.tholian.kloc.y == QUADSIZE-1:
- id.x = QUADSIZE-1; id.y = QUADSIZE-1
- elif game.tholian.kloc.x == QUADSIZE-1 and game.tholian.kloc.y == QUADSIZE-1:
- id.x = QUADSIZE-1; id.y = 0
- elif game.tholian.kloc.x == QUADSIZE-1 and game.tholian.kloc.y == 0:
- id.x = 0; id.y = 0
+ if game.tholian.location.i == 0 and game.tholian.location.j == 0:
+ id.i = 0; id.j = QUADSIZE-1
+ elif game.tholian.location.i == 0 and game.tholian.location.j == QUADSIZE-1:
+ id.i = QUADSIZE-1; id.j = QUADSIZE-1
+ elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == QUADSIZE-1:
+ id.i = QUADSIZE-1; id.j = 0
+ elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == 0:
+ id.i = 0; id.j = 0
else:
# something is wrong!
game.tholian.move(None)
prout("***Internal error: Tholian in a bad spot.")
return
# do nothing if we are blocked
- if game.quad[id.x][id.y] not in (IHDOT, IHWEB):
+ if game.quad[id.i][id.j] not in ('.', '#'):
return
- here = copy.copy(game.tholian.kloc)
- delta = (id - game.tholian.kloc).sgn()
+ here = copy.copy(game.tholian.location)
+ delta = (id - game.tholian.location).sgn()
# move in x axis
- while here.x != id.x:
- #print "Moving in X", delta
- here.x += delta.x
- if game.quad[here.x][here.y]==IHDOT:
+ while here.i != id.i:
+ here.i += delta.i
+ if game.quad[here.i][here.j]=='.':
game.tholian.move(here)
# move in y axis
- while here.y != id.y:
- #print "Moving in Y", delta
- here.y += delta.y
- if game.quad[here.x][here.y]==IHDOT:
+ while here.j != id.j:
+ here.j += delta.j
+ if game.quad[here.i][here.j]=='.':
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:
+ if game.quad[0][i]!='#' and game.quad[0][i]!='T':
return
- if game.quad[QUADSIZE][i]!=IHWEB and game.quad[QUADSIZE][i]!=IHT:
+ if game.quad[QUADSIZE-1][i]!='#' and game.quad[QUADSIZE-1][i]!='T':
return
- if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT:
+ if game.quad[i][0]!='#' and game.quad[i][0]!='T':
return
- if game.quad[i][QUADSIZE]!=IHWEB and game.quad[i][QUADSIZE]!=IHT:
+ if game.quad[i][QUADSIZE-1]!='#' and game.quad[i][QUADSIZE-1]!='T':
return
# All plugged up -- Tholian splits
- game.quad[game.tholian.kloc.x][game.tholian.kloc.y]=IHWEB
- dropin(IHBLANK)
- crmena(True, IHT, "sector", game.tholian)
- prout(_(" completes web."))
+ game.quad[game.tholian.location.i][game.tholian.location.j]='#'
+ dropin(' ')
+ prout(crmena(True, 'T', "sector", game.tholian) + _(" completes web."))
game.tholian.move(None)
- print "Tholian movement ends"
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 = scanner.next()
- if key == IHALPHA:
+ if key == "IHALPHA":
if scanner.sees("transfer"):
action = "NRG"
else:
game.ididit = True
return
elif action == "NRG":
- while scanner.next() != IHREAL:
+ while scanner.next() != "IHREAL":
scanner.chew()
proutn(_("Energy to transfer to shields- "))
scanner.chew()
return
def randdevice():
- # choose a device to damage, at random.
- #
- # Quoth Eric Allman in the code of BSD-Trek:
- # "Under certain conditions you can get a critical hit. This
- # sort of hit damages devices. The probability that a given
- # device is damaged depends on the device. Well protected
- # devices (such as the computer, which is in the core of the
- # ship and has considerable redundancy) almost never get
- # damaged, whereas devices which are exposed (such as the
- # warp engines) or which are particularly delicate (such as
- # the transporter) have a much higher probability of being
- # damaged."
- #
- # This is one place where OPTION_PLAIN does not restore the
- # original behavior, which was equiprobable damage across
- # all devices. If we wanted that, we'd return randrange(NDEVICES)
- # and have done with it. Also, in the original game, DNAVYS
- # and DCOMPTR were the same device.
- #
- # Instead, we use a table of weights similar to the one from BSD Trek.
- # BSD doesn't have the shuttle, shield controller, death ray, or probes.
- # We don't have a cloaking device. The shuttle got the allocation
- # for the cloaking device, then we shaved a half-percent off
- # everything to have some weight to give DSHCTRL/DDRAY/DDSP.
- #
+ "Choose a device to damage, at random."
weights = (
105, # DSRSENS: short range scanners 10.5%
105, # DLRSENS: long range scanners 10.5%
120, # DPHASER: phasers 12.0%
120, # DPHOTON: photon torpedoes 12.0%
- 25, # DLIFSUP: life support 2.5%
+ 25, # DLIFSUP: life support 2.5%
65, # DWARPEN: warp drive 6.5%
70, # DIMPULS: impulse engines 6.5%
145, # DSHIELD: deflector shields 14.5%
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()
- hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0)
+ proutn(crmshp())
+ hardness = {'R':1.5, 'C':2.0, 'S':2.5, 'T':0.5, '?':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.location))
if rammed:
proutn(_(" (original position)"))
skip(1)
- deadkl(enemy.kloc, enemy.type, game.sector)
- proutn("***")
- crmshp()
- prout(_(" heavily damaged."))
+ deadkl(enemy.location, enemy.type, game.sector)
+ 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()
finish(FWON)
return
-def torpedo(course, dispersion, origin, number, nburst):
- # let a photon torpedo fly
- iquad = 0
- shoved = False
- ac = course + 0.25*dispersion
- angle = (15.0-ac)*0.5235988
- bullseye = (15.0 - course)*0.5235988
- deltax = -math.sin(angle);
- deltay = math.cos(angle);
- x = origin.x; y = origin.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 step 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]
+ iquad=game.quad[w.i][w.j]
tracktorpedo(origin, w, step, number, nburst, iquad)
- if iquad==IHDOT:
+ if iquad=='.':
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
+ if iquad in ('E', 'F'): # Hit our ship
skip(1)
- proutn(_("Torpedo hits "))
- crmshp()
- prout(".")
+ prout(_("Torpedo hits %s.") % crmshp())
hit = 700.0 + randreal(100) - \
- 1000.0 * (w-origin).distance() * 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]==' ':
finish(FHOLE)
return hit
- if game.quad[jw.x][jw.y]!=IHDOT:
+ if game.quad[bumpto.i][bumpto.j]!='.':
# 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]='.'
+ 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.location).distance()
+ game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ return None
+ elif iquad in ('C', 'S', 'R', 'K'): # Hit a regular enemy
+ # find the enemy
+ if iquad in ('C', 'S') 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.location:
break
- kp = math.fabs(e.kpower)
+ kp = math.fabs(enemy.power)
h1 = 700.0 + randrange(100) - \
- 1000.0 * (w-origin).distance() * 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
- if enemy.kpower < 0:
- enemy.kpower -= -h1
+ if enemy.power < 0:
+ enemy.power -= -h1
else:
- enemy.kpower -= h1
- if enemy.kpower == 0:
+ enemy.power -= h1
+ if enemy.power == 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 = int(w.x+xx+0.5)
- jw.y = int(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] == ' ':
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] != '.':
prout(_(" damaged but not destroyed."))
- return None
- proutn(_(" damaged--"))
- enemy.kloc = jw
- shoved = True
- break
- elif iquad == IHB: # Hit a base
+ else:
+ prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
+ enemy.location = bumpto
+ game.quad[w.i][w.j]='.'
+ game.quad[bumpto.i][bumpto.j]=iquad
+ for enemy in game.enemies:
+ enemy.kdist = enemy.kavgd = (game.sector-enemy.location).distance()
+ game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ return None
+ elif iquad == 'B': # Hit a base
skip(1)
prout(_("***STARBASE DESTROYED.."))
game.state.baseq = filter(lambda x: x != game.quadrant, game.state.baseq)
- game.quad[w.x][w.y]=IHDOT
+ game.quad[w.i][w.j]='.'
game.base.invalidate()
- game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase -= 1
- game.state.chart[game.quadrant.x][game.quadrant.y].starbase -= 1
+ 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."))
+ elif iquad == 'P': # Hit a planet
+ 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
game.plnet.invalidate()
- game.quad[w.x][w.y] = IHDOT
+ game.quad[w.i][w.j] = '.'
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."))
+ elif iquad == '@': # Hit an inhabited world -- very bad!
+ 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
game.plnet.invalidate()
- game.quad[w.x][w.y] = IHDOT
+ game.quad[w.i][w.j] = '.'
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
+ elif iquad == '*': # Hit a star
if withprob(0.9):
nova(w)
else:
- crmena(True, IHSTAR, "sector", w)
- prout(_(" unaffected by photon blast."))
+ prout(crmena(True, '*', "sector", w) + _(" unaffected by photon blast."))
return None
- elif iquad == IHQUEST: # Hit a thingy
+ elif iquad == '?': # Hit a thingy
if not (game.options & OPTION_THINGY) or withprob(0.3):
skip(1)
prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
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
+ elif iquad == ' ': # Black hole
skip(1)
- crmena(True, IHBLANK, "sector", w)
- prout(_(" swallows torpedo."))
+ prout(crmena(True, ' ', "sector", w) + _(" swallows torpedo."))
return None
- elif iquad == IHWEB: # hit the web
+ elif iquad == '#': # hit the web
skip(1)
prout(_("***Torpedo absorbed by Tholian web."))
return None
- elif iquad == IHT: # Hit a Tholian
+ elif iquad == 'T': # Hit a Tholian
h1 = 700.0 + randrange(100) - \
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] = '.'
deadkl(w, iquad, w)
game.tholian = None
return None
skip(1)
- crmena(True, IHT, "sector", w)
+ proutn(crmena(True, 'T', "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
- dropin(IHBLANK)
+ game.quad[w.i][w.j] = '#'
+ dropin(' ')
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 = (game.sector-game.enemies[ll].kloc).distance()
- 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)))
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
if game.skill <= SKILL_FAIR:
where = "sector"
for enemy in game.enemies:
- if enemy.kpower < 0:
+ if enemy.power < 0:
continue; # too weak to attack
# compute hit strength and diminish shield power
r = randreal()
# Increase chance of photon torpedos if docked or enemy energy is low
if game.condition == "docked":
r *= 0.25
- if enemy.kpower < 500:
+ if enemy.power < 500:
r *= 0.25;
- if enemy.type==IHT or (enemy.type==IHQUEST and not thing.angry):
+ if enemy.type=='T' or (enemy.type=='?' and not thing.angry):
continue
# different enemies have different probabilities of throwing a torp
usephasers = not torps_ok or \
- (enemy.type == IHK and r > 0.0005) or \
- (enemy.type==IHC and r > 0.015) or \
- (enemy.type==IHR and r > 0.3) or \
- (enemy.type==IHS and r > 0.07) or \
- (enemy.type==IHQUEST and r > 0.05)
+ (enemy.type == 'K' and r > 0.0005) or \
+ (enemy.type=='C' and r > 0.015) or \
+ (enemy.type=='R' and r > 0.3) or \
+ (enemy.type=='S' and r > 0.07) or \
+ (enemy.type=='?' and r > 0.05)
if usephasers: # Enemy uses phasers
if game.condition == "docked":
continue; # Don't waste the effort!
attempt = True; # Attempt to attack
dustfac = randreal(0.8, 0.85)
- hit = enemy.kpower*math.pow(dustfac,enemy.kavgd)
- enemy.kpower *= 0.75
+ hit = enemy.power*math.pow(dustfac,enemy.kavgd)
+ enemy.power *= 0.75
else: # Enemy uses photon torpedo
- #course2 = (enemy.kloc-game.sector).bearing()
- 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.location.j, enemy.location.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.location))
attempt = True
prout(" ")
dispersion = (randreal()+randreal())*0.5 - 0.5
- dispersion += 0.002*enemy.kpower*dispersion
- hit = torpedo(course, dispersion, origin=enemy.kloc, number=1, nburst=1)
+ dispersion += 0.002*enemy.power*dispersion
+ hit = torpedo(enemy.location, 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
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.location))
skip(1)
# Decide if hit is critical
if hit > hitmax:
# 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:
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
+ if type == 'R':
+ # 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:
+ elif type == 'T':
# Killed a Tholian
game.tholian = None
- elif type == IHQUEST:
+ elif type == '?':
# Killed a Thingy
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:
+ if type == 'C':
game.state.kcmdr.remove(game.quadrant)
unschedule(FTBEAM)
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:
+ elif type == 'K':
game.state.remkl -= 1
- elif type == IHS:
+ elif type == 'S':
game.state.nscrem -= 1
game.state.kscmdr.invalidate()
game.isatb = 0
game.recompute()
# Remove enemy ship from arrays describing local conditions
for e in game.enemies:
- if e.kloc == w:
+ if e.location == w:
e.move(None)
break
return
def targetcheck(w):
- # Return None if target is invalid, otherwise return a course angle
- if not VALID_SECTOR(w.x, w.y):
+ "Return None if target is invalid, otherwise return a course angle."
+ if not w.valid_sector():
huh()
return None
- delta = 0.1*(w - game.sector)
- if delta.x==0 and delta.y== 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"))
return delta.bearing()
def photon():
- # launch photon torpedo
- course = [0.0] * MAXBURST
+ "Launch photon torpedo."
+ course = []
game.ididit = False
if damaged(DPHOTON):
prout(_("Photon tubes damaged."))
prout(_("No torpedoes left."))
scanner.chew()
return
- key = scanner.next()
+ # 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 = scanner.next()
- else: # key == IHREAL
+ continue # Go back around to get a number
+ else: # key == "IHREAL"
n = scanner.int()
if n <= 0: # abort command
scanner.chew()
if n > MAXBURST:
scanner.chew()
prout(_("Maximum of %d torpedoes per burst.") % MAXBURST)
- key = IHEOL
return
- if n <= game.torps:
- break
- scanner.chew()
- key = IHEOL
- targ = []
- for i in range(MAXBURST):
- targ.append(coord())
+ 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; # we will try prompting
- if i==1 and key == IHEOL:
+ 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] = targ[0]
- course[i] = course[0]
+ while i < n:
+ target.append(target[0])
+ course.append(course[0])
i += 1
break
- if key != IHREAL:
- huh()
- return
- targ[i].x = scanner.int()
- key = scanner.next()
- if key != IHREAL:
- huh()
- return
- targ[i].y = scanner.int()
- course[i] = targetcheck(targ[i])
- 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
scanner.chew()
- if i == 0 and key == IHEOL:
+ if len(target) == 0:
# prompt for each one
for i in range(n):
proutn(_("Target sector for torpedo number %d- ") % (i+1))
- key = scanner.next()
- if key != IHREAL:
- huh()
- return
- targ[i].x = scanner.int()
- key = scanner.next()
- if key != IHREAL:
- huh()
- return
- targ[i].y = scanner.int()
scanner.chew()
- course[i] = targetcheck(targ[i])
- if course[i] == None:
+ 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 <n> torpedoes
break
if game.shldup or game.condition == "docked":
dispersion *= 1.0 + 0.0001*game.shield
- torpedo(course[i], dispersion, origin=game.sector, number=i, nburst=n)
- if game.alldone or game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova:
+ 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 + 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):
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."))
return True;
def hittem(hits):
- # register a phaser hit on Klingons and Romulans
+ "Register a phaser hit on Klingons and Romulans."
nenhr2 = len(game.enemies); kk=0
w = coord()
skip(1)
- print "Hits are:", hits
for (k, wham) in enumerate(hits):
if wham==0:
continue
dustfac = randreal(0.9, 1.0)
hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
- kpini = game.enemies[kk].kpower
+ kpini = game.enemies[kk].power
kp = math.fabs(kpini)
if PHASEFAC*hit < kp:
kp = PHASEFAC*hit
- if game.enemies[kk].kpower < 0:
- game.enemies[kk].kpower -= -kp
+ if game.enemies[kk].power < 0:
+ game.enemies[kk].power -= -kp
else:
- game.enemies[kk].kpower -= kp
- kpow = game.enemies[kk].kpower
- w = game.enemies[kk].kloc
+ game.enemies[kk].power -= kp
+ kpow = game.enemies[kk].power
+ w = game.enemies[kk].location
if hit > 0.005:
if not damaged(DSRSENS):
boom(w)
proutn(_("%d unit hit on ") % int(hit))
else:
proutn(_("Very small hit on "))
- ienm = game.quad[w.x][w.y]
- if ienm==IHQUEST:
+ ienm = game.quad[w.i][w.j]
+ if ienm=='?':
thing.angry = True
- crmena(False, ienm, "sector", w)
+ proutn(crmena(False, ienm, "sector", w))
skip(1)
if kpow == 0:
deadkl(w, ienm, w)
if kpow>0 and withprob(0.9) and kpow <= randreal(0.4, 0.8)*kpini:
prout(_("***Mr. Spock- \"Captain, the vessel at Sector %s")%w)
prout(_(" has just lost its firepower.\""))
- game.enemies[kk].kpower = -kpow
+ game.enemies[kk].power = -kpow
kk += 1
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
# (That was Tom Almy talking about the C code, I think -- ESR)
while automode=="NOTSET":
key=scanner.next()
- if key == IHALPHA:
+ if key == "IHALPHA":
if scanner.sees("manual"):
if len(game.enemies)==0:
prout(_("There is no enemy present to select."))
scanner.chew()
- key = IHEOL
+ key = "IHEOL"
automode="AUTOMATIC"
else:
automode = "MANUAL"
else:
huh()
return
- elif key == IHREAL:
+ elif key == "IHREAL":
if len(game.enemies)==0:
prout(_("Energy will be expended into space."))
automode = "AUTOMATIC"
else:
automode = "AUTOMATIC"
else:
- # IHEOL
+ # "IHEOL"
if len(game.enemies)==0:
prout(_("Energy will be expended into space."))
automode = "AUTOMATIC"
if ifast:
avail -= 200.0
if automode == "AUTOMATIC":
- if key == IHALPHA and scanner.sees("no"):
+ if key == "IHALPHA" and scanner.sees("no"):
no = True
key = scanner.next()
- if key != IHREAL and len(game.enemies) != 0:
+ if key != "IHREAL" and len(game.enemies) != 0:
prout(_("Phasers locked on target. Energy available: %.2f")%avail)
irec=0
while True:
scanner.chew()
if not kz:
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
+ irec += math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
kz=1
proutn(_("%d units required. ") % irec)
scanner.chew()
proutn(_("Units to fire= "))
key = scanner.next()
- if key!=IHREAL:
+ if key!="IHREAL":
return
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:
scanner.chew()
return
key=scanner.next()
- if key == IHALPHA and scanner.sees("no"):
+ if key == "IHALPHA" and scanner.sees("no"):
no = True
if ifast:
game.energy -= 200; # Go and do it!
hits.append(0.0)
if powrem <= 0:
continue
- hits[i] = math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
+ hits[i] = math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
over = randreal(1.01, 1.06) * hits[i]
temp = powrem
powrem -= hits[i] + over
prout(_("%d expended on empty space.") % int(extra))
elif automode == "FORCEMAN":
scanner.chew()
- key = IHEOL
+ key = "IHEOL"
if damaged(DCOMPTR):
prout(_("Battle computer damaged, manual fire only."))
else:
elif automode == "MANUAL":
rpow = 0.0
for k in range(len(game.enemies)):
- aim = game.enemies[k].kloc
- ienm = game.quad[aim.x][aim.y]
+ aim = game.enemies[k].location
+ 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 game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS):
- cramen(ienm)
- prout(_(" can't be located without short range scan."))
+ not game.sector.distance(aim)<2**0.5 and ienm in ('C', 'S'):
+ prout(cramen(ienm) + _(" can't be located without short range scan."))
scanner.chew()
- key = IHEOL
+ key = "IHEOL"
hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko
k += 1
continue
- if key == IHEOL:
+ 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
+ irec=(abs(game.enemies[k].power)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) * randreal(1.01, 1.06) + 1.0
kz = k
proutn("(")
if not damaged(DCOMPTR):
else:
proutn("??")
proutn(") ")
- proutn(_("units to fire at "))
- crmena(False, ienm, "sector", aim)
- proutn("- ")
+ proutn(_("units to fire at %s- ") % crmena(False, ienm, "sector", aim))
key = scanner.next()
- if key == IHALPHA and scanner.sees("no"):
+ if key == "IHALPHA" and scanner.sees("no"):
no = True
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
# zero energy -- abort
scanner.chew()
return
- if key == IHALPHA and scanner.sees("no"):
+ if key == "IHALPHA" and scanner.sees("no"):
no = True
game.energy -= rpow
scanner.chew()
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!"))
# 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?\""))
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
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:
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.)"))
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(torps_ok=False)
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.state.chart[game.battle.i][game.battle.j].starbase = False
+ game.quad[game.base.i][game.base.j] = '.'
game.base.invalidate()
newcnd()
skip(1)
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
+ 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.isatb = 0
else:
game.battle.invalidate()
-
if idebug:
prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
for i in range(1, NEVENTS):
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
# Fix devices
repair = xtime
if game.condition == "docked":
- repair /= game.docfac
+ repair /= DOCKFAC
# Don't fix Deathray here
for l in range(NDEVICES):
if game.damage[l] > 0.0 and l != DDRAY:
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 \
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 "foundit"
- except "foundit":
- # no match found -- try later
- schedule(FBATTAK, expran(0.3*game.intime))
- unschedule(FCDBAS)
- continue
+ 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)
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
if evcode==FCDBAS:
unschedule(FCDBAS)
if not game.state.baseq() \
- or not game.state.galaxy[game.battle.x][game.battle.y].starbase:
+ or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
game.battle.invalidate()
continue
# find the lucky pair
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)
# 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):
# 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") \
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
# 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
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
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
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"))
prout(_("in Quadrant %s.") % w)
def wait():
- # wait on events
+ "Wait on events."
game.ididit = False
while True:
key = scanner.next()
- if key != IHEOL:
+ if key != "IHEOL":
break
proutn(_("How long? "))
scanner.chew()
- if key != IHREAL:
+ if key != "IHREAL":
huh()
return
origTime = delay = scanner.real
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] = '.'
+ prout(crmena(False, '*', "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]
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):
+ if iquad in ('.', '?', ' ', 'T', '#'):
pass
- elif iquad == IHSTAR: # Affect another star
+ elif iquad == '*': # 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, '*', "sector", neighbor))
prout(_(" novas."))
- game.quad[neighbor.x][neighbor.y] = IHDOT
+ game.quad[neighbor.i][neighbor.j] = '.'
kount += 1
- elif iquad in (IHP, IHW): # Destroy planet
- game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None
- if iquad == IHP:
+ elif iquad in ('P', '@'): # Destroy planet
+ game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
+ if iquad == 'P':
game.state.nplankl += 1
else:
game.state.worldkl += 1
- crmena(True, iquad, "sector", neighbor)
- prout(_(" destroyed."))
+ prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
game.iplnet.pclass = "destroyed"
game.iplnet = None
game.plnet.invalidate()
if game.landed:
finish(FPNOVA)
return
- game.quad[neighbor.x][neighbor.y] = IHDOT
- elif iquad == IHB: # Destroy base
- game.state.galaxy[game.quadrant.x][game.quadrant.y].starbase = False
+ game.quad[neighbor.i][neighbor.j] = '.'
+ elif iquad == 'B': # Destroy 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
- elif iquad in (IHE, IHF): # Buffet ship
+ prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
+ game.quad[neighbor.i][neighbor.j] = '.'
+ elif iquad in ('E', 'F'): # Buffet ship
prout(_("***Starship buffeted by nova."))
if game.shldup:
if game.shield >= 2000.0:
return
# add in course nova contributes to kicking starship
bump += (game.sector-hits[mm]).sgn()
- elif iquad == IHK: # kill klingon
+ elif iquad == 'K': # kill klingon
deadkl(neighbor, iquad, neighbor)
- elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies
+ elif iquad in ('C','S','R'): # Damage/destroy big enemies
for ll in range(len(game.enemies)):
- if game.enemies[ll].kloc == neighbor:
+ if game.enemies[ll].location == neighbor:
break
- game.enemies[ll].kpower -= 800.0 # If firepower is lost, die
- if game.enemies[ll].kpower <= 0.0:
+ game.enemies[ll].power -= 800.0 # If firepower is lost, die
+ if game.enemies[ll].power <= 0.0:
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]
- if iquad1 == IHBLANK:
- proutn(_(", blasted into "))
- crmena(False, IHBLANK, "sector", newc)
+ iquad1 = game.quad[newc.i][newc.j]
+ if iquad1 == ' ':
+ proutn(_(", blasted into ") + crmena(False, ' ', "sector", newc))
skip(1)
deadkl(neighbor, iquad, newc)
break
- if iquad1 != IHDOT:
+ if iquad1 != '.':
# can't move into something else
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] = '.'
+ 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:
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]=='*':
num -= 1
if num==0:
break
prouts(_("***RED ALERT! RED ALERT!"))
skip(1)
prout(_("***Incipient supernova detected at Sector %s") % ns)
- if (ns.x-game.sector.x)**2 + (ns.y-game.sector.y)**2 <= 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)
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):
# 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 + 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)
# Code from finish.c ends here.
def selfdestruct():
- # self-destruct maneuver
- # Finish with a BANG!
+ "Self-destruct maneuver. Finish with a BANG!"
scanner.chew()
if damaged(DCOMPTR):
prout(_("Computer damaged; cannot execute destruct sequence."))
def kaboom():
stars()
- if game.ship==IHE:
+ if game.ship=='E':
prouts("***")
- prouts(_("********* Entropy of "))
- crmshp()
- prouts(_(" maximized *********"))
+ prouts(_("********* Entropy of %s maximized *********") % crmshp())
skip(1)
stars()
skip(1)
whammo = 25.0 * game.energy
l=1
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)
+ if game.enemies[l].power*game.enemies[l].kdist <= whammo:
+ deadkl(game.enemies[l].location, game.quad[game.enemies[l].location.i][game.enemies[l].location.j], game.enemies[l].location)
l += 1
finish(FDILITHIUM)
45.0*game.nhelp +\
100.0*game.state.basekl +\
3.0*game.abandoned
- if game.ship == IHF:
+ if game.ship == 'F':
badpt += 100.0
elif game.ship == None:
badpt += 200.0
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:
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"))
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."))
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)
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"))
prout(_("You are crushed into extremely dense matter."))
elif ifin == FCREW:
prout(_("Your last crew member has died."))
- if game.ship == IHF:
+ if game.ship == 'F':
game.ship = None
- elif game.ship == IHE:
- game.ship = IHF
+ elif game.ship == 'E':
+ game.ship = 'F'
game.alive = False
if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
goodies = game.state.remres/game.inresor
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 + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0:
iwon = 0
if game.gamewon:
iwon = 100*game.skill
- if game.ship == IHE:
+ if game.ship == 'E':
klship = 0
- elif game.ship == IHF:
+ elif game.ship == 'F':
klship = 1
else:
klship = 2
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: "))
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)
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:
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()
prompt_window = curses.newwin(1, 0, rows-2, 0)
message_window.scrollok(True)
setwnd(fullscreen_window)
- textcolor(DEFAULT)
-
-def textcolor(color):
- "Set text foreground color. Presently a stub."
- pass # FIXME
def ioend():
- "Wrap up I/O. Presently a stub."
- pass
+ "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"
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():
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()
pause_game()
clrscr()
else:
- proutn("\n")
+ try:
+ curwnd.move(y+1, 0)
+ except curses.error:
+ pass
else:
global linecount
linecount += 1
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:
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."
curwnd.refresh()
linecount = 0
-def highvideo():
- "Set highlight video, if this is reasonable."
- if game.options & OPTION_CURSES:
- curwnd.attron(curses.A_REVERSE)
-
#
# Things past this point have policy implications.
#
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()
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)
if step == 1:
if n != 1:
skip(1)
- proutn(_("Track for %s torpedo number %d- ") % (game.quad[origin.x][origin.y],i+1))
+ proutn(_("Track for torpedo number %d- ") % (i+1))
else:
skip(1)
proutn(_("Torpedo track- "))
if i != 0 and step == 1:
drawmaps(2)
time.sleep(0.4)
- if (iquad==IHDOT) or (iquad==IHBLANK):
+ if (iquad=='.') or (iquad==' '):
put_srscan_sym(w, '+')
#sound(step*10)
#time.sleep(0.1)
# 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.enemies:
+ 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()
+ finald = (w - enemy.location).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.x][game.quadrant.y].supernova:
+ # 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)
- for enemy in game.enemies:
- enemy.kavgd = enemy.kdist
- newcnd()
- drawmaps(0)
- setwnd(message_window)
- w.x = w.y = 0
+ 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 != '.':
+ # object encountered in flight path
+ stopegy = 50.0*course.distance/game.optime
+ if iquad in ('T', 'K', 'C', 'S', 'R', '?'):
+ for enemy in game.enemies:
+ if enemy.location == game.sector:
+ break
+ collision(rammed=False, enemy=enemy)
+ return True
+ elif iquad == ' ':
+ 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 == '#':
+ 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 len(game.enemies) != 0 and not novapush:
- 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.x][game.quadrant.y].supernova:
- attack(torps_ok=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(torps_ok=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 = (game.sector - w).distance() / (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 = (game.sector - w).distance() / (QUADSIZE * 1.0)
- game.sector = w
- final = game.sector
- no_quad_change()
+ # Move out
+ game.quad[game.sector.i][game.sector.j] = '.'
+ 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.location).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
+ "Dock our ship at a starbase."
scanner.chew()
if game.condition == "docked" and verbose:
prout(_("Already docked."))
if game.inorbit:
prout(_("You must first leave standard orbit."))
return
- if not game.base.is_valid() 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":
prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\""))
attackreport(False)
game.iseenit = True
-
-# This program originally required input in terms of a (clock)
-# direction and distance. Somewhere in history, it was changed to
-# cartesian coordinates. So we need to convert. Probably
-# "manual" input should still be done this way -- it's a real
-# pain if the computer isn't working! Manual mode is still confusing
-# because it involves giving x and y motions, yet the coordinates
-# are always displayed y - x, where +y is downward!
-
-def 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"
prout(_("Dummy! You can't leave standard orbit until you"))
proutn(_("are back aboard the ship."))
scanner.chew()
- return False
+ raise TrekError
while navmode == "unspecified":
if damaged(DNAVSYS):
if isprobe:
prout(_("Computer damaged; manual movement only"))
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 = scanner.next()
- if key == IHEOL:
+ key = scanner.next()
+ if key == "IHEOL":
proutn(_("Manual or automatic- "))
iprompt = True
scanner.chew()
- elif key == IHALPHA:
+ elif key == "IHALPHA":
if scanner.sees("manual"):
navmode = "manual"
key = scanner.next()
else:
huh()
scanner.chew()
- return False
+ raise TrekError
else: # numeric
if isprobe:
prout(_("(Manual navigation assumed.)"))
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:
scanner.chew()
iprompt = True
key = scanner.next()
- if key != IHREAL:
+ if key != "IHREAL":
huh()
- return False
+ raise TrekError
xi = int(round(scanner.real))-1
key = scanner.next()
- if key != IHREAL:
+ if key != "IHREAL":
huh()
- return False
+ raise TrekError
xj = int(round(scanner.real))-1
key = scanner.next()
- if key == IHREAL:
+ if key == "IHREAL":
# both quadrant and sector specified
xk = int(round(scanner.real))-1
key = scanner.next()
- if key != IHREAL:
+ if key != "IHREAL":
huh()
- return False
+ raise TrekError
xl = int(round(scanner.real))-1
- dquad.x = xi
- dquad.y = xj
- dsect.y = xk
- dsect.x = xl
+ 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":
else:
prout(_("Ensign Chekov- \"Course laid in, Captain.\""))
# the actual deltas get computed here
- delta = coord()
- delta.x = dquad.y-game.quadrant.y + 0.1*(dsect.x-game.sector.y)
- delta.y = 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- "))
scanner.chew()
iprompt = True
key = scanner.next()
itemp = "verbose"
- if key != IHREAL:
+ if key != "IHREAL":
huh()
- return False
- delta.x = scanner.real
+ raise TrekError
+ delta.j = scanner.real
key = scanner.next()
- if key != IHREAL:
+ if key != "IHREAL":
huh()
- return False
- delta.y = scanner.real
+ raise TrekError
+ delta.i = scanner.real
# Check for zero movement
- if delta.x == 0 and delta.y == 0:
+ if delta.i == 0 and delta.j == 0:
scanner.chew()
- return False
+ raise TrekError
if itemp == "verbose" and not isprobe:
skip(1)
prout(_("Helmsman Sulu- \"Aye, Sir.\""))
- # Course actually laid in.
- game.dist = delta.distance()
- game.direc = delta.bearing()
- if game.direc < 0.0:
- game.direc += 12.0
scanner.chew()
- return True
+ 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):
scanner.chew()
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:
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"))
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:
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:
scanner.chew()
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:
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"))
if game.warpfac > 6.0:
# Decide if engine damage will occur
# ESR: Seems wrong. Probability of damage goes *down* with distance?
- prob = game.dist*(6.0-game.warpfac)**2/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
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] != '.':
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:
return
def setwarp():
- # change the warp factor
+ "Change the warp factor."
while True:
key=scanner.next()
- if key != IHEOL:
+ if key != "IHEOL":
break
scanner.chew()
proutn(_("Warp factor- "))
scanner.chew()
- if key != IHREAL:
+ if key != "IHREAL":
huh()
return
if game.damage[DWARPEN] > 10.0:
return
oldfac = game.warpfac
game.warpfac = scanner.real
- game.wfacsq=game.warpfac*game.warpfac
if game.warpfac <= oldfac or game.warpfac <= 6.0:
prout(_("Helmsman Sulu- \"Warp factor %d, Captain.\"") %
int(game.warpfac))
return
def atover(igrab):
- # cope with being tossed out of quadrant by supernova or yanked by beam
+ "Cope with being tossed out of quadrant by supernova or yanked by beam."
scanner.chew()
# is captain on planet?
if game.landed:
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)
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:
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 + 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
unschedule(FCDBAS)
unschedule(FSCDBAS)
game.battle.invalidate()
-
# Make sure Galileo is consistant -- Snapshot may have been taken
# when on planet, which would give us two Galileos!
gotit = False
for l in range(game.inplan):
if game.state.planets[l].known == "shuttle_down":
gotit = True
- if game.iscraft == "onship" and game.ship==IHE:
+ if game.iscraft == "onship" and game.ship=='E':
prout(_("Chekov- \"Security reports the Galileo has disappeared, Sir!"))
game.iscraft = "offship"
# Likewise, if in the original time the Galileo was abandoned, but
# was on ship earlier, it would have vanished -- let's restore it.
if game.iscraft == "offship" and not gotit and game.damage[DSHUTTL] >= 0.0:
- prout(_("Checkov- \"Security reports the Galileo has reappeared in the dock!\""))
+ prout(_("Chekov- \"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
- game.optime = -0.5*game.intime*math.log(randreal())
+ game.optime = expran(0.5*game.intime)
prout(_("You are traveling forward in time %d stardates.") % int(game.optime))
# cheat to make sure no tractor beams occur during time warp
postpone(FTBEAM, game.optime)
game.damage[DRADIO] += game.optime
- newqad(False)
+ 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:
scanner.chew()
skip(1)
- if game.ship == IHE:
+ if game.ship == 'E':
prout(_("Engineer Scott- \"We have no more deep space probes, Sir.\""))
else:
prout(_("Ye Faerie Queene has no deep space probes."))
prout(_("Uhura- \"The previous probe is still reporting data, Sir.\""))
return
key = scanner.next()
- if key == IHEOL:
- # slow mode, so let Kirk know how many probes there are left
+ if key == "IHEOL":
if game.nprobes == 1:
prout(_("1 probe left."))
else:
if ja() == False:
return
game.isarmed = False
- if key == IHALPHA and scanner.token == "armed":
+ if key == "IHALPHA" and scanner.token == "armed":
game.isarmed = True
key = scanner.next()
- elif key == IHEOL:
+ 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!
scanner.chew()
# Test for conditions which prevent calling for help
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 = (game.base - game.sector).distance()
else:
ddist = xdist
# Since starbase not in quadrant, set up new quadrant
game.quadrant = ibq
- newqad(True)
+ 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]='.'
+ 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]=='.':
# found one -- finish up
game.sector = w
break
if m == 1: proutn(_("1st"))
elif m == 2: proutn(_("2nd"))
elif m == 3: proutn(_("3rd"))
- proutn(_(" attempt to re-materialize "))
- crmshp()
- game.quad[ix][iy]=(IHMATER0,IHMATER1,IHMATER2)[m-1]
- textcolor("red")
+ proutn(_(" attempt to re-materialize ") + crmshp())
+ game.quad[ix][iy]=('-','o','O')[m-1]
warble()
if randreal() > probf:
break
prout(_("fails."))
curses.delay_output(500)
- textcolor(None)
if m > 3:
- game.quad[ix][iy]=IHQUEST
+ game.quad[ix][iy]='?'
game.alive = False
drawmaps(1)
setwnd(message_window)
finish(FMATERIALIZE)
return
game.quad[ix][iy]=game.ship
- textcolor("green")
prout(_("succeeds."))
- 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
+ "Abandon ship."
scanner.chew()
if game.condition=="docked":
- if game.ship!=IHE:
+ if game.ship!='E':
prout(_("You cannot abandon Ye Faerie Queene."))
return
else:
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)
# 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"))
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
# 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] = '.'
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] == '.':
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 = 'F'
game.state.crew = FULLCREW
prout(_("Starfleet puts you in command of another ship,"))
prout(_("the Faerie Queene, which is antiquated but,"))
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)
scanner.chew()
prout(_("No information available."))
def orbit():
- # enter standard orbit
+ "Enter standard orbit."
skip(1)
scanner.chew()
if game.inorbit:
if not game.plnet.is_valid():
prout("There is no planet in this sector.")
return
- if abs(game.sector.x-game.plnet.x)>1 or abs(game.sector.y-game.plnet.y)>1:
- crmshp()
- prout(_(" not adjacent to planet."))
+ 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)
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."))
prout(_(" is located at Sector %s, Captain.\"") % game.plnet)
def beam():
- # use the transporter
+ "Use the transporter."
nrgneed = 0
scanner.chew()
skip(1)
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."))
return
def mine():
- # strip-mine a world for dilithium
+ "Strip-mine a world for dilithium."
skip(1)
scanner.chew()
if not game.landed:
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"))
game.imine = game.ididit = True
def usecrystals():
- # use dilithium crystals
+ "Use dilithium crystals."
game.ididit = False
skip(1)
scanner.chew()
game.ididit = True
def shuttle():
- # use shuttlecraft for planetary jaunt
+ "Use shuttlecraft for planetary jaunt."
scanner.chew()
skip(1)
if damaged(DSHUTTL):
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."))
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)
return
def deathray():
- # use the big zapper
+ "Use the big zapper."
game.ididit = False
skip(1)
scanner.chew()
- if game.ship != IHE:
+ if game.ship != 'E':
prout(_("Ye Faerie Queene has no death ray."))
return
if len(game.enemies)==0:
prouts(_("Sulu- \"Captain! It's working!\""))
skip(2)
while len(game.enemies) > 0:
- deadkl(game.enemies[1].kloc, game.quad[game.enemies[1].kloc.x][game.enemies[1].kloc.y],game.enemies[1].kloc)
+ deadkl(game.enemies[1].location, game.quad[game.enemies[1].location.i][game.enemies[1].location.j],game.enemies[1].location)
prout(_("Ensign Chekov- \"Congratulations, Captain!\""))
if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
finish(FWON)
prout(_(" Mr. Sulu."))
for i in range(QUADSIZE):
for j in range(QUADSIZE):
- if game.quad[i][j] == IHDOT:
- game.quad[i][j] = IHQUEST
+ if game.quad[i][j] == '.':
+ game.quad[i][j] = '?'
prout(_(" Captain, our quadrant is now infested with"))
prouts(_(" - - - - - - *THINGS*."))
skip(1)
# 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)
prout(_("%d casualt%s suffered so far.") % (game.casual, ("y", "ies")[game.casual!=1]))
if game.nhelp:
prout(_("There were %d call%s for help.") % (game.nhelp, ("" , _("s"))[game.nhelp!=1]))
- if game.ship == IHE:
+ if game.ship == 'E':
proutn(_("You have "))
if game.nprobes:
proutn("%d" % (game.nprobes))
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":
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:
prout(" ")
def damagereport():
- # damage report
+ "Damage report."
jdam = False
scanner.chew()
-
for i in range(NDEVICES):
if damaged(i):
if not jdam:
jdam = True
prout(" %-26s\t%8.2f\t\t%8.2f" % (device[i],
game.damage[i]+0.05,
- game.docfac*game.damage[i]+0.005))
+ DOCKFAC*game.damage[i]+0.005))
if not jdam:
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):
game.state.chart[i][j].stars = game.state.galaxy[i][j].stars
def chart():
- # display the star chart
+ "Display the star chart."
scanner.chew()
if (game.options & OPTION_AUTOSCAN):
lrscan(silent=True)
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)))
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(" ")
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(" ")
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):
- 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.quad[i][j] != game.ship:
- highvideo()
+ "Light up an individual dot in a sector."
+ if goodScan or (abs(i-game.sector.i)<= 1 and abs(j-game.sector.j) <= 1):
proutn("%c " % game.quad[i][j])
- 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:
prstat(_("Shields"), s+data)
if not req or req == 9:
prstat(_("Klingons Left"), "%d" \
- % (game.state.remkl + len(game.state.kcmdr) + 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:
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 scanner.next() == IHEOL:
+ while scanner.next() == "IHEOL":
proutn(_("Information desired? "))
scanner.chew()
if scanner.token in requests:
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
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()
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 scanner.next() != IHREAL:
+ if scanner.next() != "IHREAL":
prompt = True
scanner.chew()
proutn(_("Destination quadrant and/or sector? "))
- if scanner.next()!=IHREAL:
+ if scanner.next()!="IHREAL":
huh()
return
- w1.y = int(scanner.real-0.5)
- if scanner.next() != IHREAL:
+ w1.j = int(scanner.real-0.5)
+ if scanner.next() != "IHREAL":
huh()
return
- w1.x = int(scanner.real-0.5)
- if scanner.next() == IHREAL:
- w2.y = int(scanner.real-0.5)
- if scanner.next() != 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(scanner.real-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((w1.y-game.quadrant.y+0.1*(w2.y-game.sector.y))**2+
- (w1.x-game.quadrant.x+0.1*(w2.x-game.sector.x))**2)
+ 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:
scanner.chew()
proutn(_("Time or arrival date? "))
- if scanner.next()==IHREAL:
+ 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."))
scanner.chew()
break
scanner.chew()
proutn(_("Warp factor? "))
- if scanner.next()== IHREAL:
+ if scanner.next()== "IHREAL":
wfl = True
twarp = scanner.real
if twarp<1.0 or twarp > 10.0:
prout(_("Captain, certainly you can give me one of these."))
while True:
scanner.chew()
- ttime = (10.0*game.dist)/twarp**2
- tpower = game.dist*twarp*twarp*twarp*(game.shldup+1)
+ 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 scanner.next() == IHREAL:
+ if scanner.next() == "IHREAL":
wfl = True
twarp = scanner.real
if twarp<1.0 or twarp > 10.0:
(scheduled(FCDBAS)<ttime+game.state.date and game.battle == w1):
prout(_("The starbase there will be destroyed by then."))
proutn(_("New warp factor to try? "))
- if scanner.next() == IHREAL:
+ if scanner.next() == "IHREAL":
wfl = True
twarp = scanner.real
if twarp<1.0 or twarp > 10.0:
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)
# skip(1)
def freeze(boss):
- # save game
+ "Save game."
if boss:
- scanner.token = "emsave.trk"
- else:
+ scanner.push("emsave.trk")
+ key = scanner.next()
+ if key == "IHEOL":
+ proutn(_("File name: "))
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"
+ if key != "IHALPHA":
+ huh()
+ return
+ scanner.chew()
+ if '.' not in scanner.token:
+ scanner.token += ".trk"
try:
fp = open(scanner.token, "wb")
except IOError:
fp.close()
def thaw():
- # retrieve saved game
+ "Retrieve saved game."
game.passwd[0] = '\0'
key = scanner.next()
- if key == IHEOL:
+ if key == "IHEOL":
proutn(_("File name: "))
key = scanner.next()
- if key != IHALPHA:
+ if key != "IHALPHA":
huh()
return True
scanner.chew()
_("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"
)
def setup():
- # prepare to play, set up cosmos
+ "Prepare to play, set up cosmos."
w = coord()
# Decide how many of everything
if choose():
return # frozen game
# Prepare the Enterprise
- game.alldone = game.gamewon = False
- game.ship = IHE
+ game.alldone = game.gamewon = game.shldchg = game.shldup = False
+ game.ship = 'E'
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)
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
game.iscraft = "onship"
game.landed = False
game.alive = True
- game.docfac = 0.25
# Starchart is functional but we've never seen it
game.lastchart = FOREVER
# Put stars in the galaxy
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--)
if not contflag:
break
game.state.baseq.append(w)
- game.state.galaxy[w.x][w.y].starbase = game.state.chart[w.x][w.y].starbase = True
+ 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
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
w = randplace(GALSIZE)
if not welcoming(w) or w in game.state.kcmdr:
continue
- if (game.state.galaxy[w.x][w.y].klingons or withprob(0.25)):
+ 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.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.quadrant = w
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 welcoming(w):
+ 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))))
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:
if game.state.nscrem:
prout(_(" YOU'LL NEED IT."))
waitfor()
- newqad(False)
+ 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(torps_ok=False)
def choose():
- # choose your game type
- global thing
+ "Choose your game type."
while True:
- game.tourn = 0
+ game.tourn = game.length = 0
game.thawed = False
game.skill = SKILL_NONE
- game.length = 0
if not scanner.inqueue: # Can start with command line options
proutn(_("Would you like a regular, tournament, or saved game? "))
scanner.next()
- if len(scanner.token)==0: # Try again
- continue
if scanner.sees("tournament"):
- while scanner.next() == IHEOL:
+ while scanner.next() == "IHEOL":
proutn(_("Type in tournament number-"))
if scanner.real == 0:
scanner.chew()
proutn(_("What is \"%s\"?") % scanner.token)
scanner.chew()
while game.length==0 or game.skill==SKILL_NONE:
- if scanner.next() == IHALPHA:
+ if scanner.next() == "IHALPHA":
if scanner.sees("short"):
game.length = 1
elif scanner.sees("medium"):
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 scanner.next() != IHALPHA:
+ if scanner.next() != "IHALPHA":
scanner.chew()
proutn(_("Choose your game style (or just press enter): "))
scanner.next()
# Approximates Tom Almy's version.
game.options &=~ (OPTION_THINGY | OPTION_BLKHOLE | OPTION_BASE | OPTION_WORLDS)
game.options |= OPTION_ALMY
- elif scanner.sees("fancy"):
+ elif scanner.sees("fancy") or scanner.sees("\n"):
pass
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.inbase = randrange(BASEMIN, BASEMAX+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] == '.':
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
- return enemy(IHK, loc=dropin(), power=randreal(300,450)+25.0*game.skill)
+ "Drop new Klingon into current quadrant."
+ return enemy('K', 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.irhere = 0
- game.iplnet = 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)
+ game.quad = fill2d(QUADSIZE, lambda i, j: '.')
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
# 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 cmdr in game.state.kcmdr:
if cmdr == game.quadrant:
e = game.enemies[game.klhere-1]
- game.quad[e.kloc.x][e.kloc.y] = IHC
- e.kpower = randreal(950,1350) + 50.0*game.skill
+ game.quad[e.location.i][e.location.j] = 'C'
+ e.power = randreal(950,1350) + 50.0*game.skill
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
- e.kpower = randreal(1175.0, 1575.0) + 125.0*game.skill
+ game.quad[e.location.i][e.location.j] = 'S'
+ e.power = randreal(1175.0, 1575.0) + 125.0*game.skill
game.iscate = (game.state.remkl > 1)
# Put in Romulans if needed
- for i in range(game.klhere, len(game.enemies)):
- enemy(IHR, loc=dropin(), power=randreal(400.0,850.0)+50.0*game.skill)
+ for i in range(q.romulans):
+ enemy('R', loc=dropin(), power=randreal(400.0,850.0)+50.0*game.skill)
# If quadrant needs a starbase, put it in
if q.starbase:
- game.base = dropin(IHB)
+ game.base = dropin('B')
# If quadrant needs a planet, put it in
if q.planet:
game.iplnet = q.planet
if not q.planet.inhabited:
- game.plnet = dropin(IHP)
+ game.plnet = dropin('P')
else:
- game.plnet = dropin(IHW)
-
+ game.plnet = dropin('@')
# Check for condition
newcnd()
# Check for RNZ
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(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.\""))
+ # Put in THING if needed
+ if thing == game.quadrant:
+ enemy(type='?', 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 \
(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] == '.':
break
- game.tholian = enemy(type=IHT, loc=w,
+ game.tholian = enemy(type='T', loc=w,
power=randrange(100, 500) + 25.0*game.skill)
# Reserve unoccupied corners
- if game.quad[0][0]==IHDOT:
+ if game.quad[0][0]=='.':
game.quad[0][0] = 'X'
- if game.quad[0][QUADSIZE-1]==IHDOT:
+ if game.quad[0][QUADSIZE-1]=='.':
game.quad[0][QUADSIZE-1] = 'X'
- if game.quad[QUADSIZE-1][0]==IHDOT:
+ if game.quad[QUADSIZE-1][0]=='.':
game.quad[QUADSIZE-1][0] = 'X'
- if game.quad[QUADSIZE-1][QUADSIZE-1]==IHDOT:
+ if game.quad[QUADSIZE-1][QUADSIZE-1]=='.':
game.quad[QUADSIZE-1][QUADSIZE-1] = 'X'
game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
# And finally the stars
for i in range(q.stars):
- dropin(IHSTAR)
+ dropin('*')
# Put in a few black holes
for i in range(1, 3+1):
if withprob(0.5):
- dropin(IHBLANK)
+ dropin(' ')
# Take out X's in corners if Tholian present
if game.tholian:
if game.quad[0][0]=='X':
- game.quad[0][0] = IHDOT
+ game.quad[0][0] = '.'
if game.quad[0][QUADSIZE-1]=='X':
- game.quad[0][QUADSIZE-1] = IHDOT
+ game.quad[0][QUADSIZE-1] = '.'
if game.quad[QUADSIZE-1][0]=='X':
- game.quad[QUADSIZE-1][0] = IHDOT
+ game.quad[QUADSIZE-1][0] = '.'
if game.quad[QUADSIZE-1][QUADSIZE-1]=='X':
- game.quad[QUADSIZE-1][QUADSIZE-1] = IHDOT
+ game.quad[QUADSIZE-1][QUADSIZE-1] = '.'
def setpassword():
- # set the self-destruct password
+ "Set the self-destruct password."
if game.options & OPTION_PLAIN:
while True:
scanner.chew()
"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
+ "Browse on-line help."
key = scanner.next()
while True:
- if key == IHEOL:
+ if key == "IHEOL":
setwnd(prompt_window)
proutn(_("Help on what command? "))
key = scanner.next()
setwnd(message_window)
- if key == IHEOL:
+ if key == "IHEOL":
return
if scanner.token in commands or scanner.token == "ABBREV":
break
skip(1)
listCommands()
- key = IHEOL
+ key = "IHEOL"
scanner.chew()
skip(1)
cmd = scanner.token.upper()
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()
fp.close()
def makemoves():
- # command-interpretation loop
- v = 0
+ "Command-interpretation loop."
clrscr()
setwnd(message_window)
while True: # command loop
drawmaps(1)
while True: # get a command
hitme = False
- game.justin = False
- game.optime = 0.0
+ game.optime = game.justin = False
scanner.chew()
setwnd(prompt_window)
clrscr()
proutn("COMMAND> ")
- if scanner.next() == IHEOL:
+ if scanner.next() == "IHEOL":
if game.options & OPTION_CURSES:
makechart()
continue
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:
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(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
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 == 'R': s = _("Romulan")
+ elif type == 'K': s = _("Klingon")
+ elif type == 'C': s = _("Commander")
+ elif type == 'S': s = _("Super-commander")
+ elif type == '*': s = _("Star")
+ elif type == 'P': s = _("Planet")
+ elif type == 'B': s = _("Starbase")
+ elif type == ' ': s = _("Black hole")
+ elif type == 'T': s = _("Tholian")
+ elif type == '#': s = _("Tholian web")
+ elif type == '?': s = _("Stranger")
+ elif type == '@': 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{'E':_("Enterprise"),'F':_("Faerie Queene")}.get(game.ship,"Ship???")
def stars():
- # print a line of stars
+ "Emit a line of stars"
prouts("******************************************************")
skip(1)
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
class sstscanner:
clrscr()
if line == '':
return None
- # Skip leading white space
- line = line.lstrip()
if not line:
continue
else:
- self.inqueue = line.lstrip().split() + [IHEOL]
+ 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 == IHEOL:
- self.type = IHEOL
- return IHEOL
+ if self.token == "\n":
+ self.type = "IHEOL"
+ return "IHEOL"
try:
self.real = float(self.token)
- self.type = IHREAL
- return IHREAL
+ self.type = "IHREAL"
+ return "IHREAL"
except ValueError:
pass
# Treat as alpha
self.token = self.token.lower()
- self.type = IHALPHA
+ self.type = "IHALPHA"
self.real = None
- return IHALPHA
- def push(self, toklist):
- self.inqueue += toklist
+ 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 = None
- self.real = self.token = None
- def chew2(self):
- # return IHEOL next time
self.inqueue = []
self.real = self.token = None
def sees(self, s):
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 "<sstcanner: token=%s, type=%s, queue=%s>" % (scanner.token, scanner.type, scanner.inqueue)
def ja():
- # yes-or-no confirmation
+ "Yes-or-no confirmation."
scanner.chew()
while True:
scanner.next()
- scanner.chew()
if scanner.token == 'y':
return True
if scanner.token == 'n':
return False
+ scanner.chew()
proutn(_("Please answer with \"y\" or \"n\": "))
def huh():
- # complain about unparseable input
+ "Complain about unparseable input."
scanner.chew()
skip(1)
prout(_("Beg your pardon, Captain?"))
-
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:
proutn("Cause selective damage? ")
if ja() == True:
for i in range(NDEVICES):
- proutn("Kill ")
- proutn(device[i])
- proutn("? ")
+ proutn("Kill %s?" % device[i])
scanner.chew()
key = scanner.next()
- if key == IHALPHA and scanner.sees("y"):
+ if key == "IHALPHA" and scanner.sees("y"):
game.damage[i] = 10.0
proutn("Examine/change events? ")
if ja() == True:
if key == 'n':
unschedule(i)
scanner.chew()
- elif key == IHREAL:
+ elif key == "IHREAL":
ev = schedule(i, scanner.real)
if i == FENSLV or i == FREPRO:
scanner.chew()
proutn("In quadrant- ")
key = scanner.next()
- # IHEOL says to leave coordinates as they are
- if key != IHEOL:
- if key != IHREAL:
+ # "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(scanner.real))
+ w.i = int(round(scanner.real))
key = scanner.next()
- if key != IHREAL:
+ if key != "IHREAL":
prout("Event %d canceled, no y coordinate." % (i))
unschedule(i)
continue
- w.y = int(round(scanner.real))
+ w.j = int(round(scanner.real))
ev.quadrant = w
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 = None
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:
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
if logfp:
logfp.write("# seed %s\n" % seed)
logfp.write("# options %s\n" % " ".join(arguments))
+ logfp.write("# recorded by %s@%s on %s\n" % \
+ (getpass.getuser(),socket.gethostname(),time.ctime()))
random.seed(seed)
scanner = sstscanner()
- scanner.push(arguments)
+ map(scanner.append, arguments)
try:
iostart()
while True: # Play a game
if game.tourn and game.alldone:
proutn(_("Do you want your score recorded?"))
if ja() == True:
- scanner.chew2()
+ scanner.chew()
+ scanner.push("\n")
freeze(False)
scanner.chew()
proutn(_("Do you want to play again? "))
ioend()
raise SystemExit, 0
except KeyboardInterrupt:
- print""
- pass
+ if logfp:
+ logfp.close()
+ print ""