Rename Pheromone in molecule

TODO

@@ -2,4 +2,4 @@
 * Pygame: smell, pheromons: rendre + generique
 * Smell: Calcul de la distance max
 * Ant: MOVE_MODE_HOME && rien à faire (pas de truc à stocker, switch to mode EXPLO)
-* Plus de pheromone deposer a l'explo !
+* Plus de molecule deposer a l'explo !

intelligine/core/Context.py

@@ -1,17 +1,17 @@
 from synergine_xyz.Context import Context as XyzContext
 from intelligine.cst import IMPENETRABLE
 from synergine_xyz.cst import POSITIONS
-from intelligine.synergy.stigmergy.PheromonesManager import PheromonesManager
+from intelligine.synergy.stigmergy.MoleculesManager import MoleculesManager
 
 
 class Context(XyzContext):
 
     def __init__(self):
         super().__init__()
-        self._pheromones = PheromonesManager(self)
+        self._molecules = MoleculesManager(self)
 
-    def pheromones(self):
-        return self._pheromones
+    def molecules(self):
+        return self._molecules
 
     def position_is_penetrable(self, position):
         """

intelligine/core/exceptions.py

@@ -13,27 +13,27 @@ class UnableToFoundMovement(MovementException):
     pass
 
 
-class PheromoneException(Exception):
+class MoleculeException(Exception):
     pass
 
 
-class NoPheromone(PheromoneException):
+class NoMolecule(MoleculeException):
     pass
 
 
-class NoPheromoneMove(PheromoneException, MovementException):
+class NoMoleculeMove(MoleculeException, MovementException):
     pass
 
 
-class NoTypeInPheromone(NoPheromone):
+class NoTypeInMolecule(NoMolecule):
     pass
 
 
-class NoCategoryInPheromone(NoPheromone):
+class NoCategoryInMolecule(NoMolecule):
     pass
 
 
-class BestPheromoneHere(PheromoneException):
+class BestMoleculeHere(MoleculeException):
 
     def __init__(self, best_distance,  *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -42,7 +42,7 @@ class BestPheromoneHere(PheromoneException):
     def get_best_distance(self):
         return self._best_distance
 
-class PheromoneGlandDisabled(PheromoneException):
+class MoleculeGlandDisabled(MoleculeException):
     pass
 
 

intelligine/cst.py

@@ -13,7 +13,7 @@ CARRIED = IncrementedNamedInt.get('intelligine.carried')
 CANT_CARRY_STILL = IncrementedNamedInt.get('intelligine.cantcarry.still')
 CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
 ACTION_DIE = IncrementedNamedInt.get('intelligine.basebug.action.die')
-PHEROMONE_SEARCHING = IncrementedNamedInt.get('intelligine.pheromone_searching')
+PHEROMONE_SEARCHING = IncrementedNamedInt.get('intelligine.molecule_searching')
 
 # TODO: Renommer "move_mode" en "mode"
 MOVE_MODE = IncrementedNamedInt.get('intelligine.basebug.move.mode')
@@ -58,4 +58,4 @@ BRAIN_PART_PUT = IncrementedNamedInt.get('intelligine.brain.part.put')
 BRAIN_PART_ATTACK = IncrementedNamedInt.get('intelligine.brain.part.attack')
 
 BODY_SCHEMA = IncrementedNamedInt.get('intelligine.body_schema')
-BODY_PART_PHEROMONE_GLAND = IncrementedNamedInt.get('intelligine.body.part.pheromone_gland')
+BODY_PART_PHEROMONE_GLAND = IncrementedNamedInt.get('intelligine.body.part.molecule_gland')

intelligine/display/Pygame.py

@@ -1,4 +1,4 @@
-from intelligine.core.exceptions import NoPheromone
+from intelligine.core.exceptions import NoMolecule
 from synergine_xyz.display.Pygame import Pygame as XyzPygame
 import pygame
 from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, PHEROMON_POSITIONS, POINTS_SMELL, \
@@ -11,17 +11,17 @@ class Pygame(XyzPygame):
 
     def __init__(self, config, context, synergy_manager):
         super().__init__(config, context, synergy_manager)
-        self._is_display_pheromones = False
+        self._is_display_molecules = False
         self._is_display_smells = False
 
     def receive(self, actions_done):
         super().receive(actions_done)
 
-        if self._is_display_pheromones:
-            pheromones_positions = self._context.metas.list.get(PHEROMON_POSITIONS,
+        if self._is_display_molecules:
+            molecules_positions = self._context.metas.list.get(PHEROMON_POSITIONS,
                                                                 PHEROMON_POSITIONS,
                                                                 allow_empty=True)
-            self._display_pheromones(pheromones_positions, self._context)
+            self._display_molecules(molecules_positions, self._context)
 
         if self._is_display_smells:
             smell_positions = self._context.metas.list.get(POINTS_SMELL,
@@ -29,23 +29,23 @@ class Pygame(XyzPygame):
                                                            allow_empty=True)
             self._display_smells(smell_positions, self._context)
 
-    def _display_pheromones(self, pheromones_positions, context):
-        pheromone_exploration_surface = self._object_visualizer.get_surface(SURFACE_PHEROMONE_EXPLORATION)
-        pheromone_home_surface = self._object_visualizer.get_surface(SURFACE_PHEROMONE_HOME)
+    def _display_molecules(self, molecules_positions, context):
+        molecule_exploration_surface = self._object_visualizer.get_surface(SURFACE_PHEROMONE_EXPLORATION)
+        molecule_home_surface = self._object_visualizer.get_surface(SURFACE_PHEROMONE_HOME)
 
-        for point in pheromones_positions:
-            point_flavour = context.pheromones().get_flavour(point)
+        for point in molecules_positions:
+            point_flavour = context.molecules().get_flavour(point)
             try:
-                point_flavour.get_pheromone(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_HOME)
-                self.draw_surface(point, pheromone_home_surface)
-            except NoPheromone:
-                pass # No pheromone here
+                point_flavour.get_molecule(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_HOME)
+                self.draw_surface(point, molecule_home_surface)
+            except NoMolecule:
+                pass # No molecule here
 
             try:
-                point_flavour.get_pheromone(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_EXPLO)
-                self.draw_surface(point, pheromone_exploration_surface)
-            except NoPheromone:
-                pass # No pheromone here
+                point_flavour.get_molecule(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_EXPLO)
+                self.draw_surface(point, molecule_exploration_surface)
+            except NoMolecule:
+                pass # No molecule here
 
     def _display_smells(self, smell_positions, context):
         smell_egg_surface = self._object_visualizer.get_surface(SURFACE_SMELL_EGG)
@@ -61,10 +61,10 @@ class Pygame(XyzPygame):
     def _key_pressed(self, key):
 
         if key == pygame.K_p:
-            if self._is_display_pheromones:
-                self._is_display_pheromones = False
+            if self._is_display_molecules:
+                self._is_display_molecules = False
             else:
-                self._is_display_pheromones = True
+                self._is_display_molecules = True
 
         if key == pygame.K_s:
             if self._is_display_smells:

intelligine/display/pygame/visualisation.py

@@ -14,8 +14,8 @@ from os import getcwd
 from synergine_xyz.cst import PREVIOUS_DIRECTION
 from synergine_xyz.tmx.TileMapConnector import TileMapConnector
 
-SURFACE_PHEROMONE_HOME = 'pheromone_home'
-SURFACE_PHEROMONE_EXPLORATION = 'pheromone_exploration'
+SURFACE_PHEROMONE_HOME = 'molecule_home'
+SURFACE_PHEROMONE_EXPLORATION = 'molecule_exploration'
 
 SURFACE_SMELL_EGG = 'smell_egg'
 SURFACE_SMELL_FOOD = 'smell_food'

intelligine/simulation/molecule/DirectionMolecule.py

@@ -0,0 +1,85 @@
+from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_POSITIONS
+from intelligine.core.exceptions import NoMolecule
+from random import shuffle
+from synergine_xyz.geometry import get_degree_from_north
+from intelligine.synergy.event.move.direction import get_direction_for_degrees
+
+
+class DirectionMolecule():
+
+    @staticmethod
+    def appose(context, point, molecule):
+        context.molecules().increment_with_molecule(point, molecule)
+        context.metas.list.add(PHEROMON_POSITIONS, PHEROMON_POSITIONS, point, assert_not_in=False)
+
+    @classmethod
+    def get_direction_for_point(cls, context, point, molecule_type):
+        flavour = context.molecules().get_flavour(point)
+        molecule = flavour.get_molecule(category=PHEROMON_DIRECTION, type=molecule_type)
+
+        distance = molecule.get_distance()
+        around_molecule_filter = lambda around_molecule: around_molecule.get_distance() < distance
+        around_molecules_points = cls._get_around_molecules(context, point, molecule_type,
+                                                              molecule_filter=around_molecule_filter)
+
+        if not around_molecules_points:
+            raise NoMolecule()
+
+        shuffle(around_molecules_points)
+        around_molecules_sorted = sorted(around_molecules_points, key=lambda x: x[1].get_intensity(), reverse=True)
+        max_intensity = around_molecules_sorted[0][1].get_intensity()
+
+        around_molecules_max = []
+        for around_molecule_sorted in around_molecules_sorted:
+            if around_molecule_sorted[1].get_intensity() == max_intensity:
+                around_molecules_max.append(around_molecule_sorted)
+
+        around_molecules_sorted_by_distance = sorted(around_molecules_max,
+                                                      key=lambda x: x[1].get_distance(),
+                                                      reverse=False)
+
+        go_to_point = around_molecules_sorted_by_distance[0][0]
+
+        direction_degrees = get_degree_from_north(point, go_to_point)
+        direction = get_direction_for_degrees(direction_degrees)
+
+        return direction
+
+    @staticmethod
+    def _get_around_molecules(context, reference_point, molecule_type,
+                               molecule_filter=lambda around_molecule: True):
+        around_points = context.get_around_points_of_point(reference_point)
+        around_molecules_points = []
+        for around_point in around_points:
+            flavour = context.molecules().get_flavour(around_point)
+            try:
+                around_molecule = flavour.get_molecule(category=PHEROMON_DIRECTION, type=molecule_type)
+                if molecule_filter(around_molecule):
+                    around_molecules_points.append((around_point, around_molecule))
+            except NoMolecule:
+                pass  # No molecule, ok continue to sniff around
+
+        return around_molecules_points
+
+    @staticmethod
+    def get_best_molecule_direction_in(context, reference_point, points, molecule_type):
+        around_molecules_points = []
+        for around_point in points:
+            flavour = context.molecules().get_flavour(around_point)
+            try:
+                around_molecule = flavour.get_molecule(category=PHEROMON_DIRECTION, type=molecule_type)
+                around_molecules_points.append((around_point, around_molecule))
+            except NoMolecule:
+                pass  # Ok, no molecule, continue to sniff around
+
+        if not around_molecules_points:
+            raise NoMolecule()
+
+        shuffle(around_molecules_points)
+        around_molecules_sorted = sorted(around_molecules_points, key=lambda x: x[1].get_intensity(), reverse=True)
+        go_to_point = around_molecules_sorted[0][0]
+
+        direction_degrees = get_degree_from_north(reference_point, go_to_point)
+        direction = get_direction_for_degrees(direction_degrees)
+
+        return direction

intelligine/simulation/pheromone/Pheromone.py → intelligine/simulation/molecule/Molecule.py

@@ -1,4 +1,4 @@
-class Pheromone():
+class Molecule():
 
     def __init__(self, category, type, distance=None, intensity=0):
         self._category = category

intelligine/simulation/molecule/MoleculeFlavour.py

@@ -0,0 +1,51 @@
+from intelligine.core.exceptions import NoTypeInMolecule, NoCategoryInMolecule
+from intelligine.simulation.molecule.Molecule import Molecule
+
+
+class MoleculeFlavour():
+
+    @classmethod
+    def new_from_raw_data(cls, raw_data):
+        flavour = {}
+        for category in raw_data:
+            molecules_by_category = raw_data[category]
+            for type in molecules_by_category:
+                distance, intensity = molecules_by_category[type]
+                if category not in flavour:
+                    flavour[category] = {}
+                flavour[category][type] = Molecule(category, type, distance, intensity)
+        return cls(flavour)
+
+    def get_raw_data(self):
+        raw_data = {}
+        for category in self._flavour:
+            molecules_by_category = self._flavour[category]
+            for type in molecules_by_category:
+                molecule = molecules_by_category[type]
+                if category not in raw_data:
+                    raw_data[category] = {}
+                raw_data[category][type] = (molecule.get_distance(), molecule.get_intensity())
+        return raw_data
+
+    def __init__(self, flavour):
+        self._flavour = flavour
+
+    def get_molecule(self, category, type):
+        types = self.get_types(category)
+        if type not in types:
+            raise NoTypeInMolecule()
+        return types[type]
+
+    def get_types(self, category):
+        if category not in self._flavour:
+            raise NoCategoryInMolecule()
+        return self._flavour[category]
+
+    def set_molecule(self, molecule):
+        category = molecule.get_category()
+        type = molecule.get_type()
+
+        if category not in self._flavour:
+            self._flavour[category] = {}
+
+        self._flavour[category][type] = molecule

intelligine/simulation/object/brain/AntBrain.py

@@ -23,47 +23,47 @@ class AntBrain(Brain):
         super().__init__(context, host)
         self._movement_mode = MOVE_MODE_HOME
         self._distance_from_objective = 0  # TODO rename: distance_since_objective
-        self._pheromone_searching = PHEROMON_DIR_EXPLO
+        self._molecule_searching = PHEROMON_DIR_EXPLO
 
     def switch_to_mode(self, mode):
         # TODO: Mode explo: reinit exploration vector
         self._movement_mode = mode
-        self._update_pheromone_gland(mode)
+        self._update_molecule_gland(mode)
         self._context.metas.value.set(MOVE_MODE, self._host.get_id(), mode)
         self._distance_from_objective = 0
-        self._update_pheromone_searching(mode)
+        self._update_molecule_searching(mode)
 
-    def _update_pheromone_gland(self, mode):
+    def _update_molecule_gland(self, mode):
         if mode == MOVE_MODE_EXPLO:
-            pheromone_direction_type = PHEROMON_DIR_HOME
+            molecule_direction_type = PHEROMON_DIR_HOME
         elif mode == MOVE_MODE_GOHOME:
-            pheromone_direction_type = PHEROMON_DIR_EXPLO
+            molecule_direction_type = PHEROMON_DIR_EXPLO
         elif mode == MOVE_MODE_NURSE:
-            pheromone_direction_type = None
+            molecule_direction_type = None
         elif mode == MOVE_MODE_HOME:
-            pheromone_direction_type = None
+            molecule_direction_type = None
         else:
             raise NotImplementedError()
 
-        if pheromone_direction_type:
-            self._host.get_movement_pheromone_gland().set_pheromone_type(pheromone_direction_type)
-            self._host.get_movement_pheromone_gland().enable()
+        if molecule_direction_type:
+            self._host.get_movement_molecule_gland().set_molecule_type(molecule_direction_type)
+            self._host.get_movement_molecule_gland().enable()
         else:
-            self._host.get_movement_pheromone_gland().disable()
+            self._host.get_movement_molecule_gland().disable()
 
-    def _update_pheromone_searching(self, mode):
+    def _update_molecule_searching(self, mode):
         if mode == MOVE_MODE_EXPLO:
-            pheromone_searching = PHEROMON_DIR_EXPLO
+            molecule_searching = PHEROMON_DIR_EXPLO
         elif mode == MOVE_MODE_GOHOME:
-            pheromone_searching = PHEROMON_DIR_HOME
+            molecule_searching = PHEROMON_DIR_HOME
         elif mode == MOVE_MODE_NURSE:
-            pheromone_searching = PHEROMON_DIR_NONE
+            molecule_searching = PHEROMON_DIR_NONE
         elif mode == MOVE_MODE_HOME:
             return
         else:
             raise NotImplementedError()
-        self._pheromone_searching = pheromone_searching
-        self._context.metas.value.set(PHEROMONE_SEARCHING, self._host.get_id(), pheromone_searching)
+        self._molecule_searching = molecule_searching
+        self._context.metas.value.set(PHEROMONE_SEARCHING, self._host.get_id(), molecule_searching)
 
     def get_movement_mode(self):
         return self._movement_mode

intelligine/simulation/object/brain/part/move/AntMoveBrainPart.py

@@ -1,10 +1,10 @@
 from intelligine.simulation.object.brain.part.move.MoveBrainPart import MoveBrainPart
 from intelligine.synergy.event.move.direction import directions_modifiers, get_direction_for_degrees
 from synergine_xyz.cst import POSITION
-from intelligine.core.exceptions import NoPheromone
+from intelligine.core.exceptions import NoMolecule
 from intelligine.cst import PHEROMONE_SEARCHING, MOVE_MODE_EXPLO, \
     MOVE_MODE_HOME, MOVE_MODE, MOVE_MODE_GOHOME, EXPLORATION_VECTOR, POINTS_SMELL
-from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
+from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 from synergine_xyz.geometry import get_degree_from_north
 
 
@@ -26,8 +26,8 @@ class AntMoveBrainPart(MoveBrainPart):
         move_mode = context.metas.value.get(MOVE_MODE, object_id)
         if move_mode == MOVE_MODE_EXPLO:
             try:
-                return cls._get_direction_with_pheromones(context, object_id)
-            except NoPheromone:
+                return cls._get_direction_with_molecules(context, object_id)
+            except NoMolecule:
                 return super().get_direction(context, object_id)
         elif move_mode == MOVE_MODE_GOHOME:
             return cls._get_direction_with_exploration_vector(context, object_id)
@@ -35,32 +35,32 @@ class AntMoveBrainPart(MoveBrainPart):
         return super().get_direction(context, object_id)
 
     @classmethod
-    def _get_direction_with_pheromones(cls, context, object_id):
+    def _get_direction_with_molecules(cls, context, object_id):
         object_point = context.metas.value.get(POSITION, object_id)
-        pheromone_type = context.metas.value.get(PHEROMONE_SEARCHING, object_id)
+        molecule_type = context.metas.value.get(PHEROMONE_SEARCHING, object_id)
         try:
-            direction = cls._get_pheromone_direction_for_point(context, object_point, pheromone_type)
-        except NoPheromone:
+            direction = cls._get_molecule_direction_for_point(context, object_point, molecule_type)
+        except NoMolecule:
             try:
-                direction = cls._get_direction_of_pheromone(context, object_point, pheromone_type)
-            except NoPheromone:
+                direction = cls._get_direction_of_molecule(context, object_point, molecule_type)
+            except NoMolecule:
                 raise
         return direction
 
     @staticmethod
-    def _get_pheromone_direction_for_point(context, point, pheromone_type):
-        return DirectionPheromone.get_direction_for_point(context, point, pheromone_type)
+    def _get_molecule_direction_for_point(context, point, molecule_type):
+        return DirectionMolecule.get_direction_for_point(context, point, molecule_type)
 
     @staticmethod
-    def _get_direction_of_pheromone(context, point, pheromone_type):
-        search_pheromone_in_points = context.get_around_points_of_point(point)
+    def _get_direction_of_molecule(context, point, molecule_type):
+        search_molecule_in_points = context.get_around_points_of_point(point)
         try:
-            best_pheromone_direction = DirectionPheromone.get_best_pheromone_direction_in(context,
+            best_molecule_direction = DirectionMolecule.get_best_molecule_direction_in(context,
                                                                                           point,
-                                                                                          search_pheromone_in_points,
-                                                                                          pheromone_type)
-            return best_pheromone_direction
-        except NoPheromone as err:
+                                                                                          search_molecule_in_points,
+                                                                                          molecule_type)
+            return best_molecule_direction
+        except NoMolecule as err:
             raise err
 
     @staticmethod
@@ -79,14 +79,14 @@ class AntMoveBrainPart(MoveBrainPart):
     # TODO: obj pas necessaire, il est dans _host
     def done(self, obj, context):
         super().done(obj, context)
-        self._appose_pheromone(obj)
+        self._appose_molecule(obj)
         self._check_context(obj, context)
         self._apply_context(obj, context)
 
     @staticmethod
-    def _appose_pheromone(obj):
-        if obj.get_movement_pheromone_gland().is_enabled():
-            obj.get_movement_pheromone_gland().appose()
+    def _appose_molecule(obj):
+        if obj.get_movement_molecule_gland().is_enabled():
+            obj.get_movement_molecule_gland().appose()
 
     def _check_context(self, obj, context):
         """

