From f6c5565852c9374631917d535799887a8dd297e3 Mon Sep 17 00:00:00 2001
From: Neil <neil@dip.sun.ac.za>
Date: Sat, 10 Sep 2016 21:46:44 +0200
Subject: [PATCH] Add serialize methods to lights and rays

---
 tabakrolletjie/lights.py | 39 +++++++++++++++++++++++++++++++++++++--
 tabakrolletjie/rays.py   | 14 ++++++++++++++
 2 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/tabakrolletjie/lights.py b/tabakrolletjie/lights.py
index 2736509..498c0b0 100644
--- a/tabakrolletjie/lights.py
+++ b/tabakrolletjie/lights.py
@@ -64,6 +64,12 @@ class LightManager(object):
         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
@@ -140,11 +146,16 @@ 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):
         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
@@ -157,6 +168,18 @@ class BaseLight(object):
         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
@@ -299,6 +322,13 @@ class PulsatingLamp(BaseLight):
             "intensity_velocity", self.DEFAULT_INTENSITY_VELOCITY)
         super(PulsatingLamp, self).__init__(**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
         if value < value_range[0]:
@@ -324,6 +354,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(
diff --git a/tabakrolletjie/rays.py b/tabakrolletjie/rays.py
index a475d8f..8b53278 100644
--- a/tabakrolletjie/rays.py
+++ b/tabakrolletjie/rays.py
@@ -129,6 +129,20 @@ class RayPolyManager(object):
     def min_radius(self, value):
         self._min_radius = value or 0.0
 
+    def serialize(self):
+        """ Return the required information from the ray_manager """
+        if self._direction is None:
+            direction = None
+            spread = None
+        else:
+            direction = self._direction.angle_degrees
+            spread = math.degrees(self.spread)
+        return {
+            "radius_limits": (self._min_radius, self._max_radius),
+            "direction": direction,
+            "spread": spread,
+        }
+
     def reaches(self, position):
         distance = self.position.get_distance(position)
         return (self._min_radius <= distance <= self._max_radius)
-- 
2.34.1