module refactoring

game/states/game_screens.py

@@ -13,11 +13,11 @@ from game.constants import DIRECTION_KEYS, ACTION_KEYS
 from game.state import Push, State, StateResult
 from game.tags import IsItem, IsPlayer, IsDoor, IsActor
 from game.constants import WALL_CHAR
-from game.states import MainMenu
+from game.states import menu_screens
 
 
 @attrs.define()
-class InGame(State):
+class MainScreen(State):
     """Primary in-game state."""
 
     def on_event(self, event: tcod.event.Event) -> StateResult:
@@ -43,7 +43,7 @@ class InGame(State):
                     gold.clear()
                 return None
             case tcod.event.KeyDown(sym=KeySym.ESCAPE):
-                return Push(MainMenu())
+                return Push(menu_screens())
             case _:
                 return None
 

game/states/menu_screens.py

@@ -3,23 +3,23 @@
 from __future__ import annotations
 
 import g
-import game.menus
+import game.states.menus
 import game.world_tools
 from game.state import Reset, StateResult
-from game.states.InGame import InGame
+from game.states.game_screens import MainScreen
 
-class MainMenu(game.menus.ListMenu):
+class MainMenu(game.states.menus.ListMenu):
     """Main/escape menu."""
     __slots__ = ()
 
     def __init__(self) -> None:
         """Initialize the main menu."""
         items = [
-            game.menus.SelectItem("New game", self.new_game),
-            game.menus.SelectItem("Quit", self.quit),
+            game.states.menus.SelectItem("New game", self.new_game),
+            game.states.menus.SelectItem("Quit", self.quit),
         ]
         if hasattr(g, "world"):
-            items.insert(0, game.menus.SelectItem("Continue", self.continue_))
+            items.insert(0, game.states.menus.SelectItem("Continue", self.continue_))
 
         super().__init__(
             items=tuple(items),
@@ -31,13 +31,13 @@ class MainMenu(game.menus.ListMenu):
     @staticmethod
     def continue_() -> StateResult:
         """Return to the game."""
-        return Reset(InGame())
+        return Reset(MainScreen())
 
     @staticmethod
     def new_game() -> StateResult:
         """Begin a new game."""
         g.world = game.world_tools.new_world()
-        return Reset(InGame())
+        return Reset(MainScreen())
 
     @staticmethod
     def quit() -> StateResult:

game/states/menus.py

@@ -0,0 +1,100 @@
+"""Menu UI classes."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Protocol
+
+import attrs
+import tcod.console
+import tcod.event
+from tcod.event import KeySym
+
+from game.constants import DIRECTION_KEYS
+from game.state import Pop, State, StateResult, draw_previous_states
+
+
+class MenuItem(Protocol):
+    """Menu item protocol."""
+
+    __slots__ = ()
+
+    def on_event(self, event: tcod.event.Event) -> StateResult:
+        """Handle events passed to the menu item."""
+
+    def on_draw(self, console: tcod.console.Console, x: int, y: int, highlight: bool) -> None:
+        """Draw is item at the given position."""
+
+
+@attrs.define()
+class SelectItem(MenuItem):
+    """Clickable menu item."""
+
+    label: str
+    callback: Callable[[], StateResult]
+
+    def on_event(self, event: tcod.event.Event) -> StateResult:
+        """Handle events selecting this item."""
+        match event:
+            case tcod.event.KeyDown(sym=sym) if sym in {KeySym.RETURN, KeySym.RETURN2, KeySym.KP_ENTER}:
+                return self.callback()
+            case tcod.event.MouseButtonUp(button=tcod.event.MouseButton.LEFT):
+                return self.callback()
+            case _:
+                return None
+
+    def on_draw(self, console: tcod.console.Console, x: int, y: int, highlight: bool) -> None:
+        """Render this items label."""
+        console.print(x, y, self.label, fg=(255, 255, 255), bg=(64, 64, 64) if highlight else (0, 0, 0))
+
+
+@attrs.define()
+class ListMenu(State):
+    """Simple list menu state."""
+
+    items: tuple[MenuItem, ...]
+    selected: int | None = 0
+    x: int = 0
+    y: int = 0
+
+    def on_event(self, event: tcod.event.Event) -> StateResult:
+        """Handle events for menus."""
+        match event:
+            case tcod.event.Quit():
+                raise SystemExit()
+            case tcod.event.KeyDown(sym=sym) if sym in DIRECTION_KEYS:
+                dx, dy = DIRECTION_KEYS[sym]
+                if dx != 0 or dy == 0:
+                    return self.activate_selected(event)
+                if self.selected is not None:
+                    self.selected += dy
+                    self.selected %= len(self.items)
+                else:
+                    self.selected = 0 if dy == 1 else len(self.items) - 1
+                return None
+            case tcod.event.MouseMotion(position=(_, y)):
+                y -= self.y
+                self.selected = y if 0 <= y < len(self.items) else None
+                return None
+            case tcod.event.KeyDown(sym=KeySym.ESCAPE):
+                return self.on_cancel()
+            case tcod.event.MouseButtonUp(button=tcod.event.MouseButton.RIGHT):
+                return self.on_cancel()
+            case _:
+                return self.activate_selected(event)
+
+    def activate_selected(self, event: tcod.event.Event) -> StateResult:
+        """Call the selected menu items callback."""
+        if self.selected is not None:
+            return self.items[self.selected].on_event(event)
+        return None
+
+    def on_cancel(self) -> StateResult:
+        """Handle escape or right click being pressed on menus."""
+        return Pop()
+
+    def on_draw(self, console: tcod.console.Console) -> None:
+        """Render the menu."""
+        draw_previous_states(self, console)
+        for i, item in enumerate(self.items):
+            item.on_draw(console, x=self.x, y=self.y + i, highlight=i == self.selected)