adofai 2.9.13 → 2.9.15

package/dist/src/parser/index.d.ts

@@ -0,0 +1,16 @@
+import { LevelOptions, ParseProvider } from '../structure';
+declare class BaseParser {
+    static parseError(f: string): string;
+    /**
+        * @param {string} t - Input Content
+        * @param {object} provider - ParserProvider
+        * @returns {LevelOptions} ADOFAI File Object
+    */
+    static parseAsObject(t: string, provider?: ParseProvider): LevelOptions;
+    /**
+        * @param {string} t - Input Content
+        * @returns {string} ADOFAI File Content
+    */
+    static parseAsText(t: string): string;
+}
+export default BaseParser;

package/dist/src/parser/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const StringParser_1 = __importDefault(require("./StringParser"));
+class BaseParser {
+    static parseError(f) {
+        return f;
+    }
+    /**
+        * @param {string} t - Input Content
+        * @param {object} provider - ParserProvider
+        * @returns {LevelOptions} ADOFAI File Object
+    */
+    static parseAsObject(t, provider) {
+        const parser = provider || new StringParser_1.default();
+        return parser.parse(BaseParser.parseAsText(t));
+    }
+    /**
+        * @param {string} t - Input Content
+        * @returns {string} ADOFAI File Content
+    */
+    static parseAsText(t) {
+        return this.parseError(t);
+    }
+}
+exports.default = BaseParser;

package/{src/parser.ts → dist/src/parser.d.ts}

@@ -2,6 +2,5 @@ import Parser from "./parser/index";
 import BufferParser from './parser/BufferParser';
 import ArrayBufferParser from "./parser/ArrayBufferParser";
 import StringParser from "./parser/StringParser";
-
-export {StringParser, BufferParser, ArrayBufferParser}
+export { StringParser, BufferParser, ArrayBufferParser };
 export default Parser;

package/dist/src/parser.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayBufferParser = exports.BufferParser = exports.StringParser = void 0;
+const index_1 = __importDefault(require("./parser/index"));
+const BufferParser_1 = __importDefault(require("./parser/BufferParser"));
+exports.BufferParser = BufferParser_1.default;
+const ArrayBufferParser_1 = __importDefault(require("./parser/ArrayBufferParser"));
+exports.ArrayBufferParser = ArrayBufferParser_1.default;
+const StringParser_1 = __importDefault(require("./parser/StringParser"));
+exports.StringParser = StringParser_1.default;
+exports.default = index_1.default;

package/dist/src/pathdata.d.ts

@@ -0,0 +1,13 @@
+interface PathDataTable {
+    [key: string]: number;
+}
+/**
+    * @param {string} pathdata - PathData from ADOFAI
+    * @returns {Array<number>} Converted AngleData
+*/
+declare function parseToangleData(pathdata: string): number[];
+declare const _default: {
+    pathDataTable: PathDataTable;
+    parseToangleData: typeof parseToangleData;
+};
+export default _default;

package/dist/src/pathdata.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pathDataTable = { "R": 0, "p": 15, "J": 30, "E": 45, "T": 60, "o": 75, "U": 90, "q": 105, "G": 120, "Q": 135, "H": 150, "W": 165, "L": 180, "x": 195, "N": 210, "Z": 225, "F": 240, "V": 255, "D": 270, "Y": 285, "B": 300, "C": 315, "M": 330, "A": 345, "5": 555, "6": 666, "7": 777, "8": 888, "!": 999 };
+/**
+    * @param {string} pathdata - PathData from ADOFAI
+    * @returns {Array<number>} Converted AngleData
+*/
+function parseToangleData(pathdata) {
+    let pt = Array.from(String(pathdata));
+    let result = pt.map(t => pathDataTable[t]);
+    return result;
+}
+exports.default = {
+    pathDataTable,
+    parseToangleData
+};

package/dist/src/presets.d.ts

@@ -0,0 +1,10 @@
+export interface Preset {
+    type: 'include' | 'exclude' | "special";
+    events: string[];
+    [key: string]: any;
+}
+export declare const preset_noeffect: Preset;
+export declare const preset_noholds: Preset;
+export declare const preset_nomovecamera: Preset;
+export declare const preset_noeffect_completely: Preset;
+export declare const preset_inner_no_deco: Preset;

