Fire cursor drawing

sandbox/tile/gui/base.py

 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_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.utils import get_angle
 
 
 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:
             if k == key.M:
                 self.user_action_pending = UserAction.ORDER_MOVE_FAST
             if k == key.C:
                 self.user_action_pending = UserAction.ORDER_MOVE_CRAWL
+            if k == key.F:
+                self.user_action_pending = UserAction.ORDER_FIRE
 
 
 class TileLayerManager(LayerManager):
         self.layer_manager.interaction_manager.register(MoveActorInteraction, self.layer_manager)
         self.layer_manager.interaction_manager.register(MoveFastActorInteraction, self.layer_manager)
         self.layer_manager.interaction_manager.register(MoveCrawlActorInteraction, self.layer_manager)
+        self.layer_manager.interaction_manager.register(FireActorInteraction, self.layer_manager)
 
     def set_subject_position(self, event: FinishMoveEvent):
         actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]

sandbox/tile/gui/fire.py

+# coding: utf-8
+import typing
+
+from sandbox.tile.simulation.fire import RequestFireBehaviour
+from synergine2_cocos2d.interaction import BaseActorInteraction
+from sandbox.tile.user_action import UserAction
+from synergine2.simulation import SimulationBehaviour
+from synergine2_cocos2d.actor import Actor
+from synergine2_cocos2d.gl import draw_line
+
+
+class BaseFireActorInteraction(BaseActorInteraction):
+    gui_action = None
+    color = None
+    not_visible_color = (0, 0, 0)
+    request_move_behaviour_class = RequestFireBehaviour
+
+    def draw_pending(self) -> None:
+        for actor in self.layer_manager.edit_layer.selection:
+            actor_grid_position = self.layer_manager.grid_manager.get_grid_position(actor.position)
+            actor_pixel_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                actor_grid_position,
+            )
+            mouse_grid_position = self.layer_manager.grid_manager.get_grid_position(
+                self.layer_manager.scrolling_manager.screen_to_world(
+                    *self.layer_manager.edit_layer.screen_mouse,
+                )
+            )
+            draw_to_pixel = self.layer_manager.edit_layer.screen_mouse
+
+            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',
+            )
+            if obstacle_grid_position:
+                obstacle_pixel = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                    obstacle_grid_position,
+                )
+                draw_to_pixel = obstacle_pixel
+
+                draw_line(
+                    obstacle_pixel,
+                    self.layer_manager.edit_layer.screen_mouse,
+                    self.not_visible_color,
+                )
+
+            draw_line(
+                self.layer_manager.scrolling_manager.world_to_screen(*actor_pixel_position),
+                draw_to_pixel,
+                self.color,
+            )
+
+    def get_behaviour(self, actor: Actor, mouse_grid_position) -> typing.Tuple[typing.Type[SimulationBehaviour], dict]:
+        raise NotImplementedError()
+        return self.request_move_behaviour_class, {
+            'subject_id': actor.subject.id,
+            'move_to': mouse_grid_position,
+            'gui_action': self.gui_action,
+        }
+
+
+class FireActorInteraction(BaseFireActorInteraction):
+    gui_action = UserAction.ORDER_FIRE
+    color = (255, 0, 0)

sandbox/tile/maps/003/terrain.tsx

    <property name="name" type="str" value="Grass"/>
    <property name="traversable_by_man" type="bool" value="true"/>
    <property name="traversable_by_vehicle" type="bool" value="true"/>
+   <property name="opacity" type="float" value="0.0"/>
+   <property name="height" type="float" value="0.0"/>
   </properties>
  </tile>
  <tile id="1">
    <property name="name" type="str" value="Wood wall"/>
    <property name="traversable_by_man" type="bool" value="false"/>
    <property name="traversable_by_vehicle" type="bool" value="false"/>
+   <property name="opacity" type="float" value="100.0"/>
+   <property name="height" type="float" value="2.0"/>
   </properties>
  </tile>
 </tileset>

sandbox/tile/simulation/base.py

 # coding: utf-8
-import tmx
 
-from sandbox.tile.simulation.physics import TerrainTile
-from sandbox.tile.simulation.physics import TileMoveCostComputer
+from sandbox.tile.simulation.physics import TilePhysics
 from synergine2.config import Config
-from synergine2_xyz.map import TMXMap
 from synergine2_xyz.physics import Physics
-from synergine2_xyz.physics import TMXPhysics
 from synergine2_xyz.simulation import XYZSimulation
