chlss/dist/pawnMoveGenerator.js

Open-Source Chess Engine in TypeScript.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.PawnMoveGenerator = void 0;
const boardPosition_1 = require("./boardPosition");
const piece_1 = require("./piece");
const colour_1 = require("./colour");
const coords_1 = require("./coords");
const pieces_1 = __importDefault(require("./pieces"));
function isLastSquare(pawnColour, sq) {
    const y = coords_1.Coords.toY(sq);
    return (pawnColour == colour_1.Colours.white && y == 0) || (pawnColour == colour_1.Colours.black && y == 7);
}
exports.PawnMoveGenerator = {
    generatePawnMoves(boardPosition, piece, index, posX, posY, colour, moveList, enPassant) {
        const yDir = this.getYDir(colour);
        const oneMoveTargetY = posY + yDir;
        const oneSquareAheadEmpty = boardPosition_1.BoardPosition.isEmpty(boardPosition, posX, oneMoveTargetY);
        if (oneSquareAheadEmpty) {
            this.tryAddTwoSquareMoveIfLegalAndOneSquareIsEmpty(piece, boardPosition, colour, yDir, posX, posY, index, moveList);
            this.addOneMoveIfOneSquareAheadIsEmpty(piece, index, coords_1.Coords.toSquareIndex(posX, oneMoveTargetY), moveList);
        }
        this.addCaptureMove(boardPosition, piece, index, posX + 1, oneMoveTargetY, colour, moveList);
        this.addCaptureMove(boardPosition, piece, index, posX - 1, oneMoveTargetY, colour, moveList);
        this.tryAddEnPassant(piece, colour, index, enPassant, yDir, posX, posY, moveList);
    },
    addCaptureMove(boardPosition, piece, index, posX, posY, colour, moveList) {
        if (!(boardPosition_1.BoardPosition.isInBoard(posX, posY)))
            return;
        const targetI = coords_1.Coords.toSquareIndex(posX, posY);
        const targetPiece = boardPosition_1.BoardPosition.getPiece(boardPosition, targetI);
        if (piece_1.Piece.isEmpty(targetPiece))
            return;
        if (!(piece_1.Piece.isEnemy(targetPiece, colour)))
            return;
        this.addMove(piece, index, targetI, targetPiece, moveList);
    },
    addOneMoveIfOneSquareAheadIsEmpty(piece, index, targetIndex, moveList) {
        this.addMove(piece, index, targetIndex, pieces_1.default.Empty, moveList);
    },
    addMove(piece, from, target, targetPiece, moveList) {
        moveList.push({
            from: from,
            to: target,
            piece: piece,
            targetPiece: targetPiece,
            setEnPassant: null,
            promotion: undefined,
            isPromo: isLastSquare(piece_1.Piece.getColour(piece), target)
        });
    },
    addMoveWithOptionalSetEnPassant(piece, from, target, targetPiece, moveList, setEnPassant) {
        moveList.push({
            from: from,
            to: target,
            piece: piece,
            targetPiece: targetPiece,
            setEnPassant: setEnPassant,
            promotion: undefined,
            isPromo: false
        });
    },
    tryAddTwoSquareMoveIfLegalAndOneSquareIsEmpty(piece, boardPosition, colour, yDir, posX, posY, index, moveList) {
        const targetY = posY + (yDir * 2);
        const targetIndex = coords_1.Coords.toSquareIndex(posX, targetY);
        if (this.validateYPositionToMoveTwoSquare(posY, colour) && boardPosition_1.BoardPosition.isSquareEmpty(boardPosition, targetIndex)) {
            const setEnPassant = this.trySetEnPassantWhenMovesTwoSquare(colour, boardPosition, posX, posY, targetY, yDir);
            this.addMoveWithOptionalSetEnPassant(piece, index, targetIndex, pieces_1.default.Empty, moveList, setEnPassant);
        }
    },
    getYDir(colour) {
        return colour == colour_1.Colours.white ? -1 : 1;
    },
    validateYPositionToMoveTwoSquare(posY, colour) {
        return (posY == 1 && colour == colour_1.Colours.black) || (posY == 6 && colour == colour_1.Colours.white);
    },
    isOneSquareAheadEmpty(boardPosition, yDir, posX, posY) {
        return boardPosition_1.BoardPosition.isEmpty(boardPosition, posX, posY + yDir);
    },
    tryAddEnPassant(piece, colour, index, enPassant, yDir, posX, posY, moveList) {
        if (enPassant == null)
            return;
        function validateIsEnPassantSquareReachable(posX, posY, enPassantPosX, enPassantPosY, yDir) {
            const expectedY = posY + yDir;
            return (expectedY == enPassantPosY) && (posX + 1 == enPassantPosX || posX - 1 == enPassantPosX);
        }
        const enPassantX = coords_1.Coords.toX(enPassant);
        const enPassantY = coords_1.Coords.toY(enPassant);
        if (!validateIsEnPassantSquareReachable(posX, posY, enPassantX, enPassantY, yDir))
            return;
        moveList.push({
            from: index,
            to: coords_1.Coords.toSquareIndex(enPassantX, enPassantY),
            piece: piece,
            targetPiece: pieces_1.default.Empty,
            setEnPassant: null,
            promotion: undefined,
            isPromo: false
        });
    },
    trySetEnPassantWhenMovesTwoSquare(colour, boardPosition, posX, posY, targetY, yDir) {
        function isEnemyPawnStands(posX, targetY, boardPosition, colour) {
            if (boardPosition_1.BoardPosition.isInBoard(posX + 1, targetY)) {
                const sqIndex = coords_1.Coords.toSquareIndex(posX + 1, targetY);
                const piece = boardPosition_1.BoardPosition.getPieceOrNull(boardPosition, sqIndex);
                if (piece == piece_1.Piece.getPawn(colour_1.Colours.inverseColour(colour)))
                    return true;
            }
            if (boardPosition_1.BoardPosition.isInBoard(posX - 1, targetY)) {
                const sqIndex = coords_1.Coords.toSquareIndex(posX - 1, targetY);
                const piece = boardPosition_1.BoardPosition.getPieceOrNull(boardPosition, sqIndex);
                if (piece == piece_1.Piece.getPawn(colour_1.Colours.inverseColour(colour)))
                    return true;
            }
            return false;
        }
        if (!isEnemyPawnStands(posX, targetY, boardPosition, colour))
            return null;
        function getEnPassantSquare(posX, targetY, yDir) {
            return coords_1.Coords.toSquareIndex(posX, targetY - yDir);
        }
        return getEnPassantSquare(posX, targetY, yDir);
    }
};