dirty but working code for pheromone food exploration

TODO

@@ -0,0 +1,30 @@
+Warning:
+ * Lorsque une f trp un objet, l'event PUtableEvent observe cjaque tours. C parce que la fourmis rentre dans les clous
+ (carrying). Mais le mechanisme n'a rien trouve: on peux economier les observe dans ce cas la.
+
+Pheromones:
+
+ * Une pheromone doit transporter les données:
+ ** Direction
+ ** Intensité (cumul des pheromones identique, ou depot plus puissant)
+ ** Age (exprimé en "pas"/"nb de cases" depuis l'objectif (colonie/nourriture).
+
+ * Une fourmis ne pose de pheromone que sur la case ou elle se trouve.
+ * Une fourmis ne lit de pheromone que sur la case ou elle se trouve.
+ ** Si il n'y en a pas elle regarde sur les cases autour d'elle
+ *** Si il y a une pheromone (si plusieurs choisir la plus forte, et parmis les plus forte la plus recente (distance))
+ **** Aller dessus, repdrendre depuis "*".
+
+BUGS:
+ * Comme c'est une action qui pose les pheromones, elle survient parfois avant le mouvement. La direction ne pointe
+ alors pas vers la ou il faut. Le depot de pheromone doit etre declenché par l'action de mouvement effectué.
+
+
+NOTE:
+ * Lorsque une fourmis prend un Food; Elle effectue un deplacement en meme temps. Ce qui fait qu'elle va
+   se retrouver a 2 case (?) de la derniere trace de pheromone.aa
+
+Questions en suspens:
+  * Pour limiter la quantité de données, lorsque l'on pose une pheromone pour la direction x, peut-on (au lieu d'ajouter une nouvelle pheromone avec l'age préci) redescendre l'age de la pheromone precedente a l'age en cours.
+    Ex: Directions: Nord: (intensité 5 += 1, age 22 <= 15)
+  * Deux fourmis qui se croisent, posant respectivement ce qu'elle cherche comme pheromone. Vont-elle se bloquer ?

config.py

@@ -2,16 +2,23 @@ from intelligine.core.Context import Context
 from intelligine.synergy.Simulation import Simulation
 from intelligine.display.Pygame import Pygame
 from intelligine.display.pygame.visualisation import visualisation as pygame_visualisation
-from intelligine.sandbox.colored.colors_colonys import collections
+#from intelligine.sandbox.colored.colors_colonys import collections
+# TODO: influencer avec argument python
+from intelligine.sandbox.exploration.collections import collections
 
 """
  TODO:
  * AttackAction :: comment choisir entre les actions ?
- * TakeAction, PutAction, Object Egg
- * --> frameworkiser les usage de states, metas etc ?
- * Plusieurs objets au mm endroit; Cinq oeuf => dessein de cinq oeuf; etc (image dynamique (param max_supperposer ?)
- * 3d
- * Optimisation display pygame: ne pas tout reafficher; opt google
+
+ * pheromones:
+   cf. doc papier
+   + Pour le "pt de ressource": Poser un objet qui, lorsque on applique la position:
+     L'objet doit pouvoir occuper plusieurs positions (gros objet)
+     Il a donc * une position de reference
+               * une liste de positions occupe
+               * dans les metas cette liste de position contient la reference de l'objet
+               *
+
 """
 
 config = {

intelligine/core/exceptions.py

@@ -1,11 +1,28 @@
 class MovementException(Exception):
     pass
 
+
 class SamePosition(MovementException):
     pass
 
+
 class PheromoneException(Exception):
     pass
 
+
+class NoPheromone(PheromoneException):
+    pass
+
+
 class NoPheromoneMove(PheromoneException, MovementException):
-    pass
+    pass
+
+
+class BestPheromoneHere(PheromoneException):
+
+    def __init__(self, best_distance,  *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._best_distance = best_distance
+
+    def get_best_distance(self):
+        return self._best_distance

intelligine/cst.py

@@ -15,9 +15,12 @@ CANT_CARRY_STILL = IncrementedNamedInt.get('intelligine.cantcarry.still')
 CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
 ACTION_DIE = IncrementedNamedInt.get('intelligine.basebug.action.die')
 
+MOVE_MODE = IncrementedNamedInt.get('intelligine.basebug.move.mode')
 MOVE_MODE_EXPLO = IncrementedNamedInt.get('intelligine.basebug.move.mode.explo')
 MOVE_MODE_GOHOME = IncrementedNamedInt.get('intelligine.basebug.move.mode.gohome')
 
+LAST_PHERMONES_POINTS = IncrementedNamedInt.get('intelligine.last_pheromones_points')
+
 PHEROMON_POSITIONS = IncrementedNamedInt.get('intelligine.phero.positions')
 PHEROMON_INFOS = IncrementedNamedInt.get('intelligine.phero.infos')
 PHEROMON_DIRECTION = IncrementedNamedInt.get('intelligine.phero.direction')

intelligine/display/Pygame.py

@@ -25,11 +25,10 @@ class Pygame(XyzPygame):
                                                              allow_empty=True,
                                                              empty_value={})
 
-            for direction in exploration_info:
-                intensity = exploration_info[direction]
-                # TODO: ne pas avoir a creer d'objet, voir comment dans display
+            # TODO: ne pas avoir a creer d'objet, voir comment dans display
+            if exploration_info:
                 pheromon = PheromonHome(object(), context)
-                pheromon.set_direction(direction)
+                pheromon.set_direction(11) # TODO: plus de direction avec ces nlles pheromones
                 self._draw_objects_with_decal(point, [pheromon])
 
 
@@ -38,12 +37,10 @@ class Pygame(XyzPygame):
                                                               PHEROMON_DIR_EXPLO],
                                                              allow_empty=True,
                                                              empty_value={})
