arcade 3.0.0.dev34__tar.gz → 3.0.0.dev35__tar.gz

{arcade-3.0.0.dev34 → arcade-3.0.0.dev35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arcade
-Version: 3.0.0.dev34
+Version: 3.0.0.dev35
 Summary: Arcade Game Development Library
 Author-email: Paul Vincent Craven <paul@cravenfamily.com>
 License: License

arcade-3.0.0.dev35/arcade/VERSION

@@ -0,0 +1 @@
+3.0.0-dev.35

{arcade-3.0.0.dev34 → arcade-3.0.0.dev35}/arcade/application.py

@@ -20,7 +20,6 @@ import arcade
 from arcade.clock import GLOBAL_CLOCK, GLOBAL_FIXED_CLOCK, _setup_clock, _setup_fixed_clock
 from arcade.color import TRANSPARENT_BLACK
 from arcade.context import ArcadeContext
-from arcade.sections import SectionManager
 from arcade.types import LBWH, Color, Rect, RGBANormalized, RGBOrA255
 from arcade.utils import is_raspberry_pi
 from arcade.window_commands import get_display_size, set_window
@@ -979,37 +978,21 @@ class Window(pyglet.window.Window):
         # remove previously shown view's handlers
         if self._current_view is not None:
             self._current_view.on_hide_view()
-            if self._current_view.has_sections:
-                self.remove_handlers(self._current_view.section_manager)
             self.remove_handlers(self._current_view)
 
         # push new view's handlers
         self._current_view = new_view
-        if new_view.has_sections:
-            section_manager_managed_events = new_view.section_manager.managed_events
-            section_handlers = {
-                event_type: getattr(new_view.section_manager, event_type, None)
-                for event_type in section_manager_managed_events
-            }
-            if section_handlers:
-                self.push_handlers(**section_handlers)
-        else:
-            section_manager_managed_events = set()
 
         # Note: Excluding on_show because this even can trigger multiple times.
         #       It should only be called once when the view is shown.
         view_handlers = {
             event_type: getattr(new_view, event_type, None)
             for event_type in self.event_types
-            if event_type != "on_show"
-            and event_type not in section_manager_managed_events
-            and hasattr(new_view, event_type)
+            if event_type != "on_show" and hasattr(new_view, event_type)
         }
         if view_handlers:
             self.push_handlers(**view_handlers)
         self._current_view.on_show_view()
-        if self._current_view.has_sections:
-            self._current_view.section_manager.on_show_view()
 
         # Note: After the View has been pushed onto pyglet's stack of event handlers
         # (via push_handlers()), pyglet
@@ -1028,18 +1011,9 @@ class Window(pyglet.window.Window):
             return
 
         self._current_view.on_hide_view()
-        if self._current_view.has_sections:
-            self._current_view.section_manager.on_hide_view()
-            self.remove_handlers(self._current_view.section_manager)
         self.remove_handlers(self._current_view)
         self._current_view = None
 
-    # def _create(self) -> None:
-    #     super()._create()
-
-    # def _recreate(self, changes) -> None:
-    #     super()._recreate(changes)
-
     def flip(self) -> None:
         """
         Present the rendered content to the screen.
@@ -1249,7 +1223,7 @@ class View:
     Subclassing the window is very inflexible since you can't easily switch
     your update and draw logic.
 
-    A view is a way to encapsulate that logic so you can easily switch between
+    A view is a way to encapsulate that logic, so you can easily switch between
     different parts of your game. Maybe you have a title screen, a game screen,
     and a game over screen. Each of these could be a different view.
 
@@ -1261,46 +1235,6 @@ class View:
 
     def __init__(self, window: Window | None = None) -> None:
         self.window = arcade.get_window() if window is None else window
-        self.key: int | None = None
-        self._section_manager: SectionManager | None = None
-
-    @property
-    def section_manager(self) -> SectionManager:
-        """The section manager for this view.
-
-        If the view has section manager one will be created.
-        """
-        if self._section_manager is None:
-            self._section_manager = SectionManager(self)
-        return self._section_manager
-
-    @property
-    def has_sections(self) -> bool:
-        """Returns ``True`` if this view has sections."""
-        if self._section_manager is None:
-            return False
-        else:
-            return self.section_manager.has_sections
-
-    def add_section(
-        self,
-        section: arcade.Section,
-        at_index: int | None = None,
-        at_draw_order: int | None = None,
-    ) -> None:
-        """
-        Adds a section to the view Section Manager.
-
-        Args:
-            section:
-                The section to add to this section manager
-            at_index (optional):
-                The index to insert the section for event capture and
-                update events. If ``None`` it will be added at the end.
-            at_draw_order (optional):
-                Inserts the section in a specific draw order. Overwrites section.draw_order
-        """
-        self.section_manager.add_section(section, at_index, at_draw_order)
 
     def clear(
         self,

{arcade-3.0.0.dev34 → arcade-3.0.0.dev35}/arcade/examples/sections_demo_1.py

@@ -15,13 +15,15 @@ Note:
 If Python and Arcade are installed, this example can be run from the command line with:
 python -m arcade.examples.sections_demo_1
 """
+
 from __future__ import annotations
 
 import arcade
+from arcade import SectionManager
 
 
 class Box(arcade.SpriteSolidColor):
-    """ This is a Solid Sprite that represents a GREEN Box on the screen """
+    """This is a Solid Sprite that represents a GREEN Box on the screen"""
 
     def __init__(self, section):
         super().__init__(100, 100, color=arcade.color.APPLE_GREEN)
@@ -47,8 +49,7 @@ class ScreenPart(arcade.Section):
     boundaries (left, bottom, etc.)
     """
 
-    def __init__(self, left: int, bottom: int, width: int, height: int,
-                 **kwargs):
+    def __init__(self, left: int, bottom: int, width: int, height: int, **kwargs):
         super().__init__(left, bottom, width, height, **kwargs)
 
         self.selected: bool = False  # if this section is selected
@@ -66,19 +67,26 @@ class ScreenPart(arcade.Section):
         self.box.on_update(delta_time)
 
     def on_draw(self):
-        """ Draw this section """
+        """Draw this section"""
         if self.selected:
             # Section is selected when mouse is within its boundaries
-            arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom,
-                                              self.top, arcade.color.GRAY)
-            arcade.draw_text(f'You\'re are on the {self.name}', self.left + 30,
-                             self.top - 50, arcade.color.BLACK, 16)
+            arcade.draw_lrbt_rectangle_filled(
+                self.left, self.right, self.bottom, self.top, arcade.color.GRAY
+            )
+            arcade.draw_text(
+                f"You're are on the {self.name}",
+                self.left + 30,
+                self.top - 50,
+                arcade.color.BLACK,
+                16,
+            )
 
         # draw the box
         arcade.draw_sprite(self.box)
 
-    def on_mouse_drag(self, x: float, y: float, dx: float, dy: float,
-                      _buttons: int, _modifiers: int):
+    def on_mouse_drag(
+        self, x: float, y: float, dx: float, dy: float, _buttons: int, _modifiers: int
+    ):
         # if we hold a box, then whe move it at the same rate the mouse moves
         if self.hold_box:
             self.hold_box.position = x, y
@@ -110,28 +118,43 @@ class ScreenPart(arcade.Section):
 
 
 class GameView(arcade.View):
-
     def __init__(self):
         super().__init__()
 
         # add sections to the view
+        self.section_manager = SectionManager(self)
 
         # 1) First section holds half of the screen
-        self.add_section(ScreenPart(0, 0, self.window.width / 2,
-                                    self.window.height, name='Left'))
+        self.section_manager.add_section(
+            ScreenPart(0, 0, self.window.width / 2, self.window.height, name="Left")
+        )
 
         # 2) Second section holds the other half of the screen
-        self.add_section(ScreenPart(self.window.width / 2, 0,
-                                    self.window.width / 2, self.window.height,
-                                    name='Right'))
+        self.section_manager.add_section(
+            ScreenPart(
+                self.window.width / 2, 0, self.window.width / 2, self.window.height, name="Right"
+            )
+        )
+
+    def on_show_view(self) -> None:
+        self.section_manager.enable()
+
+    def on_hide_view(self) -> None:
+        self.section_manager.disable()
 
     def on_draw(self):
         # clear the screen
         self.clear(color=arcade.color.BEAU_BLUE)
 
         # draw a line separating each Section
-        arcade.draw_line(self.window.width / 2, 0, self.window.width / 2,
-                         self.window.height, arcade.color.BLACK, 1)
+        arcade.draw_line(
+            self.window.width / 2,
+            0,
+            self.window.width / 2,
+            self.window.height,
+            arcade.color.BLACK,
+            1,
+        )
 
 
 def main():
@@ -148,5 +171,5 @@ def main():
     window.run()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

{arcade-3.0.0.dev34 → arcade-3.0.0.dev35}/arcade/examples/sections_demo_2.py

@@ -18,9 +18,10 @@ Note:
 If Python and Arcade are installed, this example can be run from the command line with:
 python -m arcade.examples.sections_demo_2
 """
+
 import random
 
-import  arcade
+import arcade
 from arcade.color import BLACK, BLUE, RED, BEAU_BLUE, GRAY
 from arcade.key import W, S, UP, DOWN
 
@@ -35,9 +36,8 @@ class Player(arcade.Section):
     """
 
     def __init__(
-            self, left: int, bottom: int, width: int, height: int,
-            key_up: int, key_down: int, **kwargs
-        ):
+        self, left: int, bottom: int, width: int, height: int, key_up: int, key_down: int, **kwargs
+    ):
         super().__init__(
             left,
             bottom,
@@ -67,19 +67,24 @@ class Player(arcade.Section):
 
     def on_draw(self):
         # draw sections info and score
-        if self.name == 'Left':
-            keys = 'W and S'
+        if self.name == "Left":
+            keys = "W and S"
             start_x = self.left + 5
         else:
-            keys = 'UP and DOWN'
+            keys = "UP and DOWN"
             start_x = self.left - 290
         arcade.draw_text(
-            f'Player {self.name} (move paddle with: {keys})',
-            start_x, self.top - 20, BLUE, 9,
+            f"Player {self.name} (move paddle with: {keys})",
+            start_x,
+            self.top - 20,
+            BLUE,
+            9,
         )
         arcade.draw_text(
-            f'Score: {self.score}', self.left + 20,
-            self.bottom + 20, BLUE,
+            f"Score: {self.score}",
+            self.left + 20,
+            self.bottom + 20,
+            BLUE,
         )
 
         # draw the paddle
@@ -98,7 +103,6 @@ class Player(arcade.Section):
 
 
 class Pong(arcade.View):
-
     def __init__(self):
         super().__init__()
 
@@ -108,15 +112,22 @@ class Pong(arcade.View):
 
         # we store each Section
         self.left_player: Player = Player(
-            0, 0, PLAYER_SECTION_WIDTH, self.window.height, key_up=W,
-            key_down=S, name='Left')
+            0, 0, PLAYER_SECTION_WIDTH, self.window.height, key_up=W, key_down=S, name="Left"
+        )
         self.right_player: Player = Player(
-            self.window.width - PLAYER_SECTION_WIDTH, 0, PLAYER_SECTION_WIDTH,
-            self.window.height, key_up=UP, key_down=DOWN, name='Right')
+            self.window.width - PLAYER_SECTION_WIDTH,
+            0,
+            PLAYER_SECTION_WIDTH,
+            self.window.height,
+            key_up=UP,
+            key_down=DOWN,
+            name="Right",
+        )
 
         # add the sections to the SectionManager so Sections start to work
-        self.add_section(self.left_player)
-        self.add_section(self.right_player)
+        self.section_manager = arcade.SectionManager(self)
+        self.section_manager.add_section(self.left_player)
+        self.section_manager.add_section(self.right_player)
 
         # add each paddle to the sprite list
         self.paddles.append(self.left_player.paddle)
@@ -139,6 +150,12 @@ class Pong(arcade.View):
         self.left_player.setup()
         self.right_player.setup()
 
+    def on_show_view(self) -> None:
+        self.section_manager.enable()
+
+    def on_hide_view(self) -> None:
+        self.section_manager.disable()
+
     def on_update(self, delta_time: float):
         self.ball.update()  # update the ball
 
@@ -168,7 +185,7 @@ class Pong(arcade.View):
             self.end_game(self.left_player)
 
     def end_game(self, winner: Player):
-        """ Called when one player wins """
+        """Called when one player wins"""
         winner.score += 1  # increment the winner score
         self.setup()  # prepare a new game
 
@@ -185,7 +202,7 @@ class Pong(arcade.View):
 
 def main():
     # create the window
-    window = arcade.Window(title='Two player simple Pong with Sections!')
+    window = arcade.Window(title="Two player simple Pong with Sections!")
 
     # create the custom View
     game = Pong()
@@ -200,5 +217,5 @@ def main():
     window.run()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

{arcade-3.0.0.dev34 → arcade-3.0.0.dev35}/arcade/examples/sections_demo_3.py

@@ -21,26 +21,28 @@ Note:
 If Python and Arcade are installed, this example can be run from the command line with:
 python -m arcade.examples.sections_demo_3
 """
+
 from __future__ import annotations
+
 from math import sqrt
 
 import arcade
-from arcade import Section
+from arcade import Section, SectionManager
 from arcade.types import Color
 
 INFO_BAR_HEIGHT = 40
 PANEL_WIDTH = 200
 SPRITE_SPEED = 1
 
-COLOR_LIGHT = Color.from_hex_string('#D9BBA0')
-COLOR_DARK = Color.from_hex_string('#0D0D0D')
-COLOR_1 = Color.from_hex_string('#2A1459')
-COLOR_2 = Color.from_hex_string('#4B89BF')
-COLOR_3 = Color.from_hex_string('#03A688')
+COLOR_LIGHT = Color.from_hex_string("#D9BBA0")
+COLOR_DARK = Color.from_hex_string("#0D0D0D")
+COLOR_1 = Color.from_hex_string("#2A1459")
+COLOR_2 = Color.from_hex_string("#4B89BF")
+COLOR_3 = Color.from_hex_string("#03A688")
 
 
 class Ball(arcade.SpriteCircle):
-    """ The moving ball """
+    """The moving ball"""
 
     def __init__(self, radius, color):
         super().__init__(radius, color)
@@ -54,7 +56,7 @@ class Ball(arcade.SpriteCircle):
 
 
 class ModalSection(Section):
-    """ A modal section that represents a popup that waits for user input """
+    """A modal section that represents a popup that waits for user input"""
 
     def __init__(self, left: int, bottom: int, width: int, height: int):
         super().__init__(left, bottom, width, height, modal=True, enabled=False)
@@ -66,34 +68,39 @@ class ModalSection(Section):
 
     def on_draw(self):
         # draw modal frame and button
-        arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom,
-                                          self.top, arcade.color.GRAY)
-        arcade.draw_lrbt_rectangle_outline(self.left, self.right, self.bottom,
-                                           self.top, arcade.color.WHITE)
+        arcade.draw_lrbt_rectangle_filled(
+            self.left, self.right, self.bottom, self.top, arcade.color.GRAY
+        )
+        arcade.draw_lrbt_rectangle_outline(
+            self.left, self.right, self.bottom, self.top, arcade.color.WHITE
+        )
         self.draw_button()
 
     def draw_button(self):
         # draws the button and button text
         arcade.draw_sprite(self.button)
