metas: brain, brain parts attached to class instead instance

intelligine/core/exceptions.py

@@ -50,10 +50,6 @@ class BrainException(Exception):
     pass
 
 
-class BrainPartAlreadyExist(BrainException):
-    pass
-
-
 class BodyException(Exception):
     pass
 

intelligine/cst.py

@@ -57,6 +57,8 @@ COL_TRANSPORTER_NOT_CARRYING = IncrementedNamedInt.get('intelligine.col.transpor
 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

@@ -1,10 +1,12 @@
-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

@@ -1,4 +1,3 @@
-from intelligine.core.exceptions import BrainPartAlreadyExist
 from intelligine.cst import BRAIN_SCHEMA
 
 
@@ -9,31 +8,17 @@ class Brain():
     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

@@ -3,8 +3,4 @@ from intelligine.cst import BRAIN_SCHEMA
 
 
 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

@@ -1,4 +1,5 @@
 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
@@ -22,7 +23,7 @@ class NearAttackableEvent(NearEvent):
         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

@@ -1,5 +1,6 @@
 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
@@ -31,8 +32,7 @@ class MoveEvent(Event):
         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

@@ -1,4 +1,5 @@
 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
@@ -27,7 +28,7 @@ class PutableEvent(NearEvent):
             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()
@@ -47,5 +48,5 @@ class PutableEvent(NearEvent):
 
     @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

@@ -1,4 +1,5 @@
 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
@@ -34,5 +35,5 @@ class TakeableEvent(NearEvent):
 
     @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

@@ -20,7 +20,7 @@ class BaseBug(Transportable):
         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

@@ -1,4 +1,4 @@
-from intelligine.cst import OBJ_SMELL
+from intelligine.cst import OBJ_SMELL, INSTANCE_CLASS
 from synergine_xyz.SynergyObject import SynergyObject as XyzSynergyObject
 
 
@@ -7,6 +7,7 @@ class SynergyObject(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