dev: molecule to follow and to find smell origin

intelligine/cst.py

 CANT_CARRY_STILL = IncrementedNamedInt.get('intelligine.cantcarry.still')
 CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
 ACTION_DIE = IncrementedNamedInt.get('intelligine.basebug.action.die')
-PHEROMONE_SEARCHING = IncrementedNamedInt.get('intelligine.molecule_searching')
+MOLECULE_SEARCHING = IncrementedNamedInt.get('intelligine.molecule_searching')
+MOLECULES = IncrementedNamedInt.get('intelligine.molecules')
 
-# TODO: Renommer "move_mode" en "mode"
+# 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')
 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.phero.infos')
+MOLECULES_DIRECTION = IncrementedNamedInt.get('intelligine.phero.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')
+#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')

intelligine/display/Pygame.py

 from intelligine.core.exceptions import NoMolecule
 from synergine_xyz.display.Pygame import Pygame as XyzPygame
 import pygame
-from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, PHEROMON_POSITIONS, POINTS_SMELL, \
-    POINT_SMELL, SMELL_EGG, SMELL_FOOD
+from intelligine.cst import PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, MOLECULES, \
+    SMELL_EGG, SMELL_FOOD, MOLECULES_DIRECTION
 from intelligine.display.pygame.visualisation import SURFACE_PHEROMONE_EXPLORATION, SURFACE_PHEROMONE_HOME, \
     SURFACE_SMELL_EGG, SURFACE_SMELL_FOOD
 
         super().receive(actions_done)
 
         if self._is_display_molecules:
-            molecules_positions = self._context.metas.list.get(PHEROMON_POSITIONS,
-                                                                PHEROMON_POSITIONS,
-                                                                allow_empty=True)
+            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:
-                point_flavour.get_molecule(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_HOME)
+                point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=PHEROMON_DIR_HOME)
                 self.draw_surface(point, molecule_home_surface)
             except NoMolecule:
                 pass # No molecule here
 
             try:
-                point_flavour.get_molecule(category=PHEROMON_DIRECTION, type=PHEROMON_DIR_EXPLO)
+                point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=PHEROMON_DIR_EXPLO)
                 self.draw_surface(point, molecule_exploration_surface)
             except NoMolecule:
                 pass # No molecule here
 
-    def _display_smells(self, smell_positions, context):
-        smell_egg_surface = self._object_visualizer.get_surface(SURFACE_SMELL_EGG)
-        smell_food_surface = self._object_visualizer.get_surface(SURFACE_SMELL_FOOD)
+            try:
+                molecule = point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=SMELL_FOOD)
+                self.draw_surface(point, smell_food_surface)
 
-        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:
+                adapted_point = self._get_real_pixel_position_of_position(point)
+                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_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 key == pygame.K_m:
             if self._is_display_molecules:
                 self._is_display_molecules = False
             else:
                 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

intelligine/simulation/molecule/DirectionMolecule.py

-from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_POSITIONS
+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
 
 class DirectionMolecule():
 
-    @staticmethod
-    def appose(context, point, molecule):
+    _positions_key = None
+
+    @classmethod
+    def appose(cls, context, point, molecule):
         context.molecules().increment_with_molecule(point, molecule)
-        context.metas.list.add(PHEROMON_POSITIONS, PHEROMON_POSITIONS, point, assert_not_in=False)
+        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=PHEROMON_DIRECTION, type=molecule_type)
+        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)
+                                                            molecule_filter=around_molecule_filter)
 
         if not around_molecules_points:
             raise NoMolecule()
 
         return direction
 
-    @staticmethod
-    def _get_around_molecules(context, reference_point, molecule_type,
-                               molecule_filter=lambda around_molecule: True):
+    @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=PHEROMON_DIRECTION, type=molecule_type)
+                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:
 
         return around_molecules_points
 
-    @staticmethod
-    def get_best_molecule_direction_in(context, reference_point, points, molecule_type):
+    @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=PHEROMON_DIRECTION, type=molecule_type)
+                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

intelligine/simulation/object/brain/AntBrain.py

 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, MOVE_MODE_HOME
-from intelligine.cst import PHEROMONE_SEARCHING
+    BRAIN_PART_TAKE, BRAIN_PART_PUT, MOVE_MODE_NURSE, PHEROMON_DIR_NONE, BRAIN_PART_ATTACK, MOVE_MODE_HOME, SMELL_FOOD
+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 synergine.core.exceptions import NotFound
 
 
 class AntBrain(Brain):
         BRAIN_PART_ATTACK: AttackBrainPart
     }
 