intelligine/simulation/object/brain/part/transport/AntTakeBrainPart.py

@@ -22,4 +22,4 @@ class AntTakeBrainPart(TakeBrainPart):
         # TODO: Ranger ca ? Truc plus dynamique/configurable ?
         if isinstance(take_object, Resource):
             obj.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
-            obj.get_movement_pheromone_gland().appose()
+            obj.get_movement_molecule_gland().appose()

intelligine/simulation/object/molecule/MoleculeGland.py

@@ -0,0 +1,41 @@
+from intelligine.core.exceptions import BestMoleculeHere, MoleculeGlandDisabled
+from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
+
+class MoleculeGland():
+
+    def __init__(self, host, context):
+        self._molecule_type = None
+        self._host = host
+        self._context = context
+        self._enabled = False
+
+    def set_molecule_type(self, molecule_type):
+        self._molecule_type = molecule_type
+
+    def get_molecule_type(self):
+        if self._molecule_type is None:
+            raise Exception("molecule_type not specified")
+        return self._molecule_type
+
+    def get_molecule(self):
+        raise NotImplementedError()
+
+    def appose(self):
+        if not self._enabled:
+            raise MoleculeGlandDisabled()
+
+        try:
+            DirectionMolecule.appose(self._context,
+                                      self._host.get_position(),
+                                      self.get_molecule())
+        except BestMoleculeHere as best_molecule_here:
+            self._host.get_brain().set_distance_from_objective(best_molecule_here.get_best_distance())
+
+    def disable(self):
+        self._enabled = False
+
+    def enable(self):
+        self._enabled = True
+
+    def is_enabled(self):
+        return self._enabled

