@akashic/headless-driver 1.11.37 → 2.0.1

package/lib/runner/v2/platform/NullVideoPlayer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullVideoplayerAsset = void 0;
+const aev2_1 = require("aev2");
+class NullVideoplayerAsset extends aev2_1.akashicEngine.VideoPlayer {
+    isDummy() {
+        return true;
+    }
+}
+exports.NullVideoplayerAsset = NullVideoplayerAsset;

package/lib/runner/v2/platform/PlatformV2.d.ts

@@ -0,0 +1,23 @@
+import type { akashicEngine as g, pdi } from "aev2";
+import { Looper } from "../../../Looper";
+import type { PlatformParameters } from "../../Platform";
+import { Platform } from "../../Platform";
+export declare class PlatformV2 extends Platform implements pdi.Platform {
+    private resFac;
+    private rendererReq;
+    private primarySurface;
+    private eventHandler;
+    private loopers;
+    private isLooperPaused;
+    constructor(param: PlatformParameters);
+    getResourceFactory(): g.ResourceFactory;
+    setRendererRequirement(requirement: pdi.RendererRequirement): void;
+    setPlatformEventHandler(handler: pdi.PlatformEventHandler): void;
+    getPlatformHandler(): pdi.PlatformEventHandler | null;
+    getPrimarySurface(): g.Surface;
+    createLooper(fun: (deltaTime: number) => number): Looper;
+    advanceLoopers(ms: number): void;
+    pauseLoopers(): void;
+    resumeLoopers(): void;
+    firePointEvent(event: pdi.PointEvent): void;
+}

package/lib/runner/v2/platform/PlatformV2.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformV2 = void 0;
+const Looper_1 = require("../../../Looper");
+const Platform_1 = require("../../Platform");
+const NullSurface_1 = require("./NullSurface");
+const ResourceFactory_1 = require("./ResourceFactory");
+class PlatformV2 extends Platform_1.Platform {
+    constructor(param) {
+        super(param);
+        this.rendererReq = null;
+        this.primarySurface = null;
+        this.eventHandler = null;
+        this.loopers = [];
+        this.isLooperPaused = false;
+        this.resFac = new ResourceFactory_1.ResourceFactory({
+            errorHandler: (e) => this.errorHandler(e),
+            loadFileHandler: param.loadFileHandler
+        });
+    }
+    getResourceFactory() {
+        return this.resFac;
+    }
+    setRendererRequirement(requirement) {
+        this.rendererReq = requirement;
+        this.primarySurface = new NullSurface_1.NullSurface(this.rendererReq.primarySurfaceWidth, this.rendererReq.primarySurfaceHeight, null);
+    }
+    setPlatformEventHandler(handler) {
+        this.eventHandler = handler;
+    }
+    getPlatformHandler() {
+        return this.eventHandler;
+    }
+    getPrimarySurface() {
+        if (this.primarySurface == null) {
+            throw new Error("PlatformV2#getPrimarySurface(): Primary surface has not been initialized yet");
+        }
+        return this.primarySurface;
+    }
+    createLooper(fun) {
+        const looper = new Looper_1.Looper(fun, (e) => this.errorHandler(e));
+        if (this.isLooperPaused) {
+            looper.debugStop();
+        }
+        this.loopers.push(looper);
+        return looper;
+    }
+    advanceLoopers(ms) {
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStep(ms);
+        }
+    }
+    pauseLoopers() {
+        this.isLooperPaused = true;
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStop();
+        }
+    }
+    resumeLoopers() {
+        this.isLooperPaused = false;
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStart();
+        }
+    }
+    firePointEvent(event) {
+        var _a;
+        (_a = this.eventHandler) === null || _a === void 0 ? void 0 : _a.onPointEvent(event);
+    }
+}
+exports.PlatformV2 = PlatformV2;

package/lib/runner/v2/platform/ResourceFactory.d.ts

