attack event and action

config.py

@@ -4,6 +4,14 @@ from intelligine.display.Pygame import Pygame
 from intelligine.display.pygame.visualisation import visualisation as pygame_visualisation
 from intelligine.sandbox.redblue.red_blue_colonys import collections
 
+"""
+ TODO:
+ * AttackAction :: comment choisir entre les actions ?
+ * TakeAction, PutAction, Object Egg
+ * Plusieurs objets au mm endroit; Cinq oeuf => dessein de cinq oeuf; etc (image dynamique (param max_supperposer ?)
+ * 3d
+"""
+
 config = {
     'app': {
         'name': 'StigEngine',
@@ -12,7 +20,7 @@ config = {
         }
     },
     'engine': {
-        'fpsmax': 5,
+        'fpsmax': 225,
         'debug': {
             'mainprocess': True,
             'cycles': -1

intelligine/cst.py

@@ -3,4 +3,7 @@ from synergine.lib.eint import IncrementedNamedInt
 ALIVE = IncrementedNamedInt.get('intelligine.alive')
 IMPENETRABLE = IncrementedNamedInt.get('intelligine.impenetrable')
 PREVIOUS_DIRECTION = IncrementedNamedInt.get('intelligine.previous_direction')
-BLOCKED_SINCE = IncrementedNamedInt.get('intelligine.blocked_since')
+BLOCKED_SINCE = IncrementedNamedInt.get('intelligine.blocked_since')
+ATTACKABLE = IncrementedNamedInt.get('intelligine.attackable')
+ATTACKER = IncrementedNamedInt.get('intelligine.attacker')
+COLONY = IncrementedNamedInt.get('intelligine.colony')

intelligine/synergy/Colony.py

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

intelligine/synergy/ColonyConfiguration.py

@@ -1,8 +1,7 @@
 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
-from synergine.synergy.Simulation import Simulation
+from intelligine.cst import ALIVE, COLONY
 
 
 class ColonyConfiguration(Configuration):
@@ -10,13 +9,13 @@ class ColonyConfiguration(Configuration):
     _start_position = (0, 20, 20)
     _ant_class = Ant
 
-    def get_start_objects(self):
+    def get_start_objects(self, collection):
 
       ants = []
       for i in range(100):
           ant = self._ant_class()
+          metas.value.set(COLONY, ant.get_id(), collection.get_id())
           ant.set_position(self._start_position)
-          metas.list.add(Simulation.STATE, ant.get_id(), ALIVE)
           ants.append(ant)
 
       return ants

intelligine/synergy/RocksConfiguration.py

@@ -7,7 +7,7 @@ from synergine.synergy.Simulation import Simulation
 
 class RocksConfiguration(Configuration):
 
-    def get_start_objects(self):
+    def get_start_objects(self, collection):
 
       rocks = []
 

intelligine/synergy/event/attack/NearAttackableAction.py

@@ -0,0 +1,28 @@
+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
+
+
+class NearAttackableAction(Action):
+
+    _listen = NearAttackableEvent
+
+    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
+        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:
+                    context.metas.list.remove(Simulation.STATE, obj_id_attackable, ALIVE)
+                    context.metas.list.remove(Simulation.STATE, obj_id_attackable, ATTACKABLE)
+                except ValueError:  # Ant maybed killed by other ant at same turn
+                    pass

intelligine/synergy/event/attack/NearAttackableEvent.py

@@ -0,0 +1,28 @@
+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)
+
+    def __init__(self, actions):
+        super().__init__(actions)
+        self._mechanism = ArroundMechanism
+
+    def _object_match(self, object_id, context, parameters={}):
+      # 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 obj_colony_id != context.metas.value.get(COLONY, obj_near_id):
+                    if 'objects_ids_attackable' not in parameters:
+                        parameters['objects_ids_attackable'] = []
+                    parameters['objects_ids_attackable'].append(obj_near_id)
+        if 'objects_ids_attackable' not in parameters:
+            return False
+        return True

intelligine/synergy/event/move/MoveAction.py

@@ -58,7 +58,7 @@ class MoveAction(Action):
             return False
         return True
 
-    def run(self, obj, collection, context):
+    def run(self, obj, collection, context, synergy_manager):
         if self._move_to_point is not None:
             obj.set_position(self._move_to_point)
             context.metas.value.set(PREVIOUS_DIRECTION, self._object_id, self._move_to_direction)

intelligine/synergy/event/move/MoveEvent.py

@@ -1,11 +1,13 @@
 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
 
 
 class MoveEvent(Event):
 
     def concern(self, object_id, context):
-        return True
+        return context.metas.list.have(Simulation.STATE, object_id, ALIVE)
 
     def __init__(self, actions):
         super().__init__(actions)

intelligine/synergy/object/Bug.py

@@ -1,4 +1,20 @@
 from xyzworld.SynergyObject import SynergyObject as XyzSynergyObject
+from synergine.metas import metas
+from intelligine.cst import ALIVE, ATTACKABLE, ATTACKER
+from synergine.synergy.Simulation import Simulation
+
 
 class Bug(XyzSynergyObject):
-  pass
+
+    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