refact putable action/events/brain

intelligine/core/exceptions.py

@@ -1,3 +1,6 @@
+from synergine.synergy.event.exception.ActionAborted import ActionException
+
+
 class MovementException(Exception):
     pass
 
@@ -59,5 +62,10 @@ class NearException(Exception):
 class NearFound(NearException):
     pass
 
+
 class NearNothingFound(NearException):
+    pass
+
+
+class CantFindWhereToPut(ActionException):
     pass

intelligine/cst.py

@@ -9,6 +9,7 @@ COLONY = IncrementedNamedInt.get('intelligine.colony')
 TRANSPORTABLE = IncrementedNamedInt.get('intelligine.transportable')
 TRANSPORTER = IncrementedNamedInt.get('intelligine.transporter')
 CARRYING = IncrementedNamedInt.get('intelligine.carrying')
+CARRIED = IncrementedNamedInt.get('intelligine.carried')
 CANT_CARRY_STILL = IncrementedNamedInt.get('intelligine.cantcarry.still')
 CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
 ACTION_DIE = IncrementedNamedInt.get('intelligine.basebug.action.die')

intelligine/sandbox/exploration/RocksConfiguration.py

@@ -1,3 +1,4 @@
+from intelligine.synergy.object.Food import Food
 from synergine.synergy.collection.Configuration import Configuration
 from intelligine.synergy.object.Rock import Rock
 import pytmx
@@ -30,4 +31,10 @@ class RocksConfiguration(Configuration):
                         rock.set_position((0, xi, yi))
                         rocks.append(rock)
 
+        #  TEST
+        food1 = Food(collection, context)
+        food1.set_position((0, 0, 0))
+        food1.is_takable = lambda: False
+        rocks.append(food1)
+
         return rocks

intelligine/simulation/object/brain/AntBrain.py

@@ -1,22 +1,25 @@
 from intelligine.simulation.object.brain.Brain import Brain
 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
+    BRAIN_PART_TAKE, BRAIN_PART_PUT
 from intelligine.cst import PHEROMONE_SEARCHING
 from intelligine.cst import BRAIN_PART_MOVE
-from intelligine.simulation.object.brain.part.take.AntTakeBrainPart import AntTakeBrainPart
+from intelligine.simulation.object.brain.part.transport.AntPutBrainPart import AntPutBrainPart
+from intelligine.simulation.object.brain.part.transport.AntTakeBrainPart import AntTakeBrainPart
 
 
 class AntBrain(Brain):
 
     _brain_part_move_class = AntMoveBrainPart
     _brain_part_take_class = AntTakeBrainPart
