class RayPolyManager(object):
def __init__(
- self, body, position, ray_filter, radius_limits, angle_limits):
+ self, body, position, ray_filter, radius_limits, direction,
+ spread):
self._body = body # light's body
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(angle_limits)
+ 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)
return self._max_radius
@max_radius.setter
- def max_radius_setter(self, value):
+ def max_radius(self, value):
self._max_radius = value or 0.0
@property
return self._min_radius
@min_radius.setter
- def min_radius_setter(self, value):
+ def min_radius(self, value):
self._min_radius = value or 0.0
+ def reaches(self, position):
+ distance = self.position.get_distance(self.position)
+ return (self._min_radius <= distance <= self._max_radius)
+
def _set_radius_limits(self, radius_limits):
if radius_limits is None or not radius_limits[0]:
self._min_radius = 0
else:
self._max_radius = radius_limits[1]
- def rotate_degrees(self, degrees):
- self._start.rotate_degrees(degrees)
- self._end.rotate_degrees(degrees)
+ def rotatable(self):
+ return self._direction is not None
+
+ @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
- def _set_angle_limits(self, angle_limits):
- if angle_limits is 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:
+ self._direction = None
self._start = None
self._end = None
else:
- self._start = pymunk.Vec2d(1, 0).rotated(
- to_pymunk_radians(angle_limits[0]))
- self._end = pymunk.Vec2d(1, 0).rotated(
- to_pymunk_radians(angle_limits[1]))
+ 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):