Engulf: Slighty move

sandbox/engulf/behaviour.py

 # coding: utf-8
-from random import randint
+from random import choice
 
 from sandbox.engulf.const import COLLECTION_GRASS
 from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour
 from synergine2.simulation import Event
 from synergine2.utils import ChunkManager
-from synergine2.xyz import ProximitySubjectMechanism
-from synergine2.xyz_utils import get_around_positions_of_positions, get_around_positions_of
+from synergine2.xyz import ProximitySubjectMechanism, DIRECTIONS, DIRECTION_SLIGHTLY
+from synergine2.xyz_utils import get_around_positions_of_positions, get_around_positions_of, get_position_for_direction
 
 
 class GrassGrownUp(Event):
     use = []
 
     def action(self, data) -> [Event]:
-        position = self.get_random_around_position()
+        direction = self.get_random_direction()
+        position = get_position_for_direction(self.subject.position, direction)
+        self.subject.position = position
+        self.subject.previous_direction = direction
+
         return [MoveTo(self.subject.id, position)]
 
     def run(self, data):
         return True  # for now, want move every time
 
-    def get_random_around_position(self):
-        around_positions = get_around_positions_of(self.subject.position)
-        return around_positions[randint(0, len(around_positions)-1)]
+    def get_random_direction(self):
+        if not self.subject.previous_direction:
+            return choice(DIRECTIONS)
+        return choice(DIRECTION_SLIGHTLY[self.subject.previous_direction])

sandbox/engulf/run.py

         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),
+            0,
         )
         if position not in subjects.cell_xyz:
             cell = Cell(
         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),
+            0,
         )
 
         if position not in subjects.grass_xyz:

sandbox/engulf/subject.py

         COLLECTION_ALIVE,
         COLLECTION_EATABLE,
     ]
+    # TODO: Mettre en place la "selection/choix": car il y a deux move possible chaque cycle ci-dessous.
     behaviours_classes = [
         SearchFood,
         Eat,

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'
 
+NORTH = 11
+NORTH_EST = 12
+EST = 15
+SOUTH_EST = 18
+SOUTH = 17
+SOUTH_WEST = 16
+WEST = 13
+NORTH_WEST = 10
+
+DIRECTIONS = (
+    NORTH,
+    NORTH_EST,
+    EST,
+    SOUTH_EST,
+    SOUTH,
+    SOUTH_WEST,
+    WEST,
+    NORTH_WEST,
+)
+
+DIRECTION_FROM_NORTH_DEGREES = {
+    (0, 22.5): NORTH,
+    (22.5, 67): NORTH_EST,
+    (67, 112.5): EST,
+    (112.5, 157.5): SOUTH_EST,
+    (157.5, 202.5): SOUTH,
+    (202.5, 247.5): SOUTH_WEST,
+    (247.5, 292.5): WEST,
+    (292.5, 337.5): NORTH_WEST,
+    (337.5, 360): NORTH,
+    (337.5, 0): NORTH
+}
+
+DIRECTION_SLIGHTLY = {
+    NORTH: (NORTH_WEST, NORTH, NORTH_EST),
+    NORTH_EST: (NORTH, NORTH_EST, EST),
+    EST: (NORTH_EST, EST, SOUTH_EST),
+    SOUTH_EST: (EST, SOUTH_EST, SOUTH),
+    SOUTH: (SOUTH_EST, SOUTH, SOUTH_WEST),
+    SOUTH_WEST: (SOUTH, SOUTH_WEST, WEST),
+    WEST: (SOUTH_WEST, WEST, NORTH_WEST),
+    NORTH_WEST: (WEST, NORTH_WEST, NORTH),
+}
+
+DIRECTION_MODIFIERS = {
+    NORTH_WEST: (-1, -1, 0),
+    NORTH: (0, -1, 0),
+    NORTH_EST: (1, -1, 0),
+    WEST: (-1, 0, 0),
+    EST: (1, 0, 0),
+    SOUTH_WEST: (-1, 1, 0),
+    SOUTH: (0, 1, 0),
+    SOUTH_EST: (1, 1, 0),
+}
+
 
 def get_degree_from_north(a, b):
     if a == b:
         """
         :param position: tuple with (x, y, z)
         """
-        self.position = kwargs.pop('position')
+        self._position = kwargs.pop('position')
+        self.previous_direction = None
         super().__init__(*args, **kwargs)
 
+    @property
+    def position(self):
+        return self._position
+
+    @position.setter
+    def position(self, value):
+        self._position = value
+
 
 class ProximityMixin(object):
     distance = 1
 
     @classmethod
     def get_distance_of(cls, position, subject: XYZSubjectMixin):
+        from synergine2.xyz_utils import get_distance_between_points  # cyclic import
         return get_distance_between_points(
             position,
             subject.position,

synergine2/xyz_utils.py

 from math import sqrt
 import collections
 
+from synergine2.xyz import DIRECTION_MODIFIERS
+
 
 def get_positions_from_str_representation(str_representation):
     # TODO: Manage z axis (like ------------ as separator)
 
 
 def get_distance_between_points(a: tuple, b: tuple) -> float:
-    return abs(sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2))
+    return abs(sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2))
+
+
+def get_position_for_direction(from_position: tuple, direction: int) -> tuple:
+    modifier = DIRECTION_MODIFIERS[direction]
+    return (
+        from_position[0] + modifier[0],
+        from_position[1] + modifier[1],
+        from_position[2] + modifier[2],
+    )