@real_one_chess_king/game-logic/dist/esm/chess/rules-engine.js

R.O.C.K. chess game logic

import { DiagonalMovementRule, HorizontalMovementRule, KnightMovementRule, PositionSpecificMovementRule, TransformationOnPositionRule, VerticalMovementRule, } from "./rules/piece-movement";
import { CastlingMovementRule } from "./rules/piece-movement/castling.rule";
import { TakeOnThePassMovementRule } from "./rules/piece-movement/take-on-the-pass.rule";
import { isPositionSpecificMovementRuleMeta } from "./rules/piece-movement/rules.typeguards";
import { MovementRules, PostMovementRules, } from "./rules/piece-movement/movement-rules.const";
import { isTransformingRuleMeta } from "./rules/piece-post-movement/transforming-on-position/transforming-on-position.typeguard";
const rulesMapper = {
    [MovementRules.VerticalMovementRule]: VerticalMovementRule,
    [MovementRules.HorizontalMovementRule]: HorizontalMovementRule,
    [MovementRules.DiagonalMovementRule]: DiagonalMovementRule,
    [MovementRules.KnightMovementRule]: KnightMovementRule,
    [MovementRules.PositionSpecificMovementRule]: PositionSpecificMovementRule,
    [MovementRules.TakeOnThePassMovementRule]: TakeOnThePassMovementRule,
    [MovementRules.CastlingMovementRule]: CastlingMovementRule,
};
const postMovementRulesMapper = {
    [PostMovementRules.TransformationOnPositionRule]: TransformationOnPositionRule,
};
export class RulesEngine {
    movementRules = new Map();
    postMovementRules = new Map();
    addMovementRule(ruleMeta) {
        const r = rulesMapper[ruleMeta.name];
        const uniqRulesParams = {};
        if (isPositionSpecificMovementRuleMeta(ruleMeta)) {
            const activatePositions = {};
            if (ruleMeta.activatePositions.x) {
                activatePositions.x = new Set(ruleMeta.activatePositions.x);
            }
            if (ruleMeta.activatePositions.y) {
                activatePositions.y = new Set(ruleMeta.activatePositions.y);
            }
            uniqRulesParams.activatePositions = activatePositions;
        }
        const ruleInstance = new r({
            ...ruleMeta,
            directions: new Set(ruleMeta.directions),
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            ...uniqRulesParams,
        });
        this.movementRules.set(ruleMeta.id, ruleInstance);
    }
    addMovementRules(rulesMeta) {
        rulesMeta.forEach((ruleMeta) => {
            if (!this.movementRules.has(ruleMeta.id)) {
                this.addMovementRule(ruleMeta);
            }
        });
    }
    addPostMovementRule(ruleMeta) {
        if (isTransformingRuleMeta(ruleMeta)) {
            const ruleInstance = new postMovementRulesMapper[ruleMeta.name](ruleMeta);
            this.postMovementRules.set(ruleMeta.id, ruleInstance);
        }
        else {
            throw new Error("Invalid post movement rule");
        }
    }
    addPostMovementRules(rulesMeta) {
        rulesMeta.forEach((ruleMeta) => {
            if (!this.postMovementRules.has(ruleMeta.id)) {
                this.addPostMovementRule(ruleMeta);
            }
        });
    }
    getAvailableMoves(ruleId, x, y, getPiece, turns, size) {
        const ruleInstance = this.movementRules.get(ruleId);
        if (!ruleInstance) {
            throw new Error(`Movement rule not found ${ruleId}`);
        }
        return ruleInstance.availableMoves(x, y, getPiece, turns, size);
    }
    addPostMovementCorrections(rule, sourceMoves, pieceType) {
        const ruleInstance = this.postMovementRules.get(rule);
        if (!ruleInstance) {
            throw new Error(`Post movement rule not found ${rule}`);
        }
        return ruleInstance.updateMovesAffects(sourceMoves, pieceType);
    }
}
//# sourceMappingURL=rules-engine.js.map