boardgame-core/src/core/game.ts

import {MutableSignal, mutableSignal} from "@/utils/mutable-signal";
import {
    Command,
    CommandRegistry, CommandResult,
    CommandRunnerContextExport,
    CommandSchema,
    createCommandRegistry,
    createCommandRunnerContext,
} from "@/utils/command";
import {PromptValidator} from "@/utils/command/command-runner";

export interface IGameContext<TState extends Record<string, unknown> = {} > {
    get value(): TState;
    produce(fn: (draft: TState) => void): void;
    produceAsync(fn: (draft: TState) => void): Promise<void>;
    run<T>(input: string): Promise<CommandResult<T>>;
    runParsed<T>(command: Command): Promise<CommandResult<T>>;
    prompt<T>(schema: CommandSchema | string, validator: PromptValidator<T>, currentPlayer?: string | null): Promise<T>;
    addInterruption(promise: Promise<void>): void;
    
    // test only
    _state: MutableSignal<TState>;
    _commands: CommandRunnerContextExport<IGameContext<TState>>;
}

export function createGameContext<TState extends Record<string, unknown> = {} >(
    commandRegistry: CommandRegistry<IGameContext<TState>>,
    initialState?: TState | (() => TState)
): IGameContext<TState> {
    const stateValue = typeof initialState === 'function' ? initialState() : initialState ?? {} as TState;
    const state = mutableSignal(stateValue);
    let commands: CommandRunnerContextExport<IGameContext<TState>> = null as any;

    const context: IGameContext<TState> = {
        get value(): TState {
            return state.value;
        },
        produce(fn) {
            return state.produce(fn);
        },
        produceAsync(fn) {
            return state.produceAsync(fn);
        },
        run<T>(input: string) {
            return commands.run<T>(input);
        },
        runParsed<T>(command: Command) {
            return commands.runParsed<T>(command);
        },
        prompt(schema, validator, currentPlayer) {
            return commands.prompt(schema, validator, currentPlayer);
        },
        addInterruption(promise) {
            state.addInterruption(promise);
        },
        
        _state: state,
        _commands: commands,
    };

    context._commands = commands = createCommandRunnerContext(commandRegistry, context);
    
    return context;
}

export function createGameCommandRegistry<TState extends Record<string, unknown> = {} >() {
    return createCommandRegistry<IGameContext<TState>>();
}