Refacto: move from Pygame to Pyglet

.gitignore

@@ -1 +1,5 @@
-*.pyc
+.venv/
+.vscode/*
+!.vscode/launch.json
+
+__pycache__

.pylintrc

@@ -0,0 +1,5 @@
+[MASTER]
+disable=
+    C0114,
+    C0115,
+    C0116,

.python-version

@@ -0,0 +1 @@
+3.12.1

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+  // Utilisez IntelliSense pour en savoir plus sur les attributs possibles.
+  // Pointez pour afficher la description des attributs existants.
+  // Pour plus d'informations, visitez : https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python : fichier actif",
+      "type": "python",
+      "request": "launch",
+      "program": "${file}",
+      "console": "integratedTerminal",
+      "justMyCode": true
+    }
+  ]
+}

pyoro/activity/activities/activity.py

@@ -0,0 +1,27 @@
+from pyglet import event, clock
+
+from pyoro.views.view import View
+
+
+class Activity(event.EventDispatcher):
+    def __init__(self) -> None:
+        self.running = False
+
+        self.view: View | None = None
+
+        self.register_event_type("on_start")  # type: ignore
+        self.register_event_type("on_stop")  # type: ignore
+
+    def start(self):
+        self.running = True
+
+        def update_view(_dt: float) -> None:
+            if self.view:
+                self.view.refresh()
+
+        clock.schedule(update_view)  # type: ignore
+        self.dispatch_event("on_start")  # type: ignore
+
+    def stop(self):
+        self.running = False
+        self.dispatch_event("on_stop")  # type: ignore

pyoro/activity/activities/game_activity.py

@@ -0,0 +1,21 @@
+import logging
+
+from pyoro.activity.activities.activity import Activity
+from pyoro.game.controllers.user_controller import UserController
+from pyoro.game.game_engine import GameEngine
+from pyoro.game.game_state import GameMode
+from pyoro.views.game_view import GameView
+
+
+class GameActivity(Activity):
+    def __init__(self, game_mode: GameMode):
+        super().__init__()
+
+        self.controller = UserController()
+        self.game_engine = GameEngine(game_mode, self.controller)
+        self.view = GameView(self.game_engine)
+
+    def start(self) -> None:
+        logging.info("Starting")
+        self.game_engine.run()
+        return super().start()

pyoro/activity/activities/main_menu_activity.py

@@ -0,0 +1,37 @@
+import logging
+
+from pyoro.activity.activities.activity import Activity
+from pyoro.activity.activities.game_activity import GameActivity
+from pyoro.activity.activities.settings_activity import SettingsActivity
+from pyoro.activity.activity_manager import ActivityManager
+from pyoro.game.game_engine import GameEngine
+from pyoro.game.game_state import GameMode
+from pyoro.views.main_menu_view import MainMenuView
+
+
+class MainMenuActivity(Activity):
+    def __init__(self):
+        super().__init__()
+        self.game_engine = GameEngine(GameMode.TONGUE)
+        self.view = MainMenuView(
+            self.game_engine, self.on_play, self.on_show_settings, self.on_quit
+        )
+
+    def start(self) -> None:
+        logging.info("Starting")
+        self.game_engine.run()
+        return super().start()
+
+    def on_play(self, mode: GameMode) -> None:
+        activity_manager = ActivityManager()
+        activity_manager.push_activity(GameActivity(mode))
+        self.stop()
+
+    def on_show_settings(self) -> None:
+        activity_manager = ActivityManager()
+        activity_manager.push_activity(SettingsActivity())
+        self.stop()
+
+    def on_quit(self) -> None:
+        activity_manager = ActivityManager()
+        activity_manager.stop()

pyoro/activity/activities/settings_activity.py

@@ -0,0 +1,7 @@
+import logging
+from pyoro.activity.activities.activity import Activity
+
+
+class SettingsActivity(Activity):
+    def start(self):
+        logging.info("Starting")

pyoro/activity/activity_manager.py

@@ -0,0 +1,52 @@
+import logging
+import pyglet
+
+from pyoro.activity.activities.activity import Activity
+from pyoro.graphics.window import Window
+from pyoro.utils.singleton import singleton
+
+
+@singleton
+class ActivityManager:
+    def __init__(self):
+        self._activities: list[Activity] = []
+        self._current_activity: Activity | None = None
+
+        window = Window()
+        window.push_handlers(on_close=self.stop)  # type: ignore
+
+    def push_activity(self, activity: Activity) -> None:
+        logging.debug(
+            f"New activity of type {activity.__class__.__name__} added to the stack"
+        )
+        self._activities.append(activity)
+
+    def on_activity_stop(self) -> None:
+        logging.info("Current activity stopped. Starting next activity")
+
+        self._current_activity.pop_handlers()  # type: ignore
+
+        if self._activities:
+            self.set_current_activity(self._activities.pop(0))
+        else:
+            logging.info("No activity left on stack")
+            self.stop()
+
+    def set_current_activity(self, activity: Activity) -> None:
+        self._current_activity = activity
+        self._current_activity.push_handlers(on_stop=self.on_activity_stop)  # type: ignore
+        self._current_activity.start()
+
+    def start(self) -> None:
+        logging.info("Starting")
+
+        if not self._activities:
+            logging.warn("No activity to start")
+            return self.stop()
+        self.set_current_activity(self._activities.pop(0))
+
+        pyglet.app.run()
+
+    def stop(self) -> None:
+        logging.info("Stopping")
+        pyglet.app.exit()

pyoro/banks/animation_bank.py

@@ -0,0 +1,70 @@
+import logging
+import pyglet
+from pyoro.banks.bank import Bank
+from pyoro.banks.image_bank import ImageBank
+from pyoro.utils.singleton import singleton
+
+ANIMATION_IDS: dict[str, tuple[tuple[str, float], ...]] = {
+    "bean_green": (
+        ("bean_green_left", 0.4),
+        ("bean_green_middle", 0.4),
+        ("bean_green_right", 0.4),
+        ("bean_green_middle", 0.4),
+    ),
+    "bean_pink": (
+        ("bean_pink_left", 0.4),
+        ("bean_pink_middle", 0.4),
+        ("bean_pink_right", 0.4),
+        ("bean_pink_middle", 0.4),
+    ),
+    "explosion": (
+        ("explosion_0", 0.4),
+        ("explosion_1", 0.4),
+        ("explosion_2", 0.4),
+    ),
+    "score_300": (
+        ("score_300_0", 0.05),
+        ("score_300_1", 0.05),
+        ("score_300_2", 0.05),
+        ("score_300_3", 0.05),
+        ("score_300_4", 0.05),
+        ("score_300_5", 0.05),
+    ),
+    "score_1000": (
+        ("score_1000_0", 0.05),
+        ("score_1000_1", 0.05),
+        ("score_1000_2", 0.05),
+        ("score_1000_3", 0.05),
+        ("score_1000_4", 0.05),
+        ("score_1000_5", 0.05),
+    ),
+}
+
+
+@singleton
+class AnimationBank(Bank[pyglet.image.Animation]):
+    def __init__(self):
+        logging.info("Initializing")
+
+        image_bank = ImageBank()
+        self.fallback = pyglet.image.Animation(
+            [pyglet.image.AnimationFrame(image_bank.get_fallback(), 1)]
+        )
+        super().__init__()
+
+    def load(self):
+        logging.info("Generating animations")
+
+        image_bank = ImageBank()
+
+        for key, value in ANIMATION_IDS.items():
+            self.data[key] = pyglet.image.Animation(
+                [
+                    pyglet.image.AnimationFrame(
+                        image_bank.get(image_id), frame_duration
+                    )
+                    for (image_id, frame_duration) in value
+                ]
+            )
+
+        return super().load()

pyoro/banks/bank.py

@@ -0,0 +1,25 @@
+import typing
+
+T = typing.TypeVar("T")
+
+
+class Bank(typing.Generic[T]):
+    def __init__(self):
+        self.data: dict[str, T] = {}
+        self.fallback: T | None = None
+
+    def load(self) -> None:
+        pass
+
+    def get(self, key: str) -> T:
+        if key not in self.data:
+            raise KeyError(f"Key '{key}' not found in bank '{self.__class__.__name__}'")
+        return self.data[key]
+
+    def __getitem__(self, key: str):
+        return self.get(key)
+
+    def get_fallback(self) -> T:
+        if not self.fallback:
+            raise NotImplementedError()
+        return self.fallback