metas: brain, brain parts attached to class instead instance

intelligine/core/exceptions.py

     pass
 
 
-class BrainPartAlreadyExist(BrainException):
-    pass
-
-
 class BodyException(Exception):
     pass
 

intelligine/cst.py

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

intelligine/shorcut/brain.py

-from intelligine.cst import BRAIN, BRAIN_SCHEMA
+from intelligine.cst import BRAIN, BRAIN_SCHEMA, INSTANCE_CLASS
 
 
 def get_brain_class(context, object_id):
-    return context.metas.value.get(BRAIN, 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_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
+    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/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
 

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/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/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/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

         self._alive = True
         self._movements_count = -1
         self._brain = self._brain_class(self._context, self)
-        self._context.metas.value.set(BRAIN, self.get_id(), self._brain_class)
+        self._context.metas.value.set(BRAIN, self.__class__, self._brain_class)
         self._parts = {}
         self._init_parts()
 

intelligine/synergy/object/SynergyObject.py

-from intelligine.cst import OBJ_SMELL
+from intelligine.cst import OBJ_SMELL, INSTANCE_CLASS
 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