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, readline, cPickle, random, 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
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',
IHMATER1 = 'o',
IHMATER2 = '0'
+class TrekError:
+ pass
+
class coord:
def __init__(self, x=None, y=None):
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.i = self.j = None
def is_valid(self):
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.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.probe = None # location of probe
- self.probein = None # probe i,j increment
+ 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):
def welcoming(iq):
"Would this quadrant welcome another Klingon?"
- return VALID_QUADRANT(iq.i,iq.j) and \
+ return iq.valid_quadrant() and \
not game.state.galaxy[iq.i][iq.j].supernova and \
game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD
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:
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))
+ bumpto = coord(0, 0)
# Loop to move a single torpedo
+ setwnd(message_window)
for step in range(1, QUADSIZE*2):
- ungridded += delta
- w = ungridded.snaptogrid()
- if not VALID_SECTOR(w.i, w.j):
+ track.next()
+ w = track.sector()
+ if not w.valid_sector():
break
iquad=game.quad[w.i][w.j]
tracktorpedo(origin, w, step, number, nburst, iquad)
if iquad==IHDOT:
continue
# hit something
- setwnd(message_window)
if damaged(DSRSENS) and not game.condition=="docked":
skip(1); # start new line after text track
if iquad in (IHE, IHF): # Hit our ship
skip(1)
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)
+ 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))
xx = -math.sin(ang)/temp
yy = math.cos(ang)/temp
- jw.i = int(w.i+xx+0.5)
- jw.j = int(w.j+yy+0.5)
- if not VALID_SECTOR(jw.i, jw.j):
+ bumpto.i = int(w.i+xx+0.5)
+ bumpto.j = int(w.j+yy+0.5)
+ if not bumpto.valid_sector():
return hit
- if game.quad[jw.i][jw.j]==IHBLANK:
+ if game.quad[bumpto.i][bumpto.j]==IHBLANK:
finish(FHOLE)
return hit
- if game.quad[jw.i][jw.j]!=IHDOT:
+ if game.quad[bumpto.i][bumpto.j]!=IHDOT:
# can't move into object
return hit
- game.sector = jw
+ game.sector = bumpto
proutn(crmshp())
- shoved = True
+ game.quad[w.i][w.j]=IHDOT
+ game.quad[bumpto.i][bumpto.j]=iquad
+ prout(_(" displaced by blast to Sector %s ") % bumpto)
+ for enemy in game.enemies:
+ enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
+ game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ return None
elif iquad in (IHC, IHS, IHR, IHK): # Hit a regular enemy
# find the enemy
if iquad in (IHC, IHS) and withprob(0.05):
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))
xx = -math.sin(ang)/temp
yy = math.cos(ang)/temp
- jw.i = int(w.i+xx+0.5)
- jw.j = int(w.j+yy+0.5)
- if not VALID_SECTOR(jw.i, jw.j):
+ bumpto.i = int(w.i+xx+0.5)
+ bumpto.j = int(w.j+yy+0.5)
+ if not bumpto.valid_sector():
prout(_(" damaged but not destroyed."))
return
- if game.quad[jw.i][jw.j]==IHBLANK:
+ if game.quad[bumpto.i][bumpto.j] == IHBLANK:
prout(_(" buffeted into black hole."))
- deadkl(w, iquad, jw)
+ deadkl(w, iquad, bumpto)
return None
- if game.quad[jw.i][jw.j]!=IHDOT:
+ if game.quad[bumpto.i][bumpto.j] != IHDOT:
# can't move into object
prout(_(" damaged but not destroyed."))
return None
proutn(_(" damaged--"))
- enemy.kloc = jw
- shoved = True
+ enemy.kloc = bumpto
+ game.quad[w.i][w.j]=IHDOT
+ game.quad[bumpto.i][bumpto.j]=iquad
+ prout(_(" displaced by blast to Sector %s ") % bumpto)
+ for enemy in game.enemies:
+ enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
+ game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ return None
break
elif iquad == IHB: # Hit a base
skip(1)
skip(1)
return None
break
- if curwnd!=message_window:
- setwnd(message_window)
- if shoved:
- game.quad[w.i][w.j]=IHDOT
- game.quad[jw.i][jw.j]=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;
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:
def targetcheck(w):
"Return None if target is invalid, otherwise return a course angle."
- if not VALID_SECTOR(w.i, w.j):
+ if not w.valid_sector():
huh()
return None
delta = coord()
supercommander()
elif evcode == FDSPROB: # Move deep space probe
schedule(FDSPROB, 0.01)
- game.probe += game.probein
- i = int(round(game.probe.i/float(QUADSIZE)))
- j = int(round(game.probe.j/float(QUADSIZE)))
- 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 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 communicating():
announce()
skip(1)
proutn(_("Lt. Uhura- \"The deep space probe "))
- if not VALID_QUADRANT(i, j):
- 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.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:
- supernova(game.probec) # fire in the hole!
+ 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)
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.i - 1, w.i + 2):
- for j in range(w.j - 1, w.j + 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.i][w.j]
+ 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.i = i; w.j = 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"))
if offset.j==0 and offset.i==0:
continue
neighbor = start + offset
- if not VALID_SECTOR(neighbor.j, neighbor.i):
+ if not neighbor.valid_sector():
continue
iquad = game.quad[neighbor.i][neighbor.j]
# Empty space ends reaction
break
newc = neighbor + neighbor - hits[mm]
proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
- if not VALID_SECTOR(newc.i, newc.j):
+ if not newc.valid_sector():
# can't leave quadrant
skip(1)
break
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:
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()
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
y += deltay
w.i = int(round(x))
w.j = int(round(y))
- if not VALID_SECTOR(w.i, w.j):
+ if not w.valid_sector():
# Leaving quadrant -- allow final enemy attack
# Don't do it if being pushed by Nova
if len(game.enemies) != 0 and not novapush:
# 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 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
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:
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
dsect.i = xi
dsect.j = xj
itemp = "normal"
- if not VALID_QUADRANT(dquad.i,dquad.j) or not VALID_SECTOR(dsect.i,dsect.j):
+ 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.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):
+ 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):
- 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):
ix = x + 0.5
y += deltay
iy = y +0.5
- if not VALID_SECTOR(ix, iy):
+ if not coord(ix, iy).valid_sector():
break
if game.quad[ix][iy] != IHDOT:
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:
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
game.isarmed = ja()
elif key == "IHREAL": # first element of course
scanner.push(scanner.token)
- if not getcourse(isprobe=True):
- return
+ try:
+ game.probe = getcourse(isprobe=True)
+ except TrekError:
+ return
game.nprobes -= 1
- angle = ((15.0 - game.direc) * 0.5235988)
- game.probein = coord(-math.sin(angle), math.cos(angle))
- bigger = max(abs(game.probein.i), abs(game.probein.j))
- game.probein /= bigger
- game.proben = 10.0*game.dist*bigger +0.5
- game.probe = coord(game.quadrant.i*QUADSIZE + game.sector.i,
- game.quadrant.j*QUADSIZE + game.sector.j)
- game.probec = copy.copy(game.quadrant)
schedule(FDSPROB, 0.01) # Time to move one sector
prout(_("Ensign Chekov- \"The deep space probe is launched, Captain.\""))
game.ididit = True
game.sector.invalidate()
for m in range(1, 5+1):
w = game.base.scatter()
- if VALID_SECTOR(w.i,w.j) and game.quad[w.i][w.j]==IHDOT:
+ if w.valid_sector() and game.quad[w.i][w.j]==IHDOT:
# found one -- finish up
game.sector = w
break
game.quad[game.sector.i][game.sector.j] = IHDOT
for l in range(QUADSIZE):
game.sector = game.base.scatter()
- if VALID_SECTOR(game.sector.i, game.sector.j) and \
+ if game.sector.valid_sector() and \
game.quad[game.sector.i][game.sector.j] == IHDOT:
break
if l < QUADSIZE+1:
if not silent:
proutn(" ")
for y in range(game.quadrant.j-1, game.quadrant.j+2):
- if not VALID_QUADRANT(x, y):
+ if not coord(x, y).valid_quadrant():
if not silent:
proutn(" -1")
else:
"Damage report."
jdam = False
scanner.chew()
-
for i in range(NDEVICES):
if damaged(i):
if not jdam:
w2.j = 0
else:
w2.j=QUADSIZE-1
- if not VALID_QUADRANT(w1.i, w1.j) or not VALID_SECTOR(w2.i, w2.j):
+ if not w1.valid_quadrant() or not w2.valid_sector():
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)
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