Fire and kill

sandbox/tile/config.yaml

 core:
     cycle_duration: 0.25
-    use_x_cores: 1
+    use_x_cores: 2
 terminals:
     sync: True
 game:
+    look_around:
+        frequency: 1
+    engage:
+        frequency: 2
     move:
         walk_ref_time: 3
         run_ref_time: 1

sandbox/tile/const.py

 FLAG_URSS = 'URSS'
 
 SIDE = 'SIDE'
+COMBAT_MODE = 'COMBAT_MODE'
+COMBAT_MODE_DEFENSE = 'COMBAT_MODE_DEFENSE'
 
 DE_COLOR = (0, 81, 211)
 URSS_COLOR = (204, 0, 0)

sandbox/tile/gui/base.py

 # coding: utf-8
+import os
+import random
 import typing
 
+import pyglet
 from pyglet.window import key
 
 from cocos.actions import MoveTo as BaseMoveTo
+from cocos.audio.pygame.mixer import Sound
 from sandbox.tile.user_action import UserAction
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
 from synergine2_xyz.utils import get_angle
 from sandbox.tile.simulation.event import NewVisibleOpponent
 from sandbox.tile.simulation.event import NoLongerVisibleOpponent
+from sandbox.tile.simulation.event import FireEvent
+from sandbox.tile.simulation.event import DieEvent
 
 
 class EditLayer(BaseEditLayer):
     edit_layer_class = EditLayer
 
 
+# TODO: Move into synergine2cocos2d
+class AudioLibrary(object):
+    sound_file_paths = {
+        'gunshot_default': '204010__duckduckpony__homemade-gunshot-2.ogg',
+    }
+
+    def __init__(self, sound_dir_path: str) -> None:
+        self._sound_dir_path = sound_dir_path
+        self._sounds = {}
+
+    def get_sound(self, name: str) -> Sound:
+        if name not in self._sounds:
+            sound_file_name = self.sound_file_paths[name]
+            self._sounds[name] = Sound(os.path.join(self._sound_dir_path, sound_file_name))
+        return self._sounds[name]
+
+
 class Game(TMXGui):
     layer_manager_class = TileLayerManager
 
             read_queue_interval=read_queue_interval,
             map_dir_path=map_dir_path,
         )
+        self.sound_lib = AudioLibrary('sandbox/tile/sounds/')
 
         self.terminal.register_event_handler(
             FinishMoveEvent,
             self.no_longer_visible_opponent,
         )
 
+        self.terminal.register_event_handler(
+            FireEvent,
+            self.fire_happen,
+        )
+
+        self.terminal.register_event_handler(
+            DieEvent,
+            self.subject_die,
+        )
+
         # configs
         self.move_duration_ref = float(self.config.resolve('game.move.walk_ref_time'))
         self.move_fast_duration_ref = float(self.config.resolve('game.move.run_ref_time'))
             observer_actor = self.layer_manager.subject_layer.subjects_index[event.observer_subject_id]
             observed_actor = self.layer_manager.subject_layer.subjects_index[event.observed_subject_id]
 
-            observer_pixel_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
-                observer_actor.subject.position,
+            observer_pixel_position = self.layer_manager.scrolling_manager.world_to_screen(
+                *self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                    observer_actor.subject.position,
+                )
             )
-            observed_pixel_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
-                observed_actor.subject.position,
+            observed_pixel_position = self.layer_manager.scrolling_manager.world_to_screen(
+                *self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                    observed_actor.subject.position,
+                )
             )
 
             def draw_visible_opponent():
                     line_color,
                 )
 
+            # TODO: Not in edit layer !
             self.layer_manager.edit_layer.append_callback(draw_visible_opponent, 1.0)
+
+    def fire_happen(self, event: FireEvent) -> None:
+        # TODO: Not in edit layer !
+        shooter_actor = self.layer_manager.subject_layer.subjects_index[event.shooter_subject_id]
+        shooter_pixel_position = self.layer_manager.scrolling_manager.world_to_screen(
+            *self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                shooter_actor.subject.position,
+            )
+        )
+        fire_to_pixel_position = self.layer_manager.scrolling_manager.world_to_screen(
+            *self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                event.target_position,
+            )
+        )
+
+        def gunshot_trace():
+            draw_line(
+                shooter_pixel_position,
+                fire_to_pixel_position,
+                color=(255, 0, 0),
+            )
+
+        def gunshot_sound():
+            self.sound_lib.get_sound('gunshot_default').play()
+
+        # To avoid all in same time
+        delay = random.uniform(0.0, 0.6)
+
+        self.layer_manager.edit_layer.append_callback(gunshot_trace, duration=0.1, delay=delay)
+        self.layer_manager.edit_layer.append_callback(gunshot_sound, duration=0.0, delay=delay)
+
+    def subject_die(self, event: DieEvent) -> None:
+        killed_actor = self.layer_manager.subject_layer.subjects_index[event.shoot_subject_id]
+        dead_image = pyglet.resource.image('maps/003/actors/man_d1.png')
+        killed_actor.update_image(dead_image)
+        killed_actor.freeze()

