boardgame-core/src/core/game.ts

import {createEntityCollection, entity, Entity, EntityCollection} from "../utils/entity";
import {Part} from "./part";
import {Region} from "./region";
import {
    Command,
    CommandRegistry,
    type CommandRunner, CommandRunnerContext,
    CommandRunnerContextExport, CommandSchema, createCommandRegistry,
    createCommandRunnerContext, parseCommandSchema,
    PromptEvent
} from "../utils/command";
import {AsyncQueue} from "../utils/async-queue";

export interface IGameContext<TState extends Record<string, unknown> = {} > {
    parts: EntityCollection<Part>;
    regions: EntityCollection<Region>;
    state: Entity<TState>;
    commands: CommandRunnerContextExport<IGameContext<TState>>;
    prompts: AsyncQueue<PromptEvent>;
}

export function createGameContext<TState extends Record<string, unknown> = {} >(
    commandRegistry: CommandRegistry<IGameContext<TState>>,
    initialState?: TState | (() => TState)
): IGameContext<TState> {
    const parts = createEntityCollection<Part>();
    const regions = createEntityCollection<Region>();
    const prompts = new AsyncQueue<PromptEvent>();
    const state = typeof initialState === 'function' ? initialState() : initialState ?? {} as TState;

    const ctx = {
        parts,
        regions,
        prompts,
        commands: null!,
        state: entity('gameState', state),
    } as IGameContext<TState>

    ctx.commands = createCommandRunnerContext(commandRegistry, ctx);
    ctx.commands.on('prompt', (prompt: PromptEvent) => ctx.prompts.push(prompt));

    return ctx;
}

/**
 * so that we can do `import * as tictactoe from './tic-tac-toe.ts';\n\n createGameContextFromModule(tictactoe);`
 * @param module
 */
export function createGameContextFromModule<TState extends Record<string, unknown> = {} >(
    module: {
        registry: CommandRegistry<IGameContext<TState>>,
        createInitialState: () => TState
    },
): IGameContext<TState> {
    return createGameContext(module.registry, module.createInitialState);
}

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

export function createGameCommand<TState extends Record<string, unknown> = {} , TResult = unknown>(
    schema: CommandSchema | string,
    run: (this: CommandRunnerContext<IGameContext<TState>>, command: Command) => Promise<TResult>
): CommandRunner<IGameContext<TState>, TResult> {
    return {
        schema: typeof schema === 'string' ? parseCommandSchema(schema) : schema,
        run,
    };
}