Merge branch 'dev/mol'

.travis.yml

 script:
   - coverage run tests.py --rcfile=.coveragerc -v && coverage report -m && python3.4 tests.py
 after_success:
-  - coveralls
+  - coveralls

INSTALL.md

-INSTALL
-=====================
-
-Windows
---------------------
-
-(dirty tmp howto)
-
-Install python 3.4+: https://www.python.org/downloads/
-Install Git: http://git-scm.com/download/win
-
-Execute command 
-````
-C:\Python34\python -m pip install pytmx
-````
-Install pygame for python3.4: Download pygame‑1.9.2a0‑cp34‑none‑win32.whl on http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame
-
-Execute command 
-````
-C:\Python34\python -m pip install "Downloads\pygame-1.9.2a0-cp34-none-win32.whl"
-````
-Launch Git Bash program and execute command
-````
-git clone https://github.com/buxx/intelligine.git ant/intelligine
-````
-
-Open Cmd and execute commands 
-````
-cd intelligine
-git clone https://github.com/buxx/synergine.git
-git clone https://github.com/buxx/synergine_xyz.git
-````
-
-Open new Cmd:
-````
-cd intelligine
-C:\Python34\python run.py multi
-````
-
-Linux
--------------------
-
-You need python3.4+ and git. Clone the project:
-````
-git clone https://github.com/buxx/intelligine.git ant/intelligine
-````
-Install requirements:
-````
-pip install -r requirements.txt
-````
-It's ready
-````
-python run.py multi
-````
+Soon ...

README.md

 ### Ressource exploration
 
 [![Intelligine: ressource exploration](https://raw.githubusercontent.com/buxx/intelligine/master/doc/images/intelligine_ressource_20150421_r.gif)](https://raw.githubusercontent.com/buxx/intelligine/master/doc/images/intelligine_ressource_20150421_r.gif) 
+[![Intelligine: ressource exploration with AntStar algo for bypass](https://raw.githubusercontent.com/buxx/intelligine/dev/mol/doc/images/explo_antstar_glue.gif)](https://raw.githubusercontent.com/buxx/intelligine/dev/mol/doc/images/explo_antstar_glue.gif)

TODO

 * Fourmis (map.tmx) pas en mode nurse (-> algo de choix d'activité plus tard)
-* 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)
+* Nourriture posé: Comme oeufs, plus de debug. Implique algo pour pas remplir couloirs. Implique ne plus travailler a xplo de nourriture si plus de place ? etc ...

config.py

             'mainprocess': True,
             'cycles': -1,
             'seed': 42
-        }
+        },
+        'clean_each_cycle': 100
     },
     'simulations': simulations,
     'connections': [Pygame],
     'ant': {
         'take': {
             'cant_put_still': 5
+        },
+        'put': {
+            'max_objects_at_same_position': 5
+        }
+    },
+    'stigmergy': {
+        'molecule': {
+            'evaporate_decrement': 5,
+            'evaporate_min_age': 100,
+            'evaporate_each_cycle': 100
         }
     }
-}
+}

intelligine/core/Context.py

 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

     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)
     def get_best_distance(self):
         return self._best_distance
 
-class PheromoneGlandDisabled(PheromoneException):
+class MoleculeGlandDisabled(MoleculeException):
     pass
 
 
     pass
 
 
-class BrainPartAlreadyExist(BrainException):
-    pass
-
-
 class BodyException(Exception):
     pass
 

intelligine/cst.py

 TRANSPORTABLE = IncrementedNamedInt.get('intelligine.transportable')
 TRANSPORTER = IncrementedNamedInt.get('intelligine.transporter')
 CARRYING = IncrementedNamedInt.get('intelligine.carrying')
-CARRIED = IncrementedNamedInt.get('intelligine.carried')
+CARRIED_BY = IncrementedNamedInt.get('intelligine.carried_by')
+CARRY = IncrementedNamedInt.get('intelligine.carry')
 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')
+MOLECULE_SEARCHING = IncrementedNamedInt.get('intelligine.molecule_searching')
+MOLECULES = IncrementedNamedInt.get('intelligine.molecules')
 
-# TODO: Renommer "move_mode" en "mode"
-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')
-MOVE_MODE_NURSE = IncrementedNamedInt.get('intelligine.basebug.move.mode.nurse')
+MODE = IncrementedNamedInt.get('intelligine.basebug.move')
+MODE_EXPLO = IncrementedNamedInt.get('intelligine.basebug.move.explo')
+MODE_GOHOME = IncrementedNamedInt.get('intelligine.basebug.move.gohome')
+MODE_NURSE = IncrementedNamedInt.get('intelligine.basebug.move.nurse')
+MODE_HOME = IncrementedNamedInt.get('intelligine.basebug.move.home')
+
+MOVE_BYBASS = IncrementedNamedInt.get('intelligine.basebug.move.bypass')
+MOVE_BYBASS_DISTANCE = IncrementedNamedInt.get('intelligine.basebug.move.bypass.distance')
+MOVE_BYBASS_MEMORY = IncrementedNamedInt.get('intelligine.basebug.move.bypass.memory')
+MOVE_BYBASS_WALL = IncrementedNamedInt.get('intelligine.basebug.move.bypass.wall')
+MOVE_BYBASS_RE_WALKING = IncrementedNamedInt.get('intelligine.basebug.move.bypass.re_walking')
 
 TYPE = IncrementedNamedInt.get('intelligine.object.type')
 TYPE_RESOURCE_EXPLOITABLE = IncrementedNamedInt.get('intelligine.object.type.resource.transformable')
+TYPE_RESOURCE_EATABLE = IncrementedNamedInt.get('intelligine.object.type.resource.eatable')
 TYPE_NURSERY = IncrementedNamedInt.get('intelligine.object.type.nursery')
 TYPE_ANT = IncrementedNamedInt.get('intelligine.object.type.ant')
 
 PHEROMON_POSITIONS = IncrementedNamedInt.get('intelligine.phero.positions')
-PHEROMON_INFOS = IncrementedNamedInt.get('intelligine.phero.infos')
-PHEROMON_DIRECTION = IncrementedNamedInt.get('intelligine.phero.direction')
+MOLECULES_INFOS = IncrementedNamedInt.get('intelligine.mol.infos')
+MOLECULES_DIRECTION = IncrementedNamedInt.get('intelligine.mol.direction')
 PHEROMON_DIR_NONE = IncrementedNamedInt.get('intelligine.phero.direction.none')
 PHEROMON_DIR_EXPLO = IncrementedNamedInt.get('intelligine.phero.direction.explo')
-PHEROMON_DIR_HOME = IncrementedNamedInt.get('intelligine.phero.direction.home')
+EXPLORATION_VECTOR = IncrementedNamedInt.get('intelligine.exploration_vector')
 
+#SMELL = IncrementedNamedInt.get('intelligine.smell')
 OBJ_SMELL = IncrementedNamedInt.get('intelligine.obj_smell')
 SMELL_FOOD = IncrementedNamedInt.get('intelligine.smell.food')
 SMELL_EGG = IncrementedNamedInt.get('intelligine.smell.egg')
 COL_EATABLE = IncrementedNamedInt.get('intelligine.col.eatable')
 COL_SMELL = IncrementedNamedInt.get('intelligine.col.smell')
 
+INSTANCE_CLASS = IncrementedNamedInt.get('intelligine.instance_class')
+
+BRAIN = IncrementedNamedInt.get('intelligine.brain')
 BRAIN_SCHEMA = IncrementedNamedInt.get('intelligine.brain_schema')
 BRAIN_PART_MOVE = IncrementedNamedInt.get('intelligine.brain.part.move')
 BRAIN_PART_TAKE = IncrementedNamedInt.get('intelligine.brain.part.take')
 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

-from intelligine.core.exceptions import NoPheromone
+from intelligine.core.exceptions import NoMolecule
+from intelligine.synergy.object.ant.Ant import Ant
+from intelligine.synergy.object.ant.Egg import Egg
 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, \
-    POINT_SMELL, SMELL_EGG, SMELL_FOOD
+from intelligine.cst import PHEROMON_DIR_EXPLO, MOLECULES, SMELL_EGG, SMELL_FOOD, MOLECULES_DIRECTION, \
+    MOVE_BYBASS_MEMORY
 from intelligine.display.pygame.visualisation import SURFACE_PHEROMONE_EXPLORATION, SURFACE_PHEROMONE_HOME, \
     SURFACE_SMELL_EGG, SURFACE_SMELL_FOOD
 
 
     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
+        self._draw_callbacks = []
 
     def receive(self, actions_done):
         super().receive(actions_done)
 
-        if self._is_display_pheromones:
-            pheromones_positions = self._context.metas.list.get(PHEROMON_POSITIONS,
-                                                                PHEROMON_POSITIONS,
-                                                                allow_empty=True)
-            self._display_pheromones(pheromones_positions, self._context)
+        if self._is_display_molecules:
+            molecules_positions = self._context.metas.list.get(MOLECULES,
+                                                               MOLECULES,
+                                                               allow_empty=True)
+            self._display_molecules(molecules_positions, self._context)
 
-        if self._is_display_smells:
-            smell_positions = self._context.metas.list.get(POINTS_SMELL,
-                                                           POINTS_SMELL,
-                                                           allow_empty=True)
-            self._display_smells(smell_positions, self._context)
+    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)
+        smell_egg_surface = self._object_visualizer.get_surface(SURFACE_SMELL_EGG)
+        smell_food_surface = self._object_visualizer.get_surface(SURFACE_SMELL_FOOD)
+
+        for point in molecules_positions:
+            point_flavour = context.molecules().get_flavour(point)
+            try:
+                molecule = point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=PHEROMON_DIR_EXPLO)
+                self.draw_surface(point, molecule_exploration_surface)
+
+                adapted_point = self._get_real_pixel_position_of_position(point)
+                myfont = pygame.font.SysFont("monospace", 15)
+                label = myfont.render(str(molecule.get_distance()), 1, (128,255,128))
+                self._screen.blit(label, adapted_point)
 
-    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)
+            except NoMolecule:
+                pass # No molecule here
 
-        for point in pheromones_positions:
-            point_flavour = context.pheromones().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
+                molecule = point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=SMELL_FOOD)
+                self.draw_surface(point, smell_food_surface)
+
+                adapted_point = self._get_real_pixel_position_of_position(point)
+                adapted_point = (adapted_point[0]+10, adapted_point[1]+10)
+                myfont = pygame.font.SysFont("monospace", 15)
+                label = myfont.render(str(molecule.get_distance()), 1, (255,255,0))
+                self._screen.blit(label, adapted_point)
+
+            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
+                molecule = point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=SMELL_EGG)
+                self.draw_surface(point, smell_food_surface)
 
-    def _display_smells(self, smell_positions, context):
-        smell_egg_surface = self._object_visualizer.get_surface(SURFACE_SMELL_EGG)
-        smell_food_surface = self._object_visualizer.get_surface(SURFACE_SMELL_FOOD)
+                adapted_point = self._get_real_pixel_position_of_position(point)
+                adapted_point = (adapted_point[0]+10, adapted_point[1]+10)
+                myfont = pygame.font.SysFont("monospace", 15)
+                label = myfont.render(str(molecule.get_distance()), 1, (255,255,0))
+                self._screen.blit(label, adapted_point)
+
+            except NoMolecule:
+                pass # No molecule here
 
