boardgame-core/src/core/rule.ts

import {Command, CommandSchema, parseCommand, parseCommandSchema} from "../utils/command";

export type RuleState = 'running' | 'yielded' | 'waiting' | 'done';

export type RuleContext<T = unknown> = {
    type: string;
    schema?: CommandSchema;
    generator: Generator<string | CommandSchema, T, Command>;
    parent?: RuleContext<unknown>;
    children: RuleContext<unknown>[];
    state: RuleState;
    resolution?: T;
}

export type RuleDef<T = unknown> = {
    schema: CommandSchema;
    create: (cmd: Command) => Generator<string | CommandSchema, T, Command>;
};

export type RuleRegistry = Map<string, RuleDef<unknown>>;

export function createRule<T>(
    schemaStr: string,
    fn: (cmd: Command) => Generator<string | CommandSchema, T, Command>
): RuleDef<T> {
    return {
        schema: parseCommandSchema(schemaStr, ''),
        create: fn as RuleDef<T>['create'],
    };
}

function parseYieldedSchema(value: string | CommandSchema): CommandSchema {
    if (typeof value === 'string') {
        return parseCommandSchema(value, '');
    }
    return value;
}

function pushContextToGame(game: GameContextLike, ctx: RuleContext<unknown>) {
    game.contexts.value = [...game.contexts.value, { value: ctx } as any];
    game.addRuleContext(ctx);
}

function discardChildren(game: GameContextLike, parent: RuleContext<unknown>) {
    for (const child of parent.children) {
        game.removeRuleContext(child);

        const ctxIdx = game.contexts.value.findIndex((c: any) => c.value === child);
        if (ctxIdx !== -1) {
            const arr = [...game.contexts.value];
            arr.splice(ctxIdx, 1);
            game.contexts.value = arr;
        }
    }
    parent.children = [];
    parent.state = 'yielded';
}

function validateYieldedSchema(command: Command, schema: CommandSchema): boolean {
    const requiredParams = schema.params.filter(p => p.required);
    const variadicParam = schema.params.find(p => p.variadic);

    if (command.params.length < requiredParams.length) {
        return false;
    }

    if (!variadicParam && command.params.length > schema.params.length) {
        return false;
    }

    const requiredOptions = schema.options.filter(o => o.required);
    for (const opt of requiredOptions) {
        const hasOption = opt.name in command.options || (opt.short && opt.short in command.options);
        if (!hasOption) {
            return false;
        }
    }

    return true;
}

function invokeRule<T>(
    game: GameContextLike,
    command: Command,
    ruleDef: RuleDef<T>,
    parent?: RuleContext<unknown>
): RuleContext<T> {
    const ctx: RuleContext<T> = {
        type: ruleDef.schema.name,
        schema: undefined,
        generator: ruleDef.create(command),
        parent,
        children: [],
        state: 'running',
        resolution: undefined,
    };

    if (parent) {
        discardChildren(game, parent);
        parent.children.push(ctx as RuleContext<unknown>);
        parent.state = 'waiting';
    }

    pushContextToGame(game, ctx as RuleContext<unknown>);

    const result = ctx.generator.next();
    if (result.done) {
        ctx.resolution = result.value;
        ctx.state = 'done';
    } else {
        ctx.schema = parseYieldedSchema(result.value);
        ctx.state = 'yielded';
    }

    return ctx;
}

export function dispatchCommand(game: GameContextLike, input: string): RuleContext<unknown> | undefined {
    const command = parseCommand(input);

    if (game.rules.has(command.name)) {
        const ruleDef = game.rules.get(command.name)!;

        const parent = findYieldedParent(game);

        return invokeRule(game, command, ruleDef, parent);
    }

    for (let i = game.ruleContexts.length - 1; i >= 0; i--) {
        const ctx = game.ruleContexts[i];
        if (ctx.state === 'yielded' && ctx.schema) {
            if (validateYieldedSchema(command, ctx.schema)) {
                const result = ctx.generator.next(command);
                if (result.done) {
                    ctx.resolution = result.value;
                    ctx.state = 'done';
                } else {
                    ctx.schema = parseYieldedSchema(result.value);
                    ctx.state = 'yielded';
                }
                return ctx;
            }
        }
    }

    return undefined;
}

function findYieldedParent(game: GameContextLike): RuleContext<unknown> | undefined {
    for (let i = game.ruleContexts.length - 1; i >= 0; i--) {
        const ctx = game.ruleContexts[i];
        if (ctx.state === 'yielded') {
            return ctx;
        }
    }
    return undefined;
}

type GameContextLike = {
    rules: RuleRegistry;
    ruleContexts: RuleContext<unknown>[];
    contexts: { value: any[] };
    addRuleContext: (ctx: RuleContext<unknown>) => void;
    removeRuleContext: (ctx: RuleContext<unknown>) => void;
};