-        arcade.draw_text('Close Modal', self.button.left + 5,
-                         self.button.bottom + self.button.height / 2,
-                         arcade.color.WHITE)
+        arcade.draw_text(
+            "Close Modal",
+            self.button.left + 5,
+            self.button.bottom + self.button.height / 2,
+            arcade.color.WHITE,
+        )
 
     def on_resize(self, width: int, height: int):
-        """ set position on screen resize """
+        """set position on screen resize"""
         self.left = width // 3
         self.bottom = (height // 2) - self.height // 2
         pos = self.left + self.width / 2, self.bottom + self.height / 2
         self.button.position = pos
 
     def on_mouse_press(self, x: float, y: float, button: int, modifiers: int):
-        """ Check if the button is pressed """
+        """Check if the button is pressed"""
         if self.button.collides_with_point((x, y)):
             self.enabled = False
 
 
 class InfoBar(Section):
-    """ This is the top bar of the screen where info is showed """
+    """This is the top bar of the screen where info is showed"""
 
     @property
     def ball(self):
@@ -101,21 +108,30 @@ class InfoBar(Section):
 
     def on_draw(self):
         # draw game info
-        arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom,
-                                          self.top, COLOR_DARK)
-        arcade.draw_lrbt_rectangle_outline(self.left, self.right, self.bottom,
-                                           self.top, COLOR_LIGHT)
-        arcade.draw_text(f'Ball bounce count: {self.ball.bounce_count}',
-                         self.left + 20, self.top - self.height / 1.6,
-                         COLOR_LIGHT)
+        arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom, self.top, COLOR_DARK)
+        arcade.draw_lrbt_rectangle_outline(
+            self.left, self.right, self.bottom, self.top, COLOR_LIGHT
+        )
+        arcade.draw_text(
+            f"Ball bounce count: {self.ball.bounce_count}",
+            self.left + 20,
+            self.top - self.height / 1.6,
+            COLOR_LIGHT,
+        )
 
         ball_change_axis = self.ball.change_x, self.ball.change_y
