molecules evaporation

TODO

 * Fourmis (map.tmx) pas en mode nurse (-> algo de choix d'activité plus tard)
 * 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 ...
-* ! Les molecules d'odeur (oeuf et bouffe) ne disparaissent pas. Ce que l'on peut faire: Ces odeurs ont tjrs une intensité de 1. En même temps que l'on lance la SmellAction on lance (juste avant) l'Action d'évaporation. Les odeurs seront ainsi nettoyé.
+* ! Les molecules d'odeur (oeuf et bouffe) ne disparaissent pas. Ce que l'on peut faire: Ces odeurs ont tjrs une intensité de 1. En même temps que l'on lance la SmellAction on lance (juste avant) l'Action d'évaporation. Les odeurs seront ainsi nettoyé. EDIT c'est censcé être dans le cycle_pre_run de l'action !

config.py

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

intelligine/cst.py

 TYPE_ANT = IncrementedNamedInt.get('intelligine.object.type.ant')
 
 PHEROMON_POSITIONS = IncrementedNamedInt.get('intelligine.phero.positions')
-MOLECULES_INFOS = IncrementedNamedInt.get('intelligine.phero.infos')
-MOLECULES_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')
 EXPLORATION_VECTOR = IncrementedNamedInt.get('intelligine.exploration_vector')

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 synergine.synergy.Simulation import Simulation
 from intelligine.synergy.object.Food import Food
 from intelligine.synergy.object.Rock import Rock
 from intelligine.synergy.object.ant.Ant import Ant

intelligine/simulation/molecule/DirectionMolecule.py

 
     @classmethod
     def appose(cls, context, point, molecule):
-        context.molecules().increment_with_molecule(point, molecule)
+        context.molecules().increment_with_molecule(point, molecule, context.get_cycle())
         context.metas.list.add(MOLECULES, MOLECULES, point, assert_not_in=False)
 
     @classmethod

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, molecules_exclude_types, molecule_minimum_age):
+        self._context = context
+        self._intensity_decrement = intensity_decrement
+        self._molecules_manager = MoleculesManager(context)
+        self._molecules_exclude_types = molecules_exclude_types
+        self._molecule_minimum_age = molecule_minimum_age
+
+    def evaporate(self):
+        for position, flavour in self._get_flavours():
+            self._decrease_flavour(flavour)
+            self._molecules_manager.set_flavour(position, flavour)
+
+    def _get_flavours(self):
+        molecules_points = self._context.metas.list.get(MOLECULES, MOLECULES)
+        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 flavour.get_molecules(MOLECULES_DIRECTION):
+            if not self._is_recent_molecule(direction_molecule) \
+               and not self._is_excluded_molecule_type(direction_molecule):
+                direction_molecule.increment_intensity(-self._intensity_decrement)
+                flavour.set_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):
+        return molecule.get_type() in self._molecules_exclude_types

intelligine/simulation/molecule/Molecule.py

 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

intelligine/simulation/molecule/MoleculeFlavour.py

         for category in raw_data:
             molecules_by_category = raw_data[category]
             for type in molecules_by_category:
-                distance, intensity = molecules_by_category[type]
+                distance, intensity, cycle_age = molecules_by_category[type]
                 if category not in flavour:
                     flavour[category] = {}
-                flavour[category][type] = Molecule(category, type, distance, intensity)
+                flavour[category][type] = Molecule(category, type, distance, intensity, cycle_age)
         return cls(flavour)
 
     def get_raw_data(self):
                 molecule = molecules_by_category[type]
                 if category not in raw_data:
                     raw_data[category] = {}
-                raw_data[category][type] = (molecule.get_distance(), molecule.get_intensity())
+                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):
         :return: Molecules dict or empty dict of no molecules
         """
         try:
-            return self.get_types(category)
+            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 {}
 

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

     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(MOLECULES_DIRECTION)
+        molecules = flavour.get_molecules_types(MOLECULES_DIRECTION)
 
         if not molecules:
             return False
             self._update_exploration_vector()
 
     def _start_new_exploration(self):
-        self._reinit_exploration_vector()
+        self._init_exploration_vector()
         self._host_brain.switch_to_mode(MODE_EXPLO)
 
     def _init_exploration_vector(self):

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 MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, \
-    MODE_GOHOME, MODE_NURSE, TYPE_NURSERY
+    MODE_GOHOME, MODE_NURSE, TYPE_NURSERY, MODE_HOME
 
 
 class AntTakeBrainPart(TakeBrainPart):

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/smell/SmellAction.py

             try:
                 DirectionMolecule.appose(context, smell_point, molecule)
             except BestMoleculeHere:
-                pass  #
+                pass  # TODO: Pas l'inverse ? A voir apres avoir fix la disparition.
 
             #
             # current_point_smell = points_distances[smell_point]

intelligine/synergy/object/SynergyObject.py

 from intelligine.cst import OBJ_SMELL, INSTANCE_CLASS
+from intelligine.synergy.Simulation import Simulation
 from synergine_xyz.SynergyObject import SynergyObject as XyzSynergyObject
 
 
     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/stigmergy/MoleculesManager.py

                 return Molecule()
             raise
 
-    def increment_with_molecule(self, position, apposed_molecule):
+    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())
+                                         distance=apposed_molecule.get_distance(),
+                                         cycle_age=cycle_age)
 
         position_molecule.increment_intensity(apposed_molecule.get_intensity())