X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=tabakrolletjie%2Fobstacles.py;h=071ca9f935c1d4cd87fec3de82e13bf6ca0f82e9;hb=61414d7b471661f35e533cb1430c6fea1d2ea48c;hp=61d4376e29da7080a71dbfcf16a38eb0ab29883a;hpb=e78f6923fc05f61c0724fb9b963341562393ec1b;p=tabakrolletjie.git

diff --git a/tabakrolletjie/obstacles.py b/tabakrolletjie/obstacles.py
index 61d4376..071ca9f 100644
--- a/tabakrolletjie/obstacles.py
+++ b/tabakrolletjie/obstacles.py
@@ -1,16 +1,117 @@
+""" Obstacles for light and space mould. """
+
+import pygame.locals as pgl
+
 import pymunk
 import pymunk.pygame_util
 import pygame.draw
+import pygame.surface
+from pygame.math import Vector2
+
+from .constants import (SCREEN_SIZE, OBSTACLE_CATEGORY)
+from .loader import loader
+
+OBSTACLE_FILTER = pymunk.ShapeFilter(categories=OBSTACLE_CATEGORY)
+
+
+class ObstacleManager(object):
+    """ Manages a set of obstacles. """
+
+    def __init__(self, space, gamestate):
+        self._space = space
+        self._obstacles = [
+            BaseObstacle.load(cfg) for cfg in gamestate.station["obstacles"]]
+        for obs in self._obstacles:
+            obs.add(self._space)
+
+    def render(self, surface):
+        for obs in self._obstacles:
+            obs.render(surface)
+
+
+class BaseObstacle(object):
+    def __init__(self):
+        self.body = pymunk.Body(0, 0, pymunk.body.Body.STATIC)
+        self.shapes = []
+
+    def add(self, space):
+        if self.body.space is not None:
+            space.remove(self.body, *self.body.shapes)
+        for shape in self.shapes:
+            shape.filter = OBSTACLE_FILTER
+        space.add(self.body, *self.shapes)
+
+    def render(self, surface):
+        raise NotImplementedError("Obstacles should implement .render().")
+
+    @classmethod
+    def load(cls, config):
+        kw = config.copy()
+        obstacle_type = kw.pop("type")
+        [obstacle_class] = [
+            c for c in cls.__subclasses__()
+            if c.__name__.lower() == obstacle_type]
+        return obstacle_class(**kw)
+
+
+class Wall(BaseObstacle):
+
+    def __init__(self, vertices):
+        super(Wall, self).__init__()
+        self.shapes.append(pymunk.Poly(self.body, vertices))
+        self._image = None
+
+    def get_image(self):
+        if self._image is None:
+            self._image = pygame.surface.Surface(SCREEN_SIZE).convert_alpha()
+            self._image.fill((0, 0, 0, 0))
+
+            for shape in self.shapes:
+                pygame_poly = [
+                    pymunk.pygame_util.to_pygame(v, self._image) for v in
+                    shape.get_vertices()]
+                pygame.draw.polygon(self._image, (255, 255, 255), pygame_poly)
+
+            wall_texture = loader.load_image(
+                "textures", "stone.png").convert_alpha()
+            self._image.blit(wall_texture, (0, 0), None, pgl.BLEND_RGBA_MULT)
+
+        return self._image
+
+    def render(self, surface):
+        surface.blit(self.get_image(), (0, 0), None, 0)
+
+
+class Shrub(BaseObstacle):
+
+    def __init__(self, shrublets):
+        super(Shrub, self).__init__()
+        for (x, y, r) in shrublets:
+            vec = Vector2(0, int(r))
+            STEPS = 18
+            vertices = [
+                vec.rotate(angle) + (x, y)
+                for angle in range(0, 360, 360/STEPS)]
+            vertices = [(v.x, v.y) for v in vertices]
+
+            self.shapes.append(pymunk.Poly(self.body, vertices))
+        self.shrublets = shrublets
+        self._image = None
+
+    def get_image(self):
+        if self._image is None:
+            self._image = pygame.surface.Surface(SCREEN_SIZE).convert_alpha()
+            self._image.fill((0, 0, 0, 0))
 
+            for (x, y, r) in self.shrublets:
+                centre = pymunk.pygame_util.to_pygame((x, y), self._image)
+                pygame.draw.circle(self._image, (255, 255, 255), centre, r)
 
-class Wall(object):
+            shrub_texture = loader.load_image(
+                "textures", "shrub.png").convert_alpha()
+            self._image.blit(shrub_texture, (0, 0), None, pgl.BLEND_RGBA_MULT)
 
-    def __init__(self, vertices, space):
-        body = pymunk.Body(0, 0, pymunk.body.Body.STATIC)
-        self._shape = pymunk.Poly(body, vertices)
-        space.add(self._shape)
+        return self._image
 
     def render(self, surface):
-        pygame_poly = [pymunk.pygame_util.to_pygame(v, surface) for v in
-                       self._shape.get_vertices()]
-        pygame.draw.polygon(surface, (0, 0, 0), pygame_poly)
+        surface.blit(self.get_image(), (0, 0), None, 0)