intelligine/simulation/object/molecule/MovementMoleculeGland.py

@@ -0,0 +1,12 @@
+from intelligine.cst import PHEROMON_DIRECTION
+from intelligine.simulation.object.molecule.MoleculeGland import MoleculeGland
+from intelligine.simulation.molecule.Molecule import Molecule
+
+
+class MovementMoleculeGland(MoleculeGland):
+
+    def get_molecule(self):
+        """
+        :return: Molecule
+        """
+        return Molecule(PHEROMON_DIRECTION, self._molecule_type, self._host.get_brain().get_distance_from_objective(), 1)

intelligine/simulation/object/pheromone/MovementPheromoneGland.py

@@ -1,12 +0,0 @@
-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_pheromone(self):
-        """
-        :return: Pheromone
-        """
-        return Pheromone(PHEROMON_DIRECTION, self._pheromone_type, self._host.get_brain().get_distance_from_objective(), 1)

intelligine/simulation/object/pheromone/PheromoneGland.py

@@ -1,41 +0,0 @@
-from intelligine.core.exceptions import BestPheromoneHere, PheromoneGlandDisabled
-from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
-
-class PheromoneGland():
-
-    def __init__(self, host, context):
-        self._pheromone_type = None
-        self._host = host
-        self._context = context
-        self._enabled = False
-
-    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
-
-    def get_pheromone(self):
-        raise NotImplementedError()
-
-    def appose(self):
-        if not self._enabled:
-            raise PheromoneGlandDisabled()
-
-        try:
-            DirectionPheromone.appose(self._context,
-                                      self._host.get_position(),
-                                      self.get_pheromone())
-        except BestPheromoneHere as best_pheromone_here:
-            self._host.get_brain().set_distance_from_objective(best_pheromone_here.get_best_distance())
-
-    def disable(self):
-        self._enabled = False
-
-    def enable(self):
-        self._enabled = True
-
-    def is_enabled(self):
-        return self._enabled