@@ -0,0 +1,18 @@
+import { akashicEngine as g } from "aev2";
+export interface ResourceFactoryParameters {
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+    errorHandler: (err: any) => void;
+}
+export declare class ResourceFactory extends g.ResourceFactory {
+    private loadFileHandler;
+    private errorHandler;
+    constructor({ loadFileHandler, errorHandler }: ResourceFactoryParameters);
+    createImageAsset(id: string, assetPath: string, width: number, height: number): g.ImageAsset;
+    createVideoAsset(id: string, assetPath: string, width: number, height: number, system: g.VideoSystem, loop: boolean, useRealSize: boolean): g.VideoAsset;
+    createAudioAsset(id: string, assetPath: string, duration: number, system: g.AudioSystem, loop: boolean, hint: g.AudioAssetHint): g.AudioAsset;
+    createAudioPlayer(system: g.AudioSystem): g.AudioPlayer;
+    createTextAsset(id: string, assetPath: string): g.TextAsset;
+    createScriptAsset(id: string, assetPath: string): g.ScriptAsset;
+    createSurface(width: number, height: number): g.Surface;
+    createGlyphFactory(fontFamily: g.FontFamily | string | (g.FontFamily | string)[], fontSize: number, baselineHeight?: number, fontColor?: string, strokeWidth?: number, strokeColor?: string, strokeOnly?: boolean, fontWeight?: g.FontWeight): g.GlyphFactory;
+}

