COL system compatibility

intelligine/cst.py

 TRANSPORTER = IncrementedNamedInt.get('intelligine.transporter')
 CARRYING = IncrementedNamedInt.get('intelligine.carrying')
 CANT_CARRY_STILL = IncrementedNamedInt.get('intelligine.cantcarry.still')
-CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
+CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
+ACTION_DIE = IncrementedNamedInt.get('intelligine.basebug.action.die')
+
+COL_ALIVE = IncrementedNamedInt.get('intelligine.col.alive')
+COL_WALKER = IncrementedNamedInt.get('intelligine.col.walker')
+COL_FIGHTER = IncrementedNamedInt.get('intelligine.col.walker')
+COL_TRANSPORTER_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_carrying')
+COL_TRANSPORTER_NOT_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_not_carrying')

intelligine/display/pygame/visualisation.py

 from intelligine.synergy.object.Rock import Rock
 from intelligine.synergy.object.ant.Egg import Egg
 from os import getcwd
-from synergine.metas import metas
 from intelligine.cst import PREVIOUS_DIRECTION
 
 # TODO: Analyser les procedes ici pour proposer des outils dans le framework
 directions_blue_ant = DirectionnedImage(blue_ant)
 directions_green_ant = DirectionnedImage(green_ant)
 
-def bug_direction(bug):
+# TODO: context donne au callbacks
+
+def bug_direction(bug, context):
     if bug.get_life_points() <= 0:
         return dead_ant
     try:
-        previous_direction = metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
+        previous_direction = context.metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
     except KeyError:
         previous_direction = 14
     return directions_ant.get_for_direction(previous_direction)
 
-def red_ant_direction(bug):
+def red_ant_direction(bug, context):
     if bug.get_life_points() <= 0:
         return dead_red_ant
     try:
-        previous_direction = metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
+        previous_direction = context.metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
     except KeyError:
         previous_direction = 14
     return directions_red_ant.get_for_direction(previous_direction)
 
-def blue_ant_direction(bug):
+def blue_ant_direction(bug, context):
     if bug.get_life_points() <= 0:
         return dead_blue_ant
     try:
-        previous_direction = metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
+        previous_direction = context.metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
     except KeyError:
         previous_direction = 14
     return directions_blue_ant.get_for_direction(previous_direction)
 
-def green_ant_direction(bug):
+def green_ant_direction(bug, context):
     if bug.get_life_points() <= 0:
         return dead_green_ant
     try:
-        previous_direction = metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
+        previous_direction = context.metas.value.get(PREVIOUS_DIRECTION, bug.get_id())
     except KeyError:
         previous_direction = 14
     return directions_green_ant.get_for_direction(previous_direction)

intelligine/sandbox/colored/RedColonyConfiguration.py

 from intelligine.synergy.ColonyConfiguration import ColonyConfiguration
 from intelligine.sandbox.colored.RedAnt import RedAnt
 from intelligine.synergy.object.ant.Egg import Egg
-from synergine.metas import metas
 from intelligine.cst import COLONY
 
 
     _start_position = (0, 20, 70)
     _ant_class = RedAnt
 
-    def get_start_objects(self, collection):
-        objects = super().get_start_objects(collection)
+    def get_start_objects(self, collection, context):
+        objects = super().get_start_objects(collection, context)
 
         for x in range(50):
           for y in range(1, 50):
             if x % 3 == 0 and y % 3 == 0:
-              egg = Egg()
+              egg = Egg(context)
               egg.set_position((0, 1+x, 50+y))
               # TODO: Ce COLONY doit devenir un truc automatise au niveau de la collection (qd get_object)
-              metas.value.set(COLONY, egg.get_id(), collection.get_id())
+              context.metas.value.set(COLONY, egg.get_id(), collection.get_id())
               objects.append(egg)
 
         return objects

intelligine/synergy/ColonyConfiguration.py

 from synergine.synergy.collection.Configuration import Configuration
 from intelligine.synergy.object.ant.Ant import Ant
-from synergine.metas import metas
 from intelligine.cst import ALIVE, COLONY
 
 
     _start_position = (0, 20, 20)
     _ant_class = Ant
 