+    _brain_part_put_class = AntPutBrainPart
 
     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._set_brain_part(BRAIN_PART_PUT, self._get_put_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
@@ -27,6 +30,9 @@ class AntBrain(Brain):
     def _get_take_brain_part_instance(self):
         return self._brain_part_take_class()
 
+    def _get_put_brain_part_instance(self):
+        return self._brain_part_put_class()
+
     def switch_to_mode(self, mode):
         self._movement_mode = mode
         self._update_pheromone_gland(mode)

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

@@ -47,15 +47,15 @@ class AntMoveBrainPart(MoveBrainPart):
         super().done(obj, context)
         self._appose_pheromone(obj)
 
-        # TEST: le temps de tout tester
-        if obj.get_position() == obj.get_colony().get_start_position() and obj.is_carrying():
-            obj_transported = obj.get_carried()
-            obj_transported.set_carried_by(None)
-            obj.put_carry(obj_transported, (-1, 0, 0))
-            obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
-            context.metas.collections.add_remove(obj.get_id(),
-                                                 COL_TRANSPORTER_NOT_CARRYING,
-                                                 COL_TRANSPORTER_CARRYING)
+        # # TEST: le temps de tout tester
+        # if obj.get_position() == obj.get_colony().get_start_position() and obj.is_carrying():
+        #     obj_transported = obj.get_carried()
+        #     obj_transported.set_carried_by(None)
+        #     obj.put_carry(obj_transported, (-1, 0, 0))
+        #     obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
+        #     context.metas.collections.add_remove(obj.get_id(),
+        #                                          COL_TRANSPORTER_NOT_CARRYING,
+        #                                          COL_TRANSPORTER_CARRYING)
 
     @staticmethod
     def _appose_pheromone(obj):

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

@@ -1,10 +0,0 @@
-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/simulation/object/brain/part/transport/AntPutBrainPart.py

@@ -0,0 +1,57 @@
+from intelligine.core.exceptions import CantFindWhereToPut
+from intelligine.simulation.object.brain.part.transport.TakeBrainPart import TakeBrainPart
+from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE, TYPE_RESOURCE_TRANSFORMABLE, TYPE, CARRIED, \
+    COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING
+from xyzworld.cst import POSITION, POSITIONS
+
+
+class AntPutBrainPart(TakeBrainPart):
+
+    # TODO: methode __nit_ pour la classe ?
+    _mode_matches = {
+        MOVE_MODE_EXPLO: [TYPE_RESOURCE_TRANSFORMABLE],
+    }
+
+    @classmethod
+    def can_put(cls, context, object_id, object_near_id):
+        object_carried_id = context.metas.value.get(CARRIED, object_id)
+        #  Pour le moment on considere qu'un objet peut-etre depose a cote d'un objet qui a un type identique
+        return cls._objects_have_same_type(context, object_carried_id, object_near_id)
+
+    @classmethod
+    def get_put_position(cls, context, object_id, object_near_id):
+        """
+        Maybe part "found available position arround" should be in other class.
+        :param context:
+        :param object_id:
+        :param object_near_id:
+        :return:
+        """
+        obj_near_position = context.metas.value.get(POSITION, object_near_id)
+        if cls._is_available_position(context, obj_near_position):
+            return obj_near_position
+
+        obj_transporter_position = context.metas.value.get(POSITION, object_id)
+        obj_transporter_around_positions = context.get_around_points_of_point(obj_transporter_position)
+        obj_near_around_positions = context.get_around_points_of_point(obj_near_position)
+
+        # For each position between target and current transporter
+        for pos_around_target in obj_near_around_positions:
+            if pos_around_target in obj_transporter_around_positions:
+                if cls._is_available_position(context, pos_around_target):
+                    return pos_around_target
+        raise CantFindWhereToPut()
+
+    @staticmethod
+    def _is_available_position(context, position):
+        # TODO: Pour le moment on ne regarde pas si ce sont tous des obj identique
+        count_obj_here = len(context.metas.list.get(POSITIONS, position, allow_empty=True))
+        # TODO: 5 est hardcode; de plus cette cntrainte (not brain) devrait dependre de l'objet, du contexte ...
+        if count_obj_here <= 5 and (context.position_is_penetrable(position) or position == (0, 0, 0)):  # TODO TEST !!!
+            return True
+        return False
+
+    def done(self, obj, puted_object, context):
+        # TODO: Depose au -1 pour des raisons de test. Plus tard ce sera des tas comme un autre !
+        puted_object.set_position((-1, 0, 0))
+        obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)

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

@@ -1,4 +1,4 @@
-from intelligine.simulation.object.brain.part.take.TakeBrainPart import TakeBrainPart
+from intelligine.simulation.object.brain.part.transport.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
@@ -6,24 +6,15 @@ from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE, TYPE_RESOURCE_TRANSFORMA
 
 class AntTakeBrainPart(TakeBrainPart):
 
