import pymunk
import pymunk.pygame_util
import pygame.draw
-import pygame.locals as pgl
-from .constants import SCREEN_SIZE, LIGHT_CATEGORY
+from .constants import (
+ SCREEN_SIZE, LIGHT_CATEGORY, FITTINGS_CATEGORY)
+from .utils import debug_timer
LIGHT_FILTER = pymunk.ShapeFilter(
- mask=pymunk.ShapeFilter.ALL_MASKS ^ LIGHT_CATEGORY,
+ mask=pymunk.ShapeFilter.ALL_MASKS ^ (
+ LIGHT_CATEGORY | FITTINGS_CATEGORY),
categories=LIGHT_CATEGORY)
+FITTINGS_FILTER = pymunk.ShapeFilter(
+ mask=pymunk.ShapeFilter.ALL_MASKS ^ (
+ LIGHT_CATEGORY | FITTINGS_CATEGORY),
+ categories=FITTINGS_CATEGORY)
+
def screen_rays(pos):
""" An iterable that returns ordered rays from pos to the edge of the
"""
w, h = SCREEN_SIZE
left, right, bottom, top = 0, w, 0, h
- for y in range(h):
+ step = 1
+ for y in range(0, h, step):
yield pymunk.Vec2d(left, y)
- for x in range(w):
+ for x in range(0, w, step):
yield pymunk.Vec2d(x, top)
- for y in range(top, -1, -1):
+ for y in range(top, -1, -step):
yield pymunk.Vec2d(right, y)
- for x in range(right, -1, -1):
+ for x in range(right, -1, -step):
yield pymunk.Vec2d(x, bottom)
+@debug_timer("lights.calculate_ray_polys")
def calculate_ray_polys(space, body, position):
position = pymunk.Vec2d(position)
vertices = [position]
new_poly = pymunk.Poly(body, vertices[:-1])
vertices = [position, vertices[-1]]
ray_polys.append(new_poly)
+ else:
+ vertices = trial_poly.get_vertices() + [point]
if len(vertices) > 2:
ray_polys.append(pymunk.Poly(body, vertices))
- print "NUM POLYS: ", len(ray_polys)
return ray_polys
+class LightManager(object):
+ """ Manages a set of lights. """
+
+ def __init__(self, space, gamestate):
+ self._space = space
+ self._lights = [
+ BaseLight.load(cfg) for cfg in gamestate.station["lights"]]
+ for light in self._lights:
+ light.add(self._space)
+
+ def render_light(self, surface):
+ for light in self._lights:
+ light.render_light(surface)
+
+ def render_fittings(self, surface):
+ for light in self._lights:
+ light.render_fitting(surface)
+
+
class BaseLight(object):
""" Common light functionality. """
+ COLOURS = {
+ "red": (255, 0, 0),
+ "green": (0, 255, 0),
+ "blue": (0, 255, 255),
+ "yellow": (255, 255, 0),
+ "white": (255, 255, 255),
+ }
+
def __init__(self, colour, position):
- self.body = pymunk.Body(0, 0, pymunk.body.Body.STATIC)
self.colour = colour
- self.position = position
-
- def add(self, space):
- if self.body.space is not None:
- space.remove(self.body, *self.body.shapes)
- shapes = self.shapes_for_ray_polys(
- calculate_ray_polys(space, self.body, self.position))
- for shape in shapes:
- shape.filter = LIGHT_FILTER
- space.add(self.body, *shapes)
-
- def shapes_for_ray_polys(self, space):
- raise NotImplementedError(
- "Lights should implement .determine_ray_polys.")
+ self.position = pymunk.Vec2d(position)
+ self.on = True
+ self.body = pymunk.Body(0, 0, pymunk.body.Body.STATIC)
+ self.fitting = pymunk.Circle(self.body, 10.0, self.position)
+ self.body.light = self
@classmethod
def load(cls, config):
if c.__name__.lower() == light_type]
return light_class(**kw)
-
-class SpotLight(BaseLight):
- def __init__(
- self, colour="white", position=None, direction=90.0, spread=45.0):
- super(SpotLight, self).__init__(colour, position)
- self.direction = direction
- self.spread = spread
- self.i = 0
+ def add(self, space):
+ if self.body.space is not None:
+ space.remove(self.body, *self.body.shapes)
+ shapes = self.shapes_for_ray_polys(
+ calculate_ray_polys(space, self.body, self.position))
+ for shape in shapes:
+ shape.filter = LIGHT_FILTER
+ self.fitting.filter = FITTINGS_FILTER
+ space.add(self.body, self.fitting, *shapes)
def shapes_for_ray_polys(self, ray_polys):
- x, y = self.position
- return ray_polys #+ [
- # pymunk.Poly(self.body, [self.position, [x + 50, y], [x, y + 50]])]
+ return ray_polys
- def render(self, surface):
+ def toggle(self):
+ self.on = not self.on
+
+ def render_light(self, surface):
+ if not self.on:
+ return
subsurface = surface.copy()
- pygame.draw.circle(
- surface, (255, 255, 0),
- pymunk.pygame_util.to_pygame(self.position, surface), 5)
+ light_colour = self.COLOURS[self.colour]
for shape in self.body.shapes:
+ if shape is self.fitting:
+ continue
pygame_poly = [
pymunk.pygame_util.to_pygame(v, surface) for v in
shape.get_vertices()]
pygame.draw.polygon(
- subsurface, (200, 200, 200), pygame_poly, 0)
+ subsurface, light_colour, pygame_poly, 0)
pygame.draw.aalines(
- subsurface, (200, 200, 200), True, pygame_poly, 1)
- subsurface.set_alpha(200)
+ subsurface, light_colour, True, pygame_poly, 1)
+ subsurface.set_alpha(50)
surface.blit(subsurface, (0, 0), None)
+ def render_fitting(self, surface):
+ pygame.draw.circle(
+ surface, (255, 255, 0),
+ pymunk.pygame_util.to_pygame(self.fitting.offset, surface),
+ int(self.fitting.radius))
+
+
+class SpotLight(BaseLight):
+ def __init__(
+ self, colour="white", position=None, direction=90.0, spread=45.0):
+ super(SpotLight, self).__init__(colour, position)
+ self.direction = direction
+ self.spread = spread
+ self.i = 0
+
class Lamp(BaseLight):
def __init__(self, colour="white", position=None, radius=100.0):
projects / tabakrolletjie.git / blobdiff