| """Pure, deterministic vertical-placement falling-block game rules.""" |
|
|
| from dataclasses import replace |
|
|
| from stackcraft.pieces import piece_at, rotations |
| from stackcraft.schema import COLORS, HEIGHT, WIDTH, Board, Cells, GameState, Placement, Transition |
|
|
| _SCORES = (0, 100, 300, 500, 800) |
|
|
|
|
| def new_game(seed: int) -> GameState: |
| return GameState( |
| board=tuple((0,) * WIDTH for _ in range(HEIGHT)), |
| seed=seed, |
| piece_index=0, |
| current=piece_at(seed, 0), |
| next_piece=piece_at(seed, 1), |
| ) |
|
|
|
|
| def _fits(state: GameState, cells: Cells, x: int, y: int) -> bool: |
| return all( |
| 0 <= x + dx < WIDTH and 0 <= y + dy < HEIGHT and state.board[y + dy][x + dx] == 0 |
| for dx, dy in cells |
| ) |
|
|
|
|
| def legal_actions(state: GameState) -> tuple[Placement, ...]: |
| """Enumerate rotation then column; each move starts fully inside row zero.""" |
| if state.terminal: |
| return () |
| result = [] |
| for rotation, cells in enumerate(rotations(state.current)): |
| width = max(x for x, _ in cells) + 1 |
| for x in range(WIDTH - width + 1): |
| if not _fits(state, cells, x, 0): |
| continue |
| y = 0 |
| while _fits(state, cells, x, y + 1): |
| y += 1 |
| absolute = tuple((x + dx, y + dy) for dx, dy in cells) |
| result.append(Placement(f"r{rotation}x{x}", rotation, x, y, absolute)) |
| return tuple(result) |
|
|
|
|
| def place(board: Board, piece: str, action: Placement) -> tuple[Board, int]: |
| """Place a previously validated action without reading any future pieces. |
| |
| Callers must supply an action from legal_actions for this board and piece. |
| This low-level helper checks occupied/boundary cells but not hard-drop paths; |
| user-controlled IDs must go through step instead. |
| """ |
| if piece not in COLORS: |
| raise ValueError(f"unknown piece: {piece!r}") |
| if len(set(action.cells)) != 4 or any( |
| not (0 <= x < WIDTH and 0 <= y < HEIGHT) or board[y][x] for x, y in action.cells |
| ): |
| raise ValueError("placement cells must be four distinct empty in-bounds cells") |
| rows = [list(row) for row in board] |
| for x, y in action.cells: |
| rows[y][x] = COLORS[piece] |
| remaining = [tuple(row) for row in rows if not all(row)] |
| cleared = HEIGHT - len(remaining) |
| if cleared > 4: |
| raise ValueError("invalid starting board: more than four completed rows") |
| return tuple([(0,) * WIDTH] * cleared + remaining), cleared |
|
|
|
|
| def step(state: GameState, action_id: str) -> Transition: |
| """Validate, place, clear simultaneously, advance, and detect next top-out.""" |
| action = next((move for move in legal_actions(state) if move.id == action_id), None) |
| if action is None: |
| raise ValueError(f"illegal action {action_id!r}") |
| board, cleared = place(state.board, state.current, action) |
| next_state = GameState( |
| board=board, |
| seed=state.seed, |
| piece_index=state.piece_index + 1, |
| current=state.next_piece, |
| next_piece=piece_at(state.seed, state.piece_index + 2), |
| score=state.score + _SCORES[cleared], |
| lines=state.lines + cleared, |
| ) |
| if not legal_actions(next_state): |
| next_state = replace(next_state, terminal=True) |
| return Transition(next_state, action, cleared) |
|
|