+    _taken_smell_matches = {
+        Food: SMELL_FOOD
+    }
+    """ 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_HOME
         if mode == MOVE_MODE_EXPLO:
             molecule_searching = PHEROMON_DIR_EXPLO
         elif mode == MOVE_MODE_GOHOME:
+            # TODO: Plus rien ici (path integration)
             molecule_searching = PHEROMON_DIR_HOME
         elif mode == MOVE_MODE_NURSE:
             molecule_searching = PHEROMON_DIR_NONE
         elif mode == MOVE_MODE_HOME:
-            return
+            molecule_searching = self.get_part(BRAIN_PART_TAKE).get_smell_target()
         else:
             raise NotImplementedError()
+
         self._molecule_searching = molecule_searching
-        self._context.metas.value.set(PHEROMONE_SEARCHING, self._host.get_id(), molecule_searching)
+        self._context.metas.value.set(MOLECULE_SEARCHING, self._host.get_id(), molecule_searching)
 
     def get_movement_mode(self):
         return self._movement_mode
         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()

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

+from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 from intelligine.simulation.object.brain.part.move.MoveBrainPart import MoveBrainPart
 from intelligine.synergy.event.move.direction import directions_modifiers, get_direction_for_degrees
 from synergine_xyz.cst import POSITION
-from intelligine.core.exceptions import NoMolecule
-from intelligine.cst import PHEROMONE_SEARCHING, MOVE_MODE_EXPLO, \
-    MOVE_MODE_HOME, MOVE_MODE, MOVE_MODE_GOHOME, EXPLORATION_VECTOR, POINTS_SMELL
+from intelligine.core.exceptions import NoMolecule, NoTypeInMolecule
+from intelligine.cst import MOLECULE_SEARCHING, MOVE_MODE_EXPLO, \
+    MOVE_MODE_HOME, MOVE_MODE, MOVE_MODE_GOHOME, EXPLORATION_VECTOR, POINTS_SMELL, MOLECULES, MOLECULES_DIRECTION, \
+    SMELL_FOOD, SMELL_EGG
 from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 from synergine_xyz.geometry import get_degree_from_north
 
     @classmethod
     def get_direction(cls, context, object_id):
         move_mode = context.metas.value.get(MOVE_MODE, object_id)
-        if move_mode == MOVE_MODE_EXPLO:
+        if move_mode == MOVE_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)
-        elif move_mode == MOVE_MODE_GOHOME:
-            return cls._get_direction_with_exploration_vector(context, object_id)
 
         return super().get_direction(context, object_id)
 
     @classmethod
     def _get_direction_with_molecules(cls, context, object_id):
         object_point = context.metas.value.get(POSITION, object_id)
-        molecule_type = context.metas.value.get(PHEROMONE_SEARCHING, object_id)
+        molecule_type = context.metas.value.get(MOLECULE_SEARCHING, object_id)
         try:
             direction = cls._get_molecule_direction_for_point(context, object_point, molecule_type)
         except NoMolecule:
     def _get_direction_with_exploration_vector(context, object_id):
         current_position = context.metas.value.get(POSITION, object_id)
         exploration_vector = context.metas.value.get(EXPLORATION_VECTOR, object_id)
-        # TODO: inverser
+        # TODO: inverser (math)
         home_vector = (exploration_vector[0] - (exploration_vector[0]*2),
                        exploration_vector[1] - (exploration_vector[1]*2))
         home_position = (0, current_position[1]+home_vector[0], current_position[2]+home_vector[1])
         :param context:
         :return:
         """
-        if self._host_brain.get_movement_mode() == MOVE_MODE_EXPLO and self._on_home_smell(context, obj.get_id()):
+        movement_mode = self._host_brain.get_movement_mode()
+
+        if movement_mode == MOVE_MODE_GOHOME and self._on_home_smell(context, obj.get_id()):
             self._host_brain.switch_to_mode(MOVE_MODE_HOME)
+            # TODO: on change les molecule recherché (Food => SmellFood, definis dans Take, en fct de ce qui est take)
 
-        if self._host_brain.get_movement_mode() == MOVE_MODE_HOME and not self._on_home_smell(context, obj.get_id()):
-            # TODO: sitwh explo que si rien a faire (rien a poser par exemple)
+        elif movement_mode == MOVE_MODE_HOME and not self._on_home_smell(context, obj.get_id()):
             self._host_brain.switch_to_mode(MOVE_MODE_EXPLO)
             self._start_new_exploration()
 
+        # TODO: sitch explo si rien a faire (rien a poser par exemple) et HOME
+
+        # TODO: Poser sur StockedFood
+
     @classmethod
     def _on_home_smell(cls, context, object_id):
         current_position = context.metas.value.get(POSITION, object_id)
