Add interaction management on gui

sandbox/tile/gui/actor.py

 
 from sandbox.tile.gui.animation import ANIMATION_WALK
 from sandbox.tile.gui.animation import ANIMATION_CRAWL
+from synergine2.simulation import Subject
 from synergine2_cocos2d.actor import Actor
 
 
         ]
     }
 
-    def __init__(self):
-        super().__init__(pyglet.resource.image('actors/man.png'))
+    def __init__(self, subject: Subject) -> None:
+        super().__init__(pyglet.resource.image('actors/man.png'), subject=subject)

sandbox/tile/gui/base.py

 from sandbox.tile.gui.animation import ANIMATION_CRAWL
 from synergine2_cocos2d.animation import Animate
 from synergine2_cocos2d.gui import TMXGui
+from synergine2_cocos2d.interaction import MoveActorInteraction
 
 
 class Game(TMXGui):
     def before_run(self) -> None:
-        pass
+        self.layer_manager.interaction_manager.register(MoveActorInteraction, self.layer_manager)
+
         # Test
         # from sandbox.tile.gui.actor import Man
         # from cocos import euclid

synergine2_cocos2d/actor.py

 import cocos
 from cocos import collision_model
 from cocos import euclid
+from synergine2.simulation import Subject
 from synergine2_cocos2d.animation import AnimatedInterface
 
 
     def __init__(
         self,
         image: pyglet.image.TextureRegion,
+        subject: Subject,
         position=(0, 0),
         rotation=0,
         scale=1,
             anchor,
             **kwargs
         )
+        self.subject = subject
         self.cshape = None  # type: collision_model.AARectShape
         self.update_cshape()
         self.build_animation_images()

synergine2_cocos2d/event.py

+# coding: utf-8
+
+"""
+WARNING: Do not import cocos/pyglet stuff here: cocos/pyglet modules must be loaded inside gui process.
+"""
+import typing
+
+from synergine2.simulation import Event
+
+
+class GuiRequestMoveEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        move_to_position: typing.Tuple[int, int],
+        *args,
+        **kwargs
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.subject_id = subject_id
+        self.move_to_position = move_to_position

synergine2_cocos2d/exception.py

 
 class OuterWorldPosition(PositionException):
     pass
+
+
+class InteractionNotFound(Exception):
+    pass

synergine2_cocos2d/gl.py

         pyglet.gl.glVertex3f(positions[2][0], positions[2][1], 0)
         pyglet.gl.glVertex3f(positions[3][0], positions[3][1], 0)
         pyglet.gl.glEnd()
+
+
+def draw_line(
+    from_position: typing.Tuple[int, int],
+    to_position: typing.Tuple[int, int],
+    color: rgb_type,
+    width: typing.Optional[int]=1,
+):
+    pyglet.gl.glColor3ub(*color)
+    pyglet.gl.glLineWidth(width)
+    pyglet.graphics.draw(
+        4,
+        pyglet.gl.GL_LINES,
+        ("v2f", (0, 0, 0, 0, from_position[0], from_position[1], to_position[0], to_position[1]))
+    )

synergine2_cocos2d/gui.py

 
 import pyglet
 from pyglet.window import mouse
+from pyglet.window import key
 
 import cocos
 from cocos import collision_model
 from synergine2.xyz import XYZSubjectMixin
 from synergine2_cocos2d.actor import Actor
 from synergine2_cocos2d.exception import OuterWorldPosition
+from synergine2_cocos2d.exception import InteractionNotFound
 from synergine2_cocos2d.gl import rectangle_positions_type
 from synergine2_cocos2d.gl import draw_rectangle
+from synergine2_cocos2d.interaction import InteractionManager
 from synergine2_cocos2d.layer import LayerManager
 from synergine2_cocos2d.middleware import TMXMiddleware
+from synergine2_cocos2d.middleware import TMXMiddlewareMapMiddleware
+from synergine2_cocos2d.user_action import UserAction
 
 
 class GridManager(object):
         self.sright = None
         self.sbottom = None
         self.s_top = None
+        self.user_action_pending = None  # UserAction
 
         # opers that change cshape must ensure it goes to False,
         # selection opers must ensure it goes to True
         self.collision_manager.remove_tricky(actor)
 
     def draw(self, *args, **kwargs) -> None:
+        self.draw_update_cshapes()
+        self.draw_selection()
+        self.draw_interactions()
+
+    def draw_update_cshapes(self) -> None:
         for actor in self.selectable_actors:
             if actor.need_update_cshape:
                 if self.collision_manager.knows(actor):
                     actor.update_cshape()
                     self.collision_manager.add(actor)
 
+    def draw_selection(self) -> None:
         for actor, cshape in self.selection.items():
             grid_position = self.grid_manager.get_grid_position(actor.position)
             rect_positions = self.grid_manager.get_rectangle_positions(grid_position)
                 (0, 81, 211),
             )
 
+    def draw_interactions(self) -> None:
+        if self.user_action_pending:
+            try:
+                interaction = self.layer_manager.interaction_manager.get_for_user_action(self.user_action_pending)
+                interaction.draw_pending()
+            except InteractionNotFound:
+                pass
+
     def on_enter(self):
         super(EditLayer, self).on_enter()
         scene = self.get_ancestor(cocos.scene.Scene)
 
     def on_key_press(self, k, m):
         binds = self.bindings
+
+        # TODO: Clarify code
+        # Actions available if actor selected
+        if self.selection:
+            if k == key.M:
+                self.user_action_pending = UserAction.ORDER_MOVE
+
         if k in binds:
             self.buttons[binds[k]] = 1
             self.modifiers[binds[k]] = 1
             'GUI click: x: {}, y: {}, rx: {}, ry: {} ({}|{})'.format(x, y, rx, ry, buttons, modifiers)
         )
 
-        actor = self.single_actor_from_mouse()
-        if actor:
-            self.selection_add(actor)
+        if mouse.LEFT:
+            # Non action pending case
+            if not self.user_action_pending:
+                actor = self.single_actor_from_mouse()
+                if actor:
+                    self.selection.clear()
+                    self.selection_add(actor)
+            # Action pending case
+            else:
+                try:
+                    interaction = self.layer_manager.interaction_manager.get_for_user_action(self.user_action_pending)
+                    interaction.execute()
+                except InteractionNotFound:
+                    pass
+
+        if mouse.RIGHT:
+            if self.user_action_pending:
+                self.user_action_pending = None
 
     def on_mouse_release(self, sx, sy, button, modifiers):
         # should we handle here mod_restricted_mov ?
         else:
             # new_selected becomes the current selected
             self.selection.clear()
+            self.user_action_pending = None
             if under_mouse_unique is not None:
                 self.selection_add(under_mouse_unique)
 
         subject: XYZSubjectMixin,
         layer_manager: LayerManager,
     ) -> None:
-        actor = self.actor_class()
-        pixel_position = layer_manager.grid_manager.get_pixel_position_of_grid_position((
-            subject.position[0],
-            subject.position[1],
-        ))
+        actor = self.actor_class(subject)
+        pixel_position = layer_manager.grid_manager.get_pixel_position_of_grid_position(
+            (subject.position[0], subject.position[1]),
+        )
         actor.update_position(euclid.Vector2(*pixel_position))
 
         # TODO: Selectable nature must be configurable
             resizable=True,
         )
 
+        self.interaction_manager = InteractionManager(
+            config=self.config,
+            logger=self.logger,
+            terminal=self.terminal,
+        )
+        self.layer_manager = LayerManager(
+            self.config,
+            self.logger,
+            middleware=self.get_layer_middleware(),
+            interaction_manager=self.interaction_manager,
+        )
+        self.layer_manager.init()
+        self.layer_manager.center()
+
         # Enable blending
         pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
         pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA, pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)
 
         self.subject_mapper_factory = SubjectMapperFactory()
 
+    def get_layer_middleware(self) -> MapMiddleware:
+        raise NotImplementedError()
+
     def run(self):
         self.before_run()
         pyglet.clock.schedule_interval(
         map_dir_path: str=None,
     ):
         assert map_dir_path
+        self.map_dir_path = map_dir_path
         super(TMXGui, self).__init__(
             config,
             logger,
             terminal,
             read_queue_interval,
         )