intelligine/simulation/pheromone/DirectionPheromone.py

@@ -1,85 +0,0 @@
-from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_POSITIONS
-from intelligine.core.exceptions import NoPheromone
-from random import shuffle
-from synergine_xyz.geometry import get_degree_from_north
-from intelligine.synergy.event.move.direction import get_direction_for_degrees
-
-
-class DirectionPheromone():
-
-    @staticmethod
-    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)
-
-    @classmethod
-    def get_direction_for_point(cls, context, point, pheromone_type):
-        flavour = context.pheromones().get_flavour(point)
-        pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
-
-        distance = pheromone.get_distance()
-        around_pheromone_filter = lambda around_pheromone: around_pheromone.get_distance() < distance
-        around_pheromones_points = cls._get_around_pheromones(context, point, pheromone_type,
-                                                              pheromone_filter=around_pheromone_filter)
-
-        if not around_pheromones_points:
-            raise NoPheromone()
-
-        shuffle(around_pheromones_points)
-        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].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].get_distance(),
-                                                      reverse=False)
-
-        go_to_point = around_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
-
-    @staticmethod
-    def _get_around_pheromones(context, reference_point, pheromone_type,
-                               pheromone_filter=lambda around_pheromone: True):
-        around_points = context.get_around_points_of_point(reference_point)
-        around_pheromones_points = []
-        for around_point in around_points:
-            flavour = context.pheromones().get_flavour(around_point)
-            try:
-                around_pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
-                if pheromone_filter(around_pheromone):
-                    around_pheromones_points.append((around_point, around_pheromone))
-            except NoPheromone:
-                pass  # No pheromone, ok continue to sniff around
-
-        return around_pheromones_points
-
-    @staticmethod
-    def get_best_pheromone_direction_in(context, reference_point, points, pheromone_type):
-        around_pheromones_points = []
-        for around_point in points:
-            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].get_intensity(), reverse=True)
-        go_to_point = around_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/simulation/pheromone/PheromoneFlavour.py