package/{src/presets.ts → dist/src/presets.js}

@@ -1,10 +1,7 @@
-export interface Preset {
-    type: 'include'|'exclude'|"special";
-    events: string[];
-    [key: string]: any;
-}
-
-export const preset_noeffect: Preset = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preset_inner_no_deco = exports.preset_noeffect_completely = exports.preset_nomovecamera = exports.preset_noholds = exports.preset_noeffect = void 0;
+exports.preset_noeffect = {
     type: 'exclude', events: [
         'Flash',
         'SetFilter',
@@ -17,20 +14,17 @@ export const preset_noeffect: Preset = {
         'ShakeScreen'
     ]
 };
-
-export const preset_noholds: Preset = {
+exports.preset_noholds = {
     type: 'exclude', events: [
         'Hold',
     ]
-}
-
-export const preset_nomovecamera: Preset = {
+};
+exports.preset_nomovecamera = {
     type: 'exclude', events: [
         'MoveCamera',
     ]
-}
-
-export const preset_noeffect_completely: Preset = {
+};
+exports.preset_noeffect_completely = {
     type: 'exclude', events: [
         "AddDecoration",
         "AddText",
@@ -73,13 +67,12 @@ export const preset_noeffect_completely: Preset = {
         "ScaleMargin",
         "ScaleRadius"
     ]
-}
-
-export const preset_inner_no_deco: Preset = {
+};
+exports.preset_inner_no_deco = {
     type: "special", events: [
         "MoveDecorations",
         "SetText",
         "SetObject",
         "SetDefaultText"
     ]
-}
+};

package/dist/src/structure/Level.d.ts

@@ -0,0 +1,54 @@
+import { AdofaiEvent, LevelOptions, Tile, ParseProvider } from './interfaces';
+export declare class Level {
+    private _events;
+    private guidCallbacks;
+    private guidCounter;
+    private _options;
+    private _provider?;
+    angleData: number[];
+    actions: AdofaiEvent[];
+    settings: Record<string, any>;
+    __decorations: AdofaiEvent[];
+    tiles: Tile[];
+    private _angleDir;
+    private _twirlCount;
+    constructor(opt: string | LevelOptions, provider?: ParseProvider);
+    generateGUID(): string;
+    load(): Promise<boolean>;
+    on(eventName: string, callback: Function): string;
+    trigger(eventName: string, data: any): void;
+    off(guid: string): void;
+    private _createArray;
+    private _changeAngle;
+    private _parsechangedAngle;
+    private _filterByFloor;
+    private _flattenAngleDatas;
+    private _flattenActionsWithFloor;
+    private _filterByFloorwithDeco;
+    private _flattenDecorationsWithFloor;
+    private _parseAngle;
+    filterActionsByEventType(en: string): {
+        index: number;
+        action: AdofaiEvent;
+    }[];
+    getActionsByIndex(en: string, index: number): {
+        count: number;
+        actions: AdofaiEvent[];
+    };
+    calculateTileCoordinates(): void;
+    floorOperation(info?: {
+        type: 'append' | 'insert' | 'delete';
+        direction: number;
+        id?: number;
+    }): void;
+    appendFloor(args: {
+        direction: number;
+    }): void;
+    clearDeco(): boolean;
+    clearEffect(presetName: string): void;
+    clearEvent(preset: {
+        type: string;
+        events: string[];
+    }): void;
+    export(type: 'string' | 'object', indent?: number, useAdofaiStyle?: boolean): string | Record<string, any>;
+}

package/dist/src/structure/Level.js

@@ -0,0 +1,387 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Level = void 0;
+const pathdata_1 = __importDefault(require("../pathdata"));
+const format_1 = __importDefault(require("../format"));
+const parser_1 = __importDefault(require("../parser"));
+const effectProcessor_1 = __importDefault(require("../effectProcessor"));
+const presets = __importStar(require("../presets"));
+class Level {
+    constructor(opt, provider) {
+        this._events = new Map();
+        this.guidCallbacks = new Map();
+        this.guidCounter = 0;
+        this._options = opt;
+        this._provider = provider;
+    }
+    generateGUID() {
+        return `event_${Date.now()}_${this.guidCounter++}_${Math.floor(Math.random() * 1000)}`;
+    }
+    load() {
+        return new Promise((resolve, reject) => {
+            let opt = this._options;
+            let options;
+            switch (typeof opt) {
+                case 'string':
+                    try {
+                        options = parser_1.default.parseAsObject(opt, this._provider);
+                    }
+                    catch (e) {
+                        reject(e);
+                        return;
+                    }
+                    break;
+                case 'object':
+                    options = Object.assign({}, opt);
+                    break;
+                default:
+                    reject("Options must be String or Object");
+                    return;
+            }
+            if (options && typeof options === 'object' && options !== null && typeof options.pathData !== 'undefined') {
+                this.angleData = pathdata_1.default.parseToangleData(options['pathData']);
+            }
+            else {
+                if (options && typeof options === 'object' && options !== null && typeof options.angleData !== 'undefined') {
+                    this.angleData = options['angleData'];
+                }
+                else {
+                    reject("There is not any angle datas.");
+                    return;
+                }
+            }
+            if (options && typeof options === 'object' && options !== null && typeof options.actions !== 'undefined') {
+                this.actions = options['actions'];
+            }
+            else {
+                this.actions = [];
+            }
+            if (options && typeof options === 'object' && options !== null && typeof options.settings !== 'undefined') {
+                this.settings = options['settings'];
+            }
+            else {
+                reject("There is no ADOFAI settings.");
+                return;
+            }
+            if (options && typeof options === 'object' && options !== null && typeof options.decorations !== 'undefined') {
+                this.__decorations = options['decorations'];
+            }
+            else {
+                this.__decorations = [];
+            }
+            this.tiles = [];
+            this._angleDir = -180;
+            this._twirlCount = 0;
+            this._createArray(this.angleData.length, { angleData: this.angleData, actions: this.actions, decorations: this.__decorations })
+                .then(e => {
+                this.tiles = e;
+                this.trigger('load', this);
+                resolve(true);
+            }).catch(e => {
+                reject(e);
+            });
+        });
+    }
+    on(eventName, callback) {
+        if (!this._events.has(eventName)) {
+            this._events.set(eventName, []);
+        }
+        const guid = this.generateGUID();
+        const eventCallbacks = this._events.get(eventName);
+        eventCallbacks.push({ guid, callback });
+        this.guidCallbacks.set(guid, { eventName, callback });
+        return guid;
+    }
+    trigger(eventName, data) {
+        if (!this._events.has(eventName))
+            return;
+        const callbacks = this._events.get(eventName);
+        callbacks.forEach(({ callback }) => callback(data));
+    }
+    off(guid) {
+        if (!this.guidCallbacks.has(guid))
+            return;
+        const { eventName } = this.guidCallbacks.get(guid);
+        this.guidCallbacks.delete(guid);
+        if (!this._events.has(eventName))
+            return;
+        const callbacks = this._events.get(eventName);
+        const index = callbacks.findIndex(cb => cb.guid === guid);
+        if (index !== -1) {
+            callbacks.splice(index, 1);
+        }
+    }
+    _createArray(xLength, opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let m = Array.from({ length: xLength }, (_, i) => ({
+                direction: opt.angleData[i],
+                _lastdir: opt.angleData[i - 1] || 0,
+                actions: this._filterByFloor(opt.actions, i),
+                angle: this._parseAngle(opt.angleData, i, this._twirlCount % 2),
+                addDecorations: this._filterByFloorwithDeco(opt.decorations, i),
+                twirl: this._twirlCount,
+                extraProps: {}
+            }));
+            return m;
+        });
+    }
+    _changeAngle() {
+        let y = 0;
+        let m = this.tiles.map(t => {
+            y++;
+            t.angle = this._parsechangedAngle(t.direction, y, t.twirl, t._lastdir);
+            return t;
+        });
+        return m;
+    }
+    _parsechangedAngle(agd, i, isTwirl, lstagd) {
+        let prev = 0;
+        if (i === 0) {
+            this._angleDir = 180;
+        }
+        if (agd === 999) {
+            this._angleDir = lstagd;
+            if (isNaN(this._angleDir)) {
+                this._angleDir = 0;
+            }
+            prev = 0;
+        }
+        else {
+            if (isTwirl === 0) {
+                prev = (this._angleDir - agd) % 360;
+            }
+            else {
+                prev = 360 - (this._angleDir - agd) % 360;
+            }
+            if (prev === 0) {
+                prev = 360;
+            }
+            this._angleDir = agd + 180;
+        }
+        return prev;
+    }
+    _filterByFloor(arr, i) {
+        let actionT = arr.filter(item => item.floor === i);
+        this._twirlCount += actionT.filter(t => t.eventType === 'Twirl').length;
+        return actionT.map((_a) => {
+            var { floor } = _a, rest = __rest(_a, ["floor"]);
+            return rest;
+        });
+    }
+    _flattenAngleDatas(arr) {
+        return arr.map(item => item.direction);
+    }
+    _flattenActionsWithFloor(arr) {
+        return arr.map(item => item.actions).flat();
+    }
+    _filterByFloorwithDeco(arr, i) {
+        let actionT = arr.filter(item => item.floor === i);
+        return actionT.map((_a) => {
+            var { floor } = _a, rest = __rest(_a, ["floor"]);
+            return rest;
+        });
+    }
+    _flattenDecorationsWithFloor(arr) {
+        return arr.map(item => item.addDecorations).flat();
+    }
+    _parseAngle(agd, i, isTwirl) {
+        let prev = 0;
+        if (i === 0) {
+            this._angleDir = 180;
+        }
+        if (agd[i] === 999) {
+            this._angleDir = agd[i - 1];
+            if (isNaN(this._angleDir)) {
+                this._angleDir = 0;
+            }
+            prev = 0;
+        }
+        else {
+            if (isTwirl === 0) {
+                prev = (this._angleDir - agd[i]) % 360;
+            }
+            else {
+                prev = 360 - (this._angleDir - agd[i]) % 360;
+            }
+            if (prev === 0) {
+                prev = 360;
+            }
+            this._angleDir = agd[i] + 180;
+        }
+        return prev;
+    }
+    filterActionsByEventType(en) {
+        return Object.entries(this.tiles)
+            .flatMap(([index, a]) => (a.actions || []).map(b => ({ b, index })))
+            .filter(({ b }) => b.eventType === en)
+            .map(({ b, index }) => ({
+            index: Number(index),
+            action: b
+        }));
+    }
+    getActionsByIndex(en, index) {
+        const filtered = this.filterActionsByEventType(en);
+        const matches = filtered.filter(item => item.index === index);
+        return {
+            count: matches.length,
+            actions: matches.map(item => item.action)
+        };
+    }
+    calculateTileCoordinates() {
+        let angles = this.angleData;
+        let floats = [];
+        let startPos = [0, 0];
+        for (let i = 0; i < this.tiles.length; i++) {
+            let value = angles[i];
+            if (value === 999) {
+                value = angles[i - 1] + 180;
+            }
+            floats.push(value);
+        }
+        for (let i = 0; i <= floats.length; i++) {
+            let angle1 = Number((i === floats.length) ? floats[i - 1] : floats[i]) || 0;
+            let angle2 = Number((i === 0) ? 0 : floats[i - 1]) || 0;
+            let currentTile = this.tiles[i];
+            if (this.getActionsByIndex('PositionTrack', i).count > 0) {
+                let pevent = this.getActionsByIndex('PositionTrack', i).actions[0];
+                if (pevent.positionOffset) {
+                    if (pevent['editorOnly'] !== true && pevent['editorOnly'] !== 'Enabled') {
+                        startPos[0] += pevent['positionOffset'][0];
+                        startPos[1] += pevent['positionOffset'][1];
+                    }
+                }
+            }
+            startPos[0] += Math.cos(angle1 * Math.PI / 180);
+            startPos[1] += Math.sin(angle1 * Math.PI / 180);
+            if (typeof currentTile !== 'undefined') {
+                currentTile.position = [
+                    Number(startPos[0].toFixed(8)),
+                    Number(startPos[1].toFixed(8))
+                ];
+                currentTile.extraProps.angle1 = angle1;
+                currentTile.extraProps.angle2 = angle2 - 180;
+                currentTile.extraProps.cangle = i === floats.length ? floats[i - 1] + 180 : floats[i];
+            }
+        }
+    }
+    floorOperation(info = { type: 'append', direction: 0 }) {
+        switch (info.type) {
+            case 'append':
+                this.appendFloor(info);
+                break;
+            case 'insert':
+                if (typeof info.id === 'number') {
+                    this.tiles.splice(info.id, 0, {
+                        direction: info.direction || 0,
+                        angle: 0,
+                        actions: [],
+                        addDecorations: [],
+                        _lastdir: this.tiles[info.id - 1].direction,
+                        twirl: this.tiles[info.id - 1].twirl
+                    });
+                }
+                break;
+            case 'delete':
+                if (typeof info.id === 'number') {
+                    this.tiles.splice(info.id, 1);
+                }
+                break;
+        }
+        this._changeAngle();
+    }
+    appendFloor(args) {
+        this.tiles.push({
+            direction: args.direction,
+            angle: 0,
+            actions: [],
+            addDecorations: [],
+            _lastdir: this.tiles[this.tiles.length - 1].direction,
+            twirl: this.tiles[this.tiles.length - 1].twirl,
+            extraProps: {}
+        });
+        this._changeAngle();
+    }
+    clearDeco() {
+        this.tiles = effectProcessor_1.default.clearDecorations(this.tiles);
+        return true;
+    }
+    clearEffect(presetName) {
+        this.clearEvent(presets[presetName]);
+    }
+    clearEvent(preset) {
+        switch (preset.type) {
+            case 'include':
+                this.tiles = effectProcessor_1.default.keepEvents(preset.events, this.tiles);
+                break;
+            case 'exclude':
+                this.tiles = effectProcessor_1.default.clearEvents(preset.events, this.tiles);
+                break;
+        }
+    }
+    export(type, indent, useAdofaiStyle = true) {
+        const ADOFAI = {
+            angleData: this._flattenAngleDatas(this.tiles),
+            settings: this.settings,
+            actions: this._flattenActionsWithFloor(this.tiles),
+            decorations: this._flattenDecorationsWithFloor(this.tiles)
+        };
+        return type === 'object' ? ADOFAI : (0, format_1.default)(ADOFAI, indent, useAdofaiStyle);
+    }
+}
+exports.Level = Level;

