Pheromone: object model

intelligine/core/exceptions.py

     pass
 
 
+class NoTypeInPheromone(NoPheromone):
+    pass
+
+
+class NoCategoryInPheromone(NoPheromone):
+    pass
+
+
 class BestPheromoneHere(PheromoneException):
 
     def __init__(self, best_distance,  *args, **kwargs):

intelligine/display/Pygame.py

+from intelligine.core.exceptions import NoPheromone
 from xyzworld.display.Pygame import Pygame as XyzPygame
 import pygame
 from intelligine.cst import PHEROMON_INFOS, PHEROMON_DIRECTION, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, PHEROMON_POSITIONS
         super().__init__(config, context)
         self._is_display_pheromones = False
 
-
     def receive(self, synergy_object_manager, context):
         super().receive(synergy_object_manager, context)
         if self._is_display_pheromones:
             self._display_pheromones(context.metas.list.get(PHEROMON_POSITIONS, PHEROMON_POSITIONS, allow_empty=True), context)
 
     def _display_pheromones(self, pheromones_positions, context):
+        # TODO: Code de test bordelique !
         for point in pheromones_positions:
-            exploration_info = context.pheromones().get_info(point,
-                                                             [PHEROMON_DIRECTION,
-                                                              PHEROMON_DIR_HOME],
-                                                             allow_empty=True,
-                                                             empty_value={})
-
-            # TODO: ne pas avoir a creer d'objet, voir comment dans display
-            if exploration_info:
+            flavour = context.pheromones().get_flavour(point)
+            try:
+                flavour.get_pheromone(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_HOME)
                 pheromon = PheromonHome(object(), context)
                 pheromon.set_direction(11) # TODO: plus de direction avec ces nlles pheromones
                 self._draw_objects_with_decal(point, [pheromon])
-
-
-            exploration_info = context.pheromones().get_info(point,
-                                                             [PHEROMON_DIRECTION,
-                                                              PHEROMON_DIR_EXPLO],
-                                                             allow_empty=True,
-                                                             empty_value={})
-            if exploration_info:
-                # TODO: ne pas avoir a creer d'objet, voir comment dans display
+            except NoPheromone:
+                pass
+            try:
+                flavour.get_pheromone(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_EXPLO)
                 pheromon = PheromonExploration(object(), context)
                 pheromon.set_direction(11) # TODO: plus de direction avec ces nlles pheromones
                 self._draw_objects_with_decal(point, [pheromon])
+            except NoPheromone:
+                pass
 
     def _key_pressed(self, key):
         if key == pygame.K_p:

intelligine/simulation/object/pheromone/MovementPheromoneGland.py

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

intelligine/simulation/object/pheromone/PheromoneGland.py

             raise Exception("pheromone_type not specified")
         return self._pheromone_type
 
+    def get_pheromone(self):
+        raise NotImplementedError()
+
     def appose(self):
         try:
             DirectionPheromone.appose(self._context,
                                       self._host.get_position(),
-                                      self._host.get_movement_pheromone_gland().get_movement_molecules())
+                                      self.get_pheromone())
         except BestPheromoneHere as best_pheromone_here:
             self._host.get_brain().set_distance_from_objective(best_pheromone_here.get_best_distance())

intelligine/simulation/pheromone/DirectionPheromone.py

 class DirectionPheromone():
 
     @staticmethod
-    def appose(context, point, movement_molecules):
-        pheromone_type, distance_from = movement_molecules
-        context.pheromones().increment(point, [PHEROMON_DIRECTION, pheromone_type], distance=distance_from)
+    def appose(context, point, pheromone):
+        context.pheromones().increment_with_pheromone(point, pheromone)
         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()
+        flavour = context.pheromones().get_flavour(point)
+        pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
 
-        point_intensity = pheromone_info[1]
-        point_distance = pheromone_info[0]
+        distance = pheromone.get_distance()
         around_points = context.get_around_points_of(point)
-
+        # TODO: Cet algo around a mettre ailleurs
         around_pheromones_points = []
         for around_point in around_points:
-            around_pheromone_info = context.pheromones().get_info(around_point,
-                                                                   [PHEROMON_DIRECTION, pheromone_type],
-                                                                   allow_empty=True,
-                                                                   empty_value={})
-            if around_pheromone_info and around_pheromone_info[0] < point_distance:
-                around_pheromones_points.append((around_point, around_pheromone_info))
+            flavour = context.pheromones().get_flavour(around_point)
+            try:
+                around_pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
+                if around_pheromone.get_distance() < distance:
+                    around_pheromones_points.append((around_point, around_pheromone))
+            except NoPheromone:
+                pass  # No pheromone, ok continue to sniff around
 
         if not around_pheromones_points:
             raise NoPheromone()
 
         shuffle(around_pheromones_points)
