Remove unused pos arg.

[tabakrolletjie.git] / tabakrolletjie / rays.py

diff --git a/tabakrolletjie/rays.py b/tabakrolletjie/rays.py
index 65fbc3d628b19de13a237124c89f73484ab5e5a5..a475d8fb27bb6c680a90555cad7dc2a4f6043954 100644 (file)
--- a/tabakrolletjie/rays.py
+++ b/tabakrolletjie/rays.py
@@ -12,7 +12,7 @@ from .constants import SCREEN_SIZE
 from .utils import debug_timer
 
 
 from .utils import debug_timer
 
 

-def screen_rays(pos):
+def screen_rays():

     """ An iterable that returns ordered rays from pos to the edge of the
         screen, starting with the edge point (0, 0) and continuing clockwise
         in pymunk coordinates.
     """ An iterable that returns ordered rays from pos to the edge of the
         screen, starting with the edge point (0, 0) and continuing clockwise
         in pymunk coordinates.


@@ -40,7 +40,7 @@ def calculate_ray_polys(space, position, light_filter):
     vertices = [position]
     start, end = None, None
     ray_polys = []
     vertices = [position]
     start, end = None, None
     ray_polys = []

-    for ray in screen_rays(position):
+    for ray in screen_rays():

         info = space.segment_query_first(position, ray, 1, light_filter)
         point = ray if info is None else info.point
         vertices.append(point)
         info = space.segment_query_first(position, ray, 1, light_filter)
         point = ray if info is None else info.point
         vertices.append(point)


@@ -84,9 +84,12 @@ class RayPolyManager(object):
         self._position = pymunk.Vec2d(position)  # light's position
         self._ray_filter = ray_filter  # light filter
         self._rays = []  # list of RayPolys
         self._position = pymunk.Vec2d(position)  # light's position
         self._ray_filter = ray_filter  # light filter
         self._rays = []  # list of RayPolys

+        self._direction = None  # normal vector for direction

         self._start = None  # normal vector in direction of start angle limit
         self._end = None  # normal vector in direction of end angle limit
         self._set_angle_limits(direction, spread)
         self._start = None  # normal vector in direction of start angle limit
         self._end = None  # normal vector in direction of end angle limit
         self._set_angle_limits(direction, spread)

+        if direction:
+            self.direction = direction  # Update direction

         self._max_radius = None  # maximum radius in pixels
         self._min_radius = None  # minimum radius in pixels
         self._set_radius_limits(radius_limits)
         self._max_radius = None  # maximum radius in pixels
         self._min_radius = None  # minimum radius in pixels
         self._set_radius_limits(radius_limits)


@@ -127,7 +130,7 @@ class RayPolyManager(object):
         self._min_radius = value or 0.0
 
     def reaches(self, position):
         self._min_radius = value or 0.0
 
     def reaches(self, position):

-        distance = self.position.get_distance(self.position)
+        distance = self.position.get_distance(position)

         return (self._min_radius <= distance <= self._max_radius)
 
     def _set_radius_limits(self, radius_limits):
         return (self._min_radius <= distance <= self._max_radius)
 
     def _set_radius_limits(self, radius_limits):


@@ -141,21 +144,37 @@ class RayPolyManager(object):
             self._max_radius = radius_limits[1]
 
     def rotatable(self):
             self._max_radius = radius_limits[1]
 
     def rotatable(self):

-        return self._start is not None
+        return self._direction is not None

 
 

-    def rotate_degrees(self, degrees):
-        self._start.rotate_degrees(degrees)
-        self._end.rotate_degrees(degrees)
+    @property
+    def direction(self):
+        if self._direction is None:
+            return 0
+        return self._direction.angle_degrees
+
+    @direction.setter
+    def direction(self, degrees):
+        spread = self._direction.get_angle_between(self._start)
+        self._direction.angle_degrees = degrees
+        self._start = self._direction.rotated(spread)
+        self._end = self._direction.rotated(-spread)

         self._poly_cache = None
 
         self._poly_cache = None
 

+    @property
+    def spread(self):
+        if not self._direction:
+            return 2 * math.pi
+        return math.fabs(self._start.get_angle_between(self._end))
+

     def _set_angle_limits(self, direction, spread):
         if direction is None or spread is None:
     def _set_angle_limits(self, direction, spread):
         if direction is None or spread is None:

+            self._direction = None

             self._start = None
             self._end = None
         else:
             self._start = None
             self._end = None
         else:

-            n = pymunk.Vec2d(1, 0)
-            self._start = n.rotated_degrees(-spread/2.)
-            self._end = n.rotated_degrees(spread/2.)
+            self._direction = pymunk.Vec2d(1, 0)
+            self._start = self._direction.rotated_degrees(-spread/2.)
+            self._end = self._direction.rotated_degrees(spread/2.)

         self._poly_cache = None
 
     def polys(self):
         self._poly_cache = None
 
     def polys(self):