Core game (src/core/)

Result sentinel: game is still in progress (not yet finished).

ZOBRIST_TABLE

128-entry table of random UInt64 values indexed by [row, col, color_idx] (color_idx 1 = BLACK, 2 = WHITE) used for incremental Zobrist hashing.

Position

Represents a position on the Reversi board (row, col). Supports construction from standard Reversi notation (e.g. "e4").

Position(s::AbstractString) -> Position

Parse a standard Reversi notation string (e.g. "e4") into a Position. Column letters a–h map to columns 1–8; row digits 1–8 map to rows 1–8.

Examples

Position("e4")  # Position(4, 5)
Position("a1")  # Position(1, 1)

ReversiGame

Represents the state of a Reversi game using two UInt64 bitboards.

Fields:

• black::UInt64 – bitmask of squares occupied by Black
• white::UInt64 – bitmask of squares occupied by White
• current_player::Int – BLACK or WHITE
• pass_count::Int – consecutive passes (≥ 2 → game over)
• hash::UInt64 – incremental Zobrist hash of the current position

copy(game::ReversiGame) -> ReversiGame

Fast field-by-field copy of a ReversiGame. Prefer this over deepcopy since all fields are value types (integers).

compute_full_hash(game::ReversiGame) -> UInt64

Compute the Zobrist hash of game from scratch. Useful for debugging.

position_to_string(pos::Position) -> String

Convert a Position to standard Reversi notation (e.g. Position(4, 5) → "e4").

update_hash(current_hash, row, col, color) -> UInt64

Toggle one piece of color at (row, col) in the hash (add or remove).

board_to_matrix(game::ReversiGame; flip_for_current=true) -> Array{Float32, 2}

Encode the 8x8 board as a matrix of Float32. If flip_for_current=true, the current_player's pieces are 1.0f0 and the opponent's are -1.0f0. Empty squares are 0.0f0.

compute_flips(pos, player, opponent) -> UInt64

Return a bitmask of opponent pieces that would be flipped when player places at the single-bit position pos.

count_pieces(game) -> (Int, Int)

Return (black_count, white_count).

get_piece(game, row, col) -> Int

Return BLACK, WHITE, or EMPTY for the given square.

get_winner(game) -> Int

Return BLACK, WHITE, or EMPTY (draw) based on piece counts.

is_game_over(game) -> Bool

Return true when the game has ended (two consecutive passes, board full, or neither player has any legal move).

is_valid_move(game, row, col[, player]) -> Bool

Check if placing a piece at (row, col) is legal for player.

is_valid_position(row::Int, col::Int) -> Bool

Check if a position is within the board boundaries.

legal_moves_bb(player, opponent) -> UInt64

Return a bitmask of all squares where player can legally place a piece (Kogge-Stone Dumb7Fill in each of the 8 directions).

make_move!(game, s) -> Bool

Make a move specified in standard Reversi notation (e.g. "e4").

make_move!(game, row, col) -> Bool

Place a piece at (row, col) for the current player. Updates the board and the Zobrist hash. Returns true on success, false if the move is illegal.

make_move!(game, pos) -> Bool

Make a move at the given Position.

mobility(game[, player]) -> Int

Return the number of legal moves available to player (defaults to game.current_player). A commonly used feature in evaluation.

next_state(game, move) -> ReversiGame

Return a new ReversiGame resulting from applying move to a copy of game. The original game is not modified.

opponent(player::Int) -> Int

Returns the opponent's color.

pass!(game; force=false)

Pass the turn to the opponent.

If force=false (default), throws ArgumentError when the current player still has at least one legal move — callers must only pass when genuinely stuck. Set force=true to skip the check (useful for replaying external records or tests).

valid_moves(game[, player]) -> Vector{Position}

Return all valid moves for player (defaults to game.current_player).

GreedyPlayer <: Player

A player that always picks the move that flips the most pieces.

HumanPlayer <: Player

A human player that can receive moves from any interface (GUI, terminal, etc.) via its internal move_channel.

Use get_move(player, game) to wait for the next move.

Player

Abstract type for all player implementations. Subtype and implement get_move(player, game) to create a new player.

RandomPlayer <: Player

A player that picks a random valid move each turn.

get_move(player::Player, game::ReversiGame) -> Union{Position, Nothing}

Get the next move from a player. Returns nothing to indicate a pass.

get_terminal_input(game::ReversiGame; hints=true) -> Union{Position, Nothing}

A helper for CLI frontends to get move input from the terminal using readline. Can be used to put! a move into a HumanPlayer's channel.

CornerPlayer <: Player

Picks any available corner move first, then falls back to HeuristicPlayer's positional weights.

HeuristicPlayer <: Player

A player that picks the move with the highest positional weight. Corners are strongly preferred; corner-adjacent squares are penalised.

MCTSPlayer(iterations::Int=200, c::Float64=1.414) <: Player

Monte Carlo Tree Search with UCB1 selection and random rollouts. iterations controls the number of simulations per move.

MinimaxPlayer(depth::Int=3) <: Player

Alpha-beta search using a piece-count difference evaluation. depth controls the search depth in plies.

MobilityPlayer <: Player

Picks the move that leaves the opponent with the fewest legal replies while keeping its own mobility high.