Package-level declarations

An arena style tournament.

A container class representing the information about a chess opening based on the Encyclopedia of Chess Openings (ECO). It is immutable.

Calculates and updates player ratings based on the Elo rating system. This class uses a logistic distribution to predict the outcome of a match between two players and adjusts their ratings based on the difference between the actual and expected results.

Class for manipulating games. It allows starting a game from a configurable initial position and with various configuration options, such as the game type (match or analysis), and how to apply the three-fold repetition and 50-move rules.

Represents a single match or pairing within a tournament. This interface tracks the two participants (White and Black) and the final outcome of their game.

Represents a single player's move on the board. It does not store information about the origin position, as its primary purpose is move representation. Its string representation is the full algebraic notation of the move as used in the UCI protocol (e.g., "e2e4", "a7a8q"). It is immutable.

Exception thrown when inconsistencies occur in functionalities related to move validation or generation logic.

This enum represents the types of move notation supported by this library. This enum is used as an argument in functions related to move validation and generation logic.

Represents the final or current result of a tournament match. Each outcome defines the points awarded to both the white and black players, as well as a standard string representation used for display.

This class represents the chess pieces on the board. Each piece has a corresponding side (color).

Represents a participant in a tournament, tracking their score, opponents, and eligibility.

Class to represent a position on the chessboard. It is immutable.

Represents a standard competitive match between two Players. This class handles the automation of score accumulation, Elo rating updates, and opponent tracking once an outcome is reached.

Represents a score in a tournament. This class uses an internal integer value to represent scores in increments of 0.5. For example, a value of 1 represents a score of 0.5, and 2 represents 1.0.

This enum represents the two sides (colors) in a chess game: White or Black.

This enum represents the squares on the chessboard. The order is set such that when calling ordinal, the integer 0 corresponds to A1, 1 corresponds to B1, and so on, following the file-major order (A1, B1, C1... H1, A2, B2... H8), with 63 corresponding to H8.

A swiss style tournament.

Internal contract for defining tournament tie-breaking strategies. Implementing classes must define how to calculate a specific score for a player. The interface automatically handles the creation of a descending Comparator based on that score.

Contract for tournament management.

Auxiliary generic class to represent a pair of related, heterogeneous elements. It is immutable.

A list of tuples, where each tuple represents a legal move from this position and the resulting new position (Tuple). This list effectively defines the legal branches of the game tree from the current position.

True if the position is a forced draw. This is true if the position results in a stalemate or lackOfMaterial. False otherwise.

Returns a bitboard representing the occupancy of all enemy pieces.

The square exposed to an en passant capture, if one exists. Returns null if no en passant capture is possible in the current position.

Returns a bitboard representing the occupancy of all friendly pieces.

True if the game state is concluded (terminal position), either due to a forced draw or checkmate. False otherwise.

The side (Side.WHITE or Side.BLACK) whose turn it is to move.

Creates a new Game instance configured for analysis. Uses Game.GameMode.ANALYSIS with Game.ThreeRepetitionsMode.AWARE and Game.FiftyMovesRuleMode.AWARE, making the game fully mutable.

Determines if Black has insufficient material to win the game. Returns true if the current pieces for Black cannot potentially lead to a checkmate.

Creates a new Game instance with fully customizable parameters. Allows setting the game mode, rule enforcement, initial FEN, and PGN tags.

Deletes all moves that preceded the provided node in the main line. The node (and its position) becomes the new effective start of the game, creating a new RootNode.

Deletes all moves (the main line continuation and any variations) that follow the provided node. The node provided remains in the game.

Deletes the provided node and all subsequent moves/variations in its subtree. The move represented by the node is effectively removed from the game.

Creates a new Position identical to the current one, but with the active side toggled.

Returns true if the evaluated Move is legal in the current position, and false otherwise.

Returns true if the move specified in the given notation is legal in the current position. If no notation is specified, Notation.UCI is assumed.

Retrieves the new Position that results from executing the provided legal Move. Throws a MoveException if the provided move is not legal in the current position.

Retrieves the new Position that results from executing the move specified in the given notation. Throws a MoveException if the move is not legal. If no notation is provided, Notation.UCI is assumed.

Creates a Move object from its UCI notation string (e.g., "e7e8q").

Creates a Move object from the origin square and target square Square enum constants.

Creates a Move object from the specified origin and target squares (using Int as the squares types).

Creates a Move object from the origin square, target square, and the promotion piece, using Square and Piece enum constants.

Creates a Move object from the specified origin and target squares (using Int as the squares types) and the promotion piece.

Parses a string containing one or more games in Portable Game Notation (PGN) format. Games are returned in Game.GameMode.ANALYSIS mode, making them mutable for subsequent use.

Returns the standard starting Position (the startpos FEN).

Factory function to create a Position object from a FEN string. Throws an exception if the FEN string is invalid or leads to an illegal position.

Parses a string representation of a score into a Score. The input must be a string ending in either ".0" (for whole points) or ".5" (for half points).

Creates a new Game instance configured for strict competitive match play. Uses Game.GameMode.MATCH with strict enforcement for the three-fold repetition and 50-move rules.

Factory function that creates a composite Comparator for Players based on a prioritized list of tie-breaker criteria. The function chains the comparators in the order provided. If the first tie-breaker results in a tie, it moves to the second, and so on.

Factory function that maps a string identifier to a concrete Tiebreaker strategy.

Factory function to create a Tournament instance based on the specified type.

Removes the last node in the main line, effectively undoing the last move, and returns the parent node. This function only operates on the primary variation (main line).

Calculates a bitboard of all squares "visible" or attacked by a specific piece from a given square.

Determines if White has insufficient material to win the game. Returns true if the current pieces for White cannot potentially lead to a checkmate.