-    # TODO: methode __nit_ pour la classe ?
-    _take = {
+    # TODO: methode __nit_ pour la classe ? vt mieux surcharger !
+    _mode_matches = {
         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
+        # 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):
         # TODO: Ranger ca ? Truc plus dynamique/configurable ?

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

@@ -0,0 +1,8 @@
+from intelligine.simulation.object.brain.part.transport.TransportBrainPart import TransportBrainPart
+
+
+class PutBrainPart(TransportBrainPart):
+
+    @classmethod
+    def can_put(cls, context, object_to_take_id):
+        raise NotImplementedError()

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

@@ -0,0 +1,8 @@
+from intelligine.simulation.object.brain.part.transport.TransportBrainPart import TransportBrainPart
+
+
+class TakeBrainPart(TransportBrainPart):
+
+    @classmethod
+    def can_take(cls, context, object_to_take_id):
+        raise NotImplementedError()

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

@@ -0,0 +1,26 @@
+from intelligine.cst import MOVE_MODE, TYPE
+from intelligine.simulation.object.brain.part.BrainPart import BrainPart
+
+
+class TransportBrainPart(BrainPart):
+
+    _mode_matches = {}
+
+    @classmethod
+    def _match_with_mode(cls, context, object_id, concerned_object_id):
+        move_mode = context.metas.value.get(MOVE_MODE, object_id)
+        for takable_type in cls._mode_matches[move_mode]:
+            if context.metas.list.have(TYPE, concerned_object_id, takable_type, allow_empty=True):
+                return True
+        return False
+
+    @classmethod
+    def _objects_have_same_type(cls, context, object_carried_id, object_to_put_id):
+        # BUG: On considere ici que c une liste de type pour obj. J'ai fait l'inverse.
+        # Une listde de objid pour un type.
+        # TODO: Il faut inverser !
+        object_carried_types = context.metas.list.get(TYPE, object_carried_id)
+        for object_carried_type in object_carried_types:
+            if context.metas.list.have(TYPE, object_to_put_id, object_carried_type):
+                return True
+        return False

intelligine/synergy/event/transport/PutableAction.py

@@ -1,9 +1,7 @@
 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
-from xyzworld.cst import POSITIONS
-from synergine.synergy.event.exception.ActionAborted import ActionAborted
+from intelligine.cst import CANT_CARRY_STILL, BRAIN_PART_PUT
 
 
 class PutableAction(Action):
@@ -14,37 +12,13 @@ class PutableAction(Action):
     def __init__(self, object_id, parameters):
         super().__init__(object_id, parameters)
 
-    def prepare(self, context):
-        pass
-
     def run(self, obj, context, synergy_manager):
-        # TODO: DEV
-        obj_id_transportable = self._parameters['objects_ids_transportable'][0]
-        obj_transportable = synergy_manager.get_map().get_object(obj_id_transportable)
-        # TODO: Cette logique de calcul cote process!
-        position_to_put = self._get_position_to_put(context, obj, obj_transportable)
-        # TODO: Doit etre du meme type que ce qui est transporte !
+        position_to_put = self._parameters[PutableEvent.PARAM_PUT_TO]
         obj_transported = obj.get_carried()
+
         obj_transported.set_carried_by(None)
+        #  TODO: re controle de si posable ? (5 max etc)
         obj.put_carry(obj_transported, position_to_put)
         context.metas.value.set(CANT_CARRY_STILL, obj.get_id(), 5)
 
-    def _get_position_to_put(self, context, obj, obj_transportable):
-        obj_transportable_pos = obj_transportable.get_position()
-        if self._is_available_position(context, obj_transportable_pos):
-            return obj_transportable_pos
-        poss_around_target = context.get_around_points_of_point(obj_transportable_pos)
-        poss_around_obj = context.get_around_points_of_point(obj.get_position())
-        # For each position between target and current transporter
-        for pos_around_target in poss_around_target:
-            if pos_around_target in poss_around_obj:
-                if self._is_available_position(context, pos_around_target):
-                    return pos_around_target
-        raise ActionAborted()
-
-    def _is_available_position(self, context, position):
-        # TODO: Pour le moment on ne regarde pas si ce sont tous des oeufs
-        count_obj_here = len(context.metas.list.get(POSITIONS, position, allow_empty=True))
-        if count_obj_here <= 5 and context.position_is_penetrable(position):
-            return True
-        return False
+        obj.get_brain().get_part(BRAIN_PART_PUT).done(obj, obj_transported, context)

intelligine/synergy/event/transport/PutableEvent.py

@@ -1,13 +1,61 @@
+from intelligine.core.exceptions import NearNothingFound, CantFindWhereToPut
+from intelligine.synergy.event.src.NearEvent import NearEvent
 from synergine.core.exceptions import NotConcernedEvent
-from intelligine.synergy.event.transport.TakeableEvent import TakeableEvent
-from intelligine.cst import CANT_PUT_STILL, COL_TRANSPORTER_CARRYING
+from intelligine.cst import CANT_PUT_STILL, COL_TRANSPORTER_CARRYING, TRANSPORTABLE, BRAIN_SCHEMA, BRAIN_PART_PUT
+from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
 
 
-class PutableEvent(TakeableEvent):
+class PutableEvent(NearEvent):
+    """
+    TODO: Refactorise with TakableEvent
+    """
 
+    PARAM_PUT = 'put'
+    PARAM_PUT_TO = 'put_to'
     concern = COL_TRANSPORTER_CARRYING
+    _near_name = 'objects_ids_putable'
+    _near_map = lambda self, near_object_id, context: context.metas.states.have(near_object_id, TRANSPORTABLE)
+
+    def __init__(self, actions):
+        super().__init__(actions)
+        self._mechanism = ArroundMechanism
 
     def _prepare(self, object_id, context, parameters={}):
-        if context.metas.value.get(CANT_PUT_STILL, object_id, allow_empty=True):
+        if not self._can_put(object_id, context):
+            raise NotConcernedEvent()
+
+        try:
+            self.map(context, parameters, stop_at_first=True)
+        except NearNothingFound:
+            raise NotConcernedEvent()
+
+        object_near_id = parameters[self._near_name][0]
+        brain_part = self._get_brain_part(object_id, context)
+
+        if not brain_part.can_put(context, object_id, object_near_id):
             raise NotConcernedEvent()
-        return super()._prepare(object_id, context, parameters)
+
+        try:
+            put_position = brain_part.get_put_position(context, object_id, object_near_id)
+        except CantFindWhereToPut:
+            raise NotConcernedEvent()
+
+        parameters[self.PARAM_PUT] = parameters[self._near_name][0]
+        parameters[self.PARAM_PUT_TO] = put_position
+        return parameters
+
+    @staticmethod
+    def _can_put(object_id, context):
+        return not context.metas.value.get(CANT_PUT_STILL, object_id, allow_empty=True)
+
+    @staticmethod
+    def _get_brain_part(object_id, context):
+        # TODO: refatc au dessus ?
+        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
+        return object_brain_schema[BRAIN_PART_PUT]
+
+    @staticmethod
+    def _object_can_put(object_id, context, object_to_put_id):
+        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
+        object_take_brain_part = object_brain_schema[BRAIN_PART_PUT]
+        return object_take_brain_part.can_put(context, object_id, object_to_put_id)

intelligine/synergy/object/Food.py

@@ -6,7 +6,7 @@ class Food(Resource):
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
-        context.metas.list.add(TYPE, TYPE_RESOURCE_TRANSFORMABLE, self.get_id())
+        context.metas.list.add(TYPE, self.get_id(), TYPE_RESOURCE_TRANSFORMABLE)
         # TODO: ?? TRANSPORTABLE ne devrait pas ette du cote de Transportable ?
         context.metas.states.add(self.get_id(), TRANSPORTABLE)
 

intelligine/synergy/object/ant/Ant.py

@@ -4,7 +4,7 @@ from intelligine.synergy.object.Bug import Bug
 from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER, \
                             COL_TRANSPORTER, COL_TRANSPORTER_NOT_CARRYING, \
                             COL_FIGHTER, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, \
-                            PHEROMON_DIR_EXPLO, LAST_PHERMONES_POINTS
+                            PHEROMON_DIR_EXPLO, LAST_PHERMONES_POINTS, CARRIED
 from intelligine.synergy.object.Food import Food
 from intelligine.simulation.object.pheromone.MovementPheromoneGland import MovementPheromoneGland
 from intelligine.simulation.object.brain.AntBrain import AntBrain
@@ -44,6 +44,8 @@ class Ant(Bug):
     def carry(self, obj):
         self._carried.append(obj)
         self._context.metas.states.add(self.get_id(), CARRYING)
+        #  TODO: On gere une liste de carried (mais pas juste la dessous). Ne gerer qu'un objet carried ?
+        self._context.metas.value.set(CARRIED, self.get_id(), obj.get_id())
         # TODO: pour le moment hardcode
         if isinstance(obj, Food):
             self.get_brain().switch_to_mode(MOVE_MODE_GOHOME)