refactorise event/action

intelligine/core/exceptions.py

 
 class DirectionException(Exception):
     pass
+
+
+class NearException(Exception):
+    pass
+
+
+class NearFound(NearException):
+    pass
+
+class NearNothingFound(NearException):
+    pass

intelligine/cst.py

 MOVE_MODE_EXPLO = IncrementedNamedInt.get('intelligine.basebug.move.mode.explo')
 MOVE_MODE_GOHOME = IncrementedNamedInt.get('intelligine.basebug.move.mode.gohome')
 
+TYPE = IncrementedNamedInt.get('intelligine.object.type')
+TYPE_RESOURCE_TRANSFORMABLE = IncrementedNamedInt.get('intelligine.object.type.resource.transformable')
+
 LAST_PHERMONES_POINTS = IncrementedNamedInt.get('intelligine.last_pheromones_points')
 
 PHEROMON_POSITIONS = IncrementedNamedInt.get('intelligine.phero.positions')
 COL_TRANSPORTER_NOT_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_not_carrying')
 
 BRAIN_SCHEMA = IncrementedNamedInt.get('intelligine.brain_schema')
-BRAIN_PART_MOVE = IncrementedNamedInt.get('intelligine.brain.part.move')
+BRAIN_PART_MOVE = IncrementedNamedInt.get('intelligine.brain.part.move')
+BRAIN_PART_TAKE = IncrementedNamedInt.get('intelligine.brain.part.take')
+BRAIN_PART_PUT = IncrementedNamedInt.get('intelligine.brain.part.put')

intelligine/simulation/object/brain/AntBrain.py

 from intelligine.simulation.object.brain.Brain import Brain
-from intelligine.simulation.object.brain.part.AntMoveBrainPart import AntMoveBrainPart
-from intelligine.cst import MOVE_MODE, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO
+from intelligine.simulation.object.brain.part.move.AntMoveBrainPart import AntMoveBrainPart
+from intelligine.cst import MOVE_MODE, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, \
+    BRAIN_PART_TAKE
 from intelligine.cst import PHEROMONE_SEARCHING
 from intelligine.cst import BRAIN_PART_MOVE
+from intelligine.simulation.object.brain.part.take.AntTakeBrainPart import AntTakeBrainPart
 
 
 class AntBrain(Brain):
 
     _brain_part_move_class = AntMoveBrainPart
+    _brain_part_take_class = AntTakeBrainPart
 
     def __init__(self, context, host):
         super().__init__(context, host)
+        # TODO: Gerer les BrainPart avec un dictionnaire ?
         self._set_brain_part(BRAIN_PART_MOVE, self._get_move_brain_part_instance())
+        self._set_brain_part(BRAIN_PART_TAKE, self._get_take_brain_part_instance())
         self._movement_mode = MOVE_MODE_EXPLO
         self._distance_from_objective = 0  # TODO rename: distance_since_objective
         self._pheromone_searching = PHEROMON_DIR_EXPLO
     def _get_move_brain_part_instance(self):
         return self._brain_part_move_class()
 
+    def _get_take_brain_part_instance(self):
+        return self._brain_part_take_class()
+
     def switch_to_mode(self, mode):
         self._movement_mode = mode
         self._update_pheromone_gland(mode)

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

-from intelligine.simulation.object.brain.part.MoveBrainPart import MoveBrainPart
+from intelligine.simulation.object.brain.part.move.MoveBrainPart import MoveBrainPart
 from xyzworld.cst import POSITION
 from intelligine.core.exceptions import NoPheromone
 from intelligine.cst import PHEROMONE_SEARCHING, MOVE_MODE_EXPLO, COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING

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

