remove pheromones

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')

intelligine/simulation/molecule/Evaporation.py

 
 class Evaporation:
 
-    def __init__(self, context, intensity_decrement, molecules_exclude_types, molecule_minimum_age):
+    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._molecules_exclude_types = molecules_exclude_types
         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)
+        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):
-                direction_molecule.increment_intensity(-self._intensity_decrement)
-                flavour.set_molecule(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):
-        return molecule.get_type() in self._molecules_exclude_types
+        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/molecule/Molecule.py

         return self._cycle_age
 
     def increment_intensity(self, increment_value):
-        self._intensity += increment_value
+        self._intensity += increment_value

intelligine/simulation/molecule/MoleculeFlavour.py

         if category not in self._flavour:
             self._flavour[category] = {}
 
-        self._flavour[category][type] = molecule
+        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/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 MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, CARRIED, MODE_NURSE, TYPE_NURSERY, \
-    MODE_HOME, TYPE_RESOURCE_EATABLE, MODE_GOHOME
+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 synergine_xyz.cst import POSITION, POSITIONS
 
         # 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(CARRIED, object_id)
+            object_carried_id = context.metas.value.get(CARRY, object_id)
             return cls._objects_types_match(context, object_carried_id, object_near_id)
         return False
 

intelligine/synergy/event/smell/SmellAction.py

 from intelligine.core.exceptions import BestMoleculeHere
-from intelligine.cst import POINT_SMELL, POINTS_SMELL, MOLECULES_INFOS, MOLECULES_DIRECTION, SMELL_FOOD, SMELL_EGG
+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:
-            # 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)
+        evaporation = Evaporation(context, molecules_include_types=[SMELL_FOOD, SMELL_EGG])
+        evaporation.remove()
 
     def run(self, obj, context, synergy_manager):
 

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/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.synergy.object.Bug import Bug
 from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER, COL_TRANSPORTER, COL_TRANSPORTER_NOT_CARRYING, \
     COL_FIGHTER, MODE_EXPLO, MODE_GOHOME, BODY_PART_PHEROMONE_GLAND, TYPE, TYPE_ANT, \
-    COL_TRANSPORTER_CARRYING, MODE_NURSE, MODE_HOME
+    COL_TRANSPORTER_CARRYING, MODE_NURSE, MODE_HOME, CARRY
 from intelligine.synergy.object.Food import Food
 from intelligine.simulation.object.molecule.MovementMoleculeGland import MovementMoleculeGland
 from intelligine.simulation.object.brain.AntBrain import AntBrain
                                                            COL_FIGHTER])
         self._carried = None
         #  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)
+        self._brain.switch_to_mode(MODE_NURSE)
         context.metas.list.add(TYPE, self.get_id(), TYPE_ANT)
 
     def die(self):
         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(MODE_GOHOME)