numba impl cleanup

Author: ReconGit

src_numba/core_numba/mcts.py

@@ -1,22 +1,25 @@
 from __future__ import annotations
-import random
+
 import math
+import random
+
 import numpy as np
 from numba import njit
-from typing import List, Tuple
+
 from .othello import (
-    make_move,
-    get_valid_moves,
     STATE_BLACK_TURN,
-    STATE_WHITE_TURN,
     STATE_BLACK_WON,
-    STATE_WHITE_WON,
     STATE_DRAW,
+    STATE_WHITE_TURN,
+    STATE_WHITE_WON,
+    get_valid_moves,
+    make_move,
 )
 
 
-def mcts_move(board: np.ndarray, black_score: int, white_score: int, state: int, iterations: int) -> Tuple[int, int]:
+def mcts_move(board: np.ndarray, black_score: int, white_score: int, state: int, iterations: int):
     """Returns the best move for the current turn using Monte Carlo Tree Search."""
+
     valid_moves = [tuple(move) for move in get_valid_moves(board, state)]  # Convert to list of tuples
     root = Node(None, (-1, -1), state, valid_moves)
 
@@ -68,12 +71,12 @@ def mcts_move(board: np.ndarray, black_score: int, white_score: int, state: int,
 class Node:
     """Node of the MCTS tree."""
 
-    def __init__(self, parent: Node | None, move: Tuple[int, int], turn: int, unexplored: List[Tuple[int, int]]):
+    def __init__(self, parent: Node | None, move: tuple[int, int], turn: int, unexplored: list[tuple[int, int]]):
         self.move = move
         self.turn = turn
         self.unexplored = unexplored
         self.parent = parent
-        self.children: List[Node] = []
+        self.children: list[Node] = []
         self.visits = 0
         self.wins = 0
 

src_numba/core_numba/minimax.py

@@ -34,6 +34,7 @@
 
 def minimax_move(board: np.ndarray, black_score: int, white_score: int, state: int, depth: int) -> Tuple[int, int]:
     """Use minimax to find a good move for the current player. Returns (x, y)."""
+
     moves = [tuple(move) for move in get_valid_moves(board, state)]  # Convert to list of tuples
     if not moves:
         return (-1, -1)
@@ -67,6 +68,7 @@ def _minimax(
     beta: float,
 ) -> Tuple[float, Tuple[int, int]]:
     """Minimax with alpha-beta pruning. Returns (value, (x, y))."""
+
     if depth == 0 or state not in (STATE_BLACK_TURN, STATE_WHITE_TURN):
         return _evaluate_board(board, black_score, white_score, state, my_turn), (-1, -1)
 
@@ -111,6 +113,7 @@ def _minimax(
 @njit
 def _evaluate_board(board: np.ndarray, black_score: int, white_score: int, state: int, my_turn: int) -> float:
     """Evaluate the board using the REWARDS matrix with Numba-compatible loops."""
+    
     if state == STATE_BLACK_WON:
         return np.float64(np.inf) if my_turn == STATE_BLACK_TURN else np.float64(-np.inf)
     if state == STATE_WHITE_WON:

src_numba/core_numba/othello.py

@@ -1,5 +1,5 @@
 import numpy as np
-from numba import jit, njit
+from numba import njit
 
 # Constants replacing Enums
 CELL_EMPTY = 0
@@ -14,7 +14,19 @@
 STATE_DRAW = 5
 
 # Directions for checking flipped cells
-DIRECTIONS = np.array([[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [-1, -1], [1, -1], [-1, 1]], dtype=np.int32)
+DIRECTIONS = np.array(
+    [
+        [1, 0],
+        [-1, 0],
+        [0, 1],
+        [0, -1],
+        [1, 1],
+        [-1, -1],
+        [1, -1],
+        [-1, 1],
+    ],
+    dtype=np.int32,
+)
 
 
 @njit
@@ -220,115 +232,3 @@ def flipped_cells_in_direction(
     if not (0 <= x < 8 and 0 <= y < 8) or board[y, x] != player:
         return flipped[:0]
     return flipped[:count]
-
-
-@njit
-def make_move_reversible(
-    board: np.ndarray,
-    black_score: np.int32,
-    white_score: np.int32,
-    state: np.int32,
-    move_x: int,
-    move_y: int,
-):
-    """Make a move and return flipped cells for undoing. Returns (board, black_score, white_score, state, flipped)."""
-
-    if state not in (STATE_BLACK_TURN, STATE_WHITE_TURN) or board[move_y, move_x] != 3:
-        return board, black_score, white_score, state, np.zeros((0, 2), dtype=np.int32)
-
-    player = CELL_BLACK if state == STATE_BLACK_TURN else CELL_WHITE
-    opponent = CELL_WHITE if state == STATE_BLACK_TURN else CELL_BLACK
-    board[move_y, move_x] = player
-
-    flipped = get_flipped_cells(board, move_x, move_y, player, opponent)
-    num_flipped = flipped.shape[0]
-    for x, y in flipped:
-        board[y, x] = player
-
-    # Update scores
-    if player == CELL_BLACK:
-        black_score += 1 + num_flipped
-        white_score -= num_flipped
-    else:
-        white_score += 1 + num_flipped
-        black_score -= num_flipped
-
-    board, black_score, white_score, new_state, _ = update_state(board, black_score, white_score, state)
-    return board, black_score, white_score, new_state, flipped
-
-
-@njit
-def undo_move(
-    board: np.ndarray,
-    move_x: int,
-    move_y: int,
-    flipped: np.ndarray,
-    original_state: np.int32,
-):
-    """Undo a move by restoring the board."""
-
-    player = CELL_BLACK if original_state == STATE_BLACK_TURN else CELL_WHITE
-    opponent = CELL_WHITE if original_state == STATE_BLACK_TURN else CELL_BLACK
-
-    # Restore flipped cells to opponent
-    for x, y in flipped:
-        board[y, x] = opponent
-
-    # Clear the move position
-    board[move_y, move_x] = 0  # Will be updated to VALID later if needed
-
-
-# Example usage (not Numba-compiled)
-def print_board(board: np.ndarray) -> None:
-    """Print the board for debugging."""
-
-    for row in board:
-        print(
-            " ".join(
-                ["." if c == CELL_EMPTY else "V" if c == CELL_VALID else "B" if c == CELL_BLACK else "W" for c in row]
-            )
-        )
-    print()
-
-
-def state_to_str(state: int) -> str:
-    """Convert state to string for printing."""
-
-    return {
-        STATE_BLACK_TURN: "Black's turn",
-        STATE_WHITE_TURN: "White's turn",
-        STATE_BLACK_WON: "Black won",
-        STATE_WHITE_WON: "White won",
-        STATE_DRAW: "Draw",
-    }.get(state, "Unknown")
-
-
-if __name__ == "__main__":
-    # Initialize game
-    board, black_score, white_score, state = init_game()
-    print("Initial board:")
-    print_board(board)
-
-    # Test a valid move
-    print("Making move (3, 2):")
-    board, black_score, white_score, state, success = make_move(board, black_score, white_score, state, 3, 2)
-    if success:
-        print("Move successful!")
-        print_board(board)
-        print(f"Black score: {black_score}, White score: {white_score}")
-        print(f"State: {state_to_str(state)}")
-
-        # Print valid moves
-        valid_moves = get_valid_moves(board, state)
-        print("Valid moves:", valid_moves.tolist())
-    else:
-        print("Move failed!")
-
-    # Test an invalid move
-    print("\nMaking invalid move (0, 0):")
-    board, black_score, white_score, state, success = make_move(board, black_score, white_score, state, 0, 0)
-    if success:
-        print("Move successful!")
-        print_board(board)
-    else:
-        print("Move failed!")