Look around mechanism

sandbox/tile/const.py

 FLAG_DE = 'DE'
 FLAG_URSS = 'URSS'
 
+SIDE = 'SIDE'
+
 DE_COLOR = (0, 81, 211)
 URSS_COLOR = (204, 0, 0)

sandbox/tile/gui/base.py

 # coding: utf-8
+import typing
 
 from pyglet.window import key
 
 from cocos.actions import MoveTo as BaseMoveTo
-from sandbox.tile.simulation.physics import TilePhysics
 from sandbox.tile.user_action import UserAction
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
 from synergine2_cocos2d.actions import MoveTo
-# TODO NOW: MOVE
 from synergine2_cocos2d.animation import ANIMATION_CRAWL
 from synergine2_cocos2d.animation import ANIMATION_WALK
 from synergine2_cocos2d.animation import Animate
+from synergine2_cocos2d.gl import draw_line
 from synergine2_cocos2d.gui import EditLayer as BaseEditLayer
 from synergine2_cocos2d.gui import TMXGui
 from synergine2_cocos2d.layer import LayerManager
 from synergine2_xyz.move.simulation import FinishMoveEvent
 from synergine2_xyz.move.simulation import StartMoveEvent
-from synergine2_xyz.physics import Matrixes
+from synergine2_xyz.physics import Physics
 from synergine2_xyz.utils import get_angle
+from sandbox.tile.simulation.event import NewVisibleOpponent
+from sandbox.tile.simulation.event import NoLongerVisibleOpponent
 
 
 class EditLayer(BaseEditLayer):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.matrixes = Matrixes()
-        self.physics = TilePhysics(
-            self.config,
-            map_file_path='sandbox/tile/maps/003/003.tmx',  # FIXME: HARDCODED
-        )
 
     def _on_key_press(self, k, m):
         if self.selection:
         config: Config,
         logger: SynergineLogger,
         terminal: Terminal,
+        physics: Physics,
         read_queue_interval: float = 1 / 60.0,
         map_dir_path: str=None,
     ):
             config,
             logger,
             terminal,
-            read_queue_interval,
-            map_dir_path,
+            physics=physics,
+            read_queue_interval=read_queue_interval,
+            map_dir_path=map_dir_path,
         )
 
         self.terminal.register_event_handler(
             self.start_move_subject,
         )
 
+        self.terminal.register_event_handler(
+            NewVisibleOpponent,
+            self.new_visible_opponent,
+        )
+
+        self.terminal.register_event_handler(
+            NoLongerVisibleOpponent,
+            self.no_longer_visible_opponent,
+        )
+
         # 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'))
         actor.do(move_action)
         actor.do(Animate(animation, duration=move_duration, cycle_duration=cycle_duration))
         actor.rotation = get_angle(event.from_position, event.to_position)
+
+    def new_visible_opponent(self, event: NewVisibleOpponent):
+        self.visible_or_no_longer_visible_opponent(event, (153, 0, 153))
+
+    def no_longer_visible_opponent(self, event: NoLongerVisibleOpponent):
+        self.visible_or_no_longer_visible_opponent(event, (255, 102, 0))
+
+    def visible_or_no_longer_visible_opponent(
+        self,
+        event: typing.Union[NoLongerVisibleOpponent, NewVisibleOpponent],
+        line_color,
+    ) -> None:
+        if self.layer_manager.debug:
+            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,
+            )
+            observed_pixel_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                observed_actor.subject.position,
+            )
+
+            def draw_visible_opponent():
+                draw_line(
+                    observer_pixel_position,
+                    observed_pixel_position,
+                    line_color,
+                )
+
+            self.layer_manager.edit_layer.append_callback(draw_visible_opponent, 1.0)

sandbox/tile/gui/fire.py

             obstacle_grid_position = self.layer_manager.edit_layer.physics.get_visibility_obstacle(
                 subject=actor.subject,
                 to_position=mouse_grid_position,
-                matrixes=self.layer_manager.edit_layer.matrixes,
                 matrix_name='visibility',
                 opacity_property_name='opacity',
             )
 
             # DEBUG
             if self.layer_manager.debug:
