feat(#333); rework deck to use better choosebox

pyproject.toml

@@ -15,15 +15,28 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",
 ]
-dependencies = ["scrap_engine>=1.5.1"]
+dependencies = ["scrap_engine>=1.5.4"]
 
 [project.scripts]
 pokete = "pokete.__main__:main"
 pokete-util = "pokete.util.__main__:main"
 
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = ["tests*"]
+
 [tool.setuptools.package-data]
 "*" = ["*.mp3", "*.so", "*.dll"]
 
+[tool.basedpyright]
+reportMissingTypeStubs = false
+reportUnknownMemberType = false
+reportUnannotatedClassAttribute = false
+deprecateTypingAliases = false
+executionEnvironments = [
+    { root = "src" },
+]
+
 [project.urls]
 Homepage = "https://github.com/lxgr-linux/pokete"
 Issues = "https://github.com/lxgr-linux/pokete/issue"

src/pokete/__main__.py

@@ -35,13 +35,14 @@
 from pokete.base.tss import tss
 from pokete.base.ui.input import TextInput
 from pokete.base.ui.notify import notifier
-from pokete.classes import deck, roadmap, timer
 from pokete.classes import movemap as mvp
 from pokete.classes import ob_maps as obmp
+from pokete.classes import roadmap, timer
 from pokete.classes.achievements import achievements
 from pokete.classes.asset_service.service import asset_service
 from pokete.classes.audio import audio
 from pokete.classes.classes import PlayMap
+from pokete.classes.deck import Deck
 from pokete.classes.dex import PokeDex
 from pokete.classes.fight import ProtoFigure
 from pokete.classes.game import MapChangeException, ReturnToMenuException
@@ -60,7 +61,7 @@
     NotifierEvent,
     TreatNPCEvent,
 )
-from pokete.classes.poke import Poke, Stats
+from pokete.classes.poke.poke import Poke, Stats
 from pokete.classes.pokete_care import pokete_care
 from pokete.classes.pre_game import PreGameMap
 from pokete.classes.save import read_save, save
