react-chessboard-ui 0.1.1

package/dist/JSChessEngine/JSChessEngine.d.ts

@@ -0,0 +1,383 @@
+export declare type FigureType = 'pawn' | 'bishop' | 'knigts' | 'rook' | 'queen' | 'king';
+export declare type FigureColor = 'white' | 'black';
+export declare type CellPos = [number, number];
+export interface Figure {
+    type: FigureType;
+    color: FigureColor;
+    touched?: boolean;
+    position?: CellPos;
+}
+export declare type CellColor = 'white' | 'black';
+export interface Cell {
+    figure?: Figure;
+    beated?: boolean;
+}
+export interface ChessBoardConfig {
+    cellWhiteBg: string;
+    cellBlackBg: string;
+    cellSelectedBg: string;
+    cellSize: number;
+    figures: {
+        black: {
+            [figureType: string]: string;
+        };
+        white: {
+            [figureType: string]: string;
+        };
+    };
+}
+export interface MoveNotation {
+    move: string;
+    figure: Figure;
+    stateFEN: string;
+}
+export declare type MoveDirection = 'top' | 'right' | 'bottom' | 'left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'top-left';
+export declare type MoveType = 'move' | 'beat' | 'check' | 'double-check' | 'mat' | 'transform' | '0-0' | '0-0-0';
+export declare type GameResultType = 'mat' | 'pat' | 'draw' | 'timeout' | 'surrender' | undefined;
+export interface GameResult {
+    resultType: GameResultType;
+    winColor?: FigureColor;
+}
+export declare type PawnMoveType = 'first' | 'default' | 'attack';
+export interface MoveByPawn {
+    pos: CellPos;
+    typeMove: PawnMoveType;
+}
+export interface MoveData {
+    from: CellPos;
+    to: CellPos;
+    figure: Figure;
+    type?: MoveType;
+    FEN?: string;
+    timeWhite?: number;
+    timeBlack?: number;
+}
+export interface BeatedCountsData {
+    pawn: number;
+    knigts: number;
+    bishop: number;
+    rook: number;
+    queen: number;
+}
+export declare type CastlingType = '0-0' | '0-0-0';
+export declare type OnCheckPossible = (state: Cell[][], figurePos: CellPos, targetPos: CellPos) => boolean;
+declare const FIGURES_COUNTS: {
+    PAWNS_COUNT: number;
+    KNIGHTS_COUNT: number;
+    BISHOPS_COUNT: number;
+    ROOKS_COUNT: number;
+    QUEENS_COUNT: number;
+    KINGS_COUNT: number;
+};
+export declare class JSChessEngine {
+    /**
+     * Возвращает возможные ходы фигуры
+     * @param state состояние доски
+     * @param param1 позиция фигуры, которой хотим сыграть
+     * @param linesWithCheck линии по которым есть шах на союзного короля
+     * @param revese перевернута ли доска
+     */
+    static getNextMoves: (state: Cell[][], [i, j]: CellPos, linesWithCheck: CellPos[][], revese?: boolean) => CellPos[];
+    /**
+     * Возвращает первернутое состояние доски
+     * @param state состояние доски
+     */
+    static reverseChessBoard: (state: Cell[][]) => Cell[][];
+    /**
+     * Обновляет данные хода для того чтобы
+     * можно было применить ход к перевернутой доске
+     * @param moveData данные хода
+     * @param boardSize размер доски
+     */
+    static reverseMove: (moveData: MoveData, boardSize: number) => MoveData;
+    /**
+     * Возвращет перевернутое значение для начала и конца хода фигуры
+     * Использовать при подсветке хода если доска перевернута
+     * @param moveVector Координаты начала и конца хода фигуры
+     * @param boardSize размер доски
+     */
+    static reverseMoveVector: (moveVector: CellPos[], boardSize?: number) => number[][];
+    /**
+     * Проверка на то что позиция находится в пределах доски
+     * @param state состояние доски
+     * @param pos проверяемая позиция
+     */
+    static checkInBorderBoard: (state: Cell[][], pos: CellPos) => boolean;
+    /**
+     * Возвращает цвет фигуры
+     * @param state состояние доски
+     * @param pos позиция фигуры
+     */
+    static getFigureColor: (state: Cell[][], pos: CellPos) => FigureColor;
+    /**
+     * Возвращает тип фигры
+     * @param state состояние доски
+     * @param pos позиция фигуры
+     */
+    static getFigureType: (state: Cell[][], pos: CellPos) => FigureType;
+    /**
+     * Проверка находится ли в указанной клетке вражеская фигура
+     * @param state состояние доски
+     * @param pos положение фигуры союзного цвета
+     * @param target положение фигуры - цели
+     */
+    static checkEnemy: (state: Cell[][], pos: CellPos, target: CellPos) => boolean;
+    /**
+     * Проверка находится ли в указанной клетке союзная фигура
+     * @param state состояние доски
+     * @param pos положение фигуры союзного цвета
+     * @param target положение фигуры - цели
+     */
+    static checkTeammate: (state: Cell[][], pos: CellPos, target: CellPos) => boolean;
+    /**
+     * Проверка на то что фигура-цель вражеский король
+     * @param state состояние доски
+     * @param pos положение фигуры союзного цвета
+     * @param target положение фигуры - цели
+     */
+    static checkEnemyKing: (state: Cell[][], pos: CellPos, target: CellPos) => boolean;
+    /**
+     * Проверяет битая ли клетка, клетка становится битой после того
+     * как пешка сделает ход на две клетки веперед
+     * @param state состояние доски
+     * @param target позиция проверяемой клетки
+     */
+    static checkBeatedCell: (state: Cell[][], target: CellPos) => boolean;
+    /**
+     * Возвращает есть ли фигура в указаной позиции
+     * @param state состояние доски
+     * @param pos проверяемая позиция
+     * @returns
+     */
+    static hasFigure: (state: Cell[][], pos: CellPos) => boolean;
+    /**
+     * Проверяет дальнобойная ли фигура
+     * слон, ладья или ферзь
+     * @param state состояние доски
+     * @param figurePos позиция фигуры
+     */
+    static checkFigureIsLongRange: (state: Cell[][], figurePos: CellPos) => boolean;
+    /**
+     * Возвращает количество вражеских которые можно атаковать (кроме короля) фигур из массива позиций
+     * @param state состояние доски
+     * @param figurePos позиция фигуры
+     * @param positions проверяемые позиции
+     */
+    static getCountEnemys: (state: Cell[][], figurePos: CellPos, positions: CellPos[]) => number;
+    /**
+     * Возвращает позицию союзного короля
+     * @param state состояние доски
+     * @param figurePos позиция фигуры
+     */
+    static getTeammateKingPos: (state: Cell[][], figurePos: CellPos) => CellPos;
+    /**
+     * Возвращает все клетки с вражескими фигурами
+     * @param state состояние доски
+     * @param pos позиция союзной фигуры
+     */
+    static getAllEnemysPositions: (state: Cell[][], pos: CellPos) => CellPos[];
+    /**
+     * Возвращает позиции фигур-союзников по цвету
+     * @param state состояние доски
+     * @param color цвет по которому ищем фигуры-союзники
+     */
+    static getAllTeammatesPositionsByColor: (state: Cell[][], color: FigureColor) => CellPos[];
+    /**
+     * Полная проверка возможности хода для фигур: pawn, knigt, bishop, rook, queen
+     * @param state состояния доски
+     * @param pos положение фигуры союзного цвета
+     * @param target позиция клетки - цели
+     * @returns
+     */
+    static checkPossibleMoveTo: (state: Cell[][], pos: CellPos, target: CellPos) => boolean;
+    /**
+     * Прооверяет возможность атаки клетки
+     * Если в клетке вражеская фигура, считает ее атакованной
+     * Необходима для проверки нахождения вражеского короля за атакованной фигурой
+     * @param state состояние доски
+     * @param figurePos позиция фигураы
+     * @param target клетака под атакой
+     */
+    static checkPossibleAttackTo: (state: Cell[][], figurePos: CellPos, target: CellPos) => boolean;
+    /**
+     * Проверка находится ли поле под атакой вражеской фигуры
+     * (Используется для расчета возможных ходов для короля)
+     * @param state состояние доски
+     * @param pos позиция фигуры
+     * @param target проверяемая клетка
+     */
+    static checkAttackedCell: (state: Cell[][], pos: CellPos, target: CellPos) => boolean;
+    /**
+     * Проверяет атакованные поля вражеской пешкой
+     * (используется для получения возможных ходово для короля)
+     * @param state состояние доски
+     * @param pos текущая позиция пешки
+     * @param target клетка - цель
+     */
+    static checkAttackedCellByPawn: (state: Cell[][], pos: CellPos, target: MoveByPawn) => boolean;
+    /**
+     * Проверяет находится ли позиция между атакованным королем
+     * и атакующей фигурой
+     * @param state состояние доски
+     * @param pos проверяемая позиция
+     * @param kingPos позиция союзного короля
+     * @param attackerPos позиция атакующей фигуры
+     */
+    static checkPosBetweenAttckerAndKing: (state: Cell[][], pos: CellPos, kingPos: CellPos, attackerPos: CellPos) => boolean;
+    /**
+     * Корректирует возможные ходы фигуры в зависимости от того находится ли
+     * фигура под атакой и стоит ли на линии атаки король за фигурой
+     * @param state состояние доски
+     * @param figurePos позиция фигуры
+     * @param possibleMoves возможные ходы фигуры
+     * @param linesWithCheck массив линий по которым есть шах на союзного короля
+     */
+    static correctionPossibleMoves: (state: Cell[][], figurePos: CellPos, possibleMoves: CellPos[], linesWithCheck: CellPos[][]) => CellPos[];
+    /**
+     * Возвращает всю атакованную линию дальнобойной фигурой
+     * @param state состояние доски
+     * @param figurePos позиция фигуры
+     * @param direction направление атаки
+     */
+    static getFullAttackedLine: (state: Cell[][], figurePos: CellPos, direction: MoveDirection) => CellPos[];
+    /**
+     * Возвращает все атакованные врагом позиции
+     * используется для проверки ходов короля
+     * @param state состояние доски
+     * @param figurePos позиция фигуры
+     * @param reverse перевернута ли доска
+     */
+    static getAllAttckedPostionsByEnemys: (state: Cell[][], figurePos: CellPos, reverse: boolean) => CellPos[];
+    /**
+     * Возвращает возможные позиция для движения по диагонали
+     * для Слона и Ферзя
+     * @param state состояние доски
+     * @param figurePos текущая позиция фигуры
+     */
+    static calcDiagonalMoves: (state: Cell[][], figurePos: CellPos, onCheckPossible?: OnCheckPossible, onCheckFigureInCell?: OnCheckPossible) => CellPos[];
+    /**
+     * Возвращает возможные позиция для движения по горизонтали и вертикали
+     * для Ладьи и Ферзя
+     * @param state состяние доски
+     * @param figurePos
+     * @returns
+     */
+    static calcHorizontalAndVerticalMoves: (state: Cell[][], figurePos: CellPos, onCheckPossible?: OnCheckPossible, onCheckFigureInCell?: OnCheckPossible) => CellPos[];
+    /**
+     * Возвращает возможные ходы для коня
+     * @param state состояние доски
+     * @param figurePos текущая позиция фигуры
+     * @returns
+     */
+    static calcKnigtsMoves: (state: Cell[][], figurePos: CellPos, onCheckPossible?: OnCheckPossible) => CellPos[];
+    /**
+     * Проверяет возможность пешки пойти на клетку - цель
+     * @param state состояние доски
+     * @param pos текущая позиция пешки
+     * @param target клетка - цель
+     * @param pawnColor цвет пешки вычисленный заранее
+     * @param reverse перевернута ли доска
+     */
+    static checkPossiblePawnMoveToPos: (state: Cell[][], pos: CellPos, target: MoveByPawn, pawnColor: FigureColor, reverse: boolean) => boolean;
+    /**
+     * Возвращает возможные позиции для пешки
+     * @param state состояние доски
+     * @param figurePos текущее положение пешки
+     * @param revese перевернута ли доска
+     * @returns
+     */
+    static calcPawnMoves: (state: Cell[][], figurePos: CellPos, revese: boolean, onCheckPossible?: typeof JSChessEngine.checkPossiblePawnMoveToPos | typeof JSChessEngine.checkAttackedCellByPawn) => CellPos[];
+    /**
+     * Проверяет возможна ли рокеровка
+     * @param state состояние доски
+     * @param kingPos позиция короля
+     * @param reverse перевенута ли доска
+     */
+    static checkPossibleCastling: (state: Cell[][], kingPos: CellPos, castlingPath: CellPos[], reverse: boolean) => boolean;
+    /**
+     * Возвращает возможные ходы для короля
+     * @param state состояние доски
+     * @param figurePos позиция короля
+     * @returns
+     */
+    static calcKingMoves: (state: Cell[][], figurePos: CellPos, reverse: boolean, onlyAttacks?: boolean) => CellPos[];
+    static getNextMovesPawn: (state: Cell[][], figurePos: CellPos, reverse: boolean) => CellPos[];
+    static getNextMovesBishop: (state: Cell[][], figurePos: CellPos) => CellPos[];
+    static getNextMovesKnigts: (state: Cell[][], figurePos: CellPos) => CellPos[];
+    static getNextMovesRook: (state: Cell[][], figurePos: CellPos) => CellPos[];
+    static getNextMovesQueen: (state: Cell[][], figurePos: CellPos) => CellPos[];
+    static getNextMovesKing: (state: Cell[][], figurePos: CellPos, reverse: boolean) => CellPos[];
+    /**
+     * Возвращает линии по которым есть шах вражескому королю
+     * @param state состояние доски
+     * @param activeColor цвет фигур, которые сделали ход
+     */
+    static getLinesWithCheck: (state: Cell[][], activeColor: FigureColor, reverse?: boolean) => CellPos[][];
+    /**
+     * Принимает данные о фигуре, которой сыграли
+     * затем обновляет и возвращает новое состояние доски
+     * !!! Какой-то старнный эффект если не использовать мап
+     * !!! Как будто происходит мутация состояния
+     * @param state состояние доски
+     * @param currentFigure фигура, которой сыграли
+     * @param targetPos позиция на которую перемещаем фигуру
+     * @param prevPos начальная позиция фигуры
+     * @param reverse перевернута ли доска
+     */
+    static changeState: (state: Cell[][], currentFigure: Figure, targetPos: CellPos, prevPos: CellPos, reverse: boolean) => {
+        updatedCells: Cell[][];
+        attackedPos?: CellPos;
+    };
+    /**
+     * Обновляет состояние с превращение пешки в фигуру
+     * @param state состояние доски
+     * @param fromPos с какой клетки сделан ход
+     * @param targetPos на какую клетку сделали ход
+     * @param transformFigure в какую фигуру превратить пешку
+     */
+    static transformPawnToFigure: (state: Cell[][], fromPos: CellPos, targetPos: CellPos, transformFigure: Figure) => Cell[][];
+    /**
+     * Возвращает плоский массив полей с фигурами
+     * @param state состояние доски
+     */
+    static getFieldsWithFigures: (state: Cell[][]) => Cell[];
+    /**
+     * Возвращает результат игры
+     * mat - Мат
+     * pat - Пат
+     * undefined - игра продолжается
+     * @param state состояние доски
+     * @param linesWithCheck линии по которым есть шахом
+     * @param activeColor активный цвет
+     */
+    static getGameResult: (state: Cell[][], linesWithCheck: CellPos[][], activeColor: FigureColor, reverse: boolean) => GameResult | undefined;
+    /**
+     * Возвращает количество фигур указанного типа
+     * @param flatState Обработанное состояние - одномерный массив клеток с фигурами одного цвета
+     * @param figureType тип фигуры
+     */
+    static getFiguresCountByType: (flatState: Cell[], figureType: FigureType) => number;
+    /**
+     * Возвращает информацию о количестве съеденных фигур одного цвета
+     * @param state состояние доски
+     * @param color цвет съеденных фигур
+     */
+    static getBeatedFigures: (state: Cell[][], color: FigureColor, countsConfig?: typeof FIGURES_COUNTS) => BeatedCountsData;
+    /**
+     * По последним шести позициям - трем ходам
+     * определяет было ли повторение позиций
+     * если да, то это ничья,
+     * Определить троекратное повторение
+     * можно по последним 8ми ходам
+     * поэтому нужно брать на сравнение массив
+     * length - 8
+     * @param fenMoves история ходов в формате FEN
+     */
+    static detectDrawByRepeatMoves(fenMoves: string[]): boolean;
+    /**
+     * Проверяет является ли ход рокеровкой
+     * @param move данные хода
+     */
+    static getCastlingType(move: MoveData): CastlingType | undefined;
+}
+export {};

