return coord(self.x*other, self.y*other)
def __rmul__(self, other):
return coord(self.x*other, self.y*other)
+ def __div__(self, other):
+ return coord(self.x/other, self.y/other)
+ def __rdiv__(self, other):
+ return coord(self.x/other, self.y/other)
+ def snaptogrid(self):
+ return coord(int(round(self.x)), int(round(self.y)))
def distance(self, other=None):
if not other: other = coord(0, 0)
return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
# Code from ai.c begins here
def welcoming(iq):
- # Would this quadrant welcome another Klingon?
+ "Would this quadrant welcome another Klingon?"
return VALID_QUADRANT(iq.x,iq.y) and \
not game.state.galaxy[iq.x][iq.y].supernova or \
game.state.galaxy[iq.x][iq.y].klingons < MAXKLQUAD
def tryexit(enemy, look, irun):
- # a bad guy attempts to bug out
+ "A bad guy attempts to bug out."
iq = coord()
iq.x = game.quadrant.x+(look.x+(QUADSIZE-1))/QUADSIZE - 1
iq.y = game.quadrant.y+(look.y+(QUADSIZE-1))/QUADSIZE - 1
# don't leave if over 1000 units of energy
if enemy.kpower > 1000.0:
return False
- # print escape message and move out of quadrant.
+ # emit escape message and move out of quadrant.
# we know this if either short or long range sensors are working
if not damaged(DSRSENS) or not damaged(DLRSENS) or \
game.condition == "docked":
- crmena(True, enemy.type, "sector", enemy.kloc)
- prout(_(" escapes to Quadrant %s (and regains strength).") % q)
+ prout(crmena(True, enemy.type, "sector", enemy.kloc) + \
+ (_(" escapes to Quadrant %s (and regains strength).") % q))
# handle local matters related to escape
enemy.move(None)
game.klhere -= 1
#
def movebaddy(enemy):
- # tactical movement for the bad guys
+ "Tactical movement for the bad guys."
next = coord(); look = coord()
irun = False
# This should probably be just (game.quadrant in game.state.kcmdr) + (game.state.kscmdr==game.quadrant)
skip(1)
if enemy.move(next):
if not damaged(DSRSENS) or game.condition == "docked":
- proutn("***")
- cramen(enemy.type)
- proutn(_(" from Sector %s") % enemy.kloc)
+ proutn(_("*** %s from Sector %s") % (cramen(enemy.type), enemy.kloc))
if enemy.kdist < dist1:
proutn(_(" advances to "))
else:
prout("Sector %s." % next)
def moveklings():
- # Klingon tactical movement
+ "Sequence Klingon tactical movement."
if idebug:
prout("== MOVCOM")
# Figure out which Klingon is the commander (or Supercommander)
game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
def movescom(iq, avoid):
- # commander movement helper
+ "Commander movement helper."
# Avoid quadrants with bases if we want to avoid Enterprise
if not welcoming(iq) or (avoid and iq in game.state.baseq):
return True
return False; # looks good!
def supercommander():
- # move the Super Commander
+ "Move the Super Commander."
iq = coord(); sc = coord(); ibq = coord(); idelta = coord()
basetbl = []
if idebug:
return
def movetholian():
- # move the Tholian
+ "Move the Tholian."
if not game.tholian or game.justin:
return
id = coord()
delta = (id - game.tholian.kloc).sgn()
# move in x axis
while here.x != id.x:
- #print "Moving in X", delta
here.x += delta.x
if game.quad[here.x][here.y]==IHDOT:
game.tholian.move(here)
# move in y axis
while here.y != id.y:
- #print "Moving in Y", delta
here.y += delta.y
if game.quad[here.x][here.y]==IHDOT:
game.tholian.move(here)
# All plugged up -- Tholian splits
game.quad[game.tholian.kloc.x][game.tholian.kloc.y]=IHWEB
dropin(IHBLANK)
- crmena(True, IHT, "sector", game.tholian)
- prout(_(" completes web."))
+ prout(crmena(True, IHT, "sector", game.tholian) + _(" completes web."))
game.tholian.move(None)
- print "Tholian movement ends"
return
# Code from battle.c begins here
def doshield(shraise):
- # change shield status
+ "Change shield status."
action = "NONE"
game.ididit = False
if shraise:
return None; # we should never get here
def collision(rammed, enemy):
- # collision handling
+ "Collision handling fot rammong events."
prouts(_("***RED ALERT! RED ALERT!"))
skip(1)
prout(_("***COLLISION IMMINENT."))
skip(2)
proutn("***")
- crmshp()
+ proutn(crmshp())
hardness = {IHR:1.5, IHC:2.0, IHS:2.5, IHT:0.5, IHQUEST:4.0}.get(enemy.type, 1.0)
if rammed:
proutn(_(" rammed by "))
else:
proutn(_(" rams "))
- crmena(False, enemy.type, "sector", enemy.kloc)
+ proutn(crmena(False, enemy.type, "sector", enemy.kloc))
if rammed:
proutn(_(" (original position)"))
skip(1)
deadkl(enemy.kloc, enemy.type, game.sector)
- proutn("***")
- crmshp()
- prout(_(" heavily damaged."))
+ proutn("***" + crmship() + " heavily damaged.")
icas = randrange(10, 30)
prout(_("***Sickbay reports %d casualties"), icas)
game.casual += icas
return
def torpedo(course, dispersion, origin, number, nburst):
- # let a photon torpedo fly
+ "Let a photon torpedo fly"
iquad = 0
shoved = False
ac = course + 0.25*dispersion
deltax = -math.sin(angle);
deltay = math.cos(angle);
x = origin.x; y = origin.y
- w = coord(); jw = coord()
- w.x = w.y = jw.x = jw.y = 0
+ w = coord(0, 0); jw = coord(0, 0)
bigger = max(math.fabs(deltax), math.fabs(deltay))
deltax /= bigger
deltay /= bigger
skip(1); # start new line after text track
if iquad in (IHE, IHF): # Hit our ship
skip(1)
- proutn(_("Torpedo hits "))
- crmshp()
- prout(".")
+ prout(_("Torpedo hits %s.") % crmshp())
hit = 700.0 + randreal(100) - \
1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
newcnd(); # we're blown out of dock
# can't move into object
return hit
game.sector = jw
- crmshp()
+ proutn(crmshp())
shoved = True
elif iquad in (IHC, IHS): # Hit a commander
if withprob(0.05):
- crmena(True, iquad, "sector", w)
- prout(_(" uses anti-photon device;"))
+ prout(crmena(True, iquad, "sector", w) + _(" uses anti-photon device;"))
prout(_(" torpedo neutralized."))
return None
elif iquad in (IHR, IHK): # Hit a regular enemy
if enemy.kpower == 0:
deadkl(w, iquad, w)
return None
- crmena(True, iquad, "sector", w)
+ proutn(crmena(True, iquad, "sector", w))
# If enemy damaged but not destroyed, try to displace
ang = angle + 2.5*(randreal()-0.5)
temp = math.fabs(math.sin(ang))
newcnd()
return None
elif iquad == IHP: # Hit a planet
- crmena(True, iquad, "sector", w)
- prout(_(" destroyed."))
+ prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
game.state.nplankl += 1
game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None
game.iplnet.pclass = "destroyed"
finish(FDPLANET)
return None
elif iquad == IHW: # Hit an inhabited world -- very bad!
- crmena(True, iquad, "sector", w)
- prout(_(" destroyed."))
+ prout(crmena(True, iquad, "sector", w) + _(" destroyed."))
game.state.nworldkl += 1
game.state.galaxy[game.quadrant.x][game.quadrant.y].planet = None
game.iplnet.pclass = "destroyed"
if withprob(0.9):
nova(w)
else:
- crmena(True, IHSTAR, "sector", w)
- prout(_(" unaffected by photon blast."))
+ prout(crmena(True, IHSTAR, "sector", w) + _(" unaffected by photon blast."))
return None
elif iquad == IHQUEST: # Hit a thingy
if not (game.options & OPTION_THINGY) or withprob(0.3):
return None
elif iquad == IHBLANK: # Black hole
skip(1)
- crmena(True, IHBLANK, "sector", w)
- prout(_(" swallows torpedo."))
+ prout(crmena(True, IHBLANK, "sector", w) + _(" swallows torpedo."))
return None
elif iquad == IHWEB: # hit the web
skip(1)
game.tholian = None
return None
skip(1)
- crmena(True, IHT, "sector", w)
+ proutn(crmena(True, IHT, "sector", w))
if withprob(0.05):
prout(_(" survives photon blast."))
return None
else: # Problem!
skip(1)
proutn("Don't know how to handle torpedo collision with ")
- crmena(True, iquad, "sector", w)
+ proutn(crmena(True, iquad, "sector", w))
skip(1)
return None
break
return None;
def fry(hit):
- # critical-hit resolution
+ "Critical-hit resolution."
if hit < (275.0-25.0*game.skill)*randreal(1.0, 1.5):
return
ncrit = int(1.0 + hit/(500.0+randreal(100)))
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.kloc))
attempt = True
prout(" ")
dispersion = (randreal()+randreal())*0.5 - 0.5
ihurt = True
proutn(_("%d unit hit") % int(hit))
if (damaged(DSRSENS) and usephasers) or game.skill<=SKILL_FAIR:
- proutn(_(" on the "))
- crmshp()
+ proutn(_(" on the ") + crmshp())
if not damaged(DSRSENS) and usephasers:
- proutn(_(" from "))
- crmena(False, enemy.type, where, enemy.kloc)
+ prout(_(" from ") + crmena(False, enemy.type, where, enemy.kloc))
skip(1)
# Decide if hit is critical
if hit > hitmax:
# Shields fully protect ship
proutn(_("Enemy attack reduces shield strength to "))
else:
- # Print message if starship suffered hit(s)
+ # Emit message if starship suffered hit(s)
skip(1)
proutn(_("Energy left %2d shields ") % int(game.energy))
if game.shldup:
return
def deadkl(w, type, mv):
- # kill a Klingon, Tholian, Romulan, or Thingy
+ "Kill a Klingon, Tholian, Romulan, or Thingy."
# Added mv to allow enemy to "move" before dying
- crmena(True, type, "sector", mv)
+ proutn(crmena(True, type, "sector", mv))
# Decide what kind of enemy it is and update appropriately
if type == IHR:
# chalk up a Romulan
return
def targetcheck(w):
- # Return None if target is invalid, otherwise return a course angle
+ "Return None if target is invalid, otherwise return a course angle."
if not VALID_SECTOR(w.x, w.y):
huh()
return None
return delta.bearing()
def photon():
- # launch photon torpedo
+ "Launch photon torpedo."
course = [0.0] * MAXBURST
game.ididit = False
if damaged(DPHOTON):
prout(_("No torpedoes left."))
scanner.chew()
return
- key = scanner.next()
+ # First, get torpedo count
while True:
- if key == IHALPHA:
+ scanner.next()
+ if scanner.token == IHALPHA:
huh()
return
- elif key == IHEOL:
+ elif scanner.token == IHEOL or not scanner.waiting():
prout(_("%d torpedoes left.") % game.torps)
scanner.chew()
proutn(_("Number of torpedoes to fire- "))
- key = scanner.next()
+ continue # Go back around to get a number
else: # key == IHREAL
n = scanner.int()
if n <= 0: # abort command
if n > MAXBURST:
scanner.chew()
prout(_("Maximum of %d torpedoes per burst.") % MAXBURST)
- key = IHEOL
return
- if n <= game.torps:
- break
- scanner.chew()
- key = IHEOL
- targ = []
- for i in range(MAXBURST):
- targ.append(coord())
+ if n > game.torps:
+ scanner.chew() # User requested more torps than available
+ continue # Go back around
+ break # All is good, go to next stage
+ # Next, get targets
+ target = []
for i in range(n):
key = scanner.next()
if i==0 and key == IHEOL:
- break; # we will try prompting
+ break; # no coordinate waiting, we will try prompting
if i==1 and key == IHEOL:
# direct all torpedoes at one target
- while i <= n:
- targ[i] = targ[0]
- course[i] = course[0]
+ while i < n:
+ target.append(targets[0])
+ course.append(course[0])
i += 1
break
- if key != IHREAL:
- huh()
- return
- targ[i].x = scanner.int()
- key = scanner.next()
- if key != IHREAL:
- huh()
- return
- targ[i].y = scanner.int()
- course[i] = targetcheck(targ[i])
+ scanner.push(key)
+ target.append(scanner.getcoord())
+ if target[-1] == None:
+ return
+ course.append(targetcheck(target[1]))
if course[i] == None:
return
scanner.chew()
- if i == 0 and key == IHEOL:
+ if i == 0:
# prompt for each one
for i in range(n):
proutn(_("Target sector for torpedo number %d- ") % (i+1))
- key = scanner.next()
- if key != IHREAL:
- huh()
- return
- targ[i].x = scanner.int()
- key = scanner.next()
- if key != IHREAL:
- huh()
- return
- targ[i].y = scanner.int()
scanner.chew()
- course[i] = targetcheck(targ[i])
- if course[i] == None:
+ target.append(scanner.getcoord())
+ if target[-1] == None:
+ return
+ course.append(targetcheck(target[-1]))
+ if course[-1] == None:
return
game.ididit = True
# Loop for moving <n> torpedoes
finish(FWON);
def overheat(rpow):
- # check for phasers overheating
+ "Check for phasers overheating."
if rpow > 1500:
checkburn = (rpow-1500.0)*0.00038
if withprob(checkburn):
game.damage[DPHASER] = game.damfac* randreal(1.0, 2.0) * (1.0+checkburn)
def checkshctrl(rpow):
- # check shield control
+ "Check shield control."
skip(1)
if withprob(0.998):
prout(_("Shields lowered."))
return True;
def hittem(hits):
- # register a phaser hit on Klingons and Romulans
+ "Register a phaser hit on Klingons and Romulans."
nenhr2 = len(game.enemies); kk=0
w = coord()
skip(1)
- print "Hits are:", hits
for (k, wham) in enumerate(hits):
if wham==0:
continue
ienm = game.quad[w.x][w.y]
if ienm==IHQUEST:
thing.angry = True
- crmena(False, ienm, "sector", w)
+ proutn(crmena(False, ienm, "sector", w))
skip(1)
if kpow == 0:
deadkl(w, ienm, w)
return
def phasers():
- # fire phasers
+ "Fire phasers at bad guys."
hits = []
kz = 0; k = 1; irec=0 # Cheating inhibitor
ifast = False; no = False; itarg = True; msgflag = True; rpow=0
rpow = 0.0
if damaged(DSRSENS) and \
not game.sector.distance(aim)<2**0.5 and ienm in (IHC, IHS):
- cramen(ienm)
- prout(_(" can't be located without short range scan."))
+ prout(cramen(ienm) + _(" can't be located without short range scan."))
scanner.chew()
key = IHEOL
hits[k] = 0; # prevent overflow -- thanks to Alexei Voitenko
else:
proutn("??")
proutn(") ")
- proutn(_("units to fire at "))
- crmena(False, ienm, "sector", aim)
- proutn("- ")
+ proutn(_("units to fire at %s- ") % crmena(False, ienm, "sector", aim))
+
key = scanner.next()
if key == IHALPHA and scanner.sees("no"):
no = True
# BSD Trek, from which we swiped the idea, can have up to 5.
def unschedule(evtype):
- # remove an event from the schedule
+ "Remove an event from the schedule."
game.future[evtype].date = FOREVER
return game.future[evtype]
def is_scheduled(evtype):
- # is an event of specified type scheduled
+ "Is an event of specified type scheduled."
return game.future[evtype].date != FOREVER
def scheduled(evtype):
- # when will this event happen?
+ "When will this event happen?"
return game.future[evtype].date
def schedule(evtype, offset):
- # schedule an event of specified type
+ "Schedule an event of specified type."
game.future[evtype].date = game.state.date + offset
return game.future[evtype]
def postpone(evtype, offset):
- # postpone a scheduled event
+ "Postpone a scheduled event."
game.future[evtype].date += offset
def cancelrest():
- # rest period is interrupted by event
+ "Rest period is interrupted by event."
if game.resting:
skip(1)
proutn(_("Mr. Spock- \"Captain, shall we cancel the rest period?\""))
return False
def events():
- # run through the event queue looking for things to do
+ "Run through the event queue looking for things to do."
i=0
fintim = game.state.date + game.optime; yank=0
ictbeam = False; istract = False
ev = event(); ev2 = event()
def tractorbeam(yank):
- # tractor beaming cases merge here
+ "Tractor-beaming cases merge here."
announce()
game.optime = (10.0/(7.5*7.5))*yank # 7.5 is yank rate (warp 7.5)
skip(1)
- proutn("***")
- crmshp()
- prout(_(" caught in long range tractor beam--"))
+ prout("***" + crmshp() + _(" caught in long range tractor beam--"))
# If Kirk & Co. screwing around on planet, handle
atover(True) # atover(true) is Grab
if game.alldone:
else:
game.quadrant = game.state.kcmdr[i]
game.sector = randplace(QUADSIZE)
- crmshp()
- prout(_(" is pulled to Quadrant %s, Sector %s") \
+ prout(crmshp() + _(" is pulled to Quadrant %s, Sector %s") \
% (game.quadrant, game.sector))
if game.resting:
prout(_("(Remainder of rest/repair period cancelled.)"))
schedule(FTBEAM, game.optime+expran(1.5*game.intime/len(game.state.kcmdr)))
def destroybase():
- # Code merges here for any commander destroying base
+ "Code merges here for any commander destroying a starbase."
# Not perfect, but will have to do
# Handle case where base is in same quadrant as starship
if game.battle == game.quadrant:
game.isatb = 0
else:
game.battle.invalidate()
-
if idebug:
prout("=== EVENTS from %.2f to %.2f:" % (game.state.date, fintim))
for i in range(1, NEVENTS):
prout(_("in Quadrant %s.") % w)
def wait():
- # wait on events
+ "Wait on events."
game.ididit = False
while True:
key = scanner.next()
# If the zap is too much, it gets destroyed.
def nova(nov):
- # star goes nova
+ "Star goes nova."
course = (0.0, 10.5, 12.0, 1.5, 9.0, 0.0, 3.0, 7.5, 6.0, 4.5)
newc = coord(); neighbor = coord(); bump = coord(0, 0)
if withprob(0.05):
return
# handle initial nova
game.quad[nov.x][nov.y] = IHDOT
- crmena(False, IHSTAR, "sector", nov)
- prout(_(" novas."))
+ prout(crmena(False, IHSTAR, "sector", nov) + _(" novas."))
game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1
game.state.starkl += 1
# Set up queue to recursively trigger adjacent stars
hits.append(neighbor)
game.state.galaxy[game.quadrant.x][game.quadrant.y].stars -= 1
game.state.starkl += 1
- crmena(True, IHSTAR, "sector", neighbor)
+ proutn(crmena(True, IHSTAR, "sector", neighbor))
prout(_(" novas."))
game.quad[neighbor.x][neighbor.y] = IHDOT
kount += 1
game.state.nplankl += 1
else:
game.state.worldkl += 1
- crmena(True, iquad, "sector", neighbor)
- prout(_(" destroyed."))
+ prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
game.iplnet.pclass = "destroyed"
game.iplnet = None
game.plnet.invalidate()
game.base.invalidate()
game.state.basekl += 1
newcnd()
- crmena(True, IHB, "sector", neighbor)
- prout(_(" destroyed."))
+ prout(crmena(True, IHB, "sector", neighbor) + _(" destroyed."))
game.quad[neighbor.x][neighbor.y] = IHDOT
elif iquad in (IHE, IHF): # Buffet ship
prout(_("***Starship buffeted by nova."))
deadkl(neighbor, iquad, neighbor)
break
newc = neighbor + neighbor - hits[mm]
- crmena(True, iquad, "sector", neighbor)
- proutn(_(" damaged"))
+ proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
if not VALID_SECTOR(newc.x, newc.y):
# can't leave quadrant
skip(1)
break
iquad1 = game.quad[newc.x][newc.y]
if iquad1 == IHBLANK:
- proutn(_(", blasted into "))
- crmena(False, IHBLANK, "sector", newc)
+ proutn(_(", blasted into ") + crmena(False, IHBLANK, "sector", newc))
skip(1)
deadkl(neighbor, iquad, newc)
break
return
def supernova(induced, w=None):
- # star goes supernova
+ "Star goes supernova."
num = 0; npdead = 0
nq = coord()
if w != None:
# Code from finish.c ends here.
def selfdestruct():
- # self-destruct maneuver
- # Finish with a BANG!
+ "Self-destruct maneuver. Finish with a BANG!"
scanner.chew()
if damaged(DCOMPTR):
prout(_("Computer damaged; cannot execute destruct sequence."))
stars()
if game.ship==IHE:
prouts("***")
- prouts(_("********* Entropy of "))
- crmshp()
- prouts(_(" maximized *********"))
+ prouts(_("********* Entropy of %s maximized *********") % crmshp())
skip(1)
stars()
skip(1)
skip(1)
prout(_("Your starship is a derelict in space."))
elif ifin == FBATTLE:
- proutn(_("The "))
- crmshp()
- prout(_(" has been destroyed in battle."))
+ prout(_("The %s has been destroyed in battle.") % crmshp())
skip(1)
prout(_("Dulce et decorum est pro patria mori."))
elif ifin == FNEG3:
prout(_("That was a great shot."))
skip(1)
elif ifin == FSNOVAED:
- proutn(_("The "))
- crmshp()
- prout(_(" has been fried by a supernova."))
+ prout(_("The %s has been fried by a supernova.") % crmshp())
prout(_("...Not even cinders remain..."))
elif ifin == FABANDN:
prout(_("You have been captured by the Klingons. If you still"))
prout(_("Starbase was unable to re-materialize your starship."))
prout(_("Sic transit gloria mundi"))
elif ifin == FPHASER:
- proutn(_("The "))
- crmshp()
- prout(_(" has been cremated by its own phasers."))
+ prout(_("The %s has been cremated by its own phasers.") % crmshp())
elif ifin == FLOST:
prout(_("You and your landing party have been"))
prout(_("converted to energy, disipating through space."))
skip(1)
prout(_("They are very fond of \"Captain Kirk\" soup."))
skip(1)
- proutn(_("Without your leadership, the "))
- crmshp()
- prout(_(" is destroyed."))
+ prout(_("Without your leadership, the %s is destroyed.") % crmshp())
elif ifin == FDPLANET:
prout(_("You and your mining party perish."))
skip(1)
prout(_("The Galileo is instantly annihilated by the supernova."))
prout(_("You and your mining party are atomized."))
skip(1)
- proutn(_("Mr. Spock takes command of the "))
- crmshp()
- prout(_(" and"))
- prout(_("joins the Romulans, reigning terror on the Federation."))
+ prout(_("Mr. Spock takes command of the %s and") % crmshp())
+ prout(_("joins the Romulans, wreaking terror on the Federation."))
elif ifin == FPNOVA:
prout(_("You and your mining party are atomized."))
skip(1)
- proutn(_("Mr. Spock takes command of the "))
- crmshp()
- prout(_(" and"))
- prout(_("joins the Romulans, reigning terror on the Federation."))
+ prout(_("Mr. Spock takes command of the %s and") % crmshp())
+ prout(_("joins the Romulans, wreaking terror on the Federation."))
elif ifin == FSTRACTOR:
prout(_("The shuttle craft Galileo is also caught,"))
prout(_("and breaks up under the strain."))
skip(1)
prout(_("Your debris is scattered for millions of miles."))
- proutn(_("Without your leadership, the "))
- crmshp()
- prout(_(" is destroyed."))
+ prout(_("Without your leadership, the %s is destroyed.") % crmshp())
elif ifin == FDRAY:
prout(_("The mutants attack and kill Spock."))
prout(_("Your ship is captured by Klingons, and"))
score()
def score():
- # compute player's score
+ "Compute player's score."
timused = game.state.date - game.indate
iskill = game.skill
if (timused == 0 or (game.state.remkl + len(game.state.kcmdr) + game.state.nscrem) != 0) and timused < 5.0:
prout(_("TOTAL SCORE %5d") % iscore)
def plaque():
- # emit winner's commemmorative plaque
+ "Emit winner's commemmorative plaque."
skip(2)
while True:
proutn(_("File or device name for your plaque: "))
curwnd = None
def outro():
- "wrap up, either normally or due to signal"
+ "Wrap up, either normally or due to signal"
if game.options & OPTION_CURSES:
#clear()
#curs_set(1)
skip(1)
def prouts(line):
- "print slowly!"
+ "Emit slowly!"
for c in line:
if not replayfp or replayfp.closed: # Don't slow down replays
time.sleep(0.03)
# Code from moving.c begins here
def imove(novapush):
- # movement execution for warp, impulse, supernova, and tractor-beam events
+ "Movement execution for warp, impulse, supernova, and tractor-beam events."
w = coord(); final = coord()
trbeam = False
skip(1)
prouts(_("***RED ALERT! RED ALERT!"))
skip(1)
- proutn("***")
- crmshp()
+ proutn("***" + crmshp())
proutn(_(" pulled into black hole at Sector %s") % w)
#
# Getting pulled into a black hole was certain
else:
# something else
skip(1)
- crmshp()
+ proutn(crmshp())
if iquad == IHWEB:
prout(_(" encounters Tholian web at %s;") % w)
else:
return
def dock(verbose):
- # dock our ship at a starbase
+ "Dock our ship at a starbase."
scanner.chew()
if game.condition == "docked" and verbose:
prout(_("Already docked."))
prout(_("You must first leave standard orbit."))
return
if not game.base.is_valid() or abs(game.sector.x-game.base.x) > 1 or abs(game.sector.y-game.base.y) > 1:
- crmshp()
- prout(_(" not adjacent to base."))
+ prout(crmshp() + _(" not adjacent to base."))
return
game.condition = "docked"
if "verbose":
# are always displayed y - x, where +y is downward!
def getcourse(isprobe, akey):
- # get course and distance
+ "Get a course and distance from the user."
key = 0
dquad = copy.copy(game.quadrant)
navmode = "unspecified"
return True
def impulse():
- # move under impulse power
+ "Move under impulse power."
game.ididit = False
if damaged(DIMPULS):
scanner.chew()
return
def warp(timewarp):
- # move under warp drive
+ "ove under warp drive."
blooey = False; twarp = False
if not timewarp: # Not WARPX entry
game.ididit = False
return
def setwarp():
- # change the warp factor
+ "Change the warp factor."
while True:
key=scanner.next()
if key != IHEOL:
return
def atover(igrab):
- # cope with being tossed out of quadrant by supernova or yanked by beam
+ "Cope with being tossed out of quadrant by supernova or yanked by beam."
scanner.chew()
# is captain on planet?
if game.landed:
if game.justin:
prouts(_("***RED ALERT! RED ALERT!"))
skip(1)
- proutn(_("The "))
- crmshp()
- prout(_(" has stopped in a quadrant containing"))
+ proutn(_("The %s has stopped in a quadrant containing") % crmshp())
prouts(_(" a supernova."))
skip(2)
- proutn(_("***Emergency automatic override attempts to hurl "))
- crmshp()
+ prout(_("***Emergency automatic override attempts to hurl ")+crmshp())
skip(1)
prout(_("safely out of quadrant."))
if not damaged(DRADIO):
finish(FWON) # Snova killed remaining enemy.
def timwrp():
- # let's do the time warp again
+ "Let's do the time warp again."
prout(_("***TIME WARP ENTERED."))
if game.state.snap and withprob(0.5):
# Go back in time
if game.iscraft == "offship" and not gotit and game.damage[DSHUTTL] >= 0.0:
prout(_("Checkov- \"Security reports the Galileo has reappeared in the dock!\""))
game.iscraft = "onship"
- #
-# * There used to be code to do the actual reconstrction here,
-# * but the starchart is now part of the snapshotted galaxy state.
-#
+ # There used to be code to do the actual reconstrction here,
+ # but the starchart is now part of the snapshotted galaxy state.
prout(_("Spock has reconstructed a correct star chart from memory"))
else:
# Go forward in time
events() # Stas Sergeev added this -- do pending events
def probe():
- # launch deep-space probe
+ "Launch deep-space probe."
# New code to launch a deep space probe
if game.nprobes == 0:
scanner.chew()
# problem.
def mayday():
- # yell for help from nearest starbase
+ "Yell for help from nearest starbase."
# There's more than one way to move in this game!
scanner.chew()
# Test for conditions which prevent calling for help
prout(_("Lt. Uhura- \"Captain, I'm not getting any response from Starbase.\""))
return
if game.landed:
- proutn(_("You must be aboard the "))
- crmshp()
- prout(".")
+ prout(_("You must be aboard the %s.") % crmshp())
return
# OK -- call for help from nearest starbase
game.nhelp += 1
newqad(True)
# dematerialize starship
game.quad[game.sector.x][game.sector.y]=IHDOT
- proutn(_("Starbase in Quadrant %s responds--") % game.quadrant)
- crmshp()
- prout(_(" dematerializes."))
- game.sector.x=0
+ proutn(_("Starbase in Quadrant %s responds--%s dematerializes") \
+ % (game.quadrant, crmshp()))
+ game.sector.invalidate()
for m in range(1, 5+1):
w = game.base.scatter()
- if VALID_SECTOR(ix,iy) and game.quad[ix][iy]==IHDOT:
+ if VALID_SECTOR(w.x,w.y) and game.quad[w.x][w.y]==IHDOT:
# found one -- finish up
game.sector = w
break
if m == 1: proutn(_("1st"))
elif m == 2: proutn(_("2nd"))
elif m == 3: proutn(_("3rd"))
- proutn(_(" attempt to re-materialize "))
- crmshp()
+ proutn(_(" attempt to re-materialize ") + crmshp())
game.quad[ix][iy]=(IHMATER0,IHMATER1,IHMATER2)[m-1]
textcolor("red")
warble()
# can't happen unless you have taken some prisoners.
def abandon():
- # abandon ship
+ "Abandon ship."
scanner.chew()
if game.condition=="docked":
if game.ship!=IHE:
if game.iscraft != "onship":
prout(_("Shuttle craft not currently available."))
return
- # Print abandon ship messages
+ # Emit abandon ship messages
skip(1)
prouts(_("***ABANDON SHIP! ABANDON SHIP!"))
skip(1)
# Code from planets.c begins here.
def consumeTime():
- # abort a lengthy operation if an event interrupts it
+ "Abort a lengthy operation if an event interrupts it."
game.ididit = True
events()
if game.alldone or game.state.galaxy[game.quadrant.x][game.quadrant.y].supernova or game.justin:
return False
def survey():
- # report on (uninhabited) planets in the galaxy
+ "Report on (uninhabited) planets in the galaxy."
iknow = False
skip(1)
scanner.chew()
prout(_("No information available."))
def orbit():
- # enter standard orbit
+ "Enter standard orbit."
skip(1)
scanner.chew()
if game.inorbit:
prout("There is no planet in this sector.")
return
if abs(game.sector.x-game.plnet.x)>1 or abs(game.sector.y-game.plnet.y)>1:
- crmshp()
- prout(_(" not adjacent to planet."))
+ prout(crmshp() + _(" not adjacent to planet."))
skip(1)
return
game.optime = randreal(0.02, 0.05)
game.ididit = True
def sensor():
- # examine planets in this quadrant
+ "Examine planets in this quadrant."
if damaged(DSRSENS):
if game.options & OPTION_TTY:
prout(_("Short range sensors damaged."))
prout(_(" is located at Sector %s, Captain.\"") % game.plnet)
def beam():
- # use the transporter
+ "Use the transporter."
nrgneed = 0
scanner.chew()
skip(1)
shuttle()
return
if not game.inorbit:
- crmshp()
- prout(_(" not in standard orbit."))
+ prout(crmshp() + _(" not in standard orbit."))
return
if game.shldup:
prout(_("Impossible to transport through shields."))
return
def mine():
- # strip-mine a world for dilithium
+ "Strip-mine a world for dilithium."
skip(1)
scanner.chew()
if not game.landed:
prout(_("You've already mined enough crystals for this trip."))
return
if game.icrystl and game.cryprob == 0.05:
- proutn(_("With all those fresh crystals aboard the "))
- crmshp()
- skip(1)
+ prout(_("With all those fresh crystals aboard the ") + crmshp())
prout(_("there's no reason to mine more at this time."))
return
game.optime = randreal(0.1, 0.3)*(ord(game.iplnet.pclass)-ord("L"))
game.imine = game.ididit = True
def usecrystals():
- # use dilithium crystals
+ "Use dilithium crystals."
game.ididit = False
skip(1)
scanner.chew()
game.ididit = True
def shuttle():
- # use shuttlecraft for planetary jaunt
+ "Use shuttlecraft for planetary jaunt."
scanner.chew()
skip(1)
if damaged(DSHUTTL):
prout(_("Shuttle craft is now serving Big Macs."))
return
if not game.inorbit:
- crmshp()
- prout(_(" not in standard orbit."))
+ prout(crmshp() + _(" not in standard orbit."))
return
if (game.iplnet.known != "shuttle_down") and game.iscraft != "onship":
prout(_("Shuttle craft not currently available."))
prout(_("Trip complete."))
return
else:
- # Kirk on ship
- # and so is Galileo
+ # Kirk on ship and so is Galileo
prout(_("Mining party assembles in the hangar deck,"))
prout(_("ready to board the shuttle craft \"Galileo\"."))
skip(1)
return
def deathray():
- # use the big zapper
+ "Use the big zapper."
game.ididit = False
skip(1)
scanner.chew()
# Code from reports.c begins here
def attackreport(curt):
- # report status of bases under attack
+ "eport status of bases under attack."
if not curt:
if is_scheduled(FCDBAS):
prout(_("Starbase in Quadrant %s is currently under Commander attack.") % game.battle)
skip(1)
def lrscan(silent):
- # long-range sensor scan
+ "Long-range sensor scan."
if damaged(DLRSENS):
# Now allow base's sensors if docked
if game.condition != "docked":
prout(" ")
def damagereport():
- # damage report
+ "Damage report."
jdam = False
scanner.chew()
prout(_("All devices functional."))
def rechart():
- # update the chart in the Enterprise's computer from galaxy data
+ "Update the chart in the Enterprise's computer from galaxy data."
game.lastchart = game.state.date
for i in range(GALSIZE):
for j in range(GALSIZE):
game.state.chart[i][j].stars = game.state.galaxy[i][j].stars
def chart():
- # display the star chart
+ "Display the star chart."
scanner.chew()
if (game.options & OPTION_AUTOSCAN):
lrscan(silent=True)
if game.lastchart < game.state.date and game.condition == "docked":
prout(_("Spock- \"I revised the Star Chart from the starbase's records.\""))
rechart()
-
prout(_(" STAR CHART FOR THE KNOWN GALAXY"))
if game.state.date > game.lastchart:
prout(_("(Last surveillance update %d stardates ago).") % ((int)(game.state.date-game.lastchart)))
skip(1)
def sectscan(goodScan, i, j):
- # light up an individual dot in a sector
+ "Light up an individual dot in a sector."
if goodScan or (abs(i-game.sector.x)<= 1 and abs(j-game.sector.y) <= 1):
if (game.quad[i][j]==IHMATER0) or (game.quad[i][j]==IHMATER1) or (game.quad[i][j]==IHMATER2) or (game.quad[i][j]==IHE) or (game.quad[i][j]==IHF):
if game.condition == "red": textcolor("red")
proutn("- ")
def status(req=0):
- # print status report lines
-
+ "Emit status report lines"
if not req or req == 1:
prstat(_("Stardate"), _("%.1f, Time Left %.2f") \
% (game.state.date, game.state.remtime))
attackreport(not req)
def request():
+ "Request specified status data, a historical relic from slow TTYs."
requests = ("da","co","po","ls","wa","en","to","sh","kl","sy", "ti")
while scanner.next() == IHEOL:
proutn(_("Information desired? "))
prout((" energy, torpedoes, shields, klingons, system, time."))
def srscan():
- # short-range scan
+ "Short-range scan."
goodScan=True
if damaged(DSRSENS):
# Allow base's sensors if docked
skip(1)
def eta():
- # use computer to get estimated time of arrival for a warp jump
+ "Use computer to get estimated time of arrival for a warp jump."
w1 = coord(); w2 = coord()
prompt = False
if damaged(DCOMPTR):
# Code from setup.c begins here
def prelim():
- # issue a historically correct banner
+ "Issue a historically correct banner."
skip(2)
prout(_("-SUPER- STAR TREK"))
skip(1)
# skip(1)
def freeze(boss):
- # save game
+ "Save game."
if boss:
scanner.token = "emsave.trk"
else:
fp.close()
def thaw():
- # retrieve saved game
+ "Retrieve saved game."
game.passwd[0] = '\0'
key = scanner.next()
if key == IHEOL:
)
def setup():
- # prepare to play, set up cosmos
+ "Prepare to play, set up cosmos."
w = coord()
# Decide how many of everything
if choose():
attack(torps_ok=False)
def choose():
- # choose your game type
+ "Choose your game type."
global thing
while True:
game.tourn = 0
setpassword()
if game.passwd == "debug":
idebug = True
- fputs("=== Debug mode enabled\n", sys.stdout)
-
+ prout("=== Debug mode enabled.")
# Use parameters to generate initial values of things
game.damfac = 0.5 * game.skill
game.inbase = randrange(BASEMIN, BASEMAX+1)
return False
def dropin(iquad=None):
- # drop a feature on a random dot in the current quadrant
+ "Drop a feature on a random dot in the current quadrant."
w = coord()
while True:
w = randplace(QUADSIZE)
return w
def newcnd():
- # update our alert status
+ "Update our alert status."
game.condition = "green"
if game.energy < 1000.0:
game.condition = "yellow"
game.condition="dead"
def newkling():
- # drop new Klingon into current quadrant
+ "Drop new Klingon into current quadrant."
return enemy(IHK, loc=dropin(), power=randreal(300,450)+25.0*game.skill)
def newqad(shutup):
- # set up a new state of quadrant, for when we enter or re-enter it
+ "Set up a new state of quadrant, for when we enter or re-enter it."
w = coord()
game.justin = True
game.klhere = 0
game.quad[QUADSIZE-1][QUADSIZE-1] = IHDOT
def setpassword():
- # set the self-destruct password
+ "Set the self-destruct password."
if game.options & OPTION_PLAIN:
while True:
scanner.chew()
def ACCEPT(cmd): return (not commands[cmd] or (commands[cmd] & game.options))
def listCommands():
- # generate a list of legal commands
+ "Generate a list of legal commands."
k = 0
proutn(_("LEGAL COMMANDS ARE:"))
for key in commands:
skip(1)
def helpme():
- # browse on-line help
- # Give help on commands
+ "Browse on-line help."
key = scanner.next()
while True:
if key == IHEOL:
fp.close()
def makemoves():
- # command-interpretation loop
+ "Command-interpretation loop."
v = 0
clrscr()
setwnd(message_window)
if idebug:
prout("=== Ending")
-def cramen(cmd):
- # return an enemy
- if cmd == IHR: s = _("Romulan")
- elif cmd == IHK: s = _("Klingon")
- elif cmd == IHC: s = _("Commander")
- elif cmd == IHS: s = _("Super-commander")
- elif cmd == IHSTAR: s = _("Star")
- elif cmd == IHP: s = _("Planet")
- elif cmd == IHB: s = _("Starbase")
- elif cmd == IHBLANK: s = _("Black hole")
- elif cmd == IHT: s = _("Tholian")
- elif cmd == IHWEB: s = _("Tholian web")
- elif cmd == IHQUEST: s = _("Stranger")
- elif cmd == IHW: s = _("Inhabited World")
+def cramen(type):
+ "Emit the name of an enemy or feature."
+ if type == 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")
else: s = "Unknown??"
- proutn(s)
+ return s
def crmena(stars, enemy, loctype, w):
- # print an enemy and his location
- if stars:
- proutn("***")
- cramen(enemy)
- proutn(_(" at "))
+ "Emit the name of an enemy and his location."
buf = ""
+ if stars:
+ buf += "***"
+ buf += cramen(enemy) + _(" at ")
if loctype == "quadrant":
- buf = _("Quadrant ")
+ buf += _("Quadrant ")
elif loctype == "sector":
- buf = _("Sector ")
- proutn(buf + `w`)
+ buf += _("Sector ")
+ return buf + `w`
def crmshp():
- # print our ship name
+ "Emit our ship name."
if game.ship == IHE:
s = _("Enterprise")
elif game.ship == IHF:
s = _("Faerie Queene")
else:
s = "Ship???"
- proutn(s)
+ return s
def stars():
- # print a line of stars
+ "Emit a line of stars"
prouts("******************************************************")
skip(1)
return -avrage*math.log(1e-7 + randreal())
def randplace(size):
- # choose a random location
+ "Choose a random location."
w = coord()
w.x = randrange(size)
w.y = randrange(size)
self.type = IHALPHA
self.real = None
return IHALPHA
- def push(self, toklist):
- self.inqueue += toklist
+ def push(self, tok):
+ self.inqueue.append(tok)
+ def waiting(self):
+ return self.inqueue
def chew(self):
# Demand input for next scan
- self.inqueue = None
+ self.inqueue = []
self.real = self.token = None
def chew2(self):
# return IHEOL next time
- self.inqueue = []
+ self.inqueue = [IHEOL]
self.real = self.token = None
def sees(self, s):
# compares s to item and returns true if it matches to the length of s
def int(self):
# Round token value to nearest integer
return int(round(scanner.real))
+ def getcoord(self):
+ s = coord()
+ scanner.next()
+ if scanner.type != IHREAL:
+ huh()
+ return None
+ s.x = scanner.int()-1
+ scanner.next()
+ if scanner.type != IHREAL:
+ huh()
+ return None
+ s.y = scanner.int()-1
+ return s
def ja():
- # yes-or-no confirmation
+ "Yes-or-no confirmation."
scanner.chew()
while True:
scanner.next()
proutn(_("Please answer with \"y\" or \"n\": "))
def huh():
- # complain about unparseable input
+ "Complain about unparseable input."
scanner.chew()
skip(1)
prout(_("Beg your pardon, Captain?"))
def debugme():
- # access to the internals for debugging
+ "Access to the internals for debugging."
proutn("Reset levels? ")
if ja() == True:
if game.energy < game.inenrg:
logfp.write("# options %s\n" % " ".join(arguments))
random.seed(seed)
scanner = sstscanner()
- scanner.push(arguments)
+ map(scanner.push, arguments)
try:
iostart()
while True: # Play a game