1 files changed, 67 insertions, 44 deletions

diff --git a/src/sliceitoff/field/field.py b/src/sliceitoff/field/field.py
index 5d2a573..842b07a 100644
--- a/src/sliceitoff/field/field.py
+++ b/src/sliceitoff/field/field.py
@@ -7,48 +7,57 @@ from stats import Stats
 
 DEBUG = os.getenv("DEBUG")
 
+
 class FieldSprite(pygame.sprite.Sprite):
-    def __init__(self, area: tuple ):
+    def __init__(self, area: tuple):
         super().__init__()
+        self.color = (0,255,0,255)
+        self.dead = False
         self.area = area
-        self.update()
-        
-    def update(self):
         self.rect = Scaling.area_to_rect(self.area)
-        self.image = pygame.Surface(self.rect.size)
-        self.image.fill("green")
+        self.image = pygame.Surface(self.rect.size, pygame.SRCALPHA)
+        self.image.fill(self.color)
+
+    def update(self, dt = 0):
+        if dt and self.dead:
+            self.color = (
+                    self.color[0],
+                    self.color[1],
+                    self.color[2],
+                    self.color[3] - dt/4)
+            if self.color[3] <= 0:
+                self.kill()
+            else:
+                self.image.fill(self.color)
+
+
+class SliceSprite(FieldSprite):
+    def __init__(self, area: tuple ):
+        super().__init__(area)
+        self.color = (255,255,0,255)
+        self.image.fill(self.color)
+        self.dead = True
         
 
-class Field():
+
+class Field(pygame.sprite.LayeredUpdates):
     initial_area = (320_000, 220_000)
 
     def __init__(self):
-        self.sprites = pygame.sprite.Group()
-        self.sprites.add(FieldSprite( (0, 0, *__class__.initial_area) ))
+        super().__init__()
+        self.add(FieldSprite( (0, 0, *__class__.initial_area) ))
         self.area_full = __class__.initial_area[0] * __class__.initial_area[1]
         self.area_current = self.area_full
-        self.percentage = 100
-        
-    def coordinates_inside_area(self, area, x, y) -> bool:
-        """ Test if coordinates are inside area """
-        if x < area[0]:
-            return False
-        if y < area[1]:
-            return False
-        if x >= area[0]+area[2]:
-            return False
-        if y >= area[1]+area[3]:
-            return False
-        return True
         
+
     def update_area(self):
         """ calculates remaining area and remaining percentage """
-        self.area_current = sum( s.area[2]*s.area[3] for s in self.sprites )
+        self.area_current = sum( s.area[2]*s.area[3] for s in self.sprites() )
         Stats.percent = 100 * self.area_current / self.area_full
         if DEBUG:
             print(
                     f"FIELD: {self.area_full}/{self.area_current}, "
-                    f"{self.percentage}")
+                    f"{Stats.percent}")
 
     def slice(
             self,
@@ -56,20 +65,17 @@ class Field():
             direction: bool,
             thickness: int) -> pygame.Rect:
         """ Slice one area into two areas """
-
-        # Find the overlapping area
-        for field in self.sprites:
-            if self.coordinates_inside_area(field.area, pos[0], pos[1]):
-                break
-        else:
+        
+        # Slicing hits the area?
+        overlap = self.get_sprites_at(Scaling.scale_to_display(pos))
+        if not overlap:
             return None
-
-        # remove current area
-        ax, ay, aw, ah = field.area
-        field.remove(self.sprites)
+        
+        # Save the area information and remove the sprite
+        ax, ay, aw, ah = overlap[0].area
+        overlap[0].remove(self)
 
         # create new areas if there is any space
-
         if direction:
             x1 = ax
             x2 = pos[0] - thickness
@@ -77,10 +83,12 @@ class Field():
             x4 = ax + aw
             
             if x2 > x1:
-                self.sprites.add(FieldSprite( (x1, ay, x2-x1, ah) ))
+                self.add(FieldSprite( (x1, ay, x2-x1, ah) ))
             if x4 > x3:
-                self.sprites.add(FieldSprite( (x3, ay, x4-x3, ah) ))
+                self.add(FieldSprite( (x3, ay, x4-x3, ah) ))
             self.update_area()
+
+            self.add(SliceSprite( (x2, ay, x3-x2, ah) ))
             return Scaling.area_to_rect((x2, ay, x3-x2, ah))
         y1 = ay
         y2 = pos[1] - thickness
@@ -88,13 +96,28 @@ class Field():
         y4 = ay + ah
 
         if y2 > y1:
-            self.sprites.add(FieldSprite( (ax, y1, aw, y2-y1) ))
+            self.add(FieldSprite( (ax, y1, aw, y2-y1) ))
         if y4 > y3:
-            self.sprites.add(FieldSprite( (ax, y3, aw, y4-y3) ))
+            self.add(FieldSprite( (ax, y3, aw, y4-y3) ))
+
+        self.add(SliceSprite( (ax, y2, aw, y3-y2) ))
+
         self.update_area()
         return Scaling.area_to_rect((ax, y2, aw, y3-y2))
-        
-    def update(self, dt):
-        """ Update sprites basis of dt. dt = milliseconds from last update """
-        pass
-        
\ No newline at end of file
+
+    def active_sprites(self):
+        """ Returns all sprites that are not dead """
+        return (s for s in self.sprites() if not s.dead)
+    
+    def kill_if_not_colliding(self, sprites):
+        """ If there is empty fields that are not yet dead kill them """
+        for field in self.active_sprites():
+            for enemy in sprites:
+                if enemy.rect.colliderect(field.rect):
+                    break
+            else:
+                field.dead = True
+
+#    def update(self, dt):
+#        """---"""
+    
\ No newline at end of file