-        arcade.draw_text(f'Ball change in axis: {ball_change_axis}',
-                         self.left + 220, self.top - self.height / 1.6,
-                         COLOR_LIGHT)
-        arcade.draw_text(f'Ball speed: {self.ball.speed} pixels/second',
-                         self.left + 480, self.top - self.height / 1.6,
-                         COLOR_LIGHT)
+        arcade.draw_text(
+            f"Ball change in axis: {ball_change_axis}",
+            self.left + 220,
+            self.top - self.height / 1.6,
+            COLOR_LIGHT,
+        )
+        arcade.draw_text(
+            f"Ball speed: {self.ball.speed} pixels/second",
+            self.left + 480,
+            self.top - self.height / 1.6,
+            COLOR_LIGHT,
+        )
 
     def on_resize(self, width: int, height: int):
         # stick to the top
@@ -124,10 +140,9 @@ class InfoBar(Section):
 
 
 class Panel(Section):
-    """This is the Panel to the right where buttons and info is showed """
+    """This is the Panel to the right where buttons and info is showed"""
 
-    def __init__(self, left: int, bottom: int, width: int, height: int,
-                 **kwargs):
+    def __init__(self, left: int, bottom: int, width: int, height: int, **kwargs):
         super().__init__(left, bottom, width, height, **kwargs)
 
         # create buttons
