improve brain

intelligine/cst.py

 COL_EATABLE = IncrementedNamedInt.get('intelligine.col.eatable')
 COL_SMELL = IncrementedNamedInt.get('intelligine.col.smell')
 
+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')

intelligine/simulation/molecule/MoleculeFlavour.py

             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)
+        except NoCategoryInMolecule:
+            return {}
+
     def get_types(self, category):
         if category not in self._flavour:
             raise NoCategoryInMolecule()

intelligine/simulation/object/brain/AntBrain.py

             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/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 synergine_xyz.cst import POSITION
 from intelligine.core.exceptions import NoMolecule
 from intelligine.cst import MOLECULE_SEARCHING, MOVE_MODE_EXPLO, MOVE_MODE_HOME, MOVE_MODE, MOVE_MODE_GOHOME, \
-    EXPLORATION_VECTOR, MOLECULES_DIRECTION, SMELL_FOOD, SMELL_EGG
+    EXPLORATION_VECTOR, MOLECULES_DIRECTION, SMELL_FOOD, SMELL_EGG, BRAIN_SCHEMA, BRAIN
 from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 
 
     def _on_home_smell(cls, context, object_id):
         current_position = context.metas.value.get(POSITION, object_id)
         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)
+        molecules = flavour.get_molecules(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
-            except NoMolecule:
-                pass  # C'est qu'elle y est pas ^^
+
         return False
 
     def _update_exploration_vector(self):
-        # TODO: add tuple as vectors ?
         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]))

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.get_id(), 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/ant/Ant.py

     _body_parts = {
         BODY_PART_PHEROMONE_GLAND: MovementMoleculeGland
     }
+    _brain_class = AntBrain
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
         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_molecule_gland(self):
         return self.get_body_part(BODY_PART_PHEROMONE_GLAND)