refactor: miscellaneous API changes (non-breaking)

- include the types submodule, MinoType and MoveKind to __all__
- create MinoType enum; includes EMPTY, GARBAGE and GHOST minos
- allow BaseGame to be initialised with a seed, board (or board size), 
level and score
- add height and width properties to BaseGame
- update render to use the board height by default

Author: Sofia "dzshn" N. L

tetris/__init__.py

@@ -1,24 +1,30 @@
 from tetris import engine
+from tetris import types
 from tetris.engine import DefaultEngine
 from tetris.engine import Engine
 from tetris.game import BaseGame
+from tetris.types import MinoType
 from tetris.types import Move
 from tetris.types import MoveDelta
+from tetris.types import MoveKind
 from tetris.types import PartialMove
 from tetris.types import Piece
 from tetris.types import PieceType
 from tetris.types import PlayingStatus
 
 __version__ = "0.4.0"
 __all__ = (
-    "engine",
+    "BaseGame",
     "DefaultEngine",
+    "engine",
     "Engine",
-    "BaseGame",
+    "MinoType",
     "Move",
     "MoveDelta",
+    "MoveKind",
     "PartialMove",
     "Piece",
     "PieceType",
     "PlayingStatus",
+    "types",
 )

tetris/engine/scorer.py

@@ -7,14 +7,11 @@
 class GuidelineScorer(Scorer):
     def __init__(self):  # type: ignore[no-untyped-def]
         self.score = 0
+        self.level = 0
         self.line_clears = 0
         self.combo = 0
         self.back_to_back = 0
 
-    @property
-    def level(self) -> int:
-        return self.line_clears // 10 + 1
-
     def judge(self, delta: MoveDelta) -> None:
         if delta.kind == MoveKind.soft_drop:
             if not delta.auto:
@@ -95,6 +92,8 @@ def judge(self, delta: MoveDelta) -> None:
 
             self.score += score
             self.line_clears += line_clears
+            if line_clears and self.line_clears % 10 == 0:
+                self.level += 1
 
 
 class NoScorer(Scorer):

tetris/game.py

@@ -7,36 +7,57 @@
 
 from tetris.engine import DefaultEngine
 from tetris.engine import Engine
+from tetris.types import Board
+from tetris.types import MinoType
 from tetris.types import Move
 from tetris.types import MoveDelta
 from tetris.types import MoveKind
 from tetris.types import PartialMove
 from tetris.types import PieceType
 from tetris.types import PlayingStatus
+from tetris.types import Seed
 
 _default_tiles = {
-    0: " ",
-    PieceType.I: "I",
-    PieceType.J: "J",
-    PieceType.L: "L",
-    PieceType.O: "O",
-    PieceType.S: "S",
-    PieceType.T: "T",
-    PieceType.Z: "Z",
-    8: "@",
-    9: "X",
+    MinoType.EMPTY: " ",
+    MinoType.I: "I",
+    MinoType.J: "J",
+    MinoType.L: "L",
+    MinoType.O: "O",
+    MinoType.S: "S",
+    MinoType.T: "T",
+    MinoType.Z: "Z",
+    MinoType.GHOST: "@",
+    MinoType.GARBAGE: "X",
 }
 
 
 class BaseGame:
-    def __init__(self, engine: Engine = DefaultEngine):
+    def __init__(
+        self,
+        engine: Engine = DefaultEngine,
+        seed: Optional[Seed] = None,
+        board: Optional[Board] = None,
+        board_size: tuple[int, int] = (20, 10),
+        level: int = 0,
+        score: int = 0,
+    ):
         self.engine = engine
         self.seed = secrets.token_bytes()
-        self.board = np.zeros((40, 10), dtype=np.int8)
+        if board is None:
+            # Internally, we use 2x the height to "buffer" the board being pushed above the view
+            self.board = np.zeros((board_size[0] * 2, board_size[1]), dtype=np.int8)
+
+        else:
+            self.board = board
+
         self.gravity = engine.gravity(self)
         self.queue = engine.queue(seed=self.seed)
         self.rs = engine.rs(self.board)
+
         self.scorer = engine.scorer()
+        self.scorer.level = level
+        self.scorer.score = score
+
         self.piece = self.rs.spawn(self.queue.pop())
         self.status = PlayingStatus.playing
         self.delta: Optional[MoveDelta] = None
@@ -51,9 +72,17 @@ def score(self) -> int:
     def level(self) -> int:
         return self.scorer.level
 
+    @property
+    def height(self) -> int:
+        return self.board.shape[0] // 2
+
+    @property
+    def width(self) -> int:
+        return self.board.shape[1]
+
     def reset(self) -> None:
         self.seed = secrets.token_bytes()
-        self.board = np.zeros((40, 10), dtype=np.int8)
+        self.board[:] = 0
         self.gravity = self.engine.gravity(self)
         self.queue = self.engine.queue(seed=self.seed)
         self.rs = self.engine.rs(self.board)
@@ -101,7 +130,7 @@ def _lock_piece(self) -> None:
 
         # If all tiles are out of view (half of the internal size), it's a lock-out
         for x, y in piece.minos:
-            if self.piece.x + x > self.board.shape[0] / 2:
+            if self.piece.x + x > self.height:
                 break
 
         else:
@@ -121,7 +150,14 @@ def _lock_piece(self) -> None:
 
         self.hold_lock = False
 
-    def render(self, tiles: dict[int, str] = _default_tiles, lines: int = 20) -> str:
+    def render(
+        self,
+        tiles: dict[MinoType, str] = _default_tiles,
+        lines: Optional[int] = None,
+    ) -> str:
+        if lines is None:
+            lines = self.height
+
         board = self.board.copy()
         piece = self.piece
         ghost_x = piece.x

tetris/types.py

@@ -32,6 +32,19 @@ def __repr__(self) -> str:
         return f"{self.__class__.__name__}.{self.name}"
 
 
+class MinoType(enum.IntEnum):
+    EMPTY = 0
+    I = enum.auto()  # noqa
+    J = enum.auto()
+    L = enum.auto()
+    O = enum.auto()  # noqa
+    S = enum.auto()
+    T = enum.auto()
+    Z = enum.auto()
+    GHOST = enum.auto()
+    GARBAGE = enum.auto()
+
+
 @dataclasses.dataclass
 class Piece:
     __slots__ = ("type", "x", "y", "r", "minos")