@@ -144,31 +159,39 @@ class Panel(Section):
         return arcade.SpriteSolidColor(100, 50, color=color)
 
     def draw_button_stop(self):
-        arcade.draw_text('Press button to stop the ball', self.left + 10,
-                         self.top - 40, COLOR_LIGHT, 10)
+        arcade.draw_text(
+            "Press button to stop the ball", self.left + 10, self.top - 40, COLOR_LIGHT, 10
+        )
         arcade.draw_sprite(self.button_stop)
 
     def draw_button_toggle_info_bar(self):
-        arcade.draw_text('Press to toggle info_bar', self.left + 10,
-                         self.top - 140, COLOR_LIGHT, 10)
+        arcade.draw_text(
+            "Press to toggle info_bar", self.left + 10, self.top - 140, COLOR_LIGHT, 10
+        )
         arcade.draw_sprite(self.button_toggle_info_bar)
 
     def draw_button_show_modal(self):
         arcade.draw_sprite(self.button_show_modal)
-        arcade.draw_text('Show Modal', self.left - 37 + self.width / 2,
-                         self.bottom + 95, COLOR_DARK, 10)
+        arcade.draw_text(
+            "Show Modal", self.left - 37 + self.width / 2, self.bottom + 95, COLOR_DARK, 10
+        )
 
     def on_draw(self):