package/lib/runner/v2/platform/ResourceFactory.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceFactory = void 0;
+const aev2_1 = require("aev2");
+const NodeScriptAsset_1 = require("./assets/NodeScriptAsset");
+const NodeTextAsset_1 = require("./assets/NodeTextAsset");
+const NullAudioAsset_1 = require("./assets/NullAudioAsset");
+const NullImageAsset_1 = require("./assets/NullImageAsset");
+const NullVideoAsset_1 = require("./assets/NullVideoAsset");
+const NullAudioPlayer_1 = require("./NullAudioPlayer");
+const NullGlyphFactory_1 = require("./NullGlyphFactory");
+const NullSurface_1 = require("./NullSurface");
+class ResourceFactory extends aev2_1.akashicEngine.ResourceFactory {
+    constructor({ loadFileHandler, errorHandler }) {
+        super();
+        this.loadFileHandler = loadFileHandler;
+        this.errorHandler = errorHandler;
+    }
+    createImageAsset(id, assetPath, width, height) {
+        return new NullImageAsset_1.NullImageAsset(id, assetPath, width, height);
+    }
+    createVideoAsset(id, assetPath, width, height, system, loop, useRealSize) {
+        return new NullVideoAsset_1.NullVideoAsset(id, assetPath, width, height, system, loop, useRealSize);
+    }
+    createAudioAsset(id, assetPath, duration, system, loop, hint) {
+        return new NullAudioAsset_1.NullAudioAsset(id, assetPath, duration, system, loop, hint);
+    }
+    createAudioPlayer(system) {
+        return new NullAudioPlayer_1.NullAudioPlayer(system);
+    }
+    createTextAsset(id, assetPath) {
+        return new NodeTextAsset_1.NodeTextAsset({
+            id,
+            path: assetPath,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createScriptAsset(id, assetPath) {
+        return new NodeScriptAsset_1.NodeScriptAsset({
+            id,
+            path: assetPath,
+            errorHandler: this.errorHandler,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createSurface(width, height) {
+        return new NullSurface_1.NullSurface(width, height);
+    }
+    createGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight) {
+        return new NullGlyphFactory_1.NullGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight);
+    }
+}
+exports.ResourceFactory = ResourceFactory;

package/lib/runner/v2/platform/assets/NodeScriptAsset.d.ts

@@ -0,0 +1,16 @@
+import { akashicEngine as g } from "aev2";
+export interface NodeScriptAssetParameters {
+    id: string;
+    path: string;
+    errorHandler: (err: any) => void;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+}
+export declare class NodeScriptAsset extends g.ScriptAsset {
+    static PRE_SCRIPT: string;
+    static POST_SCRIPT: string;
+    private errorHandler;
+    private loadFileHandler;
+    constructor(param: NodeScriptAssetParameters);
+    _load(loader: g.AssetLoadHandler): void;
+    execute(execEnv: g.ScriptAssetExecuteEnvironment): any;
+}

package/lib/runner/v2/platform/assets/NodeScriptAsset.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeScriptAsset = void 0;
+const aev2_1 = require("aev2");
+class NodeScriptAsset extends aev2_1.akashicEngine.ScriptAsset {
+    constructor(param) {
+        super(param.id, param.path);
+        this.errorHandler = param.errorHandler;
+        this.loadFileHandler = param.loadFileHandler;
+    }
+    _load(loader) {
+        this.loadFileHandler(this.path, (err, text) => {
+            // NOTE: 過去バージョンのため型については精査しない
+            if (err) {
+                loader._onAssetError(this, err);
+            }
+            else {
+                this.script = text;
+                loader._onAssetLoad(this);
+            }
+        });
+    }
+    execute(execEnv) {
+        const func = new Function("g", NodeScriptAsset.PRE_SCRIPT + this.script + NodeScriptAsset.POST_SCRIPT);
+        try {
+            func(execEnv);
+        }
+        catch (e) {
+            this.errorHandler(e);
+        }
+        return execEnv.module.exports;
+    }
+}
+exports.NodeScriptAsset = NodeScriptAsset;
+NodeScriptAsset.PRE_SCRIPT = "(function(exports, require, module, __filename, __dirname) {\n";
+NodeScriptAsset.POST_SCRIPT = "\n})(g.module.exports, g.module.require, g.module, g.filename, g.dirname);";

package/lib/runner/v2/platform/assets/NodeTextAsset.d.ts

@@ -0,0 +1,11 @@
+import { akashicEngine as g } from "aev2";
+export interface NodeTextAssetParameters {
+    id: string;
+    path: string;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+}
+export declare class NodeTextAsset extends g.TextAsset {
+    private loadFileHandler;
+    constructor(param: NodeTextAssetParameters);
+    _load(loader: g.AssetLoadHandler): void;
+}

package/lib/runner/v2/platform/assets/NodeTextAsset.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTextAsset = void 0;
+const aev2_1 = require("aev2");
+class NodeTextAsset extends aev2_1.akashicEngine.TextAsset {
+    constructor(param) {
+        super(param.id, param.path);
+        this.loadFileHandler = param.loadFileHandler;
+    }
+    _load(loader) {
+        this.loadFileHandler(this.path, (err, text) => {
+            // NOTE: 過去バージョンのため型については精査しない
+            if (err) {
+                loader._onAssetError(this, err);
+            }
+            else {
+                this.data = text;
+                loader._onAssetLoad(this);
+            }
+        });
+    }
+}
+exports.NodeTextAsset = NodeTextAsset;

package/lib/runner/v2/platform/assets/NullAudioAsset.d.ts

@@ -0,0 +1,4 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullAudioAsset extends g.AudioAsset {
+    _load(loader: g.AssetLoadHandler): void;
+}

package/lib/runner/v2/platform/assets/NullAudioAsset.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAudioAsset = void 0;
+const aev2_1 = require("aev2");
+class NullAudioAsset extends aev2_1.akashicEngine.AudioAsset {
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+}
+exports.NullAudioAsset = NullAudioAsset;

package/lib/runner/v2/platform/assets/NullImageAsset.d.ts

@@ -0,0 +1,6 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullImageAsset extends g.ImageAsset {
+    _surface: g.Surface | null;
+    _load(loader: g.AssetLoadHandler): void;
+    asSurface(): g.Surface;
+}

package/lib/runner/v2/platform/assets/NullImageAsset.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullImageAsset = void 0;
+const aev2_1 = require("aev2");
+const NullSurface_1 = require("../NullSurface");
+class NullImageAsset extends aev2_1.akashicEngine.ImageAsset {
+    constructor() {
+        super(...arguments);
+        this._surface = null;
+    }
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+    asSurface() {
+        return this._surface || (this._surface = new NullSurface_1.NullSurface(this.width, this.height, null));
+    }
+}
+exports.NullImageAsset = NullImageAsset;

package/lib/runner/v2/platform/assets/NullVideoAsset.d.ts

@@ -0,0 +1,10 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullVideoAsset extends g.VideoAsset {
+    _surface: g.Surface | null;
+    _player: g.VideoPlayer;
+    constructor(id: string, assetPath: string, width: number, height: number, system: any, loop: boolean, useRealSize: boolean);
+    _load(loader: g.AssetLoadHandler): void;
+    asSurface(): g.Surface;
+    getPlayer(): g.VideoPlayer;
+    play(): g.VideoPlayer;
+}

package/lib/runner/v2/platform/assets/NullVideoAsset.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullVideoAsset = void 0;
+const aev2_1 = require("aev2");
+const NullSurface_1 = require("../NullSurface");
+class NullVideoAsset extends aev2_1.akashicEngine.VideoAsset {
+    constructor(id, assetPath, width, height, system, loop, useRealSize) {
+        super(id, assetPath, width, height, system, loop, useRealSize);
+        this._surface = null;
+        this._player = new aev2_1.akashicEngine.VideoPlayer();
+    }
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+    asSurface() {
+        return this._surface || (this._surface = new NullSurface_1.NullSurface(this.width, this.height, null));
+    }
+    getPlayer() {
+        return this._player;
+    }
+    play() {
+        return this._player;
+    }
+}
+exports.NullVideoAsset = NullVideoAsset;

package/lib/runner/v3/RunnerV3.d.ts

@@ -0,0 +1,38 @@
+import type { Canvas } from "canvas";
+import type { RunnerStartParameters } from "../Runner";
+import { Runner } from "../Runner";
+import type { RunnerPointEvent } from "../types";
+import { akashicEngine as g, gameDriver as gdr } from "./engineFiles";
+import type { NodeCanvasSurface } from "./platform/graphics/canvas/NodeCanvasSurface";
+import type { NullSurface } from "./platform/graphics/null/NullSurface";
+import { PlatformV3 } from "./platform/PlatformV3";
+export declare type RunnerV3Game = g.Game;
+export declare class RunnerV3 extends Runner {
+    readonly engineVersion: string;
+    readonly g: typeof g;
+    platform: PlatformV3 | null;
+    private driver;
+    private fps;
+    private running;
+    start(params?: RunnerStartParameters): Promise<RunnerV3Game | null>;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    step(): void;
+    advance(ms: number): Promise<void>;
+    changeGameDriverState(param: gdr.GameDriverInitializeParameterObject): Promise<void>;
+    firePointEvent(event: RunnerPointEvent): void;
+    /**
+     * プライマリサーフェスを取得する。
+     * @returns NullSurface または NodeCanvasSurface
+     */
+    getPrimarySurface(): NullSurface | NodeCanvasSurface;
+    /**
+     * プライマリサーフェスの Canvas インスタンスを取得する。
+     * @returns node-canvas の Canvas
+     */
+    getPrimarySurfaceCanvas(): Canvas;
+    protected _stepMinimal(): void;
+    private initGameDriver;
+    private onSendedToExternal;
+}

package/lib/runner/v3/RunnerV3.js

@@ -0,0 +1,245 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerV3 = void 0;
+const Runner_1 = require("../Runner");
+const engineFiles_1 = require("./engineFiles");
+const PlatformV3_1 = require("./platform/PlatformV3");
+class RunnerV3 extends Runner_1.Runner {
+    constructor() {
+        super(...arguments);
+        this.engineVersion = "3";
+        this.g = engineFiles_1.akashicEngine;
+        this.platform = null;
+        this.driver = null;
+        this.fps = null;
+        this.running = false;
+    }
+    start(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let game = null;
+            const paused = !!(params === null || params === void 0 ? void 0 : params.paused);
+            try {
+                game = yield this.initGameDriver();
+                if (!paused) {
+                    this.resume();
+                }
+            }
+            catch (e) {
+                this.onError(e);
+            }
+            return game;
+        });
+    }
+    stop() {
+        if (this.driver) {
+            this.driver.stopGame();
+            this.driver = null;
+        }
+        this.running = false;
+    }
+    pause() {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#pause() before initialized"));
+            return;
+        }
+        this.platform.pauseLoopers();
+        this.running = false;
+    }
+    resume() {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#resume() before initialized"));
+            return;
+        }
+        this.platform.resumeLoopers();
+        this.running = true;
+    }
+    step() {
+        if (this.fps == null || this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#step() before initialized"));
+            return;
+        }
+        if (this.running) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#step() in running"));
+            return;
+        }
+        this.platform.stepLoopers();
+    }
+    advance(ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fps == null || this.platform == null || this.driver == null) {
+                this.errorTrigger.fire(new Error("Cannot call Runner#advance() before initialized"));
+                return;
+            }
+            if (this.running) {
+                this.errorTrigger.fire(new Error("Cannot call Runner#advance() in running"));
+                return;
+            }
+            const loopConfiguration = this.driver.getLoopConfiguration();
+            if (!loopConfiguration) {
+                this.errorTrigger.fire(new Error("Cannot get LoopConfiguration"));
+                return;
+            }
+            const { loopMode, skipThreshold } = loopConfiguration;
+            // NOTE: skip の通知タイミングを一度に制限するため skipThreshold を一時的に変更する。
+            yield this.changeGameDriverState({
+                loopConfiguration: {
+                    loopMode,
+                    skipThreshold: Math.ceil(ms / this.fps) + 1
+                }
+            });
+            const delta = Math.ceil(1000 / this.fps);
+            let progress = 0;
+            while (progress <= ms) {
+                // NOTE: game-driver の内部実装により Looper 経由で一度に進める時間に制限がある。
+                // そのため一度に進める時間を fps に応じて分割する。
+                this.platform.advanceLoopers(delta);
+                progress += delta;
+            }
+            yield this.changeGameDriverState({
+                loopConfiguration: {
+                    loopMode,
+                    skipThreshold
+                }
+            });
+        });
+    }
+    changeGameDriverState(param) {
+        return new Promise((resolve, reject) => {
+            if (!this.driver) {
+                reject(new Error("Game is not started"));
+                return;
+            }
+            this.driver.changeState(param, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+    firePointEvent(event) {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#firePointEvent() before initialized"));
+            return;
+        }
+        let type;
+        if (event.type === "down") {
+            type = 0 /* Down */;
+        }
+        else if (event.type === "move") {
+            type = 1 /* Move */;
+        }
+        else if (event.type === "up") {
+            type = 2 /* Up */;
+        }
+        else {
+            this.errorTrigger.fire(new Error(`RunnerV3#firePointEvent(): unknown event type: ${event.type}`));
+            return;
+        }
+        this.platform.firePointEvent({
+            type,
+            identifier: event.identifier,
+            offset: event.offset
+        });
+    }
+    /**
+     * プライマリサーフェスを取得する。
+     * @returns NullSurface または NodeCanvasSurface
+     */
+    getPrimarySurface() {
+        if (!this.platform) {
+            throw new Error("RunnerV3#getPrimarySurface(): Platform has not been initialized");
+        }
+        if (this.renderingMode === "canvas") {
+            return this.platform.getPrimarySurface();
+        }
+        return this.platform.getPrimarySurface();
+    }
+    /**
+     * プライマリサーフェスの Canvas インスタンスを取得する。
+     * @returns node-canvas の Canvas
+     */
+    getPrimarySurfaceCanvas() {
+        if (this.renderingMode !== "canvas") {
+            throw Error("RunnerV3#getPrimarySurface(): Not supported except in the case of renderingMode === 'canvas");
+        }
+        return this.getPrimarySurface()._drawable;
+    }
+    _stepMinimal() {
+        this.step();
+    }
+    initGameDriver() {
+        return new Promise((resolve, reject) => {
+            if (this.driver) {
+                this.driver.destroy();
+                this.driver = null;
+            }
+            const player = {
+                id: this.player ? this.player.id : undefined,
+                name: this.player ? this.player.name : undefined
+            };
+            const executionMode = this.executionMode === "active" ? engineFiles_1.gameDriver.ExecutionMode.Active : engineFiles_1.gameDriver.ExecutionMode.Passive;
+            this.platform = new PlatformV3_1.PlatformV3({
+                configurationBaseUrl: this.configurationBaseUrl,
+                assetBaseUrl: this.assetBaseUrl,
+                amflow: this.amflow,
+                trusted: this.trusted,
+                renderingMode: this.renderingMode,
+                sendToExternalHandler: (data) => this.onSendedToExternal(data),
+                errorHandler: (e) => this.onError(e),
+                loadFileHandler: (url, callback) => this.loadFileHandler(url, callback)
+            });
+            this.pause();
+            const driver = new engineFiles_1.gameDriver.GameDriver({
+                platform: this.platform,
+                player,
+                errorHandler: (e) => this.onError(e)
+            });
+            this.driver = driver;
+            let result = null;
+            // TODO: パラメータを外部から変更可能にする
+            driver.initialize({
+                configurationUrl: this.configurationUrl,
+                configurationBase: this.configurationBaseUrl,
+                assetBase: this.assetBaseUrl,
+                driverConfiguration: {
+                    playId: this.playId,
+                    playToken: this.playToken,
+                    executionMode
+                },
+                loopConfiguration: {
+                    loopMode: engineFiles_1.gameDriver.LoopMode.Realtime
+                },
+                gameArgs: this.gameArgs
+            }, (e) => {
+                if (e) {
+                    reject(e);
+                    return;
+                }
+                if (!result) {
+                    // GameDriver の内部実装上ここに来ることはないはずだが念のため確認
+                    return reject(new Error("Game is null."));
+                }
+                driver.startGame();
+                resolve(result);
+            });
+            driver.gameCreatedTrigger.addOnce((game) => {
+                if (this.externalValue) {
+                    Object.keys(this.externalValue).forEach((key) => {
+                        game.external[key] = this.externalValue[key];
+                    });
+                }
+                this.fps = game.fps;
+                result = game;
+            });
+        });
+    }
+    onSendedToExternal(data) {
+        this.sendToExternalTrigger.fire(data);
+    }
+}
+exports.RunnerV3 = RunnerV3;

package/lib/runner/v3/engineFiles.d.ts

@@ -0,0 +1,2 @@
+import { akashicEngine, gameDriver, pdi } from "aev3";
+export { akashicEngine, gameDriver, pdi };

package/lib/runner/v3/engineFiles.js

@@ -0,0 +1,31 @@
+"use strict";
+// 環境に応じて適当な engineFiles を返すモジュール。
+// 通常の engine-files と同様に `import { akashicEngine, gameDriver, pdi } from "./engineFiles"` という形で呼び出せる。
+// RunnerV3 内では基本的に本モジュールを介して engine-files の読み込みを行うこと。
+//
+// NOTE: このモジュールは現実装において NodeVM のサンドボックスの内側と外側の両方から require される。
+// サンドボックスの内側ではグローバル関数 trustedFunctions.engineFiles() が存在するため、下の (1) のパスから engine-files を読みようにする。
+// 一方、このモジュール自体が NodeVM の外側から require されるケースも存在するため、下の (2) のパスから engine-files を読み込むようにしている。
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pdi = exports.gameDriver = exports.akashicEngine = void 0;
+const aev3_1 = require("aev3");
+Object.defineProperty(exports, "akashicEngine", { enumerable: true, get: function () { return aev3_1.akashicEngine; } });
+Object.defineProperty(exports, "gameDriver", { enumerable: true, get: function () { return aev3_1.gameDriver; } });
+Object.defineProperty(exports, "pdi", { enumerable: true, get: function () { return aev3_1.pdi; } });
+let e;
+if (typeof trustedFunctions !== "undefined") {
+    // (1)
+    // NodeVM の中であれば
+    e = trustedFunctions.engineFiles();
+}
+else {
+    // (2)
+    // NodeVM 起動前もしくはその他環境であれば
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    e = require("./requireEngineFiles").requireEngineFiles();
+}
+if (e) {
+    aev3_1.akashicEngine = e.akashicEngine;
+    aev3_1.gameDriver = e.gameDriver;
+    aev3_1.pdi = e.pdi;
+}