boardgame-core/src/core/game.ts

import {MutableSignal, mutableSignal} from "@/utils/mutable-signal";
import {
    Command,
    CommandRegistry, CommandResult,
    CommandRunnerContextExport,
    CommandSchema,
    createCommandRegistry,
    createCommandRunnerContext, parseCommandSchema,
} 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: <TResult,TArgs extends any[]=any[]>(def: PromptDef<TArgs>, validator: PromptValidator<TResult,TArgs>, currentPlayer?: string | null) => Promise<TResult>;
    
    // 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(def, validator, currentPlayer) {
            return commands.prompt(def.schema, validator, def.hintText, currentPlayer);
        },
        
        _state: state,
        _commands: commands,
    };

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

export type PromptDef<TArgs extends any[]=any[]> = {
    schema: CommandSchema,
    hintText?: string,
}
export function createPromptDef<TArgs extends any[]=any[]>(schema: CommandSchema | string, hintText?: string): PromptDef<TArgs> {
    schema = typeof schema === 'string' ? parseCommandSchema(schema) : schema;
    return { schema, hintText };
}

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