Use pulsating lamp images.

[tabakrolletjie.git] / tabakrolletjie / lights.py

diff --git a/tabakrolletjie/lights.py b/tabakrolletjie/lights.py
index 723da6a9f427ee0304130269bc6f76716dfd8f19..cda60022a5d5aa227d7a9401ad119ca31ff2ba67 100644 (file)
--- a/tabakrolletjie/lights.py
+++ b/tabakrolletjie/lights.py
@@ -11,7 +11,9 @@ import pygame.locals as pgl
 import pygame.rect
 import pygame.transform
 
-from .constants import LIGHT_CATEGORY, FITTINGS_CATEGORY, COLOURS
+from .constants import (
+    LIGHT_CATEGORY, FITTINGS_CATEGORY, OBSTACLE_CATEGORY, TURNIP_CATEGORY,
+    COLOURS)
 from .rays import RayPolyManager
 from .utils import DetailedTimer
 from .loader import loader
@@ -29,6 +31,16 @@ FITTINGS_FILTER = pymunk.ShapeFilter(
 
 # Just match lights, nothing else
 LIT_BY_FILTER = pymunk.ShapeFilter(mask=LIGHT_CATEGORY)
+SPACE_FOR_LIGHT_FILTER = pymunk.ShapeFilter(
+    mask=FITTINGS_CATEGORY | OBSTACLE_CATEGORY | TURNIP_CATEGORY)
+
+
+def check_space_for_light(space, pos, max_distance):
+    point_info = space.point_query_nearest(
+        pos, max_distance, SPACE_FOR_LIGHT_FILTER)
+    if point_info is not None:
+        return True
+    return False
 
 
 class LightManager(object):
@@ -36,6 +48,7 @@ class LightManager(object):
 
     def __init__(self, space, gamestate):
         self._space = space
+        self._battery_dead = False
         self._lights = [
             BaseLight.load(cfg) for cfg in gamestate.station["lights"]]
         for light in self._lights:
@@ -46,7 +59,24 @@ class LightManager(object):
         self._lights.append(light)
         light.add(self._space)
 
+    def remove_light(self, light):
+        self._lights.remove(light)
+        light.remove(self._space)
+
+    def battery_dead(self):
+        self._battery_dead = True
+        for light in self._lights:
+            light.off()
+
+    def serialize_lights(self):
+        result = []
+        for light in self._lights:
+            result.append(light.serialize())
+        return result
+
     def toggle_nearest(self, *args, **kw):
+        if self._battery_dead:
+            return
         light = self.nearest(*args, **kw)
         if light:
             light.toggle()
@@ -120,23 +150,42 @@ class BaseLight(object):
 
     def __init__(
             self, colours, position, intensity=1.0, radius_limits=None,
-            direction=None, spread=None):
+            direction=None, spread=None, on=True, start_colour=None,
+            bounding_radius=None):
         self.colour_cycle = colours
         self.colour_pos = 0
         self.colour = colours[0]
-        self.on = True
+        if start_colour and start_colour in colours:
+            self.colour_pos = colours.index(start_colour)
+            self.colour = start_colour
+        self.on = on
+        if not on and len(colours) > 1:
+            self.colour_pos = -1
         self.intensity = intensity
         self.body = pymunk.Body(0, 0, pymunk.body.Body.STATIC)
         self.body.light = self
         self.ray_manager = self.RAY_MANAGER(
             self.body, position, ray_filter=LIGHT_FILTER,
-            radius_limits=radius_limits, direction=direction, spread=spread)
+            radius_limits=radius_limits, direction=direction, spread=spread,
+            bounding_radius=bounding_radius)
         self.fitting = pymunk.Circle(
             self.body, self.FITTING_RADIUS, self.ray_manager.position)
         self.fitting.filter = FITTINGS_FILTER
         self._fitting_image = None
         self._colour_mult_image = None
 
+    def serialize(self):
+        result = self.ray_manager.serialize()
+        result.update({
+            "type": self.__class__.__name__.lower(),
+            "colours": self.colour_cycle,
+            "position": self.position,
+            "intensity": self.intensity,
+            "on": self.on,
+            "start_colour": self.colour,
+        })
+        return result
+
     @property
     def position(self):
         return self.ray_manager.position
@@ -162,6 +211,10 @@ class BaseLight(object):
         self.ray_manager.set_space(space)
         self.ray_manager.update_shapes()
 
+    def remove(self, space):
+        if self.body.space is not None:
+            space.remove(self.body, *self.body.shapes)
+
     def _cached_surface(self, name, surface):
         surf = self._surface_cache.get(name)
         if surf is None:
@@ -239,6 +292,9 @@ class BaseLight(object):
     def base_damage(self):
         return 10 * self.intensity
 
+    def off(self):
+        self.on = False
+
     def toggle(self):
         self.colour_pos += 1
         if self.colour_pos >= len(self.colour_cycle):
@@ -260,7 +316,7 @@ class Lamp(BaseLight):
 
 class PulsatingLamp(BaseLight):
 
-    FITTING_IMG = "lamp.png"
+    FITTING_IMG = "pulsatinglamp.png"
     DEFAULT_PULSE_RANGE = (20, 100)
     DEFAULT_PULSE_VELOCITY = 2
     DEFAULT_INTENSITY_RANGE = (0.0, 0.9)
@@ -274,7 +330,15 @@ class PulsatingLamp(BaseLight):
             "intensity_range", self.DEFAULT_INTENSITY_RANGE)
         self.intensity_velocity = kw.pop(
             "intensity_velocity", self.DEFAULT_INTENSITY_VELOCITY)
-        super(PulsatingLamp, self).__init__(**kw)
+        super(PulsatingLamp, self).__init__(
+            bounding_radius=self.pulse_range[1], **kw)
+
+    def serialize(self):
+        result = super(PulsatingLamp, self).serialize()
+        result["pulse_velocity"] = self.pulse_velocity
+        result["intensity_range"] = self.intensity_range
+        result["intensity_velocity"] = self.intensity_velocity
+        return result
 
     def _update_range(self, value, velocity, value_range):
         value += velocity
@@ -301,6 +365,11 @@ class SpotLight(BaseLight):
         self.angular_velocity = kw.pop("angular_velocity", None)
         super(SpotLight, self).__init__(**kw)
 
+    def serialize(self):
+        result = super(SpotLight, self).serialize()
+        result["angular_velocity"] = self.angular_velocity
+        return result
+
     def fitting_image(self):
         fitting_image = super(SpotLight, self).fitting_image()
         rot_fitting_image = pygame.transform.rotozoom(