-    def get_start_objects(self, collection):
+    def get_start_objects(self, collection, context):
 
       ants = []
       for i in range(20):
-          ant = self._ant_class()
-          metas.value.set(COLONY, ant.get_id(), collection.get_id())
+          ant = self._ant_class(context)
+          context.metas.value.set(COLONY, ant.get_id(), collection.get_id())
           ant.set_position(self._start_position)
           ants.append(ant)
 

intelligine/synergy/RocksConfiguration.py

 
 class RocksConfiguration(Configuration):
 
-    def get_start_objects(self, collection):
+    def get_start_objects(self, collection, context):
 
       rocks = []
       rocks_positions = []
       rocks_positions.append((0, 100, 100))
 
       for rock_position in rocks_positions:
-          rock = Rock()
+          rock = Rock(context)
           rock.set_position(rock_position)
           rocks.append(rock)
 

intelligine/synergy/Simulation.py

 from synergine.synergy.Simulation import Simulation as BaseSimulation
 from xyzworld.cst import POSITION, POSITIONS
+#from intelligine.synergy.event.attack.NearAttackableAction import NearAttackableAction
+from intelligine.synergy.event.transport.PutableAction import PutableAction
+from intelligine.synergy.event.transport.TakeableAction import TakeableAction
+from intelligine.synergy.event.move.MoveAction import MoveAction
+from intelligine.synergy.event.CycleAction import CycleAction
+from intelligine.cst import COL_TRANSPORTER_CARRYING, COL_TRANSPORTER_NOT_CARRYING, \
+    COL_WALKER, ACTION_DIE, COL_ALIVE
 
+# TODO: Mettre ailleurs ?
+def bug_die(bug, context):
+    context.metas.collections.remove_list(bug.get_id(),
+                                          [COL_TRANSPORTER_CARRYING, \
+                                           COL_TRANSPORTER_NOT_CARRYING, \
+                                           COL_WALKER, \
+                                           COL_ALIVE],
+                                          allow_not_in=True)
+    context.metas.states.remove_list(bug.get_id(), [ALIVE, ATTACKABLE])
 
 class Simulation(BaseSimulation):
 
+    def connect_actions_signals(self, Signals):
+        Signals.signal(PutableAction).connect(lambda obj, context: \
+            context.metas.collections.add_remove(obj.get_id(), COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING))
+        Signals.signal(TakeableAction).connect(lambda obj, context: \
+            context.metas.collections.add_remove(obj.get_id(), COL_TRANSPORTER_CARRYING, COL_TRANSPORTER_NOT_CARRYING))
+        Signals.signal(ACTION_DIE).connect(lambda obj, context: bug_die(obj, context))
+
     def end_cycle(self, context):
         if context.get_cycle() % 100 is 0:
             context.metas.list.clean(POSITIONS)

intelligine/synergy/event/CycleEvent.py

 from synergine.synergy.event.Event import Event
-from intelligine.cst import CANT_CARRY_STILL, TRANSPORTER, ALIVE
+from intelligine.cst import COL_ALIVE # TODO: Crer une col TRANPORTER ?
 
 
 class CycleEvent(Event):
 
-    def concern(self, object_id, context):
-        return context.metas.states.have_list(object_id, [TRANSPORTER, ALIVE])
+    concern = COL_ALIVE
 
     def _object_match(self, object_id, context, parameters):
         return True

intelligine/synergy/event/attack/NearAttackableAction.py

 from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.attack.NearAttackableEvent import NearAttackableEvent
 from random import randint
-from intelligine.cst import ALIVE, ATTACKABLE
+from intelligine.cst import ALIVE, ATTACKABLE, ACTION_DIE
+from synergine.core.Signals import Signals
 
 
 class NearAttackableAction(Action):
         pass
 
     def run(self, obj, collection, context, synergy_manager):
-        # TODO: TEST
+        # TODO: reprendre ?
         for obj_id_attackable in self._parameters['objects_ids_attackable']:
             obj_attackable = synergy_manager.get_map().get_object(obj_id_attackable)
             obj_attackable.hurted(randint(0, 2))
             if obj_attackable.get_life_points() <= 0:
-                try:
-                    # TODO: Doit etre dans l'objet, lui sais cz qu'il perd comme etat
-                    context.metas.states.remove_list(obj_id_attackable, [ALIVE, ATTACKABLE])
-                except ValueError:  # Ant maybed killed by other ant at same turn
-                    pass
+                Signals.signal(ACTION_DIE).send(obj=obj_attackable, context=context)

intelligine/synergy/event/attack/NearAttackableEvent.py

 from synergine.synergy.event.Event import Event
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
-from intelligine.cst import ATTACKER, ATTACKABLE, COLONY, ALIVE
+from intelligine.cst import ATTACKABLE, COLONY, COL_FIGHTER
 
 
 class NearAttackableEvent(Event):
 
-    def concern(self, object_id, context):
-        return context.metas.states.have_list(object_id, [ATTACKER, ALIVE])
+    concern = COL_FIGHTER
 
     def __init__(self, actions):
         super().__init__(actions)

intelligine/synergy/event/move/MoveEvent.py

 from synergine.synergy.event.Event import Event
 from synergine.core.simulation.mechanism.Mechanism import Mechanism
-from intelligine.cst import ALIVE, WALKER
+from intelligine.cst import COL_WALKER
 
 
 class MoveEvent(Event):
 
-    def concern(self, object_id, context):
-        return context.metas.states.have_list(object_id, [ALIVE, WALKER])
+    concern = COL_WALKER
 
     def __init__(self, actions):
         super().__init__(actions)

intelligine/synergy/event/transport/PutableEvent.py

 from intelligine.synergy.event.transport.TakeableEvent import TakeableEvent
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
-from intelligine.cst import TRANSPORTER, ALIVE, CARRYING, CANT_PUT_STILL
+from intelligine.cst import CANT_PUT_STILL, COL_TRANSPORTER_CARRYING
 
 
 class PutableEvent(TakeableEvent):
 
-    def concern(self, object_id, context):
-        return context.metas.states.have_list(object_id, [TRANSPORTER, ALIVE, CARRYING]) \
-               and not context.metas.value.get(CANT_PUT_STILL, object_id, allow_empty=True)
+    concern = COL_TRANSPORTER_CARRYING
+
+    def _object_match(self, object_id, context, parameters={}):
+        if context.metas.value.get(CANT_PUT_STILL, object_id, allow_empty=True):
+            return False
+        return super()._object_match(object_id, context, parameters)

intelligine/synergy/event/transport/TakeableAction.py

 from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.transport.TakeableEvent import TakeableEvent
 from intelligine.cst import CANT_PUT_STILL
+from synergine.synergy.event.exception.ActionAborted import ActionAborted
 
 
 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)
-        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
+        if obj_transportable.is_carried():
+            raise ActionAborted()
+        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.cst import TRANSPORTABLE, TRANSPORTER, ALIVE, CARRYING, CANT_CARRY_STILL
+from intelligine.cst import TRANSPORTABLE, CANT_CARRY_STILL, COL_TRANSPORTER_NOT_CARRYING
 
 
 class TakeableEvent(Event):
 
-    def concern(self, object_id, context):
-        return context.metas.states.have_list(object_id, [TRANSPORTER, ALIVE]) and \
-               context.metas.states.dont_have(object_id, CARRYING) and not \
-               context.metas.value.get(CANT_CARRY_STILL, object_id, allow_empty=True) # TODO: si COLS: ca plus dans concern mais dans object_match
+    concern = COL_TRANSPORTER_NOT_CARRYING
 
     def __init__(self, actions):
         super().__init__(actions)
         self._mechanism = ArroundMechanism
 
     def _object_match(self, object_id, context, parameters={}):
+        if context.metas.value.get(CANT_CARRY_STILL, object_id, allow_empty=True):
+            return False
         # TODO: Nettoyer (refact possible sur ces objets ont tel states, comme dans concern)
         for obj_near_id in parameters['objects_ids_near']:
             if context.metas.states.have(obj_near_id, TRANSPORTABLE):

intelligine/synergy/object/BaseBug.py

 from xyzworld.SynergyObject import SynergyObject as XyzSynergyObject