@@ -1,51 +0,0 @@
-from intelligine.core.exceptions import NoTypeInPheromone, NoCategoryInPheromone
-from intelligine.simulation.pheromone.Pheromone import Pheromone
-
-
-class PheromoneFlavour():
-
-    @classmethod
-    def new_from_raw_data(cls, raw_data):
-        flavour = {}
-        for category in raw_data:
-            pheromones_by_category = raw_data[category]
-            for type in pheromones_by_category:
-                distance, intensity = pheromones_by_category[type]
-                if category not in flavour:
-                    flavour[category] = {}
-                flavour[category][type] = Pheromone(category, type, distance, intensity)
-        return cls(flavour)
-
-    def get_raw_data(self):
-        raw_data = {}
-        for category in self._flavour:
-            pheromones_by_category = self._flavour[category]
-            for type in pheromones_by_category:
-                pheromone = pheromones_by_category[type]
-                if category not in raw_data:
-                    raw_data[category] = {}
-                raw_data[category][type] = (pheromone.get_distance(), pheromone.get_intensity())
-        return raw_data
-
-    def __init__(self, flavour):
-        self._flavour = flavour
-
-    def get_pheromone(self, category, type):
-        types = self.get_types(category)
-        if type not in types:
-            raise NoTypeInPheromone()
-        return types[type]
-
-    def get_types(self, category):
-        if category not in self._flavour:
-            raise NoCategoryInPheromone()
-        return self._flavour[category]
-
-    def set_pheromone(self, pheromone):
-        category = pheromone.get_category()
-        type = pheromone.get_type()
-
-        if category not in self._flavour:
-            self._flavour[category] = {}
-
-        self._flavour[category][type] = pheromone

intelligine/synergy/object/ant/Ant.py

@@ -1,17 +1,17 @@
-from intelligine.core.exceptions import PheromoneException
+from intelligine.core.exceptions import MoleculeException
 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, BODY_PART_PHEROMONE_GLAND, TYPE, TYPE_ANT, \
     COL_TRANSPORTER_CARRYING, MOVE_MODE_NURSE, MOVE_MODE_HOME
 from intelligine.synergy.object.Food import Food
