introduce grass into engulf

sandbox/engulf/gui.py

 
 import cocos
 from cocos.sprite import Sprite
-from sandbox.engulf.subject import Cell
+from sandbox.engulf.subject import Cell, Grass
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.gui import Gui, GridLayerMixin
 from synergine2_cocos2d.gui import MainLayer as BaseMainLayer
         self.add(cell)
 
 
-class MainLayer(GridLayerMixin, BaseMainLayer):
+class GrassLayer(GridLayerMixin, BaseMainLayer):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.cells = CellsLayer(terminal=kwargs.pop('terminal'))
+        self.cells = {}
+
+    def born(self, grid_position):
+        grass = Sprite('resources/grass.png')
+        self.grid_manager.scale_sprite(grass)
+        self.grid_manager.position_sprite(grass, grid_position)
+        self.cells[grid_position] = grass
+        self.add(grass)
+
+
+class MainLayer(GridLayerMixin, BaseMainLayer):
+    def __init__(self, terminal, *args, **kwargs):
+        super().__init__(terminal, *args, **kwargs)
+
+        self.cells = CellsLayer(terminal=terminal)
         self.add(self.cells)
 
+        self.grasses = GrassLayer(terminal=terminal)
+        self.add(self.grasses)
+
 
 class Game(Gui):
     def __init__(self, *args, **kwargs):
                 if isinstance(subject, Cell):
                     self.positions[subject.id] = subject.position
                     self.main_layer.cells.born(subject.position)
+                if isinstance(subject, Grass):
+                    self.positions[subject.id] = subject.position
+                    self.main_layer.grasses.born(subject.position)

sandbox/engulf/run.py

 """
 from random import randint
 
-from sandbox.engulf.subject import Cell
+from sandbox.engulf.subject import Cell, Grass
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
 from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
 from synergine2.xyz import Simulation
-from synergine2.xyz import XYZSubjects
+from sandbox.engulf.simulation import EngulfSubjects
 
 
 class Engulf(Simulation):
         self.gui.run()
 
 
-def get_random_subjects(
-        simulation: Simulation,
-        count: int,
-        x_min: int,
-        y_min: int,
-        x_max: int,
-        y_max: int,
-) -> [Cell]:
-    cells = XYZSubjects(simulation=simulation)
+def fill_with_random_cells(
+    subjects: EngulfSubjects,
+    count: int,
+    start_position: tuple,
+    end_position: tuple,
+) -> None:
+    cells = []
 
     while len(cells) < count:
         position = (
-            randint(x_min, x_max+1),
-            randint(y_min, y_max+1),
-            0
+            randint(start_position[0], end_position[0]+1),
+            randint(start_position[1], end_position[1]+1),
+            randint(start_position[2], end_position[2]+1),
         )
-        if position not in cells.xyz:
-            cells.append(Cell(
-                simulation=simulation,
+        if position not in subjects.cell_xyz:
+            cell = Cell(
+                simulation=subjects.simulation,
                 position=position,
-            ))
+            )
+            cells.append(cell)
+            subjects.append(cell)
 
-    return cells
+
+def fill_with_random_grass(
+    subjects: EngulfSubjects,
+    start_count: int,
+    start_position: tuple,
+    end_position: tuple,
+    density: int=10,
+) -> None:
+    grasses = []
+
+    while len(grasses) < start_count:
+        position = (
+            randint(start_position[0], end_position[0]+1),
+            randint(start_position[1], end_position[1]+1),
+            randint(start_position[2], end_position[2]+1),
+        )
+        if position not in subjects.grass_xyz:
+            grass = Grass(
+                simulation=subjects.simulation,
+                position=position,
+            )
+            grasses.append(grass)
+            subjects.append(grass)
+
+        # TODO: density
 
 
 def main():
     simulation = Engulf()
-    subjects = get_random_subjects(
-        simulation,
+    subjects = EngulfSubjects(simulation=simulation)
+    fill_with_random_cells(
+        subjects,
         30,
-        -34,
-        -34,
-        34,
-        34,
+        (-34, -34, 0),
+        (34, 34, 0),
+    )
+    fill_with_random_grass(
+        subjects,
+        15,
+        (-34, -34, 0),
+        (34, 34, 0),
     )
     simulation.subjects = subjects
 

sandbox/engulf/simulation.py

+from sandbox.engulf.subject import Cell, Grass
+from synergine2.xyz import XYZSubjects, XYZSubjectMixin
+
+__author__ = 'bux'
+
+
+class EngulfSubjects(XYZSubjects):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # TODO: accept multiple subjects as same position
+        # TODO: init xyz with given list
+        self.cell_xyz = {}
+        self.grass_xyz = {}
+
+    def remove(self, value: XYZSubjectMixin):
+        super().remove(value)
+
+        if isinstance(value, Cell):
+            del self.cell_xyz[value.position]
+
+        if isinstance(value, Grass):
+            del self.grass_xyz[value.position]
+
+    def append(self, p_object: XYZSubjectMixin):
+        super().append(p_object)
+
+        if isinstance(p_object, Cell):
+            self.cell_xyz[p_object.position] = p_object
+
+        if isinstance(p_object, Grass):
+            self.grass_xyz[p_object.position] = p_object

sandbox/engulf/subject.py

 
 COLLECTION_CELL = 'CELL'
 COLLECTION_ALIVE = 'ALIVE'
+COLLECTION_EATABLE = 'EATABLE'
 
 
 class Cell(XYZSubjectMixin, Subject):
     collections = [
         COLLECTION_CELL,
         COLLECTION_ALIVE,
+        COLLECTION_EATABLE,
+    ]
+
+
+class Grass(XYZSubjectMixin, Subject):
+    collections = [
+        COLLECTION_EATABLE,
     ]