fix gui positions when zoom

sandbox/tile/gui/base.py

 
     def set_subject_position(self, event: FinishMoveEvent):
         actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
-        new_world_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(event.to_position)
+        new_world_position = self.layer_manager.grid_manager.get_world_position_of_grid_position(event.to_position)
 
         actor.stop_actions((BaseMoveTo,))
         actor.set_position(*new_world_position)
 
     def start_move_subject(self, event: StartMoveEvent):
         actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
-        new_world_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(event.to_position)
+        new_world_position = self.layer_manager.grid_manager.get_world_position_of_grid_position(event.to_position)
 
         if event.gui_action == UserAction.ORDER_MOVE:
             animation = ANIMATION_WALK
             observed_actor = self.layer_manager.subject_layer.subjects_index[event.observed_subject_id]
 
             observer_pixel_position = self.layer_manager.scrolling_manager.world_to_screen(
-                *self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                *self.layer_manager.grid_manager.get_world_position_of_grid_position(
                     observer_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(
+                *self.layer_manager.grid_manager.get_world_position_of_grid_position(
                     observed_actor.subject.position,
                 )
             )
         # 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(
+            *self.layer_manager.grid_manager.get_world_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(
+            *self.layer_manager.grid_manager.get_world_position_of_grid_position(
                 event.target_position,
             )
         )

sandbox/tile/gui/fire.py

     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_pixel_position = self.layer_manager.grid_manager.get_world_position_of_grid_position(
                 actor_grid_position,
             )
             mouse_grid_position = self.layer_manager.grid_manager.get_grid_position(
             )
             draw_to_pixel = self.layer_manager.edit_layer.screen_mouse
 
-            obstacle_grid_position = self.layer_manager.edit_layer.physics.get_visibility_obstacle(
+            obstacle_grid_position = self.layer_manager.gui.physics.get_visibility_obstacle(
                 subject=actor.subject,
                 to_position=mouse_grid_position,
                 matrix_name='visibility',
 
             # DEBUG
             if self.layer_manager.debug:
-                grid_paths = self.layer_manager.edit_layer.physics.matrixes.get_path_positions(
+                grid_paths = self.layer_manager.gui.physics.matrixes.get_path_positions(
                     from_=actor_grid_position,
                     to=mouse_grid_position,
                 )
                 previous_grid_path = None
                 for grid_path in grid_paths:
                     if previous_grid_path:
-                        previous_grid_path_pixel = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                        previous_grid_path_pixel = self.layer_manager.grid_manager.get_world_position_of_grid_position(
                             previous_grid_path,
                         )
-                        current_grid_pixel = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                        current_grid_pixel = self.layer_manager.grid_manager.get_world_position_of_grid_position(
                             grid_path,
                         )
                         draw_line(
-                            previous_grid_path_pixel,
-                            current_grid_pixel,
+                            self.layer_manager.scrolling_manager.world_to_screen(*previous_grid_path_pixel),
+                            self.layer_manager.scrolling_manager.world_to_screen(*current_grid_pixel),
                             (25, 125, 25),
                         )
                     previous_grid_path = grid_path
 
             if obstacle_grid_position:
-                obstacle_pixel = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(
+                obstacle_pixel = self.layer_manager.grid_manager.get_world_position_of_grid_position(
                     obstacle_grid_position,
                 )
-                draw_to_pixel = obstacle_pixel
+                draw_to_pixel = self.layer_manager.scrolling_manager.world_to_screen(*obstacle_pixel)
 
                 draw_line(
-                    obstacle_pixel,
+                    self.layer_manager.scrolling_manager.world_to_screen(*obstacle_pixel),
                     self.layer_manager.edit_layer.screen_mouse,
                     self.not_visible_color,
                 )

sandbox/tile/gui/move.py

     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)
+            pixel_position = self.layer_manager.grid_manager.get_world_position_of_grid_position(grid_position)
 
             draw_line(
                 self.layer_manager.scrolling_manager.world_to_screen(*pixel_position),

synergine2_cocos2d/gui.py

 
         return cell_x, cell_y
 
-    def get_pixel_position_of_grid_position(self, grid_position: typing.Tuple[int, int]) -> typing.Tuple[int, int]:
+    def get_world_position_of_grid_position(self, grid_position: typing.Tuple[int, int]) -> typing.Tuple[int, int]:
         return grid_position[0] * self.cell_width + (self.cell_width // 2),\
                grid_position[1] * self.cell_height + (self.cell_height // 2)
 
 
                 try:
                     grid_pos = self.grid_manager.get_grid_position(new_pos)
-                    grid_pixel_pos = self.grid_manager.get_pixel_position_of_grid_position(grid_pos)
+                    grid_pixel_pos = self.grid_manager.get_world_position_of_grid_position(grid_pos)
                     actor.update_position(grid_pixel_pos)
                 except OuterWorldPosition:
                     # don't update position
         layer_manager: LayerManager,
     ) -> None:
         actor = self.actor_class(subject)
-        pixel_position = layer_manager.grid_manager.get_pixel_position_of_grid_position(
+        pixel_position = layer_manager.grid_manager.get_world_position_of_grid_position(
             (subject.position[0], subject.position[1]),
         )
         actor.update_position(euclid.Vector2(*pixel_position))
             config: Config,
             logger: SynergineLogger,
             terminal: Terminal,
+            physics: Physics,
             read_queue_interval: float= 1/60.0,
     ):
         self.config = config
         self.logger = logger
+        self.physics = physics
         self._read_queue_interval = read_queue_interval
         self.terminal = terminal
         self.cycle_duration = self.config.resolve('core.cycle_duration')
             self.logger,
             middleware=self.get_layer_middleware(),
             interaction_manager=self.interaction_manager,
+            gui=self,
         )
         self.layer_manager.init()
         self.layer_manager.center()
             config,
             logger,
             terminal,
-            read_queue_interval,
+            physics=physics,
+            read_queue_interval=read_queue_interval,
         )
         self.physics = physics
 

synergine2_cocos2d/interaction.py

     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)
+            pixel_position = self.layer_manager.grid_manager.get_world_position_of_grid_position(grid_position)
 
             draw_line(
                 self.layer_manager.scrolling_manager.world_to_screen(*pixel_position),

synergine2_cocos2d/layer.py

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