+from intelligine.simulation.object.brain.part.take.TakeBrainPart import TakeBrainPart
+from intelligine.synergy.object.ressource.Ressource import Resource
+from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE, TYPE_RESOURCE_TRANSFORMABLE, \
+    TYPE, MOVE_MODE_GOHOME, PHEROMON_DIR_EXPLO
+
+
+class AntTakeBrainPart(TakeBrainPart):
+
+    # TODO: methode __nit_ pour la classe ?
+    _take = {
+        MOVE_MODE_EXPLO: [TYPE_RESOURCE_TRANSFORMABLE],
+    }
+
+    @classmethod
+    def can_take(cls, context, object_id, object_to_take_id):
+        if not cls._object_is_takable_type(context, object_id, object_to_take_id):
+            return False
+        return True
+
+    @classmethod
+    def _object_is_takable_type(cls, context, object_id, object_to_take_id):
+        move_mode = context.metas.value.get(MOVE_MODE, object_id)
+        for takable_type in cls._take[move_mode]:
+            if context.metas.list.have(TYPE, takable_type, object_to_take_id, allow_empty=True):
+                return True
+        return False
+
+    def done(self, obj, take_object, context):
+        # TODO: Ranger ca ? Truc plus dynamique/configurable ?
+        if isinstance(take_object, Resource):
+            obj.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
+            # TODO: set_last_pheromone_point ca devrait pas etre dans get_movement_pheromone_gland().appose() ?
+            obj.set_last_pheromone_point(PHEROMON_DIR_EXPLO, obj.get_position())
+            obj.get_movement_pheromone_gland().appose()

intelligine/simulation/object/brain/part/take/TakeBrainPart.py

+from intelligine.simulation.object.brain.part.BrainPart import BrainPart
+
+
+class TakeBrainPart(BrainPart):
+
+    _take = {}
+
+    @classmethod
+    def can_take(cls, context, object_to_take_id):
+        return False

intelligine/synergy/event/attack/NearAttackableEvent.py

+from intelligine.core.exceptions import NearNothingFound
 from synergine.core.exceptions import NotConcernedEvent
 from intelligine.synergy.event.src.NearEvent import NearEvent
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
     def _prepare(self, object_id, context, parameters={}):
         obj_colony_id = context.metas.value.get(COLONY, object_id)
         filter = lambda near_object_id, context: obj_colony_id != context.metas.value.get(COLONY, near_object_id)
-        self.map(context, parameters, stop_at_first=True, filter=filter)
-        if self._near_name not in parameters:
+
+        try:
+            self.map(context, parameters, stop_at_first=True, filter=filter)
+        except NearNothingFound:
             raise NotConcernedEvent()
+
         return parameters

intelligine/synergy/event/src/NearEvent.py

+from intelligine.core.exceptions import NearFound, NearNothingFound
 from synergine.synergy.event.Event import Event
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
 
         super().__init__(actions)
         self._mechanism = ArroundMechanism
 
-    def map(self, context, parameters, stop_at_first = False, filter = lambda near_object_id, context: True):
+    # TODO: parameters en entre/sortie c pas bon ca
+    def map(self, context, parameters, stop_at_first=False, filter=lambda near_object_id, context: True):
         for near_object_id in parameters['objects_ids_near']:
             if self._near_map(near_object_id, context) and filter(near_object_id, context):
                 if self._near_name not in parameters:
                     parameters[self._near_name] = []
                 parameters[self._near_name].append(near_object_id)
                 if stop_at_first:
-                    return
+                    return
+        raise NearNothingFound()

intelligine/synergy/event/transport/PutableAction.py

+from intelligine.synergy.event.move.MoveAction import MoveAction
 from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.transport.PutableEvent import PutableEvent
 from intelligine.cst import CANT_CARRY_STILL
 class PutableAction(Action):
 
     _listen = PutableEvent
+    _depend = [MoveAction]
 
     def __init__(self, object_id, parameters):
         super().__init__(object_id, parameters)

intelligine/synergy/event/transport/TakeableAction.py

 from intelligine.synergy.event.move.MoveAction import MoveAction
 from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.transport.TakeableEvent import TakeableEvent
-from intelligine.cst import CANT_PUT_STILL
+from intelligine.cst import CANT_PUT_STILL, BRAIN_SCHEMA, BRAIN_PART_TAKE
 from synergine.synergy.event.exception.ActionAborted import ActionAborted
 
 
 class TakeableAction(Action):
-
+    """
+    TODO: Prendre le premier prenable, interrompre la recherche si trouve
+          si au run de l'action objet non prenable, tant pis. ActionAborted.
+    """
     _listen = TakeableEvent
     _depend = [MoveAction]
 
         super().__init__(object_id, parameters)
 
     def prepare(self, context):
+        # TODO: C l'event qui doit preparer les donnees
         pass
 
     def run(self, obj, context, synergy_manager):