sandbox/tile/run.py

 from synergine2.terminals import TerminalManager
 
 
-def main(map_dir_path: str, seed_value: int=42):
-    seed(seed_value)
+def main(map_dir_path: str, seed_value: int=None):
+    if seed_value is not None:
+        seed(seed_value)
 
     config = Config()
     config.load_yaml('sandbox/tile/config.yaml')
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Run TileStrategy')
     parser.add_argument('map_dir_path', help='map directory path')
-    parser.add_argument('--seed', dest='seed', default=42)
+    parser.add_argument('--seed', dest='seed', default=None)
 
     args = parser.parse_args()
 

sandbox/tile/simulation/base.py

 # coding: utf-8
-
+from sandbox.tile.const import COLLECTION_ALIVE
 from sandbox.tile.simulation.physics import TilePhysics
 from synergine2.config import Config
+from synergine2.simulation import SubjectBehaviour
 from synergine2_xyz.physics import Physics
 from synergine2_xyz.simulation import XYZSimulation
 from synergine2_xyz.subjects import XYZSubject
 
 class BaseSubject(XYZSubject):
     pass
+
+
+class AliveSubjectBehaviour(SubjectBehaviour):
+    def is_terminated(self) -> bool:
+        return COLLECTION_ALIVE not in self.subject.collections

sandbox/tile/simulation/behaviour.py

 # coding: utf-8
+import random
 import time
+import typing
 
+from sandbox.tile.const import COLLECTION_ALIVE
+from sandbox.tile.simulation.base import AliveSubjectBehaviour
 from sandbox.tile.simulation.event import NoLongerVisibleOpponent
+from sandbox.tile.simulation.event import FireEvent
+from sandbox.tile.simulation.event import DieEvent
 from sandbox.tile.simulation.event import NewVisibleOpponent
 from sandbox.tile.simulation.mechanism import OpponentVisibleMechanism
 from sandbox.tile.user_action import UserAction
 from synergine2.config import Config
 from synergine2.simulation import Simulation
-from synergine2.simulation import SubjectBehaviour
 from synergine2.simulation import Event
 from synergine2.simulation import Subject
 from synergine2_xyz.move.simulation import MoveToBehaviour as BaseMoveToBehaviour
         self._run_duration = float(self.config.resolve('game.move.run_ref_time'))
         self._crawl_duration = float(self.config.resolve('game.move.crawl_ref_time'))
 
+    def is_terminated(self) -> bool:
+        return COLLECTION_ALIVE not in self.subject.collections
+
     def _can_move_to_next_step(self, move_to_data: dict) -> bool:
         if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
             return time.time() - move_to_data['last_intention_time'] >= self._walk_duration
             return time.time() - move_to_data['last_intention_time'] >= self._crawl_duration
 
 
-class LookAroundBehaviour(SubjectBehaviour):
+class LookAroundBehaviour(AliveSubjectBehaviour):
     """
     Behaviour who permit to reference visible things like enemies
     """
     visible_mechanism = OpponentVisibleMechanism
     use = [visible_mechanism]
-    force_action = True
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._seconds_frequency = float(self.config.resolve('game.look_around.frequency'))
+
+    @property
+    def seconds_frequency(self) -> typing.Optional[float]:
+        return self._seconds_frequency
 
     def action(self, data) -> [Event]:
         new_visible_subject_events = []
             'new_visible_subject_ids': new_visible_subject_ids,
             'no_longer_visible_subject_ids': no_longer_visible_subject_ids,
         }
