WORKING: pheromones appose infos

intelligine/cst.py

 CANT_CARRY_STILL = IncrementedNamedInt.get('intelligine.cantcarry.still')
 CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
 ACTION_DIE = IncrementedNamedInt.get('intelligine.basebug.action.die')
+PHEROMON_POSITIONS = IncrementedNamedInt.get('intelligine.phero.positions')
+PHEROMON_INFOS = IncrementedNamedInt.get('intelligine.phero.infos')
+PHEROMON_DIRECTION = IncrementedNamedInt.get('intelligine.phero.direction')
+PHEROMON_DIR_EXPLO = IncrementedNamedInt.get('intelligine.phero.direction.explo')
 
 COL_ALIVE = IncrementedNamedInt.get('intelligine.col.alive')
 COL_WALKER = IncrementedNamedInt.get('intelligine.col.walker')
 COL_FIGHTER = IncrementedNamedInt.get('intelligine.col.walker')
 COL_TRANSPORTER = IncrementedNamedInt.get('intelligine.col.transporter')
 COL_TRANSPORTER_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_carrying')
-COL_TRANSPORTER_NOT_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_not_carrying')
+COL_TRANSPORTER_NOT_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_not_carrying')

intelligine/display/Pygame.py

 from xyzworld.display.Pygame import Pygame as XyzPygame
+from intelligine.cst import PHEROMON_INFOS, PHEROMON_DIRECTION, PHEROMON_DIR_EXPLO, PHEROMON_POSITIONS
+from intelligine.synergy.object.ant.Pheromon import Pheromon
 
 
 class Pygame(XyzPygame):
-  pass
+
+    def receive(self, synergy_object_manager, context):
+        super().receive(synergy_object_manager, context)
+        self._display_pheromones(context.metas.list.get(PHEROMON_POSITIONS, PHEROMON_POSITIONS, allow_empty=True), context)
+
+    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,
+                                                             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]
+                # TODO: ne pas avoir a creer d'objet, voir comment dans display
+                pheromon = Pheromon(object(), context)
+                pheromon.set_direction(direction)
+                self._draw_objects_with_decal(point, [pheromon])

intelligine/display/pygame/visualisation.py

 eggc5 = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/egg_c5.png')
 eggc7 = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/egg_c7.png')
 
+
+from intelligine.synergy.object.ant.Pheromon import Pheromon
+phee = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/phee.png')
+dir_phee = directions_ant = DirectionnedImage(phee)
+
+
 directions_ant = DirectionnedImage(ant)
 directions_red_ant = DirectionnedImage(red_ant)
 directions_blue_ant = DirectionnedImage(blue_ant)
 directions_green_ant = DirectionnedImage(green_ant)
 
+def phee_direction(phee, context):
+    return dir_phee.get_for_direction(phee.get_direction())
+
 def bug_direction(bug, context):
     if bug.get_life_points() <= 0:
         return dead_ant
         },
         Rock: {
             'default': rock
-        }
+        },
+        Pheromon: {
+            'default': phee,
+            'callbacks': [phee_direction]
+        },
     }
 }

intelligine/synergy/Colony.py

 from intelligine.synergy.event.transport.TakeableAction import TakeableAction
 from intelligine.synergy.event.transport.PutableAction import PutableAction
 from intelligine.synergy.event.CycleAction import CycleAction
+from intelligine.synergy.event.pheromone.ApposeDirection import ApposeDirection
 
 
 class Colony(SynergyCollection):
 
     def __init__(self, configuration):
         super().__init__(configuration)
-        self._actions = [MoveAction, NearAttackableAction, TakeableAction, PutableAction, CycleAction]
+        self._actions = [MoveAction, NearAttackableAction, TakeableAction, PutableAction,
+                         CycleAction, ApposeDirection]

intelligine/synergy/ColonyConfiguration.py

 from synergine.synergy.collection.Configuration import Configuration
 from intelligine.synergy.object.ant.Ant import Ant
 from intelligine.cst import ALIVE, COLONY
+from xyzworld.cst import POSITION
 
 
 class ColonyConfiguration(Configuration):
 
     _start_position = (0, 20, 20)
     _ant_class = Ant
+    _ant_count = 50
 
     def get_start_objects(self, collection, context):
+      context.metas.value.set(POSITION, collection.get_id(), self._start_position)
 
       ants = []
-      for i in range(50):
+      for i in range(self._ant_count):
           ant = self._ant_class(collection, context)
           context.metas.value.set(COLONY, ant.get_id(), collection.get_id())
           ant.set_position(self._start_position)

intelligine/synergy/event/move/direction.py

   26: (25, 26, 27, 16, 17, 18),
   27: (24, 27, 26, 15, 18, 17),
 }
+
+directions_degrees = {
+    (0, 22): 11,
+    (22, 67): 12,
+    (68, 112): 15,
+    (112, 158): 18,
+    (158, 201): 17,
+    (201, 246): 16,
+    (246, 291): 13,
+    (291, 338): 10,
+    (338, 0): 11
+}
+
+def get_direction_for_degrees(degrees):
+    if degrees < 0:
+        degrees = 360 - degrees - degrees - degrees # TODO: math absolute !!!
+    for plage in directions_degrees:
+        if degrees >= plage[0] and degrees <= plage[1]:
+            return directions_degrees[plage]
+    raise IndexError()  # TODO: personnalised exception
+
+"""
+niv 0:   10 11 12
+         13 14 15
+         16 17 18
+"""
+
+directions_opposites = {
+    10: 18,
+    11: 17,
+    12: 16,
+    13: 15,
+    15: 13,
+    16: 12,
+    17: 11,
+    18: 10
+}
+
+def get_direction_opposite(direction):
+    return directions_opposites[direction]

intelligine/synergy/object/BaseBug.py

         context.metas.collections.add(self.get_id(), COL_ALIVE)
         self._life_points = 10
         self._carried_by = None
+        self._movements_count = -1
 
     def hurted(self, points):
         self._life_points -= points
     def is_carried(self):
         if self._carried_by:
             return True
-        return False
+        return False
+
+    def set_position(self, point):
+        super().set_position(point)
+        self._movements_count += 1
+
+    def get_movements_count(self):
+        return self._movements_count

intelligine/synergy/object/ant/Ant.py

                                                            COL_TRANSPORTER_NOT_CARRYING,
                                                            COL_FIGHTER])
         self._carried = []
+        self._last_pheromones_points = {}
 
     def put_carry(self, obj, position=None):
         if position is None:
         if self.is_carrying():
             for obj_carried in self._carried:
                 obj_carried.set_position(position)
+
+    def get_last_pheromone_point(self, pheromone_name):
+        if pheromone_name in self._last_pheromones_points:
+            return self._last_pheromones_points[pheromone_name]
+        return self._start_position
+
+    def set_last_pheromone_point(self, pheromone_name, position):
+        self._last_pheromones_points[pheromone_name] = position