X-Git-Url: https://jxself.org/git/?p=super-star-trek.git;a=blobdiff_plain;f=src%2Fsst.py;h=1133bcfc83fff5bf93c01b3bacffb13ddb3c2610;hp=bcd8499ffc54a947d0c3d2ebd986f05511dd14fd;hb=dbca5a522c4b10da953b18847b011db581363263;hpb=75f5b1c071664586ca048275e959cdfe0e2b2b87

diff --git a/src/sst.py b/src/sst.py
index bcd8499..1133bcf 100644
--- a/src/sst.py
+++ b/src/sst.py
@@ -201,10 +201,6 @@ FOREVER 	= 1e30
 MAXBURST	= 3
 MINCMDR 	= 10
 
-# These functions hide the difference between 0-origin and 1-origin addressing.
-def VALID_QUADRANT(x, y):	return ((x)>=0 and (x)<GALSIZE and (y)>=0 and (y)<GALSIZE)
-def VALID_SECTOR(x, y):	return ((x)>=0 and (x)<QUADSIZE and (y)>=0 and (y)<QUADSIZE)
-
 # How to represent features
 IHR = 'R',
 IHK = 'K',
@@ -232,6 +228,10 @@ class coord:
     def __init__(self, x=None, y=None):
         self.i = x
         self.j = y
+    def valid_quadrant(self):
+        return self.i>=0 and self.i<GALSIZE and self.j>=0 and self.j<GALSIZE
+    def valid_sector(self):
+	return self.i>=0 and self.i<QUADSIZE and self.j>=0 and self.j<QUADSIZE
     def invalidate(self):
         self.i = self.j = None
     def is_valid(self):
@@ -250,12 +250,12 @@ class coord:
         return coord(self.i*other, self.j*other)
     def __div__(self, other):
         return coord(self.i/other, self.j/other)
+    def __mod__(self, other):
+        return coord(self.i % other, self.j % other)
     def __rdiv__(self, other):
         return coord(self.i/other, self.j/other)
     def roundtogrid(self):
         return coord(int(round(self.i)), int(round(self.j)))
-    def trunctogrid(self):
-        return coord(int(round(self.i)), int(round(self.j)))
     def distance(self, other=None):
         if not other: other = coord(0, 0)
         return math.sqrt((self.i - other.i)**2 + (self.j - other.j)**2)
@@ -273,13 +273,15 @@ class coord:
         else:
             s.j = self.j / abs(self.j)
         return s
+    def quadrant(self):
+        return (self / QUADSIZE).roundtogrid()
+    def sector(self):
+        return self.roundtogrid() % QUADSIZE
     def scatter(self):
         s = coord()
         s.i = self.i + randrange(-1, 2)
         s.j = self.j + randrange(-1, 2)
         return s
-    def __hash__(self):
-        return hash((x, y))
     def __str__(self):
         if self.i == None or self.j == None:
             return "Nowhere"
@@ -602,7 +604,7 @@ def randreal(*args):
 
 def welcoming(iq):
     "Would this quadrant welcome another Klingon?"
-    return VALID_QUADRANT(iq.i,iq.j) and \
+    return iq.valid_quadrant() and \
 	not game.state.galaxy[iq.i][iq.j].supernova and \
 	game.state.galaxy[iq.i][iq.j].klingons < MAXKLQUAD
 
@@ -1267,32 +1269,30 @@ def torpedo(origin, bearing, dispersion, number, nburst):
 	setwnd(srscan_window)
     else: 
 	setwnd(message_window)
-    shoved = False
     ac = bearing + 0.25*dispersion	# dispersion is a random variable
     bullseye = (15.0 - bearing)*0.5235988
     track = course(bearing=ac, distance=QUADSIZE, origin=cartesian(origin)) 
-    jw = coord(0, 0)
+    bumpto = coord(0, 0)
     # Loop to move a single torpedo 
+    setwnd(message_window)
     for step in range(1, QUADSIZE*2):
 	track.next()
         w = track.sector()
