#!/usr/bin/env python
"""
-sst.py =-- Super Star Trek in Python
-
-This code is a Python translation of a C translation of a FORTRAN
-original dating back to 1973. Beautiful Python it is not. But it
-works.
-
-Dave Matuszek says:
-
-SRSCAN, MOVE, PHASERS, CALL, STATUS, IMPULSE, PHOTONS, ABANDON,
-LRSCAN, WARP, SHIELDS, DESTRUCT, CHART, REST, DOCK, QUIT, and DAMAGE
-were in the original non-"super" version of UT FORTRAN Star Trek.
-
-Tholians were not in the original. Dave is dubious about their merits.
-(They are now controlled by OPTION_THOLIAN and turned off if the game
-type is "plain".)
-
-Planets and dilithium crystals were not in the original. Dave is OK
-with this idea. (It's now controlled by OPTION_PLANETS and turned
-off if the game type is "plain".)
+sst.py -- Super Star Trek 2K
-Dave says the bit about the Galileo getting turned into a
-McDonald's is "consistant with our original vision". (This has been
-left permanently enabled, as it can only happen if OPTION_PLANETS
-is on.)
+SST2K is a Python translation of a C translation of a FORTRAN
+original dating back to 1973. Beautiful Python it is not, but it
+works. Translation by Eric S. Raymond; original game by David Matuszek
+and Paul Reynolds, with modifications by Don Smith, Tom Almy,
+Stas Sergeev, and Eric S. Raymond.
-Dave also says the Space Thingy should not be preserved across saved
-games, so you can't prove to others that you've seen it. He says it
-shouldn't fire back, either. It should do nothing except scream and
-disappear when hit by photon torpedos. It's OK that it may move
-when attacked, but it didn't in the original. (Whether the Thingy
-can fire back is now controlled by OPTION_THINGY and turned off if the
-game type is "plain" or "almy". The no-save behavior has been restored.)
-
-The Faerie Queen, black holes, and time warping were in the original.
-
-Here are Tom Almy's changes:
-
-In early 1997, I got the bright idea to look for references to
-"Super Star Trek" on the World Wide Web. There weren't many hits,
-but there was one that came up with 1979 Fortran sources! This
-version had a few additional features that mine didn't have,
-however mine had some feature it didn't have. So I merged its
-features that I liked. I also took a peek at the DECUS version (a
-port, less sources, to the PDP-10), and some other variations.
-
-1, Compared to the original UT version, I've changed the "help"
-command to "call" and the "terminate" command to "quit" to better
-match user expectations. The DECUS version apparently made those
-changes as well as changing "freeze" to "save". However I like
-"freeze". (Both "freeze" and "save" work in SST2K.)
-
-2. The experimental deathray originally had only a 5% chance of
-success, but could be used repeatedly. I guess after a couple
-years of use, it was less "experimental" because the 1979
-version had a 70% success rate. However it was prone to breaking
-after use. I upgraded the deathray, but kept the original set of
-failure modes (great humor!). (Now controlled by OPTION_DEATHRAY
-and turned off if game type is "plain".)
-
-3. The 1979 version also mentions srscan and lrscan working when
-docked (using the starbase's scanners), so I made some changes here
-to do this (and indicating that fact to the player), and then realized
-the base would have a subspace radio as well -- doing a Chart when docked
-updates the star chart, and all radio reports will be heard. The Dock
-command will also give a report if a base is under attack.
-
-4. Tholian Web from the 1979 version. (Now controlled by
-OPTION_THOLIAN and turned off if game type is "plain".)
-
-5. Enemies can ram the Enterprise. (Now controlled by OPTION_RAMMING
-and turned off if game type is "plain".)
-
-6. Regular Klingons and Romulans can move in Expert and Emeritus games.
-This code could use improvement. (Now controlled by OPTION_MVBADDY
-and turned off if game type is "plain".)
-
-7. The deep-space probe feature from the DECUS version. (Now controlled
-by OPTION_PROBE and turned off if game type is "plain").
-
-8. 'emexit' command from the 1979 version.
-
-9. Bugfix: Klingon commander movements are no longer reported if long-range
-sensors are damaged.
-
-10. Bugfix: Better base positioning at startup (more spread out).
-That made sense to add because most people abort games with
-bad base placement.
-
-In June 2002, I fixed two known bugs and a documentation typo.
-In June 2004 I fixed a number of bugs involving: 1) parsing invalid
-numbers, 2) manual phasers when SR scan is damaged and commander is
-present, 3) time warping into the future, 4) hang when moving
-klingons in crowded quadrants. (These fixes are in SST2K.)
-
-Here are Stas Sergeev's changes:
-
-1. The Space Thingy can be shoved, if you ram it, and can fire back if
-fired upon. (Now controlled by OPTION_THINGY and turned off if game
-type is "plain" or "almy".)
-
-2. When you are docked, base covers you with an almost invincible shield.
-(A commander can still ram you, or a Romulan can destroy the base,
-or a SCom can even succeed with direct attack IIRC, but this rarely
-happens.) (Now controlled by OPTION_BASE and turned off if game
-type is "plain" or "almy".)
-
-3. Ramming a black hole is no longer instant death. There is a
-chance you might get timewarped instead. (Now controlled by
-OPTION_BLKHOLE and turned off if game type is "plain" or "almy".)
-
-4. The Tholian can be hit with phasers.
-
-5. SCom can't escape from you if no more enemies remain
-(without this, chasing SCom can take an eternity).
-
-6. Probe target you enter is now the destination quadrant. Before I don't
-remember what it was, but it was something I had difficulty using.
-
-7. Secret password is now autogenerated.
-
-8. "Plaque" is adjusted for A4 paper :-)
-
-9. Phasers now tells you how much energy needed, but only if the computer
-is alive.
-
-10. Planets are auto-scanned when you enter the quadrant.
-
-11. Mining or using crystals in presense of enemy now yields an attack.
-There are other minor adjustments to what yields an attack
-and what does not.
-
-12. "freeze" command reverts to "save", most people will understand this
-better anyway. (SST2K recognizes both.)
-
-13. Screen-oriented interface, with sensor scans always up. (SST2K
-supports both screen-oriented and TTY modes.)
-
-Eric Raymond's changes:
-
-Mainly, I translated this C code out of FORTRAN into C -- created #defines
-for a lot of magic numbers and refactored the heck out of it.
-
-1. "sos" and "call" becomes "mayday", "freeze" and "save" are both good.
-
-2. Status report now indicates when dilithium crystals are on board.
-
-3. Per Dave Matuszek's remarks, Thingy state is never saved across games.
-
-4. Added game option selection so you can play a close (but not bug-for-
-bug identical) approximation of older versions.
-
-5. Half the quadrants now have inhabited planets, from which one
-cannot mine dilithium (there will still be the same additional number
-of dilithium-bearing planets). Torpedoing an inhabited world is *bad*.
-There is BSD-Trek-like logic for Klingons to attack and enslave
-inhabited worlds, producing more ships (only is skill is 'good' or
-better). (Controlled by OPTION_WORLDS and turned off if game
-type is "plain" or "almy".)
-
-6. User input is now logged so we can do regression testing.
-
-7. More BSD-Trek features: You can now lose if your entire crew
-dies in battle. When abandoning ship in a game with inhabited
-worlds enabled, they must have one in the quadrant to beam down
-to; otherwise they die in space and this counts heavily against
-your score. Docking at a starbase replenishes your crew.
-
-8. Still more BSD-Trek: we now have a weighted damage table.
-Also, the nav subsystem (enabling automatic course
-setting) can be damaged separately from the main computer (which
-handles weapons targeting, ETA calculation, and self-destruct).
-
-After these features were added, I translated this into Python and added
-more:
-
-9. A long-range scan is done silently whenever you call CHART; thus
-the LRSCAN command is no longer needed. (Controlled by OPTION_AUTOSCAN
-and turned off if game type is "plain" or "almy".)
+See the doc/HACKING file in the distribution for designers notes and advice
+ion how to modify (and how not to modify!) this code.
"""
-import os, sys, math, curses, time, readline, cPickle, random, copy, gettext
+import os, sys, math, curses, time, readline, cPickle, random, copy, gettext, getpass
SSTDOC = "/usr/share/doc/sst/sst.doc"
DOC_NAME = "sst.doc"
def _(str): return gettext.gettext(str)
-PHASEFAC = 2.0
-GALSIZE = 8
-NINHAB = (GALSIZE * GALSIZE / 2)
-MAXUNINHAB = 10
-PLNETMAX = (NINHAB + MAXUNINHAB)
-QUADSIZE = 10
-BASEMIN = 2
-BASEMAX = (GALSIZE * GALSIZE / 12)
-MAXKLGAME = 127
-MAXKLQUAD = 9
-FULLCREW = 428 # BSD Trek was 387, that's wrong
-FOREVER = 1e30
-MAXBURST = 3
-MINCMDR = 10
-
-# How to represent features
-IHR = 'R',
-IHK = 'K',
-IHC = 'C',
-IHS = 'S',
-IHSTAR = '*',
-IHP = 'P',
-IHW = '@',
-IHB = 'B',
-IHBLANK = ' ',
-IHDOT = '.',
-IHQUEST = '?',
-IHE = 'E',
-IHF = 'F',
-IHT = 'T',
-IHWEB = '#',
-IHMATER0 = '-',
-IHMATER1 = 'o',
-IHMATER2 = '0'
+GALSIZE = 8 # Galaxy size in quadrants
+NINHAB = (GALSIZE * GALSIZE / 2) # Number of inhabited worlds
+MAXUNINHAB = 10 # Maximum uninhabited worlds
+QUADSIZE = 10 # Quadrant size in sectors
+BASEMIN = 2 # Minimum starbases
+BASEMAX = (GALSIZE * GALSIZE / 12) # Maximum starbases
+MAXKLGAME = 127 # Maximum Klingons per game
+MAXKLQUAD = 9 # Maximum Klingons per quadrant
+FULLCREW = 428 # Crew size. BSD Trek was 387, that's wrong
+FOREVER = 1e30 # Time for the indefinite future
+MAXBURST = 3 # Max # of torps you can launch in one turn
+MINCMDR = 10 # Minimum number of Klingon commanders
+DOCKFAC = 0.25 # Repair faster when docked
+PHASEFAC = 2.0 # Unclear what this is, it was in the C version
class TrekError:
pass
def distance(self, other=None):
if not other: other = coord(0, 0)
return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
- def bearing(self, other=None):
- if not other: other = coord(0, 0)
- return 1.90985*math.atan2(self.j-other.j, self.i-other.i)
+ def bearing(self):
+ return 1.90985*math.atan2(self.j, self.i)
def sgn(self):
s = coord()
if self.i == 0:
FREPRO = 11 # Klingons build a ship in an enslaved system
NEVENTS = 12
-#
-# abstract out the event handling -- underlying data structures will change
-# when we implement stateful events
-#
+# Abstract out the event handling -- underlying data structures will change
+# when we implement stateful events
def findevent(evtype): return game.future[evtype]
class enemy:
def __init__(self, type=None, loc=None, power=None):
self.type = type
- self.kloc = coord()
+ self.location = coord()
if loc:
self.move(loc)
- self.kpower = power # enemy energy level
+ self.power = power # enemy energy level
game.enemies.append(self)
def move(self, loc):
- motion = (loc != self.kloc)
- if self.kloc.i is not None and self.kloc.j is not None:
+ motion = (loc != self.location)
+ if self.location.i is not None and self.location.j is not None:
if motion:
- if self.type == IHT:
- game.quad[self.kloc.i][self.kloc.j] = IHWEB
+ if self.type == 'T':
+ game.quad[self.location.i][self.location.j] = '#'
else:
- game.quad[self.kloc.i][self.kloc.j] = IHDOT
+ game.quad[self.location.i][self.location.j] = '.'
if loc:
- self.kloc = copy.copy(loc)
- game.quad[self.kloc.i][self.kloc.j] = self.type
+ self.location = copy.copy(loc)
+ game.quad[self.location.i][self.location.j] = self.type
self.kdist = self.kavgd = (game.sector - loc).distance()
else:
- self.kloc = coord()
+ self.location = coord()
self.kdist = self.kavgd = None
game.enemies.remove(self)
return motion
def __repr__(self):
- return "<%s,%s.%f>" % (self.type, self.kloc, self.kpower) # For debugging
+ return "<%s,%s.%f>" % (self.type, self.location, self.power) # For debugging
class gamestate:
def __init__(self):
self.energy = 0.0 # energy level
self.shield = 0.0 # shield level
self.warpfac = 0.0 # warp speed
- self.wfacsq = 0.0 # squared warp factor
self.lsupres = 0.0 # life support reserves
self.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
# if the only remaining klingon is SCOM.
game.state.remtime = game.state.remres/(game.state.remkl + 4*len(game.state.kcmdr))
-IHR = 'R'
-IHK = 'K'
-IHC = 'C'
-IHS = 'S'
-IHSTAR = '*'
-IHP = 'P'
-IHW = '@'
-IHB = 'B'
-IHBLANK = ' '
-IHDOT = '.'
-IHQUEST = '?'
-IHE = 'E'
-IHF = 'F'
-IHT = 'T'
-IHWEB = '#'
-IHMATER0 = '-'
-IHMATER1 = 'o'
-IHMATER2 = '0'
-
FWON = 0
FDEPLETE = 1
FLIFESUP = 2
FCREW = 21
def withprob(p):
- v = random.random()
- #logfp.write("# withprob(%s) -> %f (%s) at %s\n" % (p, v, v<p, traceback.extract_stack()[-2][1:]))
- return v < p
+ return random.random() < p
def randrange(*args):
- v = random.randrange(*args)
- #logfp.write("# randrange%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
- return v
+ return random.randrange(*args)
def randreal(*args):
v = random.random()
if len(args) == 1:
- v *= args[0] # returns from [0, args[0])
+ v *= args[0] # from [0, args[0])
elif len(args) == 2:
- v = args[0] + v*(args[1]-args[0]) # returns from [args[0], args[1])
- #logfp.write("# randreal%s -> %s at %s\n" % (args, v, traceback.extract_stack()[-2][1:]))
+ v = args[0] + v*(args[1]-args[0]) # from [args[0], args[1])
return v
# Code from ai.c begins here
iq.j = game.quadrant.j+(look.j+(QUADSIZE-1))/QUADSIZE - 1
if not welcoming(iq):
return False;
- if enemy.type == IHR:
+ if enemy.type == 'R':
return False; # Romulans cannot escape!
if not irun:
# avoid intruding on another commander's territory
- if enemy.type == IHC:
+ if enemy.type == 'C':
if iq in game.state.kcmdr:
return False
# refuse to leave if currently attacking starbase
if game.battle == game.quadrant:
return False
# don't leave if over 1000 units of energy
- if enemy.kpower > 1000.0:
+ if enemy.power > 1000.0:
return False
# emit escape message and move out of quadrant.
# we know this if either short or long range sensors are working
if not damaged(DSRSENS) or not damaged(DLRSENS) or \
game.condition == "docked":
- prout(crmena(True, enemy.type, "sector", enemy.kloc) + \
+ prout(crmena(True, enemy.type, "sector", enemy.location) + \
(_(" escapes to Quadrant %s (and regains strength).") % q))
# handle local matters related to escape
enemy.move(None)
# 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==IHS:
+ if enemy.type=='S':
game.iscate = False
game.ientesc = False
game.isatb = 0
dist1 = enemy.kdist
mdist = int(dist1 + 0.5); # Nearest integer distance
# If SC, check with spy to see if should hi-tail it
- if enemy.type==IHS and \
- (enemy.kpower <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
+ if enemy.type=='S' and \
+ (enemy.power <= 500.0 or (game.condition=="docked" and not damaged(DPHOTON))):
irun = True
motion = -QUADSIZE
else:
# decide whether to advance, retreat, or hold position
- forces = enemy.kpower+100.0*len(game.enemies)+400*(nbaddys-1)
+ forces = enemy.power+100.0*len(game.enemies)+400*(nbaddys-1)
if not game.shldup:
forces += 1000; # Good for enemy if shield is down!
if not damaged(DPHASER) or not damaged(DPHOTON):
if idebug:
proutn("NSTEPS = %d:" % nsteps)
# Compute preferred values of delta X and Y
- m = game.sector - enemy.kloc
+ m = game.sector - enemy.location
if 2.0 * abs(m.i) < abs(m.j):
m.i = 0
- if 2.0 * abs(m.j) < abs(game.sector.i-enemy.kloc.i):
+ if 2.0 * abs(m.j) < abs(game.sector.i-enemy.location.i):
m.j = 0
m = (motion * m).sgn()
- next = enemy.kloc
+ next = enemy.location
# main move loop
for ll in range(nsteps):
if idebug:
break
look.j = next.j + krawlj
krawlj = -krawlj
- elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != IHDOT:
+ elif (game.options & OPTION_RAMMING) and game.quad[look.i][look.j] != '.':
# See if enemy should ram ship
if game.quad[look.i][look.j] == game.ship and \
- (enemy.type == IHC or enemy.type == IHS):
+ (enemy.type == 'C' or enemy.type == 'S'):
collision(rammed=True, enemy=enemy)
return
if krawli != m.i and m.j != 0:
skip(1)
if enemy.move(next):
if not damaged(DSRSENS) or game.condition == "docked":
- proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.kloc))
+ proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.location))
if enemy.kdist < dist1:
proutn(_(" advances to "))
else:
# and do move
if game.quadrant in game.state.kcmdr:
for enemy in game.enemies:
- if enemy.type == IHC:
+ if enemy.type == 'C':
movebaddy(enemy)
if game.state.kscmdr==game.quadrant:
for enemy in game.enemies:
- if enemy.type == IHS:
+ if enemy.type == 'S':
movebaddy(enemy)
break
# If skill level is high, move other Klingons and Romulans too!
# commander(s) do.
if game.skill >= SKILL_EXPERT and (game.options & OPTION_MVBADDY):
for enemy in game.enemies:
- if enemy.type in (IHK, IHR):
+ if enemy.type in ('K', 'R'):
movebaddy(enemy)
game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
game.ientesc = False
unschedule(FSCDBAS)
for enemy in game.enemies:
- if enemy.type == IHS:
+ if enemy.type == 'S':
break
enemy.move(None)
game.klhere -= 1
if not game.tholian or game.justin:
return
id = coord()
- if game.tholian.kloc.i == 0 and game.tholian.kloc.j == 0:
+ if game.tholian.location.i == 0 and game.tholian.location.j == 0:
id.i = 0; id.j = QUADSIZE-1
- elif game.tholian.kloc.i == 0 and game.tholian.kloc.j == QUADSIZE-1:
+ elif game.tholian.location.i == 0 and game.tholian.location.j == QUADSIZE-1:
id.i = QUADSIZE-1; id.j = QUADSIZE-1
- elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == QUADSIZE-1:
+ elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == QUADSIZE-1:
id.i = QUADSIZE-1; id.j = 0
- elif game.tholian.kloc.i == QUADSIZE-1 and game.tholian.kloc.j == 0:
+ elif game.tholian.location.i == QUADSIZE-1 and game.tholian.location.j == 0:
id.i = 0; id.j = 0
else:
# something is wrong!
prout("***Internal error: Tholian in a bad spot.")
return
# do nothing if we are blocked
- if game.quad[id.i][id.j] not in (IHDOT, IHWEB):
+ if game.quad[id.i][id.j] not in ('.', '#'):
return
- here = copy.copy(game.tholian.kloc)
- delta = (id - game.tholian.kloc).sgn()
+ here = copy.copy(game.tholian.location)
+ delta = (id - game.tholian.location).sgn()
# move in x axis
while here.i != id.i:
here.i += delta.i
- if game.quad[here.i][here.j]==IHDOT:
+ if game.quad[here.i][here.j]=='.':
game.tholian.move(here)
# move in y axis
while here.j != id.j:
here.j += delta.j
- if game.quad[here.i][here.j]==IHDOT:
+ if game.quad[here.i][here.j]=='.':
game.tholian.move(here)
# check to see if all holes plugged
for i in range(QUADSIZE):
- if game.quad[0][i]!=IHWEB and game.quad[0][i]!=IHT:
+ if game.quad[0][i]!='#' and game.quad[0][i]!='T':
return
- if game.quad[QUADSIZE-1][i]!=IHWEB and game.quad[QUADSIZE-1][i]!=IHT:
+ if game.quad[QUADSIZE-1][i]!='#' and game.quad[QUADSIZE-1][i]!='T':
return
- if game.quad[i][0]!=IHWEB and game.quad[i][0]!=IHT:
+ if game.quad[i][0]!='#' and game.quad[i][0]!='T':
return
- if game.quad[i][QUADSIZE-1]!=IHWEB and game.quad[i][QUADSIZE-1]!=IHT:
+ if game.quad[i][QUADSIZE-1]!='#' and game.quad[i][QUADSIZE-1]!='T':
return
# All plugged up -- Tholian splits
- game.quad[game.tholian.kloc.i][game.tholian.kloc.j]=IHWEB
- dropin(IHBLANK)
- prout(crmena(True, IHT, "sector", game.tholian) + _(" completes web."))
+ game.quad[game.tholian.location.i][game.tholian.location.j]='#'
+ dropin(' ')
+ prout(crmena(True, 'T', "sector", game.tholian) + _(" completes web."))
game.tholian.move(None)
return
def randdevice():
"Choose a device to damage, at random."
- # Quoth Eric Allman in the code of BSD-Trek:
- # "Under certain conditions you can get a critical hit. This
- # sort of hit damages devices. The probability that a given
- # device is damaged depends on the device. Well protected
- # devices (such as the computer, which is in the core of the
- # ship and has considerable redundancy) almost never get
- # damaged, whereas devices which are exposed (such as the
- # warp engines) or which are particularly delicate (such as
- # the transporter) have a much higher probability of being
- # damaged."
- #
- # This is one place where OPTION_PLAIN does not restore the
- # original behavior, which was equiprobable damage across
- # all devices. If we wanted that, we'd return randrange(NDEVICES)
- # and have done with it. Also, in the original game, DNAVYS
- # and DCOMPTR were the same device.
- #
- # Instead, we use a table of weights similar to the one from BSD Trek.
- # BSD doesn't have the shuttle, shield controller, death ray, or probes.
- # We don't have a cloaking device. The shuttle got the allocation
- # for the cloaking device, then we shaved a half-percent off
- # everything to have some weight to give DSHCTRL/DDRAY/DDSP.
weights = (
105, # DSRSENS: short range scanners 10.5%
105, # DLRSENS: long range scanners 10.5%
120, # DPHASER: phasers 12.0%
120, # DPHOTON: photon torpedoes 12.0%
- 25, # DLIFSUP: life support 2.5%
+ 25, # DLIFSUP: life support 2.5%
65, # DWARPEN: warp drive 6.5%
70, # DIMPULS: impulse engines 6.5%
145, # DSHIELD: deflector shields 14.5%
skip(2)
proutn("***")
proutn(crmshp())
- hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0)
+ hardness = {'R':1.5, 'C':2.0, 'S':2.5, 'T':0.5, '?':4.0}.get(enemy.type, 1.0)
if rammed:
proutn(_(" rammed by "))
else:
proutn(_(" rams "))
- proutn(crmena(False, enemy.type, "sector", enemy.kloc))
+ proutn(crmena(False, enemy.type, "sector", enemy.location))
if rammed:
proutn(_(" (original position)"))
skip(1)
- deadkl(enemy.kloc, enemy.type, game.sector)
+ deadkl(enemy.location, enemy.type, game.sector)
proutn("***" + crmship() + " heavily damaged.")
icas = randrange(10, 30)
prout(_("***Sickbay reports %d casualties"), icas)
# Loop to move a single torpedo
setwnd(message_window)
for step in range(1, QUADSIZE*2):
- track.next()
+ 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==IHDOT:
+ if iquad=='.':
continue
# hit something
if not damaged(DSRSENS) or game.condition == "docked":
skip(1); # start new line after text track
- if iquad in (IHE, IHF): # Hit our ship
+ if iquad in ('E', 'F'): # Hit our ship
skip(1)
prout(_("Torpedo hits %s.") % crmshp())
hit = 700.0 + randreal(100) - \
newcnd(); # we're blown out of dock
if game.landed or game.condition=="docked":
return hit # Cheat if on a planet
- 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
- bumpto.i = int(w.i+xx+0.5)
- bumpto.j = int(w.j+yy+0.5)
+ # In the C/FORTRAN version, dispersion was 2.5 radians, which
+ # is 143 degrees, which is almost exactly 4.8 clockface units
+ displacement = course(track.bearing+randreal(-2.4,2.4), distance=2**0.5)
+ displacement.next()
+ bumpto = displacement.sector()
if not bumpto.valid_sector():
return hit
- if game.quad[bumpto.i][bumpto.j]==IHBLANK:
+ if game.quad[bumpto.i][bumpto.j]==' ':
finish(FHOLE)
return hit
- if game.quad[bumpto.i][bumpto.j]!=IHDOT:
+ 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]=IHDOT
+ 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.kloc).distance()
+ enemy.kdist = enemy.kavgd = (game.sector-enemy.location).distance()
game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
return None
- elif iquad in (IHC, IHS, IHR, IHK): # Hit a regular enemy
+ elif iquad in ('C', 'S', 'R', 'K'): # Hit a regular enemy
# find the enemy
- if iquad in (IHC, IHS) and withprob(0.05):
+ if iquad in ('C', 'S') and withprob(0.05):
prout(crmena(True, iquad, "sector", w) + _(" uses anti-photon device;"))
prout(_(" torpedo neutralized."))
return None
for enemy in game.enemies:
- if w == enemy.kloc:
+ if w == enemy.location:
break
- kp = math.fabs(enemy.kpower)
+ kp = math.fabs(enemy.power)
h1 = 700.0 + randrange(100) - \
1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
h1 = math.fabs(h1)
if kp < h1:
h1 = kp
- if enemy.kpower < 0:
- enemy.kpower -= -h1
+ if enemy.power < 0:
+ enemy.power -= -h1
else:
- enemy.kpower -= h1
- if enemy.kpower == 0:
+ enemy.power -= h1
+ if enemy.power == 0:
deadkl(w, iquad, w)
return None
proutn(crmena(True, iquad, "sector", w))
- # If enemy damaged but not destroyed, try to displace
- 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
- bumpto.i = int(w.i+xx+0.5)
- bumpto.j = int(w.j+yy+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():
prout(_(" damaged but not destroyed."))
return
- if game.quad[bumpto.i][bumpto.j] == IHBLANK:
+ if game.quad[bumpto.i][bumpto.j] == ' ':
prout(_(" buffeted into black hole."))
deadkl(w, iquad, bumpto)
- if game.quad[bumpto.i][bumpto.j] != IHDOT:
+ if game.quad[bumpto.i][bumpto.j] != '.':
prout(_(" damaged but not destroyed."))
else:
prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
- enemy.kloc = bumpto
- game.quad[w.i][w.j]=IHDOT
+ enemy.location = bumpto
+ game.quad[w.i][w.j]='.'
game.quad[bumpto.i][bumpto.j]=iquad
for enemy in game.enemies:
- enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
+ enemy.kdist = enemy.kavgd = (game.sector-enemy.location).distance()
game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
return None
- elif iquad == IHB: # Hit a base
+ 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]=IHDOT
+ 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
game.state.basekl += 1
newcnd()
return None
- elif iquad == IHP: # Hit a planet
+ elif iquad == 'P': # Hit a planet
prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
game.state.nplankl += 1
game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
game.iplnet.pclass = "destroyed"
game.iplnet = None
game.plnet.invalidate()
- game.quad[w.i][w.j] = IHDOT
+ game.quad[w.i][w.j] = '.'
if game.landed:
# captain perishes on planet
finish(FDPLANET)
return None
- elif iquad == IHW: # Hit an inhabited world -- very bad!
+ elif iquad == '@': # Hit an inhabited world -- very bad!
prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
game.state.nworldkl += 1
game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
game.iplnet.pclass = "destroyed"
game.iplnet = None
game.plnet.invalidate()
- game.quad[w.i][w.j] = IHDOT
+ game.quad[w.i][w.j] = '.'
if game.landed:
# captain perishes on planet
finish(FDPLANET)
- prout(_("You have just destroyed an inhabited planet."))
- prout(_("Celebratory rallies are being held on the Klingon homeworld."))
+ prout(_("The torpedo destroyed an inhabited planet."))
return None
- elif iquad == IHSTAR: # Hit a star
+ elif iquad == '*': # Hit a star
if withprob(0.9):
nova(w)
else:
- prout(crmena(True, IHSTAR, "sector", w) + _(" unaffected by photon blast."))
+ prout(crmena(True, '*', "sector", w) + _(" unaffected by photon blast."))
return None
- elif iquad == IHQUEST: # Hit a thingy
+ elif iquad == '?': # Hit a thingy
if not (game.options & OPTION_THINGY) or withprob(0.3):
skip(1)
prouts(_("AAAAIIIIEEEEEEEEAAAAAAAAUUUUUGGGGGHHHHHHHHHHHH!!!"))
thing.angry = True
shoved = True
return None
- elif iquad == IHBLANK: # Black hole
+ elif iquad == ' ': # Black hole
skip(1)
- prout(crmena(True, IHBLANK, "sector", w) + _(" swallows torpedo."))
+ prout(crmena(True, ' ', "sector", w) + _(" swallows torpedo."))
return None
- elif iquad == IHWEB: # hit the web
+ elif iquad == '#': # hit the web
skip(1)
prout(_("***Torpedo absorbed by Tholian web."))
return None
- elif iquad == IHT: # Hit a Tholian
+ elif iquad == 'T': # Hit a Tholian
h1 = 700.0 + randrange(100) - \
1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
h1 = math.fabs(h1)
if h1 >= 600:
- game.quad[w.i][w.j] = IHDOT
+ game.quad[w.i][w.j] = '.'
deadkl(w, iquad, w)
game.tholian = None
return None
skip(1)
- proutn(crmena(True, IHT, "sector", w))
+ proutn(crmena(True, 'T', "sector", w))
if withprob(0.05):
prout(_(" survives photon blast."))
return None
prout(_(" disappears."))
game.tholian.move(None)
- game.quad[w.i][w.j] = IHWEB
- dropin(IHBLANK)
+ game.quad[w.i][w.j] = '#'
+ dropin(' ')
return None
else: # Problem!
skip(1)
if game.skill <= SKILL_FAIR:
where = "sector"
for enemy in game.enemies:
- if enemy.kpower < 0:
+ if enemy.power < 0:
continue; # too weak to attack
# compute hit strength and diminish shield power
r = randreal()
# Increase chance of photon torpedos if docked or enemy energy is low
if game.condition == "docked":
r *= 0.25
- if enemy.kpower < 500:
+ if enemy.power < 500:
r *= 0.25;
- if enemy.type==IHT or (enemy.type==IHQUEST and not thing.angry):
+ if enemy.type=='T' or (enemy.type=='?' and not thing.angry):
continue
# different enemies have different probabilities of throwing a torp
usephasers = not torps_ok or \
- (enemy.type == IHK and r > 0.0005) or \
- (enemy.type==IHC and r > 0.015) or \
- (enemy.type==IHR and r > 0.3) or \
- (enemy.type==IHS and r > 0.07) or \
- (enemy.type==IHQUEST and r > 0.05)
+ (enemy.type == 'K' and r > 0.0005) or \
+ (enemy.type=='C' and r > 0.015) or \
+ (enemy.type=='R' and r > 0.3) or \
+ (enemy.type=='S' and r > 0.07) or \
+ (enemy.type=='?' and r > 0.05)
if usephasers: # Enemy uses phasers
if game.condition == "docked":
continue; # Don't waste the effort!
attempt = True; # Attempt to attack
dustfac = randreal(0.8, 0.85)
- hit = enemy.kpower*math.pow(dustfac,enemy.kavgd)
- enemy.kpower *= 0.75
+ hit = enemy.power*math.pow(dustfac,enemy.kavgd)
+ enemy.power *= 0.75
else: # Enemy uses photon torpedo
# We should be able to make the bearing() method work here
- course = 1.90985*math.atan2(game.sector.j-enemy.kloc.j, enemy.kloc.i-game.sector.i)
+ course = 1.90985*math.atan2(game.sector.j-enemy.location.j, enemy.location.i-game.sector.i)
hit = 0
proutn(_("***TORPEDO INCOMING"))
if not damaged(DSRSENS):
- proutn(_(" From ") + crmena(False, enemy.type, where, enemy.kloc))
+ proutn(_(" From ") + crmena(False, enemy.type, where, enemy.location))
attempt = True
prout(" ")
dispersion = (randreal()+randreal())*0.5 - 0.5
- dispersion += 0.002*enemy.kpower*dispersion
- hit = torpedo(enemy.kloc, course, dispersion, number=1, nburst=1)
+ dispersion += 0.002*enemy.power*dispersion
+ hit = torpedo(enemy.location, course, dispersion, number=1, nburst=1)
if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem)==0:
finish(FWON); # Klingons did themselves in!
if game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova or game.alldone:
if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR:
proutn(_(" on the ") + crmshp())
if not damaged(DSRSENS) and usephasers:
- prout(_(" from ") + crmena(False, enemy.type, where, enemy.kloc))
+ prout(_(" from ") + crmena(False, enemy.type, where, enemy.location))
skip(1)
# Decide if hit is critical
if hit > hitmax:
# Added mv to allow enemy to "move" before dying
proutn(crmena(True, type, "sector", mv))
# Decide what kind of enemy it is and update appropriately
- if type == IHR:
+ if type == 'R':
# Chalk up a Romulan
game.state.galaxy[game.quadrant.i][game.quadrant.j].romulans -= 1
game.irhere -= 1
game.state.nromrem -= 1
- elif type == IHT:
+ elif type == 'T':
# Killed a Tholian
game.tholian = None
- elif type == IHQUEST:
+ elif type == '?':
# Killed a Thingy
global thing
thing = None
# Killed some type of Klingon
game.state.galaxy[game.quadrant.i][game.quadrant.j].klingons -= 1
game.klhere -= 1
- if type == IHC:
+ if type == 'C':
game.state.kcmdr.remove(game.quadrant)
unschedule(FTBEAM)
if game.state.kcmdr:
schedule(FTBEAM, expran(1.0*game.incom/len(game.state.kcmdr)))
if is_scheduled(FCDBAS) and game.battle == game.quadrant:
unschedule(FCDBAS)
- elif type == IHK:
+ elif type == 'K':
game.state.remkl -= 1
- elif type == IHS:
+ elif type == 'S':
game.state.nscrem -= 1
game.state.kscmdr.invalidate()
game.isatb = 0
game.recompute()
# Remove enemy ship from arrays describing local conditions
for e in game.enemies:
- if e.kloc == w:
+ if e.location == w:
e.move(None)
break
return
continue
dustfac = randreal(0.9, 1.0)
hit = wham*math.pow(dustfac,game.enemies[kk].kdist)
- kpini = game.enemies[kk].kpower
+ kpini = game.enemies[kk].power
kp = math.fabs(kpini)
if PHASEFAC*hit < kp:
kp = PHASEFAC*hit
- if game.enemies[kk].kpower < 0:
- game.enemies[kk].kpower -= -kp
+ if game.enemies[kk].power < 0:
+ game.enemies[kk].power -= -kp
else:
- game.enemies[kk].kpower -= kp
- kpow = game.enemies[kk].kpower
- w = game.enemies[kk].kloc
+ game.enemies[kk].power -= kp
+ kpow = game.enemies[kk].power
+ w = game.enemies[kk].location
if hit > 0.005:
if not damaged(DSRSENS):
boom(w)
else:
proutn(_("Very small hit on "))
ienm = game.quad[w.i][w.j]
- if ienm==IHQUEST:
+ if ienm=='?':
thing.angry = True
proutn(crmena(False, ienm, "sector", w))
skip(1)
if kpow>0 and withprob(0.9) and kpow <= randreal(0.4, 0.8)*kpini:
prout(_("***Mr. Spock- \"Captain, the vessel at Sector %s")%w)
prout(_(" has just lost its firepower.\""))
- game.enemies[kk].kpower = -kpow
+ game.enemies[kk].power = -kpow
kk += 1
return
scanner.chew()
if not kz:
for i in range(len(game.enemies)):
- irec += math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
+ irec += math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))*randreal(1.01, 1.06) + 1.0
kz=1
proutn(_("%d units required. ") % irec)
scanner.chew()
hits.append(0.0)
if powrem <= 0:
continue
- hits[i] = math.fabs(game.enemies[i].kpower)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
+ hits[i] = math.fabs(game.enemies[i].power)/(PHASEFAC*math.pow(0.90,game.enemies[i].kdist))
over = randreal(1.01, 1.06) * hits[i]
temp = powrem
powrem -= hits[i] + over
elif automode == "MANUAL":
rpow = 0.0
for k in range(len(game.enemies)):
- aim = game.enemies[k].kloc
+ aim = game.enemies[k].location
ienm = game.quad[aim.i][aim.j]
if msgflag:
proutn(_("Energy available= %.2f") % (avail-0.006))
msgflag = False
rpow = 0.0
if damaged(DSRSENS) and \
- not game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS):
+ not game.sector.distance(aim)<2**0.5 and ienm in ('C', 'S'):
prout(cramen(ienm) + _(" can't be located without short range scan."))
scanner.chew()
key = "IHEOL"
if key == "IHEOL":
scanner.chew()
if itarg and k > kz:
- irec=(abs(game.enemies[k].kpower)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) * randreal(1.01, 1.06) + 1.0
+ irec=(abs(game.enemies[k].power)/(PHASEFAC*math.pow(0.9,game.enemies[k].kdist))) * randreal(1.01, 1.06) + 1.0
kz = k
proutn("(")
if not damaged(DCOMPTR):
# Handle case where base is in same quadrant as starship
if game.battle == game.quadrant:
game.state.chart[game.battle.i][game.battle.j].starbase = False
- game.quad[game.base.i][game.base.j] = IHDOT
+ game.quad[game.base.i][game.base.j] = '.'
game.base.invalidate()
newcnd()
skip(1)
# Fix devices
repair = xtime
if game.condition == "docked":
- repair /= game.docfac
+ repair /= DOCKFAC
# Don't fix Deathray here
for l in range(NDEVICES):
if game.damage[l] > 0.0 and l != DDRAY:
supercommander()
elif evcode == FDSPROB: # Move deep space probe
schedule(FDSPROB, 0.01)
- if game.probe.next(grain=QUADSIZE):
+ if not game.probe.next():
if not game.probe.quadrant().valid_quadrant() or \
game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova:
# Left galaxy or ran into supernova
supernova(game.quadrant)
return
# handle initial nova
- game.quad[nov.i][nov.j] = IHDOT
- prout(crmena(False, IHSTAR, "sector", nov) + _(" novas."))
+ game.quad[nov.i][nov.j] = '.'
+ prout(crmena(False, '*', "sector", nov) + _(" novas."))
game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
game.state.starkl += 1
# Set up queue to recursively trigger adjacent stars
continue
iquad = game.quad[neighbor.i][neighbor.j]
# Empty space ends reaction
- if iquad in (IHDOT, IHQUEST, IHBLANK, IHT, IHWEB):
+ if iquad in ('.', '?', ' ', 'T', '#'):
pass
- elif iquad == IHSTAR: # Affect another star
+ elif iquad == '*': # Affect another star
if withprob(0.05):
# This star supernovas
supernova(game.quadrant)
hits.append(neighbor)
game.state.galaxy[game.quadrant.i][game.quadrant.j].stars -= 1
game.state.starkl += 1
- proutn(crmena(True, IHSTAR, "sector", neighbor))
+ proutn(crmena(True, '*', "sector", neighbor))
prout(_(" novas."))
- game.quad[neighbor.i][neighbor.j] = IHDOT
+ game.quad[neighbor.i][neighbor.j] = '.'
kount += 1
- elif iquad in (IHP, IHW): # Destroy planet
+ elif iquad in ('P', '@'): # Destroy planet
game.state.galaxy[game.quadrant.i][game.quadrant.j].planet = None
- if iquad == IHP:
+ if iquad == 'P':
game.state.nplankl += 1
else:
game.state.worldkl += 1
- prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
+ prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
game.iplnet.pclass = "destroyed"
game.iplnet = None
game.plnet.invalidate()
if game.landed:
finish(FPNOVA)
return
- game.quad[neighbor.i][neighbor.j] = IHDOT
- elif iquad == IHB: # Destroy base
+ game.quad[neighbor.i][neighbor.j] = '.'
+ elif iquad == 'B': # Destroy base
game.state.galaxy[game.quadrant.i][game.quadrant.j].starbase = False
game.state.baseq = filter(lambda x: x!= game.quadrant, game.state.baseq)
game.base.invalidate()
game.state.basekl += 1
newcnd()
- prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
- game.quad[neighbor.i][neighbor.j] = IHDOT
- elif iquad in (IHE, IHF): # Buffet ship
+ prout(crmena(True, 'B', "sector", neighbor) + _(" destroyed."))
+ game.quad[neighbor.i][neighbor.j] = '.'
+ elif iquad in ('E', 'F'): # Buffet ship
prout(_("***Starship buffeted by nova."))
if game.shldup:
if game.shield >= 2000.0:
return
# add in course nova contributes to kicking starship
bump += (game.sector-hits[mm]).sgn()
- elif iquad == IHK: # kill klingon
+ elif iquad == 'K': # kill klingon
deadkl(neighbor, iquad, neighbor)
- elif iquad in (IHC,IHS,IHR): # Damage/destroy big enemies
+ elif iquad in ('C','S','R'): # Damage/destroy big enemies
for ll in range(len(game.enemies)):
- if game.enemies[ll].kloc == neighbor:
+ if game.enemies[ll].location == neighbor:
break
- game.enemies[ll].kpower -= 800.0 # If firepower is lost, die
- if game.enemies[ll].kpower <= 0.0:
+ game.enemies[ll].power -= 800.0 # If firepower is lost, die
+ if game.enemies[ll].power <= 0.0:
deadkl(neighbor, iquad, neighbor)
break
newc = neighbor + neighbor - hits[mm]
skip(1)
break
iquad1 = game.quad[newc.i][newc.j]
- if iquad1 == IHBLANK:
- proutn(_(", blasted into ") + crmena(False, IHBLANK, "sector", newc))
+ if iquad1 == ' ':
+ proutn(_(", blasted into ") + crmena(False, ' ', "sector", newc))
skip(1)
deadkl(neighbor, iquad, newc)
break
- if iquad1 != IHDOT:
+ if iquad1 != '.':
# can't move into something else
skip(1)
break
proutn(_(", buffeted to Sector %s") % newc)
- game.quad[neighbor.i][neighbor.j] = IHDOT
+ game.quad[neighbor.i][neighbor.j] = '.'
game.quad[newc.i][newc.j] = iquad
game.enemies[ll].move(newc)
# Starship affected by nova -- kick it away.
game.optime = course.time(warp=4)
skip(1)
prout(_("Force of nova displaces starship."))
- imove(course, novapush=True)
+ imove(course, noattack=True)
game.optime = course.time(warp=4)
return
num = randrange(game.state.galaxy[nq.i][nq.j].stars) + 1
for ns.i in range(QUADSIZE):
for ns.j in range(QUADSIZE):
- if game.quad[ns.i][ns.j]==IHSTAR:
+ if game.quad[ns.i][ns.j]=='*':
num -= 1
if num==0:
break
def kaboom():
stars()
- if game.ship==IHE:
+ if game.ship=='E':
prouts("***")
prouts(_("********* Entropy of %s maximized *********") % crmshp())
skip(1)
whammo = 25.0 * game.energy
l=1
while l <= len(game.enemies):
- if game.enemies[l].kpower*game.enemies[l].kdist <= whammo:
- deadkl(game.enemies[l].kloc, game.quad[game.enemies[l].kloc.i][game.enemies[l].kloc.j], game.enemies[l].kloc)
+ if game.enemies[l].power*game.enemies[l].kdist <= whammo:
+ deadkl(game.enemies[l].location, game.quad[game.enemies[l].location.i][game.enemies[l].location.j], game.enemies[l].location)
l += 1
finish(FDILITHIUM)
45.0*game.nhelp +\
100.0*game.state.basekl +\
3.0*game.abandoned
- if game.ship == IHF:
+ if game.ship == 'F':
badpt += 100.0
elif game.ship == None:
badpt += 200.0
prout(_("You are crushed into extremely dense matter."))
elif ifin == FCREW:
prout(_("Your last crew member has died."))
- if game.ship == IHF:
+ if game.ship == 'F':
game.ship = None
- elif game.ship == IHE:
- game.ship = IHF
+ elif game.ship == 'E':
+ game.ship = 'F'
game.alive = False
if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0:
goodies = game.state.remres/game.inresor
iwon = 0
if game.gamewon:
iwon = 100*game.skill
- if game.ship == IHE:
+ if game.ship == 'E':
klship = 0
- elif game.ship == IHF:
+ elif game.ship == 'F':
klship = 1
else:
klship = 2
curwnd.refresh()
linecount = 0
-def highvideo():
- "Set highlight video, if this is reasonable."
- if game.options & OPTION_CURSES:
- curwnd.attron(curses.A_REVERSE)
-
#
# Things past this point have policy implications.
#
if i != 0 and step == 1:
drawmaps(2)
time.sleep(0.4)
- if (iquad==IHDOT) or (iquad==IHBLANK):
+ if (iquad=='.') or (iquad==' '):
put_srscan_sym(w, '+')
#sound(step*10)
#time.sleep(0.1)
# Code from moving.c begins here
-def imove(course=None, novapush=False):
+def imove(course=None, noattack=False):
"Movement execution for warp, impulse, supernova, and tractor-beam events."
- w = coord(); final = coord()
- trbeam = False
+ w = coord()
- def no_quad_change():
- # No quadrant change -- compute new average enemy distances
- game.quad[game.sector.i][game.sector.j] = game.ship
- if game.enemies:
+ def newquadrant(noattack):
+ # Leaving quadrant -- allow final enemy attack
+ # Don't do it if being pushed by Nova
+ if len(game.enemies) != 0 and not noattack:
+ newcnd()
for enemy in game.enemies:
- finald = (w-enemy.kloc).distance()
+ finald = (w - enemy.location).distance()
enemy.kavgd = 0.5 * (finald + enemy.kdist)
- enemy.kdist = finald
- game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
- if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
+ # Stas Sergeev added the condition
+ # that attacks only happen if Klingons
+ # are present and your skill is good.
+ if game.skill > SKILL_GOOD and game.klhere > 0 and not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
attack(torps_ok=False)
- for enemy in game.enemies:
- enemy.kavgd = enemy.kdist
- newcnd()
- drawmaps(0)
- setwnd(message_window)
-
- if game.inorbit:
- prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
- game.inorbit = False
- # If tractor beam is to occur, don't move full distance
- if game.state.date+game.optime >= scheduled(FTBEAM):
- trbeam = True
- game.condition = "red"
- 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
- for m in range(course.moves):
- course.next()
- w = course.sector()
- if course.origin.quadrant() != course.location.quadrant():
- # Leaving quadrant -- allow final enemy attack
- # Don't do it if being pushed by Nova
- if len(game.enemies) != 0 and not novapush:
- newcnd()
- for enemy in game.enemies:
- finald = (w - enemy.kloc).distance()
- enemy.kavgd = 0.5 * (finald + enemy.kdist)
- # Stas Sergeev added the condition
- # that attacks only happen if Klingons
- # are present and your skill is good.
- if game.skill > SKILL_GOOD and game.klhere > 0 and not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
- attack(torps_ok=False)
- if game.alldone:
- return
- # check for edge of galaxy
- kinks = 0
- while True:
- kink = False
- if course.final.i < 0:
- course.final.i = -course.final.i
- kink = True
- if course.final.j < 0:
- course.final.j = -course.final.j
- kink = True
- if course.final.i >= GALSIZE*QUADSIZE:
- course.final.i = (GALSIZE*QUADSIZE*2) - course.final.i
- kink = True
- if course.final.j >= GALSIZE*QUADSIZE:
- course.final.j = (GALSIZE*QUADSIZE*2) - course.final.j
- kink = True
- if kink:
- kinks += 1
- else:
- break
- if kinks:
- game.nkinks += 1
- if game.nkinks == 3:
- # Three strikes -- you're out!
- finish(FNEG3)
- return
- skip(1)
- prout(_("YOU HAVE ATTEMPTED TO CROSS THE NEGATIVE ENERGY BARRIER"))
- prout(_("AT THE EDGE OF THE GALAXY. THE THIRD TIME YOU TRY THIS,"))
- prout(_("YOU WILL BE DESTROYED."))
- # Compute final position in new quadrant
- if trbeam: # Don't bother if we are to be beamed
+ if game.alldone:
+ return
+ # check for edge of galaxy
+ kinks = 0
+ while True:
+ kink = False
+ if course.final.i < 0:
+ course.final.i = -course.final.i
+ kink = True
+ if course.final.j < 0:
+ course.final.j = -course.final.j
+ kink = True
+ if course.final.i >= GALSIZE*QUADSIZE:
+ course.final.i = (GALSIZE*QUADSIZE*2) - course.final.i
+ kink = True
+ if course.final.j >= GALSIZE*QUADSIZE:
+ course.final.j = (GALSIZE*QUADSIZE*2) - course.final.j
+ kink = True
+ if kink:
+ kinks += 1
+ else:
+ break
+ if kinks:
+ game.nkinks += 1
+ if game.nkinks == 3:
+ # Three strikes -- you're out!
+ finish(FNEG3)
return
- game.quadrant = course.final.quadrant()
- game.sector = course.final.sector()
skip(1)
- prout(_("Entering Quadrant %s.") % game.quadrant)
- game.quad[game.sector.i][game.sector.j] = game.ship
- newqad()
- if game.skill>SKILL_NOVICE:
- attack(torps_ok=False)
+ prout(_("YOU HAVE ATTEMPTED TO CROSS THE NEGATIVE ENERGY BARRIER"))
+ prout(_("AT THE EDGE OF THE GALAXY. THE THIRD TIME YOU TRY THIS,"))
+ prout(_("YOU WILL BE DESTROYED."))
+ # Compute final position in new quadrant
+ if trbeam: # Don't bother if we are to be beamed
return
- iquad = game.quad[w.i][w.j]
- if iquad != IHDOT:
+ game.quadrant = course.final.quadrant()
+ game.sector = course.final.sector()
+ skip(1)
+ prout(_("Entering Quadrant %s.") % game.quadrant)
+ game.quad[game.sector.i][game.sector.j] = game.ship
+ newqad()
+ if game.skill>SKILL_NOVICE:
+ attack(torps_ok=False)
+
+ def check_collision(h):
+ iquad = game.quad[h.i][h.j]
+ if iquad != '.':
# object encountered in flight path
stopegy = 50.0*course.distance/game.optime
- course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
- game.sector = w
- if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST):
+ if iquad in ('T', 'K', 'C', 'S', 'R', '?'):
for enemy in game.enemies:
- if enemy.kloc == game.sector:
+ if enemy.location == game.sector:
break
collision(rammed=False, enemy=enemy)
- final = game.sector
- elif iquad == IHBLANK:
+ return True
+ elif iquad == ' ':
skip(1)
prouts(_("***RED ALERT! RED ALERT!"))
skip(1)
proutn("***" + crmshp())
- proutn(_(" pulled into black hole at Sector %s") % w)
+ proutn(_(" pulled into black hole at Sector %s") % h)
# Getting pulled into a black hole was certain
# death in Almy's original. Stas Sergeev added a
# possibility that you'll get timewarped instead.
timwrp()
else:
finish(FHOLE)
- return
+ return True
else:
# something else
skip(1)
proutn(crmshp())
- if iquad == IHWEB:
- prout(_(" encounters Tholian web at %s;") % w)
+ if iquad == '#':
+ prout(_(" encounters Tholian web at %s;") % h)
else:
- prout(_(" blocked by object at %s;") % w)
+ prout(_(" blocked by object at %s;") % h)
proutn(_("Emergency stop required "))
prout(_("%2d units of energy.") % int(stopegy))
game.energy -= stopegy
- game.sector = w
if game.energy <= 0:
finish(FNRG)
- return
- # We're here!
- no_quad_change()
- return
- course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
- game.sector = w
- final = game.sector
- no_quad_change()
+ return True
+ return False
+
+ trbeam = False
+ if game.inorbit:
+ prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
+ game.inorbit = False
+ # If tractor beam is to occur, don't move full distance
+ if game.state.date+game.optime >= scheduled(FTBEAM):
+ trbeam = True
+ game.condition = "red"
+ course.distance = course.distance*(scheduled(FTBEAM)-game.state.date)/game.optime + 0.1
+ game.optime = scheduled(FTBEAM) - game.state.date + 1e-5
+ # Move out
+ game.quad[game.sector.i][game.sector.j] = '.'
+ for m in range(course.moves):
+ course.next()
+ w = course.sector()
+ if course.origin.quadrant() != course.location.quadrant():
+ newquadrant(noattack)
+ break
+ elif check_collision(w):
+ print "Collision detected"
+ break
+ else:
+ game.sector = w
+ # We're in destination quadrant -- compute new average enemy distances
+ game.quad[game.sector.i][game.sector.j] = game.ship
+ if game.enemies:
+ for enemy in game.enemies:
+ finald = (w-enemy.location).distance()
+ enemy.kavgd = 0.5 * (finald + enemy.kdist)
+ enemy.kdist = finald
+ game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+ if not game.state.galaxy[game.quadrant.i][game.quadrant.j].supernova:
+ attack(torps_ok=False)
+ for enemy in game.enemies:
+ enemy.kavgd = enemy.kdist
+ newcnd()
+ drawmaps(0)
+ setwnd(message_window)
return
def dock(verbose):
prout(_("Lt. Uhura- \"Captain, an important message from the starbase:\""))
attackreport(False)
game.iseenit = True
-
-# This program originally required input in terms of a (clock)
-# direction and distance. Somewhere in history, it was changed to
-# cartesian coordinates. So we need to convert. Probably
-# "manual" input should still be done this way -- it's a real
-# pain if the computer isn't working! Manual mode is still confusing
-# because it involves giving x and y motions, yet the coordinates
-# are always displayed y - x, where +y is downward!
def cartesian(loc1=None, loc2=None):
if loc1 is None:
self.step = 0
def arrived(self):
return self.location.roundtogrid() == self.final
- def next(self, grain=1):
+ def next(self):
"Next step on course."
self.step += 1
self.nextlocation = self.location + self.increment
- oldloc = (self.location/grain).roundtogrid()
- newloc = (self.nextlocation/grain).roundtogrid()
+ samequad = (self.location.quadrant() == self.nextlocation.quadrant())
self.location = self.nextlocation
- if newloc != oldloc:
- return True
- else:
- return False
+ return samequad
def quadrant(self):
return self.location.quadrant()
def sector(self):
if ja() == False:
return
# Activate impulse engines and pay the cost
- imove(course, novapush=False)
+ imove(course, noattack=False)
game.ididit = True
if game.alldone:
return
if game.warpfac > 6.0:
# Decide if engine damage will occur
# ESR: Seems wrong. Probability of damage goes *down* with distance?
- prob = course.dist*(6.0-game.warpfac)**2/66.666666666
+ prob = course.distance*(6.0-game.warpfac)**2/66.666666666
if prob > randreal():
blooey = True
course.distance = randreal(course.distance)
# Decide if time warp will occur
- if 0.5*course.dist*math.pow(7.0,game.warpfac-10.0) > randreal():
+ if 0.5*course.distance*math.pow(7.0,game.warpfac-10.0) > randreal():
twarp = True
if idebug and game.warpfac==10 and not twarp:
blooey = False
w = course.sector()
if not w.valid_sector():
break
- if game.quad[w.x][w.y] != IHDOT:
+ if game.quad[w.i][w.j] != '.':
blooey = False
twarp = False
course.reset()
# Activate Warp Engines and pay the cost
- imove(course, novapush=False)
+ imove(course, noattack=False)
if game.alldone:
return
game.energy -= course.power(game.warpfac)
proutn(_("The %s has stopped in a quadrant containing") % crmshp())
prouts(_(" a supernova."))
skip(2)
- proutn(_("***Emergency automatic override attempts to hurl ")+crmshp())
+ prout(_("***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
prout(_("Warp factor set to %d") % int(game.warpfac))
power = 0.75*game.energy
dist = power/(game.warpfac*game.warpfac*game.warpfac*(game.shldup+1))
- distreq = randreal(math.sqrt(2))
- if distreq < game.dist:
- dist = distreq
- course = course(bearing=randreal(12), distance=dist) # How dumb!
- game.optime = course.time()
+ dist = max(dist, randreal(math.sqrt(2)))
+ bugout = course(bearing=randreal(12), distance=dist) # How dumb!
+ game.optime = bugout.time(game.warpfac)
game.justin = False
game.inorbit = False
- warp(course, involuntary=True)
+ warp(bugout, involuntary=True)
if not game.justin:
# This is bad news, we didn't leave quadrant.
if game.alldone:
for l in range(game.inplan):
if game.state.planets[l].known == "shuttle_down":
gotit = True
- if game.iscraft == "onship" and game.ship==IHE:
+ if game.iscraft == "onship" and game.ship=='E':
prout(_("Chekov- \"Security reports the Galileo has disappeared, Sir!"))
game.iscraft = "offship"
# Likewise, if in the original time the Galileo was abandoned, but
# was on ship earlier, it would have vanished -- let's restore it.
if game.iscraft == "offship" and not gotit and game.damage[DSHUTTL] >= 0.0:
- prout(_("Checkov- \"Security reports the Galileo has reappeared in the dock!\""))
+ prout(_("Chekov- \"Security reports the Galileo has reappeared in the dock!\""))
game.iscraft = "onship"
# There used to be code to do the actual reconstrction here,
# but the starchart is now part of the snapshotted galaxy state.
prout(_("Spock has reconstructed a correct star chart from memory"))
else:
# Go forward in time
- game.optime = -0.5*game.intime*math.log(randreal())
+ game.optime = expran(0.5*game.intime)
prout(_("You are traveling forward in time %d stardates.") % int(game.optime))
# cheat to make sure no tractor beams occur during time warp
postpone(FTBEAM, game.optime)
if game.nprobes == 0:
scanner.chew()
skip(1)
- if game.ship == IHE:
+ if game.ship == 'E':
prout(_("Engineer Scott- \"We have no more deep space probes, Sir.\""))
else:
prout(_("Ye Faerie Queene has no deep space probes."))
game.quadrant = ibq
newqad()
# dematerialize starship
- game.quad[game.sector.i][game.sector.j]=IHDOT
+ game.quad[game.sector.i][game.sector.j]='.'
proutn(_("Starbase in Quadrant %s responds--%s dematerializes") \
% (game.quadrant, crmshp()))
game.sector.invalidate()
for m in range(1, 5+1):
w = game.base.scatter()
- if w.valid_sector() and game.quad[w.i][w.j]==IHDOT:
+ if w.valid_sector() and game.quad[w.i][w.j]=='.':
# found one -- finish up
game.sector = w
break
elif m == 2: proutn(_("2nd"))
elif m == 3: proutn(_("3rd"))
proutn(_(" attempt to re-materialize ") + crmshp())
- game.quad[ix][iy]=(IHMATER0,IHMATER1,IHMATER2)[m-1]
- #textcolor("red")
+ game.quad[ix][iy]=('-','o','O')[m-1]
warble()
if randreal() > probf:
break
prout(_("fails."))
curses.delay_output(500)
- #textcolor(None)
if m > 3:
- game.quad[ix][iy]=IHQUEST
+ game.quad[ix][iy]='?'
game.alive = False
drawmaps(1)
setwnd(message_window)
finish(FMATERIALIZE)
return
game.quad[ix][iy]=game.ship
- #textcolor("green")
prout(_("succeeds."))
- #textcolor(None)
dock(False)
skip(1)
prout(_("Lt. Uhura- \"Captain, we made it!\""))
"Abandon ship."
scanner.chew()
if game.condition=="docked":
- if game.ship!=IHE:
+ if game.ship!='E':
prout(_("You cannot abandon Ye Faerie Queene."))
return
else:
newqad()
while True:
# position next to base by trial and error
- game.quad[game.sector.i][game.sector.j] = IHDOT
+ game.quad[game.sector.i][game.sector.j] = '.'
for l in range(QUADSIZE):
game.sector = game.base.scatter()
if game.sector.valid_sector() and \
- game.quad[game.sector.i][game.sector.j] == IHDOT:
+ game.quad[game.sector.i][game.sector.j] == '.':
break
if l < QUADSIZE+1:
break # found a spot
game.sector.j=QUADSIZE/2
newqad()
# Get new commission
- game.quad[game.sector.i][game.sector.j] = game.ship = IHF
+ game.quad[game.sector.i][game.sector.j] = game.ship = 'F'
game.state.crew = FULLCREW
prout(_("Starfleet puts you in command of another ship,"))
prout(_("the Faerie Queene, which is antiquated but,"))
game.ididit = False
skip(1)
scanner.chew()
- if game.ship != IHE:
+ if game.ship != 'E':
prout(_("Ye Faerie Queene has no death ray."))
return
if len(game.enemies)==0:
prouts(_("Sulu- \"Captain! It's working!\""))
skip(2)
while len(game.enemies) > 0:
- deadkl(game.enemies[1].kloc, game.quad[game.enemies[1].kloc.i][game.enemies[1].kloc.j],game.enemies[1].kloc)
+ deadkl(game.enemies[1].location, game.quad[game.enemies[1].location.i][game.enemies[1].location.j],game.enemies[1].location)
prout(_("Ensign Chekov- \"Congratulations, Captain!\""))
if (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) == 0:
finish(FWON)
prout(_(" Mr. Sulu."))
for i in range(QUADSIZE):
for j in range(QUADSIZE):
- if game.quad[i][j] == IHDOT:
- game.quad[i][j] = IHQUEST
+ if game.quad[i][j] == '.':
+ game.quad[i][j] = '?'
prout(_(" Captain, our quadrant is now infested with"))
prouts(_(" - - - - - - *THINGS*."))
skip(1)
prout(_("%d casualt%s suffered so far.") % (game.casual, ("y", "ies")[game.casual!=1]))
if game.nhelp:
prout(_("There were %d call%s for help.") % (game.nhelp, ("" , _("s"))[game.nhelp!=1]))
- if game.ship == IHE:
+ if game.ship == 'E':
proutn(_("You have "))
if game.nprobes:
proutn("%d" % (game.nprobes))
jdam = True
prout(" %-26s\t%8.2f\t\t%8.2f" % (device[i],
game.damage[i]+0.05,
- game.docfac*game.damage[i]+0.005))
+ DOCKFAC*game.damage[i]+0.005))
if not jdam:
prout(_("All devices functional."))
def sectscan(goodScan, i, j):
"Light up an individual dot in a sector."
if goodScan or (abs(i-game.sector.i)<= 1 and abs(j-game.sector.j) <= 1):
- if (game.quad[i][j]==IHMATER0) or (game.quad[i][j]==IHMATER1) or (game.quad[i][j]==IHMATER2) or (game.quad[i][j]==IHE) or (game.quad[i][j]==IHF):
- #if game.condition == "red": textcolor("red")
- #elif game.condition == "green": textcolor("green")
- #elif game.condition == "yellow": textcolor("yellow")
- #elif game.condition == "docked": textcolor("cyan")
- #elif game.condition == "dead": textcolor("brown")
- if game.quad[i][j] != game.ship:
- highvideo()
proutn("%c " % game.quad[i][j])
- #textcolor(None)
else:
proutn("- ")
if not req or req == 2:
if game.condition != "docked":
newcnd()
- dam = 0
- for t in range(NDEVICES):
- if game.damage[t]>0:
- dam += 1
- prstat(_("Condition"), _("%s, %i DAMAGES") % (game.condition.upper(), dam))
+ prstat(_("Condition"), _("%s, %i DAMAGES") % \
+ (game.condition.upper(), sum(map(lambda x: x > 0, game.damage))))
if not req or req == 3:
prstat(_("Position"), "%s , %s" % (game.quadrant, game.sector))
if not req or req == 4:
prstat(_("Shields"), s+data)
if not req or req == 9:
prstat(_("Klingons Left"), "%d" \
- % (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem))
+ % (game.state.remkl+len(game.state.kcmdr)+game.state.nscrem))
if not req or req == 10:
if game.options & OPTION_WORLDS:
plnet = game.state.galaxy[game.quadrant.i][game.quadrant.j].planet
prout(_("Captain, certainly you can give me one of these."))
while True:
scanner.chew()
- ttime = (10.0*game.dist)/twarp**2
+ ttime = (10.0*dist)/twarp**2
tpower = dist*twarp*twarp*twarp*(game.shldup+1)
if tpower >= game.energy:
prout(_("Insufficient energy, sir."))
return # frozen game
# Prepare the Enterprise
game.alldone = game.gamewon = game.shldchg = game.shldup = False
- game.ship = IHE
+ game.ship = 'E'
game.state.crew = FULLCREW
game.energy = game.inenrg = 5000.0
game.shield = game.inshld = 2500.0
game.iscraft = "onship"
game.landed = False
game.alive = True
- game.docfac = 0.25
# Starchart is functional but we've never seen it
game.lastchart = FOREVER
# Put stars in the galaxy
def choose():
"Choose your game type."
- global thing
while True:
- game.tourn = 0
+ game.tourn = game.length = 0
game.thawed = False
game.skill = SKILL_NONE
- game.length = 0
if not scanner.inqueue: # Can start with command line options
proutn(_("Would you like a regular, tournament, or saved game? "))
scanner.next()
"Drop a feature on a random dot in the current quadrant."
while True:
w = randplace(QUADSIZE)
- if game.quad[w.i][w.j] == IHDOT:
+ if game.quad[w.i][w.j] == '.':
break
if iquad is not None:
game.quad[w.i][w.j] = iquad
def newkling():
"Drop new Klingon into current quadrant."
- return enemy(IHK, loc=dropin(), power=randreal(300,450)+25.0*game.skill)
+ return enemy('K', loc=dropin(), power=randreal(300,450)+25.0*game.skill)
def newqad():
"Set up a new state of quadrant, for when we enter or re-enter it."
game.neutz = game.inorbit = game.landed = False
game.ientesc = game.iseenit = False
# Create a blank quadrant
- game.quad = fill2d(QUADSIZE, lambda i, j: IHDOT)
+ game.quad = fill2d(QUADSIZE, lambda i, j: '.')
if game.iscate:
# Attempt to escape Super-commander, so tbeam back!
game.iscate = False
for cmdr in game.state.kcmdr:
if cmdr == game.quadrant:
e = game.enemies[game.klhere-1]
- game.quad[e.kloc.i][e.kloc.j] = IHC
- e.kpower = randreal(950,1350) + 50.0*game.skill
+ game.quad[e.location.i][e.location.j] = 'C'
+ e.power = randreal(950,1350) + 50.0*game.skill
break
# If we need a super-commander, promote a Klingon
if game.quadrant == game.state.kscmdr:
e = game.enemies[0]
- game.quad[e.kloc.i][e.kloc.j] = IHS
- e.kpower = randreal(1175.0, 1575.0) + 125.0*game.skill
+ game.quad[e.location.i][e.location.j] = 'S'
+ e.power = randreal(1175.0, 1575.0) + 125.0*game.skill
game.iscate = (game.state.remkl > 1)
# Put in Romulans if needed
for i in range(q.romulans):
- enemy(IHR, 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(IHB)
+ game.base = dropin('B')
# If quadrant needs a planet, put it in
if q.planet:
game.iplnet = q.planet
if not q.planet.inhabited:
- game.plnet = dropin(IHP)
+ game.plnet = dropin('P')
else:
- game.plnet = dropin(IHW)
+ game.plnet = dropin('@')
# Check for condition
newcnd()
# Check for RNZ
prout(_("LEAVE AT ONCE, OR YOU WILL BE DESTROYED!"))
# Put in THING if needed
if thing == game.quadrant:
- enemy(type=IHQUEST, loc=dropin(),
+ enemy(type='?', loc=dropin(),
power=randreal(6000,6500.0)+250.0*game.skill)
if not damaged(DSRSENS):
skip(1)
while True:
w.i = withprob(0.5) * (QUADSIZE-1)
w.j = withprob(0.5) * (QUADSIZE-1)
- if game.quad[w.i][w.j] == IHDOT:
+ if game.quad[w.i][w.j] == '.':
break
- game.tholian = enemy(type=IHT, loc=w,
+ game.tholian = enemy(type='T', loc=w,
power=randrange(100, 500) + 25.0*game.skill)
# Reserve unoccupied corners
- if game.quad[0][0]==IHDOT:
+ if game.quad[0][0]=='.':
game.quad[0][0] = 'X'
- if game.quad[0][QUADSIZE-1]==IHDOT:
+ if game.quad[0][QUADSIZE-1]=='.':
game.quad[0][QUADSIZE-1] = 'X'
- if game.quad[QUADSIZE-1][0]==IHDOT:
+ if game.quad[QUADSIZE-1][0]=='.':
game.quad[QUADSIZE-1][0] = 'X'
- if game.quad[QUADSIZE-1][QUADSIZE-1]==IHDOT:
+ if game.quad[QUADSIZE-1][QUADSIZE-1]=='.':
game.quad[QUADSIZE-1][QUADSIZE-1] = 'X'
game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
# And finally the stars
for i in range(q.stars):
- dropin(IHSTAR)
+ dropin('*')
# Put in a few black holes
for i in range(1, 3+1):
if withprob(0.5):
- dropin(IHBLANK)
+ dropin(' ')
# Take out X's in corners if Tholian present
if game.tholian:
if game.quad[0][0]=='X':
- game.quad[0][0] = IHDOT
+ game.quad[0][0] = '.'
if game.quad[0][QUADSIZE-1]=='X':
- game.quad[0][QUADSIZE-1] = IHDOT
+ game.quad[0][QUADSIZE-1] = '.'
if game.quad[QUADSIZE-1][0]=='X':
- game.quad[QUADSIZE-1][0] = IHDOT
+ game.quad[QUADSIZE-1][0] = '.'
if game.quad[QUADSIZE-1][QUADSIZE-1]=='X':
- game.quad[QUADSIZE-1][QUADSIZE-1] = IHDOT
+ game.quad[QUADSIZE-1][QUADSIZE-1] = '.'
def setpassword():
"Set the self-destruct password."
drawmaps(1)
while True: # get a command
hitme = False
- game.justin = False
- game.optime = 0.0
+ game.optime = game.justin = False
scanner.chew()
setwnd(prompt_window)
clrscr()
def cramen(type):
"Emit the name of an enemy or feature."
- if type == IHR: s = _("Romulan")
- elif type == IHK: s = _("Klingon")
- elif type == IHC: s = _("Commander")
- elif type == IHS: s = _("Super-commander")
- elif type == IHSTAR: s = _("Star")
- elif type == IHP: s = _("Planet")
- elif type == IHB: s = _("Starbase")
- elif type == IHBLANK: s = _("Black hole")
- elif type == IHT: s = _("Tholian")
- elif type == IHWEB: s = _("Tholian web")
- elif type == IHQUEST: s = _("Stranger")
- elif type == IHW: s = _("Inhabited World")
+ if type == 'R': s = _("Romulan")
+ elif type == 'K': s = _("Klingon")
+ elif type == 'C': s = _("Commander")
+ elif type == 'S': s = _("Super-commander")
+ elif type == '*': s = _("Star")
+ elif type == 'P': s = _("Planet")
+ elif type == 'B': s = _("Starbase")
+ elif type == ' ': s = _("Black hole")
+ elif type == 'T': s = _("Tholian")
+ elif type == '#': s = _("Tholian web")
+ elif type == '?': s = _("Stranger")
+ elif type == '@': s = _("Inhabited World")
else: s = "Unknown??"
return s
def crmshp():
"Emit our ship name."
- return{IHE:_("Enterprise"),IHF:_("Faerie Queene")}.get(game.ship,"Ship???")
+ return{'E':_("Enterprise"),'F':_("Faerie Queene")}.get(game.ship,"Ship???")
def stars():
"Emit a line of stars"
raise SystemExit, 1
# where to save the input in case of bugs
try:
- logfp = open("/usr/tmp/sst-input.log", "w")
+ logfp = open("/tmp/sst-input.log", "w")
except IOError:
sys.stderr.write("sst: warning, can't open logfile\n")
+ sys.exit(1)
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()))
+ (getpass.getuser(),socket.gethostname(),time.ctime()))
random.seed(seed)
scanner = sstscanner()
map(scanner.append, arguments)
projects / super-star-trek.git / blobdiff