-
-            for direction in exploration_info:
-                intensity = exploration_info[direction]
+            if exploration_info:
                 # TODO: ne pas avoir a creer d'objet, voir comment dans display
                 pheromon = PheromonExploration(object(), context)
-                pheromon.set_direction(direction)
+                pheromon.set_direction(11) # TODO: plus de direction avec ces nlles pheromones
                 self._draw_objects_with_decal(point, [pheromon])
 
     def _key_pressed(self, key):

intelligine/display/pygame/visualisation.py

@@ -2,6 +2,7 @@ from xyworld.display.object.pygame.PygameImage import PygameImage
 from xyworld.display.object.pygame.DirectionnedImage import DirectionnedImage
 from intelligine.synergy.object.Bug import Bug
 from intelligine.synergy.object.Food import Food
+from intelligine.synergy.object.Hole import Hole
 from intelligine.synergy.object.ant.Ant import Ant
 from intelligine.sandbox.colored.BlueAnt import BlueAnt
 from intelligine.sandbox.colored.RedAnt import RedAnt
@@ -15,6 +16,7 @@ from intelligine.cst import PREVIOUS_DIRECTION
 
 ant = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/ant.png')
 food = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/food.png')
+hole = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/hole.png')
 dead_ant = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/dead_ant.png')
 red_ant = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/red_ant.png')
 green_ant = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/green_ant.png')