-from intelligine.simulation.object.pheromone.MovementPheromoneGland import MovementPheromoneGland
+from intelligine.simulation.object.molecule.MovementMoleculeGland import MovementMoleculeGland
 from intelligine.simulation.object.brain.AntBrain import AntBrain
 
 
 class Ant(Bug):
 
     _body_parts = {
-        BODY_PART_PHEROMONE_GLAND: MovementPheromoneGland
+        BODY_PART_PHEROMONE_GLAND: MovementMoleculeGland
     }
 
     def __init__(self, collection, context):
@@ -36,7 +36,7 @@ class Ant(Bug):
     def _get_brain_instance(self):
         return AntBrain(self._context, self)
 
-    def get_movement_pheromone_gland(self):
+    def get_movement_molecule_gland(self):
         return self.get_body_part(BODY_PART_PHEROMONE_GLAND)
 
     def put_carry(self, obj, position=None):
@@ -61,7 +61,7 @@ class Ant(Bug):
         # TODO: pour le moment hardcode, a gerer dans AntTakeBrainPart (callback en fct de ce qui est depose)
         if isinstance(obj, Food):
             self.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
-            self.get_movement_pheromone_gland().appose()
+            self.get_movement_molecule_gland().appose()
 
     def is_carrying(self):
         if self._carried:
@@ -77,10 +77,10 @@ class Ant(Bug):
 
     def initialize(self):
         super().initialize()
-        if self.get_movement_pheromone_gland().is_enabled():
+        if self.get_movement_molecule_gland().is_enabled():
             try:
-                self.get_movement_pheromone_gland().appose()
-            except PheromoneException:
+                self.get_movement_molecule_gland().appose()
+            except MoleculeException:
                 pass
 
     def get_colony(self):

intelligine/synergy/stigmergy/MoleculesManager.py

@@ -0,0 +1,49 @@
+from intelligine.core.exceptions import BestMoleculeHere, NoMolecule
+from intelligine.cst import PHEROMON_INFOS
+from intelligine.simulation.molecule.MoleculeFlavour import MoleculeFlavour
+from intelligine.simulation.molecule.Molecule import Molecule
+
+
+class MoleculesManager():
+
+    def __init__(self, context):
+        self._context = context
+
+    def get_flavour(self, position):
+        point_molecules = self._context.metas.value.get(PHEROMON_INFOS,
+                                                         position,
+                                                         allow_empty=True,
+                                                         empty_value={})
+        return MoleculeFlavour.new_from_raw_data(point_molecules)
+
+    def set_flavour(self, position, flavour):
+        self._context.metas.value.set(PHEROMON_INFOS, position, flavour.get_raw_data())
+
+    def get_molecule(self, position, category, type, allow_empty=False):
+        flavour = self.get_flavour(position)
+        try:
+            return flavour.get_molecule(category, type)
+        except NoMolecule:
+            if allow_empty:
+                return Molecule()
+            raise
+
+    def increment_with_molecule(self, position, apposed_molecule):
+        flavour = self.get_flavour(position)
+        try:
+            position_molecule = flavour.get_molecule(apposed_molecule.get_category(), apposed_molecule.get_type())
+        except NoMolecule:
+            position_molecule = Molecule(apposed_molecule.get_category(),
+                                           apposed_molecule.get_type(),
+                                           distance=apposed_molecule.get_distance())
+
+        position_molecule.increment_intensity(apposed_molecule.get_intensity())
+
+        if apposed_molecule.get_distance() < position_molecule.get_distance():
+            position_molecule.set_distance(apposed_molecule.get_distance())
+
+        flavour.set_molecule(position_molecule)
+        self.set_flavour(position, flavour)
+
+        if apposed_molecule.get_distance() > position_molecule.get_distance():
+            raise BestMoleculeHere(position_molecule.get_distance())

intelligine/synergy/stigmergy/PheromonesManager.py

@@ -1,49 +0,0 @@
-from intelligine.core.exceptions import BestPheromoneHere, NoPheromone
-from intelligine.cst import PHEROMON_INFOS
-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_flavour(self, position):
-        point_pheromones = self._context.metas.value.get(PHEROMON_INFOS,
-                                                         position,
-                                                         allow_empty=True,
-                                                         empty_value={})
-        return PheromoneFlavour.new_from_raw_data(point_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):
-        flavour = self.get_flavour(position)
-        try:
-            return flavour.get_pheromone(category, type)
-        except NoPheromone:
-            if allow_empty:
-                return Pheromone()
-            raise
-
-    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())
-
-        position_pheromone.increment_intensity(apposed_pheromone.get_intensity())
-
-        if apposed_pheromone.get_distance() < position_pheromone.get_distance():
-            position_pheromone.set_distance(apposed_pheromone.get_distance())
-
-        flavour.set_pheromone(position_pheromone)
-        self.set_flavour(position, flavour)
-
-        if apposed_pheromone.get_distance() > position_pheromone.get_distance():
-            raise BestPheromoneHere(position_pheromone.get_distance())

intelligine/tests/simulation/mode/TestChangeMode.py

@@ -1,6 +1,6 @@
 from os import getcwd
 from sys import path as ppath
-from intelligine.core.exceptions import NoPheromone
+from intelligine.core.exceptions import NoMolecule
 
 ppath.insert(1,getcwd()+'/modules')
 
@@ -16,7 +16,7 @@ from intelligine.tests.src.event.MoveAction import MoveAction as TestMoveAction
 from synergine.synergy.collection.SynergyCollection import SynergyCollection
 from synergine.synergy.collection.Configuration import Configuration
 from intelligine.core.Context import Context
-from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, MOVE_MODE
+from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, MOVE_MODE, MOVE_MODE_HOME
 from intelligine.cst import PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO
 
 
@@ -101,7 +101,7 @@ class TestChangeMode(Base):
     def test_from_exploration_to_go_home(self):
         self._run_and_get_core(0)
         self.assertEquals((0, 0, 0), self.ant.get_position())