-        arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom,
-                                          self.top, COLOR_DARK)
-        arcade.draw_lrbt_rectangle_outline(self.left, self.right, self.bottom,
-                                           self.top, COLOR_LIGHT)
+        arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom, self.top, COLOR_DARK)
+        arcade.draw_lrbt_rectangle_outline(
+            self.left, self.right, self.bottom, self.top, COLOR_LIGHT
+        )
         self.draw_button_stop()
         self.draw_button_toggle_info_bar()
 
         if self.pressed_key:
-            arcade.draw_text(f'Pressed key code: {self.pressed_key}',
-                             self.left + 10, self.top - 240, COLOR_LIGHT, 9)
+            arcade.draw_text(
+                f"Pressed key code: {self.pressed_key}",
+                self.left + 10,
+                self.top - 240,
+                COLOR_LIGHT,
+                9,
+            )
 
         self.draw_button_show_modal()
 
@@ -200,10 +223,9 @@ class Panel(Section):
 
 
 class Map(Section):
-    """ This represents the place where the game takes place """
+    """This represents the place where the game takes place"""
 
-    def __init__(self, left: int, bottom: int, width: int, height: int,
-                 **kwargs):
+    def __init__(self, left: int, bottom: int, width: int, height: int, **kwargs):
         super().__init__(left, bottom, width, height, **kwargs)
 
         self.ball = Ball(20, COLOR_3)