+
+
+class EngageOpponent(AliveSubjectBehaviour):
+    visible_mechanism = OpponentVisibleMechanism
+    use = [visible_mechanism]
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._seconds_frequency = float(self.config.resolve('game.engage.frequency'))
+
+    @property
+    def seconds_frequency(self) -> typing.Optional[float]:
+        return self._seconds_frequency
+
+    def action(self, data) -> [Event]:
+        kill = data['kill']
+        target_subject_id = data['target_subject_id']
+        target_subject = self.simulation.subjects.index[target_subject_id]
+        target_position = data['target_position']
+
+        events = list()
+        events.append(FireEvent(shooter_subject_id=self.subject.id, target_position=target_position))
+
+        if kill:
+            target_subject.collections.remove(COLLECTION_ALIVE)
+            # FIXME: Must be automatic when manipulate subject collections !
+            self.simulation.collections[COLLECTION_ALIVE].remove(target_subject_id)
+            self.simulation.collections[COLLECTION_ALIVE] = self.simulation.collections[COLLECTION_ALIVE]
+            events.append(DieEvent(shooter_subject_id=self.subject.id, shoot_subject_id=target_subject_id))
+
+        return events
+
+    def run(self, data):
+        visible_subjects = data[self.visible_mechanism]['visible_subjects']
+        if not visible_subjects:
+            return
+        # Manage selected target (can change, better visibility, etc ...)
+        # Manage weapon munition to be able to fire
+        # Manage fear/under fire ...
+        # Manage weapon reload time
+
+        # For dev fun, don't fire at random
+        if random.randint(1, 3) == -1:
+            # Executed but decided to fail
+            self.last_execution_time = time.time()
+            return False
+
+        target_subject = random.choice(visible_subjects)
+        kill = random.randint(0, 100) >= 75
+
+        # Manage fire miss or touch (visibility, fear, opponent hiding, etc ...)
+        return {
+            'kill': kill,
+            'target_subject_id': target_subject.id,
+            'target_position': target_subject.position,
+        }

sandbox/tile/simulation/event.py

 
 
 # TODO: Reprendre les events Move, pour les lister tous ici
+import typing
+
 from synergine2.simulation import Event
 
 
     ) -> None:
         self.observer_subject_id = observer_subject_id
         self.observed_subject_id = observed_subject_id
+
+
+class FireEvent(Event):
+    def __init__(
+        self,
+        shooter_subject_id: int,
+        target_position: typing.Tuple[int, int],
+    ) -> None:
+        self.shooter_subject_id = shooter_subject_id
+        self.target_position = target_position
+
+
+class DieEvent(Event):
+    def __init__(
+        self,
+        shooter_subject_id: int,
+        shoot_subject_id: int,
+    ) -> None:
+        self.shooter_subject_id = shooter_subject_id
+        self.shoot_subject_id = shoot_subject_id

sandbox/tile/simulation/mechanism.py

 # coding: utf-8
 import typing
 
-from sandbox.tile.const import SIDE
+from sandbox.tile.const import SIDE, COLLECTION_ALIVE
 from synergine2_xyz.subjects import XYZSubject
 from synergine2_xyz.visible.simulation import VisibleMechanism
 
 
 class OpponentVisibleMechanism(VisibleMechanism):
+    from_collection = COLLECTION_ALIVE
+
     def reduce_subjects(self, subjects: typing.List[XYZSubject]) -> typing.Iterator[XYZSubject]:
-        def is_opponent(subject: XYZSubject) -> bool:
+        def filter_subject(subject: XYZSubject) -> bool:
             return self.subject.properties[SIDE] != subject.properties[SIDE]
 
-        return filter(is_opponent, subjects)
+        return filter(filter_subject, subjects)

sandbox/tile/simulation/subject.py

 # coding: utf-8
-from sandbox.tile.const import COLLECTION_ALIVE
+from sandbox.tile.const import COLLECTION_ALIVE, COMBAT_MODE_DEFENSE
 from sandbox.tile.simulation.base import BaseSubject
 from sandbox.tile.simulation.behaviour import MoveToBehaviour
+from sandbox.tile.simulation.behaviour import EngageOpponent
 from sandbox.tile.simulation.behaviour import LookAroundBehaviour
 from synergine2.share import shared
 
     behaviours_classes = [
         MoveToBehaviour,
         LookAroundBehaviour,
+        EngageOpponent,
     ]
     visible_opponent_ids = shared.create_self('visible_opponent_ids', lambda: [])
+    combat_mode = shared.create_self('combat_mode', COMBAT_MODE_DEFENSE)
     # TODO: implement (copied from engulf)
     # behaviour_selector_class = CellBehaviourSelector

sandbox/tile/terminal/base.py

 # coding: utf-8
 from sandbox.tile.simulation.event import NewVisibleOpponent
