textadv/dist/cli.js

Text Adventures generator from Markdown files

#!/usr/bin/env node
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
import { cac } from 'cac';
import { writeFileSync } from 'fs';
import { Engine } from './engine.js';
import { generateBasic } from './gen-basic.js';
import { generateJson } from './gen-json.js';
import { parseFile, validateProject } from './parser.js';
import * as readline from 'readline';
const cli = cac('textadv');
cli.command('gen <file>', 'Generates Text Adventure from a Markdown file')
    .option('--target <target>', 'Target language', { default: 'basic' })
    .option('--output <file>', 'Output file path')
    .action((file, options) => __awaiter(void 0, void 0, void 0, function* () {
    const { project, mdAST } = yield parseFile(file);
    const errors = validateProject(project);
    if (errors.length > 0) {
        throw new Error(`Error(s): ${errors.join("\n")}`);
    }
    let generate;
    switch (options.target) {
        case 'ast':
            generate = () => JSON.stringify(mdAST, null, 3);
            break;
        case 'basic':
            generate = generateBasic;
            break;
        case 'json':
            generate = generateJson;
            break;
        default:
            throw new Error(`Generator for lang '${options.lang}' unavailable`);
    }
    const output = generate(project);
    if (options.output) {
        writeFileSync(options.output, output, 'utf-8');
    }
    else {
        console.log(output);
    }
}));
cli.command('run <file>', 'Runs Text Adventure from a Markdown file')
    .option('--debug', 'Debug internal states')
    .action((file, options) => __awaiter(void 0, void 0, void 0, function* () {
    const { project } = yield parseFile(file);
    const engine = new Engine(project);
    let state = engine.start();
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });
    function prompt() {
        rl.question('> ', (input) => {
            if (input === '/quit') {
                return rl.close();
            }
            const roomIndex = state.roomIndex;
            state = engine.input(input, state);
            const { output } = state, other = __rest(state, ["output"]);
            if (options.debug) {
                console.debug('[state]', JSON.stringify(other));
            }
            if (output.length > 0) {
                console.log(output.join("\n"));
            }
            if (state.roomIndex !== roomIndex) {
                console.log(engine.getRoomIntro(state.roomIndex).join("\n\n"));
            }
            prompt();
        });
    }
    console.log(`[${project.name}]\n`);
    console.log(project.intro.join("\n\n"));
    console.log("\n---\n");
    console.log(engine.getRoomIntro(state.roomIndex).join("\n\n"));
    prompt();
}));
cli.help();
cli.parse();
//# sourceMappingURL=cli.js.map