package/{src/structure/interfaces.ts → dist/src/structure/interfaces.d.ts}

@@ -1,38 +1,33 @@
-export interface AdofaiEvent {
-    eventType: string;
-    [key: string]: any;
-}
-
-export interface LevelOptions {
-    pathData?: string;
-    angleData?: number[];
-    actions: AdofaiEvent[];
-    settings: Record<string, any>;
-    decorations: AdofaiEvent[];
-    [key: string]: any;
-}
-
-export interface EventCallback {
-    guid: string;
-    callback: Function;
-}
-
-export interface GuidCallback {
-    eventName: string;
-    callback: Function;
-}
-
-export interface Tile {
-    direction?: number;
-    angle?: number;
-    actions: AdofaiEvent[];
-    addDecorations?: AdofaiEvent[];
-    _lastdir?: number;
-    twirl?: number;
-    position?: number[];
-    extraProps?: Record<string, any>;
-}
-
-export interface ParseProvider {
-    parse(t: string): LevelOptions;
-}
+export interface AdofaiEvent {
+    eventType: string;
+    [key: string]: any;
+}
+export interface LevelOptions {
+    pathData?: string;
+    angleData?: number[];
+    actions: AdofaiEvent[];
+    settings: Record<string, any>;
+    decorations: AdofaiEvent[];
+    [key: string]: any;
+}
+export interface EventCallback {
+    guid: string;
+    callback: Function;
+}
+export interface GuidCallback {
+    eventName: string;
+    callback: Function;
+}
+export interface Tile {
+    direction?: number;
+    angle?: number;
+    actions: AdofaiEvent[];
+    addDecorations?: AdofaiEvent[];
+    _lastdir?: number;
+    twirl?: number;
+    position?: number[];
+    extraProps?: Record<string, any>;
+}
+export interface ParseProvider {
+    parse(t: string): LevelOptions;
+}