@@ -139,6 +141,9 @@ visualisation = {
         Food: {
             'default': food
         },
+        Hole: {
+            'default': hole
+        },
         PheromonExploration: {
             'default': phee,
             'callbacks': [phee_direction]

intelligine/sandbox/exploration/ColonyConfiguration.py

@@ -1,11 +1,12 @@
+from intelligine.core.exceptions import BestPheromoneHere
+from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
 from intelligine.synergy.ColonyConfiguration import ColonyConfiguration
 from intelligine.synergy.object.ant.Ant import Ant
+from intelligine.cst import PHEROMON_DIR_HOME
 
 
 class ColonyConfiguration(ColonyConfiguration):
 
     _start_position = (0, 5, 5)
     _ant_class = Ant
-    _ant_count = 50
-
-
+    _ant_count = 5

intelligine/sandbox/exploration/map2.tmx

@@ -18,9 +18,18 @@
    </properties>
   </tile>
  </tileset>
+ <tileset firstgid="3" name="hole" tilewidth="20" tileheight="20">
+  <image source="../../display/pygame/image/hole.png" width="20" height="20"/>
+  <tile id="0">
+   <properties>
+    <property name="classname" value="Hole"/>
+    <property name="file" value="intelligine.synergy.object.Hole"/>
+   </properties>
+  </tile>
+ </tileset>
  <layer name="Calque 1" width="200" height="100">
   <data encoding="base64" compression="zlib">
-   eJzt3MEKg0AQREH1/z86lxyFBFnxTVIFc2+36av7tm27u3z8tikdF3MWM7HWlI6LOYuZWGtKx8WcxUysNaXjYs5iJtaa0nExZzETa03p+FPOJ75jyttxXaHjbzLYB08odGwfVBU6tg+qCh3bB1WFju2DqkLH9kFVoWP7oKrQsX1QVejYPqgqdGwfVBU6tg+qCh1P28fxvsLbca9Cxysy3P0dx8kV3o57FTqu7+NsG/bxHwod2wdVhY7tg6qn/48z/QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaHgB3d0BMg==
+   eJzt3MFKI0EARdFE//+fBxeiDE5MXsIs6p4DvS14dC4upOt6uVyunvnhbK96x6f+Vt5uPKdu5os+fqePLn3cRx9N+rifPnp+esfvLzrnRPpo8ffjcfro0MdGHw362BU31+hjV9xco49dcXONPnbFzTX62BU31+hjV9xco49dcXONPnbFzTX62BU31+hjV9xco49dcXONPnbFzTX62BU31+hjV9xc8/GOb91BcO9T/K0UN9foY1fcXKOPXXFzjT52xc01+tgVN9foY1fcXKOPXXFzjf9/7Iqba/SxK26u0ceuuLlGH7vi5hp97Iqba/SxK26u0ceuuLlGH7vi5hp97Iqba/SxK26u0ceuuLlGH7vi5hp97Iqba/SxK26u0ceuuLlGH7vi5hp9bKrfhNXo43HlbyZrPr+vfcU5BfVvimu+f3/+7Dmn8819z9/3MzxzzsncSdH00/0l6zmncmdL17/u91nOOZE7jdpu3X/16DmncecXv90P98g5J3EnHh+unqceAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+jz/dxQL7
   </data>
  </layer>
 </map>

intelligine/simulation/object/brain/AntBrain.py

@@ -0,0 +1,37 @@
+from intelligine.simulation.object.brain.Brain import Brain
+from intelligine.cst import MOVE_MODE, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO
+
+
+class AntBrain(Brain):
+
+    def __init__(self, context, host):
+        super().__init__(context, host)
+        self._movement_mode = MOVE_MODE_EXPLO
+        self._distance_from_objective = 0  # TODO rename: distance_since_objective
+
+    def switch_to_mode(self, mode):
+        self._movement_mode = mode
+        self._update_pheromone_gland(mode)
+        self._context.metas.value.set(MOVE_MODE, self._host.get_id(), mode)
+        self._distance_from_objective = 0
+
+    def _update_pheromone_gland(self, mode):
+        if mode == MOVE_MODE_EXPLO:
+            pheromone_direction_type = PHEROMON_DIR_HOME
+        elif mode == MOVE_MODE_GOHOME:
+            pheromone_direction_type = PHEROMON_DIR_EXPLO
+        else:
+            raise NotImplementedError()
+        self._host.get_movement_pheromone_gland().set_pheromone_type(pheromone_direction_type)
+
+    def get_movement_mode(self):
+        return self._movement_mode
+
+    def host_moved(self, distance=1):
+        self._distance_from_objective += 1
+
+    def set_distance_from_objective(self, distance):
+        self._distance_from_objective = distance
+
+    def get_distance_from_objective(self):
+        return self._distance_from_objective

intelligine/simulation/object/brain/Brain.py

@@ -0,0 +1,5 @@
+class Brain():
+
+    def __init__(self, context, host):
+        self._context = context
+        self._host = host

intelligine/simulation/object/pheromone/MovementPheromoneGland.py

@@ -0,0 +1,11 @@
+from intelligine.simulation.object.pheromone.PheromoneGland import PheromoneGland
+
+
+class MovementPheromoneGland(PheromoneGland):
+
+
+    def get_movement_molecules(self):
+        """
+        :return: pheromone_type, distance_from_objective
+        """
+        return self._pheromone_type, self._host.get_brain().get_distance_from_objective()

intelligine/simulation/object/pheromone/PheromoneGland.py

@@ -0,0 +1,13 @@
+class PheromoneGland():
+
+    def __init__(self, host):
+        self._pheromone_type = None
+        self._host = host
+
+    def set_pheromone_type(self, pheromone_type):
+        self._pheromone_type = pheromone_type
+
+    def get_pheromone_type(self):
+        if self._pheromone_type is None:
+            raise Exception("pheromone_type not specified")
+        return self._pheromone_type

intelligine/simulation/pheromone/DirectionPheromone.py

@@ -0,0 +1,107 @@
+from collections import OrderedDict
+from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_POSITIONS, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME,\
+    PHEROMON_DIR_EXPLO, PHEROMON_DIR_HOME
+from intelligine.core.exceptions import NoPheromone
+from random import shuffle
+from xyzworld.geometry import get_degree_from_north
+from intelligine.synergy.event.move.direction import get_direction_for_degrees
+
+
+class DirectionPheromone():
+
+    @staticmethod
+    def get_pheromone_type_for_move_mode(move_mode):
+        if move_mode == MOVE_MODE_EXPLO:
+            return PHEROMON_DIR_EXPLO
+        if move_mode == MOVE_MODE_GOHOME:
+            return PHEROMON_DIR_HOME
+        raise NotImplementedError()
+
+    @staticmethod
+    def appose(context, point, movement_molecules):
+        pheromone_type, distance_from = movement_molecules
+        # TODO: Ajouter l'age de la pheromone !
+        context.pheromones().increment(point, [PHEROMON_DIRECTION, pheromone_type], distance=distance_from)
+        context.metas.list.add(PHEROMON_POSITIONS, PHEROMON_POSITIONS, point, assert_not_in=False)
+
+    @staticmethod
+    def get_direction_for_point(context, point, pheromone_type):
+        try:
+            pheromone_info = context.pheromones().get_info(point, [PHEROMON_DIRECTION, pheromone_type])
+        except KeyError:
+            raise NoPheromone()
+
+        # DEBUG: On se rettrouve avec un {} ...
+        if not pheromone_info:
+            raise NoPheromone()
+
+        point_intensity = pheromone_info[1]
+        point_distance = pheromone_info[0]
+        arround_points = context.get_arround_points_of(point)
+
+        arround_pheromones_points = []
+        for arround_point in arround_points:
+            arround_pheromone_info = context.pheromones().get_info(arround_point,
+                                                                   [PHEROMON_DIRECTION, pheromone_type],
+                                                                   allow_empty=True,
+                                                                   empty_value={})
+            if arround_pheromone_info and arround_pheromone_info[0] < point_distance:
+                arround_pheromones_points.append((arround_point, arround_pheromone_info))
+
+        if not arround_pheromones_points:
+            raise NoPheromone()
+
+        shuffle(arround_pheromones_points)
+        arround_pheromones_sorted = sorted(arround_pheromones_points, key=lambda x: x[1][1])
+        max_intensity = arround_pheromones_sorted[0][1][1]
+
+        arround_pheromones_max = []
+        for arround_pheromone_sorted in arround_pheromones_sorted:
+            if arround_pheromone_sorted[1][1] == max_intensity:
+                arround_pheromones_max.append(arround_pheromone_sorted)
+
+        arround_pheromones_sorted_by_distance = sorted(arround_pheromones_max, key=lambda x: x[1][0], reverse=False)
+
+        go_to_point = arround_pheromones_sorted_by_distance[0][0]
+
+        direction_degrees = get_degree_from_north(point, go_to_point)
+        direction = get_direction_for_degrees(direction_degrees)
+
+        return direction
+        # # 1: On melange
+        # items = pheromone_info.items()
+        # shuffle(items)
+        # ph = OrderedDict(items)
+        # foo = True
+        # # 2: On trie par puissance
+        # ph_sorted = sorted(ph.items(), key=lambda x: x[1])
+        # # 3: On recupere les direction de la puissance max
+        # max_intensity = ph_sorted[0][1][1]
+        # max_directions = [direction_name for direction_name in pheromone_info
+        #                  if pheromone_info[direction_name][1] == max_intensity]
+        # # 4: On trie par age
+        # # 5: On recupere les directions de l'age le plus court
+        # # 6: On choisis une direction au hasard parmis elles (ou par rapport a direction precedente ??bug autre fois??)
+
+    @staticmethod
+    def get_best_pheromone_direction_in(context, reference_point, points, pheromone_type):
+        arround_pheromones_points = []
+        for arround_point in points:
+            arround_pheromone_info = context.pheromones().get_info(arround_point,
+                                                                   [PHEROMON_DIRECTION, pheromone_type],
+                                                                   allow_empty=True,
+                                                                   empty_value={})
+            if arround_pheromone_info:
+                arround_pheromones_points.append((arround_point, arround_pheromone_info))
+
+        if not arround_pheromones_points:
+            raise NoPheromone()
+
+        shuffle(arround_pheromones_points)
+        arround_pheromones_sorted = sorted(arround_pheromones_points, key=lambda x: x[1][1])
+        go_to_point = arround_pheromones_sorted[0][0]
+
+        direction_degrees = get_degree_from_north(reference_point, go_to_point)
+        direction = get_direction_for_degrees(direction_degrees)
+
+        return direction

intelligine/synergy/Colony.py

@@ -13,4 +13,4 @@ class Colony(SynergyCollection):
     def __init__(self, configuration):
         super().__init__(configuration)
         self._actions = [MoveAction, NearAttackableAction, TakeableAction, PutableAction,
-                         CycleAction, ApposeDirection]
+                         CycleAction]

intelligine/synergy/event/move/MoveAction.py

@@ -2,9 +2,15 @@ from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.move.MoveEvent import MoveEvent
 from random import randint, choice, randrange
 from xyzworld.cst import POSITION, POSITIONS
-from intelligine.cst import PREVIOUS_DIRECTION, BLOCKED_SINCE
+from intelligine.cst import PREVIOUS_DIRECTION, BLOCKED_SINCE, MOVE_MODE, MOVE_MODE_GOHOME, MOVE_MODE_EXPLO, \
+                            PHEROMON_DIR_EXPLO, PHEROMON_DIR_HOME, PHEROMON_DIRECTION, \
+    COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING
 from intelligine.synergy.event.move.direction import directions_same_level, directions_modifiers, directions_slighty
-from intelligine.core.exceptions import NoPheromoneMove
+from intelligine.core.exceptions import NoPheromoneMove, NoPheromone, BestPheromoneHere
+import operator
+from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
+from xyzworld.geometry import get_degree_from_north
+from intelligine.synergy.event.move.direction import get_direction_for_degrees, directions_opposites
 
 
 class MoveAction(Action):
@@ -12,28 +18,62 @@ class MoveAction(Action):
     _listen = MoveEvent
 
     def __init__(self, object_id, parameters):
-      super().__init__(object_id, parameters)
-      self._move_to_point = None
-      self._move_to_direction = None
+        super().__init__(object_id, parameters)
+        self._move_to_point = None
+        self._move_to_direction = None
 
     def prepare(self, context):
-      object_point = context.metas.value.get(POSITION, self._object_id)
-      try:
-          choosed_direction_name, choosed_direction_point = self._get_pheromone_direction_point(context, object_point)
-      except NoPheromoneMove:
-          choosed_direction_name, choosed_direction_point = self._get_random_direction_point(context, object_point)
-      if self._direction_point_is_possible(context, choosed_direction_point):
-        self._move_to_point = choosed_direction_point
-        self._move_to_direction = choosed_direction_name
-
-    def _get_random_direction_point(self, context, reference_point):
-        z, x, y = reference_point
-        direction_name = self._get_random_direction_name(context)
-        directions_modifier = directions_modifiers[direction_name]
-        new_position = (z + directions_modifier[0], x + directions_modifier[1], y + directions_modifier[2])
-        return (direction_name, new_position)
+        object_point = context.metas.value.get(POSITION, self._object_id)
+
+        try:
+            direction = self._get_direction_with_pheromones(context, object_point)
+        except NoPheromone:
+            direction = self._get_random_direction(context)
+
+        move_to_point = self._get_point_for_direction(object_point, direction)
+        if self._direction_point_is_possible(context, move_to_point):
+            self._move_to_point = move_to_point
+            self._move_to_direction = direction
+        else:
+            # TODO: mettre self._dont_move = True ?
+            pass
+
+    def _get_direction_with_pheromones(self, context, object_point):
+        # TODO: Placer directnement pheromone type dans les metas
+        object_movement_mode = context.metas.value.get(MOVE_MODE, self._object_id)
+        pheromone_type = DirectionPheromone.get_pheromone_type_for_move_mode(object_movement_mode)
+        try:
+            direction = self._get_pheromone_direction_for_point(context, object_point, pheromone_type)
+        except NoPheromone:
+            direction = self._get_direction_of_pheromone(context, object_point, pheromone_type)
+        return direction
+
+    @staticmethod
+    def _get_pheromone_direction_for_point(context, point, pheromone_type):
+        return DirectionPheromone.get_direction_for_point(context, point, pheromone_type)
+
+    @staticmethod
+    def _get_direction_of_pheromone(context, point, pheromone_type):
+        search_pheromone_distance = 1  # TODO: config
+        search_pheromone_in_points = context.get_arround_points_of(point, distance=search_pheromone_distance)
+        try:
+            # TODO: ? Avoir plutot un DirectionPheromone.get_best_pheromone_direction_in ?
+            best_pheromone_direction = DirectionPheromone.get_best_pheromone_direction_in(context,
+                                                                                          point,
+                                                                                          search_pheromone_in_points,
+                                                                                          pheromone_type)
+            return best_pheromone_direction
+        except NoPheromone as err:
+            raise err
+
+    # def _get_random_direction_point(self, context, reference_point):
+    #     z, x, y = reference_point
+    #     direction_name = self._get_random_direction_name(context)
+    #     directions_modifier = directions_modifiers[direction_name]
+    #     new_position = (z + directions_modifier[0], x + directions_modifier[1], y + directions_modifier[2])
+    #     return (direction_name, new_position)
 
-    def _get_random_direction_name(self, context):
+    def _get_random_direction(self, context):
         try:
             blocked_since = context.metas.value.get(BLOCKED_SINCE, self._object_id)
         except KeyError:
@@ -59,14 +99,45 @@ class MoveAction(Action):
 
         return direction_name
 
-    def _direction_point_is_possible(self, context, direction_point):
+    @staticmethod
+    def _get_point_for_direction(reference_point, direction):
+        # TODO: mettre une fonction cote direction.py pour appliquer le modifier.
+        z, x, y = reference_point
+        directions_modifier = directions_modifiers[direction]
+        return z + directions_modifier[0], x + directions_modifier[1], y + directions_modifier[2]
+
+    @staticmethod
+    def _direction_point_is_possible(context, direction_point):
         return context.position_is_penetrable(direction_point)
 
     def run(self, obj, context, synergy_manager):
-        if self._move_to_point is not None:
+        if self._move_to_point is not None and self._move_to_direction != 14: # TODO: il ne faut pas choisir une direction 14.
             obj.set_position(self._move_to_point)
+            #direction_from = directions_opposites[self._move_to_direction]
+            #obj.set_direction_from(direction_from)
             context.metas.value.set(PREVIOUS_DIRECTION, self._object_id, self._move_to_direction)
             context.metas.value.set(BLOCKED_SINCE, self._object_id, 0)
+            self._appose_pheromone(obj, context)
+
+            # TEST: le temps de tout tester
+            if self._move_to_point == (0, 5, 5) and obj.is_carrying():
+                obj_transported = obj.get_carried()
+                obj_transported.set_carried_by(None)
+                obj.put_carry(obj_transported, (-1, 0, 0))
+                obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
+                context.metas.collections.add_remove(obj.get_id(),
+                    COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING)
+
+            # TMP: Devra etre un event et une action
+            # if self._move_to_point == (0, 5, 5):  # position de depart
+            #     if len(obj._carried):
+            #         obj_transported = obj.get_carried()
+            #         obj_transported.set_carried_by(None)
+            #         obj.put_carry(obj_transported, (-1, 5, 5))
+            #         context.metas.collections.add_remove(obj.get_id(), COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING)
+            #     obj.set_movement_mode(MOVE_MODE_EXPLO)
+
+
         else:
             try:
                 blocked_since = context.metas.value.get(BLOCKED_SINCE, self._object_id)
@@ -74,6 +145,66 @@ class MoveAction(Action):
                 blocked_since = 0
             context.metas.value.set(BLOCKED_SINCE, self._object_id, blocked_since+1)
 
-    def _get_pheromone_direction_point(self, context, object_point):
+    # def _get_pheromone_direction_point(self, context, object_point):
+    #     try:
+    #         blocked_since = context.metas.value.get(BLOCKED_SINCE, self._object_id)
+    #     except KeyError:
+    #         blocked_since = 0
+    #     if blocked_since > 3:
+    #         raise NoPheromoneMove()
+    #     # Si on explore, on cherche pheromone d'explo
+    #     # si on rentre a home, on cherche pheromone d'home...
+    #     # TODO: code arrache
+    #     object_movement_mode = context.metas.value.get(MOVE_MODE, self._object_id)
+    #     if object_movement_mode == MOVE_MODE_EXPLO:
+    #         pheromone_direction_type = PHEROMON_DIR_EXPLO
+    #     elif object_movement_mode == MOVE_MODE_GOHOME:
+    #         pheromone_direction_type = PHEROMON_DIR_HOME
+    #
+    #     sniff_points = context.get_arround_points_of(object_point, distance=0)
+    #     # Faire un compile des infos de pheromones
+    #
+    #     directions = {}
+    #     for sniff_point in sniff_points:
+    #         info = context.pheromones().get_info(sniff_point,
+    #                                              [PHEROMON_DIRECTION, pheromone_direction_type],
+    #                                              allow_empty=True,
+    #                                              empty_value={})
+    #         for direction in info:
+    #             if direction not in directions:
+    #                 directions[direction] = info[direction]
+    #             else:
+    #                 directions[direction] += info[direction]
+    #     if len(directions):
+    #         sorted_directions = sorted(directions.items(), key=operator.itemgetter(1))
+    #         sorted_directions.reverse()
+    #         #best_direction_name = sorted_directions[0][0]
+    #         best_direction_level = sorted_directions[0][1]
+    #         best_direction_names = [direction for direction in directions \
+    #                                if directions[direction] == best_direction_level]
+    #         # Si plusieurs best directions, choisir mm direction que la precedente
+    #         # si y a pas, au hasard.
+    #         last_dir_name = context.metas.value.get(PREVIOUS_DIRECTION, self._object_id)
+    #         if last_dir_name in best_direction_names:
+    #             direction_name = last_dir_name
+    #         else:
+    #             direction_name = choice(best_direction_names)
+    #
+    #         # DRY
+    #         z, x, y = object_point
+    #         directions_modifier = directions_modifiers[direction_name]
+    #         new_position = (z + directions_modifier[0], x + directions_modifier[1], y + directions_modifier[2])
+    #         return (direction_name, new_position)
+    #
+    #         pass
+    #     raise NoPheromoneMove()
 
-        raise NoPheromoneMove()
+    def _appose_pheromone(self, obj, context):
+        # TODO: Cette action de pheromone doit etre une surcharge de Move afin d'avoir une Action Move generique.
+        obj.get_brain().host_moved()
+        try:
+            DirectionPheromone.appose(context,
+                                      obj.get_position(),
+                                      obj.get_movement_pheromone_gland().get_movement_molecules())
+        except BestPheromoneHere as best_pheromone_here:
+            obj.get_brain().set_distance_from_objective(best_pheromone_here.get_best_distance())

intelligine/synergy/event/move/direction.py

@@ -98,15 +98,15 @@ directions_slighty = {
 }
 
 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
+    (0, 22.5): 11,
+    (22.5, 67): 12,
+    (67, 112.5): 15,
+    (112.5, 157.5): 18,
+    (157.5, 202.5): 17,
+    (202.5, 247.5): 16,
+    (247.5, 292.5): 13,
+    (292.5, 337.5): 10,
+    (337.5, 0): 11
 }
 
 def get_direction_for_degrees(degrees):