@@ -347,7 +348,7 @@ def _game(_map: PlayMap, figure: Figure):
     ctx = change_ctx(Context(pevm, mvp.movemap, mvp.movemap, figure), mvp.movemap)
     MapInteract.set_ctx(ctx)  # Npcs need this global context
     inp_dict: list[tuple[list[Action], tuple]] = [
-        ([Action.DECK], (deck.deck, (ctx, 6, "Your deck"))),
+        ([Action.DECK], (Deck(), (ctx, 6, "Your deck"))),
         ([Action.CANCEL, Action.EXIT_GAME], (quit, (ctx,))),
         ([Action.MAP], (roadmap.roadmap, (ctx,))),
         ([Action.INVENTORY], (inv, (ctx,))),

src/pokete/base/change.py

@@ -1,9 +1,13 @@
+from typing import TypeVar
+
 from pokete.base.context import Context
 from pokete.base.mouse import MouseInteractor, mouse_interaction_manager
 from pokete.base.ui.overview import Overview
 
+T = TypeVar("T")
+
 
-def change_ctx(ctx: Context, overview: Overview) -> Context:
+def change_ctx(ctx: Context[T], overview: Overview) -> Context[T]:
     ctx = ctx.with_overview(overview)
     if isinstance(overview, MouseInteractor):
         mouse_interaction_manager.attach([overview])

src/pokete/base/context.py

@@ -11,7 +11,7 @@
 class Context[T]:
     def __init__(
         self,
-        pevm: PeriodicEventManager,
+        pevm: PeriodicEventManager["Context[T]"],
         _map: CompatMap,
         overview: Overview,
         figure: T,
@@ -21,12 +21,12 @@ def __init__(
         self.overview = overview
         self.figure: T = figure
 
-    def with_pevm(self, pevm: PeriodicEventManager) -> "Context":
+    def with_pevm(self, pevm: PeriodicEventManager["Context[T]"]) -> "Context[T]":
         ctx = copy(self)
         ctx.pevm = pevm
         return ctx
 
-    def with_overview(self, overview: Overview) -> "Context":
+    def with_overview(self, overview: Overview) -> "Context[T]":
         ctx = copy(self)
         ctx.overview = overview
         return ctx

src/pokete/base/mouse/interactor.py

@@ -1,12 +1,14 @@
-from abc import ABC, abstractmethod
+from abc import abstractmethod
+from typing import Protocol, runtime_checkable
 
 import scrap_engine as se
 
 from pokete.base.context import Context
 from pokete.base.input.mouse import MouseEvent
 
 
-class MouseInteractor(ABC):
+@runtime_checkable
+class MouseInteractor(Protocol):
     def get_all_interaction_areas(
         self,
     ) -> list[se.Area]:

src/pokete/base/periodic_event_manager/periodic_event_manager.py

@@ -10,11 +10,11 @@
 class PeriodicEventManager(Generic[T]):
     """As the name states: It manages periodic events in the game loop"""
 
-    def __init__(self, events: list[PeriodicEvent[T]], tick=0):
+    def __init__(self, events: list[PeriodicEvent[T]], tick: int = 0):
         self.events: list[PeriodicEvent[T]] = events
         self.tick: int = tick
 
-    def with_events(self, events: list[PeriodicEvent[T]]) -> "PeriodicEventManager":
+    def with_events(self, events: list[PeriodicEvent[T]]) -> "PeriodicEventManager[T]":
         return PeriodicEventManager(self.events + events, self.tick)
 
     def event(self, ctx: T):

src/pokete/base/ui/elements/choose.py

@@ -136,21 +136,28 @@ class BetterChooseBox(Box):
         _map: The map it will be shown on"""
 
     def __init__(
-        self, columns, labels: list[se.Text], name="", _map=None, overview=None
+        self,
+        columns,
+        labels: list[se.HasArea],
+        name="",
+        _map=None,
+        overview=None,
+        max_rows: Optional[int] = None,
     ):
-        self.nest_label_obs: list[list[BetterChooserItem]] = []
-        self.set_items(columns, labels, init=True)
         super().__init__(
-            3 * len(self.nest_label_obs) + 2,
-            sum(i.width for i in self.nest_label_obs[0]) + 2,
+            3,
+            3,
             name,
             [CloseLabel()],
             overview=overview,
         )
+        self.nest_label_obs: list[list[BetterChooserItem]] = []
         self.columns = columns
+        self.max_rows: Optional[int] = max_rows
         self.map = _map
         self.__add_obs()
         self.index = (0, 0)
+        self.set_items(columns, labels)
         self.get_item(*self.index).choose()
 
     def set_index(self, _y, _x):
@@ -196,35 +203,44 @@ def input(self, input: ActionList):
             (self.index[1] + _c[1]) % len(self.nest_label_obs[self.index[0]]),
         )
 
-    def set_items(self, columns, labels: list[se.Text], init=False):
+    def set_items(self, columns, labels: list[se.HasArea]):
         """Sets the items shown in the box
         ARGS:
             columns: Number of columns
             labels: List of se.Texts that will be shown on the items
             init: Whether or not the box is initiated"""
+        self.columns = columns
         for i in self.nest_label_obs:
             for obj in i:
                 self.rem_ob(obj)
-        box_width = sorted(len(i.text) for i in labels)[-1]
+                obj.remove()
+        box_width = sorted(i.width for i in labels)[-1]
+        box_height = sorted(i.height for i in labels)[-1]
+
         label_obs = [
-            BetterChooserItem(3, box_width + 4, label, i)
+            BetterChooserItem(box_height + 2, box_width + 4, label, i)
             for i, label in enumerate(labels)
         ]
         self.nest_label_obs = [
             label_obs[i * columns : (i + 1) * columns]
             for i in range(max(round(len(labels) / columns + 0.49), 1))
         ]
-        if not init:
-            self.resize(
-                3 * len(self.nest_label_obs) + 2,
-                sum(i.width for i in self.nest_label_obs[0]) + 2,
-            )
-            self.__add_obs()
-            try:
-                self.set_index(*self.index)
-            except IndexError:
-                self.index = (0, 0)
-                self.get_item(*self.index).choose()
+
+        rows = min(
+            tr := len(self.nest_label_obs),
+            self.max_rows if self.max_rows is not None else tr,
+        )
+
+        self.resize(
+            (box_height + 2) * rows + 2,
+            sum(i.width for i in self.nest_label_obs[0]) + 2,
+        )
+        self.__add_obs()
+        try:
+            self.set_index(*self.index)
+        except IndexError:
+            self.index = (0, 0)
+            self.get_item(*self.index).choose()
 
     def __add_obs(self):
         """Adds items to the box"""

src/pokete/base/ui/notify.py

@@ -33,7 +33,7 @@ def corner_add(self, _map):
     def shift(self):
         """Shifts the box to the right"""
         self.x += 1
-        for i in get_nested(self):
+        for i in get_nested(self)[0]:
             if i.x == self.map.width - 1:
                 i.remove()
                 i.group.rem_ob(i)

src/pokete/base/ui/overview.py

@@ -1,7 +1,8 @@
-from abc import ABC, abstractmethod
+from abc import abstractmethod
+from typing import Protocol
 
 
-class Overview(ABC):
+class Overview(Protocol):
     @abstractmethod
     def resize_view(self):
         pass

src/pokete/base/ui/util.py

@@ -3,14 +3,20 @@
 import scrap_engine as se
 
 
-def get_nested(group: se.ObjectGroup):
+def get_nested(
+    group: se.ObjectGroup,
+) -> tuple[list[se.Object], list[tuple[int, int]]]:
     """RETURNS the raw objects an ObjectGroup contains
     ARGS:
         group: The given ObjectGroup"""
-    obs = []
+    obs: list[se.Object] = []
+    coords: list[tuple[int, int]] = []
     for obj in group.obs:
         if isinstance(obj, se.ObjectGroup):
-            obs += get_nested(obj)
+            ret_obs, ret_coords = get_nested(obj)
+            obs += ret_obs
+            coords += [(c[0] + obj.rx, c[1] + obj.ry) for c in ret_coords]
         else:
             obs.append(obj)
-    return obs
+            coords.append((obj.rx, obj.ry))
+    return obs, coords

src/pokete/base/ui/views/better_choose_box.py

@@ -1,3 +1,4 @@
+import math
 from abc import ABC, abstractmethod
 from typing import Generic, Optional, TypeVar, override
 
@@ -11,16 +12,32 @@
 from pokete.base.input.mouse import MouseEvent, MouseEventType
 from pokete.base.mouse import MouseInteractor
 from pokete.base.ui.elements.choose import BetterChooseBox
+from pokete.base.ui.views.pageable import Pageable, UpDownSwitch
 
 T = TypeVar("T")
 
 
-class BetterChooseBoxView(BetterChooseBox, MouseInteractor, Generic[T], ABC):
+class BetterChooseBoxView(BetterChooseBox, MouseInteractor, Generic[T], Pageable, ABC):
     def __init__(
-        self, columns, labels: list[se.Text], name="", _map=None, overview=None
+        self, columns, rows, labels: list[se.HasArea], name="", _map=None, overview=None
     ):
-        super().__init__(columns, labels, name, _map, overview)
+        self.elems: list[se.HasArea] = labels
+        self.rows = rows
+        self.page = 0
         self.__special_ret: Optional[T] = None
+        self.up_down_switch = UpDownSwitch(self)
+        super().__init__(
+            columns, self.elems[: rows * columns], name, _map, overview, max_rows=rows
+        )
+        self.__add_up_down_switch()
+
+    def __add_up_down_switch(self):
+        if len(self.elems) / self.columns > self.rows:
+            self.add_ob(
+                self.up_down_switch,
+                self.width - 3 - self.up_down_switch.width,
+                self.height - 1,
+            )
 
     @abstractmethod
     def choose(self, ctx: Context, idx: int) -> Optional[T]: ...
@@ -42,20 +59,69 @@ def interact(self, ctx: Context, area_idx: int, event: MouseEvent):
                     if event.pressed:
                         self.__special_ret = self.choose(ctx, area_idx)
                         ctx = change_ctx(ctx, self)
+        match event.type:
+            case MouseEventType.SCROLL_UP:
+                self.change_page(-1, 0)
+            case MouseEventType.SCROLL_DOWN:
+                self.change_page(1, 0)
 
     @override
     def get_partial_interactors(self) -> list[MouseInteractor]:
+        up_down: list[MouseInteractor] = [self.up_down_switch]
         return [
             label for label in self.info_labels if isinstance(label, MouseInteractor)
-        ]
+        ] + up_down
+
+    @override
+    def resize(self, height, width):
+        self.rem_ob(self.up_down_switch)
+        self.up_down_switch.remove()
+        super().resize(height, width)
+        self.__add_up_down_switch()
+
+    def set_elems(self, columns, rows, labels: list[se.HasArea]):
+        self.rows = rows
+        self.page = 0
+        self.elems = labels
+        super().set_items(columns, self.elems[: rows * columns])
+
+    def change_page(self, add_page, n_idx):
+        if (
+            0
+            <= (self.page + add_page)
+            < math.ceil(len(self.elems) / (self.rows * self.columns))
+        ):
+            self.page += add_page
+            super().set_items(
+                self.columns,
+                self.elems[
+                    (self.rows * self.columns) * self.page : (self.rows * self.columns)
+                    * (self.page + 1)
+                ],
+            )
 
     def __call__(self, ctx: Context) -> Optional[T]:
         self.set_ctx(ctx)
         ctx = change_ctx(ctx, self)
+        self.__add_up_down_switch()
+
         with self:
             while True:
                 action, _ = get_action()
                 if action.triggers(*ACTION_DIRECTIONS):
+                    if (
+                        action.triggers(Action.UP)
+                        and self.page > 0
+                        and self.index[0] == 0
+                    ):
+                        self.change_page(-1, 0)
+                    elif (
+                        action.triggers(Action.DOWN)
+                        and self.page
+                        < math.ceil(len(self.elems) / (self.rows * self.columns)) + 1
+                        and self.index[0] == self.rows - 1
+                    ):
+                        self.change_page(1, 0)
                     self.input(action)
                 else:
                     if action.triggers(Action.CANCEL):