-	if not VALID_SECTOR(w.i, w.j):
+	if not w.valid_sector():
 	    break
 	iquad=game.quad[w.i][w.j]
 	tracktorpedo(origin, w, step, number, nburst, iquad)
 	if iquad==IHDOT:
 	    continue
 	# hit something 
-	setwnd(message_window)
-	if damaged(DSRSENS) and not game.condition=="docked":
+	if not damaged(DSRSENS) or game.condition == "docked":
 	    skip(1);	# start new line after text track 
 	if iquad in (IHE, IHF): # Hit our ship 
 	    skip(1)
 	    prout(_("Torpedo hits %s.") % crmshp())
 	    hit = 700.0 + randreal(100) - \
-		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-angle))
+		1000.0 * (w-origin).distance() * math.fabs(math.sin(bullseye-track.angle))
 	    newcnd(); # we're blown out of dock 
-	    # We may be displaced. 
 	    if game.landed or game.condition=="docked":
 		return hit # Cheat if on a planet 
 	    ang = track.angle + 2.5*(randreal()-0.5)
@@ -1301,19 +1301,25 @@ def torpedo(origin, bearing, dispersion, number, nburst):
 		temp = math.fabs(math.cos(ang))
 	    xx = -math.sin(ang)/temp
 	    yy = math.cos(ang)/temp
-	    jw.i = int(w.i+xx+0.5)
-	    jw.j = int(w.j+yy+0.5)
-	    if not VALID_SECTOR(jw.i, jw.j):
+	    bumpto.i = int(w.i+xx+0.5)
+	    bumpto.j = int(w.j+yy+0.5)
+	    if not bumpto.valid_sector():
 		return hit
-	    if game.quad[jw.i][jw.j]==IHBLANK:
+	    if game.quad[bumpto.i][bumpto.j]==IHBLANK:
 		finish(FHOLE)
 		return hit
-	    if game.quad[jw.i][jw.j]!=IHDOT:
+	    if game.quad[bumpto.i][bumpto.j]!=IHDOT:
 		# can't move into object 
 		return hit
-	    game.sector = jw
+	    game.sector = bumpto
 	    proutn(crmshp())
-	    shoved = True
+            game.quad[w.i][w.j]=IHDOT
+            game.quad[bumpto.i][bumpto.j]=iquad
+            prout(_(" displaced by blast to Sector %s ") % bumpto)
+            for enemy in game.enemies:
+                enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
+            game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+            return None
 	elif iquad in (IHC, IHS, IHR, IHK): # Hit a regular enemy 
 	    # find the enemy 
 	    if iquad in (IHC, IHS) and withprob(0.05):
@@ -1344,23 +1350,25 @@ def torpedo(origin, bearing, dispersion, number, nburst):
 		temp = math.fabs(math.cos(ang))
 	    xx = -math.sin(ang)/temp
 	    yy = math.cos(ang)/temp
-	    jw.i = int(w.i+xx+0.5)
-	    jw.j = int(w.j+yy+0.5)
-	    if not VALID_SECTOR(jw.i, jw.j):
+	    bumpto.i = int(w.i+xx+0.5)
+	    bumpto.j = int(w.j+yy+0.5)
+            if not bumpto.valid_sector():
 		prout(_(" damaged but not destroyed."))
 		return
-	    if game.quad[jw.i][jw.j]==IHBLANK:
+	    if game.quad[bumpto.i][bumpto.j] == IHBLANK:
 		prout(_(" buffeted into black hole."))
-		deadkl(w, iquad, jw)
-		return None
-	    if game.quad[jw.i][jw.j]!=IHDOT:
-		# can't move into object 
+		deadkl(w, iquad, bumpto)
+	    if game.quad[bumpto.i][bumpto.j] != IHDOT:
 		prout(_(" damaged but not destroyed."))
