Transport of eggs (non refactorised)

config.py

  TODO:
  * AttackAction :: comment choisir entre les actions ?
  * TakeAction, PutAction, Object Egg
+ * --> frameworkiser les usage de states, metas etc ?
  * Plusieurs objets au mm endroit; Cinq oeuf => dessein de cinq oeuf; etc (image dynamique (param max_supperposer ?)
  * 3d
+ * Optimisation display pygame: ne pas tout reafficher; opt google
 """
 
 config = {
         }
     },
     'engine': {
-        'fpsmax': 225,
+        'fpsmax': 25,
         'debug': {
             'mainprocess': True,
             'cycles': -1

intelligine/cst.py

 COLONY = IncrementedNamedInt.get('intelligine.colony')
 TRANSPORTABLE = IncrementedNamedInt.get('intelligine.transportable')
 TRANSPORTER = IncrementedNamedInt.get('intelligine.transporter')
-CARRYING = IncrementedNamedInt.get('intelligine.carrying')
+CARRYING = IncrementedNamedInt.get('intelligine.carrying')
+CANT_CARRY_STILL = IncrementedNamedInt.get('intelligine.cantcarry.still')
+CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')

intelligine/sandbox/colored/RedColonyConfiguration.py

 
         for x in range(50):
           for y in range(1, 50):
-            if x % 2 == 0 and y % 2 == 0:
+            if x % 3 == 0 and y % 3 == 0:
               egg = Egg()
               egg.set_position((0, 1+x, 50+y))
               # TODO: Ce COLONY doit devenir un truc automatise au niveau de la collection (qd get_object)

intelligine/synergy/Colony.py

 from intelligine.synergy.event.move.MoveAction import MoveAction
 from intelligine.synergy.event.attack.NearAttackableAction import NearAttackableAction
 from intelligine.synergy.event.transport.TakeableAction import TakeableAction
+from intelligine.synergy.event.transport.PutableAction import PutableAction
+from intelligine.synergy.event.CycleAction import CycleAction
 
 
 class Colony(SynergyCollection):
 
     def __init__(self, configuration):
         super().__init__(configuration)
-        self._actions = [MoveAction, NearAttackableAction, TakeableAction]
+        self._actions = [MoveAction, NearAttackableAction, TakeableAction, PutableAction, CycleAction]

intelligine/synergy/ColonyConfiguration.py

     def get_start_objects(self, collection):
 
       ants = []
-      for i in range(100):
+      for i in range(20):
           ant = self._ant_class()
           metas.value.set(COLONY, ant.get_id(), collection.get_id())
           ant.set_position(self._start_position)

intelligine/synergy/event/CycleAction.py

+from synergine.synergy.event.Action import Action
+from intelligine.synergy.event.CycleEvent import CycleEvent
+from intelligine.cst import CANT_CARRY_STILL, CANT_PUT_STILL
+
+
+class CycleAction(Action):
+
+    _listen = CycleEvent
+
+    def run(self, obj, collection, context, synergy_manager):
+      # TODO: refact ...
+      cant_carry_still = context.metas.value.get(CANT_CARRY_STILL, obj.get_id(), allow_empty=True, empty_value=0)
+      if cant_carry_still > 0:
+        context.metas.value.set(CANT_CARRY_STILL, obj.get_id(), cant_carry_still-1)
+
+      cant_put_still = context.metas.value.get(CANT_PUT_STILL, obj.get_id(), allow_empty=True, empty_value=0)
+      if cant_put_still > 0:
+        context.metas.value.set(CANT_PUT_STILL, obj.get_id(), cant_put_still-1)

intelligine/synergy/event/CycleEvent.py

+from synergine.synergy.event.Event import Event
+from intelligine.cst import CANT_CARRY_STILL, TRANSPORTER, ALIVE
+from intelligine.synergy.Simulation import Simulation
+
+
+class CycleEvent(Event):
+
+    def concern(self, object_id, context):
+        return context.metas.list.have(Simulation.STATE, object_id, TRANSPORTER) and \
+               context.metas.list.have(Simulation.STATE, object_id, ALIVE)
+
+    def _object_match(self, object_id, context, parameters):
+        return True

intelligine/synergy/event/transport/PutableAction.py

+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
+
+    def __init__(self, object_id, parameters):
+        super().__init__(object_id, parameters)
+
+    def prepare(self, context):
+        pass
+
+    def run(self, obj, collection, 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_transportable = synergy_manager.get_map().get_object(obj_id_transportable)
+        # TODO: Doit etre du meme type que ce qui est transporte !
+        obj_transported = obj.get_carried()
+        obj_transported.set_carried_by(None)
+        obj.put_carry(obj_transported)
+        context.metas.value.set(CANT_CARRY_STILL, obj.get_id(), 5)
+        # TODO: Il faut interdire cette action pendant un temps pour eviter que le fourmis deplace
+        # les memes objets direct apres
+        # Utiliser les metas pour ca ?

intelligine/synergy/event/transport/PutableEvent.py

+from intelligine.synergy.event.transport.TakeableEvent import TakeableEvent
+from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
+from intelligine.synergy.Simulation import Simulation
+from intelligine.cst import TRANSPORTER, ALIVE, CARRYING, CANT_PUT_STILL
+
+
+class PutableEvent(TakeableEvent):
+
+    def concern(self, object_id, context):
+        return context.metas.list.have(Simulation.STATE, object_id, TRANSPORTER) and \
+               context.metas.list.have(Simulation.STATE, object_id, ALIVE) and \
+               context.metas.list.have(Simulation.STATE, object_id, CARRYING) and \
+               not context.metas.value.get(CANT_PUT_STILL, object_id, allow_empty=True)

intelligine/synergy/event/transport/TakeableAction.py

 from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.transport.TakeableEvent import TakeableEvent
-from random import randint
+from intelligine.cst import CANT_PUT_STILL
 
 
 class TakeableAction(Action):
         # ?! Comment gerer lorsque deux obj vont vouloir transporter le meme objet ? process !
         obj_id_transportable = self._parameters['objects_ids_transportable'][0]
         obj_transportable = synergy_manager.get_map().get_object(obj_id_transportable)
-        try:
-            obj_transportable.set_carried_by(obj)
-            obj.carry(obj_transportable)
-        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
+        if not obj_transportable.is_carried():
+            try:
+                obj_transportable.set_carried_by(obj)
+                obj.carry(obj_transportable)
+                context.metas.value.set(CANT_PUT_STILL, obj.get_id(), 5)
+            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 synergine.synergy.event.Event import Event
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
 from intelligine.synergy.Simulation import Simulation
-from intelligine.cst import TRANSPORTABLE, TRANSPORTER, ALIVE, CARRYING
+from intelligine.cst import TRANSPORTABLE, TRANSPORTER, ALIVE, CARRYING, CANT_CARRY_STILL
 
 
 class TakeableEvent(Event):
     def concern(self, object_id, context):
         return context.metas.list.have(Simulation.STATE, object_id, TRANSPORTER) and \
                context.metas.list.have(Simulation.STATE, object_id, ALIVE) and \
-               not context.metas.list.have(Simulation.STATE, object_id, CARRYING)
+               not context.metas.list.have(Simulation.STATE, object_id, CARRYING) and \
+               not context.metas.value.get(CANT_CARRY_STILL, object_id, allow_empty=True)
 
     def __init__(self, actions):
         super().__init__(actions)

intelligine/synergy/object/BaseBug.py

         metas.list.add(Simulation.STATE, self.get_id(), ALIVE)
         metas.list.add(Simulation.STATE, self.get_id(), ATTACKABLE)
         self._life_points = 10
-        self._carried_by = []
+        self._carried_by = None
 
     def hurted(self, points):
         self._life_points -= points
         return self._life_points
 
     def set_carried_by(self, obj):
-        self._carried_by.append(obj)
-        metas.list.remove(Simulation.STATE, self.get_id(), TRANSPORTABLE)
+        if obj is not None:
+            assert self._carried_by is None
+            self._carried_by = obj
+            metas.list.remove(Simulation.STATE, self.get_id(), TRANSPORTABLE)
+        else:
+            assert self._carried_by is not None
+            self._carried_by = None
+            metas.list.add(Simulation.STATE, self.get_id(), TRANSPORTABLE)
 
     def is_carried(self):
         if self._carried_by:

intelligine/synergy/object/ant/Ant.py

         metas.list.add(Simulation.STATE, self.get_id(), ATTACKER)
         self._carried = []
 
+    def put_carry(self, obj):
+        self._carried.remove(obj)
+        obj.set_position(self.get_position())
+        metas.list.remove(Simulation.STATE, self.get_id(), CARRYING)
+
+    def get_carried(self):
+        # TODO: cas ou plusieurs ?
+        return self._carried[0]
+
     def carry(self, obj):
         self._carried.append(obj)
         metas.list.add(Simulation.STATE, self.get_id(), CARRYING)