-        self.map_dir_path = map_dir_path
-        self.layer_manager = LayerManager(
+
+    def get_layer_middleware(self) -> MapMiddleware:
+        return TMXMiddleware(
             self.config,
             self.logger,
-            middleware=TMXMiddleware(
-                self.config,
-                self.logger,
-                self.map_dir_path,
-            ),
+            self.map_dir_path,
         )
-        self.layer_manager.init()
-        self.layer_manager.center()
 
     def get_main_scene(self) -> cocos.cocosnode.CocosNode:
         return self.layer_manager.main_scene

synergine2_cocos2d/interaction.py

+# coding: utf-8
+import typing
+
+from synergine2.config import Config
+from synergine2.log import SynergineLogger
+from synergine2.terminals import Terminal, TerminalPackage
+from synergine2_cocos2d.event import GuiRequestMoveEvent
+from synergine2_cocos2d.exception import InteractionNotFound
+from synergine2_cocos2d.gl import draw_line
+from synergine2_cocos2d.layer import LayerManager
+from synergine2_cocos2d.user_action import UserAction
+
+
+class InteractionManager(object):
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        terminal: Terminal,
+    ) -> None:
+        self.config = config
+        self.logger = logger
+        self.terminal = terminal
+        self.interactions = []
+
+    def register(
+        self,
+        interaction_class: typing.Type['Interaction'],
+        layer_manager: LayerManager,
+    ) -> None:
+        self.interactions.append(interaction_class(
+            self.config,
+            self.logger,
+            terminal=self.terminal,
+            layer_manager=layer_manager,
+        ))
+
+    def get_for_user_action(self, action: UserAction) -> 'Interaction':
+        for interaction in self.interactions:
+            if interaction.gui_action == action:
+                return interaction
+        raise InteractionNotFound('For action"{}"'.format(action))
+
+
+class Interaction(object):
+    gui_action = None  # type: UserAction
+
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        terminal: Terminal,
+        layer_manager: LayerManager,
+    ) -> None:
+        self.config = config
+        self.logger = logger
+        self.terminal = terminal
+        self.layer_manager = layer_manager
+
+    def draw_pending(self) -> None:
+        pass
+
+    def execute(self) -> None:
+        package = self.get_package_for_terminal()
+        self.terminal.send(package)
+
+    def get_package_for_terminal(self) -> TerminalPackage:
+        raise NotImplementedError()
+
+
+class MoveActorInteraction(Interaction):
+    gui_action = UserAction.ORDER_MOVE
+
+    def draw_pending(self) -> None:
+            for actor in self.layer_manager.edit_layer.selection:
+                grid_position = self.layer_manager.grid_manager.get_grid_position(actor.position)
+                pixel_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(grid_position)
+
+                draw_line(
+                    self.layer_manager.scrolling_manager.world_to_screen(*pixel_position),
+                    self.layer_manager.edit_layer.screen_mouse,
+                    (0, 0, 255),
+                )
+
+    def get_package_for_terminal(self) -> TerminalPackage:
+        # TODO: MoveEvent ?
+        events = []
+        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,
+            )
+        )
+
+        for actor in self.layer_manager.edit_layer.selection:
+            events.append(GuiRequestMoveEvent(
+                subject_id=actor.subject.id,
+                move_to_position=mouse_grid_position,
+            ))
+
+        return TerminalPackage(
+            events=events
+        )

synergine2_cocos2d/layer.py

 if False:
     from synergine2_cocos2d.actor import Actor
     from synergine2_cocos2d.gui import GridManager
+    from synergine2_cocos2d.interaction import InteractionManager
 
 
 class ScrollingManager(cocos.layer.ScrollingManager):
         config: Config,
         logger: SynergineLogger,
         middleware: MapMiddleware,
+        interaction_manager: 'InteractionManager',
     ) -> None:
         self.config = config
         self.logger = logger
         self.middleware = middleware
+        self.interaction_manager = interaction_manager
 
         self.grid_manager = None  # type: GridManager
         self.scrolling_manager = None  # type: ScrollingManager

synergine2_cocos2d/user_action.py

+# coding: utf-8
+from enum import Enum
+
+
+class UserAction(Enum):
+    ORDER_MOVE = 'ORDER_MOVE'