-		return None
-	    proutn(_(" damaged--"))
-	    enemy.kloc = jw
-	    shoved = True
-	    break
+            else:
+                prout(_(" damaged-- displaced by blast to Sector %s ")%bumpto)
+                enemy.kloc = bumpto
+                game.quad[w.i][w.j]=IHDOT
+                game.quad[bumpto.i][bumpto.j]=iquad
+                for enemy in game.enemies:
+                    enemy.kdist = enemy.kavgd = (game.sector-enemy.kloc).distance()
+                game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
+            return None
 	elif iquad == IHB: # Hit a base 
 	    skip(1)
 	    prout(_("***STARBASE DESTROYED.."))
@@ -1456,16 +1464,6 @@ def torpedo(origin, bearing, dispersion, number, nburst):
 	    skip(1)
 	    return None
 	break
-    if curwnd!=message_window:
-	setwnd(message_window)
-    if shoved:
-	game.quad[w.i][w.j]=IHDOT
-	game.quad[jw.i][jw.j]=iquad
-	prout(_(" displaced by blast to Sector %s ") % jw)
-	for ll in range(len(game.enemies)):
-	    game.enemies[ll].kdist = game.enemies[ll].kavgd = (game.sector-game.enemies[ll].kloc).distance()
-        game.enemies.sort(lambda x, y: cmp(x.kdist, y.kdist))
-	return None
     skip(1)
     prout(_("Torpedo missed."))
     return None;
@@ -1697,7 +1695,7 @@ def deadkl(w, type, mv):
 
 def targetcheck(w):
     "Return None if target is invalid, otherwise return a course angle."
-    if not VALID_SECTOR(w.i, w.j):
+    if not w.valid_sector():
 	huh()
 	return None
     delta = coord()
@@ -2134,7 +2132,7 @@ def phasers():
     if ifast:
 	skip(1)
 	if no == 0:
-	    if withprob(0.99):
+	    if withprob(0.01):
 		prout(_("Sulu-  \"Sir, the high-speed shield control has malfunctioned . . ."))
 		prouts(_("         CLICK   CLICK   POP  . . ."))
 		prout(_(" No response, sir!"))
@@ -2453,14 +2451,14 @@ def events():
 	elif evcode == FDSPROB: # Move deep space probe 
 	    schedule(FDSPROB, 0.01)
             if game.probe.next(grain=QUADSIZE):
-		if not VALID_QUADRANT(game.probe.quadrant().i, game.probe.quadrant().j) or \
+		if not game.probe.quadrant().valid_quadrant() or \
 		    game.state.galaxy[game.probe.quadrant().i][game.probe.quadrant().j].supernova:
 		    # Left galaxy or ran into supernova
                     if communicating():
 			announce()
 			skip(1)
 			proutn(_("Lt. Uhura-  \"The deep space probe "))
-			if not VALID_QUADRANT(game.probe.quadrant().i, game.probe.quadrant().j):
+			if not game.probe.quadrant().valid_quadrant():
 			    prout(_("has left the galaxy.\""))
 			else:
 			    prout(_("is no longer transmitting.\""))
@@ -2544,14 +2542,15 @@ def events():
 		continue		# full right now 
 	    # reproduce one Klingon 
 	    w = ev.quadrant
+            m = coord()
 	    if game.klhere >= MAXKLQUAD:
                 try:
                     # this quadrant not ok, pick an adjacent one 
-                    for i in range(w.i - 1, w.i + 2):
-                        for j in range(w.j - 1, w.j + 2):
-                            if not VALID_QUADRANT(i, j):
+                    for m.i in range(w.i - 1, w.i + 2):
+                        for m.j in range(w.j - 1, w.j + 2):
+                            if not m.valid_quadrant():
                                 continue
-                            q = game.state.galaxy[w.i][w.j]
+                            q = game.state.galaxy[m.i][m.j]
                             # check for this quad ok (not full & no snova) 
                             if q.klingons >= MAXKLQUAD or q.supernova:
                                 continue
@@ -2559,7 +2558,7 @@ def events():
                     else:
                         continue	# search for eligible quadrant failed
                 except "FOUNDIT":
-                    w.i = i; w.j = j
+                    w = m
 	    # deliver the child 
 	    game.state.remkl += 1
 	    q.klingons += 1
