ui/curses: add character creation wizard

pqcli/ui/curses/views/__init__.py

@@ -1,6 +1,11 @@
 from .base_view import BaseView
 from .choose_character_view import ChooseCharacterView
 from .confirm_view import ConfirmView
-from .create_character_view import CreateCharacterView
+from .create_character_view import (
+    ChooseCharacterClassView,
+    ChooseCharacterNameView,
+    ChooseCharacterRaceView,
+    ChooseCharacterStatsView,
+)
 from .game_view import GameView
 from .roster_view import RosterView

pqcli/ui/curses/views/choose_character_view.py

@@ -2,55 +2,30 @@ import functools
 import typing as T
 
 from pqcli.roster import Roster
-
-from ..event_handler import EventHandler
-from ..util import Choice
-from ..widgets import Menu
-from .base_view import BaseView
+from pqcli.ui.curses.event_handler import EventHandler
+from pqcli.ui.curses.util import Choice
+from pqcli.ui.curses.views.menu_view import MenuView
+from pqcli.ui.curses.widgets import Menu
 
 
-class ChooseCharacterView(BaseView):
+class ChooseCharacterView(MenuView):
     def __init__(self, screen: T.Any, roster: Roster, title: str) -> None:
-        super().__init__(screen)
+        super().__init__(screen, title)
 
-        self.title = f"{title}:"
-        self.on_cancel = EventHandler()
-        self.on_confirm = EventHandler()
-
-        self.choices: T.List[Choice] = []
         for y, player in enumerate(roster.players, 1):
             key: T.Optional[str] = str(y % 10) if y <= 10 else None