-        smell_points = context.metas.value.get(POINTS_SMELL, POINTS_SMELL, allow_empty=True, empty_value={})
-        if current_position in smell_points:
-            return True
+        flavour = context.molecules().get_flavour(current_position)
+        # TODO: Idem, liste de smell_type ...
+        for smell_type in (SMELL_FOOD, SMELL_EGG):
+            try:
+                molecule = flavour.get_molecule(category=MOLECULES_DIRECTION, type=smell_type)
+                return True
+            except NoTypeInMolecule:
+                pass  # C'est qu'elle y est pas ^^
         return False
 
     def _update_exploration_vector(self):

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

         MOVE_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.
 
     def done(self, obj, take_object, context):
         # TODO: Ranger ca ? Truc plus dynamique/configurable ?
+        # TODO: qqch plus generique ... (attention aux eggs)
         if isinstance(take_object, Resource):
+            self._smell_target = self._host_brain.get_smell_for_object_taken(take_object)
             obj.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
             obj.get_movement_molecule_gland().appose()

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):
 
         try:
             DirectionMolecule.appose(self._context,
-                                      self._host.get_position(),
-                                      self.get_molecule())
+                                     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())
 

intelligine/simulation/object/molecule/MovementMoleculeGland.py

-from intelligine.cst import PHEROMON_DIRECTION
+from intelligine.cst import MOLECULES_DIRECTION
 from intelligine.simulation.object.molecule.MoleculeGland import MoleculeGland
 from intelligine.simulation.molecule.Molecule import Molecule
 
         """
         :return: Molecule
         """
-        return Molecule(PHEROMON_DIRECTION, self._molecule_type, self._host.get_brain().get_distance_from_objective(), 1)
+        return Molecule(MOLECULES_DIRECTION,
+                        self._molecule_type,
+                        self._host.get_brain().get_distance_from_objective(),
+                        1)

intelligine/synergy/event/smell/SmellAction.py

-from intelligine.cst import POINT_SMELL, POINTS_SMELL
+from intelligine.cst import POINT_SMELL, POINTS_SMELL, MOLECULES_INFOS, MOLECULES_DIRECTION, SMELL_FOOD, SMELL_EGG
+from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
+from intelligine.simulation.molecule.Molecule import Molecule
 from intelligine.synergy.event.smell.SmellEvent import SmellEvent
 from synergine.synergy.event.Action import Action
 
     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)
+            # TODO: Remonter ca dans MoleculeManager ?
+            flavour_raw_data = context.metas.value.get(MOLECULES_INFOS, smell_position)
+            # TODO: Calculer ou definir qqpart la liste des smells
+            for smell_type in (SMELL_FOOD, SMELL_EGG):
+                if smell_type in flavour_raw_data:
+                    del(flavour_raw_data[smell_type])
+                context.metas.value.set(MOLECULES_INFOS, smell_position, flavour_raw_data)
         context.metas.list.unset(POINTS_SMELL, POINTS_SMELL, allow_empty=True)
 
     def run(self, obj, context, synergy_manager):
-
+        # TODO: Utiliser molecule
         points_distances = self._parameters['points_distances']
         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)
+            DirectionMolecule.appose(context, smell_point, molecule)
+
+            #
+            # 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/object/ant/Ant.py

                                                            COL_TRANSPORTER_NOT_CARRYING,
                                                            COL_FIGHTER])
         self._carried = None
-        self._brain.switch_to_mode(MOVE_MODE_HOME)
+        self._brain.switch_to_mode(MOVE_MODE_EXPLO)
         context.metas.list.add(TYPE, self.get_id(), TYPE_ANT)
 
     def die(self):

intelligine/synergy/stigmergy/MoleculesManager.py

 from intelligine.core.exceptions import BestMoleculeHere, NoMolecule
-from intelligine.cst import PHEROMON_INFOS
+from intelligine.cst import MOLECULES_INFOS
 from intelligine.simulation.molecule.MoleculeFlavour import MoleculeFlavour
 from intelligine.simulation.molecule.Molecule import Molecule
 
         self._context = context
 
     def get_flavour(self, position):
-        point_molecules = self._context.metas.value.get(PHEROMON_INFOS,
-                                                         position,
-                                                         allow_empty=True,
-                                                         empty_value={})
+        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(PHEROMON_INFOS, position, flavour.get_raw_data())
+        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)
             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())
+                                         apposed_molecule.get_type(),
+                                         distance=apposed_molecule.get_distance())
 
         position_molecule.increment_intensity(apposed_molecule.get_intensity())
 

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.simulation.molecule.DirectionMolecule import DirectionMolecule
 
 ppath.insert(1,getcwd()+'/modules')