@@ -2568,7 +2567,6 @@ def events():
 		game.enemies.append(newkling())
 	    # recompute time left
             game.recompute()
-	    # report the disaster if we can 
 	    if communicating():
 		if game.quadrant == w:
 		    prout(_("Spock- sensors indicate the Klingons have"))
@@ -2654,7 +2652,7 @@ def nova(nov):
                 if offset.j==0 and offset.i==0:
                     continue
                 neighbor = start + offset
-                if not VALID_SECTOR(neighbor.j, neighbor.i):
+                if not neighbor.valid_sector():
                     continue
                 iquad = game.quad[neighbor.i][neighbor.j]
                 # Empty space ends reaction
@@ -2726,7 +2724,7 @@ def nova(nov):
                         break
                     newc = neighbor + neighbor - hits[mm]
                     proutn(crmena(True, iquad, "sector", neighbor) + _(" damaged"))
-                    if not VALID_SECTOR(newc.i, newc.j):
+                    if not newc.valid_sector():
                         # can't leave quadrant 
                         skip(1)
                         break
@@ -3525,7 +3523,7 @@ def tracktorpedo(origin, w, step, i, n, iquad):
 	if step == 1:
 	    if n != 1:
 		skip(1)
-		proutn(_("Track for %s torpedo number %d-  ") % (game.quad[origin.i][origin.j],i+1))
+		proutn(_("Track for torpedo number %d-  ") % (i+1))
 	    else:
 		skip(1)
 		proutn(_("Torpedo track- "))
@@ -3623,130 +3621,124 @@ def imove(course=None, novapush=False):
     game.quad[game.sector.i][game.sector.j] = IHDOT
     x = game.sector.i
     y = game.sector.j
-    n = int(10.0*course.distance*bigger+0.5)
-    if n > 0:
-	for m in range(1, n+1):
-            x += deltax
-            y += deltay
-	    w.i = int(round(x))
-	    w.j = int(round(y))
-	    if not VALID_SECTOR(w.i, w.j):
-		# 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
-		# compute final position -- new quadrant and sector 
-		x = (QUADSIZE*game.quadrant.i)+game.sector.i
-		y = (QUADSIZE*game.quadrant.j)+game.sector.j
-		w.i = int(round(x+QUADSIZE*course.distance*bigger*deltax))
-		w.j = int(round(y+QUADSIZE*course.distance*bigger*deltay))
-		# check for edge of galaxy 
-		kinks = 0
-                while True:
-		    kink = False
-		    if w.i < 0:
-			w.i = -w.i
-			kink = True
-		    if w.j < 0:
-			w.j = -w.j
-			kink = True
-		    if w.i >= GALSIZE*QUADSIZE:
-			w.i = (GALSIZE*QUADSIZE*2) - w.i
-			kink = True
-		    if w.j >= GALSIZE*QUADSIZE:
-			w.j = (GALSIZE*QUADSIZE*2) - w.j
-			kink = True
-		    if kink:
-			kinks += 1
-                    else:
+    for m in range(course.moves):
+        x += deltax
+        y += deltay
+        w.i = int(round(x))
+        w.j = int(round(y))
+        if not w.valid_sector():
+            # Leaving quadrant -- allow final enemy attack 
+            # Don't do it if being pushed by Nova 
+            if len(game.enemies) != 0 and not novapush:
+                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 
+            w = course.final
+            kinks = 0
+            while True:
+                kink = False
+                if w.i < 0:
+                    w.i = -w.i
+                    kink = True
+                if w.j < 0:
+                    w.j = -w.j
+                    kink = True
+                if w.i >= GALSIZE*QUADSIZE:
+                    w.i = (GALSIZE*QUADSIZE*2) - w.i
+                    kink = True
+                if w.j >= GALSIZE*QUADSIZE:
+                    w.j = (GALSIZE*QUADSIZE*2) - w.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 
+                return
+            game.quadrant.i = w.i/QUADSIZE
+            game.quadrant.j = w.j/QUADSIZE
+            game.sector.i = w.i - (QUADSIZE*game.quadrant.i)
+            game.sector.j = w.j - (QUADSIZE*game.quadrant.j)
+            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)  
+            return
+        iquad = game.quad[w.i][w.j]
+        if iquad != IHDOT:
+            # object encountered in flight path 
+            stopegy = 50.0*course.distance/game.optime
+            course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
+            if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST):
+                game.sector = w
+                for enemy in game.enemies:
+                    if enemy.kloc == game.sector:
                         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 