-        for point in smell_positions:
-            point_flavour = context.metas.value.get(POINT_SMELL, point, allow_empty=True, empty_value={})
-            if SMELL_EGG in point_flavour:
+            try:
+                point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=SMELL_EGG)
                 self.draw_surface(point, smell_egg_surface)
-            if SMELL_FOOD in point_flavour:
-                self.draw_surface(point, smell_food_surface)
+            except NoMolecule:
+                pass # No molecule here
 
     def _key_pressed(self, key):
 
-        if key == pygame.K_p:
-            if self._is_display_pheromones:
-                self._is_display_pheromones = False
+        if key == pygame.K_m:
+            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:
-                self._is_display_smells = False
-            else:
-                self._is_display_smells = True
+    def draw_object(self, obj, point):
+        super().draw_object(obj, point)
+        # TODO: DEBUG
+        if isinstance(obj, Ant):
+            myfont = pygame.font.SysFont("monospace", 15)
+            label = myfont.render(str(obj.get_id()), 1, (255,255,0))
+            self._draw_callbacks.append(lambda: self._screen.blit(label, point))
+            label2 = myfont.render(',', 1, (0,0,0))
+
+            ant_mem = self._context.metas.value.get(MOVE_BYBASS_MEMORY, obj.get_id(), allow_empty=True,
+                                                             empty_value=[])
+
+            def print_mem(points):
+                for m in points:
+                    real_point = self._get_real_pixel_position_of_position((0, m[0], m[1]))
+                    self._screen.blit(label2, real_point)
+
+            self._draw_callbacks.append(lambda: print_mem(ant_mem) )
+        # TODO: DEBUG
+        if isinstance(obj, Egg):
+            myfont = pygame.font.SysFont("monospace", 15)
+            label = myfont.render(str(obj.get_id()), 1, (125,255,25))
+            self._draw_callbacks.append(lambda: self._screen.blit(label, point))
+
+    def start_of_cycle(self):
+        super().start_of_cycle()
+        self._draw_callbacks = []
+
+    def end_of_cycle(self):
+        for draw_callback in self._draw_callbacks:
+            draw_callback()
+        super().end_of_cycle()

intelligine/display/map.py

+from synergine_xyz.tmx.TileMapConnector import TileMapConnector
+
+
+def get_map_connector(map_file_path, map_config):
+    return TileMapConnector.from_file(map_file_path, dict(map_config))

intelligine/display/pygame/config.py

+from intelligine.synergy.Colony import Colony
+from intelligine.synergy.Environment import Environment
+from intelligine.synergy.Simulation import Simulation
+from intelligine.synergy.object.StockedFood import StockedFood
+from intelligine.synergy.object.Food import Food
+from intelligine.synergy.object.Rock import Rock
+from intelligine.synergy.object.ant.Ant import Ant
+from intelligine.synergy.object.ant.Egg import Egg
+
+
+map_config = {
+    'simulation': {
+        'base': Simulation
+    },
+    'collection': {
+        'ant': Colony,
+        'env': Environment
+    },
+    'object': {
+        'ant': Ant,
+        'egg': Egg,
+        'rock': Rock,
+        'food': Food,
+        'stocked_food': StockedFood
+    }
+}

intelligine/display/pygame/visualisation.py

 import pygame
-from intelligine.synergy.Colony import Colony
-from intelligine.synergy.Environment import Environment
-from intelligine.synergy.object.StockedFood import StockedFood
-from synergine.synergy.Simulation import Simulation
+from intelligine.display.map import get_map_connector
 from synergine_xyz.display.PygameImageRotate import PygameImageRotate
 from synergine_xyz.display.PygameVisualisation import PygameVisualisation
 from synergine_xyz.display.object.pygame.PygameImage import PygameImage
-from intelligine.synergy.object.Food import Food
 from intelligine.synergy.object.ant.Ant import Ant
-from intelligine.synergy.object.Rock import Rock
 from intelligine.synergy.object.ant.Egg import Egg
 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'
 # Behind, new
 #############################
 
-map_config = {
-    'simulation': {
-        'base': Simulation
-    },
-    'collection': {
-        'ant': Colony,
-        'env': Environment
-    },
-    'object': {
-        'ant': Ant,
-        'egg': Egg,
-        'rock': Rock,
-        'food': Food,
-        'stocked_food': StockedFood
-    }
-}
 image_rotate = PygameImageRotate()
 
 
 
 
 def get_standard_extract_from_map(map_file_path, map_config):
-    map_connector = TileMapConnector.from_file(map_file_path, dict(map_config))
+    map_connector = get_map_connector(map_file_path, map_config)
     visualisation = PygameVisualisation.get_default_visualisation()
 
     simulations = map_connector.create_simulations()

intelligine/sandbox/all/all.py

 from os import getcwd