-from synergine2_xyz.subjects import XYZSubjects
 from synergine2_xyz.subjects import XYZSubject
-
-
-class TileMap(TMXMap):
-    xyz_tile_class = TerrainTile
-
-    def get_default_tileset(self) -> tmx.Tileset:
-        return self.tmx_tilesets['terrain']
-
-
-class TilePhysics(TMXPhysics):
-    tmx_map_class = TileMap
-    move_cost_computer_class = TileMoveCostComputer
+from synergine2_xyz.subjects import XYZSubjects
 
 
 class TileStrategySimulation(XYZSimulation):

sandbox/tile/simulation/fire.py

+# coding: utf-8
+import typing
+
+from synergine2.config import Config
+from synergine2.simulation import SimulationBehaviour
+from synergine2.simulation import Simulation
+from synergine2.simulation import Event
+from synergine2.simulation import Intention
+from synergine2_xyz.simulation import XYZSimulation
+
+
+class FireIntention(Intention):
+    def __init__(
+        self,
+        to_position: typing.Tuple[int, int],
+        to_subject_id: int,
+        gui_action: typing.Any,
+    ) -> None:
+        self.to_position = to_position
+        self.to_subject_id = to_subject_id
+        self.gui_action = gui_action
+
+
+class RequestFireBehaviour(SimulationBehaviour):
+    move_intention_class = FireIntention
+
+    def __init__(
+        self,
+        config: Config,
+        simulation: Simulation,
+    ):
+        super().__init__(config, simulation)
+        self.simulation = typing.cast(XYZSimulation, self.simulation)
+
+    def action(self, data) -> typing.List[Event]:
+        to_position = data['to_position']
+        to_subject_id = data['to_subject_id']
+
+        return []

sandbox/tile/simulation/physics.py

 # coding: utf-8
-from synergine2_xyz.map import XYZTile
+import typing
+
+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:
     from sandbox.tile.simulation.base import BaseSubject
 
 