+from sandbox.tile.simulation.event import FireEvent
+from sandbox.tile.simulation.event import DieEvent
 from sandbox.tile.simulation.event import NoLongerVisibleOpponent
 from sandbox.tile.simulation.physics import TilePhysics
 from sandbox.tile.simulation.subject import TileSubject as ManSubject
         StartMoveEvent,
         NewVisibleOpponent,
         NoLongerVisibleOpponent,
+        FireEvent,
+        DieEvent,
     ]
 
     def __init__(self, *args, asynchronous: bool, map_dir_path: str, **kwargs):

synergine2/cycle.py

 import multiprocessing
 import typing
 
+import time
+
 from synergine2.base import BaseObject
 from synergine2.config import Config
 from synergine2.exceptions import SynergineException
                 str(len(subject_behaviours)),
             ))
 
-            for behaviour in subject_behaviours.values():
+            for behaviour_key, behaviour in list(subject_behaviours.items()):
                 self.logger.info('Subject {}: run {} behaviour'.format(
                     str(subject.id),
                     str(type(behaviour)),
                 ))
 
-                # We identify behaviour data with it's class to be able to intersect it after subprocess data collect
-                with time_it() as elapsed_time:
-                    behaviour_data = behaviour.run(mechanisms_data)  # TODO: Behaviours dependencies
+                if behaviour.is_terminated():
+                    del subject.behaviours[behaviour_key]
 
-                if self.logger.is_debug:
-                    self.logger.debug('Subject {}: behaviour {} produce data: {} in {}s'.format(
-                        str(type(behaviour)),
+                # We identify behaviour data with it's class to be able to intersect it after subprocess data collect
+                if behaviour.is_skip(self.current_cycle):
+                    behaviour_data = False
+                    self.logger.debug('Subject {}: behaviour {} skip'.format(
                         str(subject.id),
-                        str(behaviour_data),
-                        elapsed_time.get_final_time(),
+                        str(type(behaviour)),
                     ))
+                else:
+                    with time_it() as elapsed_time:
+                        behaviour.last_execution_time = time.time()
+                        behaviour_data = behaviour.run(mechanisms_data)  # TODO: Behaviours dependencies
+                        if self.logger.is_debug:
+                            self.logger.debug('Subject {}: behaviour {} produce data: {} in {}s'.format(
+                                str(type(behaviour)),
+                                str(subject.id),
+                                str(behaviour_data),
+                                elapsed_time.get_final_time(),
+                            ))
 
                 if behaviour_data:
                     behaviours_data[behaviour.__class__] = behaviour_data

synergine2/processing.py

 # coding: utf-8
+import random
 import typing
 from multiprocessing import Process
 from multiprocessing.connection import Connection
             args=(
                 self.local_write_pipe,
                 self.process_read_pipe,
-            )
+            ),
+            kwargs={'seed': random.random()}
         )
-        self.db = None  # type: RedisDatabase
+        self.db = None  # TODO delete
         self.process.start()
 
     def work(self, *args, **kwargs):
+        seed_value = kwargs.pop('seed')
+        random.seed(seed_value)
         while True:
             args = self.process_read_pipe.recv()
             if args == STOP:

synergine2/share.py

         super().remove(object_)
         self.shared.set(self.shared_data.get_final_key(self.instance), list(self))
 
+    def extend(self, iterable) -> None:
+        super().extend(iterable)
+        self.shared.set(self.shared_data.get_final_key(self.instance), list(self))
+
     # TODO: Cover all methods
 
 

synergine2/simulation.py

 # coding: utf-8
 import typing
 
+import time
+
 from synergine2.base import BaseObject
 from synergine2.base import IdentifiedObject
 from synergine2.config import Config
     behaviours_classes = []
     behaviour_selector_class = None  # type: typing.Type[SubjectBehaviourSelector]
     intention_manager_class = None  # type: typing.Type[IntentionManager]
