From 483da974d07e93f71c3297899a1cfe16faff3ea0 Mon Sep 17 00:00:00 2001
From: Niels Serup <ns@metanohi.name>
Date: Sun, 12 Aug 2012 20:43:14 +0200
Subject: [PATCH] Rewriting lasers in progress.

---
 robotgame/laser.py  |  4 +--
 robotgame/level.py  |  4 +--
 robotgame/level4.py | 83 ++++++++++++++++++++++++++++++++-------------
 3 files changed, 63 insertions(+), 28 deletions(-)

diff --git a/robotgame/laser.py b/robotgame/laser.py
index fd414e3..4d8484a 100644
--- a/robotgame/laser.py
+++ b/robotgame/laser.py
@@ -29,9 +29,9 @@ import pygame
 import worldobject
 
 class Laser(worldobject.WorldObject):
-    def __init__(self, level, p0, p1):
+    def __init__(self, level, p0, p1, laser_direction):
         self.__dict__.update(locals())
-        worldobject.WorldObject.__init__(self, level, p0[0], p0[1])
+        worldobject.WorldObject.__init__(self, level, p0[0], max(p0[1], p1[1]) + 48)
 
     def update(self, e, t, dt):
 
diff --git a/robotgame/level.py b/robotgame/level.py
index 11263e0..8b5b219 100644
--- a/robotgame/level.py
+++ b/robotgame/level.py
@@ -76,8 +76,8 @@ class Level(object):
         window.blit(self.background, (0 - self.camera_x, 0 - self.camera_y))
 
     def _sorted_objs(self, objs=None):
-        return sorted(self.objects if objs is None else objs,
-                      key=lambda obj: (obj.y + obj.z))
+        objs = self.objects if objs is None else objs
+        return sorted(objs, key=lambda obj: (obj.y + obj.z))
         
     def draw(self, window):
         self._blit_background(window)
diff --git a/robotgame/level4.py b/robotgame/level4.py
index 2ab5eea..a7f84d5 100644
--- a/robotgame/level4.py
+++ b/robotgame/level4.py
@@ -115,35 +115,70 @@ class Level4(level.Level):
         for ((x0, y0), (x1, y1)), direc in self.lasers_orig:
             self.lasers.append(laser.Laser(
                     self, (x0 * 64, y0 * 48),
-                    (x1 * 64, y1 * 48)))
+                    (x1 * 64, y1 * 48), direc))
 
     def draw(self, window):
         self._blit_background(window)
 
-        objs = self._sorted_objs()
+        objs = self._sorted_objs(self.objects + self.lasers)
+        self._after_sort(itertools.groupby(objs, lambda obj: obj.y + obj.z))
         for obj in objs:
             obj.draw(window)
 
-        for obj in self.lasers:
-            obj.draw(window)
-
-        for obj in objs:
-            x0, y0 = obj.x / 64, obj.y / 48 - 1
-            if isinstance(obj, mirror.Mirror):
-                for (p0, p1), laser_direc in self.lasers_orig:
-                    if p0 == (x0, y0):
-                        mirror_direc = Left if obj.left_up else Right
-                        do_redraw = {
-                            (Left, Up): True,
-                            (Left, Left): True,
-                            (Left, Down): False,
-                            (Left, Right): False,
-                            (Right, Up): True,
-                            (Right, Right): True,
-                            (Right, Down): False,
-                            (Right, Left): False
-                        }[(mirror_direc, laser_direc)]
-                        if do_redraw:
-                            obj.draw(window)
-
         self.darkness.draw(window)
+
+    def _after_sort(self, objss):
+        for objs in objss:
+            self._after_sort_line(objs)
+
+    def _after_sort_line(self, objs):
+        is_special = lambda obj: isinstance(obj, mirror.Mirror) or isinstance(obj, laser.Laser)
+        specials, nonspecials = filter(is_special, objs), filter(lambda obj: not is_special(obj), objs)
+        return nonspecials + self._sort_line_specials(specials)
+
+    def _sort_line_specials(self, objs):
+        print(objs)
+        return objs
+
+# def _compare(a, b):
+#     types = map(type, (a, b))
+#     if a.y + a.z == b.y + b.z:
+#         if isinstance(a, mirror.Mirror) and isinstance(b, laser.Laser):
+#             return 1
+#         if isinstance(b, mirror.Mirror) and isinstance(a, laser.Laser):
+#             return -1
+#         # if mirror.Mirror in types and laser.Laser in types:
+#         #     if not isinstance(a, laser.Laser):
+#         #         a, b, swapped = b, a, True
+#         #     else:
+#         #         swapped = False
+#         #     laser_direc = a.laser_direction
+#         #     if a.p0[1] < a.p1[1]:
+#         #         laser_direc = Down # instead of Down
+#         #     if a.p0[1] > a.p1[1]:
+#         #         laser_direc = Up # instead of Up
+#         #     mirror_direc = Left if b.left_up else Right
+#         #     result = 1 if _is_laser_behind_mirror(mirror_direc, laser_direc) \
+#         #         else -1
+#         #     result = -1
+#         #     return result if not swapped else -1 * result
+#         if a is laser.Laser and b is not laser.Laser:
+#             return 1
+#         if b is laser.Laser and a is not laser.Laser:
+#             return -1
+#         return 0
+
+#     return -1 if a.y + a.z < b.y + b.z \
+#         else 1 if a.y + a.z > b.y + b.z else 0
+        
+def _is_laser_behind_mirror(mirror_direc, laser_direc):
+    return {
+        (Left, Up): True,
+        (Left, Left): True,
+        (Left, Down): False,
+        (Left, Right): False,
+        (Right, Up): True,
+        (Right, Right): True,
+        (Right, Down): False,
+        (Right, Left): False
+        }[(mirror_direc, laser_direc)]