-        # TODO: TEST
-        # TODO: Enlever le state de transportable a ce qui est transporte
-        # ?! Comment gerer lorsque deux obj vont vouloir transporter le meme objet ? process !
-        obj_id_transportable = self._parameters['objects_ids_transportable'][0]
+        obj_id_transportable = self._parameters[TakeableEvent.PARAM_TAKE]
         obj_transportable = synergy_manager.get_map().get_object(obj_id_transportable)
-        if obj_transportable.is_carried():
+        if obj_transportable.is_carried():  # TODO: is_takable
             raise ActionAborted()
         try:
             obj_carried = obj_transportable.get_what_carry()
             obj_carried.set_carried_by(obj)
             obj.carry(obj_carried)
             context.metas.value.set(CANT_PUT_STILL, obj.get_id(), 5)
+            obj.get_brain().get_part(BRAIN_PART_TAKE).done(obj, obj_carried, context)
         except ValueError: # Une NotCarriableError serais pus approprie
             # TODO: tmp? Si on as pas pu le porter c'est qu'il vient d'etre porte par une autre.
             pass

intelligine/synergy/event/transport/TakeableEvent.py

+from intelligine.core.exceptions import NearNothingFound
 from synergine.core.exceptions import NotConcernedEvent
 from intelligine.synergy.event.src.NearEvent import NearEvent
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
-from intelligine.cst import TRANSPORTABLE, CANT_CARRY_STILL, COL_TRANSPORTER_NOT_CARRYING
+from intelligine.cst import TRANSPORTABLE, CANT_CARRY_STILL, COL_TRANSPORTER_NOT_CARRYING, BRAIN_SCHEMA, BRAIN_PART_TAKE
 
 
 class TakeableEvent(NearEvent):
 
+    PARAM_TAKE = 'take'
     concern = COL_TRANSPORTER_NOT_CARRYING
     _near_name = 'objects_ids_transportable'
     _near_map = lambda self, near_object_id, context: context.metas.states.have(near_object_id, TRANSPORTABLE)
         self._mechanism = ArroundMechanism
 
     def _prepare(self, object_id, context, parameters={}):
-        if context.metas.value.get(CANT_CARRY_STILL, object_id, allow_empty=True):
+        if not self._can_carry(object_id, context):
             raise NotConcernedEvent()
-        self.map(context, parameters, stop_at_first=True)
-        if self._near_name not in parameters:
+
+        try:
+            self.map(context, parameters, stop_at_first=True)
+        except NearNothingFound:
+            raise NotConcernedEvent()
+
+        if not self._object_can_take(object_id, context, parameters[self._near_name][0]):
             raise NotConcernedEvent()
-        return parameters
+
+        parameters[self.PARAM_TAKE] = parameters[self._near_name][0]
+        return parameters
+
+    @staticmethod
+    def _can_carry(object_id, context):
+        return not context.metas.value.get(CANT_CARRY_STILL, object_id, allow_empty=True)
+
+    @staticmethod
+    def _object_can_take(object_id, context, object_to_take_id):
+        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
+        object_take_brain_part = object_brain_schema[BRAIN_PART_TAKE]
+        return object_take_brain_part.can_take(context, object_id, object_to_take_id)

intelligine/synergy/object/Food.py

-from intelligine.synergy.object.Transportable import Transportable
-from intelligine.cst import TRANSPORTABLE
+from intelligine.synergy.object.ressource.Ressource import Resource
+from intelligine.cst import TRANSPORTABLE, TYPE, TYPE_RESOURCE_TRANSFORMABLE
 
 
-class Food(Transportable):
+class Food(Resource):
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
+        context.metas.list.add(TYPE, TYPE_RESOURCE_TRANSFORMABLE, self.get_id())
+        # TODO: ?? TRANSPORTABLE ne devrait pas ette du cote de Transportable ?
         context.metas.states.add(self.get_id(), TRANSPORTABLE)
 
     def get_what_carry(self):

intelligine/synergy/object/ressource/Ressource.py

+from intelligine.synergy.object.Transportable import Transportable
+
+
+class Resource(Transportable):
+    pass

intelligine/tests/src/event/MoveEvent.py

+from intelligine.synergy.event.move.MoveEvent import MoveEvent as BaseMoveEvent
+from intelligine.synergy.event.move.direction import NORTH
+
+
+class MoveEvent(BaseMoveEvent):
+
+    force_direction = lambda self, object_id, context: NORTH
+
+    def _get_direction(self, object_id, context):
+        return self.force_direction(object_id, context)