Navigation is finally subsumed by the course object.

[super-star-trek.git] / src / sst.py

diff --git a/src/sst.py b/src/sst.py
index 6d2d8f56d9b4f9a70c3d76f90a082603d92c0476..3cfffb7209734ef84e10a9c94e4cfb597fc63d42 100644 (file)
--- a/src/sst.py
+++ b/src/sst.py
@@ -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,16 @@ class coord:
         else:
             s.j = self.j / abs(self.j)
         return s
+    def quadrant(self):
+        #print "Location %s -> %s" % (self, (self / QUADSIZE).roundtogrid())
+        return self.roundtogrid() / QUADSIZE
+    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"
@@ -3596,19 +3599,10 @@ def imove(course=None, novapush=False):
         newcnd()
         drawmaps(0)
         setwnd(message_window)
-    w.i = w.j = 0
+
     if game.inorbit:
        prout(_("Helmsman Sulu- \"Leaving standard orbit.\""))
        game.inorbit = False
-    angle = ((15.0 - course.bearing) * 0.5235988)
-    deltax = -math.sin(angle)
-    deltay = math.cos(angle)
-    if math.fabs(deltax) > math.fabs(deltay):
-       bigger = math.fabs(deltax)
-    else:
-       bigger = math.fabs(deltay)
-    deltay /= bigger
-    deltax /= bigger
     # If tractor beam is to occur, don't move full distance 
     if game.state.date+game.optime >= scheduled(FTBEAM):
        trbeam = True
@@ -3617,14 +3611,10 @@ def imove(course=None, novapush=False):
        game.optime = scheduled(FTBEAM) - game.state.date + 1e-5
     # Move within the quadrant 
     game.quad[game.sector.i][game.sector.j] = IHDOT
-    x = game.sector.i
-    y = game.sector.j
     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():
+        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:
@@ -3632,31 +3622,28 @@ def imove(course=None, novapush=False):
                 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
+                if course.final.i < 0:
+                    course.final.i = -course.final.i
                     kink = True
-                if w.j < 0:
-                    w.j = -w.j
+                if course.final.j < 0:
+                    course.final.j = -course.final.j
                     kink = True
-                if w.i >= GALSIZE*QUADSIZE:
-                    w.i = (GALSIZE*QUADSIZE*2) - w.i
+                if course.final.i >= GALSIZE*QUADSIZE:
+                    course.final.i = (GALSIZE*QUADSIZE*2) - course.final.i
                     kink = True
-                if w.j >= GALSIZE*QUADSIZE:
-                    w.j = (GALSIZE*QUADSIZE*2) - w.j
+                if course.final.j >= GALSIZE*QUADSIZE:
+                    course.final.j = (GALSIZE*QUADSIZE*2) - course.final.j
                     kink = True
                 if kink:
                     kinks += 1
@@ -3675,10 +3662,8 @@ def imove(course=None, novapush=False):
             # 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)
+            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
@@ -3691,8 +3676,8 @@ def imove(course=None, novapush=False):
             # 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):
-                game.sector = w
                 for enemy in game.enemies:
                     if enemy.kloc == game.sector:
                         break
@@ -3728,9 +3713,7 @@ def imove(course=None, novapush=False):
                 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
+                game.sector = w
                 if game.energy <= 0:
                     finish(FNRG)
                     return
@@ -3923,6 +3906,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:
@@ -3949,9 +3936,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):