@@ -214,7 +236,6 @@ class Map(Section):
         self.pressed_key: int | None = None
 
     def on_update(self, delta_time: float):
-
         if self.pressed_key:
             if self.pressed_key == arcade.key.UP:
                 self.ball.change_y += SPRITE_SPEED
@@ -235,10 +256,10 @@ class Map(Section):
             self.ball.bounce_count += 1
 
     def on_draw(self):
-        arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom,
-                                          self.top, COLOR_DARK)
-        arcade.draw_lrbt_rectangle_outline(self.left, self.right, self.bottom,
-                                           self.top, COLOR_LIGHT)
+        arcade.draw_lrbt_rectangle_filled(self.left, self.right, self.bottom, self.top, COLOR_DARK)
+        arcade.draw_lrbt_rectangle_outline(
+            self.left, self.right, self.bottom, self.top, COLOR_LIGHT
+        )
         self.sprite_list.draw()
 
     def on_key_press(self, symbol: int, modifiers: int):
@@ -253,7 +274,7 @@ class Map(Section):
 
 
 class GameView(arcade.View):
-    """ The game itself """
+    """The game itself"""
 
     def __init__(self):
         super().__init__()
@@ -263,7 +284,8 @@ class GameView(arcade.View):
         self.modal_section = ModalSection(
             (self.window.width / 2) - 150,
             (self.window.height / 2) - 100,
-            300, 200,
+            300,
+            200,
         )
 
         # we set accept_keyboard_events to False (default to True)
@@ -277,18 +299,28 @@ class GameView(arcade.View):
 
         # as prevent_dispatch is on by default, we let pass the events to the
         # following Section: the map
-        self.panel = Panel(self.window.width - PANEL_WIDTH, 0, PANEL_WIDTH,
-                           self.window.height - INFO_BAR_HEIGHT,
-                           prevent_dispatch={False})
-        self.map = Map(0, 0, self.window.width - PANEL_WIDTH,
-                       self.window.height - INFO_BAR_HEIGHT)
+        self.panel = Panel(
+            self.window.width - PANEL_WIDTH,
+            0,
+            PANEL_WIDTH,
+            self.window.height - INFO_BAR_HEIGHT,
+            prevent_dispatch={False},
+        )
+        self.map = Map(0, 0, self.window.width - PANEL_WIDTH, self.window.height - INFO_BAR_HEIGHT)
 
         # add the sections
+        self.section_manager = SectionManager(self)
         self.section_manager.add_section(self.modal_section)
         self.section_manager.add_section(self.info_bar)
         self.section_manager.add_section(self.panel)
         self.section_manager.add_section(self.map)
 
+    def on_show_view(self) -> None:
+        self.section_manager.enable()
+
+    def on_hide_view(self) -> None:
+        self.section_manager.disable()
+
     def on_draw(self):
         self.clear()
 
@@ -302,5 +334,5 @@ def main():
     window.run()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()