Tools for pheromones

intelligine/core/Context.py

@@ -1,10 +1,18 @@
 from xyzworld.Context import Context as XyzContext
 from intelligine.cst import IMPENETRABLE
 from xyzworld.cst import POSITIONS
+from intelligine.synergy.stigmergy.PheromonesManager import PheromonesManager
 
 
 class Context(XyzContext):
 
+    def __init__(self):
+        super().__init__()
+        self._pheromones = PheromonesManager(self)
+
+    def pheromones(self):
+        return self._pheromones
+
     def position_is_penetrable(self, position):
         objects_ids_on_this_point = self.metas.list.get(POSITIONS, position, allow_empty=True)
         for object_id_on_this_point in objects_ids_on_this_point:

intelligine/display/Pygame.py

@@ -18,19 +18,11 @@ class Pygame(XyzPygame):
 
     def _display_pheromones(self, pheromones_positions, context):
         for point in pheromones_positions:
-            ######
-            # refact
-            point_pheromones_infos = context.metas.value.get(PHEROMON_INFOS, point, allow_empty=True,
+            exploration_info = context.pheromones().get_info(point,
+                                                             [PHEROMON_DIRECTION,
+                                                              PHEROMON_DIR_EXPLO],
+                                                             allow_empty=True,
                                                              empty_value={})
-            # TODO: Tout ca dans un get_pheromone_info(PHEROMON_DIRECTION, PHEROMON_DIR_EXPLO, direction)
-            #point_pheromones_infos={}
-            if PHEROMON_DIRECTION not in point_pheromones_infos:
-                point_pheromones_infos[PHEROMON_DIRECTION] = {}
-            direction_pheromone = point_pheromones_infos[PHEROMON_DIRECTION]
-            if PHEROMON_DIR_EXPLO not in direction_pheromone:
-                 direction_pheromone[PHEROMON_DIR_EXPLO] = {}
-            exploration_info = direction_pheromone[PHEROMON_DIR_EXPLO]
-            ########
 
             for direction in exploration_info:
                 intensity = exploration_info[direction]

intelligine/sandbox/exploration/ColonyConfiguration.py

@@ -0,0 +1,11 @@
+from intelligine.synergy.ColonyConfiguration import ColonyConfiguration
+from intelligine.synergy.object.ant.Ant import Ant
+
+
+class ColonyConfiguration(ColonyConfiguration):
+
+    _start_position = (0, 20, 20)
+    _ant_class = Ant
+    _ant_count = 2
+
+

intelligine/sandbox/exploration/collections.py

@@ -0,0 +1,4 @@
+from intelligine.sandbox.exploration.ColonyConfiguration import ColonyConfiguration
+from intelligine.synergy.Colony import Colony
+
+collections = [Colony(ColonyConfiguration())]

intelligine/synergy/event/move/direction.py

@@ -1,4 +1,3 @@
-
 """
 Directions identifiers 3D, central position is 14.
 niv -1:  1   2  3

intelligine/synergy/event/pheromone/ApposeDirection.py

@@ -0,0 +1,79 @@
+from synergine.synergy.event.Action import Action
+from intelligine.synergy.event.pheromone.PheromoneEvent import PheromoneEvent
+from xyzworld.cst import POSITION
+from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_DIR_EXPLO, PHEROMON_POSITIONS
+from xyzworld.geometry import get_direction_degrees, get_degree_from_north
+from intelligine.synergy.event.move.direction import get_direction_for_degrees, get_direction_opposite
+
+
+class ApposeDirection(Action):
+
+    _listen = PheromoneEvent
+
+    def prepare(self, context):
+        """
+        Recupere chaque coordonnees de points qui doivent etre update
+        pour ne pas avoir a e calculer dans le run
+        :param context:
+        :return:
+        """
+        object_point =  context.metas.value.get(POSITION, self._object_id)
+        distance = 1 # TODO: Config ?
+        self._parameters['concerned_points'] = context.get_arround_points_of(object_point, distance)
+
+    def run(self, obj, context, synergy_manager):
+        """
+        On effectue l'incrementation dans le process principal. Beaucoups plus lourd que de le faie dans les
+        process. Mais si on le fait dans les process on va rater des infos ...
+        met a jour les pts (incremente)
+        :param obj:
+        :param context:
+        :param synergy_manager:
+        :return:
+        """
+        # TODO: Remonter ca dans une objet
+
+        # a = get_direction_degrees((0, 0, 0), (0, -1, -1)) # 315
+        # a = get_direction_degrees((0, 0, 0), (0, 0, -1))  # 0
+        # a = get_direction_degrees((0, 0, 0), (0, 1, -1))  # 45
+        # a = get_direction_degrees((0, 0, 0), (0, -1, 0))  # 270
+        # a = get_direction_degrees((0, 0, 0), (0, 1, 0))   # 90
+        # a = get_direction_degrees((0, 0, 0), (0, -1, 1))  # 225
+        # a = get_direction_degrees((0, 0, 0), (0, 0, 1))   # 180
+        # a = get_direction_degrees((0, 0, 0), (0, 1, 1))   # 135
+
+        # a = get_degree_from_north((0, 0, 0), (0, -1, -1)) # 315
+        # a = get_degree_from_north((0, 0, 0), (0, 0, -1))  # 0
+        # a = get_degree_from_north((0, 0, 0), (0, 1, -1))  # 45
+        # a = get_degree_from_north((0, 0, 0), (0, -1, 0))  # 270
+        # a = get_degree_from_north((0, 0, 0), (0, 1, 0))   # 90
+        # a = get_degree_from_north((0, 0, 0), (0, -1, 1))  # 225
+        # a = get_degree_from_north((0, 0, 0), (0, 0, 1))   # 180
+        # a = get_degree_from_north((0, 0, 0), (0, 1, 1))   # 135
+        self._appose_pheromones(obj, context, synergy_manager)
+
+    def _appose_pheromones(self, obj, context, synergy_manager):
+        obj_position = obj.get_position()
+        obj_last_pheromon_position = obj.get_last_pheromone_point(PHEROMON_DIRECTION)
+        try:
+            direction_degrees = get_degree_from_north(obj_last_pheromon_position, obj_position)
+        except ZeroDivisionError:
+            return
+        direction = get_direction_for_degrees(direction_degrees)
+        from_direction = get_direction_opposite(direction)
+        depose_intensity = 1 # TODO: config
+
+        for affected_point in self._parameters['concerned_points']:
+            self._appose_pheromone(context, affected_point, direction, depose_intensity)
+            context.metas.list.add(PHEROMON_POSITIONS, PHEROMON_POSITIONS, affected_point, assert_not_in=False)
+
+        obj.set_last_pheromone_point(PHEROMON_DIRECTION, obj.get_position())
+
+    def _appose_pheromone(self, context, affected_point, direction, depose_intensity):
+        context.pheromones().increment(affected_point, [PHEROMON_DIRECTION,
+                                                        PHEROMON_DIR_EXPLO,
+                                                        direction], depose_intensity)
+
+
+
+

intelligine/synergy/event/pheromone/DetermineDirection.py

@@ -0,0 +1,26 @@
+from synergine.synergy.event.Action import Action
+from intelligine.synergy.event.mind.PheromoneEvent import PheromoneEvent
+
+
+class DetermineDirection(Action):
+
+    _listen = PheromoneEvent
+
+    def prepare(self, context):
+        """
+        Recupere chaque coordonnees de points qui doivent etre update
+        pour ne pas avoir a e calculer dans le run
+        :param context:
+        :return:
+        """
+        pass
+
+    def run(self, obj, context, synergy_manager):
+        """
+        Met a jour la direction en cours de l'ant
+        :param obj:
+        :param context:
+        :param synergy_manager:
+        :return:
+        """
+        pass

intelligine/synergy/event/pheromone/PheromoneEvent.py

@@ -0,0 +1,15 @@
+from synergine.synergy.event.Event import Event
+from intelligine.cst import COL_WALKER
+
+
+class PheromoneEvent(Event):
+    """
+    TODO: dissipation des infos de pheromones:
+          On doit manipuler l'environnement (pas des syn.obj.) car -= l'intensite d'un pt.
+    """
+
+    concern = COL_WALKER # Maybe more when more pheromones
+    _each_cycle = 2
+
+    def _object_match(self, object_id, context, parameters):
+        return True

intelligine/synergy/object/ant/Pheromon.py

@@ -0,0 +1,15 @@
+from xyzworld.SynergyObject import SynergyObject as XyzSynergyObject
+
+
+class Pheromon(XyzSynergyObject):
+
+    def __init__(self, collection, context):
+        super().__init__(collection, context)
+        self._direction = None
+
+    # TODO: direction ailleurs non ?
+    def set_direction(self, direction):
+        self._direction = direction
+
+    def get_direction(self):
+        return self._direction

intelligine/synergy/stigmergy/PheromonesManager.py

@@ -0,0 +1,50 @@
+from intelligine.cst import PHEROMON_INFOS
+
+
+class PheromonesManager():
+
+    def __init__(self, context):
+        self._context = context
+
+    def get_pheromones(self, position, prepare=[]):
+        point_pheromones = self._context.metas.value.get(PHEROMON_INFOS,
+                                                         position,
+                                                         allow_empty=True,
+                                                         empty_value={})
+        current_check = point_pheromones
+        for prepare_key in prepare:
+            if prepare_key not in current_check:
+                current_check[prepare_key] = {}
+            current_check = current_check[prepare_key]
+
+        return point_pheromones
+
+    def set_pheromones(self, position, pheromones):
+        self._context.metas.value.set(PHEROMON_INFOS, position, pheromones)
+
+    def get_info(self, position, address, allow_empty=False, empty_value=None):
+        pheromones = self.get_pheromones(position, address[:-1])
+
+        pheromone = pheromones
+        for key in address[:-1]:
+            pheromone = pheromone[key]
+
+        if address[-1] not in pheromone:
+            if allow_empty:
+              pheromone[address[-1]] = empty_value
+            else:
+                raise IndexError()
+
+        return pheromone[address[-1]]
+
+    def increment(self, position, address, increment_value):
+        pheromones = self.get_pheromones(position, address[:-1])
+
+        pheromone = pheromones
+        for key in address[:-1]:
+            pheromone = pheromone[key]
+
+        if address[-1] not in pheromone:
+            pheromone[address[-1]] = 0
+        pheromone[address[-1]] += increment_value
+        self.set_pheromones(position, pheromones)