-        self.assertEquals(MOVE_MODE_EXPLO, self.ant.get_brain().get_movement_mode())
+        self.assertEquals(MOVE_MODE_HOME, self.ant.get_brain().get_movement_mode())
         self.assertFalse(self.ant.is_carrying())
 
         self._run_and_get_core(1)
@@ -115,11 +115,11 @@ class TestChangeMode(Base):
         self.assertTrue(self.ant.is_carrying())
         self.assertIsNotNone(self.ant.get_carried())
         self.assertEquals(self.food.__class__, self.ant.get_carried().__class__)
-        pheromone = self.ant.get_movement_pheromone_gland().get_pheromone()
-        # Now it appose exploration pheromone
-        self.assertEquals((PHEROMON_DIR_EXPLO, 0), (pheromone.get_type(), pheromone.get_distance()))
+        molecule = self.ant.get_movement_molecule_gland().get_molecule()
+        # Now it appose exploration molecule
+        self.assertEquals((PHEROMON_DIR_EXPLO, 0), (molecule.get_type(), molecule.get_distance()))
         self.assertEquals(MOVE_MODE_GOHOME, self.ant.get_brain().get_movement_mode())
-        self.assertEquals(PHEROMON_DIR_EXPLO, self.ant.get_movement_pheromone_gland().get_pheromone_type())
+        self.assertEquals(PHEROMON_DIR_EXPLO, self.ant.get_movement_molecule_gland().get_molecule_type())
 
         self._run_and_get_core(3)
         self.assertEquals((0, 0, -1), self.ant.get_position())
@@ -130,4 +130,4 @@ class TestChangeMode(Base):
         # Ant has put his food piece
         self.assertFalse(self.ant.is_carrying())
         self.assertEquals(MOVE_MODE_EXPLO, self.ant.get_brain().get_movement_mode())
-        self.assertEquals(PHEROMON_DIR_HOME, self.ant.get_movement_pheromone_gland().get_pheromone_type())
+        self.assertEquals(PHEROMON_DIR_HOME, self.ant.get_movement_molecule_gland().get_molecule_type())

intelligine/tests/simulation/pheromone/TestDirection.py → intelligine/tests/simulation/molecule/TestDirection.py

@@ -1,13 +1,13 @@
 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
+from intelligine.core.exceptions import NoMolecule
+from intelligine.simulation.molecule.Molecule import Molecule
+from intelligine.simulation.molecule.MoleculeFlavour import MoleculeFlavour
 
 ppath.insert(1,getcwd()+'/modules')
 
-from intelligine.tests.simulation.pheromone.Base import Base
-from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
+from intelligine.tests.simulation.molecule.Base import Base
+from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 from intelligine.core.Context import Context
 from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_DIR_EXPLO, PHEROMON_DIR_HOME
 from intelligine.synergy.event.move.direction import NORTH, NORTH_EST, EST, SOUTH_EST, SOUTH, SOUTH_WEST, WEST, \
@@ -24,47 +24,47 @@ class TestDirection(Base):
     def setUp(self):
         self._context = Context()
 
-    def _set_up_pheromones(self, pheromones, re_init=True):
+    def _set_up_molecules(self, molecules, re_init=True):
         if re_init:
             self._context = Context()
-        for position in pheromones:
-            self._context.pheromones().set_flavour(position, PheromoneFlavour.new_from_raw_data(pheromones[position]))
+        for position in molecules:
+            self._context.molecules().set_flavour(position, MoleculeFlavour.new_from_raw_data(molecules[position]))
 
-    def _test_direction_for_point(self, pheromones, direction, pheromone_type=PHEROMON_DIR_EXPLO,
+    def _test_direction_for_point(self, molecules, direction, molecule_type=PHEROMON_DIR_EXPLO,
                                   reference_point=_p(CENTER), re_init=True):
         """
 
-        :param pheromones:
+        :param molecules:
         :param direction:
-        :param pheromone_type:
+        :param molecule_type:
         :param reference_point:
         :return:
         """
-        self._set_up_pheromones(pheromones, re_init=re_init)
-        direction_tested = DirectionPheromone.get_direction_for_point(self._context, reference_point, pheromone_type)
+        self._set_up_molecules(molecules, re_init=re_init)
+        direction_tested = DirectionMolecule.get_direction_for_point(self._context, reference_point, molecule_type)
         self.assertEqual(direction, direction_tested, "Direction must be %s" % direction)
 
-    def _test_direction_for_points(self, pheromones, direction, pheromone_type=PHEROMON_DIR_EXPLO,
+    def _test_direction_for_points(self, molecules, direction, molecule_type=PHEROMON_DIR_EXPLO,
                                    reference_point=_p(CENTER), re_init=True):
         """
 
-        :param pheromones:
+        :param molecules:
         :param direction:
-        :param pheromone_type:
+        :param molecule_type:
         :param reference_point:
         :return:
         """
-        self._set_up_pheromones(pheromones, re_init=re_init)
+        self._set_up_molecules(molecules, re_init=re_init)
         around_points = self._context.get_around_points_of_point(reference_point)
-        direction_tested = DirectionPheromone.get_best_pheromone_direction_in(self._context,
+        direction_tested = DirectionMolecule.get_best_molecule_direction_in(self._context,
                                                                               reference_point,
                                                                               around_points,
-                                                                              pheromone_type)
+                                                                              molecule_type)
         self.assertEqual(direction, direction_tested, "Direction must be %s" % direction)
 
     def test_route_direct_route(self):
         """
-        Test easy direction with 1 best pheromones just near actual position
+        Test easy direction with 1 best molecules just near actual position
         :return:
         """
         test_data = {
@@ -107,7 +107,7 @@ class TestDirection(Base):
 
     def test_route_with_multiple_same_intensity(self):
         """
-        Test find route in middle of multiple pheromones
+        Test find route in middle of multiple molecules
         :return:
         """
         test_data = {
@@ -135,7 +135,7 @@ class TestDirection(Base):
 
     def test_route_with_multiple_different_intensity(self):
         """
-        Test find route in middle of multiple pheromones
+        Test find route in middle of multiple molecules
         :return:
         """
         test_data = {
@@ -148,7 +148,7 @@ class TestDirection(Base):
                 _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 2)}},
                 _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2)}},
                 _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (8, 1)}},
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (5, 10)}}  # an other pheromone type
+                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (5, 10)}}  # an other molecule type
             }
         }
 