-from intelligine.display.pygame.visualisation import get_standard_extract_from_map, map_config
+from intelligine.display.pygame.config import map_config
+from intelligine.display.pygame.visualisation import get_standard_extract_from_map
 
 
 simulations, visualisation = get_standard_extract_from_map(getcwd()+"/intelligine/sandbox/all/map.tmx",

intelligine/sandbox/exploration/exploration.py

 from os import getcwd
-from intelligine.display.pygame.visualisation import get_standard_extract_from_map, map_config
+from intelligine.display.pygame.config import map_config
+from intelligine.display.pygame.visualisation import get_standard_extract_from_map
 
 
 simulations, visualisation = get_standard_extract_from_map(getcwd()+"/intelligine/sandbox/exploration/map.tmx",

intelligine/shorcut/brain.py

+from intelligine.cst import BRAIN, BRAIN_SCHEMA, INSTANCE_CLASS
+
+
+def get_brain_class(context, object_id):
+    object_class = context.metas.value.get(INSTANCE_CLASS, object_id)
+    return context.metas.value.get(BRAIN, object_class)
+
+
+def get_brain_part(context, object_id, brain_part_name):
+    object_class = context.metas.value.get(INSTANCE_CLASS, object_id)
+    object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_class)
+    return object_brain_schema[brain_part_name]

intelligine/simulation/molecule/DirectionMolecule.py

+from intelligine.cst import POINTS_SMELL, MOLECULES, MOLECULES_DIRECTION
+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():
+
+    _positions_key = None
+
+    @classmethod
+    def appose(cls, context, point, molecule):
+        context.molecules().increment_with_molecule(point, molecule, context.get_cycle())
+        context.metas.list.add(MOLECULES, MOLECULES, 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=MOLECULES_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
+
+    @classmethod
+    def _get_around_molecules(cls, 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=MOLECULES_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
+
+    @classmethod
+    def get_best_molecule_direction_in(cls, 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=MOLECULES_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/molecule/Evaporation.py

+from intelligine.cst import MOLECULES, MOLECULES_DIRECTION
+from intelligine.synergy.stigmergy.MoleculesManager import MoleculesManager
+
+
+class Evaporation:
+
+    def __init__(self, context,
+                 intensity_decrement=1,
+                 molecule_minimum_age=0,
+                 molecules_exclude_types=None,
+                 molecules_include_types=None):
+        self._context = context
+        self._intensity_decrement = intensity_decrement
+        self._molecules_manager = MoleculesManager(context)
+        self._molecule_minimum_age = molecule_minimum_age
+        self._molecules_exclude_types = molecules_exclude_types
+        self._molecules_include_types = molecules_include_types
+
+    def evaporate(self):
+        for position, flavour in self._get_flavours():
+            self._decrease_flavour(flavour)
+            self._molecules_manager.set_flavour(position, flavour)
+
+    def remove(self):
+        for position, flavour in self._get_flavours():
+            self._remove_molecule(flavour)
+            self._molecules_manager.set_flavour(position, flavour)
+
+    def _get_flavours(self):
+        molecules_points = self._context.metas.list.get(MOLECULES, MOLECULES, allow_empty=True)
+        for molecule_point in molecules_points:
+            yield molecule_point, self._molecules_manager.get_flavour(molecule_point)
+
+    def _decrease_flavour(self, flavour):
+        for direction_molecule in self._get_molecules_from_flavour(flavour):
+            direction_molecule.increment_intensity(-self._intensity_decrement)
+            flavour.set_molecule(direction_molecule)
+
+    def _get_molecules_from_flavour(self, flavour):
+        molecules = []
+        for direction_molecule in flavour.get_molecules(MOLECULES_DIRECTION):
+            if not self._is_recent_molecule(direction_molecule) \
+               and not self._is_excluded_molecule_type(direction_molecule):
+                molecules.append(direction_molecule)
+        return molecules
+
+    def _remove_molecule(self, flavour):
+        for direction_molecule in self._get_molecules_from_flavour(flavour):
+            flavour.remove_molecule(direction_molecule)
+
+    def _is_recent_molecule(self, molecule):
+        return (self._context.get_cycle() - molecule.get_cycle_age()) < self._molecule_minimum_age
+
+    def _is_excluded_molecule_type(self, molecule):
+        if not self._molecules_exclude_types and not self._molecules_include_types:
+            return False
+
+        if self._molecules_exclude_types and not self._molecules_include_types:
+            return molecule.get_type() in self._molecules_exclude_types
+
+        if not self._molecules_exclude_types and self._molecules_include_types:
+            return molecule.get_type() not in self._molecules_include_types

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

-class Pheromone():
+class Molecule():
 
-    def __init__(self, category, type, distance=None, intensity=0):
+    def __init__(self, category, type, distance=None, intensity=0, cycle_age=None):
         self._category = category
         self._type = type
         self._distance = distance
         self._intensity = intensity
+        self._cycle_age = cycle_age
 
     def get_category(self):
         return self._category
     def get_intensity(self):
         return self._intensity
 
+    def get_cycle_age(self):
+        return self._cycle_age
+
     def increment_intensity(self, increment_value):
-        self._intensity += increment_value
+        self._intensity += increment_value

intelligine/simulation/molecule/MoleculeFlavour.py

+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, cycle_age = molecules_by_category[type]
+                if category not in flavour:
+                    flavour[category] = {}
+                flavour[category][type] = Molecule(category, type, distance, intensity, cycle_age)
+        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] = {}
+                if molecule.get_intensity() >= 0:
+                    raw_data[category][type] = (molecule.get_distance(),
+                                                molecule.get_intensity(),
+                                                molecule.get_cycle_age())
+        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_molecules(self, category):
+        """
+
+        :param category:
+        :return: Molecules dict or empty dict of no molecules
+        """
+        try:
+            return self.get_types(category).values()
+        except NoCategoryInMolecule:
+            return {}
+
+    def get_molecules_types(self, category):
+        try:
+            return self.get_types(category).keys()
+        except NoCategoryInMolecule:
+            return {}
+
+    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
+
+    def remove_molecule(self, molecule):
+        category = molecule.get_category()
+        type = molecule.get_type()
+        del(self._flavour[category][type])

intelligine/simulation/object/brain/AntBrain.py

 from intelligine.simulation.object.brain.Brain import Brain
 from intelligine.simulation.object.brain.part.attack.AttackBrainPart import AttackBrainPart
 from intelligine.simulation.object.brain.part.move.AntMoveBrainPart import AntMoveBrainPart
-from intelligine.cst import MOVE_MODE, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, \
-    BRAIN_PART_TAKE, BRAIN_PART_PUT, MOVE_MODE_NURSE, PHEROMON_DIR_NONE, BRAIN_PART_ATTACK
-from intelligine.cst import PHEROMONE_SEARCHING
+from intelligine.cst import MODE, MODE_EXPLO, MODE_GOHOME, PHEROMON_DIR_EXPLO, \
+    BRAIN_PART_TAKE, BRAIN_PART_PUT, MODE_NURSE, PHEROMON_DIR_NONE, BRAIN_PART_ATTACK, MODE_HOME, \
+    SMELL_FOOD, SMELL_EGG
+from intelligine.cst import MOLECULE_SEARCHING
 from intelligine.cst import BRAIN_PART_MOVE
 from intelligine.simulation.object.brain.part.transport.AntPutBrainPart import AntPutBrainPart
 from intelligine.simulation.object.brain.part.transport.AntTakeBrainPart import AntTakeBrainPart
+from intelligine.synergy.object.Food import Food
+from intelligine.synergy.object.ant.Egg import Egg
+from synergine.core.exceptions import NotFound
 
 
 class AntBrain(Brain):
 
-    # TODO: methode __init_ pour la classe ? Pour surcharger ici.
-    _brain_parts = {
+    _brain_parts = Brain._brain_parts.copy()
+    _brain_parts.update({
         BRAIN_PART_MOVE: AntMoveBrainPart,
         BRAIN_PART_TAKE: AntTakeBrainPart,
         BRAIN_PART_PUT: AntPutBrainPart,
         BRAIN_PART_ATTACK: AttackBrainPart
+    })
+
+    _taken_smell_matches = {
+        Food: SMELL_FOOD,
+        Egg: SMELL_EGG
     }
+    """ Correspondance entre ce qui est ramassé et où ce doit être stocké """
 
     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
-        self._pheromone_searching = PHEROMON_DIR_EXPLO
+        self._movement_mode = MODE_HOME
+        self._distance_from_objective = 0
+        self._molecule_searching = PHEROMON_DIR_EXPLO
 
     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
-        self._update_pheromone_searching(mode)
-
-    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
-        elif mode == MOVE_MODE_NURSE:
-            pheromone_direction_type = None
+        self._update_molecule_gland(mode)
+        self._context.metas.value.set(MODE, self._host.get_id(), mode)
+        self._update_molecule_searching(mode)
+
+    def _update_molecule_gland(self, mode):
+        if mode == MODE_EXPLO:
+            molecule_direction_type = None
+        elif mode == MODE_GOHOME:
+            molecule_direction_type = PHEROMON_DIR_EXPLO
+            self._distance_from_objective = 0
+        elif mode == MODE_NURSE:
+            molecule_direction_type = None
+        elif mode == MODE_HOME:
+            molecule_direction_type = PHEROMON_DIR_EXPLO
         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()
-
-    def _update_pheromone_searching(self, mode):
-        if mode == MOVE_MODE_EXPLO:
-            pheromone_searching = PHEROMON_DIR_EXPLO
-        elif mode == MOVE_MODE_GOHOME:
-            pheromone_searching = PHEROMON_DIR_HOME
-        elif mode == MOVE_MODE_NURSE:
-            pheromone_searching = PHEROMON_DIR_NONE
+            self._host.get_movement_molecule_gland().disable()
+
+    def _update_molecule_searching(self, mode):
+        if mode == MODE_EXPLO:
+            molecule_searching = PHEROMON_DIR_EXPLO
+        elif mode == MODE_GOHOME:
+            molecule_searching = PHEROMON_DIR_NONE
+        elif mode == MODE_NURSE:
+            molecule_searching = PHEROMON_DIR_NONE
+        elif mode == MODE_HOME:
+            # TODO: Ca depend de ce que fait la fourmis, si s'occupe des oeufs, etc
+            molecule_searching = self.get_part(BRAIN_PART_TAKE).get_smell_target()
         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(MOLECULE_SEARCHING, self._host.get_id(), molecule_searching)
 
     def get_movement_mode(self):
         return self._movement_mode
 
     def host_moved(self, distance=1):
-        self._distance_from_objective += 1
+        self._distance_from_objective += distance
 
     def set_distance_from_objective(self, distance):
         self._distance_from_objective = distance
 
     def get_distance_from_objective(self):
-        return self._distance_from_objective
+        return self._distance_from_objective
+
+    def get_smell_for_object_taken(self, obj):
+        for take_class in self._taken_smell_matches:
+            if isinstance(obj, take_class):
+                return self._taken_smell_matches[take_class]
+        raise NotFound()
+
+    @classmethod
+    def get_home_smells(cls):
+        """
+        Note: Actually return all know smells. Not really HOME smells.
+        :return:
+        """
+        return cls._taken_smell_matches.values()

intelligine/simulation/object/brain/Brain.py

-from intelligine.core.exceptions import BrainPartAlreadyExist
 from intelligine.cst import BRAIN_SCHEMA
 
 
     def __init__(self, context, host):
         self._context = context
         self._host = host
-        self._schema = {}
         self._parts = {}
         self._init_parts()
 
     def _init_parts(self):
         for brain_part_name in self._brain_parts:
-            self._set_brain_part(brain_part_name, self._brain_parts[brain_part_name](self))
-
-    def _set_brain_part(self, name, brain_part, replace=False):
-        if name in self._parts and not replace:
-            raise BrainPartAlreadyExist()
-        self._parts[name] = brain_part
-        self._update_schema()
+            self._parts[brain_part_name] = self._brain_parts[brain_part_name](self)
+        self._context.metas.value.set(BRAIN_SCHEMA, self._host.__class__, self._brain_parts)
 
     def get_part(self, name):
         return self._parts[name]
 
-    def _update_schema(self):
-        self._schema = {}
-        for part_name in self._parts:
-            self._schema[part_name] = self._parts[part_name].__class__
-        # TODO: N'est-ce pas un schema appartenant a la classe ? Ne suffirai t-il pas de stocker ce schema par classe
-        # plutôt que par objet ?
-        self._context.metas.value.set(BRAIN_SCHEMA, self._host.get_id(), self._schema)
+    def get_context(self):
+        return self._context
+
+    def get_host(self):
+        return self._host

intelligine/simulation/object/brain/part/BrainPart.py

 
     def __init__(self, host_brain):
         self._host_brain = host_brain
+        self._context = self._host_brain.get_context()
+        self._host = self._host_brain.get_host()
 
-    def done(self, obj, context):
+    def get_host_brain(self):
+        return self._host_brain
+
+    def get_host(self):
+        return self.get_host_brain().get_host()
+
+    def done(self):
         pass

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

+from intelligine.shorcut.brain import get_brain_class
+from intelligine.simulation.object.brain.part.move.AntStar.ByPass import ByPass
+from intelligine.simulation.object.brain.part.move.AntStar.Host import Host
 from intelligine.simulation.object.brain.part.move.MoveBrainPart import MoveBrainPart
+from intelligine.synergy.event.move.direction import directions_modifiers, get_position_with_direction_decal
 from synergine_xyz.cst import POSITION
-from intelligine.core.exceptions import NoPheromone
-from intelligine.cst import PHEROMONE_SEARCHING, MOVE_MODE_EXPLO, COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING
-from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
+from intelligine.core.exceptions import NoMolecule
+from intelligine.cst import MOLECULE_SEARCHING, MODE_EXPLO, MODE_HOME, MODE, MODE_GOHOME, \
+    EXPLORATION_VECTOR, MOLECULES_DIRECTION
+from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 
 
 class AntMoveBrainPart(MoveBrainPart):
 
+    def __init__(self, host_brain):
+        super().__init__(host_brain)
+        self._exploration_vector = (0, 0)
+
+    def _set_exploration_vector(self, new_vector):
+        self._exploration_vector = new_vector
+        self._context.metas.value.set(EXPLORATION_VECTOR,
+                                      self._host_brain.get_host().get_id(),
+                                      new_vector)
+
     @classmethod
     def get_direction(cls, context, object_id):
-        try:
-            return cls._get_direction_with_pheromones(context, object_id)
-        except NoPheromone:
-            return super().get_direction(context, object_id)
+        move_mode = context.metas.value.get(MODE, object_id)
+        if move_mode == MODE_GOHOME:
+            return cls._get_direction_with_exploration_vector(context, object_id)
+        else:
+            try:
+                return cls._get_direction_with_molecules(context, object_id)
+            except NoMolecule:
+                return super().get_direction(context, object_id)
+
+        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(MOLECULE_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,
-                                                                                          point,
-                                                                                          search_pheromone_in_points,
-                                                                                          pheromone_type)
-            return best_pheromone_direction
-        except NoPheromone as err:
+            best_molecule_direction = DirectionMolecule.get_best_molecule_direction_in(context,
+                                                                                       point,
+                                                                                       search_molecule_in_points,
+                                                                                       molecule_type)
+            return best_molecule_direction
+        except NoMolecule as err:
             raise err
 
-    def done(self, obj, context):
-        super().done(obj, context)
-        self._appose_pheromone(obj)
+    @classmethod
+    def _get_direction_with_exploration_vector(cls, context, object_id):
+        ant_star = cls._get_by_pass_brain(context, object_id)
+        ant_star.advance()
+        return ant_star.get_host().get_moved_to_direction()
 
-    @staticmethod
-    def _appose_pheromone(obj):
-        if obj.get_movement_pheromone_gland().is_enabled():
-            obj.get_movement_pheromone_gland().appose()
+    @classmethod
+    def _get_by_pass_brain(cls, context, object_id):
+        # We use an adaptation of AntStar
+        exploration_vector = context.metas.value.get(EXPLORATION_VECTOR, object_id)
+        home_vector = (-exploration_vector[0], -exploration_vector[1])
+        ant_host = Host(context, object_id)
+        return ByPass(ant_host, home_vector, context, object_id)
+
+    def done(self):
+        super().done()
+        self._appose_molecule()
+        self._check_context()
+        self._apply_context()
+
+    def _appose_molecule(self):
+        if self._host.get_movement_molecule_gland().is_enabled():
+            self._host.get_movement_molecule_gland().appose()
+
+    def _check_context(self):
+        """
+
+        If was in exploration, and just found home smell;
+            -> home mode (then, in this mode: no update vector, put food if food, etc)
+        If was in home, and just loose home smell:
+            -> exploration mode
+
+        :param obj:
+        :param context:
+        :return:
+        """
+        movement_mode = self._host_brain.get_movement_mode()
+
+        if movement_mode == MODE_GOHOME and self._on_home_smell(self._context, self._host.get_id()):
+            self._arrived_at_home()
+
+        elif movement_mode == MODE_HOME and not self._on_home_smell(self._context, self._host.get_id()):
+            self._start_new_exploration()
+
+        elif movement_mode == MODE_EXPLO and self._on_home_smell(self._context, self._host.get_id()):
+            self._init_exploration_vector()
+
+        # TODO: sitch explo si rien a faire (rien a poser par exemple) et HOME
+
+    @classmethod
+    def _on_home_smell(cls, context, object_id):
+        current_position = context.metas.value.get(POSITION, object_id)
+        flavour = context.molecules().get_flavour(current_position)
+        molecules = flavour.get_molecules_types(MOLECULES_DIRECTION)
+
+        if not molecules:
+            return False
+
+        brain_class = get_brain_class(context, object_id)
+        for smell_type in brain_class.get_home_smells():
+            if smell_type in molecules:
+                return True
+
+        return False
+
+    def _update_exploration_vector(self):
+        just_move_vector = directions_modifiers[self._host_brain.get_host().get_previous_direction()]
+        self._set_exploration_vector((self._exploration_vector[0] + just_move_vector[1],
+                                      self._exploration_vector[1] + just_move_vector[2]))
+
+    def _apply_context(self):
+        movement_mode = self._host_brain.get_movement_mode()
+        if movement_mode == MODE_EXPLO or movement_mode == MODE_GOHOME:
+            self._update_exploration_vector()
+
+    def _start_new_exploration(self):
+        self._init_exploration_vector()
+        self._host_brain.switch_to_mode(MODE_EXPLO)
+
+    def _init_exploration_vector(self):
+        # On vient de rentrer dans le monde exterieur, le vecteur de départ pointe vers la case précedente
+        # qui est une case dans la forteresse.
+        init_exploration_vector = get_position_with_direction_decal(self.get_host().get_previous_direction())
+        self._set_exploration_vector(init_exploration_vector)
 
+    def _arrived_at_home(self):
+        self._host_brain.switch_to_mode(MODE_HOME)
+        ant_star = self._get_by_pass_brain(self._context, self._host.get_id())
+        ant_star.erase()

intelligine/simulation/object/brain/part/move/AntStar/ByPass.py

+from antstar.GlueWallAntBrain import GlueWallAntBrain
+from intelligine.cst import EXPLORATION_VECTOR, MOVE_BYBASS, MOVE_BYBASS_DISTANCE, MOVE_BYBASS_MEMORY, MOVE_BYBASS_WALL, MOVE_BYBASS_RE_WALKING
+
+
+class ByPass(GlueWallAntBrain):
+
+    def __init__(self, host, home_vector, context, object_id):
+        """
+
+        Note: We broke Liskov principle here.
+
+        :param host:
+        :param home_vector:
+        :param context:
+        :param object_id:
+        :return:
+        """
+        super().__init__(host, home_vector)
+        self._context = context
+        self._object_id = object_id
+        self._memory_since_blocked = context.metas.value.get(MOVE_BYBASS_MEMORY,
+                                                             object_id,
+                                                             allow_empty=True,
+                                                             empty_value=[])
+        self._by_passing = context.metas.value.get(MOVE_BYBASS,
+                                                   object_id,
+                                                   allow_empty=True,
+                                                   empty_value=False)
+        self._distance_when_blocked = context.metas.value.get(MOVE_BYBASS_DISTANCE,
+                                                              object_id,
+                                                              allow_empty=True,
+                                                              empty_value=None)
+        self._current_wall_square_position = context.metas.value.get(MOVE_BYBASS_WALL,
+                                                                     object_id,
+                                                                     allow_empty=True,
+                                                                     empty_value=None)
+        self._is_re_walking = context.metas.value.get(MOVE_BYBASS_RE_WALKING,
+                                                      object_id,
+                                                      allow_empty=True,
+                                                      empty_value=False)
+
+    def _set_home_vector(self, home_vector):
+        super()._set_home_vector(home_vector)
+        self._context.metas.value.set(EXPLORATION_VECTOR, self._object_id, home_vector)
+
+    def _set_memory_since_blocked(self, memory_since_blocked):
+        super()._set_memory_since_blocked(memory_since_blocked)
+        self._context.metas.value.set(MOVE_BYBASS_MEMORY, self._object_id, memory_since_blocked)
+
+    def _set_by_passing(self, by_passing):
+        super()._set_by_passing(by_passing)
+        self._context.metas.value.set(MOVE_BYBASS, self._object_id, by_passing)
+
+    def _set_distance_when_blocked(self, distance):
+        super()._set_distance_when_blocked(distance)
+        self._context.metas.value.set(MOVE_BYBASS_DISTANCE, self._object_id, distance)
+
+    def _set_current_wall_square(self, position_of_square):
+        super()._set_current_wall_square(position_of_square)
+        self._context.metas.value.set(MOVE_BYBASS_WALL, self._object_id, position_of_square)
+
+    def _set_is_re_walking(self, is_re_walking):
+        super()._set_is_re_walking(is_re_walking)
+        self._context.metas.value.set(MOVE_BYBASS_RE_WALKING, self._object_id, is_re_walking)

intelligine/simulation/object/brain/part/move/AntStar/Host.py

+from intelligine.simulation.object.brain.part.move.AntStar.HostFeeler import HostFeeler
+from intelligine.synergy.event.move.direction import get_position_with_direction_decal
+from synergine_xyz.cst import POSITION
+
+
+class Host:
+
+    def __init__(self, context, object_id):
+        self._context = context
+        self._object_id = object_id
+        self._feeler = HostFeeler(context, object_id)
+        self._moved_to_direction = None
+        self._position_3d = self._context.metas.value.get(POSITION, self._object_id)
+
+    def get_position(self):
+        return self._position_3d[1], self._position_3d[2]
+
+    def get_feeler(self):
+        return self._feeler
+
+    def move_to(self, direction):
+        self._moved_to_direction = direction
+        self._position_3d = get_position_with_direction_decal(direction, self._position_3d)
+
+    def get_moved_to_direction(self):
+        return self._moved_to_direction

intelligine/simulation/object/brain/part/move/AntStar/HostFeeler.py

+from intelligine.synergy.event.move.direction import get_position_with_direction_decal
+from synergine_xyz.cst import POSITION
+from synergine_xyz.geometry import distance_from_points
+
+
+class HostFeeler:
+
+    def __init__(self, context, object_id):
+        self._context = context
+        self._object_id = object_id
+        self._current_position = context.metas.value.get(POSITION, self._object_id)
+
+    def direction_is_free(self, direction_of_home):
+        position_will_be = get_position_with_direction_decal(direction_of_home, self._current_position)
+        return self._context.position_is_penetrable(position_will_be)
+
+    def position_is_free(self, position):
+        threed_position = (0, position[0], position[1])
+        points_distance = distance_from_points(threed_position, self._current_position)
+        if points_distance > 1:
+            raise Exception("Can't feel so far (%s to %s: %s)" % (str(self._current_position),
+                                                                  str(position),
+                                                                  str(points_distance)))
+        return self._context.position_is_penetrable(threed_position)

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

+from intelligine.synergy.object.Food import Food
+from synergine.core.Core import Core
 from intelligine.core.exceptions import CantFindWhereToPut
-from intelligine.cst import MOVE_MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, CARRIED
+from intelligine.cst import MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, MODE_NURSE, TYPE_NURSERY, \
+    MODE_HOME, TYPE_RESOURCE_EATABLE, MODE_GOHOME, CARRY
 from intelligine.simulation.object.brain.part.transport.TransportBrainPart import TransportBrainPart
-from intelligine.synergy.object.Food import Food
 from synergine_xyz.cst import POSITION, POSITIONS
 
 
 class AntPutBrainPart(TransportBrainPart):
 
-    # TODO: methode __nit_ pour la classe ?
-    _mode_matches = {
-        MOVE_MODE_EXPLO: [TYPE_RESOURCE_EXPLOITABLE],
+    _mode_matches = TransportBrainPart._mode_matches.copy()
+    _mode_matches.update({
+        MODE_NURSE: [TYPE_NURSERY],
+        MODE_HOME: [TYPE_RESOURCE_EATABLE],
+        MODE_GOHOME: []
+    })
+
+    _types_matches = {
+        TYPE_RESOURCE_EXPLOITABLE: [TYPE_RESOURCE_EATABLE],
+        TYPE_NURSERY: [TYPE_NURSERY]
     }
 
     @classmethod
     def can_put(cls, context, object_id, object_near_id):
-        object_carried_id = context.metas.value.get(CARRIED, object_id)
-        #  Pour le moment on considere qu'un objet peut-etre depose a cote d'un objet qui a un type identique
-        return cls._objects_have_same_type(context, object_carried_id, object_near_id)
+        # Si l'objet à coté fait partie des objets concernés par le mode du porteur
+        if cls._match_with_mode(context, object_id, object_near_id):
+            # Et si les objet sont rangeable enssemble:
+            object_carried_id = context.metas.value.get(CARRY, object_id)
+            return cls._objects_types_match(context, object_carried_id, object_near_id)
+        return False
 
     @classmethod
     def get_put_position(cls, context, object_id, object_near_id):
 
     @staticmethod
     def _is_available_position(context, position):
-        # TODO: Pour le moment on ne regarde pas si ce sont tous des obj identique
+        if not context.position_is_penetrable(position):
+            return False
+
         count_obj_here = len(context.metas.list.get(POSITIONS, position, allow_empty=True))
-        # TODO: 5 est hardcode; de plus cette cntrainte (not brain) devrait dependre de l'objet, du contexte ...
-        if count_obj_here <= 5 and (context.position_is_penetrable(position) or position == (0, 0, 0)):  # TODO TEST !!!
+        if count_obj_here <= Core.get_configuration_manager().get('ant.put.max_objects_at_same_position', 5):
             return True
         return False
 
-    def done(self, obj, puted_object, context):
-        # TODO: Il faut refact/logique qqpart pour ca !! Genre Brain.done(PUT, ??)
+    def done(self, puted_object):
+        # TODO: lancer le choix d'un nouveau mode dans le brain.
         if isinstance(puted_object, Food):
-            obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
-            # TODO: TEST Depose au -1 pour des raisons de test. Plus tard ce sera des tas comme un autre !
-            puted_object.set_position((-1, 0, 0))
-
+            self._host.get_brain().switch_to_mode(MODE_EXPLO)

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

 from intelligine.simulation.object.brain.part.transport.TakeBrainPart import TakeBrainPart
 from intelligine.synergy.object.ressource.Ressource import Resource
-from intelligine.cst import MOVE_MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, \
-    MOVE_MODE_GOHOME, MOVE_MODE_NURSE, TYPE_NURSERY
+from intelligine.cst import MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, \
+    MODE_GOHOME, MODE_NURSE, TYPE_NURSERY, MODE_HOME
 
 
 class AntTakeBrainPart(TakeBrainPart):
 
     # TODO: methode __init_ pour la classe ? Pour surcharger ici.
     _mode_matches = {
-        MOVE_MODE_EXPLO: [TYPE_RESOURCE_EXPLOITABLE],
-        MOVE_MODE_NURSE: [TYPE_NURSERY],
-        MOVE_MODE_GOHOME: []
+        MODE_EXPLO: [TYPE_RESOURCE_EXPLOITABLE],
+        MODE_NURSE: [TYPE_NURSERY],
+        MODE_GOHOME: []
     }
 
+    def __init__(self, host_brain):
+        super().__init__(host_brain)
+        self._smell_target = None
+
+    def get_smell_target(self):
+        if not self._smell_target:
+            raise Exception('No _smell_target')
+        return self._smell_target
+
     @classmethod
     def can_take(cls, context, object_id, object_to_take_id):
         # Pour le moment si le type de l'objet fait partie des types admis pour le mode courant du porteur, c'est bon.
         return cls._match_with_mode(context, object_id, object_to_take_id)
 
-    def done(self, obj, take_object, context):
+    def done(self, take_object):
         # TODO: Ranger ca ? Truc plus dynamique/configurable ?
+        # TODO: qqch plus generique ... (attention aux eggs)
         if isinstance(take_object, Resource):
-            obj.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
-            obj.get_movement_pheromone_gland().appose()
+            self._smell_target = self._host_brain.get_smell_for_object_taken(take_object)
+            self._host.get_brain().switch_to_mode(MODE_GOHOME)
+            self._host.get_movement_molecule_gland().appose()

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

-from intelligine.cst import MOVE_MODE, TYPE
+from intelligine.cst import MODE, TYPE
 from intelligine.simulation.object.brain.part.BrainPart import BrainPart
 
 
 class TransportBrainPart(BrainPart):
 
     _mode_matches = {}
+    _types_matches = {}
 
     @classmethod
     def _match_with_mode(cls, context, object_id, concerned_object_id):
-        move_mode = context.metas.value.get(MOVE_MODE, object_id)
+        move_mode = context.metas.value.get(MODE, object_id)
         for takable_type in cls._mode_matches[move_mode]:
             if context.metas.list.have(TYPE, concerned_object_id, takable_type, allow_empty=True):
                 return True
         return False
 
     @classmethod
-    def _objects_have_same_type(cls, context, object_carried_id, object_to_put_id):
-        object_carried_types = context.metas.list.get(TYPE, object_carried_id)
-        for object_carried_type in object_carried_types:
-            if context.metas.list.have(TYPE, object_to_put_id, object_carried_type):
-                return True
-        return False
+    def _objects_types_match(cls, context, object_a_id, object_b_id):
+        """
+
+        Retourne vrai si un des type de l'objet b se trouve dans la lise de type définis dans _types_matches pour
+        l'un des types de l'objet a.
+
+        :param context:
+        :param object_a_id:
+        :param object_b_id:
+        :return: bool
+        """
+        object_a_types = context.metas.list.get(TYPE, object_a_id)
+        object_b_types = context.metas.list.get(TYPE, object_b_id)
+
+        for object_a_type in object_a_types:
+            if object_a_type in cls._types_matches:
+                wanted_types = cls._types_matches[object_a_type]
+                for object_b_type in object_b_types:
+                    if object_b_type in wanted_types:
+                        return True
+
+        return False

intelligine/simulation/object/molecule/MoleculeGland.py

+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

+from intelligine.cst import MOLECULES_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(MOLECULES_DIRECTION,
+                        self._molecule_type,
+                        self._host.get_brain().get_distance_from_objective(),
+                        1)

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_pheromone(self):
-        """
-        :return: pheromone_type, 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

-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

-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

-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/Simulation.py

+from intelligine.simulation.molecule.Evaporation import Evaporation
+from synergine.core.Core import Core
 from synergine.synergy.Simulation import Simulation as BaseSimulation
 from synergine_xyz.cst import POSITIONS
 
 
 class Simulation(BaseSimulation):
 
+    _smells = []
+
+    @classmethod
+    def add_smell(cls, smell):
+        if smell not in cls._smells:
+            cls._smells.append(smell)
+
+    @classmethod
+    def get_smells(cls):
+        return cls._smells
+
     def end_cycle(self, context):
-        if context.get_cycle() % 100 is 0:
+        clean_each_cycle = Core.get_configuration_manager().get('engine.clean_each_cycle', 100)
+        evaporate_each_cycle = Core.get_configuration_manager().get('stigmergy.molecule.evaporate_each_cycle', 100)
+
+        if context.get_cycle() % clean_each_cycle is 0:
             context.metas.list.clean(POSITIONS)
+
+        if context.get_cycle() % evaporate_each_cycle is 0:
+            self._evaporate(context)
+
+    def _evaporate(self, context):
+        evaporation_increment = Core.get_configuration_manager().get('stigmergy.molecule.evaporate_decrement', 5)
+        evaporation_min_age = Core.get_configuration_manager().get('stigmergy.molecule.evaporate_min_age', 100)
+        evaporation = Evaporation(context,
+                                  evaporation_increment,
+                                  molecules_exclude_types=self.get_smells(),
+                                  molecule_minimum_age=evaporation_min_age)
+        evaporation.evaporate()

intelligine/synergy/event/Event.py

 
 
 class Event(BaseEvent):
-
-    @classmethod
-    def _get_brain_part(cls, context, object_id, brain_part_name):
-        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
-        return object_brain_schema[brain_part_name]
+    pass

intelligine/synergy/event/attack/NearAttackableEvent.py

 from intelligine.core.exceptions import NearNothingFound
+from intelligine.shorcut.brain import get_brain_part
 from synergine.core.exceptions import NotConcernedEvent
 from intelligine.synergy.event.src.NearEvent import NearEvent
 from synergine_xyz.mechanism.AroundMechanism import AroundMechanism
         except NearNothingFound:
             raise NotConcernedEvent()
 
-        brain_part = self._get_brain_part(context, object_id, BRAIN_PART_ATTACK)
+        brain_part = get_brain_part(context, object_id, BRAIN_PART_ATTACK)
         if not brain_part.can_attack(context, object_id, parameters[self._near_name][0]):
             raise NotConcernedEvent()
 

intelligine/synergy/event/move/MoveAction.py

 
         obj.set_position(self._parameters[MoveEvent.PARAM_POSITION])
         obj.set_previous_direction(self._parameters[MoveEvent.PARAM_DIRECTION])
-        obj.get_brain().get_part(BRAIN_PART_MOVE).done(obj, context)
+        obj.get_brain().get_part(BRAIN_PART_MOVE).done()

intelligine/synergy/event/move/MoveEvent.py

 from intelligine.core.exceptions import UnableToFoundMovement
 from intelligine.synergy.event.move.direction import get_position_with_direction_decal
+from intelligine.shorcut.brain import get_brain_part
 from synergine.core.exceptions import NotConcernedEvent
 from intelligine.synergy.event.Event import Event
 from synergine.core.simulation.mechanism.Mechanism import Mechanism
         return parameters
 
     def _get_direction(self, object_id, context):
-        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
-        object_move_brain_part = object_brain_schema[BRAIN_PART_MOVE]
+        object_move_brain_part = get_brain_part(context, object_id, BRAIN_PART_MOVE)
         return object_move_brain_part.get_direction(context, object_id)
 
     @staticmethod

intelligine/synergy/event/move/direction.py

 directions_under_level = (1, 2, 3, 4, 5, 6, 7, 8, 9)
 directions_same_level = (10, 11, 12, 13, 15, 16, 17, 18)
 directions_upper_level = (19, 20, 21, 22, 23, 24, 25, 26, 27)
+
+directions_by_levels = (directions_under_level, directions_same_level, directions_upper_level)
+
 directions_modifiers = {
     # (z, x, y)
     1: (-1, -1, -1),
     (202.5, 247.5): 16,
     (247.5, 292.5): 13,
     (292.5, 337.5): 10,
+    (337.5, 360): 11,
     (337.5, 0): 11
 }
 
     for plage in directions_degrees:
         if plage[0] <= degrees <= plage[1]:
             return directions_degrees[plage]
-    raise Exception("Unknow plage for degree \"" + degrees + '"')
+    raise Exception("Unknow plage for degree \"" + str(degrees) + '"')
 
 
 """

intelligine/synergy/event/smell/SmellAction.py

-from intelligine.cst import POINT_SMELL, POINTS_SMELL
+from intelligine.core.exceptions import BestMoleculeHere
+from intelligine.cst import POINT_SMELL, POINTS_SMELL, MOLECULES_INFOS, MOLECULES_DIRECTION, SMELL_FOOD, SMELL_EGG, \
+    PHEROMON_DIR_EXPLO
+from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
+from intelligine.simulation.molecule.Evaporation import Evaporation
+from intelligine.simulation.molecule.Molecule import Molecule
 from intelligine.synergy.event.smell.SmellEvent import SmellEvent
 from synergine.synergy.event.Action import Action
 
 
     @classmethod
     def cycle_pre_run(cls, context, synergy_manager):
-        smell_positions = context.metas.list.get(POINTS_SMELL, POINTS_SMELL, allow_empty=True)
-        for smell_position in smell_positions:
-            context.metas.value.unset(POINT_SMELL, smell_position)
-        context.metas.list.unset(POINTS_SMELL, POINTS_SMELL, allow_empty=True)
+        evaporation = Evaporation(context, molecules_include_types=[SMELL_FOOD, SMELL_EGG])
+        evaporation.remove()
 
     def run(self, obj, context, synergy_manager):
 
         smell_type = obj.get_smell()
 
         for smell_point in points_distances:
-
-            where_to_put_smells = context.metas.value.get(POINT_SMELL, smell_point, allow_empty=True, empty_value={})
-            current_point_smell = points_distances[smell_point]
-
-            if smell_type not in where_to_put_smells:
-                where_to_put_smells[smell_type] = current_point_smell
-            else:
-                where_to_put_smell = where_to_put_smells[smell_type]
-                if current_point_smell < where_to_put_smell:
-                    where_to_put_smells[smell_type] = where_to_put_smell
-
-            context.metas.value.set(POINT_SMELL, smell_point, where_to_put_smells)
-            context.metas.list.add(POINTS_SMELL, POINTS_SMELL, smell_point, assert_not_in=False)
+            distance = points_distances[smell_point]
+            molecule = Molecule(MOLECULES_DIRECTION, smell_type, distance)
+
+            try:
+                DirectionMolecule.appose(context, smell_point, molecule)
+            except BestMoleculeHere:
+                pass  # TODO: Pas l'inverse ? A voir apres avoir fix la disparition.
+
+            #
+            # current_point_smell = points_distances[smell_point]
+            # where_to_put_smells = context.metas.value.get(POINT_SMELL, smell_point, allow_empty=True, empty_value={})
+            #
+            #
+            # if smell_type not in where_to_put_smells:
+            #     where_to_put_smells[smell_type] = current_point_smell
+            # else:
+            #     where_to_put_smell = where_to_put_smells[smell_type]
+            #     if current_point_smell < where_to_put_smell:
+            #         where_to_put_smells[smell_type] = where_to_put_smell
+            #
+            # context.metas.value.set(POINT_SMELL, smell_point, where_to_put_smells)
+            # context.metas.list.add(POINTS_SMELL, POINTS_SMELL, smell_point, assert_not_in=False)

intelligine/synergy/event/smell/SmellEvent.py

-from intelligine.cst import COL_SMELL
+from intelligine.cst import COL_SMELL, CARRIED_BY
 from intelligine.mechanism.TraversableDistanceFromMechanism import TraversableDistanceFromMechanism
 from intelligine.synergy.event.Event import Event
 from synergine.core.exceptions import NotConcernedEvent
     _first_cycle_force = True
 
     def _prepare(self, object_id, context, parameters={}):
-        if not parameters['points_distances']:
+        if not parameters['points_distances'] or not self._concerned_object(context, object_id):
             raise NotConcernedEvent()
 
         return parameters
+
+    def _concerned_object(self, context, object_id):
+        # TODO: Un peu hardcodé etant donné que cet event concerne tout les COL_SMELL et pas que les transportable ...
+        return not context.metas.value.get(CARRIED_BY, object_id, allow_empty=True, empty_value=False)

intelligine/synergy/event/transport/PutableAction.py

 from intelligine.synergy.event.move.MoveAction import MoveAction
+from intelligine.synergy.object.Food import Food
 from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.transport.PutableEvent import PutableEvent
 from intelligine.cst import CANT_CARRY_STILL, BRAIN_PART_PUT
         obj_transported = obj.get_carried()
 
         obj_transported.set_carried_by(None)
-        #  TODO: re controle de si posable ? (5 max etc)
+        #  TODO: re controle de si posable ? La position a été calculé
+        #  dans le process. Ce qui fait que la situation peut avoir changer.
+        # Soit: Recalculer d'office BrainPut.cant_put_at.. Soit le recalculer que si le hash
+        # de ce qu'il y a la a changer ?
         obj.put_carry(obj_transported, position_to_put)
         context.metas.value.set(CANT_CARRY_STILL, obj.get_id(), 5)
 
-        obj.get_brain().get_part(BRAIN_PART_PUT).done(obj, obj_transported, context)
+        obj.get_brain().get_part(BRAIN_PART_PUT).done(obj_transported)
+
+        # TODO: DEBUG
+        if isinstance(obj_transported, Food):
+            obj_transported.set_position((-1, 0, 0))

intelligine/synergy/event/transport/PutableEvent.py

 from intelligine.core.exceptions import NearNothingFound, CantFindWhereToPut
+from intelligine.shorcut.brain import get_brain_part
 from intelligine.synergy.event.src.NearEvent import NearEvent
 from synergine.core.exceptions import NotConcernedEvent
 from intelligine.cst import CANT_PUT_STILL, COL_TRANSPORTER_CARRYING, TRANSPORTABLE, BRAIN_SCHEMA, BRAIN_PART_PUT
             raise NotConcernedEvent()
 
         object_near_id = parameters[self._near_name][0]
-        brain_part = self._get_brain_part(context, object_id, BRAIN_PART_PUT)
+        brain_part = get_brain_part(context, object_id, BRAIN_PART_PUT)
 
         if not brain_part.can_put(context, object_id, object_near_id):
             raise NotConcernedEvent()
 
     @classmethod
     def _object_can_put(cls, object_id, context, object_to_put_id):
-        object_take_brain_part = cls._get_brain_part(context, object_id, BRAIN_PART_PUT)
+        object_take_brain_part = get_brain_part(context, object_id, BRAIN_PART_PUT)
         return object_take_brain_part.can_put(context, object_id, object_to_put_id)

intelligine/synergy/event/transport/TakeableAction.py

         obj.carry(obj_carried)
         cant_put_still = Core.get_configuration_manager().get('ant.take.cant_put_still')
         context.metas.value.set(CANT_PUT_STILL, obj.get_id(), cant_put_still)
-        obj.get_brain().get_part(BRAIN_PART_TAKE).done(obj, obj_carried, context)
+        obj.get_brain().get_part(BRAIN_PART_TAKE).done(obj_carried)

intelligine/synergy/event/transport/TakeableEvent.py

 from intelligine.core.exceptions import NearNothingFound
+from intelligine.shorcut.brain import get_brain_part
 from synergine.core.exceptions import NotConcernedEvent
 from intelligine.synergy.event.src.NearEvent import NearEvent
 from synergine_xyz.mechanism.AroundMechanism import AroundMechanism
 
     @classmethod
     def _object_can_take(cls, object_id, context, object_to_take_id):
-        object_take_brain_part = cls._get_brain_part(context, object_id, BRAIN_PART_TAKE)
-        return object_take_brain_part.can_take(context, object_id, object_to_take_id)
+        object_take_brain_part = get_brain_part(context, object_id, BRAIN_PART_TAKE)
+        return object_take_brain_part.can_take(context, object_id, object_to_take_id)

intelligine/synergy/object/BaseBug.py

 from intelligine.core.exceptions import BodyPartAlreadyExist
 from intelligine.synergy.object.Transportable import Transportable
-from intelligine.cst import COL_ALIVE, COLONY, ACTION_DIE
+from intelligine.cst import COL_ALIVE, COLONY, ACTION_DIE, BRAIN
 from intelligine.simulation.object.brain.Brain import Brain
 from intelligine.cst import ALIVE, ATTACKABLE
 from synergine.core.Signals import Signals
 class BaseBug(Transportable):
 
     _body_parts = {}
+    _brain_class = Brain
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
         self._life_points = 10
         self._alive = True
         self._movements_count = -1
-        self._brain = self._get_brain_instance()
+        self._brain = self._brain_class(self._context, self)
+        self._context.metas.value.set(BRAIN, self.__class__, self._brain_class)
         self._parts = {}
         self._init_parts()
 
     def get_movements_count(self):
         return self._movements_count
 
-    def _get_brain_instance(self):
-        return Brain(self._context, self)
-
     def get_brain(self):
         return self._brain

intelligine/synergy/object/Egg.py

 from intelligine.synergy.object.BaseBug import BaseBug
-from intelligine.cst import TYPE_NURSERY, TYPE, SMELL_EGG
+from intelligine.cst import TYPE_NURSERY, TYPE, SMELL_EGG, COL_SMELL
 
 
 class Egg(BaseBug):
         super().__init__(collection, context)
         context.metas.list.add(TYPE, self.get_id(), TYPE_NURSERY)
         self._life_points = 1
+        self._add_col(COL_SMELL)
         self._set_smell(SMELL_EGG)

intelligine/synergy/object/StockedFood.py

-from intelligine.cst import TYPE, TYPE_RESOURCE_EXPLOITABLE, COL_EATABLE, COL_SMELL, SMELL_FOOD
+from intelligine.cst import TYPE, TYPE_RESOURCE_EXPLOITABLE, COL_EATABLE, COL_SMELL, SMELL_FOOD, TYPE_RESOURCE_EATABLE
 from intelligine.synergy.object.Food import Food
 
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
         context.metas.list.remove(TYPE, self.get_id(), TYPE_RESOURCE_EXPLOITABLE)
+        context.metas.list.add(TYPE, self.get_id(), TYPE_RESOURCE_EATABLE)
         self._add_col(COL_EATABLE)
         self._add_col(COL_SMELL)
         self._set_smell(SMELL_FOOD)

intelligine/synergy/object/SynergyObject.py

-from intelligine.cst import OBJ_SMELL
+from intelligine.cst import OBJ_SMELL, INSTANCE_CLASS
+from intelligine.synergy.Simulation import Simulation
 from synergine_xyz.SynergyObject import SynergyObject as XyzSynergyObject
 
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
         self._smell = None
+        context.metas.value.set(INSTANCE_CLASS, self.get_id(), self.__class__)
 
     def _set_smell(self, smell_type):
         self._smell = smell_type
         self._context.metas.value.set(OBJ_SMELL, self.get_id(), smell_type)
+        Simulation.add_smell(smell_type)
 
     def get_smell(self):
         if not self._smell:

intelligine/synergy/object/Transportable.py

-from intelligine.cst import TRANSPORTABLE, CARRIED
+from intelligine.cst import TRANSPORTABLE, CARRIED_BY, CARRY
 from intelligine.synergy.object.SynergyObject import SynergyObject
 
 
     def set_is_carried(self, is_carried, by_obj):
         self._is_carried = bool(is_carried)
         if self._is_carried:
-            self._context.metas.value.set(CARRIED, subject=by_obj.get_id(), value=self.get_id())
+            self._context.metas.value.set(CARRIED_BY, self.get_id(), by_obj.get_id())
         else:
-            self._context.metas.value.unset(CARRIED, subject=by_obj.get_id())
+            self._context.metas.value.unset(CARRIED_BY, self.get_id())

intelligine/synergy/object/ant/Ant.py

-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
+    COL_FIGHTER, MODE_EXPLO, MODE_GOHOME, BODY_PART_PHEROMONE_GLAND, TYPE, TYPE_ANT, \
+    COL_TRANSPORTER_CARRYING, MODE_NURSE, MODE_HOME, CARRY
 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
     }
+    _brain_class = AntBrain
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
                                                            COL_TRANSPORTER_NOT_CARRYING,
                                                            COL_FIGHTER])
         self._carried = None
-        self._brain.switch_to_mode(MOVE_MODE_EXPLO)
+        #  TODO: Comme pour lorsque une action put est faite, lancer un algo de choix de la mission a suivre.
+        self._brain.switch_to_mode(MODE_EXPLO)
         context.metas.list.add(TYPE, self.get_id(), TYPE_ANT)
 
     def die(self):
         self._remove_col(COL_TRANSPORTER_CARRYING, allow_not_in=True)
         self._remove_col(COL_FIGHTER)
 
-    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):
         obj.set_position(position)
         obj.set_is_carried(False, self)
         self._context.metas.states.remove(self.get_id(), CARRYING)
+        self._context.metas.value.unset(CARRY, self.get_id())
         self._add_col(COL_TRANSPORTER_NOT_CARRYING)
         self._remove_col(COL_TRANSPORTER_CARRYING)
 
         self._add_col(COL_TRANSPORTER_CARRYING)
         self._remove_col(COL_TRANSPORTER_NOT_CARRYING)
         obj.set_is_carried(True, self)
+        self._context.metas.value.set(CARRY, self.get_id(), obj.get_id())
         # 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_brain().switch_to_mode(MODE_GOHOME)
+            self.get_movement_molecule_gland().appose()
 
     def is_carrying(self):
         if self._carried:
 
     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

+from intelligine.core.exceptions import BestMoleculeHere, NoMolecule
+from intelligine.cst import MOLECULES_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(MOLECULES_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(MOLECULES_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, cycle_age):
+        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(),
+                                         cycle_age=cycle_age)
+
+        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

-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/bypass/TestByPass.py

+from intelligine.synergy.Colony import Colony
+from intelligine.synergy.object.ant.Ant import Ant
+from intelligine.tests.src.simulation.SimpleTestWorld1Simulation import SimpleTestWorld1Simulation
+
+
+class TestByPass(SimpleTestWorld1Simulation):
+
+    _ant_move_history = []
+    _assert_ant_move_history = [(0, 21, 20), (0, 21, 19), (0, 21, 18), (0, 21, 17), (0, 21, 16), (0, 21, 15), (0, 21, 14), (0, 21, 14), (0, 22, 13), (0, 23, 12), (0, 24, 11), (0, 24, 11), (0, 24, 11), (0, 24, 11), (0, 24, 11), (0, 23, 11), (0, 22, 11), (0, 21, 11), (0, 21, 11), (0, 21, 11), (0, 21, 11), (0, 21, 11), (0, 22, 12), (0, 23, 13), (0, 24, 14), (0, 24, 14), (0, 24, 14), (0, 24, 14), (0, 24, 14), (0, 23, 15), (0, 22, 16), (0, 21, 17), (0, 21, 17), (0, 21, 17), (0, 21, 17), (0, 21, 17), (0, 21, 16), (0, 21, 15), (0, 21, 14), (0, 21, 13), (0, 21, 12), (0, 21, 11), (0, 21, 10), (0, 21, 9), (0, 21, 8), (0, 21, 7), (0, 21, 6), (0, 21, 5), (0, 21, 4), (0, 21, 3), (0, 22, 2), (0, 23, 1), (0, 23, 1), (0, 23, 1), (0, 23, 1), (0, 23, 1), (0, 22, 1), (0, 21, 1), (0, 20, 1), (0, 19, 1), (0, 18, 1), (0, 17, 1), (0, 16, 1), (0, 15, 1), (0, 14, 1), (0, 13, 1), (0, 12, 1), (0, 11, 1), (0, 10, 1), (0, 9, 1), (0, 8, 2), (0, 7, 2), (0, 6, 3), (0, 5, 4), (0, 4, 5), (0, 3, 5), (0, 4, 6), (0, 5, 7), (0, 6, 8), (0, 7, 9), (0, 8, 10), (0, 9, 11), (0, 10, 12), (0, 11, 13), (0, 11, 14), (0, 12, 15), (0, 13, 16), (0, 14, 17), (0, 15, 17), (0, 16, 17), (0, 17, 17), (0, 18, 17), (0, 19, 17), (0, 19, 16), (0, 19, 15), (0, 19, 14), (0, 19, 13), (0, 19, 12), (0, 19, 11), (0, 19, 10), (0, 19, 9), (0, 18, 9), (0, 17, 9), (0, 16, 9), (0, 15, 9), (0, 14, 9), (0, 13, 9), (0, 13, 10), (0, 13, 11), (0, 13, 12), (0, 13, 13), (0, 14, 13), (0, 15, 13), (0, 16, 13), (0, 17, 13), (0, 17, 14), (0, 16, 15), (0, 15, 15), (0, 14, 15), (0, 13, 15), (0, 14, 15), (0, 15, 15), (0, 16, 15), (0, 17, 15), (0, 17, 14), (0, 16, 13), (0, 15, 13), (0, 14, 13), (0, 13, 13), (0, 13, 12), (0, 13, 11), (0, 13, 10), (0, 13, 9), (0, 14, 9), (0, 15, 9), (0, 16, 9), (0, 17, 9), (0, 18, 9), (0, 19, 9), (0, 19, 10), (0, 19, 11), (0, 19, 12), (0, 19, 13), (0, 19, 14), (0, 19, 15), (0, 19, 16), (0, 19, 17), (0, 18, 17), (0, 17, 17), (0, 16, 17), (0, 15, 17), (0, 14, 17), (0, 13, 17), (0, 12, 17), (0, 11, 17), (0, 10, 17), (0, 9, 17), (0, 8, 17), (0, 7, 17), (0, 6, 17), (0, 5, 17), (0, 4, 17), (0, 3, 17), (0, 2, 17), (0, 1, 17), (0, 1, 16), (0, 1, 15), (0, 1, 14), (0, 1, 13), (0, 1, 12), (0, 1, 11), (0, 1, 10), (0, 1, 9), (0, 1, 8), (0, 1, 7), (0, 1, 6), (0, 1, 5), (0, 1, 4), (0, 1, 3), (0, 1, 2), (0, 1, 1), (0, 2, 1), (0, 3, 1), (0, 4, 1), (0, 5, 1), (0, 6, 1), (0, 7, 1), (0, 8, 1), (0, 9, 1), (0, 10, 1), (0, 11, 1), (0, 12, 1), (0, 13, 1), (0, 14, 1), (0, 15, 1), (0, 16, 1), (0, 17, 1), (0, 18, 1), (0, 19, 1), (0, 20, 1), (0, 21, 1), (0, 22, 1), (0, 23, 1), (0, 24, 1), (0, 24, 2), (0, 24, 3), (0, 24, 4), (0, 24, 5), (0, 24, 6), (0, 24, 7), (0, 24, 8), (0, 24, 9), (0, 24, 10), (0, 24, 11), (0, 24, 12), (0, 24, 13), (0, 24, 14), (0, 24, 15), (0, 24, 16), (0, 24, 17), (0, 23, 17), (0, 22, 17), (0, 21, 17), (0, 21, 18), (0, 21, 19), (0, 21, 20), (0, 21, 21), (0, 20, 22), (0, 19, 22), (0, 18, 23), (0, 18, 24), (0, 18, 23), (0, 19, 22), (0, 20, 22), (0, 21, 21), (0, 21, 20), (0, 21, 19), (0, 21, 18), (0, 22, 17), (0, 23, 17), (0, 24, 16), (0, 24, 15), (0, 24, 14), (0, 24, 13), (0, 24, 12), (0, 24, 11), (0, 24, 10), (0, 24, 9), (0, 24, 8), (0, 24, 7), (0, 24, 6), (0, 24, 5), (0, 24, 4), (0, 24, 3), (0, 24, 2), (0, 23, 1), (0, 22, 1), (0, 21, 1), (0, 20, 1), (0, 19, 1), (0, 18, 1), (0, 17, 1), (0, 16, 1), (0, 15, 1), (0, 14, 1), (0, 13, 1), (0, 12, 1), (0, 11, 1), (0, 10, 1), (0, 9, 1), (0, 8, 1), (0, 7, 1), (0, 6, 1), (0, 7, 2), (0, 8, 3), (0, 9, 4), (0, 10, 5), (0, 11, 6), (0, 12, 7), (0, 13, 7), (0, 14, 7), (0, 15, 7), (0, 16, 7), (0, 17, 7), (0, 18, 7), (0, 19, 7), (0, 20, 7), (0, 21, 7), (0, 21, 8), (0, 21, 9), (0, 21, 10), (0, 21, 11), (0, 21, 12), (0, 21, 13), (0, 21, 14), (0, 21, 15), (0, 21, 16), (0, 21, 17), (0, 21, 18), (0, 21, 19), (0, 21, 20)]
+
+    def setUp(self):
+        super().setUp()
+        self._ant_move_history = []
+
+    def test_simulation_road(self):
+        self._connection.receive_callback = self._record_ant_moves
+        self._run_and_get_core(300)
+        self.assertEquals(self._assert_ant_move_history, self._ant_move_history)
+
+    def _record_ant_moves(self, terminal, actions_done):
+        collections = terminal.get_synergy_manager().get_simulations()[0].get_collections()
+        for collection in collections:
+            if isinstance(collection, Colony):
+                ant = collection.get_objects()[0]
+                self.assertIsInstance(ant, Ant)
+                self._ant_move_history.append(ant.get_position())

intelligine/tests/simulation/mode/TestChangeMode.py

-from os import getcwd
-from sys import path as ppath
-from intelligine.core.exceptions import NoPheromone
-
-ppath.insert(1,getcwd()+'/modules')
-
-
+from intelligine.synergy.Environment import Environment
 from intelligine.synergy.object.Food import Food
+from intelligine.synergy.object.StockedFood import StockedFood
 from intelligine.tests.simulation.mode.Base import Base
 from intelligine.synergy.Colony import Colony
 from intelligine.synergy.Simulation import Simulation
 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 PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO
+from intelligine.cst import MODE_EXPLO, MODE_GOHOME, MODE, MODE_HOME, PHEROMON_DIR_NONE
+from intelligine.cst import PHEROMON_DIR_EXPLO
 
 
 class TestChangeMode(Base):
 
-    def __init__(self, methodName='runTest'):
-        super().__init__(methodName)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.ant = None
         self.food = None
         self._force_move = self._force_move
 
     @staticmethod
     def _force_move(self_move_action, object_id, context):
-        object_movement_mode = context.metas.value.get(MOVE_MODE, object_id)
-        if object_movement_mode == MOVE_MODE_GOHOME:
+        object_movement_mode = context.metas.value.get(MODE, object_id)
+        if object_movement_mode == MODE_GOHOME or object_movement_mode == MODE_HOME:
             return SOUTH
         return NORTH
 
     def _get_set_up_simulations(self):
-        return [Simulation([self._get_colony(), self._get_foods()])]
+        return [Simulation([self._get_colony(), self._get_foods(), self._get_environment()])]
 
     def _get_colony(self):
         test_case = self
             def get_start_objects(self, collection, context):
                 foods = []
                 food = Food(collection, context)
-                food.set_position((0, 0, -3))
-                #  TEST (en attendant d'avoir des algo pour deposer dans un depot)
-                food1 = Food(collection, context)
-                food1.set_position((0, 0, -1))
-                food1.is_takable = lambda: False
-                foods.append(food1)
+                stocked_food = StockedFood(collection, context)
+                food.set_position((0, 0, -20))
+                stocked_food.set_position((0, 0, 0))
+                foods.append(stocked_food)
                 foods.append(food)
                 test_case.food = food
                 return foods
         return FoodConfiguration()
 
+    def _get_environment(self):
+        class TestEnvironment(Environment):
+            pass
+        return TestEnvironment(self._get_environment_configuration())
+
+    def _get_environment_configuration(self):
+        class TestEnvironmentConfiguration(Configuration):
+            pass
+        return TestEnvironmentConfiguration()
+
     def _get_core_configuration(self, cycles, main_process=True):
         config = super()._get_core_configuration(cycles, main_process)
         config.update({
     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(MODE_EXPLO, self.ant.get_brain().get_movement_mode())
         self.assertFalse(self.ant.is_carrying())
 
         self._run_and_get_core(1)
         self.assertEquals((0, 0, -1), self.ant.get_position())
-        self.assertEquals(MOVE_MODE_EXPLO, self.ant.get_brain().get_movement_mode())
+        self.assertEquals(MODE_EXPLO, self.ant.get_brain().get_movement_mode())
         self.assertFalse(self.ant.is_carrying())
 
         # Ant has take Food piece
-        self._run_and_get_core(2)
-        self.assertEquals((0, 0, -2), self.ant.get_position())
+        self._run_and_get_core(19)
+        self.assertEquals((0, 0, -19), self.ant.get_position())
         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()))
-        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())
+        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(MODE_GOHOME, self.ant.get_brain().get_movement_mode())
+        self.assertEquals(PHEROMON_DIR_EXPLO, self.ant.get_movement_molecule_gland().get_molecule_type())
+
+        self._run_and_get_core(32)
+        self.assertEquals((0, 0, -6), self.ant.get_position())
+        self.assertTrue(self.ant.is_carrying())
+        self.assertEquals(MODE_HOME, self.ant.get_brain().get_movement_mode())
 
