"""
import os, sys, math, curses, time, readline, cPickle, random, copy, gettext, getpass
-version="2.0"
+version = "2.1"
docpath = (".", "../doc", "/usr/share/doc/sst")
-def _(str): return gettext.gettext(str)
+def _(st):
+ return gettext.gettext(st)
GALSIZE = 8 # Galaxy size in quadrants
NINHAB = (GALSIZE * GALSIZE / 2) # Number of inhabited worlds
pass
class JumpOut(Exception):
- pass
+ pass
-class coord:
+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
+ 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
+ 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):
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)
+ return Coord(self.i+other.i, self.j+other.j)
def __sub__(self, other):
- return coord(self.i-other.i, self.j-other.j)
+ return Coord(self.i-other.i, self.j-other.j)
def __mul__(self, other):
- return coord(self.i*other, self.j*other)
+ return Coord(self.i*other, self.j*other)
def __rmul__(self, other):
- return coord(self.i*other, self.j*other)
+ return Coord(self.i*other, self.j*other)
def __div__(self, other):
- return coord(self.i/other, self.j/other)
+ return Coord(self.i/other, self.j/other)
def __mod__(self, other):
- return coord(self.i % other, self.j % other)
+ return Coord(self.i % other, self.j % other)
def __rdiv__(self, other):
- return coord(self.i/other, self.j/other)
+ return Coord(self.i/other, self.j/other)
def roundtogrid(self):
- return coord(int(round(self.i)), int(round(self.j)))
+ return Coord(int(round(self.i)), int(round(self.j)))
def distance(self, other=None):
- if not other: other = coord(0, 0)
+ if not other:
+ other = Coord(0, 0)
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()
+ s = Coord()
if self.i == 0:
s.i = 0
else:
def sector(self):
return self.roundtogrid() % QUADSIZE
def scatter(self):
- s = coord()
+ s = Coord()
s.i = self.i + randrange(-1, 2)
s.j = self.j + randrange(-1, 2)
return s
return "%s - %s" % (self.i+1, self.j+1)
__repr__ = __str__
-class planet:
+class Thingy(Coord):
+ "Do not anger the Space Thingy!"
+ def __init__(self):
+ Coord.__init__(self)
+ self.angered = False
+ def angry(self):
+ self.angered = True
+
+class Planet:
def __init__(self):
self.name = None # string-valued if inhabited
- self.quadrant = coord() # quadrant located
+ self.quadrant = Coord() # quadrant located
self.pclass = None # could be ""M", "N", "O", or "destroyed"
self.crystals = "absent"# could be "mined", "present", "absent"
self.known = "unknown" # could be "unknown", "known", "shuttle_down"
def __str__(self):
return self.name
-class quadrant:
+class Quadrant:
def __init__(self):
self.stars = 0
self.planet = None
self.charted = False
self.status = "secure" # Could be "secure", "distressed", "enslaved"
-class page:
+class Page:
def __init__(self):
self.stars = None
self.starbase = None
lst[i].append(fillfun(i, j))
return lst
-class snapshot:
+class Snapshot:
def __init__(self):
self.snap = False # snapshot taken
self.crew = 0 # crew complement
self.remtime = 0 # remaining time
self.baseq = [] # Base quadrant coordinates
self.kcmdr = [] # Commander quadrant coordinates
- self.kscmdr = coord() # Supercommander quadrant coordinates
+ self.kscmdr = Coord() # Supercommander quadrant coordinates
# the galaxy
- self.galaxy = fill2d(GALSIZE, lambda i_unused, j_unused: quadrant())
+ self.galaxy = fill2d(GALSIZE, lambda i_unused, j_unused: Quadrant())
# the starchart
- self.chart = fill2d(GALSIZE, lambda i_unused, j_unused: page())
+ self.chart = fill2d(GALSIZE, lambda i_unused, j_unused: Page())
-class event:
+class Event:
def __init__(self):
self.date = None # A real number
self.quadrant = None # A coord structure
OPTION_COLOR = 0x04000000 # enable color display (experimental, ESR, 2010)
# Define devices
-DSRSENS = 0
-DLRSENS = 1
-DPHASER = 2
-DPHOTON = 3
-DLIFSUP = 4
-DWARPEN = 5
-DIMPULS = 6
-DSHIELD = 7
-DRADIO = 0
-DSHUTTL = 9
-DCOMPTR = 10
-DNAVSYS = 11
-DTRANSP = 12
-DSHCTRL = 13
-DDRAY = 14
-DDSP = 15
-NDEVICES= 16 # Number of devices
+DSRSENS = 0
+DLRSENS = 1
+DPHASER = 2
+DPHOTON = 3
+DLIFSUP = 4
+DWARPEN = 5
+DIMPULS = 6
+DSHIELD = 7
+DRADIO = 0
+DSHUTTL = 9
+DCOMPTR = 10
+DNAVSYS = 11
+DTRANSP = 12
+DSHCTRL = 13
+DDRAY = 14
+DDSP = 15
+NDEVICES = 16 # Number of devices
SKILL_NONE = 0
SKILL_NOVICE = 1
SKILL_EXPERT = 4
SKILL_EMERITUS = 5
-def damaged(dev): return (game.damage[dev] != 0.0)
-def communicating(): return not damaged(DRADIO) or game.condition=="docked"
+def damaged(dev):
+ return (game.damage[dev] != 0.0)
+def communicating():
+ return not damaged(DRADIO) or game.condition=="docked"
# Define future events
FSPY = 0 # Spy event happens always (no future[] entry)
# Abstract out the event handling -- underlying data structures will change
# when we implement stateful events
-def findevent(evtype): return game.future[evtype]
+def findevent(evtype):
+ return game.future[evtype]
-class enemy:
- def __init__(self, type=None, loc=None, power=None):
- self.type = type
- self.location = coord()
+class Enemy:
+ def __init__(self, etype=None, loc=None, power=None):
+ self.type = etype
+ self.location = Coord()
if loc:
self.move(loc)
self.power = power # enemy energy level
game.quad[self.location.i][self.location.j] = self.type
self.kdist = self.kavgd = (game.sector - loc).distance()
else:
- self.location = coord()
+ self.location = Coord()
self.kdist = self.kavgd = None
game.enemies.remove(self)
return motion
def __repr__(self):
return "<%s,%s.%f>" % (self.type, self.location, self.power) # For debugging
-class gamestate:
+class Gamestate:
def __init__(self):
self.options = None # Game options
- self.state = snapshot() # A snapshot structure
- self.snapsht = snapshot() # Last snapshot taken for time-travel purposes
+ self.state = Snapshot() # A snapshot structure
+ self.snapsht = Snapshot() # Last snapshot taken for time-travel purposes
self.quad = None # contents of our quadrant
self.damage = [0.0] * NDEVICES # damage encountered
self.future = [] # future events
i = NEVENTS
while i > 0:
i -= 1
- self.future.append(event())
- self.passwd = None; # Self Destruct password
+ self.future.append(Event())
+ self.passwd = None # Self Destruct password
self.enemies = []
self.quadrant = None # where we are in the large
self.sector = None # where we are in the small
self.cryprob = 0.0 # probability that crystal will work
self.probe = None # object holding probe course info
self.height = 0.0 # height of orbit around planet
+ self.score = 0.0 # overall score
+ self.perdate = 0.0 # rate of kills
self.idebug = False # Debugging instrumentation enabled?
def recompute(self):
# Stas thinks this should be (C expression):
# He says the existing expression is prone to divide-by-zero errors
# after killing the last klingon when score is shown -- perhaps also
# if the only remaining klingon is SCOM.
- game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr))
+ self.state.remtime = self.state.remres/(self.state.remkl + 4*len(self.state.kcmdr))
FWON = 0
FDEPLETE = 1
def tryexit(enemy, look, irun):
"A bad guy attempts to bug out."
- iq = coord()
+ iq = Coord()
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;
+ return False
if enemy.type == 'R':
- return False; # Romulans cannot escape!
+ return False # Romulans cannot escape!
if not irun:
# avoid intruding on another commander's territory
if enemy.type == 'C':
# Handle global matters related to escape
game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
game.state.galaxy[iq.i][iq.j].klingons += 1
- if enemy.type=='S':
+ if enemy.type == 'S':
game.iscate = False
game.ientesc = False
game.isatb = 0
schedule(FSCMOVE, 0.2777)
unschedule(FSCDBAS)
- game.state.kscmdr=iq
+ game.state.kscmdr = iq
else:
for cmdr in game.state.kcmdr:
if cmdr == game.quadrant:
game.state.kcmdr.append(iq)
break
- return True; # success
+ return True # success
# The bad-guy movement algorithm:
#
def movebaddy(enemy):
"Tactical movement for the bad guys."
- goto = coord(); look = coord()
+ goto = Coord()
+ look = Coord()
irun = False
# This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
if game.skill >= SKILL_EXPERT:
else:
nbaddys = (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
dist1 = enemy.kdist
- mdist = int(dist1 + 0.5); # Nearest integer distance
+ mdist = int(dist1 + 0.5) # Nearest integer distance
# If SC, check with spy to see if should hi-tail it
- if enemy.type=='S' and \
+ if enemy.type == 'S' and \
(enemy.power <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
irun = True
motion = -QUADSIZE
# decide whether to advance, retreat, or hold position
forces = enemy.power+100.0*len(game.enemies)+400*(nbaddys-1)
if not game.shldup:
- forces += 1000; # Good for enemy if shield is down!
+ forces += 1000 # Good for enemy if shield is down!
if not damaged(DPHASER) or not damaged(DPHOTON):
if damaged(DPHASER): # phasers damaged
forces += 300.0
else:
if forces > 1000.0: # Very strong -- move in for kill
motion = (1.0 - randreal())**2 * dist1 + 1.0
- if game.condition=="docked" and (game.options & OPTION_BASE): # protected by base -- back off !
+ if game.condition == "docked" and (game.options & OPTION_BASE): # protected by base -- back off !
motion -= game.skill*(2.0-randreal()**2)
if game.idebug:
proutn("=== MOTION = %d, FORCES = %1.2f, " % (motion, forces))
# don't move if no motion
- if motion==0:
+ if motion == 0:
return
# Limit motion according to skill
if abs(motion) > game.skill:
# calculate preferred number of steps
nsteps = abs(int(motion))
if motion > 0 and nsteps > mdist:
- nsteps = mdist; # don't overshoot
+ nsteps = mdist # don't overshoot
if nsteps > QUADSIZE:
- nsteps = QUADSIZE; # This shouldn't be necessary
+ nsteps = QUADSIZE # This shouldn't be necessary
if nsteps < 1:
- nsteps = 1; # This shouldn't be necessary
+ nsteps = 1 # This shouldn't be necessary
if game.idebug:
proutn("NSTEPS = %d:" % nsteps)
# Compute preferred values of delta X and Y
else:
krawlj = -1
success = False
- attempts = 0; # Settle mysterious hang problem
+ attempts = 0 # Settle mysterious hang problem
while attempts < 20 and not success:
attempts += 1
if look.i < 0 or look.i >= QUADSIZE:
look.j = goto.j + krawlj
krawlj = -krawlj
else:
- break; # we have failed
+ break # we have failed
else:
success = True
if success:
goto = look
if game.idebug:
- proutn(`goto`)
+ proutn(repr(goto))
else:
- break; # done early
+ break # done early
if game.idebug:
skip(1)
if enemy.move(goto):
for enemy in game.enemies:
if enemy.type == 'C':
movebaddy(enemy)
- if game.state.kscmdr==game.quadrant:
+ if game.state.kscmdr == game.quadrant:
for enemy in game.enemies:
if enemy.type == 'S':
movebaddy(enemy)
for enemy in game.enemies:
if enemy.type in ('K', 'R'):
movebaddy(enemy)
- game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ sortenemies()
def movescom(iq, avoid):
"Commander movement helper."
game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons -= 1
game.state.kscmdr = iq
game.state.galaxy[game.state.kscmdr.i][game.state.kscmdr.j].klingons += 1
- if game.state.kscmdr==game.quadrant:
+ if game.state.kscmdr == game.quadrant:
# SC has scooted, remove him from current quadrant
- game.iscate=False
- game.isatb=0
+ game.iscate = False
+ game.isatb = 0
game.ientesc = False
unschedule(FSCDBAS)
for enemy in game.enemies:
game.klhere -= 1
if game.condition != "docked":
newcnd()
- game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ sortenemies()
# check for a helpful planet
for i in range(game.inplan):
if game.state.planets[i].quadrant == game.state.kscmdr and \
proutn(_(" a planet in Quadrant %s has been destroyed") % game.state.kscmdr)
prout(_(" by the Super-commander.\""))
break
- return True; # looks good!
+ return True # looks good!
def supercommander():
"Move the Super Commander."
- iq = coord(); sc = coord(); ibq = coord(); idelta = coord()
+ iq = Coord()
+ sc = Coord()
+ ibq = Coord()
+ idelta = Coord()
basetbl = []
if game.idebug:
prout("== SUPERCOMMANDER")
unschedule(FSCMOVE)
return
sc = game.state.kscmdr
- for base in game.state.baseq:
+ for (i, base) in enumerate(game.state.baseq):
basetbl.append((i, (base - sc).distance()))
if game.state.baseq > 1:
basetbl.sort(lambda x, y: cmp(x[1], y[1]))
# without too many Klingons, and not already under attack.
ifindit = iwhichb = 0
for (i2, base) in enumerate(game.state.baseq):
- i = basetbl[i2][0]; # bug in original had it not finding nearest
- if base==game.quadrant or base==game.battle or not welcoming(base):
+ i = basetbl[i2][0] # bug in original had it not finding nearest
+ if base == game.quadrant or base == game.battle or not welcoming(base):
continue
# if there is a commander, and no other base is appropriate,
# we will take the one with the commander
ifindit = 1
iwhichb = i
break
- if ifindit==0:
+ if ifindit == 0:
return # Nothing suitable -- wait until next time
ibq = game.state.baseq[iwhichb]
# decide how to move toward base
iq = game.state.kscmdr + idelta
if not movescom(iq, avoid):
# failed -- try some other maneuvers
- if idelta.i==0 or idelta.j==0:
+ if idelta.i == 0 or idelta.j == 0:
# attempt angle move
if idelta.i != 0:
iq.j = game.state.kscmdr.j + 1
if not ja():
return
game.resting = False
- game.optime = 0.0; # actually finished
+ game.optime = 0.0 # actually finished
return
# Check for intelligence report
if not game.idebug and \
"Move the Tholian."
if not game.tholian or game.justin:
return
- tid = coord()
+ tid = Coord()
if game.tholian.location.i == 0 and game.tholian.location.j == 0:
- tid.i = 0; tid.j = QUADSIZE-1
+ tid.i = 0
+ tid.j = QUADSIZE-1
elif game.tholian.location.i == 0 and game.tholian.location.j == QUADSIZE-1:
- tid.i = QUADSIZE-1; tid.j = QUADSIZE-1
+ tid.i = QUADSIZE-1
+ tid.j = QUADSIZE-1
elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == QUADSIZE-1:
- tid.i = QUADSIZE-1; tid.j = 0
+ tid.i = QUADSIZE-1
+ tid.j = 0
elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == 0:
- tid.i = 0; tid.j = 0
+ tid.i = 0
+ tid.j = 0
else:
# something is wrong!
game.tholian.move(None)
# move in x axis
while here.i != tid.i:
here.i += delta.i
- if game.quad[here.i][here.j]=='.':
+ if game.quad[here.i][here.j] == '.':
game.tholian.move(here)
# move in y axis
while here.j != tid.j:
here.j += delta.j
- if game.quad[here.i][here.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]!='#' and game.quad[0][i]!='T':
+ if game.quad[0][i] != '#' and game.quad[0][i] != 'T':
return
- if game.quad[QUADSIZE-1][i]!='#' and game.quad[QUADSIZE-1][i]!='T':
+ if game.quad[QUADSIZE-1][i] != '#' and game.quad[QUADSIZE-1][i] != 'T':
return
- if game.quad[i][0]!='#' and game.quad[i][0]!='T':
+ if game.quad[i][0] != '#' and game.quad[i][0] != 'T':
return
- if game.quad[i][QUADSIZE-1]!='#' and game.quad[i][QUADSIZE-1]!='T':
+ if game.quad[i][QUADSIZE-1] != '#' and game.quad[i][QUADSIZE-1] != 'T':
return
# All plugged up -- Tholian splits
- game.quad[game.tholian.location.i][game.tholian.location.j]='#'
+ game.quad[game.tholian.location.i][game.tholian.location.j] = '#'
dropin(' ')
prout(crmena(True, 'T', "sector", game.tholian) + _(" completes web."))
game.tholian.move(None)
action = "SHUP"
elif scanner.sees("down"):
action = "SHDN"
- if action=="NONE":
+ if action == "NONE":
proutn(_("Do you wish to change shield energy? "))
if ja():
action = "NRG"
action = "SHUP"
else:
scanner.chew()
- return
+ return
if action == "SHUP": # raise shields
if game.shldup:
prout(_("Shields already up."))
prout(_("Shields raising uses up last of energy."))
finish(FNRG)
return
- game.ididit=True
+ game.ididit = True
return
elif action == "SHDN":
if not game.shldup:
prout(_("Shields already down."))
return
- game.shldup=False
- game.shldchg=True
+ game.shldup = False
+ game.shldchg = True
prout(_("Shields lowered."))
game.ididit = True
return
wsum += w
if idx < wsum:
return i
- return None; # we should never get here
+ return None # we should never get here
def collision(rammed, enemy):
"Collision handling fot rammong events."
def torpedo(origin, bearing, dispersion, number, nburst):
"Let a photon torpedo fly"
- if not damaged(DSRSENS) or game.condition=="docked":
+ 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)
+ bumpto = Coord(0, 0)
# Loop to move a single torpedo
setwnd(message_window)
for step in range(1, QUADSIZE*2):
- if not track.next(): break
+ if not track.next():
+ break
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=='.':
+ iquad = game.quad[w.i][w.j]
+ tracktorpedo(w, step, number, nburst, iquad)
+ if iquad == '.':
continue
# hit something
if not damaged(DSRSENS) or game.condition == "docked":
- skip(1); # start new line after text track
+ skip(1) # start new line after text track
if iquad in ('E', 'F'): # 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-track.angle))
- newcnd(); # we're blown out of dock
- if game.landed or game.condition=="docked":
+ newcnd() # we're blown out of dock
+ if game.landed or game.condition == "docked":
return hit # Cheat if on a planet
# 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 = 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[bumpto.i][bumpto.j]==' ':
+ if game.quad[bumpto.i][bumpto.j] == ' ':
finish(FHOLE)
return hit
- if game.quad[bumpto.i][bumpto.j]!='.':
+ if game.quad[bumpto.i][bumpto.j] != '.':
# can't move into object
return hit
game.sector = bumpto
proutn(crmshp())
- game.quad[w.i][w.j]='.'
- game.quad[bumpto.i][bumpto.j]=iquad
+ 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))
+ sortenemies()
return None
elif iquad in ('C', 'S', 'R', 'K'): # Hit a regular enemy
# find the enemy
deadkl(w, iquad, w)
return None
proutn(crmena(True, iquad, "sector", w))
- displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5)
+ displacement = course(track.bearing+randreal(-2.4, 2.4), distance=2**0.5)
displacement.next()
bumpto = displacement.sector()
if not bumpto.valid_sector():
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
+ 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))
+ sortenemies()
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.i][w.j]='.'
+ game.quad[w.i][w.j] = '.'
game.base.invalidate()
game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase -= 1
game.state.chart[game.quadrant.i][game.quadrant.j].starbase -= 1
# 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
+ thing.angry()
return None
elif iquad == ' ': # Black hole
skip(1)
return None
elif iquad == 'T': # Hit a Tholian
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 h1 >= 600:
game.quad[w.i][w.j] = '.'
break
skip(1)
prout(_("Torpedo missed."))
- return None;
+ return None
def fry(hit):
"Critical-hit resolution."
while True:
j = randdevice()
# Cheat to prevent shuttle damage unless on ship
- if not (game.damage[j]<0.0 or (j==DSHUTTL and game.iscraft != "onship")):
+ if not (game.damage[j]<0.0 or (j == DSHUTTL and game.iscraft != "onship")):
break
cdam.append(j)
extradm = (hit*game.damfac)/(ncrit*randreal(75, 100))
prout(_(" damaged."))
if damaged(DSHIELD) and game.shldup:
prout(_("***Shields knocked down."))
- game.shldup=False
+ game.shldup = False
def attack(torps_ok):
# bad guy attacks us
# 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
+ attempt = False
+ ihurt = False
+ hitmax = 0.0
+ hittot = 0.0
+ chgfac = 1.0
where = "neither"
if game.idebug:
prout("=== ATTACK!")
game.neutz = False
return
# commanders get a chance to tac-move towards you
- if (((game.quadrant in game.state.kcmdr or game.state.kscmdr==game.quadrant) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok:
+ if (((game.quadrant in game.state.kcmdr or game.state.kscmdr == game.quadrant) and not game.justin) or game.skill == SKILL_EMERITUS) and torps_ok:
moveklings()
# if no enemies remain after movement, we're done
- if len(game.enemies)==0 or (len(game.enemies)==1 and thing == game.quadrant and not thing.angry):
+ if len(game.enemies) == 0 or (len(game.enemies) == 1 and thing == game.quadrant and not thing.angered):
return
# set up partial hits if attack happens during shield status change
pfac = 1.0/game.inshld
where = "sector"
for enemy in game.enemies:
if enemy.power < 0:
- continue; # too weak to attack
+ 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.power < 500:
- r *= 0.25;
- if enemy.type=='T' or (enemy.type=='?' and not thing.angry):
+ r *= 0.25
+ if enemy.type == 'T' or (enemy.type == '?' and not thing.angered):
continue
# different enemies have different probabilities of throwing a torp
usephasers = not torps_ok or \
(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)
+ (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
+ continue # Don't waste the effort!
+ attempt = True # Attempt to attack
dustfac = randreal(0.8, 0.85)
- hit = enemy.power*math.pow(dustfac,enemy.kavgd)
+ hit = enemy.power*math.pow(dustfac, enemy.kavgd)
enemy.power *= 0.75
else: # Enemy uses photon torpedo
# We should be able to make the bearing() method work here
dispersion = (randreal()+randreal())*0.5 - 0.5
dispersion += 0.002*enemy.power*dispersion
hit = torpedo(enemy.location, pcourse, 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.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
+ finish(FWON) # Klingons did themselves in!
if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone:
return # Supernova or finished
if hit == None:
continue
# incoming phaser or torpedo, shields may dissipate it
- if game.shldup or game.shldchg or game.condition=="docked":
+ if game.shldup or game.shldchg or game.condition == "docked":
# shields will take hits
propor = pfac * game.shield
- if game.condition =="docked":
+ if game.condition == "docked":
propor *= 2.1
if propor < 0.1:
propor = 0.1
# After attack, reset average distance to enemies
for enemy in game.enemies:
enemy.kavgd = enemy.kdist
- game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ sortenemies()
return
-def deadkl(w, type, mv):
+def deadkl(w, etype, mv):
"Kill a Klingon, Tholian, Romulan, or Thingy."
# Added mv to allow enemy to "move" before dying
- proutn(crmena(True, type, "sector", mv))
+ proutn(crmena(True, etype, "sector", mv))
# Decide what kind of enemy it is and update appropriately
- if type == 'R':
+ if etype == '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 == 'T':
+ elif etype == 'T':
# Killed a Tholian
game.tholian = None
- elif type == '?':
+ elif etype == '?':
# Killed a Thingy
global thing
thing = None
unschedule(FSCDBAS)
# For each kind of enemy, finish message to player
prout(_(" destroyed."))
- if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
+ if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
return
game.recompute()
# Remove enemy ship from arrays describing local conditions
if not w.valid_sector():
huh()
return None
- 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):
+ delta = Coord()
+ # 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"))
target = []
for i in range(n):
key = scanner.next()
- if i==0 and key == "IHEOL":
- break; # no coordinate waiting, we will try prompting
- if i==1 and key == "IHEOL":
+ 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:
target.append(target[0])
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);
+ finish(FWON)
def overheat(rpow):
"Check for phasers overheating."
prout(_("Phaser energy dispersed by shields."))
prout(_("Enemy unaffected."))
overheat(rpow)
- return True;
+ return True
def hittem(hits):
"Register a phaser hit on Klingons and Romulans."
- kk = 0
- w = coord()
+ w = Coord()
skip(1)
- for (k, wham) in enumerate(hits):
- if wham==0:
+ for (kk, wham) in enumerate(hits):
+ if wham == 0:
continue
dustfac = randreal(0.9, 1.0)
- hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
+ hit = wham*math.pow(dustfac, game.enemies[kk].kdist)
kpini = game.enemies[kk].power
kp = math.fabs(kpini)
if PHASEFAC*hit < kp:
else:
proutn(_("Very small hit on "))
ienm = game.quad[w.i][w.j]
- if ienm=='?':
- thing.angry = True
+ if ienm == '?':
+ thing.angry()
proutn(crmena(False, ienm, "sector", w))
skip(1)
if kpow == 0:
deadkl(w, ienm, w)
if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
- finish(FWON);
+ finish(FWON)
if game.alldone:
return
kk -= 1 # don't do the increment
continue
else: # decide whether or not to emasculate klingon
- if kpow>0 and withprob(0.9) and kpow <= randreal(0.4, 0.8)*kpini:
+ 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].power = -kpow
def 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
+ kz = 0
+ k = 1
+ irec = 0 # Cheating inhibitor
+ ifast = False
+ no = False
+ itarg = True
+ msgflag = True
+ rpow = 0
automode = "NOTSET"
- key=0
+ key = 0
skip(1)
# SR sensors and Computer are needed for automode
if damaged(DSRSENS) or damaged(DCOMPTR):
ifast = True
# Original code so convoluted, I re-did it all
# (That was Tom Almy talking about the C code, I think -- ESR)
- while automode=="NOTSET":
- key=scanner.next()
+ while automode == "NOTSET":
+ key = scanner.next()
if key == "IHALPHA":
if scanner.sees("manual"):
if len(game.enemies)==0:
prout(_("There is no enemy present to select."))
scanner.chew()
key = "IHEOL"
- automode="AUTOMATIC"
+ automode = "AUTOMATIC"
else:
automode = "MANUAL"
key = scanner.next()
key = scanner.next()
if key != "IHREAL" and len(game.enemies) != 0:
prout(_("Phasers locked on target. Energy available: %.2f")%avail)
- irec=0
+ irec = 0
while True:
scanner.chew()
if not kz:
for i in range(len(game.enemies)):
- 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
+ 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:
key = "IHEOL"
if not rpow > avail:
break
- if rpow<=0:
+ if rpow <= 0:
# chicken out
scanner.chew()
return
- key=scanner.next()
+ key = scanner.next()
if key == "IHALPHA" and scanner.sees("no"):
no = True
if ifast:
- game.energy -= 200; # Go and do it!
+ game.energy -= 200 # Go and do it!
if checkshctrl(rpow):
return
scanner.chew()
hits.append(0.0)
if powrem <= 0:
continue
- hits[i] = math.fabs(game.enemies[i].power)/(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(cramen(ienm) + _(" can't be located without short range scan."))
scanner.chew()
key = "IHEOL"
- hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko
+ hits[k] = 0 # prevent overflow -- thanks to Alexei Voitenko
k += 1
continue
if key == "IHEOL":
scanner.chew()
if itarg and k > kz:
- irec=(abs(game.enemies[k].power)/(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):
huh()
return
if key == "IHEOL":
- if k==1: # Let me say I'm baffled by this
+ if k == 1: # Let me say I'm baffled by this
msgflag = True
continue
if scanner.real < 0:
prout(_("Available energy exceeded -- try again."))
scanner.chew()
return
- key = scanner.next(); # scan for next value
+ key = scanner.next() # scan for next value
k += 1
if rpow == 0.0:
# zero energy -- abort
prout(_("Shields raised."))
else:
game.shldup = False
- overheat(rpow);
+ overheat(rpow)
# Code from events,c begins here.
def events():
"Run through the event queue looking for things to do."
- i=0
- fintim = game.state.date + game.optime; yank=0
- ictbeam = False; istract = False
- w = coord(); hold = coord()
- ev = event(); ev2 = event()
+ i = 0
+ fintim = game.state.date + game.optime
+ yank = 0
+ ictbeam = False
+ istract = False
+ w = Coord()
+ hold = Coord()
+ ev = Event()
+ ev2 = Event()
def tractorbeam(yank):
"Tractor-beaming cases merge here."
# Decrement Federation resources and recompute remaining time
game.state.remres -= (game.state.remkl+4*len(game.state.kcmdr))*xtime
game.recompute()
- if game.state.remtime <=0:
+ if game.state.remtime <= 0:
finish(FDEPLETE)
return
# Any crew left alive?
- if game.state.crew <=0:
+ if game.state.crew <= 0:
finish(FCREW)
return
# Is life support adequate?
elif evcode == FSPY: # Check with spy to see if SC should tractor beam
if game.state.nscrem == 0 or \
ictbeam or istract or \
- game.condition=="docked" or game.isatb==1 or game.iscate:
+ game.condition == "docked" or game.isatb == 1 or game.iscate:
return
if game.ientesc or \
(game.energy<2000 and game.torps<4 and game.shield < 1250) or \
continue
try:
for ibq in game.state.baseq:
- for cmdr in game.state.kcmdr:
- if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
- raise ibq
+ for cmdr in game.state.kcmdr:
+ if ibq == cmdr and ibq != game.quadrant and ibq != game.state.kscmdr:
+ raise JumpOut
else:
# no match found -- try later
schedule(FBATTAK, expran(0.3*game.intime))
unschedule(FCDBAS)
continue
- except coord:
+ except JumpOut:
pass
# commander + starbase combination found -- launch attack
game.battle = ibq
game.battle = game.state.kscmdr
destroybase()
elif evcode == FCDBAS: # Commander succeeds in destroying base
- if evcode==FCDBAS:
+ if evcode == FCDBAS:
unschedule(FCDBAS)
if not game.state.baseq() \
or not game.state.galaxy[game.battle.i][game.battle.j].starbase:
# tell the captain about it if we can
if communicating():
prout(_("Uhura- Captain, %s in Quadrant %s reports it is under attack") \
- % (q.planet, `w`))
+ % (q.planet, repr(w)))
prout(_("by a Klingon invasion fleet."))
if cancelrest():
return
if q.klingons <= 0:
q.status = "secure"
continue
- if game.state.remkl >=MAXKLGAME:
+ if game.state.remkl >= MAXKLGAME:
continue # full right now
# reproduce one Klingon
w = ev.quadrant
- m = coord()
+ m = Coord()
if game.klhere >= MAXKLQUAD:
try:
# this quadrant not ok, pick an adjacent one
def nova(nov):
"Star goes nova."
ncourse = (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)
+ newc = Coord(); neighbor = Coord(); bump = Coord(0, 0)
if withprob(0.05):
# Wow! We've supernova'ed
supernova(game.quadrant)
hits = [nov]
kount = 0
while hits:
- offset = coord()
+ offset = Coord()
start = hits.pop()
for offset.i in range(-1, 1+1):
for offset.j in range(-1, 1+1):
- if offset.j==0 and offset.i==0:
+ if offset.j == 0 and offset.i == 0:
continue
neighbor = start + offset
if not neighbor.valid_sector():
if iquad == 'P':
game.state.nplankl += 1
else:
- game.state.worldkl += 1
+ game.state.nworldkl += 1
prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
game.iplnet.pclass = "destroyed"
game.iplnet = None
finish(FNOVA)
return
# add in course nova contributes to kicking starship
- bump += (game.sector-hits[mm]).sgn()
+ bump += (game.sector-hits[-1]).sgn()
elif iquad == 'K': # kill klingon
deadkl(neighbor, iquad, neighbor)
elif iquad in ('C','S','R'): # Damage/destroy big enemies
if game.enemies[ll].power <= 0.0:
deadkl(neighbor, iquad, neighbor)
break
- newc = neighbor + neighbor - hits[mm]
+ newc = neighbor + neighbor - hits[-1]
proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
if not newc.valid_sector():
# can't leave quadrant
else:
# Scheduled supernova -- select star at random.
stars = 0
- nq = coord()
+ nq = Coord()
for nq.i in range(GALSIZE):
for nq.j in range(GALSIZE):
stars += game.state.galaxy[nq.i][nq.j].stars
prout(_("Message from Starfleet Command Stardate %.2f") % game.state.date)
prout(_(" Supernova in Quadrant %s; caution advised.") % nq)
else:
- ns = coord()
+ ns = Coord()
# we are in the quadrant!
num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
for ns.i in range(QUADSIZE):
prout(_("SELF-DESTRUCT-SEQUENCE-WILL-BE-ABORTED"))
skip(1)
scanner.next()
- scanner.chew()
if game.passwd != scanner.token:
prouts(_("PASSWORD-REJECTED;"))
skip(1)
skip(1)
if len(game.enemies) != 0:
whammo = 25.0 * game.energy
- l=1
- while l <= len(game.enemies):
+ for l in range(len(game.enemies)):
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)
def killrate():
def 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:
timused = 5.0
- perdate = killrate()
- ithperd = 500*perdate + 0.5
+ game.perdate = killrate()
+ ithperd = 500*game.perdate + 0.5
iwon = 0
if game.gamewon:
iwon = 100*game.skill
klship = 1
else:
klship = 2
- iscore = 10*(game.inkling - game.state.remkl) \
+ game.score = 10*(game.inkling - game.state.remkl) \
+ 50*(game.incom - len(game.state.kcmdr)) \
+ ithperd + iwon \
+ 20*(game.inrom - game.state.nromrem) \
- game.state.nromrem \
- badpoints()
if not game.alive:
- iscore -= 200
+ game.score -= 200
skip(2)
prout(_("Your score --"))
if game.inrom - game.state.nromrem:
(game.inscom - game.state.nscrem, 200*(game.inscom - game.state.nscrem)))
if ithperd:
prout(_("%6.2f Klingons per stardate %5d") %
- (perdate, ithperd))
+ (game.perdate, ithperd))
if game.state.starkl:
prout(_("%6d stars destroyed by your action %5d") %
(game.state.starkl, -5*game.state.starkl))
elif game.skill == SKILL_EMERITUS: proutn(_("Emeritus game"))
prout(" %5d" % iwon)
skip(1)
- prout(_("TOTAL SCORE %5d") % iscore)
+ prout(_("TOTAL SCORE %5d") % game.score)
def plaque():
"Emit winner's commemmorative plaque."
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)
- fp.write(_(" Klingons per stardate: %.2f\n") % perdate)
+ fp.write(_(" Your score: %d\n\n") % game.score)
+ fp.write(_(" Klingons per stardate: %.2f\n") % game.perdate)
fp.close()
# Code from io.c begins here
curses.nonl()
curses.cbreak()
if game.options & OPTION_COLOR:
- curses.start_color();
+ curses.start_color()
curses.use_default_colors()
- curses.init_pair(curses.COLOR_BLACK, curses.COLOR_BLACK, -1);
- curses.init_pair(curses.COLOR_GREEN, curses.COLOR_GREEN, -1);
- curses.init_pair(curses.COLOR_RED, curses.COLOR_RED, -1);
- curses.init_pair(curses.COLOR_CYAN, curses.COLOR_CYAN, -1);
- curses.init_pair(curses.COLOR_WHITE, curses.COLOR_WHITE, -1);
- curses.init_pair(curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, -1);
- curses.init_pair(curses.COLOR_BLUE, curses.COLOR_BLUE, -1);
- curses.init_pair(curses.COLOR_YELLOW, curses.COLOR_YELLOW, -1);
+ curses.init_pair(curses.COLOR_BLACK, curses.COLOR_BLACK, -1)
+ curses.init_pair(curses.COLOR_GREEN, curses.COLOR_GREEN, -1)
+ curses.init_pair(curses.COLOR_RED, curses.COLOR_RED, -1)
+ curses.init_pair(curses.COLOR_CYAN, curses.COLOR_CYAN, -1)
+ curses.init_pair(curses.COLOR_WHITE, curses.COLOR_WHITE, -1)
+ curses.init_pair(curses.COLOR_MAGENTA, curses.COLOR_MAGENTA, -1)
+ curses.init_pair(curses.COLOR_BLUE, curses.COLOR_BLUE, -1)
+ curses.init_pair(curses.COLOR_YELLOW, curses.COLOR_YELLOW, -1)
global fullscreen_window, srscan_window, report_window, status_window
global lrscan_window, message_window, prompt_window
(rows, columns) = stdscr.getmaxyx()
"Skip i lines. Pause game if this would cause a scrolling event."
for dummy in range(i):
if game.options & OPTION_CURSES:
- (y, x) = curwnd.getyx()
- (my, mx) = curwnd.getmaxyx()
- if curwnd == message_window and y >= my - 2:
- pause_game()
- clrscr()
- else:
- try:
- curwnd.move(y+1, 0)
- except curses.error:
- pass
+ (y, x) = curwnd.getyx()
+ try:
+ curwnd.move(y+1, 0)
+ except curses.error:
+ pass
else:
global linecount
linecount += 1
def proutn(line):
"Utter a line with no following line feed."
if game.options & OPTION_CURSES:
+ (y, x) = curwnd.getyx()
+ (my, mx) = curwnd.getmaxyx()
+ if curwnd == message_window and y >= my - 2:
+ pause_game()
+ clrscr()
curwnd.addstr(line)
curwnd.refresh()
else:
"Clear screen -- can be a no-op in tty mode."
global linecount
if game.options & OPTION_CURSES:
- curwnd.clear()
- curwnd.move(0, 0)
- curwnd.refresh()
+ curwnd.clear()
+ curwnd.move(0, 0)
+ curwnd.refresh()
linecount = 0
def textcolor(color=DEFAULT):
if game.options & OPTION_COLOR:
if color == DEFAULT:
- curwnd.attrset(0);
+ curwnd.attrset(0)
elif color == BLACK:
- curwnd.attron(curses.color_pair(curses.COLOR_BLACK));
+ curwnd.attron(curses.color_pair(curses.COLOR_BLACK))
elif color == BLUE:
- curwnd.attron(curses.color_pair(curses.COLOR_BLUE));
+ curwnd.attron(curses.color_pair(curses.COLOR_BLUE))
elif color == GREEN:
- curwnd.attron(curses.color_pair(curses.COLOR_GREEN));
+ curwnd.attron(curses.color_pair(curses.COLOR_GREEN))
elif color == CYAN:
- curwnd.attron(curses.color_pair(curses.COLOR_CYAN));
+ curwnd.attron(curses.color_pair(curses.COLOR_CYAN))
elif color == RED:
- curwnd.attron(curses.color_pair(curses.COLOR_RED));
+ curwnd.attron(curses.color_pair(curses.COLOR_RED))
elif color == MAGENTA:
- curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA));
+ curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA))
elif color == BROWN:
- curwnd.attron(curses.color_pair(curses.COLOR_YELLOW));
+ curwnd.attron(curses.color_pair(curses.COLOR_YELLOW))
elif color == LIGHTGRAY:
- curwnd.attron(curses.color_pair(curses.COLOR_WHITE));
+ curwnd.attron(curses.color_pair(curses.COLOR_WHITE))
elif color == DARKGRAY:
- curwnd.attron(curses.color_pair(curses.COLOR_BLACK) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_BLACK) | curses.A_BOLD)
elif color == LIGHTBLUE:
- curwnd.attron(curses.color_pair(curses.COLOR_BLUE) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_BLUE) | curses.A_BOLD)
elif color == LIGHTGREEN:
- curwnd.attron(curses.color_pair(curses.COLOR_GREEN) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_GREEN) | curses.A_BOLD)
elif color == LIGHTCYAN:
- curwnd.attron(curses.color_pair(curses.COLOR_CYAN) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_CYAN) | curses.A_BOLD)
elif color == LIGHTRED:
- curwnd.attron(curses.color_pair(curses.COLOR_RED) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_RED) | curses.A_BOLD)
elif color == LIGHTMAGENTA:
- curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_MAGENTA) | curses.A_BOLD)
elif color == YELLOW:
- curwnd.attron(curses.color_pair(curses.COLOR_YELLOW) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_YELLOW) | curses.A_BOLD)
elif color == WHITE:
- curwnd.attron(curses.color_pair(curses.COLOR_WHITE) | curses.A_BOLD);
+ curwnd.attron(curses.color_pair(curses.COLOR_WHITE) | curses.A_BOLD)
def highvideo():
if game.options & OPTION_COLOR:
#nosound()
pass
-def tracktorpedo(origin, w, step, i, n, iquad):
+def tracktorpedo(w, step, i, n, iquad):
"Torpedo-track animation."
if not game.options & OPTION_CURSES:
if step == 1:
def imove(icourse=None, noattack=False):
"Movement execution for warp, impulse, supernova, and tractor-beam events."
- w = coord()
+ w = Coord()
def newquadrant(noattack):
# Leaving quadrant -- allow final enemy attack
if icourse.origin.quadrant() != icourse.location.quadrant():
newquadrant(noattack)
break
- elif check_collision(icourse, w):
+ elif check_collision(w):
print "Collision detected"
break
else:
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))
+ sortenemies()
if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
attack(torps_ok=False)
for enemy in game.enemies:
dquad = copy.copy(game.quadrant)
navmode = "unspecified"
itemp = "curt"
- dsect = coord()
+ dsect = Coord()
iprompt = False
if game.landed and not isprobe:
prout(_("Dummy! You can't leave standard orbit until you"))
prout(_("(Manual movement assumed.)"))
navmode = "manual"
break
- delta = coord()
+ delta = Coord()
if navmode == "automatic":
while key == "IHEOL":
if isprobe:
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))
+ 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))
twarp = True
if blooey or twarp:
# If time warp or engine damage, check path
- # If it is obstructed, don't do warp or damage
- for m_unused in range(wcourse.moves):
+ # If it is obstructed, don't do warp or damage
+ look = wcourse.moves
+ while look > 0:
+ look -= 1
wcourse.next()
w = wcourse.sector()
if not w.valid_sector():
twarp = False
wcourse.reset()
# Activate Warp Engines and pay the cost
- imove(course, noattack=False)
+ imove(wcourse, noattack=False)
if game.alldone:
return
game.energy -= wcourse.power(game.warpfac)
elif m == 2: proutn(_("2nd"))
elif m == 3: proutn(_("3rd"))
proutn(_(" attempt to re-materialize ") + crmshp())
- game.quad[ix][iy]=('-','o','O')[m-1]
+ game.quad[game.sector.i][game.sector.j]=('-','o','O')[m-1]
textcolor(RED)
warble()
if randreal() > probf:
textcolor(DEFAULT)
curses.delay_output(500)
if m > 3:
- game.quad[ix][iy]='?'
+ game.quad[game.sector.i][game.sector.j]='?'
game.alive = False
drawmaps(1)
setwnd(message_window)
finish(FMATERIALIZE)
return
- game.quad[ix][iy]=game.ship
- textcolor(GREEN);
+ game.quad[game.sector.i][game.sector.j]=game.ship
+ textcolor(GREEN)
prout(_("succeeds."))
- textcolor(DEFAULT);
+ textcolor(DEFAULT)
dock(False)
skip(1)
prout(_("Lt. Uhura- \"Captain, we made it!\""))
def report():
# report on general game status
scanner.chew()
- s1 = "" and game.thawed and _("thawed ")
+ s1 = (game.thawed and _("thawed ")) or ""
s2 = {1:"short", 2:"medium", 4:"long"}[game.length]
s3 = (None, _("novice"), _("fair"),
_("good"), _("expert"), _("emeritus"))[game.skill]
if not silent:
proutn(" ")
for y in range(game.quadrant.j-1, game.quadrant.j+2):
- if not coord(x, y).valid_quadrant():
+ if not Coord(x, y).valid_quadrant():
if not silent:
proutn(" -1")
else:
"docked":CYAN,
"dead":BROWN}[game.condition])
if game.quad[i][j] != game.ship:
- highvideo();
+ highvideo()
proutn("%c " % game.quad[i][j])
textcolor(DEFAULT)
else:
def eta():
"Use computer to get estimated time of arrival for a warp jump."
- w1 = coord(); w2 = coord()
+ w1 = Coord(); w2 = Coord()
prompt = False
if damaged(DCOMPTR):
prout(_("COMPUTER DAMAGED, USE A POCKET CALCULATOR."))
if key != "IHALPHA":
huh()
return
- scanner.chew()
if '.' not in scanner.token:
scanner.token += ".trk"
try:
return
cPickle.dump(game, fp)
fp.close()
+ scanner.chew()
def thaw():
"Retrieve saved game."
- game.passwd[0] = '\0'
+ global game
+ game.passwd = None
key = scanner.next()
if key == "IHEOL":
proutn(_("File name: "))
if key != "IHALPHA":
huh()
return True
- scanner.chew()
if '.' not in scanner.token:
scanner.token += ".trk"
try:
return
game = cPickle.load(fp)
fp.close()
+ scanner.chew()
return False
# I used <http://www.memory-alpha.org> to find planets
def setup():
"Prepare to play, set up cosmos."
- w = coord()
+ w = Coord()
# Decide how many of everything
if choose():
return # frozen game
for i in range(NDEVICES):
game.damage[i] = 0.0
# Set up assorted game parameters
- game.battle = coord()
+ game.battle = Coord()
game.state.date = game.indate = 100.0 * randreal(20, 51)
game.nkinks = game.nhelp = game.casual = game.abandoned = 0
game.iscate = game.resting = game.imine = game.icrystl = game.icraft = False
game.isatb = game.state.nplankl = 0
- game.state.starkl = game.state.basekl = 0
+ game.state.starkl = game.state.basekl = game.state.nworldkl = 0
game.iscraft = "onship"
game.landed = False
game.alive = True
+
+ # the galaxy
+ game.state.galaxy = fill2d(GALSIZE, lambda i_unused, j_unused: Quadrant())
+ # the starchart
+ game.state.chart = fill2d(GALSIZE, lambda i_unused, j_unused: Page())
+
+ game.state.planets = [] # Planet information
+ game.state.baseq = [] # Base quadrant coordinates
+ game.state.kcmdr = [] # Commander quadrant coordinates
+ game.statekscmdr = Coord() # Supercommander quadrant coordinates
+
# Starchart is functional but we've never seen it
game.lastchart = FOREVER
# Put stars in the galaxy
w = randplace(GALSIZE)
if game.state.galaxy[w.i][w.j].planet == None:
break
- new = planet()
+ new = Planet()
new.quadrant = w
new.crystals = "absent"
if (game.options & OPTION_WORLDS) and i < NINHAB:
if game.state.nscrem:
prout(_(" YOU'LL NEED IT."))
waitfor()
+ clrscr()
+ setwnd(message_window)
newqad()
if len(game.enemies) - (thing == game.quadrant) - (game.tholian != None):
game.shldup = True
game.tourn = game.length = 0
game.thawed = False
game.skill = SKILL_NONE
- if not scanner.inqueue: # Can start with command line options
- proutn(_("Would you like a regular, tournament, or saved game? "))
+ scanner.chew()
+# if not scanner.inqueue: # Can start with command line options
+ proutn(_("Would you like a regular, tournament, or saved game? "))
scanner.next()
if scanner.sees("tournament"):
while scanner.next() == "IHEOL":
return True
if scanner.sees("regular"):
break
- proutn(_("What is \"%s\"?") % scanner.token)
+ proutn(_("What is \"%s\"? ") % scanner.token)
scanner.chew()
while game.length==0 or game.skill==SKILL_NONE:
if scanner.next() == "IHALPHA":
def newkling():
"Drop new Klingon into current quadrant."
- return enemy('K', loc=dropin(), power=randreal(300,450)+25.0*game.skill)
+ return Enemy('K', loc=dropin(), power=randreal(300,450)+25.0*game.skill)
+
+def sortenemies():
+ "Sort enemies by distance so 'nearest' is meaningful."
+ game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
def newqad():
"Set up a new state of quadrant, for when we enter or re-enter it."
game.iscate = (game.state.remkl > 1)
# Put in Romulans if needed
for i in range(q.romulans):
- enemy('R', loc=dropin(), power=randreal(400.0,850.0)+50.0*game.skill)
+ 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('B')
prout(_("LEAVE AT ONCE, OR YOU WILL BE DESTROYED!"))
# Put in THING if needed
if thing == game.quadrant:
- enemy(type='?', loc=dropin(),
+ Enemy(type='?', loc=dropin(),
power=randreal(6000,6500.0)+250.0*game.skill)
if not damaged(DSRSENS):
skip(1)
if (game.skill < SKILL_GOOD and withprob(0.02)) or \
(game.skill == SKILL_GOOD and withprob(0.05)) or \
(game.skill > SKILL_GOOD and withprob(0.08)):
- w = coord()
+ w = Coord()
while True:
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='T', 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]=='.':
game.quad[QUADSIZE-1][0] = 'X'
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))
+ sortenemies()
# And finally the stars
for i in range(q.stars):
dropin('*')
# Code from sst.c begins here
-commands = {
- "SRSCAN": OPTION_TTY,
- "STATUS": OPTION_TTY,
- "REQUEST": OPTION_TTY,
- "LRSCAN": OPTION_TTY,
- "PHASERS": 0,
- "TORPEDO": 0,
- "PHOTONS": 0,
- "MOVE": 0,
- "SHIELDS": 0,
- "DOCK": 0,
- "DAMAGES": 0,
- "CHART": 0,
- "IMPULSE": 0,
- "REST": 0,
- "WARP": 0,
- "SCORE": 0,
- "SENSORS": OPTION_PLANETS,
- "ORBIT": OPTION_PLANETS,
- "TRANSPORT": OPTION_PLANETS,
- "MINE": OPTION_PLANETS,
- "CRYSTALS": OPTION_PLANETS,
- "SHUTTLE": OPTION_PLANETS,
- "PLANETS": OPTION_PLANETS,
- "REPORT": 0,
- "COMPUTER": 0,
- "COMMANDS": 0,
- "EMEXIT": 0,
- "PROBE": OPTION_PROBE,
- "SAVE": 0,
- "FREEZE": 0, # Synonym for SAVE
- "ABANDON": 0,
- "DESTRUCT": 0,
- "DEATHRAY": 0,
- "DEBUG": 0,
- "MAYDAY": 0,
- "SOS": 0, # Synonym for MAYDAY
- "CALL": 0, # Synonym for MAYDAY
- "QUIT": 0,
- "HELP": 0,
-}
+commands = [
+ ("SRSCAN", OPTION_TTY),
+ ("STATUS", OPTION_TTY),
+ ("REQUEST", OPTION_TTY),
+ ("LRSCAN", OPTION_TTY),
+ ("PHASERS", 0),
+ ("TORPEDO", 0),
+ ("PHOTONS", 0),
+ ("MOVE", 0),
+ ("SHIELDS", 0),
+ ("DOCK", 0),
+ ("DAMAGES", 0),
+ ("CHART", 0),
+ ("IMPULSE", 0),
+ ("REST", 0),
+ ("WARP", 0),
+ ("SCORE", 0),
+ ("SENSORS", OPTION_PLANETS),
+ ("ORBIT", OPTION_PLANETS),
+ ("TRANSPORT", OPTION_PLANETS),
+ ("MINE", OPTION_PLANETS),
+ ("CRYSTALS", OPTION_PLANETS),
+ ("SHUTTLE", OPTION_PLANETS),
+ ("PLANETS", OPTION_PLANETS),
+ ("REPORT", 0),
+ ("COMPUTER", 0),
+ ("COMMANDS", 0),
+ ("EMEXIT", 0),
+ ("PROBE", OPTION_PROBE),
+ ("SAVE", 0),
+ ("FREEZE", 0), # Synonym for SAVE
+ ("ABANDON", 0),
+ ("DESTRUCT", 0),
+ ("DEATHRAY", 0),
+ ("DEBUG", 0),
+ ("MAYDAY", 0),
+ ("SOS", 0), # Synonym for MAYDAY
+ ("CALL", 0), # Synonym for MAYDAY
+ ("QUIT", 0),
+ ("HELP", 0),
+ ("", 0),
+]
def listCommands():
"Generate a list of legal commands."
prout(_("LEGAL COMMANDS ARE:"))
emitted = 0
- for key in commands:
- if not commands[key] or (commands[key] & game.options):
+ for (key, opt) in commands:
+ if not opt or (opt & game.options):
proutn("%-12s " % key)
emitted += 1
if emitted % 5 == 4:
setwnd(message_window)
if key == "IHEOL":
return
- if scanner.token.upper() in commands or scanner.token == "ABBREV":
+ cmds = map(lambda x: x[0], commands)
+ if scanner.token.upper() in cmds or scanner.token.upper() == "ABBREV":
break
skip(1)
listCommands()
def makemoves():
"Command-interpretation loop."
- clrscr()
- setwnd(message_window)
while True: # command loop
drawmaps(1)
while True: # get a command
clrscr()
setwnd(message_window)
clrscr()
- candidates = filter(lambda x: x.startswith(scanner.token.upper()),
- commands)
- if len(candidates) == 1:
- cmd = candidates[0]
- break
- elif candidates and not (game.options & OPTION_PLAIN):
- prout("Commands with prefix '%s': %s" % (scanner.token, " ".join(candidates)))
- else:
+ abandon_passed = False
+ for (cmd, opt) in commands:
+ # commands after ABANDON cannot be abbreviated
+ if cmd == "ABANDON":
+ abandon_passed = True
+ if cmd == scanner.token.upper() or (not abandon_passed \
+ and cmd.startswith(scanner.token.upper())):
+ break
+ if cmd == "":
listCommands()
continue
+ else:
+ break
if cmd == "SRSCAN": # srscan
srscan()
elif cmd == "STATUS": # status
def randplace(size):
"Choose a random location."
- w = coord()
+ w = Coord()
w.i = randrange(size)
w.j = randrange(size)
return w
# Round token value to nearest integer
return int(round(scanner.real))
def getcoord(self):
- s = coord()
+ s = Coord()
scanner.next()
if scanner.type != "IHREAL":
huh()
game.damage[i] = 10.0
proutn("Examine/change events? ")
if ja():
- ev = event()
- w = coord()
+ ev = Event()
+ w = Coord()
legends = {
FSNOVA: "Supernova ",
FTBEAM: "T Beam ",
try:
global line, thing, game
game = None
- thing = coord()
- thing.angry = False
- game = gamestate()
+ thing = Thingy()
+ game = Gamestate()
game.options = OPTION_ALL &~ (OPTION_IOMODES | OPTION_PLAIN | OPTION_ALMY)
if os.getenv("TERM"):
game.options |= OPTION_CURSES
raise SystemExit, 1
try:
line = replayfp.readline().strip()
- (leader, key, seed) = line.split()
+ (leader, __, seed) = line.split()
seed = eval(seed)
sys.stderr.write("sst2k: seed set to %s\n" % seed)
line = replayfp.readline().strip()
if logfp:
logfp.close()
print ""
+
+# End.
projects / super-star-trek.git / blobdiff