Transport of eggs

intelligine/cst.py

@@ -1,9 +1,13 @@
 from synergine.lib.eint import IncrementedNamedInt
 
 ALIVE = IncrementedNamedInt.get('intelligine.alive')
+WALKER = IncrementedNamedInt.get('intelligine.walker')
 IMPENETRABLE = IncrementedNamedInt.get('intelligine.impenetrable')
 PREVIOUS_DIRECTION = IncrementedNamedInt.get('intelligine.previous_direction')
 BLOCKED_SINCE = IncrementedNamedInt.get('intelligine.blocked_since')
 ATTACKABLE = IncrementedNamedInt.get('intelligine.attackable')
 ATTACKER = IncrementedNamedInt.get('intelligine.attacker')
-COLONY = IncrementedNamedInt.get('intelligine.colony')
+COLONY = IncrementedNamedInt.get('intelligine.colony')
+TRANSPORTABLE = IncrementedNamedInt.get('intelligine.transportable')
+TRANSPORTER = IncrementedNamedInt.get('intelligine.transporter')
+CARRYING = IncrementedNamedInt.get('intelligine.carrying')

intelligine/display/pygame/visualisation.py

@@ -6,6 +6,7 @@ from intelligine.sandbox.colored.BlueAnt import BlueAnt
 from intelligine.sandbox.colored.RedAnt import RedAnt
 from intelligine.sandbox.colored.GreenAnt import GreenAnt
 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
@@ -22,6 +23,7 @@ dead_green_ant = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame
 dead_blue_ant = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/dead_blue_ant.png')
 bug = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/ant.png')
 rock = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/rock.png')
+egg = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/egg.png')
 
 directions_ant = DirectionnedImage(ant)
 directions_red_ant = DirectionnedImage(red_ant)
@@ -87,6 +89,9 @@ visualisation = {
             'default': bug,
             'callbacks': [bug_direction]
         },
+        Egg: {
+            'default': egg
+        },
         Rock: {
             'default': rock
         }

intelligine/sandbox/colored/RedColonyConfiguration.py

@@ -1,8 +1,26 @@
 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
 
 
 class RedColonyConfiguration(ColonyConfiguration):
 
     _start_position = (0, 20, 70)
-    _ant_class = RedAnt
+    _ant_class = RedAnt
+
+    def get_start_objects(self, collection):
+        objects = super().get_start_objects(collection)
+
+        for x in range(50):
+          for y in range(1, 50):
+            if x % 2 == 0 and y % 2 == 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)
+              metas.value.set(COLONY, egg.get_id(), collection.get_id())
+              objects.append(egg)
+
+        return objects
+

intelligine/synergy/Colony.py

@@ -1,6 +1,7 @@
 from synergine.synergy.collection.SynergyCollection import SynergyCollection
 from intelligine.synergy.event.move.MoveAction import MoveAction
 from intelligine.synergy.event.attack.NearAttackableAction import NearAttackableAction
+from intelligine.synergy.event.transport.TakeableAction import TakeableAction
 
 
 class Colony(SynergyCollection):
@@ -8,4 +9,4 @@ class Colony(SynergyCollection):
 
     def __init__(self, configuration):
         super().__init__(configuration)
-        self._actions = [MoveAction, NearAttackableAction]
+        self._actions = [MoveAction, NearAttackableAction, TakeableAction]

intelligine/synergy/event/attack/NearAttackableEvent.py

@@ -15,7 +15,7 @@ class NearAttackableEvent(Event):
         self._mechanism = ArroundMechanism
 
     def _object_match(self, object_id, context, parameters={}):
-      # TODO: nettoyer
+        # 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):

intelligine/synergy/event/move/MoveEvent.py

@@ -1,13 +1,14 @@
 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
+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)
+        return context.metas.list.have(Simulation.STATE, object_id, ALIVE) and \
+               context.metas.list.have(Simulation.STATE, object_id, WALKER)
 
     def __init__(self, actions):
         super().__init__(actions)

intelligine/synergy/event/transport/TakeableAction.py

@@ -0,0 +1,27 @@
+from synergine.synergy.event.Action import Action
+from intelligine.synergy.event.transport.TakeableEvent import TakeableEvent
+from random import randint
+
+
+class TakeableAction(Action):
+
+    _listen = TakeableEvent
+
+    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)
+        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

intelligine/synergy/event/transport/TakeableEvent.py

@@ -0,0 +1,27 @@
+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
+
+
+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)
+
+    def __init__(self, actions):
+        super().__init__(actions)
+        self._mechanism = ArroundMechanism
+
+    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 'objects_ids_transportable' not in parameters:
+                    parameters['objects_ids_transportable'] = []
+                parameters['objects_ids_transportable'].append(obj_near_id)
+        if 'objects_ids_transportable' not in parameters:
+            return False
+        return True

intelligine/synergy/object/BaseBug.py

@@ -0,0 +1,29 @@
+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)
+        self._life_points = 10
+        self._carried_by = []
+
+    def hurted(self, points):
+        self._life_points -= points
+
+    def get_life_points(self):
+        return self._life_points
+
+    def set_carried_by(self, obj):
+        self._carried_by.append(obj)
+        metas.list.remove(Simulation.STATE, self.get_id(), TRANSPORTABLE)
+
+    def is_carried(self):
+        if self._carried_by:
+            return True
+        return False

intelligine/synergy/object/Bug.py

@@ -1,20 +1,11 @@
-from xyzworld.SynergyObject import SynergyObject as XyzSynergyObject
+from intelligine.synergy.object.BaseBug import BaseBug
 from synergine.metas import metas
-from intelligine.cst import ALIVE, ATTACKABLE, ATTACKER
+from intelligine.cst import WALKER
 from synergine.synergy.Simulation import Simulation
 
 
-class Bug(XyzSynergyObject):
+class Bug(BaseBug):
 
     def __init__(self):
         super().__init__()
-        metas.list.add(Simulation.STATE, self.get_id(), ALIVE)
-        metas.list.add(Simulation.STATE, self.get_id(), ATTACKER)
-        metas.list.add(Simulation.STATE, self.get_id(), ATTACKABLE)
-        self._life_points = 10
-
-    def hurted(self, points):
-        self._life_points -= points
-
-    def get_life_points(self):
-        return self._life_points
+        metas.list.add(Simulation.STATE, self.get_id(), WALKER)

intelligine/synergy/object/Egg.py

@@ -0,0 +1,12 @@
+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)
+        self._life_points = 1

intelligine/synergy/object/ant/Ant.py

@@ -1,4 +1,29 @@
 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
+
 
 class Ant(Bug):
-  pass
+
+    def __init__(self):
+        super().__init__()
+        metas.list.add(Simulation.STATE, self.get_id(), TRANSPORTER)
+        metas.list.add(Simulation.STATE, self.get_id(), ATTACKER)
+        self._carried = []
+
+    def carry(self, obj):
+        self._carried.append(obj)
+        metas.list.add(Simulation.STATE, self.get_id(), CARRYING)
+
+    def is_carrying(self):
+        if len(self._carried):
+            return True
+        return False
+
+    # TODO: Est-ce ici que doit etre ce code ?
+    def set_position(self, position):
+        super().set_position(position)
+        if self.is_carrying():
+            for obj_carried in self._carried:
+                obj_carried.set_position(position)

intelligine/synergy/object/ant/Egg.py

@@ -0,0 +1,4 @@
+from intelligine.synergy.object.Egg import Egg as BaseEgg
+
+class Egg(BaseEgg):
+    pass