-        self._run_and_get_core(3)
-        self.assertEquals((0, 0, -1), self.ant.get_position())
+        self._run_and_get_core(33)
+        self.assertEquals((0, 0, -5), self.ant.get_position())
         self.assertTrue(self.ant.is_carrying())
+        self.assertEquals(MODE_HOME, self.ant.get_brain().get_movement_mode())
 
-        self._run_and_get_core(4)
-        self.assertEquals((0, 0, 0), self.ant.get_position())
-        # Ant has put his food piece
+        self._run_and_get_core(34)
+        self.assertEquals((0, 0, -4), self.ant.get_position())
+        self.assertEquals(MODE_HOME, self.ant.get_brain().get_movement_mode())
+
+        self._run_and_get_core(37)
+        self.assertEquals((0, 0, -1), self.ant.get_position())
+        # Ant has NOT put his food piece
+        self.assertFalse(self.ant.is_carrying())
+
+        self._run_and_get_core(38)
+        self.assertEquals((0, 0, -2), self.ant.get_position())
         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())

intelligine/tests/simulation/molecule/TestDirection.py

+from intelligine.core.exceptions import NoMolecule
+from intelligine.simulation.molecule.Molecule import Molecule
+from intelligine.simulation.molecule.MoleculeFlavour import MoleculeFlavour
+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 MOLECULES_DIRECTION, PHEROMON_DIR_EXPLO, PHEROMON_DIR_NONE
+from intelligine.synergy.event.move.direction import NORTH, NORTH_EST, EST, SOUTH_EST, SOUTH, SOUTH_WEST, WEST, \
+    NORTH_WEST, CENTER
+from intelligine.synergy.event.move.direction import get_position_with_direction_decal as _p
+
+
+class TestDirection(Base):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._context = Context()
+
+    def setUp(self):
+        self._context = Context()
+
+    def _set_up_molecules(self, molecules, re_init=True):
+        if re_init:
+            self._context = Context()
+        for position in molecules:
+            self._context.molecules().set_flavour(position, MoleculeFlavour.new_from_raw_data(molecules[position]))
+
+    def _test_direction_for_point(self, molecules, direction, molecule_type=PHEROMON_DIR_EXPLO,
+                                  reference_point=_p(CENTER), re_init=True):
+        """
+
+        :param molecules:
+        :param direction:
+        :param molecule_type:
+        :param reference_point:
+        :return:
+        """
+        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, molecules, direction, molecule_type=PHEROMON_DIR_EXPLO,
+                                   reference_point=_p(CENTER), re_init=True):
+        """
+
+        :param molecules:
+        :param direction:
+        :param molecule_type:
+        :param reference_point:
+        :return:
+        """
+        self._set_up_molecules(molecules, re_init=re_init)
+        around_points = self._context.get_around_points_of_point(reference_point)
+        direction_tested = DirectionMolecule.get_best_molecule_direction_in(self._context,
+                                                                              reference_point,
+                                                                              around_points,
+                                                                              molecule_type)
+        self.assertEqual(direction, direction_tested, "Direction must be %s" % direction)
+
+    def test_route_direct_route(self):
+        """
+        Test easy direction with 1 best molecules just near actual position
+        :return:
+        """
+        test_data = {
+            NORTH_WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            },
+            NORTH: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(NORTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            },
+            NORTH_EST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(NORTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            },
+            WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            },
+            EST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            },
+            SOUTH_WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(SOUTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            },
+            SOUTH: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(SOUTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            },
+            SOUTH_EST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}}
+            }
+        }
+
+        for direction_wanted in test_data:
+            self._test_direction_for_point(test_data[direction_wanted], direction_wanted)
+
+    def test_route_with_multiple_same_intensity(self):
+        """
+        Test find route in middle of multiple molecules
+        :return:
+        """
+        test_data = {
+            NORTH_WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1, 0)}}
+            },
+            NORTH_WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1, 0)}},
+                _p(SOUTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1, 0)}}
+            },
+            NORTH_WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1, 0)}},
+                _p(SOUTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_NONE: (8, 1, 0)}}
+            },
+        }
+
+        for direction_wanted in test_data:
+            self._test_direction_for_point(test_data[direction_wanted], direction_wanted)
+
+    def test_route_with_multiple_different_intensity(self):
+        """
+        Test find route in middle of multiple molecules
+        :return:
+        """
+        test_data = {
+            NORTH_WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 2, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (8, 1, 0)}}
+            },
+            NORTH_WEST: {
+                _p(CENTER): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 2, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (8, 1, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_NONE: (5, 10, 0)}}  # an other molecule type
+            }
+        }
+
+        for direction_wanted in test_data:
+            self._test_direction_for_point(test_data[direction_wanted], direction_wanted)
+
+    def test_direction_direct(self):
+        test_data = {
+            NORTH: {
+                _p(NORTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2, 0)}}
+            },
+            NORTH: {
+                _p(NORTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_NONE: (9, 500, 0)}}  # An other molecule type
+            }
+        }
+
+        for direction in test_data:
+            self._test_direction_for_points(test_data[direction], direction)
+
+    def test_direction_with_multiple_intensity(self):
+        test_data = {
+            NORTH: {
+                _p(NORTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 5, 0)}},
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4, 0)}}
+            },
+            NORTH: {
+                _p(NORTH): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 5, 0)}},
+                _p(WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_NONE: (9, 500, 0)}},  # An other molecule_type
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4, 0)}},
+                _p(NORTH_WEST): {MOLECULES_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4, 0)}}
+            }
+        }
+
+        for direction in test_data:
+            self._test_direction_for_points(test_data[direction], direction)
+
+    def test_no_molecules_around(self):
+        # No molecule
+        with self.assertRaises(NoMolecule):
+            self._test_direction_for_points({}, -1)
+
+        # Wrong molecule type
+        with self.assertRaises(NoMolecule):
+            self._test_direction_for_points({
+                _p(SOUTH_EST): {MOLECULES_DIRECTION: {PHEROMON_DIR_NONE: (9, 5, 0)}}
+            }, -1)
+
+    def test_appose(self):
+        self._test_point_raise_no_molecule()
+        self._test_points_raise_no_molecule()
+
+        # Une molecule au centre
+        DirectionMolecule.appose(self._context,
+                                  _p(CENTER),
+                                  self._get_molecule(PHEROMON_DIR_EXPLO, 2))
+        # Ne permet pas de trouver une route
+        self._test_point_raise_no_molecule(re_init=False)
+        self._test_points_raise_no_molecule(re_init=False)
+
+        # Une molecule au nord
+        DirectionMolecule.appose(self._context,
+                                  _p(NORTH),
+                                  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_molecule(self, molecules={}, direction=-1, molecule_type=PHEROMON_DIR_EXPLO,
+                                 reference_point=_p(CENTER), re_init=True):
+        with self.assertRaises(NoMolecule):
+            self._test_direction_for_point(molecules, direction, re_init=re_init)
+
+    def _test_points_raise_no_molecule(self, molecules={}, direction=-1, molecule_type=PHEROMON_DIR_EXPLO,
+                                 reference_point=_p(CENTER), re_init=True):
+        with self.assertRaises(NoMolecule):
+            self._test_direction_for_points(molecules, direction, re_init=re_init)
+
+    def _get_molecule(self, type, distance):
+        return Molecule(MOLECULES_DIRECTION, type, distance=distance)

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')
-
-from intelligine.tests.simulation.pheromone.Base import Base
-from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
-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, \
-    NORTH_WEST, CENTER
-from intelligine.synergy.event.move.direction import get_position_with_direction_decal as _p
-
-
-class TestDirection(Base):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._context = Context()
-
-    def setUp(self):
-        self._context = Context()
-
-    def _set_up_pheromones(self, pheromones, 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]))
-
-    def _test_direction_for_point(self, pheromones, direction, pheromone_type=PHEROMON_DIR_EXPLO,
-                                  reference_point=_p(CENTER), re_init=True):
-        """
-
-        :param pheromones:
-        :param direction:
-        :param pheromone_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.assertEqual(direction, direction_tested, "Direction must be %s" % direction)
-
-    def _test_direction_for_points(self, pheromones, direction, pheromone_type=PHEROMON_DIR_EXPLO,
-                                   reference_point=_p(CENTER), re_init=True):
-        """
-
-        :param pheromones:
-        :param direction:
-        :param pheromone_type:
-        :param reference_point:
-        :return:
-        """
-        self._set_up_pheromones(pheromones, 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,
-                                                                              reference_point,
-                                                                              around_points,
-                                                                              pheromone_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
-        :return:
-        """
-        test_data = {
-            NORTH_WEST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            },
-            NORTH: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(NORTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            },
-            NORTH_EST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(NORTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            },
-            WEST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            },
-            EST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            },
-            SOUTH_WEST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(SOUTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            },
-            SOUTH: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(SOUTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            },
-            SOUTH_EST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}}
-            }
-        }
-
-        for direction_wanted in test_data:
-            self._test_direction_for_point(test_data[direction_wanted], direction_wanted)
-
-    def test_route_with_multiple_same_intensity(self):
-        """
-        Test find route in middle of multiple pheromones
-        :return:
-        """
-        test_data = {
-            NORTH_WEST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}},
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1)}}
-            },
-            NORTH_WEST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}},
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1)}},
-                _p(SOUTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1)}}
-            },
-            NORTH_WEST: {
-                _p(CENTER): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (10, 1)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 1)}},
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (12, 1)}},
-                _p(SOUTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (8, 1)}}
-            },
-        }
-
-        for direction_wanted in test_data:
-            self._test_direction_for_point(test_data[direction_wanted], direction_wanted)
-
-    def test_route_with_multiple_different_intensity(self):
-        """
-        Test find route in middle of multiple pheromones
-        :return:
-        """
-        test_data = {
-            NORTH_WEST: {
-                _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)}}
-            },
-            NORTH_WEST: {
-                _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
-            }
-        }
-
-        for direction_wanted in test_data:
-            self._test_direction_for_point(test_data[direction_wanted], direction_wanted)
-
-    def test_direction_direct(self):
-        test_data = {
-            NORTH: {
-                _p(NORTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2)}}
-            },
-            NORTH: {
-                _p(NORTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 2)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 500)}}  # An other pheromone type
-            }
-        }
-
-        for direction in test_data:
-            self._test_direction_for_points(test_data[direction], direction)
-
-    def test_direction_with_multiple_intensity(self):
-        test_data = {
-            NORTH: {
-                _p(NORTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 5)}},
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4)}}
-            },
-            NORTH: {
-                _p(NORTH): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 5)}},
-                _p(WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 500)}},  # An other pheromone_type
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4)}},
-                _p(NORTH_WEST): {PHEROMON_DIRECTION: {PHEROMON_DIR_EXPLO: (9, 4)}}
-            }
-        }
-
-        for direction in test_data:
-            self._test_direction_for_points(test_data[direction], direction)
-
-    def test_no_pheromones_around(self):
-        # No pheromone
-        try:  # WTF ?
-            self.assertRaises(NoPheromone, self._test_direction_for_points({}, -1))
-        except NoPheromone:
-            self.assertTrue(True)
-
-        # Wrong pheromone type
-        try:  # WTF ?
-            self.assertRaises(NoPheromone, self._test_direction_for_points({
-                _p(SOUTH_EST): {PHEROMON_DIRECTION: {PHEROMON_DIR_HOME: (9, 5)}}
-            }, -1))
-        except NoPheromone:
-            self.assertTrue(True)
-
-    def test_appose(self):
-        self._test_point_raise_no_pheromone()
-        self._test_points_raise_no_pheromone()
-
-        # Une pheromone au centre
-        DirectionPheromone.appose(self._context,
-                                  _p(CENTER),
-                                  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),
-                                  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)
-
-
-    def _test_point_raise_no_pheromone(self, pheromones={}, direction=-1, pheromone_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.assertTrue(True)
-
-    def _test_points_raise_no_pheromone(self, pheromones={}, direction=-1, pheromone_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.assertTrue(True)
-
-    def _get_pheromone(self, type, distance):
-        return Pheromone(PHEROMON_DIRECTION, type, distance=distance)

intelligine/tests/src/simulation/SimpleTestWorld1Simulation.py

+from intelligine.display.map import get_map_connector
+from intelligine.display.pygame.config import map_config
+from synergine.test.TestSimulation import TestSimulation
+from os import getcwd
+
+
+class SimpleTestWorld1Simulation(TestSimulation):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        map_connector = get_map_connector(
+            getcwd()+"/intelligine/tests/src/simulation/SimpleTestWorld1.tmx",
+            map_config
+        )
+        self._simulations = map_connector.create_simulations()
+
+    def _get_set_up_simulations(self):
+        return self._simulations

requirements.txt

-synergine>=0.0.1
-synergine_xyz>=0.0.1
+git+https://github.com/buxx/synergine.git
+git+https://github.com/buxx/synergine_xyz.git
+git+https://github.com/buxx/AntStar.git
+tmx==1.2.3
+Pillow==2.8.1

tests.py

 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',
+    'intelligine.tests.simulation.bypass.TestByPass.TestByPass',
 ]
 
 suite = unittest.TestSuite()

tests_requirements.txt

 git+http://github.com/buxx/synergine.git
 git+http://github.com/buxx/synergine_xyz.git
+git+https://github.com/buxx/AntStar.git
+tmx==1.2.3
+Pillow==2.8.1