"""
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.)
+This code is a Python translation of a C translation of a FORTRAN
+original dating back to 1973. Beautiful Python it is not. But it
+works.
Dave Matuszek says:
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.)
+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
the LRSCAN command is no longer needed. (Controlled by OPTION_AUTOSCAN
and turned off if game type is "plain" or "almy".)
"""
-import os,sys,math,curses,time,atexit,readline,cPickle,random,getopt,copy
+import os, sys, math, curses, time, readline, cPickle, random, copy, gettext
SSTDOC = "/usr/share/doc/sst/sst.doc"
DOC_NAME = "sst.doc"
-# Stub to be replaced
-def _(str): return str
+def _(str): return gettext.gettext(str)
PHASEFAC = 2.0
GALSIZE = 8
IHMATER1 = 'o',
IHMATER2 = '0'
+class TrekError:
+ pass
+
class coord:
def __init__(self, x=None, y=None):
self.i = x
return self.i != None and self.j != None
def __eq__(self, other):
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.i+other.i, self.j+other.j)
def __sub__(self, other):
return coord(self.i/other, self.j/other)
def __rdiv__(self, other):
return coord(self.i/other, self.j/other)
- def snaptogrid(self):
+ def roundtogrid(self):
+ return coord(int(round(self.i)), int(round(self.j)))
+ def trunctogrid(self):
return coord(int(round(self.i)), int(round(self.j)))
def distance(self, other=None):
if not other: other = coord(0, 0)
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:
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.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'
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:]))
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."
"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.i][game.state.kscmdr.j].klingons -= 1
game.state.kscmdr = iq
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."
if not game.iscate and avoid:
# compute move away from Enterprise
idelta = game.state.kscmdr-game.quadrant
- if math.sqrt(idelta.i*idelta.i+idelta.j*idelta.j) > 2.0:
+ if idelta.distance() > 2.0:
# circulate in space
idelta.i = game.state.kscmdr.j-game.quadrant.j
idelta.j = game.quadrant.i-game.state.kscmdr.i
# 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.i==0 or idelta.j==0:
# attempt angle move
if idelta.i != 0:
iq.j = game.state.kscmdr.j + 1
- if movescom(iq, avoid):
+ if not movescom(iq, avoid):
iq.j = game.state.kscmdr.j - 1
movescom(iq, avoid)
- else:
+ elif idelta.j != 0:
iq.i = game.state.kscmdr.i + 1
- if movescom(iq, avoid):
+ if not movescom(iq, avoid):
iq.i = game.state.kscmdr.i - 1
movescom(iq, avoid)
else:
# try moving just in x or y
iq.j = game.state.kscmdr.j
- if movescom(iq, avoid):
+ if not movescom(iq, avoid):
iq.j = game.state.kscmdr.j + idelta.j
iq.i = game.state.kscmdr.i
movescom(iq, avoid)
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:
for i in range(QUADSIZE):
if game.quad[0][i]!=IHWEB and game.quad[0][i]!=IHT:
return
- if game.quad[QUADSIZE][i]!=IHWEB and game.quad[QUADSIZE][i]!=IHT:
+ if game.quad[QUADSIZE-1][i]!=IHWEB and game.quad[QUADSIZE-1][i]!=IHT:
return
if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT:
return
- if game.quad[i][QUADSIZE]!=IHWEB and game.quad[i][QUADSIZE]!=IHT:
+ if game.quad[i][QUADSIZE-1]!=IHWEB and game.quad[i][QUADSIZE-1]!=IHT:
return
# All plugged up -- Tholian splits
game.quad[game.tholian.kloc.i][game.tholian.kloc.j]=IHWEB
finish(FWON)
return
-def torpedo(origin, course, dispersion, number, nburst):
+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)
shoved = False
- ac = course + 0.25*dispersion
- angle = (15.0-ac)*0.5235988
- bullseye = (15.0 - course)*0.5235988
- delta = coord(-math.sin(angle), math.cos(angle))
- bigger = max(abs(delta.i), abs(delta.j))
- delta /= bigger
- w = coord(0, 0); jw = coord(0, 0)
- ungridded = copy.copy(origin)
+ 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))
+ jw = coord(0, 0)
# Loop to move a single torpedo
for step in range(1, QUADSIZE*2):
- ungridded += delta
- w = ungridded.snaptogrid()
+ track.next()
+ w = track.sector()
if not VALID_SECTOR(w.i, w.j):
break
iquad=game.quad[w.i][w.j]
# 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)
+ ang = track.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))
break
kp = math.fabs(enemy.kpower)
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
return None
proutn(crmena(True, iquad, "sector", w))
# If enemy damaged but not destroyed, try to displace
- ang = angle + 2.5*(randreal()-0.5)
+ ang = track.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))
proutn(crmena(True, type, "sector", mv))
# Decide what kind of enemy it is and update appropriately
if type == IHR:
- # chalk up a Romulan
+ # Chalk up a Romulan
game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans -= 1
game.irhere -= 1
game.state.nromrem -= 1
global thing
thing = None
else:
- # Some type of a Klingon
+ # Killed some type of Klingon
game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
game.klhere -= 1
if type == IHC:
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.i != i or game.probec.j != j:
- game.probec.i = i
- game.probec.j = j
- if not VALID_QUADRANT(i, j) or \
- game.state.galaxy[game.probec.i][game.probec.j].supernova:
+ if game.probe.next(grain=QUADSIZE):
+ if not VALID_QUADRANT(game.probe.quadrant().i, game.probe.quadrant().j) 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 VALID_QUADRANT(game.probe.quadrant().i, game.probe.quadrant().j):
+ 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.i][game.probec.j]
- # 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.i][game.probec.j]
+ 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(game.probec)
+ game.probe.moves -= 1 # One less to travel
+ if game.probe.moves == 0 and game.isarmed and pdest.stars:
+ supernova(game.probe) # fire in the hole!
unschedule(FDSPROB)
- if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
+ if game.state.galaxy[game.quadrant().i][game.quadrant().j].supernova:
return
elif evcode == FDISTR: # inhabited system issues distress call
unschedule(FDISTR)
game.resting = False
game.optime = 0
-# A nova occurs. It is the result of having a star hit with a
-# photon torpedo, or possibly of a probe warhead going off.
-# Stars that go nova cause stars which surround them to undergo
-# the same probabilistic process. Klingons next to them are
-# destroyed. And if the starship is next to it, it gets zapped.
-# If the zap is too much, it gets destroyed.
-
def nova(nov):
"Star goes nova."
course = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
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.i+1)+bump.j+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, novapush=True)
+ game.optime = course.time(warp=4)
return
def supernova(w):
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)
def iostart():
global stdscr, rows
+ gettext.bindtextdomain("sst", "/usr/local/share/locale")
+ gettext.textdomain("sst")
if not (game.options & OPTION_CURSES):
ln_env = os.getenv("LINES")
if ln_env:
setwnd(fullscreen_window)
def ioend():
- "Wrap up I/O. Presently a stub."
- stdscr.keypad(False)
- curses.echo()
- curses.nocbreak()
- curses.endwin()
+ "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"
def announce():
skip(1)
- prouts(_("[ANOUNCEMENT ARRIVING...]"))
+ 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()
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."
# Code from moving.c begins here
-def imove(novapush):
+def imove(course=None, novapush=False):
"Movement execution for warp, impulse, supernova, and tractor-beam events."
w = coord(); final = coord()
trbeam = False
if game.inorbit:
prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
game.inorbit = False
- angle = ((15.0 - game.direc) * 0.5235988)
+ angle = ((15.0 - course.bearing) * 0.5235988)
deltax = -math.sin(angle)
deltay = math.cos(angle)
if math.fabs(deltax) > math.fabs(deltay):
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.i][game.sector.j] = IHDOT
x = game.sector.i
y = game.sector.j
- n = int(10.0*game.dist*bigger+0.5)
+ n = int(10.0*course.distance*bigger+0.5)
if n > 0:
for m in range(1, n+1):
x += deltax
# compute final position -- new quadrant and sector
x = (QUADSIZE*game.quadrant.i)+game.sector.i
y = (QUADSIZE*game.quadrant.j)+game.sector.j
- w.i = int(round(x+10.0*game.dist*bigger*deltax))
- w.j = int(round(y+10.0*game.dist*bigger*deltay))
+ w.i = int(round(x+QUADSIZE*course.distance*bigger*deltax))
+ w.j = int(round(y+QUADSIZE*course.distance*bigger*deltay))
# check for edge of galaxy
kinks = 0
while True:
iquad = game.quad[w.i][w.j]
if iquad != IHDOT:
# object encountered in flight path
- stopegy = 50.0*game.dist/game.optime
- game.dist = (game.sector - w).distance() / (QUADSIZE * 1.0)
+ stopegy = 50.0*course.dist/game.optime
+ course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST):
game.sector = w
for enemy in game.enemies:
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:
# We're here!
no_quad_change()
return
- game.dist = (game.sector - w).distance() / (QUADSIZE * 1.0)
+ course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
game.sector = w
final = game.sector
no_quad_change()
# because it involves giving x and y motions, yet the coordinates
# are always displayed y - x, where +y is downward!
-def getcourse(isprobe, akey):
+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)
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:
navmode = "manual"
key = "IHEOL"
break
- if isprobe and akey != -1:
- # For probe launch, use pre-scanned value first time
- key = akey
- akey = -1
- else:
- key = scanner.next()
+ key = scanner.next()
if key == "IHEOL":
proutn(_("Manual or automatic- "))
iprompt = True
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":
if isprobe:
key = scanner.next()
if key != "IHREAL":
huh()
- return False
+ raise TrekError
xi = int(round(scanner.real))-1
key = scanner.next()
if key != "IHREAL":
huh()
- return False
+ raise TrekError
xj = int(round(scanner.real))-1
key = scanner.next()
if key == "IHREAL":
key = scanner.next()
if key != "IHREAL":
huh()
- return False
+ raise TrekError
xl = int(round(scanner.real))-1
dquad.i = xi
dquad.j = xj
itemp = "normal"
if not VALID_QUADRANT(dquad.i,dquad.j) or not VALID_SECTOR(dsect.i,dsect.j):
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.j = dquad.j-game.quadrant.j + 0.1*(dsect.j-game.sector.j)
- delta.i = game.quadrant.i-dquad.i + 0.1*(game.sector.i-dsect.i)
+ 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":
proutn(_("X and Y displacements- "))
itemp = "verbose"
if key != "IHREAL":
huh()
- return False
+ raise TrekError
delta.j = scanner.real
key = scanner.next()
if key != "IHREAL":
huh()
- return False
+ raise TrekError
delta.i = scanner.real
# Check for zero movement
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
+ # 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.location = cartesian(game.quadrant, game.sector)
+ else:
+ self.location = 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 = 10*self.distance*bigger +0.5
+ def next(self, grain=1):
+ "Next step on course."
+ self.moves -=1
+ self.nextlocation = self.location + self.increment
+ oldloc = (self.location/grain).roundtogrid()
+ newloc = (self.nextlocation/grain).roundtogrid()
+ self.location = self.nextlocation
+ if newloc != oldloc:
+ return True
+ else:
+ return False
+ def quadrant(self):
+ return (self.location / QUADSIZE).roundtogrid()
+ def sector(self):
+ return coord(int(round(self.location.i)) % QUADSIZE, int(round(self.location.j)) % QUADSIZE)
+ 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."
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, novapush=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):
+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.warpfac**2
+ 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.dist*(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.dist*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)
+ angle = ((15.0-course.bearing)*0.5235998)
deltax = -math.sin(angle)
deltay = math.cos(angle)
if math.fabs(deltax) > math.fabs(deltay):
bigger = math.fabs(deltay)
deltax /= bigger
deltay /= bigger
- n = 10.0 * game.dist * bigger +0.5
+ n = 10.0 * course.distance * bigger +0.5
x = game.sector.i
y = game.sector.j
for l in range(1, n+1):
blooey = False
twarp = False
# Activate Warp Engines and pay the cost
- imove(novapush=False)
+ imove(course, novapush=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.warpfac**2
+ game.optime = course.time(game.warpfac)
if twarp:
timwrp()
if blooey:
proutn(_("The %s has stopped in a quadrant containing") % crmshp())
prouts(_(" a supernova."))
skip(2)
- prout(_("***Emergency automatic override attempts to hurl ")+crmshp())
- skip(1)
+ proutn(_("***Emergency automatic override attempts to hurl ")+crmshp())
prout(_("safely out of quadrant."))
if not damaged(DRADIO):
game.state.galaxy[game.quadrant.i][game.quadrant.j].charted = True
game.warpfac = randreal(6.0, 8.0)
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))
+ 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.warpfac**2
- game.direc = randreal(12) # How dumb!
+ dist = distreq
+ course = course(bearing=randreal(12), distance=dist) # How dumb!
+ game.optime = course.time()
game.justin = False
game.inorbit = False
- warp(True)
+ warp(course, involuntary=True)
if not game.justin:
# This is bad news, we didn't leave quadrant.
if game.alldone:
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
return
key = scanner.next()
if key == "IHEOL":
- # slow mode, so let Kirk know how many probes there are left
if game.nprobes == 1:
prout(_("1 probe left."))
else:
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.i*QUADSIZE + game.sector.i - 1 # We will use better packing than original
- game.probey = game.quadrant.j*QUADSIZE + game.sector.j - 1
- game.probec = game.quadrant
schedule(FDSPROB, 0.01) # Time to move one sector
prout(_("Ensign Chekov- \"The deep space probe is launched, Captain.\""))
game.ididit = True
return
-# Here's how the mayday code works:
-#
-# First, the closest starbase is selected. If there is a a starbase
-# in your own quadrant, you are in good shape. This distance takes
-# quadrant distances into account only.
-#
-# A magic number is computed based on the distance which acts as the
-# probability that you will be rematerialized. You get three tries.
-#
-# When it is determined that you should be able to be rematerialized
-# (i.e., when the probability thing mentioned above comes up
-# positive), you are put into that quadrant (anywhere). Then, we try
-# to see if there is a spot adjacent to the star- base. If not, you
-# can't be rematerialized!!! Otherwise, it drops you there. It only
-# tries five times to find a spot to drop you. After that, it's your
-# problem.
-
def mayday():
"Yell for help from nearest starbase."
# There's more than one way to move in this game!
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."
scanner.chew()
"Damage report."
jdam = False
scanner.chew()
-
for i in range(NDEVICES):
if damaged(i):
if not jdam:
if not VALID_QUADRANT(w1.i, w1.j) or not VALID_SECTOR(w2.i, w2.j):
huh()
return
- game.dist = math.sqrt((w1.j-game.quadrant.j+0.1*(w2.j-game.sector.j))**2+
- (w1.i-game.quadrant.i+0.1*(w2.i-game.sector.i))**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:"))
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()
while True:
scanner.chew()
ttime = (10.0*game.dist)/twarp**2
- tpower = game.dist*twarp*twarp*twarp*(game.shldup+1)
+ 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:
def freeze(boss):
"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:
_("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"
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":
proutn(_("Type in tournament number-"))
# 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)
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()
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:
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":
+ if self.token == "\n":
self.type = "IHEOL"
return "IHEOL"
try:
# Demand input for next scan
self.inqueue = []
self.real = self.token = None
- def chew2(self):
- # return "IHEOL" next time
- self.inqueue = ["IHEOL"]
- self.real = self.token = None
def sees(self, s):
# compares s to item and returns true if it matches to the length of s
return s.startswith(self.token)
atover(True)
if __name__ == '__main__':
+ import getopt, socket
try:
global line, thing, game, idebug
game = None
if logfp:
logfp.write("# seed %s\n" % seed)
logfp.write("# options %s\n" % " ".join(arguments))
+ logfp.write("# recorded by %s@%s on %s\n" % \
+ (os.getenv("LOGNAME"),socket.gethostname(),time.ctime()))
random.seed(seed)
scanner = sstscanner()
map(scanner.append, arguments)
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? "))
if logfp:
logfp.close()
print ""
- pass