-            self.choices.append(
+            self._choices.append(
                 Choice(
                     keys=[ord(key)] if key is not None else [],
                     desc=f"[{key or '-'}] {player.name}",
                     callback=functools.partial(self.on_confirm, player),
                 )
             )
-        self.choices.append(
+
+        self._choices.append(
             Choice(
                 keys=list(map(ord, "qQ\N{ESC}")),
                 desc="[Q] Cancel",
                 callback=self.on_cancel,
             )
         )
-
-    def start(self) -> None:
-        scr_height, scr_width = self.screen.getmaxyx()
-        self.screen.erase()
-        self.screen.noutrefresh()
-
-        self.main_menu = Menu(
-            header=self.title,
-            choices=self.choices,
-            scr_height=scr_height,
-            scr_width=scr_width,
-        )
-        self.main_menu.render()
-
-    def stop(self) -> None:
-        self.main_menu.stop()
-
-    def keypress(self, key: int) -> None:
-        self.main_menu.keypress(key)
-        self.main_menu.render()

pqcli/ui/curses/views/create_character_view.py

@@ -1,16 +1,200 @@
+import curses
+import curses.ascii
+import functools
 import typing as T
 
-from ..event_handler import EventHandler
-from .base_view import BaseView
+from pqcli.config import CLASSES, PRIME_STATS, RACES
+from pqcli.mechanic import StatsBuilder, generate_name
+from pqcli.ui.curses.event_handler import EventHandler
+from pqcli.ui.curses.util import Choice
+from pqcli.ui.curses.views.base_view import BaseView
+from pqcli.ui.curses.views.menu_view import MenuView
 
 
-class CreateCharacterView(BaseView):
+class ChooseCharacterNameView(BaseView):
     def __init__(self, screen: T.Any) -> None:
         super().__init__(screen)
 
         self.on_cancel = EventHandler()
         self.on_confirm = EventHandler()
 
+        self._text = generate_name()
+
+    def start(self) -> None:
+        self.screen.erase()
+        self.screen.noutrefresh()
+
+        scr_height, scr_width = self.screen.getmaxyx()
+
+        h = 1
+        w = 30
+        y = (scr_height - h - 2) // 2
+        x = (scr_width - w - 2) // 2
+        self._win = curses.newwin(h + 2, w + 2, y, x)
+        self._win.box()
+        self.screen.addstr(y - 1, x, "Choose character name:")
+        self.screen.addstr(y + h + 2, x, "[ F5  ] generate random name")
+        self.screen.addstr(y + h + 3, x, "[ Esc ] cancel")
+        self.screen.addstr(y + h + 4, x, "[Enter] confirm")
+        self._win.refresh()
+        self._render()
+
+    def stop(self) -> None:
+        del self._win
+        self._win = None
+
     def keypress(self, key: int) -> None:
-        if key in map(ord, "qQ\N{ESC}"):
+        if key == curses.ascii.ESC:
             self.on_cancel()
+
+        elif key == curses.KEY_F5:
+            self._text = generate_name()
+
+        elif curses.ascii.isprint(key):
+            self._text += chr(key)
+
+        elif key == curses.KEY_BACKSPACE or key == curses.ascii.DEL:
+            self._text = self._text[:-1]
+
+        elif key == curses.ascii.NL:
+            self._text = self._text.strip()
+            if self._text:
+                self.on_confirm(self._text)
+            else:
+                self.on_cancel()
+
+        elif key == curses.ascii.ETB:  # ^w
+            self._text = ""
+
+        self._render()
+
+    def _render(self) -> None:
+        if not self._win:
+            return
+
+        self._win.erase()
+        self._win.box()
+        self._win.addnstr(1, 1, self._text, self._win.getmaxyx()[1] - 2)
+        self._win.refresh()
+
+
+class ChooseCharacterRaceView(MenuView):
+    def __init__(self, screen: T.Any) -> None:
+        super().__init__(screen, "Choose character race")
+
+        for y, race in enumerate(RACES, 1):
+            key: T.Optional[str] = str(y % 10) if y <= 10 else None
+            self._choices.append(
+                Choice(
+                    keys=[ord(key)] if key is not None else [],
+                    desc=f"[{key or '-'}] {race.name}",
+                    callback=functools.partial(self.on_confirm, race),
+                )
+            )
+
+        self._choices.append(
+            Choice(
+                keys=list(map(ord, "qQ\N{ESC}")),
+                desc="[Q] Cancel",
+                callback=self.on_cancel,
+            )
+        )
+
+
+class ChooseCharacterClassView(MenuView):
+    def __init__(self, screen: T.Any) -> None:
+        super().__init__(screen, "Choose character class")
+
+        for y, class_ in enumerate(CLASSES, 1):
+            key: T.Optional[str] = str(y % 10) if y <= 10 else None
+            self._choices.append(
+                Choice(
+                    keys=[ord(key)] if key is not None else [],
+                    desc=f"[{key or '-'}] {class_.name}",
+                    callback=functools.partial(self.on_confirm, class_),
+                )
+            )
+
+        self._choices.append(
+            Choice(
+                keys=list(map(ord, "qQ\N{ESC}")),
+                desc="[Q] Cancel",
+                callback=self.on_cancel,
+            )
+        )
+
+
+class ChooseCharacterStatsView(BaseView):
+    def __init__(self, screen: T.Any) -> None:
+        super().__init__(screen)
+
+        self.on_cancel = EventHandler()
+        self.on_confirm = EventHandler()
+
+        self._stats_builder = StatsBuilder()
+        self._stats = self._stats_builder.roll()
+
+    def start(self) -> None:
+        scr_height, scr_width = self.screen.getmaxyx()
+
+        h2 = len(PRIME_STATS) + 2
+        h = 5 + h2
+        w = 30
+        y = (scr_height - h - 2) // 2
+        x = (scr_width - w - 2) // 2
+
+        self.screen.erase()
+        self.screen.noutrefresh()
+
+        self._win = curses.newwin(h, w, y, x)
+        self._stats_win = curses.newwin(h2, w, y + 1, x)
+        self._render()
+
+    def stop(self) -> None:
+        del self._win
+        del self._stats_win
+        self._win = None
+        self._stats_win = None
+
+    def keypress(self, key: int) -> None:
+        if key == curses.ascii.ESC or key in map(ord, "qQ"):
+            self.on_cancel()
+
+        elif key == curses.ascii.NL:
+            self.on_confirm(self._stats)
+
+        elif key == curses.KEY_F5:
+            self._stats = self._stats_builder.roll()
+
+        elif key == curses.KEY_F6:
+            try:
+                self._stats = self._stats_builder.unroll()
+            except IndexError:
+                pass
+
+        self._render()
+
+    def _render(self) -> None:
+        if not self._win:
+            return
+
+        y, x = self._win.getbegyx()
+        stats_h = self._stats_win.getmaxyx()[0]
+
+        self._win.erase()
+        self._win.addstr(0, 0, "Roll character stats:")
+        self._win.addstr(1 + stats_h + 0, 0, "[ F5  ] roll")
+        self._win.addstr(1 + stats_h + 1, 0, "[ F6  ] unroll")
+        self._win.addstr(1 + stats_h + 2, 0, "[ Esc ] cancel")
+        self._win.addstr(1 + stats_h + 3, 0, "[Enter] confirm")
+        self._win.noutrefresh()
+
+        self._stats_win.erase()
+        for y, stat in enumerate(PRIME_STATS):
+            self._stats_win.addstr(
+                y + 1, 1, f"{stat.value}: {self._stats[stat]}"
+            )
+        self._stats_win.box()
+        self._stats_win.noutrefresh()
+
+        curses.doupdate()

pqcli/ui/curses/views/menu_view.py

@@ -0,0 +1,38 @@
+import functools
+import typing as T
+
+from pqcli.ui.curses.event_handler import EventHandler
+from pqcli.ui.curses.util import Choice
+from pqcli.ui.curses.views.base_view import BaseView
+from pqcli.ui.curses.widgets import Menu
+
+
+class MenuView(BaseView):
+    def __init__(self, screen: T.Any, title: str) -> None:
+        super().__init__(screen)
+
+        self.on_cancel = EventHandler()
+        self.on_confirm = EventHandler()
+
+        self._title = f"{title}:"
+        self._choices: T.List[Choice] = []
+
+    def start(self) -> None:
+        scr_height, scr_width = self.screen.getmaxyx()
+        self.screen.erase()
+        self.screen.noutrefresh()
+
+        self.main_menu = Menu(
+            header=self._title,
+            choices=self._choices,
+            scr_height=scr_height,
+            scr_width=scr_width,
+        )
+        self.main_menu.render()
+
+    def stop(self) -> None:
+        self.main_menu.stop()
+
+    def keypress(self, key: int) -> None:
+        self.main_menu.keypress(key)
+        self.main_menu.render()