@@ -162,7 +162,7 @@ class TestDirection(Base):
             },
             NORTH: {
                 _p(NORTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 500)}}  # An other pheromone type
+                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 500)}}  # An other molecule type
             }
         }
 
@@ -178,7 +178,7 @@ class TestDirection(Base):
             },
             NORTH: {
                 _p(NORTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 5)}},
-                _p(WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 500)}},  # An other pheromone_type
+                _p(WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 500)}},  # An other molecule_type
                 _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4)}},
                 _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4)}}
             }
@@ -187,55 +187,55 @@ class TestDirection(Base):
         for direction in test_data:
             self._test_direction_for_points(test_data[direction], direction)
 
-    def test_no_pheromones_around(self):
-        # No pheromone
+    def test_no_molecules_around(self):
+        # No molecule
         try:  # WTF ?
-            self.assertRaises(NoPheromone, self._test_direction_for_points({}, -1))
-        except NoPheromone:
+            self.assertRaises(NoMolecule, self._test_direction_for_points({}, -1))
+        except NoMolecule:
             self.assertTrue(True)
 
-        # Wrong pheromone type
+        # Wrong molecule type
         try:  # WTF ?
-            self.assertRaises(NoPheromone, self._test_direction_for_points({
+            self.assertRaises(NoMolecule, self._test_direction_for_points({
                 _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 5)}}
             }, -1))
-        except NoPheromone:
+        except NoMolecule:
             self.assertTrue(True)
 
     def test_appose(self):
-        self._test_point_raise_no_pheromone()
-        self._test_points_raise_no_pheromone()
+        self._test_point_raise_no_molecule()
+        self._test_points_raise_no_molecule()
 
-        # Une pheromone au centre
-        DirectionPheromone.appose(self._context,
+        # Une molecule au centre
+        DirectionMolecule.appose(self._context,
                                   _p(CENTER),
-                                  self._get_pheromone(PHEROMON_DIR_EXPLO, 2))
+                                  self._get_molecule(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)
+        self._test_point_raise_no_molecule(re_init=False)
+        self._test_points_raise_no_molecule(re_init=False)
 
-        # Une pheromone au nord
-        DirectionPheromone.appose(self._context,
+        # Une molecule au nord
+        DirectionMolecule.appose(self._context,
                                   _p(NORTH),
-                                  self._get_pheromone(PHEROMON_DIR_EXPLO, 1))
+                                  self._get_molecule(PHEROMON_DIR_EXPLO, 1))
         # le permet
         self._test_direction_for_points({}, NORTH, re_init=False)
         self._test_direction_for_point({}, NORTH, re_init=False)
 
 
-    def _test_point_raise_no_pheromone(self, pheromones={}, direction=-1, pheromone_type=PHEROMON_DIR_EXPLO,
+    def _test_point_raise_no_molecule(self, molecules={}, direction=-1, molecule_type=PHEROMON_DIR_EXPLO,
                                  reference_point=_p(CENTER), re_init=True):
         try:  # WTF ?
-            self._test_direction_for_point(pheromones, direction, re_init=re_init)
-        except NoPheromone:
+            self._test_direction_for_point(molecules, direction, re_init=re_init)
+        except NoMolecule:
             self.assertTrue(True)
 
-    def _test_points_raise_no_pheromone(self, pheromones={}, direction=-1, pheromone_type=PHEROMON_DIR_EXPLO,
+    def _test_points_raise_no_molecule(self, molecules={}, direction=-1, molecule_type=PHEROMON_DIR_EXPLO,
                                  reference_point=_p(CENTER), re_init=True):
         try:  # WTF ?
-            self._test_direction_for_points(pheromones, direction, re_init=re_init)
-        except NoPheromone:
+            self._test_direction_for_points(molecules, direction, re_init=re_init)
+        except NoMolecule:
             self.assertTrue(True)
 
-    def _get_pheromone(self, type, distance):
-        return Pheromone(PHEROMON_DIRECTION, type, distance=distance)
+    def _get_molecule(self, type, distance):
+        return Molecule(PHEROMON_DIRECTION, type, distance=distance)

tests.py

@@ -5,12 +5,12 @@ from sys import path as ppath
 ppath.insert(1,getcwd()+'/modules') # TODO: win32 compatibilite (python path)
 
 """
-python3.4 -m unittest /home/bux/Projets/socialintengine/intelligine/tests/simulation/mode/TestChangeMode.py && python3.4 -m unittest intelligine/tests/simulation/pheromone/TestDirection.py
+python3.4 -m unittest /home/bux/Projets/socialintengine/intelligine/tests/simulation/mode/TestChangeMode.py && python3.4 -m unittest intelligine/tests/simulation/molecule/TestDirection.py
 """
 
 test_modules = [
     'intelligine.tests.simulation.mode.TestChangeMode.TestChangeMode',
-    'intelligine.tests.simulation.pheromone.TestDirection.TestDirection',
+    'intelligine.tests.simulation.molecule.TestDirection.TestDirection',
 ]
 
 suite = unittest.TestSuite()