engulf: grass density

sandbox/engulf/gui.py

         super().__init__(*args, **kwargs)
         self.cells = {}
 
-    def born(self, grid_position):
+    def born(self, grid_position, opacity=100):
         grass = Sprite('resources/grass.png')
+        grass.rotation = randint(0, 360)
+        grass.opacity = opacity
         self.grid_manager.scale_sprite(grass)
         self.grid_manager.position_sprite(grass, grid_position)
         self.cells[grid_position] = grass
                     self.main_layer.cells.born(subject.position)
                 if isinstance(subject, Grass):
                     self.positions[subject.id] = subject.position
-                    self.main_layer.grasses.born(subject.position)
+                    self.main_layer.grasses.born(
+                        subject.position,
+                        subject.density,
+                    )

sandbox/engulf/run.py

       * alone/not alone: - be alone + not alone
 
 """
-from random import randint
+from random import randint, seed
 
 from sandbox.engulf.subject import Cell, Grass, COLLECTION_GRASS
 from synergine2.core import Core
 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
+from synergine2.xyz_utils import get_around_positions_of, get_distance_between_points
 
 
 class Engulf(Simulation):
             grasses.append(grass)
             subjects.append(grass)
 
-    for grass in subjects.simulation.collections[COLLECTION_GRASS][:]:
-        a = 1
+    for grass in grasses:
         for around in get_around_positions_of(grass.position, distance=density):
             if around not in subjects.grass_xyz:
-                grass = Grass(
+                new_grass = Grass(
                     simulation=subjects.simulation,
                     position=around,
                 )
-                grasses.append(grass)
-                subjects.append(grass)
-                # TODO: valeur nutritive regressive avec eloignement
+                distance = get_distance_between_points(around, grass.position)
+                new_grass.density = 100 - round((distance * 100) / 7)
+                subjects.append(new_grass)
 
 
 def main():
+    seed(0)
     simulation = Engulf()
     subjects = EngulfSubjects(simulation=simulation)
     fill_with_random_cells(
     )
     fill_with_random_grass(
         subjects,
-        15,
+        5,
         (-34, -34, 0),
         (34, 34, 0),
     )

sandbox/engulf/subject.py

         COLLECTION_EATABLE,
         COLLECTION_GRASS,
     ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._density = 100.0
+
+    @property
+    def density(self) -> float:
+        return self._density
+
+    @density.setter
+    def density(self, value: float) -> None:
+        if value > 100:
+            self._density = 100
+        elif value < 0:
+            self._density = 0
+        else:
+            self._density = value

synergine2/xyz.py

 
 from synergine2.simulation import SubjectMechanism, Subjects, Subject
 from synergine2.simulation import Simulation as BaseSimulation
+from synergine2.xyz_utils import get_distance_between_points
 
 
 """
 COLLECTION_XYZ = 'COLLECTION_XYZ'
 
 
-def get_distance_between_points(a: tuple, b: tuple) -> float:
-    return abs(sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2))
-
-
 def get_degree_from_north(a, b):
     if a == b:
         return 0

synergine2/xyz_utils.py

+from math import sqrt
 import collections
 
 
         positions.remove(position)
 
     return positions
+
+
+def get_distance_between_points(a: tuple, b: tuple) -> float:
+    return abs(sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2))