-		    return
-		game.quadrant.i = w.i/QUADSIZE
-		game.quadrant.j = w.j/QUADSIZE
-		game.sector.i = w.i - (QUADSIZE*game.quadrant.i)
-		game.sector.j = w.j - (QUADSIZE*game.quadrant.j)
-		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)  
-		return
-	    iquad = game.quad[w.i][w.j]
-	    if iquad != IHDOT:
-		# object encountered in flight path 
-		stopegy = 50.0*course.dist/game.optime
-		course.distance = (game.sector - w).distance() / (QUADSIZE * 1.0)
-                if iquad in (IHT, IHK, IHC, IHS, IHR, IHQUEST):
-		    game.sector = w
-                    for enemy in game.enemies:
-                        if enemy.kloc == game.sector:
-                            break
-		    collision(rammed=False, enemy=enemy)
-		    final = game.sector
-		elif iquad == IHBLANK:
-		    skip(1)
-		    prouts(_("***RED ALERT!  RED ALERT!"))
-		    skip(1)
-		    proutn("***" + crmshp())
-		    proutn(_(" pulled into black hole at Sector %s") % w)
-		    # Getting pulled into a black hole was certain
-		    # death in Almy's original.  Stas Sergeev added a
-		    # possibility that you'll get timewarped instead.
-		    n=0
-		    for m in range(NDEVICES):
-			if game.damage[m]>0: 
-			    n += 1
-		    probf=math.pow(1.4,(game.energy+game.shield)/5000.0-1.0)*math.pow(1.3,1.0/(n+1)-1.0)
-		    if (game.options & OPTION_BLKHOLE) and withprob(1-probf): 
-			timwrp()
-		    else: 
-			finish(FHOLE)
-		    return
-		else:
-		    # something else 
-		    skip(1)
-		    proutn(crmshp())
-		    if iquad == IHWEB:
-			prout(_(" encounters Tholian web at %s;") % w)
-		    else:
-			prout(_(" blocked by object at %s;") % w)
-		    proutn(_("Emergency stop required "))
-		    prout(_("%2d units of energy.") % int(stopegy))
-		    game.energy -= stopegy
-		    final.i = int(round(deltax))
-		    final.j = int(round(deltay))
-		    game.sector = final
-		    if game.energy <= 0:
-			finish(FNRG)
-			return
-                # We're here!
-		no_quad_change()
+                collision(rammed=False, enemy=enemy)
+                final = game.sector
+            elif iquad == IHBLANK:
+                skip(1)
+                prouts(_("***RED ALERT!  RED ALERT!"))
+                skip(1)
+                proutn("***" + crmshp())
+                proutn(_(" pulled into black hole at Sector %s") % w)
+                # Getting pulled into a black hole was certain
+                # death in Almy's original.  Stas Sergeev added a
+                # possibility that you'll get timewarped instead.
+                n=0
+                for m in range(NDEVICES):
+                    if game.damage[m]>0: 
+                        n += 1
+                probf=math.pow(1.4,(game.energy+game.shield)/5000.0-1.0)*math.pow(1.3,1.0/(n+1)-1.0)
+                if (game.options & OPTION_BLKHOLE) and withprob(1-probf): 
+                    timwrp()
+                else: 
+                    finish(FHOLE)
                 return
+            else:
+                # something else 
+                skip(1)
+                proutn(crmshp())
+                if iquad == IHWEB:
+                    prout(_(" encounters Tholian web at %s;") % w)
+                else:
+                    prout(_(" blocked by object at %s;") % w)
+                proutn(_("Emergency stop required "))
+                prout(_("%2d units of energy.") % int(stopegy))
+                game.energy -= stopegy
+                final.i = int(round(deltax))
+                final.j = int(round(deltay))
+                game.sector = final
+                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
@@ -3890,7 +3882,7 @@ def getcourse(isprobe):
 		dsect.i = xi
 		dsect.j = xj
 	    itemp = "normal"