-from synergine.metas import metas
-from intelligine.cst import ALIVE, ATTACKABLE, TRANSPORTABLE
+from intelligine.cst import ALIVE, ATTACKABLE, TRANSPORTABLE, COL_ALIVE
 
 
 class BaseBug(XyzSynergyObject):
 
-    def __init__(self):
-        super().__init__()
-        metas.states.add_list(self.get_id(), [ALIVE, ATTACKABLE])
+    def __init__(self, context):
+        super().__init__(context)
+        context.metas.states.add_list(self.get_id(), [ALIVE, ATTACKABLE])
+        context.metas.collections.add(self.get_id(), COL_ALIVE)
         self._life_points = 10
         self._carried_by = None
 
         if obj is not None:
             assert self._carried_by is None
             self._carried_by = obj
-            metas.states.remove(self.get_id(), TRANSPORTABLE)
+            self._context.metas.states.remove(self.get_id(), TRANSPORTABLE)
         else:
             assert self._carried_by is not None
             self._carried_by = None
-            metas.states.add(self.get_id(), TRANSPORTABLE)
+            self._context.metas.states.add(self.get_id(), TRANSPORTABLE)
 
     def is_carried(self):
         if self._carried_by:

intelligine/synergy/object/Bug.py

 from intelligine.synergy.object.BaseBug import BaseBug
-from synergine.metas import metas
-from intelligine.cst import WALKER
+from intelligine.cst import WALKER, COL_WALKER
 
 
 class Bug(BaseBug):
 
-    def __init__(self):
-        super().__init__()
-        metas.states.add(self.get_id(), WALKER)
+    def __init__(self, context):
+        super().__init__(context)
+        context.metas.states.add(self.get_id(), WALKER)
+        context.metas.collections.add(self.get_id(), COL_WALKER)

intelligine/synergy/object/Egg.py

 from intelligine.synergy.object.BaseBug import BaseBug
-from synergine.metas import metas
-from intelligine.cst import ALIVE, TRANSPORTABLE
+from intelligine.cst import TRANSPORTABLE
 
 
 class Egg(BaseBug):
 
-    def __init__(self):
-        super().__init__()
-        metas.states.add(self.get_id(), TRANSPORTABLE)
+    def __init__(self, context):
+        super().__init__(context)
+        context.metas.states.add(self.get_id(), TRANSPORTABLE)
         self._life_points = 1

intelligine/synergy/object/Rock.py

 from xyzworld.SynergyObject import SynergyObject as XyzSynergyObject
-from synergine.metas import metas
 from intelligine.cst import IMPENETRABLE
 
 
 class Rock(XyzSynergyObject):
 
-    def __init__(self):
-        super().__init__()
-        metas.states.add(self.get_id(), IMPENETRABLE)
+    def __init__(self, context):
+        super().__init__(context)
+        context.metas.states.add(self.get_id(), IMPENETRABLE)

intelligine/synergy/object/ant/Ant.py

 from intelligine.synergy.object.Bug import Bug
-from synergine.metas import metas
-from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER
+from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER, \
+    COL_TRANSPORTER_NOT_CARRYING, COL_FIGHTER
 
 
 class Ant(Bug):
 
-    def __init__(self):
-        super().__init__()
-        metas.states.add_list(self.get_id(), [TRANSPORTER, ATTACKER])
+    def __init__(self, context):
+        super().__init__(context)
+        context.metas.states.add_list(self.get_id(), [TRANSPORTER, ATTACKER])
+        context.metas.collections.add_list(self.get_id(), [COL_TRANSPORTER_NOT_CARRYING, COL_FIGHTER])
         self._carried = []
 
     def put_carry(self, obj):
         self._carried.remove(obj)
         obj.set_position(self.get_position())
-        metas.states.remove(self.get_id(), CARRYING)
+        self._context.metas.states.remove(self.get_id(), CARRYING)
 
     def get_carried(self):
         # TODO: cas ou plusieurs ?
 
     def carry(self, obj):
         self._carried.append(obj)
-        metas.states.add(self.get_id(), CARRYING)
+        self._context.metas.states.add(self.get_id(), CARRYING)
 
     def is_carrying(self):
         if len(self._carried):