core/io.github.lunalobos.chess4kt.js

Package-level declarations

Types

This class represents a bitboard.

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

class Game

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.

class Move

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.

class Node

Each game can be interpreted as a series of interconnected nodes in a tree. Each node is move in the game and holds information about the board state after that move. Additionally, each node can have regular or end-of-line comments, suffix annotations, as well as more than one child (from the second child onwards, they are variations), and always only one parent node.

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

class Piece

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

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

class Side

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

class Square

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.

class Tuple

Auxiliary generic class to represent a pair of position and associated move. It is immutable.

Properties

Black Bishop

Black King

val BLACK: Side

Black Player

Black Knight

Black Pawn

Black Queen

Black Rook

val EMPTY: Piece

Represents an empty square on the board.

val SAN: Notation

The Standard Algebraic Notation (SAN) used in books and PGN files (e.g., Nf3, O-O, cxd4).

val UCI: Notation

The long algebraic notation used in the Universal Chess Interface (UCI) protocol (e.g., e2e4, a7a8q).

White Bishop

val WHITE: Side

White Player

White King

White Knight

White Pawn

White Queen

White Rook

Functions

fun analysisGame(idSupplier: () -> Any? = { null }): Game

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

fun customGame(gameMode: String, threeRepetitionsMode: String, fiftyMovesRuleMode: String, initialFen: String? = null, idSupplier: () -> Any? = { null }): Game

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

fun moveOf(move: String): Move

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

fun parseGames(pgnInput: String, idSupplier: () -> Any? = { null }): JsReadonlyArray<Game>

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

fun positionOf(fen: String): Position

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.

fun startPos(): Position

Returns the standard starting Position (the startpos FEN).

fun strictMatch(idSupplier: () -> Any? = { null }): Game

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