package/dist/JSChessEngine/__tests__/FEN.utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/JSChessEngine/__tests__/chessState.mock.d.ts

@@ -0,0 +1,3 @@
+import { Cell } from "../JSChessEngine";
+export declare const INITIAL_CELLS: Cell[][];
+export declare const STATE_CELLS_WITHOUT_LONG_CASTLINGS: Cell[][];

package/dist/JSChessEngine/chess.consts.d.ts

@@ -0,0 +1,49 @@
+import { Cell, Figure } from './JSChessEngine';
+export declare const LETTERS: string[];
+export declare const FIGURES_LATTERS_NOTATIONS: {
+    white: {
+        pawn: string;
+        knigts: string;
+        bishop: string;
+        rook: string;
+        queen: string;
+        king: string;
+    };
+    black: {
+        pawn: string;
+        knigts: string;
+        bishop: string;
+        rook: string;
+        queen: string;
+        king: string;
+    };
+};
+export declare const LETTER_TO_FIGURE_MAP: {
+    [key: string]: Figure;
+};
+export declare const ALL_FIGURES: Figure[];
+export declare const CHESS_BOARD_CONFIG: {
+    cellWhiteBg: string;
+    cellBlackBg: string;
+    cellSelectedBg: string;
+    cellSize: number;
+    figures: {
+        white: {
+            pawn: string;
+            bishop: string;
+            knigts: string;
+            rook: string;
+            queen: string;
+            king: string;
+        };
+        black: {
+            pawn: string;
+            bishop: string;
+            knigts: string;
+            rook: string;
+            queen: string;
+            king: string;
+        };
+    };
+};
+export declare const INITIAL_CELLS: Cell[][];