-        around_pheromones_sorted = sorted(around_pheromones_points, key=lambda x: x[1][1], reverse=True)
-        max_intensity = around_pheromones_sorted[0][1][1]
+        around_pheromones_sorted = sorted(around_pheromones_points, key=lambda x: x[1].get_intensity(), reverse=True)
+        max_intensity = around_pheromones_sorted[0][1].get_intensity()
 
         around_pheromones_max = []
         for around_pheromone_sorted in around_pheromones_sorted:
-            if around_pheromone_sorted[1][1] == max_intensity:
+            if around_pheromone_sorted[1].get_intensity() == max_intensity:
                 around_pheromones_max.append(around_pheromone_sorted)
 
-        around_pheromones_sorted_by_distance = sorted(around_pheromones_max, key=lambda x: x[1][0], reverse=False)
+        around_pheromones_sorted_by_distance = sorted(around_pheromones_max,
+                                                      key=lambda x: x[1].get_distance(),
+                                                      reverse=False)
 
         go_to_point = around_pheromones_sorted_by_distance[0][0]
 
     def get_best_pheromone_direction_in(context, reference_point, points, pheromone_type):
         around_pheromones_points = []
         for around_point in points:
-            around_pheromone_info = context.pheromones().get_info(around_point,
-                                                                   [PHEROMON_DIRECTION, pheromone_type],
-                                                                   allow_empty=True,
-                                                                   empty_value={})
-            if around_pheromone_info:
-                around_pheromones_points.append((around_point, around_pheromone_info))
+            flavour = context.pheromones().get_flavour(around_point)
+            try:
+                around_pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
+                around_pheromones_points.append((around_point, around_pheromone))
+            except NoPheromone:
+                pass  # Ok, no pheromone, continue to sniff around
 
         if not around_pheromones_points:
             raise NoPheromone()
 
         shuffle(around_pheromones_points)
-        around_pheromones_sorted = sorted(around_pheromones_points, key=lambda x: x[1][1], reverse=True)
+        around_pheromones_sorted = sorted(around_pheromones_points, key=lambda x: x[1].get_intensity(), reverse=True)
         go_to_point = around_pheromones_sorted[0][0]
 
         direction_degrees = get_degree_from_north(reference_point, go_to_point)

intelligine/simulation/pheromone/Pheromone.py

 class Pheromone():
-    pass
+
+    def __init__(self, category, type, distance=None, intensity=0):
+        self._category = category
+        self._type = type
+        self._distance = distance
+        self._intensity = intensity
+
+    def get_category(self):
+        return self._category
+
+    def get_type(self):
+        return self._type
+
+    def get_distance(self):
+        return self._distance
+
+    def set_distance(self, distance):
+        self._distance = distance
+
+    def get_intensity(self):
+        return self._intensity
+
+    def increment_intensity(self, increment_value):
+        self._intensity += increment_value

intelligine/simulation/pheromone/PheromoneFlavour.py

+from intelligine.core.exceptions import NoTypeInPheromone, NoCategoryInPheromone
+from intelligine.simulation.pheromone.Pheromone import Pheromone
+
+
 class PheromoneFlavour():
-    pass
+
+    def __init__(self, point_data):
+        self._point_data = point_data
+
+    def get_pheromone(self, category, type):
+        types = self.get_types(category)
+        if type not in types:
+            raise NoTypeInPheromone()
+        distance, intensity = types[type]
+        return Pheromone(category, type, distance, intensity)
+
+    def get_types(self, category):
+        if category not in self._point_data:
+            raise NoCategoryInPheromone()
+        return self._point_data[category]
+
+    def update_pheromone(self, pheromone):
+        category = pheromone.get_category()
+        type = pheromone.get_type()
+
+        if category not in self._point_data:
+            self._point_data[category] = {}
+
+        self._point_data[category][type] = (pheromone.get_distance(), pheromone.get_intensity())
+
+    def get_raw_data(self):
+        return self._point_data

intelligine/synergy/object/ant/Ant.py

     def initialize(self):
         super().initialize()
         try:
-            DirectionPheromone.appose(self._context,
-                                      self.get_position(),
-                                      self.get_movement_pheromone_gland().get_movement_molecules())
+            self.get_movement_pheromone_gland().appose()
         except BestPheromoneHere as best_pheromone_here:
             pass
 

intelligine/synergy/stigmergy/PheromonesManager.py

-from intelligine.core.exceptions import BestPheromoneHere
+from intelligine.core.exceptions import BestPheromoneHere, NoPheromone
 from intelligine.cst import PHEROMON_INFOS
-from intelligine.core.exceptions import NoPheromone
+from intelligine.simulation.pheromone.PheromoneFlavour import PheromoneFlavour
+from intelligine.simulation.pheromone.Pheromone import Pheromone
 
 
 class PheromonesManager():
     def __init__(self, context):
         self._context = context
 
-    def get_pheromones(self, position, prepare=[]):
+    def get_flavour(self, position):
         point_pheromones = self._context.metas.value.get(PHEROMON_INFOS,
                                                          position,
                                                          allow_empty=True,
                                                          empty_value={})