-	if not VALID_QUADRANT(dquad.i,dquad.j) or not VALID_SECTOR(dsect.i,dsect.j):
+	if not dquad.valid_quadrant() or not dsect.valid_sector():
 	    huh()
 	    raise TrekError
 	skip(1)
@@ -3933,6 +3925,10 @@ class course:
     def __init__(self, bearing, distance, origin=None): 
         self.distance = distance
         self.bearing = bearing
+        if origin is None:
+            self.origin = cartesian(game.quadrant, game.sector)
+        else:
+            self.origin = origin
         # The bearing() code we inherited from FORTRAN is actually computing
         # clockface directions!
         if self.bearing < 0.0:
@@ -3945,7 +3941,8 @@ class course:
         self.increment = coord(-math.sin(self.angle), math.cos(self.angle))
         bigger = max(abs(self.increment.i), abs(self.increment.j))
         self.increment /= bigger
-        self.moves = 10*self.distance*bigger +0.5
+        self.moves = int(round(10*self.distance*bigger))
+        self.final = (self.location + self.moves*self.increment).roundtogrid()
     def next(self, grain=1):
         "Next step on course."
         self.moves -=1
@@ -3958,9 +3955,9 @@ class course:
         else:
             return False
     def quadrant(self):
-        return (self.location / QUADSIZE).roundtogrid()
+        return self.location.quadrant()
     def sector(self):
-        return coord(int(round(self.location.i)) % QUADSIZE, int(round(self.location.j)) % QUADSIZE)
+        return self.location.sector()
     def power(self, warp):
 	return self.distance*(warp**3)*(game.shldup+1)
     def time(self, warp):
@@ -4108,7 +4105,7 @@ def warp(course, involuntary):
 		ix = x + 0.5
 		y += deltay
 		iy = y +0.5
-		if not VALID_SECTOR(ix, iy):
+		if not coord(ix, iy).valid_sector():
 		    break
 		if game.quad[ix][iy] != IHDOT:
 		    blooey = False
@@ -4390,7 +4387,7 @@ def mayday():
     game.sector.invalidate()
     for m in range(1, 5+1):
         w = game.base.scatter() 
-	if VALID_SECTOR(w.i,w.j) and game.quad[w.i][w.j]==IHDOT:
+	if w.valid_sector() and game.quad[w.i][w.j]==IHDOT:
 	    # found one -- finish up 
             game.sector = w
 	    break
@@ -4493,7 +4490,7 @@ def abandon():
 	    game.quad[game.sector.i][game.sector.j] = IHDOT
 	    for l in range(QUADSIZE):
 		game.sector = game.base.scatter()
-		if VALID_SECTOR(game.sector.i, game.sector.j) and \
+		if game.sector.valid_sector() and \
                        game.quad[game.sector.i][game.sector.j] == IHDOT:
                     break
 	    if l < QUADSIZE+1:
@@ -5089,7 +5086,7 @@ def lrscan(silent):
         if not silent:
             proutn(" ")
         for y in range(game.quadrant.j-1, game.quadrant.j+2):
-	    if not VALID_QUADRANT(x, y):
+	    if not coord(x, y).valid_quadrant():
                 if not silent:
                     proutn("  -1")
 	    else:
@@ -5314,7 +5311,7 @@ def eta():
 	    w2.j = 0
 	else:
 	    w2.j=QUADSIZE-1
-    if not VALID_QUADRANT(w1.i, w1.j) or not VALID_SECTOR(w2.i, w2.j):
+    if not w1.valid_quadrant() or not w2.valid_sector():
 	huh()
 	return
     dist = math.sqrt((w1.j-game.quadrant.j+(w2.j-game.sector.j)/(QUADSIZE*1.0))**2+