clean code

intelligine/simulation/object/brain/part/BrainPart.py

 
     def __init__(self, host_brain):
         self._host_brain = host_brain
+        self._context = self._host_brain.get_context()
+        self._host = self._host_brain.get_host()
 
     def get_host_brain(self):
         return self._host_brain
     def get_host(self):
         return self.get_host_brain().get_host()
 
-    def done(self, obj, context):
+    def done(self):
         pass

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

 from intelligine.simulation.object.brain.part.move.MoveBrainPart import MoveBrainPart
 from intelligine.synergy.event.move.direction import directions_modifiers, get_position_with_direction_decal
 from synergine_xyz.cst import POSITION
-from intelligine.core.exceptions import NoMolecule, NoTypeInMolecule
+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
 from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 
     def _set_exploration_vector(self, new_vector):
         self._exploration_vector = new_vector
-        # TODO: On devrais donner le context aux brain parts
-        self._host_brain.get_context().metas.value.set(EXPLORATION_VECTOR,
-                                                       self._host_brain.get_host().get_id(),
-                                                       new_vector)
+        self._context.metas.value.set(EXPLORATION_VECTOR,
+                                      self._host_brain.get_host().get_id(),
+                                      new_vector)
 
     @classmethod
     def get_direction(cls, context, object_id):
         return ByPass(ant_host, home_vector, context, object_id)
 
     # TODO: obj pas necessaire, il est dans _host
-    def done(self, obj, context):
-        super().done(obj, context)
-        self._appose_molecule(obj)
-        self._check_context(obj, context)
-        self._apply_context(obj, context)
+    def done(self):
+        super().done()
+        self._appose_molecule()
+        self._check_context()
+        self._apply_context()
 
-    @staticmethod
-    def _appose_molecule(obj):
-        if obj.get_movement_molecule_gland().is_enabled():
-            obj.get_movement_molecule_gland().appose()
+    def _appose_molecule(self):
+        if self._host.get_movement_molecule_gland().is_enabled():
+            self._host.get_movement_molecule_gland().appose()
 
-    def _check_context(self, obj, context):
+    def _check_context(self):
         """
 
         If was in exploration, and just found home smell;
         """
         movement_mode = self._host_brain.get_movement_mode()
 
-        if movement_mode == MOVE_MODE_GOHOME and self._on_home_smell(context, obj.get_id()):
+        if movement_mode == MOVE_MODE_GOHOME and self._on_home_smell(self._context, self._host.get_id()):
             self._host_brain.switch_to_mode(MOVE_MODE_HOME)
-            ant_star = self._get_by_pass_brain(context, obj.get_id())
+            ant_star = self._get_by_pass_brain(self._context, self._host.get_id())
             ant_star.erase()
             # TODO: on change les molecule recherché (Food => SmellFood, definis dans Take, en fct de ce qui est take)
 
-        elif movement_mode == MOVE_MODE_HOME and not self._on_home_smell(context, obj.get_id()):
+        elif movement_mode == MOVE_MODE_HOME and not self._on_home_smell(self._context, self._host.get_id()):
             self._host_brain.switch_to_mode(MOVE_MODE_EXPLO)
             self._start_new_exploration()
 
-        elif movement_mode == MOVE_MODE_EXPLO and self._on_home_smell(context, obj.get_id()):
+        elif movement_mode == MOVE_MODE_EXPLO and self._on_home_smell(self._context, self._host.get_id()):
             self._start_new_exploration()  # TODO: rename en reinit_explo
 
         # TODO: sitch explo si rien a faire (rien a poser par exemple) et HOME
         self._set_exploration_vector((self._exploration_vector[0] + just_move_vector[1],
                                       self._exploration_vector[1] + just_move_vector[2]))
 
-    def _apply_context(self, obj, context):
+    def _apply_context(self):
         movement_mode = self._host_brain.get_movement_mode()
         if movement_mode == MOVE_MODE_EXPLO or movement_mode == MOVE_MODE_GOHOME:
             self._update_exploration_vector()

intelligine/simulation/object/brain/part/transport/AntPutBrainPart.py

             return True
         return False
 
-    def done(self, obj, puted_object, context):
+    def done(self, puted_object):
         # TODO: Il faut refact/logique qqpart pour ca !! Genre Brain.done(PUT, ??)
         if isinstance(puted_object, Food):
             # TODO: Quel mode ? On vient de poser (ps forcement dans la colonie) cls._mode_swicth ?
-            obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
+            self._host.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
             # TODO: TEST Depose au -1 pour des raisons de test. Plus tard ce sera des tas comme un autre !
             puted_object.set_position((-1, 0, 0))
 

intelligine/simulation/object/brain/part/transport/AntTakeBrainPart.py

         # Pour le moment si le type de l'objet fait partie des types admis pour le mode courant du porteur, c'est bon.
         return cls._match_with_mode(context, object_id, object_to_take_id)
 
-    def done(self, obj, take_object, context):
+    def done(self, take_object):
         # TODO: Ranger ca ? Truc plus dynamique/configurable ?
         # TODO: qqch plus generique ... (attention aux eggs)
         if isinstance(take_object, Resource):
             self._smell_target = self._host_brain.get_smell_for_object_taken(take_object)
-            obj.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
-            obj.get_movement_molecule_gland().appose()
+            self._host.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
+            self._host.get_movement_molecule_gland().appose()

intelligine/synergy/event/move/MoveAction.py

 
         obj.set_position(self._parameters[MoveEvent.PARAM_POSITION])
         obj.set_previous_direction(self._parameters[MoveEvent.PARAM_DIRECTION])
-        obj.get_brain().get_part(BRAIN_PART_MOVE).done(obj, context)
+        obj.get_brain().get_part(BRAIN_PART_MOVE).done()

intelligine/synergy/event/transport/PutableAction.py

         obj.put_carry(obj_transported, position_to_put)
         context.metas.value.set(CANT_CARRY_STILL, obj.get_id(), 5)
 
-        obj.get_brain().get_part(BRAIN_PART_PUT).done(obj, obj_transported, context)
+        obj.get_brain().get_part(BRAIN_PART_PUT).done(obj_transported)

intelligine/synergy/event/transport/TakeableAction.py

         obj.carry(obj_carried)
         cant_put_still = Core.get_configuration_manager().get('ant.take.cant_put_still')
         context.metas.value.set(CANT_PUT_STILL, obj.get_id(), cant_put_still)
-        obj.get_brain().get_part(BRAIN_PART_TAKE).done(obj, obj_carried, context)
+        obj.get_brain().get_part(BRAIN_PART_TAKE).done(obj_carried)