+        return PheromoneFlavour(point_pheromones)
+
         current_check = point_pheromones
         for prepare_key in prepare:
             if prepare_key not in current_check:
 
         return point_pheromones
 
-    def set_pheromones(self, position, pheromones):
-        self._context.metas.value.set(PHEROMON_INFOS, position, pheromones)
+    def set_flavour(self, position, flavour):
+        self._context.metas.value.set(PHEROMON_INFOS, position, flavour.get_raw_data())
+
+    def get_pheromone(self, position, category, type, allow_empty=False, empty_value=None):
+        # TODO: empty_value as du sens ?
+        flavour = self.get_flavour(position)
+        try:
+            return flavour.get_pheromone(category, type)
+        except NoPheromone:
+            if allow_empty:
+                return Pheromone()
+            raise
 
-    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]:
 
         return pheromone[address[-1]]
 
-    def increment(self, position, address, distance, increment_value=1):
-        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]] = (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]
+    def increment_with_pheromone(self, position, apposed_pheromone):
+        flavour = self.get_flavour(position)
+        try:
+            position_pheromone = flavour.get_pheromone(apposed_pheromone.get_category(), apposed_pheromone.get_type())
+        except NoPheromone:
+            position_pheromone = Pheromone(apposed_pheromone.get_category(),
+                                           apposed_pheromone.get_type(),
+                                           distance=apposed_pheromone.get_distance())
 
-        pheromone_intensity += increment_value
+        position_pheromone.increment_intensity(apposed_pheromone.get_intensity())
 
-        if distance < pheromone_distance:
-            pheromone_distance = distance
+        if apposed_pheromone.get_distance() < position_pheromone.get_distance():
+            position_pheromone.set_distance(apposed_pheromone.get_distance())
 
-        pheromone[address[-1]] = (pheromone_distance, pheromone_intensity)
-        self.set_pheromones(position, pheromones)
+        flavour.update_pheromone(position_pheromone)
+        self.set_flavour(position, flavour)
 
-        if distance > pheromone_distance:
-            raise BestPheromoneHere(pheromone_distance)
+        if apposed_pheromone.get_distance() > position_pheromone.get_distance():
+            raise BestPheromoneHere(position_pheromone.get_distance())

intelligine/tests/simulation/mode/TestChangeMode.py

 
         self._run_and_get_core(2)
         self.assertEquals((0, 0, -2), self.ant.get_position())
-        self.assertEquals((PHEROMON_DIR_EXPLO, 0),
-                          self.ant.get_movement_pheromone_gland().get_movement_molecules())
+        pheromone = self.ant.get_movement_pheromone_gland().get_pheromone()
+        self.assertEquals((PHEROMON_DIR_EXPLO, 0), (pheromone.get_type(), pheromone.get_distance()))
 
         # Ant has take Food piece
         self._run_and_get_core(3)

intelligine/tests/simulation/pheromone/TestDirection.py

 from os import getcwd
 from sys import path as ppath
 from intelligine.core.exceptions import NoPheromone
+from intelligine.simulation.pheromone.Pheromone import Pheromone
+from intelligine.simulation.pheromone.PheromoneFlavour import PheromoneFlavour
 
 ppath.insert(1,getcwd()+'/modules')
 
         if re_init:
             self._context = Context()
         for position in pheromones:
-            self._context.pheromones().set_pheromones(position, pheromones[position])
+            self._context.pheromones().set_flavour(position, PheromoneFlavour(pheromones[position]))
 
     def _test_direction_for_point(self, pheromones, direction, pheromone_type=PHEROMON_DIR_EXPLO,
                                   reference_point=_p(CENTER), re_init=True):
         # Une pheromone au centre
         DirectionPheromone.appose(self._context,
                                   _p(CENTER),
-                                  (PHEROMON_DIR_EXPLO, 2))
+                                  self._get_pheromone(PHEROMON_DIR_EXPLO, 2))
         # Ne permet pas de trouver une route
         self._test_point_raise_no_pheromone(re_init=False)
         self._test_points_raise_no_pheromone(re_init=False)
         # Une pheromone au nord
         DirectionPheromone.appose(self._context,
                                   _p(NORTH),
-                                  (PHEROMON_DIR_EXPLO, 1))
+                                  self._get_pheromone(PHEROMON_DIR_EXPLO, 1))
         # le permet
         self._test_direction_for_points({}, NORTH, re_init=False)
         self._test_direction_for_point({}, NORTH, re_init=False)
         try:  # WTF ?
             self._test_direction_for_points(pheromones, direction, re_init=re_init)
         except NoPheromone:
-            self.assertTrue(True)
+            self.assertTrue(True)
+
+    def _get_pheromone(self, type, distance):
+        return Pheromone(PHEROMON_DIRECTION, type, distance=distance)