package/dist/JSChessEngine/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JSChessEngine';
+export * from './FEN.utils';
+export * from './chess.consts';

package/dist/index.css

@@ -0,0 +1,132 @@
+._3XI6H {
+    position: relative;
+    width: -moz-fit-content;
+    width: fit-content;
+}
+
+._2SyRK {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    z-index: 1;
+}
+
+._3OVc8 {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    z-index: 10;
+    cursor: pointer;
+}
+
+._G0IIl {
+    cursor: grabbing;
+}
+
+._3THn5 {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    z-index: 5;
+}
+
+._3vcXe {
+    box-sizing: border-box;
+}
+
+._2yJs1 {}
+
+._27yHq {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+
+._UYGA_ {
+    border-radius: 100%;
+    opacity: 0.8;
+}
+
+._2XKSc {
+    display: flex;
+}
+
+._ssFQn {}
+
+._1407I {}
+
+._19mE- {
+    position: absolute;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    transition: all .15s ease-out;
+}
+
+._3u_-s {
+    transition: none;
+}
+
+._3SfMJ {
+    opacity: .4;
+}
+
+._1cIvE {
+    opacity: 0;
+    transform: rotate(-90deg);
+}
+
+._Zly-L {}
+
+._31pmr {}
+
+._12Bbd {
+    position: absolute;
+    width: 20px;
+    height: 100px;
+    opacity: 0.5;
+    z-index: 1;
+}
+
+._1BC3I {
+    position: absolute;
+    bottom: -45px;
+    left: -5px;
+    width: 0;
+    height: 0;
+    border-top: 30px solid transparent;
+    border-bottom: 30px solid transparent;
+    border-left: 30px solid;
+    transform: rotate(90deg);
+}
+
+._13OXq {
+    display: flex;
+    justify-content: center;
+}
+
+._16zCe {
+    background-position: center;
+    background-size: cover;
+    cursor: pointer;
+}
+
+._1ZGj2 {
+    z-index: 101;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    -webkit-backdrop-filter: blur(4px);
+            backdrop-filter: blur(4px);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ChessBoard';
+export * from './JSChessEngine';