-class TerrainTile(XYZTile):
-    pass
-
-
 class TileMoveCostComputer(MoveCostComputer):
     def compute_move_cost(
         self,
             return 100
 
         return 1.0
+
+
+class TilePhysics(TMXPhysics):
+    tmx_map_class = TileMap
+    move_cost_computer_class = TileMoveCostComputer
+    matrixes_configuration = {
+        'visibility': [
+            'height',
+            'opacity',
+        ]
+    }
+
+    def get_visibility_obstacle(
+        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(
+            matrix_name,
+            path_positions=path_positions,
+            value_name=opacity_property_name,
+        )
+
+        # FIXME: This algo is not ok, it is for test
+        actual_opacity = 0
+        for i, path_opacity in enumerate(path_opacities):
+            actual_opacity += path_opacity
+            if actual_opacity >= 100:
+                return path_positions[i]
+
+        return None

sandbox/tile/simulation/tmx.py

+# coding: utf-8
+import tmx
+
+from synergine2_xyz.map import TMXMap
+from synergine2_xyz.map import XYZTile
+
+
+class TerrainTile(XYZTile):
+    pass
+
+
+class TileMap(TMXMap):
+    xyz_tile_class = TerrainTile
+
+    def get_default_tileset(self) -> tmx.Tileset:
+        return self.tmx_tilesets['terrain']

sandbox/tile/user_action.py

     ORDER_MOVE = 'ORDER_MOVE'
     ORDER_MOVE_FAST = 'ORDER_MOVE_FAST'
     ORDER_MOVE_CRAWL = 'ORDER_MOVE_CRAWL'
+    ORDER_FIRE = 'ORDER_FIRE'

synergine2_cocos2d/middleware.py

         self.map_dir_path = map_dir_path
         self.tmx = None
 
-    def init(self) -> None:
-        self.tmx = cocos.tiles.load(os.path.join(
+    def get_map_file_path(self) -> str:
+        return os.path.join(
             self.map_dir_path,
             '{}.tmx'.format(os.path.basename(self.map_dir_path)),
-        ))
+        )
+
+    def init(self) -> None:
+        map_file_path = self.get_map_file_path()
+        self.tmx = cocos.tiles.load(map_file_path)
 
     def get_background_sprite(self) -> cocos.sprite.Sprite:
         raise NotImplementedError()

synergine2_xyz/physics.py

 from synergine2.share import shared
 from synergine2_xyz.map import TMXMap, XYZTile
 from synergine2_xyz.subjects import XYZSubject
+from synergine2_xyz.tmx_utils import fill_matrix
 from synergine2_xyz.utils import get_line_xy_path
 from synergine2_xyz.xyz import get_neighbor_positions
 
 
 class Matrixes(object):
     _matrixes = shared.create('matrixes', value=lambda: {})  # type: typing.Dict[str, typing.List[typing.List[tuple]]]
-
-    def __init__(self):
-        self._value_structures = {}  # type: typing.List[str]
+    _value_structures = shared.create('value_structures', value=lambda: {})  # type: typing.List[str]
 
     def initialize_empty_matrix(
         self,
     ) -> typing.List[typing.Tuple[int, int]]:
         return get_line_xy_path(from_, to)
 
-    def get_values_for_path(self, name: str, path_positions: typing.List[typing.Tuple[int, int]]):
+    def get_values_for_path(
+        self,
+        name: str,
+        path_positions: typing.List[typing.Tuple[int, int]],
+        value_name: str=None,
+    ):
         values = []
+        value_name_position = None
+
+        if value_name:
+            value_name_position = self._value_structures[name].index(value_name)
+
         matrix = self.get_matrix(name)
         for path_position in path_positions:
             x, y = path_position
-            values.append(matrix[y][x])
+            if value_name_position is None:
+                values.append(matrix[y][x])
+            else:
+                values.append(matrix[y][x][value_name_position])
         return values
 
     def get_value(self, matrix_name: str, x: int, y: int, value_name: str) -> float:
 
 class TMXPhysics(Physics):
     tmx_map_class = TMXMap
+    matrixes_configuration = None  # type: typing.Dict[str, typing.List[str]]
 
     def __init__(
         self,
         super().__init__(config)
         self.map_file_path = map_file_path
         self.tmx_map = self.tmx_map_class(map_file_path)
+        self.matrixes = Matrixes()
 
     def load(self) -> None:
         self.load_graph_from_map(self.map_file_path)
+        self.load_matrixes_from_map()
 
     def load_graph_from_map(self, map_file_path: str) -> None:
         # TODO: tmx_map contient tout en cache, faire le dessous en exploitant tmx_map.
                     to_tile = self.tmx_map.layer_tiles('terrain')[neighbor]
                     # Note: Voir https://pypi.python.org/pypi/Dijkstar/2.2
                     self.graph.add_edge(position, neighbor, to_tile)
+
+    def load_matrixes_from_map(self) -> None:
+        if not self.matrixes_configuration:
+            return
+
+        for matrix_name, properties in self.matrixes_configuration.items():
+            self.matrixes.initialize_empty_matrix(
+                matrix_name,
+                matrix_width=self.tmx_map.width,
+                matrix_height=self.tmx_map.height,
+                value_structure=properties,
+            )
+            fill_matrix(self.tmx_map, self.matrixes, 'terrain', matrix_name, properties)

synergine2_xyz/tmx_utils.py

 
 from synergine2.exceptions import ConfigurationError
 from synergine2_xyz.map import TMXMap
-from synergine2_xyz.physics import Matrixes
+
+if typing.TYPE_CHECKING:
+    from synergine2_xyz.physics import Matrixes
 
 
 def get_layer_by_name(map_: TileMap, layer_name: str) -> Layer:
 
 def fill_matrix(
     tmx_map: TMXMap,
-    matrixes: Matrixes,
+    matrixes: 'Matrixes',
     layer_name: str,
     matrix_name: str,
     properties: typing.List[str],

tests/test_physics.py

         path_values = visibility.get_values_for_path('testing', path_positions=path_positions)
         assert [(0.7,), (0.0,), (0.5,)] == path_values
 
+    def test_get_path_value(self):
+        visibility = Matrixes()
+        visibility.initialize_empty_matrix('testing', matrix_width=3, matrix_height=2, value_structure=['opacity'])
+        visibility.update_matrix('testing', x=2, y=1, value=(0.5,))
+        visibility.update_matrix('testing', x=0, y=0, value=(0.7,))
+
+        path_positions = visibility.get_path_positions(from_=(0, 0), to=(2, 1))
+        path_values = visibility.get_values_for_path('testing', path_positions=path_positions, value_name='opacity')
+        assert [0.7, 0.0, 0.5] == path_values
+
     def test_get_value(self):
         visibility = Matrixes()
         visibility.initialize_empty_matrix('testing', matrix_width=3, matrix_height=2, value_structure=['opacity'])