-                grid_paths = self.layer_manager.edit_layer.matrixes.get_path_positions(
+                grid_paths = self.layer_manager.edit_layer.physics.matrixes.get_path_positions(
                     from_=actor_grid_position,
                     to=mouse_grid_position,
                 )

sandbox/tile/run.py

 import logging
 from random import seed
 
-from sandbox.tile.const import FLAG
+synergine2_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
+sys.path.append(synergine2_path)
+
+from sandbox.tile.const import FLAG, SIDE
 from sandbox.tile.const import FLAG_DE
 from sandbox.tile.const import DE_COLOR
 from sandbox.tile.const import URSS_COLOR
 from sandbox.tile.const import FLAG_URSS
 from synergine2_cocos2d.const import SELECTION_COLOR_RGB
-
-synergine2_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
-sys.path.append(synergine2_path)
-
-from sandbox.tile.simulation.subject import Man
+from synergine2_cocos2d.util import get_map_file_path_from_dir
+from sandbox.tile.simulation.subject import TileSubject
 from sandbox.tile.simulation.base import TileStrategySimulation
 from sandbox.tile.simulation.base import TileStrategySubjects
 from synergine2.log import get_default_logger
     config.load_yaml('sandbox/tile/config.yaml')
     logger = get_default_logger(level=logging.ERROR)
 
-    map_file_path = 'sandbox/tile/{}.tmx'.format(os.path.join(map_dir_path, os.path.basename(map_dir_path)))
+    map_file_path = get_map_file_path_from_dir(map_dir_path)
 
     simulation = TileStrategySimulation(config, map_file_path=map_file_path)
     subjects = TileStrategySubjects(simulation=simulation)
 
-    for position in ((0, 2),):
-        man = Man(
+    for position in ((10, 2),):
+        man = TileSubject(
             config=config,
             simulation=simulation,
             position=position,
             properties={
                 SELECTION_COLOR_RGB: DE_COLOR,
                 FLAG: FLAG_DE,
+                SIDE: 'AXIS',
             }
         )
         subjects.append(man)
 
-    for position in ((20, 10),):
-        man = Man(
+    for position in ((30, 14),):
+        man = TileSubject(
             config=config,
             simulation=simulation,
             position=position,
             properties={
                 SELECTION_COLOR_RGB: URSS_COLOR,
                 FLAG: FLAG_URSS,
+                SIDE: 'ALLIES',
             }
         )
         subjects.append(man)

sandbox/tile/simulation/behaviour.py

 # coding: utf-8
 import time
 
+from sandbox.tile.simulation.event import NoLongerVisibleOpponent
+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
 
             return time.time() - move_to_data['last_intention_time'] >= self._run_duration
         if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
             return time.time() - move_to_data['last_intention_time'] >= self._crawl_duration
+
+
+class LookAroundBehaviour(SubjectBehaviour):
+    """
+    Behaviour who permit to reference visible things like enemies
+    """
+    visible_mechanism = OpponentVisibleMechanism
+    use = [visible_mechanism]
+    force_action = True
+
+    def action(self, data) -> [Event]:
+        new_visible_subject_events = []
+        no_longer_visible_subject_events = []
+
+        for no_longer_visible_subject_id in data['no_longer_visible_subject_ids']:
+            no_longer_visible_subject_events.append(NoLongerVisibleOpponent(
+                observer_subject_id=self.subject.id,
+                observed_subject_id=no_longer_visible_subject_id,
+            ))
+            self.subject.visible_opponent_ids.remove(no_longer_visible_subject_id)
+
+        for new_visible_subject_id in data['new_visible_subject_ids']:
+            new_visible_subject_events.append(NewVisibleOpponent(
+                observer_subject_id=self.subject.id,
+                observed_subject_id=new_visible_subject_id,
+            ))
+            self.subject.visible_opponent_ids.append(new_visible_subject_id)
+
+        return new_visible_subject_events + no_longer_visible_subject_events
+
+    def run(self, data):
+        visible_subjects = data[self.visible_mechanism]['visible_subjects']
+        visible_subject_ids = [s.id for s in visible_subjects]
+        new_visible_subject_ids = []
+        no_longer_visible_subject_ids = []
+
+        for subject_id in self.subject.visible_opponent_ids:
+            if subject_id not in visible_subject_ids:
+                no_longer_visible_subject_ids.append(subject_id)
+
+        for subject in visible_subjects:
+            if subject.id not in self.subject.visible_opponent_ids:
+                new_visible_subject_ids.append(subject.id)
+
+        return {
+            'new_visible_subject_ids': new_visible_subject_ids,
+            'no_longer_visible_subject_ids': no_longer_visible_subject_ids,
+        }

sandbox/tile/simulation/event.py

+# coding: utf-8
+
+
+# TODO: Reprendre les events Move, pour les lister tous ici
+from synergine2.simulation import Event
+
+
+class NewVisibleOpponent(Event):
+    def __init__(
+        self,
+        observer_subject_id: int,
+        observed_subject_id: int,
+    ) -> None:
+        self.observer_subject_id = observer_subject_id
+        self.observed_subject_id = observed_subject_id
+
+
+class NoLongerVisibleOpponent(Event):
+    def __init__(
+        self,
+        observer_subject_id: int,
+        observed_subject_id: int,
+    ) -> None:
+        self.observer_subject_id = observer_subject_id
+        self.observed_subject_id = observed_subject_id

sandbox/tile/simulation/mechanism.py

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

sandbox/tile/simulation/physics.py

 
 from sandbox.tile.simulation.tmx import TileMap
 from sandbox.tile.simulation.tmx import TerrainTile
-from synergine2_xyz.physics import Matrixes
 from synergine2_xyz.physics import MoveCostComputer
 from synergine2_xyz.physics import TMXPhysics
 from synergine2_xyz.subjects import XYZSubject
 
-if False:
+if typing.TYPE_CHECKING:
     from sandbox.tile.simulation.base import BaseSubject
+    from sandbox.tile.simulation.subject import TileSubject
 
 
 class TileMoveCostComputer(MoveCostComputer):
         self,
         subject: XYZSubject,
         to_position: typing.Tuple[int, int],
-        matrixes: Matrixes,
         matrix_name: str,
         opacity_property_name: str='opacity',
     ) -> typing.Union[None, typing.Tuple[int, int]]:
         Return grid position obstacle if any between given subject and given to_position
         :param subject: Subject observer
         :param to_position: position to observe
-        :param matrixes: Matrixes instance
         :param matrix_name: matrix name to use
         :param opacity_property_name: name of property containing opacity property
         :return: obstacle grid position or None if not
         """
         from_x, from_y = subject.position
-        path_positions = matrixes.get_path_positions(from_=(from_x, from_y), to=to_position)
-        path_opacities = matrixes.get_values_for_path(
+        path_positions = self.matrixes.get_path_positions(from_=(from_x, from_y), to=to_position)
+        path_opacities = self.matrixes.get_values_for_path(
             matrix_name,
             path_positions=path_positions,
             value_name=opacity_property_name,
                 return path_positions[i]
 
         return None
+
+    def subject_see_subject(self, observer: 'TileSubject', observed: 'TileSubject') -> bool:
+        return not bool(self.get_visibility_obstacle(
+            observer,
+            observed.position,
+            matrix_name='visibility',
+        ))

sandbox/tile/simulation/subject.py

 from sandbox.tile.const import COLLECTION_ALIVE
 from sandbox.tile.simulation.base import BaseSubject
 from sandbox.tile.simulation.behaviour import MoveToBehaviour
+from sandbox.tile.simulation.behaviour import LookAroundBehaviour
+from synergine2.share import shared
 
 
-class Man(BaseSubject):
+class TileSubject(BaseSubject):
     start_collections = [
         COLLECTION_ALIVE,
     ]
     behaviours_classes = [
         MoveToBehaviour,
+        LookAroundBehaviour,
     ]
+    visible_opponent_ids = shared.create_self('visible_opponent_ids', lambda: [])
     # TODO: implement (copied from engulf)
     # behaviour_selector_class = CellBehaviourSelector

sandbox/tile/terminal/base.py

 # coding: utf-8
-from sandbox.tile.simulation.subject import Man as ManSubject
+from sandbox.tile.simulation.event import NewVisibleOpponent
+from sandbox.tile.simulation.event import NoLongerVisibleOpponent
+from sandbox.tile.simulation.physics import TilePhysics
+from sandbox.tile.simulation.subject import TileSubject as ManSubject
 from sandbox.tile.gui.actor import Man as ManActor
 from synergine2_cocos2d.terminal import GameTerminal
+from synergine2_cocos2d.util import get_map_file_path_from_dir
 from synergine2_xyz.move.simulation import FinishMoveEvent
 from synergine2_xyz.move.simulation import StartMoveEvent
 
     subscribed_events = [
         FinishMoveEvent,
         StartMoveEvent,
+        NewVisibleOpponent,
+        NoLongerVisibleOpponent,
     ]
 
     def __init__(self, *args, asynchronous: bool, map_dir_path: str, **kwargs):
         super().__init__(*args, **kwargs)
         self.asynchronous = asynchronous
+        map_file_path = get_map_file_path_from_dir(map_dir_path)
+        self.physics = TilePhysics(
+            self.config,
+            map_file_path=map_file_path,
+        )
         self.map_dir_path = map_dir_path
 
     def run(self):
             self.config,
             self.logger,
             self,
+            physics=self.physics,
             map_dir_path=self.map_dir_path,
         )
 

synergine2/share.py

         super().append(p_object)
         self.shared.set(self.shared_data.get_final_key(self.instance), list(self))
 
+    def remove(self, object_):
+        super().remove(object_)
+        self.shared.set(self.shared_data.get_final_key(self.instance), list(self))
+
     # TODO: Cover all methods
 
 

synergine2/simulation.py

 
 
 class Event(BaseObject):
-    def __init__(self, *args, **kwargs):
-        pass
-
     def repr_debug(self) -> str:
         return self.__class__.__name__
 

synergine2_cocos2d/gui.py

 from math import floor
 
 import pyglet
+import time
 from pyglet.window import mouse
 
 import cocos
 from synergine2_cocos2d.middleware import MapMiddleware
 from synergine2_cocos2d.middleware import TMXMiddleware
 from synergine2_cocos2d.user_action import UserAction
+from synergine2_xyz.physics import Physics
 from synergine2_xyz.xyz import XYZSubjectMixin
 
 
         self.vertexes = [(minx, miny), (minx, maxy), (maxx, maxy), (maxx, miny)]
 
 
+class FinishedCallback(Exception):
+    pass
+
+
+class Callback(object):
+    def __init__(
+        self,
+        func: typing.Callable[[], None],
+        duration: float,
+    ) -> None:
+        self.func = func
+        self.duration = duration
+        # Started timestamp
+        self.started = None  # type: float
+
+    def execute(self) -> None:
+        if self.started is None:
+            self.started = time.time()
+
+        if time.time() - self.started < self.duration:
+            self.func()
+        else:
+            raise FinishedCallback()
+
+
 class EditLayer(cocos.layer.Layer):
     is_event_handler = True
 
 
         self.schedule(self.update)
         self.selectable_actors = []
+        # 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:
+        self.callbacks.append(Callback(
+            callback,
+            duration,
+        ))
 
     def set_selectable(self, actor: Actor) -> None:
         self.selectable_actors.append(actor)
         self.draw_update_cshapes()
         self.draw_selection()
         self.draw_interactions()
+        self.execute_callbacks()
+
+    def execute_callbacks(self) -> None:
+        for callback in self.callbacks[:]:
+            try:
+                callback.execute()
+            except FinishedCallback:
+                self.callbacks.remove(callback)
 
     def draw_update_cshapes(self) -> None:
         for actor in self.selectable_actors:
         config: Config,
         logger: SynergineLogger,
         terminal: Terminal,
+        physics: Physics,
         read_queue_interval: float = 1 / 60.0,
         map_dir_path: str=None,
     ):
             terminal,
             read_queue_interval,
         )
+        self.physics = physics
 
     def get_layer_middleware(self) -> MapMiddleware:
         return TMXMiddleware(

synergine2_cocos2d/layer.py

 class SubjectLayer(cocos.layer.ScrollableLayer):
     def __init__(self, parallax: int=1):
         super().__init__(parallax)
-        self.subjects_index = {}
+        self.subjects_index = {}  # type: typing.Dict[int, Actor]
 
     def add_subject(self, actor: 'Actor') -> None:
         self.add(actor)

synergine2_cocos2d/util.py

+# coding: utf-8
+import os
+
+
+def get_map_file_path_from_dir(map_dir_path: str) -> str:
+    # TODO: path is temp here
+    return 'sandbox/tile/{}.tmx'.format(os.path.join(map_dir_path, os.path.basename(map_dir_path)))

synergine2_xyz/move/simulation.py

 
 
 class MoveToBehaviour(SubjectBehaviour):
-    use = [MoveToMechanism]
     move_to_mechanism = MoveToMechanism
+    use = [move_to_mechanism]
 
     def run(self, data):
         move_to_data = data[self.move_to_mechanism]

synergine2_xyz/physics.py

 
 from synergine2.config import Config
 from synergine2.share import shared
-from synergine2_xyz.map import TMXMap, XYZTile
+from synergine2_xyz.map import TMXMap
+from synergine2_xyz.map import XYZTile
 from synergine2_xyz.subjects import XYZSubject
 from synergine2_xyz.tmx_utils import fill_matrix
 from synergine2_xyz.utils import get_line_xy_path
         self,
         config: Config,
         map_file_path: str,
+        matrixes: Matrixes=None,
     ) -> None:
         super().__init__(config)
         self.map_file_path = map_file_path
         self.tmx_map = self.tmx_map_class(map_file_path)
-        self.matrixes = Matrixes()
+        self.matrixes = matrixes or Matrixes()
 
     def load(self) -> None:
         self.load_graph_from_map(self.map_file_path)
                 value_structure=properties,
             )
             fill_matrix(self.tmx_map, self.matrixes, 'terrain', matrix_name, properties)
+
+    def subject_see_subject(self, observer: XYZSubject, observed: XYZSubject) -> bool:
+        raise NotImplementedError()

synergine2_xyz/simulation.py

     def create_physics(self) -> Physics:
         return Physics(self.config)
 
+    # TODO: Move into physics
     def is_possible_subject_position(self, subject: XYZSubject, position: tuple) -> bool:
         return self.is_possible_position(position)
 
+    # TODO: Move into physics
     def is_possible_position(self, position: tuple) -> bool:
         return True

synergine2_xyz/visible/__init__.py

+# coding: utf-8

synergine2_xyz/visible/simulation.py

+# coding: utf-8
+import typing
+
+from synergine2.config import Config
+from synergine2.simulation import SubjectMechanism, Simulation, Subject
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.subjects import XYZSubject
+
+
+class VisibleMechanism(SubjectMechanism):
+    def __init__(
+        self,
+        config: Config,
+        simulation: Simulation,
+        subject: Subject,
+    ) -> None:
+        super().__init__(config, simulation, subject)
+        self.simulation = typing.cast(XYZSimulation, self.simulation)
+        self.subject = typing.cast(XYZSubject, self.subject)
+
+    def reduce_subjects(self, subjects: typing.List[XYZSubject]) -> typing.Iterator[XYZSubject]:
+        return subjects
+
+    def is_visible(self, observed: XYZSubject) -> bool:
+        return self.simulation.physics.subject_see_subject(self.subject, observed)
+
+    def run(self) -> dict:
+        subjects_to_parse = self.reduce_subjects(self.simulation.subjects)
+        subjects_visible = list(filter(self.is_visible, subjects_to_parse))
+        return {
+            'visible_subjects': subjects_visible,
+        }