+    collections = shared.create_self('collections', lambda: [])
 
     def __init__(
         self,
         """
         super().__init__()
         # FIXME: use shared data to permit dynamic start_collections
-        self.collections = self.start_collections[:]
+        self.collections.extend(self.start_collections[:])
 
         self.config = config
         self._id = id(self)  # We store object id because it's lost between process
     behaviours_classes = []
 
     subject_classes = shared.create('subject_classes', {})
-    collections = shared.create('start_collections', {})
+    collections = shared.create('collections', {})
 
     def __init__(
         self,
 
 
 class SubjectBehaviour(Behaviour):
-    frequency = 1
     use = []  # type: typing.List[typing.Type[SubjectMechanism]]
 
     def __init__(
         self.config = config
         self.simulation = simulation
         self.subject = subject
+        self.last_execution_time = 0
+
+    @property
+    def cycle_frequency(self) -> typing.Optional[float]:
+        return None
+
+    @property
+    def seconds_frequency(self) -> typing.Optional[float]:
+        return None
+
+    def is_terminated(self) -> bool:
+        """
+        :return: True if behaviour will no longer exist (can be removed from simulation)
+        """
+        return False
+
+    def is_skip(self, cycle_number: int) -> bool:
+        """
+        :return: True if behaviour have to be skip this time
+        """
+        if self.cycle_frequency is not None:
+            return not bool(cycle_number % self.cycle_frequency)
+
+        if self.seconds_frequency is not None:
+            return time.time() - self.last_execution_time <= self.seconds_frequency
+
+        return False
 
     def run(self, data):
         """

synergine2_cocos2d/actor.py

         self.current_image = image
         self.need_update_cshape = False
         self.properties = properties or {}
+        self._freeze = False
+
+    def freeze(self) -> None:
+        """
+        Set object to freeze mode: No visual modification can be done anymore
+        """
+        self._freeze = True
 
     def stop_actions(self, action_types: typing.Tuple[typing.Type[cocos.actions.Action], ...]) -> None:
         for action in self.actions:
         self.need_update_cshape = False
 
     def update_position(self, new_position: euclid.Vector2) -> None:
+        if self._freeze:
+            return
+
         self.position = new_position
         self.cshape.center = new_position  # Note: if remove: strange behaviour: drag change actor position with anomaly
 
         return self.current_image
 
     def update_image(self, new_image: pyglet.image.TextureRegion):
+        if self._freeze:
+            return
+
         self.image = new_image
         self.image_anchor = new_image.width // 2, new_image.height // 2

synergine2_cocos2d/gui.py

 import cocos
 from cocos import collision_model
 from cocos import euclid
+from cocos.audio.pygame import mixer
 from cocos.layer import ScrollableLayer
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
         self,
         func: typing.Callable[[], None],
         duration: float,
+        delay: float=None,
     ) -> None:
         self.func = func
         self.duration = duration
         # Started timestamp
         self.started = None  # type: float
+        self.require_delay = False
+        self.delay = delay
+        if delay is not None:
+            self.require_delay = True
 
     def execute(self) -> None:
+        if self.require_delay and not self.started:
+            self.started = time.time()
+            return
+        elif self.require_delay and time.time() - self.started < self.delay:
+            return
+        elif self.require_delay:
+            self.started = None
+            self.require_delay = False
+
         if self.started is None:
             self.started = time.time()
 
-        if time.time() - self.started < self.duration:
+        if time.time() - self.started <= self.duration:
+            self.func()
+        elif not self.duration:
             self.func()
+            raise FinishedCallback()
         else:
             raise FinishedCallback()
 
         # TODO: In top level class: to be available in all layers
         self.callbacks = []  # type: typing.List[Callback]
 
-    def append_callback(self, callback: typing.Callable[[], None], duration: float) -> None:
+    def append_callback(self, callback: typing.Callable[[], None], duration: float, delay: float=None) -> None:
         self.callbacks.append(Callback(
             callback,
             duration,
+            delay=delay,
         ))
 
     def set_selectable(self, actor: Actor) -> None:
             vsync=True,
             resizable=True,
         )
+        mixer.init()
 
         self.interaction_manager = InteractionManager(
             config=self.config,

synergine2_xyz/visible/simulation.py

 
 
 class VisibleMechanism(SubjectMechanism):
+    from_collection = None
+
     def __init__(
         self,
         config: Config,
     def is_visible(self, observed: XYZSubject) -> bool:
         return self.simulation.physics.subject_see_subject(self.subject, observed)
 
+    def _get_subject_iterable_from_collection(self, collection_name: str) -> typing.Iterator[XYZSubject]:
+        for subject_id in self.simulation.collections[collection_name]:
+            yield self.simulation.subjects.index[subject_id]
+
     def run(self) -> dict:
-        subjects_to_parse = self.reduce_subjects(self.simulation.subjects)
+        if self.from_collection is None:
+            subjects = self.simulation.subjects
+        else:
+            subjects = self._get_subject_iterable_from_collection(self.from_collection)
+
+        subjects_to_parse = self.reduce_subjects(subjects)
         subjects_visible = list(filter(self.is_visible, subjects_to_parse))
         return {
             'visible_subjects': subjects_visible,