grass distance for engulf

sandbox/engulf/run.py

 """
 from random import randint
 
-from sandbox.engulf.subject import Cell, Grass
+from sandbox.engulf.subject import Cell, Grass, COLLECTION_GRASS
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
 from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
 from synergine2.xyz import Simulation
 from sandbox.engulf.simulation import EngulfSubjects
+from synergine2.xyz_utils import get_around_positions_of
 
 
 class Engulf(Simulation):
     start_count: int,
     start_position: tuple,
     end_position: tuple,
-    density: int=10,
+    density: int=5,
 ) -> None:
     grasses = []
 
             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,
             grasses.append(grass)
             subjects.append(grass)
 
-        # TODO: density
+    for grass in subjects.simulation.collections[COLLECTION_GRASS][:]:
+        a = 1
+        for around in get_around_positions_of(grass.position, distance=density):
+            if around not in subjects.grass_xyz:
+                grass = Grass(
+                    simulation=subjects.simulation,
+                    position=around,
+                )
+                grasses.append(grass)
+                subjects.append(grass)
+                # TODO: valeur nutritive regressive avec eloignement
 
 
 def main():

sandbox/engulf/subject.py

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

synergine2/xyz_utils.py

     if not exclude_start_position:
         points.append(position)
     return points
+
+
+def get_around_positions_of(
+        position,
+        distance=1,
+        exclude_start_point=True,
+) -> list:
+    """
+    Return positions around a point.
+    :param position: (x, y, z) tuple
+    :param distance: Distance to compute
+    :return: list of (x, y, z) positions
+    """
+    start_x = position[0] - distance
+    start_y = position[1] - distance
+    # start_z = position[0] - distance
+    positions = []
+    range_distance = (distance * 2) + 1
+    for dx in range(range_distance):
+        for dy in range(range_distance):
+            # for dz in range(range_distance):
+            # points.append((start_z+dz, start_x+dx, start_y+dy))
+            positions.append((start_x + dx, start_y + dy, position[2]))
+    if exclude_start_point:
+        positions.remove(position)
+
+    return positions