intelligine/synergy/event/pheromone/ApposeDirection.py

@@ -1,65 +0,0 @@
-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_HOME, PHEROMON_POSITIONS, MOVE_MODE_EXPLO, \
-    MOVE_MODE_GOHOME, PHEROMON_DIR_EXPLO
-from xyzworld.geometry import get_degree_from_north
-from intelligine.synergy.event.move.direction import get_direction_for_degrees, get_direction_opposite
-from intelligine.core.exceptions import SamePosition
-
-
-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)
-        """
-        self._appose_pheromones(obj, context, synergy_manager)
-
-    def _appose_pheromones(self, obj, context, synergy_manager):
-        try:
-            from_direction = self._get_from_direction(obj)
-        except SamePosition:
-            return
-
-        depose_intensity = 1 # TODO: config
-        pheromone_direction_type = self._get_pheromone_direction_type(obj)
-        for affected_point in self._parameters['concerned_points']:
-            context.pheromones().increment(affected_point, [PHEROMON_DIRECTION,
-                                                            pheromone_direction_type,
-                                                            from_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 _get_from_direction(self, obj):
-        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:
-            raise SamePosition()
-        direction = get_direction_for_degrees(direction_degrees)
-        return get_direction_opposite(direction)
-
-    def _get_pheromone_direction_type(self, obj):
-        if obj.get_movement_mode() == MOVE_MODE_EXPLO:
-            return PHEROMON_DIR_HOME
-        if obj.get_movement_mode() == MOVE_MODE_GOHOME:
-            return PHEROMON_DIR_EXPLO
-        raise NotImplementedError()

intelligine/synergy/event/pheromone/DetermineDirection.py

@@ -1,26 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/BaseBug.py

@@ -1,5 +1,6 @@
 from intelligine.synergy.object.Transportable import Transportable
 from intelligine.cst import ALIVE, ATTACKABLE, COL_ALIVE
+from intelligine.simulation.object.brain.Brain import Brain
 
 
 class BaseBug(Transportable):
@@ -10,6 +11,7 @@ class BaseBug(Transportable):
         context.metas.collections.add(self.get_id(), COL_ALIVE)
         self._life_points = 10
         self._movements_count = -1
+        self._brain = self._get_brain_instance()
 
     def hurted(self, points):
         self._life_points -= points
@@ -22,4 +24,10 @@ class BaseBug(Transportable):
         self._movements_count += 1
 
     def get_movements_count(self):
-        return self._movements_count
+        return self._movements_count
+
+    def _get_brain_instance(self):
+        return Brain(self._context, self)
+
+    def get_brain(self):
+        return self._brain

intelligine/synergy/object/Food.py

@@ -1,15 +1,14 @@
 from intelligine.synergy.object.Transportable import Transportable
-from intelligine.cst import IMPENETRABLE, TRANSPORTABLE
+from intelligine.cst import TRANSPORTABLE
 
 
 class Food(Transportable):
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
-        context.metas.states.add(self.get_id(), IMPENETRABLE)
         context.metas.states.add(self.get_id(), TRANSPORTABLE)
 
-    def get_carry(self):
+    def get_what_carry(self):
         clone = self.__class__(self._collection, self._context)
         self._collection.add_object(clone)
         return clone

intelligine/synergy/object/Hole.py

@@ -0,0 +1,5 @@
+from xyzworld.SynergyObject import SynergyObject as XyzSynergyObject
+
+
+class Hole(XyzSynergyObject):
+    pass

intelligine/synergy/object/ant/Ant.py

@@ -1,9 +1,13 @@
+from intelligine.core.exceptions import BestPheromoneHere
+from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
 from intelligine.synergy.object.Bug import Bug
 from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER, \
                             COL_TRANSPORTER, COL_TRANSPORTER_NOT_CARRYING, \
                             COL_FIGHTER, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, \
-                            PHEROMON_DIR_EXPLO
+                            PHEROMON_DIR_EXPLO, LAST_PHERMONES_POINTS
 from intelligine.synergy.object.Food import Food
+from intelligine.simulation.object.pheromone.MovementPheromoneGland import MovementPheromoneGland
+from intelligine.simulation.object.brain.AntBrain import AntBrain
 
 
 class Ant(Bug):
@@ -16,7 +20,14 @@ class Ant(Bug):
                                                            COL_FIGHTER])
         self._carried = []
         self._last_pheromones_points = {}
-        self._movement_mode = MOVE_MODE_EXPLO
+        self._movement_pheromone_gland = MovementPheromoneGland(self)
+        self._brain.switch_to_mode(MOVE_MODE_EXPLO)
+
+    def _get_brain_instance(self):
+        return AntBrain(self._context, self)
+
+    def get_movement_pheromone_gland(self):
+        return self._movement_pheromone_gland
 
     def put_carry(self, obj, position=None):
         if position is None:
@@ -34,7 +45,7 @@ class Ant(Bug):
         self._context.metas.states.add(self.get_id(), CARRYING)
         # TODO: pour le moment hardcode
         if isinstance(obj, Food):
-            self.set_movement_mode(MOVE_MODE_GOHOME)
+            self.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
             self.set_last_pheromone_point(PHEROMON_DIR_EXPLO, obj.get_position())
 
     def is_carrying(self):
@@ -56,9 +67,13 @@ class Ant(Bug):
 
     def set_last_pheromone_point(self, pheromone_name, position):
         self._last_pheromones_points[pheromone_name] = position
+        self._context.metas.value.set(LAST_PHERMONES_POINTS, self.get_id(), self._last_pheromones_points)
 
-    def get_movement_mode(self):
-        return self._movement_mode
-
-    def set_movement_mode(self, movement_mode):
-        self._movement_mode = movement_mode
+    def initialize(self):
+        super().initialize()
+        try:
+            DirectionPheromone.appose(self._context,
+                                      self.get_position(),
+                                      self.get_movement_pheromone_gland().get_movement_molecules())
+        except BestPheromoneHere as best_pheromone_here:
+            pass

intelligine/synergy/stigmergy/PheromonesManager.py

@@ -1,4 +1,6 @@
+from intelligine.core.exceptions import BestPheromoneHere
 from intelligine.cst import PHEROMON_INFOS
+from intelligine.core.exceptions import NoPheromone
 
 
 class PheromonesManager():
@@ -31,13 +33,13 @@ class PheromonesManager():
 
         if address[-1] not in pheromone:
             if allow_empty:
-              pheromone[address[-1]] = empty_value
+                pheromone[address[-1]] = empty_value
             else:
-                raise IndexError()
+                raise KeyError()
 
         return pheromone[address[-1]]
 
-    def increment(self, position, address, increment_value):
+    def increment(self, position, address, distance, increment_value=1):
         pheromones = self.get_pheromones(position, address[:-1])
 
         pheromone = pheromones
@@ -45,6 +47,21 @@ class PheromonesManager():
             pheromone = pheromone[key]
 
         if address[-1] not in pheromone:
-            pheromone[address[-1]] = 0
-        pheromone[address[-1]] += increment_value
-        self.set_pheromones(position, pheromones)
+            pheromone[address[-1]] = (distance, 0)
+        # On se retrouve avec un {} dans pheromone[address[-1]]. A cause de la recherche de pheromone avant (et main process)
+        if not pheromone[address[-1]]:
+            pheromone[address[-1]] = (distance, 0)
+
+        pheromone_distance = pheromone[address[-1]][0]
+        pheromone_intensity = pheromone[address[-1]][1]
+
+        pheromone_intensity += increment_value
+
+        if distance < pheromone_distance:
+            pheromone_distance = distance
+
+        pheromone[address[-1]] = (pheromone_distance, pheromone_intensity)
+        self.set_pheromones(position, pheromones)
+
+        if distance > pheromone_distance:
+            raise BestPheromoneHere(pheromone_distance)