use STATE shorcuts

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)
+        return context.metas.states.have(object_id, [TRANSPORTER, 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.synergy.Simulation import Simulation
 from intelligine.cst import ALIVE, ATTACKABLE
 
 
             obj_attackable.hurted(randint(0, 2))
             if obj_attackable.get_life_points() <= 0:
                 try:
-                    context.metas.list.remove(Simulation.STATE, obj_id_attackable, ALIVE)
-                    context.metas.list.remove(Simulation.STATE, obj_id_attackable, ATTACKABLE)
+                    # 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

intelligine/synergy/event/attack/NearAttackableEvent.py

 from synergine.synergy.event.Event import Event
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
-from synergine.synergy.Simulation import Simulation
 from intelligine.cst import ATTACKER, ATTACKABLE, COLONY, ALIVE
 
 
 class NearAttackableEvent(Event):
 
     def concern(self, object_id, context):
-        return context.metas.list.have(Simulation.STATE, object_id, ATTACKER) and \
-               context.metas.list.have(Simulation.STATE, object_id, ALIVE)
+        return context.metas.states.have(object_id, [ATTACKER, ALIVE])
 
     def __init__(self, actions):
         super().__init__(actions)
         # TODO: nettoyer
         obj_colony_id = context.metas.value.get(COLONY, object_id)
         for obj_near_id in parameters['objects_ids_near']:
-            if context.metas.list.have(Simulation.STATE, obj_near_id, ATTACKABLE):
+            if context.metas.states.have(obj_near_id, [ATTACKABLE]):
                 if obj_colony_id != context.metas.value.get(COLONY, obj_near_id):
                     if 'objects_ids_attackable' not in parameters:
                         parameters['objects_ids_attackable'] = []

intelligine/synergy/event/move/MoveAction.py

 from random import randint, choice
 from xyzworld.cst import POSITION, POSITIONS
 from intelligine.cst import IMPENETRABLE, PREVIOUS_DIRECTION, BLOCKED_SINCE
-from synergine.synergy.Simulation import Simulation
 from intelligine.synergy.event.move.direction import directions_same_level, directions_modifiers, directions_slighty
 
 
     def _direction_point_is_possible(self, context, direction_point):
         objects_ids_on_this_point = context.metas.list.get(POSITIONS, direction_point, allow_empty=True)
         for object_id_on_this_point in objects_ids_on_this_point:
-          if context.metas.list.have(Simulation.STATE, object_id_on_this_point, IMPENETRABLE):
+          if context.metas.states.have(object_id_on_this_point, [IMPENETRABLE]):
             return False
         return True
 

intelligine/synergy/event/move/MoveEvent.py

 from synergine.synergy.event.Event import Event
 from synergine.core.simulation.mechanism.Mechanism import Mechanism
-from intelligine.synergy.Simulation import Simulation
 from intelligine.cst import ALIVE, WALKER
 
 
 class MoveEvent(Event):
 
     def concern(self, object_id, context):
-        return context.metas.list.have(Simulation.STATE, object_id, ALIVE) and \
-               context.metas.list.have(Simulation.STATE, object_id, WALKER)
+        return context.metas.states.have(object_id, [ALIVE, 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.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)
+        return context.metas.states.have(object_id, [TRANSPORTER, ALIVE, CARRYING]) \
+               and not context.metas.value.get(CANT_PUT_STILL, object_id, allow_empty=True)

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, 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) and \
-               not context.metas.value.get(CANT_CARRY_STILL, object_id, allow_empty=True)
+        return context.metas.states.have(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)
 
     def __init__(self, actions):
         super().__init__(actions)
     def _object_match(self, object_id, context, parameters={}):
         # 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.list.have(Simulation.STATE, obj_near_id, TRANSPORTABLE):
+            if context.metas.states.have(obj_near_id, [TRANSPORTABLE]):
                 if 'objects_ids_transportable' not in parameters:
                     parameters['objects_ids_transportable'] = []
                 parameters['objects_ids_transportable'].append(obj_near_id)

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 synergine.synergy.Simulation import Simulation
 
 
 class BaseBug(XyzSynergyObject):
 
     def __init__(self):
         super().__init__()
-        metas.list.add(Simulation.STATE, self.get_id(), ALIVE)
-        metas.list.add(Simulation.STATE, self.get_id(), ATTACKABLE)
+        metas.states.add_list(self.get_id(), [ALIVE, ATTACKABLE])
         self._life_points = 10
         self._carried_by = None
 
         if obj is not None:
             assert self._carried_by is None
             self._carried_by = obj
-            metas.list.remove(Simulation.STATE, self.get_id(), TRANSPORTABLE)
+            metas.states.remove(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)
+            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 synergine.synergy.Simulation import Simulation
 
 
 class Bug(BaseBug):
 
     def __init__(self):
         super().__init__()
-        metas.list.add(Simulation.STATE, self.get_id(), WALKER)
+        metas.states.add(self.get_id(), 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 synergine.synergy.Simulation import Simulation
 
 
 class Egg(BaseBug):
 
     def __init__(self):
         super().__init__()
-        metas.list.add(Simulation.STATE, self.get_id(), TRANSPORTABLE)
+        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
-from synergine.synergy.Simulation import Simulation
 
 
 class Rock(XyzSynergyObject):
 
     def __init__(self):
         super().__init__()
-        metas.list.add(Simulation.STATE, self.get_id(), IMPENETRABLE)
+        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.synergy.Simulation import Simulation
 from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER
 
 
 
     def __init__(self):
         super().__init__()
-        metas.list.add(Simulation.STATE, self.get_id(), TRANSPORTER)
-        metas.list.add(Simulation.STATE, self.get_id(), ATTACKER)
+        metas.states.add_list(self.get_id(), [TRANSPORTER, 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)
+        metas.states.remove(self.get_id(), CARRYING)
 
     def get_carried(self):
         # TODO: cas ou plusieurs ?
 
     def carry(self, obj):
         self._carried.append(obj)
-        metas.list.add(Simulation.STATE, self.get_id(), CARRYING)
+        metas.states.add(self.get_id(), CARRYING)
 
     def is_carrying(self):
         if len(self._carried):