adofai 3.1.0 → 3.3.0

package/dist/src/parser/LargeFileParser.js

@@ -0,0 +1,382 @@
+const BOM = new Uint8Array([0xef, 0xbb, 0xbf]);
+function findAllPropertiesAtRoot(buffer) {
+    const result = new Map();
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    let propertyName = '';
+    let propertyNameStart = -1;
+    for (let i = 0; i < buffer.length; i++) {
+        const byte = buffer[i];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (byte === 92) {
+            escapeNext = true;
+            continue;
+        }
+        if (byte === 34) {
+            if (inString) {
+                inString = false;
+                if (depth === 1 && propertyNameStart !== -1) {
+                    const decoder = new TextDecoder('utf-8');
+                    propertyName = decoder.decode(buffer.slice(propertyNameStart, i));
+                }
+            }
+            else {
+                inString = true;
+                propertyNameStart = i + 1;
+            }
+            continue;
+        }
+        if (!inString) {
+            if (byte === 123) {
+                depth++;
+            }
+            else if (byte === 125) {
+                depth--;
+            }
+            else if (byte === 58 && depth === 1 && propertyName) {
+                let pos = i + 1;
+                while (pos < buffer.length && (buffer[pos] === 32 || buffer[pos] === 9 || buffer[pos] === 10 || buffer[pos] === 13)) {
+                    pos++;
+                }
+                result.set(propertyName, pos);
+                propertyName = '';
+                propertyNameStart = -1;
+            }
+        }
+    }
+    return result;
+}
+function findValueEnd(buffer, startPos) {
+    if (startPos >= buffer.length)
+        return -1;
+    const firstChar = buffer[startPos];
+    if (firstChar === 34) {
+        let i = startPos + 1;
+        let escapeNext = false;
+        while (i < buffer.length) {
+            if (escapeNext) {
+                escapeNext = false;
+                i++;
+                continue;
+            }
+            if (buffer[i] === 92) {
+                escapeNext = true;
+                i++;
+                continue;
+            }
+            if (buffer[i] === 34)
+                return i + 1;
+            i++;
+        }
+        return -1;
+    }
+    if (firstChar === 91 || firstChar === 123) {
+        const closeChar = firstChar === 91 ? 93 : 125;
+        let depth = 0;
+        let i = startPos;
+        let inString = false;
+        let escapeNext = false;
+        while (i < buffer.length) {
+            if (escapeNext) {
+                escapeNext = false;
+                i++;
+                continue;
+            }
+            if (buffer[i] === 92) {
+                escapeNext = true;
+                i++;
+                continue;
+            }
+            if (buffer[i] === 34) {
+                inString = !inString;
+                i++;
+                continue;
+            }
+            if (!inString) {
+                if (buffer[i] === firstChar) {
+                    depth++;
+                }
+                else if (buffer[i] === closeChar) {
+                    depth--;
+                    if (depth === 0)
+                        return i + 1;
+                }
+            }
+            i++;
+        }
+        return -1;
+    }
+    let i = startPos;
+    while (i < buffer.length) {
+        const byte = buffer[i];
+        if (byte === 44 || byte === 125 || byte === 93 || byte === 32 || byte === 9 || byte === 10 || byte === 13) {
+            return i;
+        }
+        i++;
+    }
+    return i;
+}
+function extractValueAsString(buffer, startPos, endPos) {
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(buffer.slice(startPos, endPos));
+}
+function parseNumberArrayIncremental(buffer, startPos, onProgress) {
+    if (startPos >= buffer.length || buffer[startPos] !== 91)
+        return null;
+    const values = [];
+    let i = startPos + 1;
+    let currentValue = '';
+    let depth = 1;
+    let inString = false;
+    let escapeNext = false;
+    let lastWasComma = false;
+    const totalLength = buffer.length;
+    while (i < buffer.length) {
+        const byte = buffer[i];
+        if (escapeNext) {
+            escapeNext = false;
+            i++;
+            continue;
+        }
+        if (byte === 92) {
+            escapeNext = true;
+            i++;
+            continue;
+        }
+        if (byte === 34) {
+            inString = !inString;
+            i++;
+            continue;
+        }
+        if (!inString) {
+            if (byte === 91) {
+                depth++;
+                i++;
+                lastWasComma = false;
+            }
+            else if (byte === 93) {
+                depth--;
+                if (depth === 0) {
+                    if (currentValue.trim() && !lastWasComma) {
+                        const num = Number(currentValue.trim());
+                        if (!isNaN(num))
+                            values.push(num);
+                    }
+                    return { values, endPos: i + 1 };
+                }
+                i++;
+                lastWasComma = false;
+            }
+            else if (byte === 44) {
+                if (currentValue.trim() && !lastWasComma) {
+                    const num = Number(currentValue.trim());
+                    if (!isNaN(num))
+                        values.push(num);
+                }
+                currentValue = '';
+                lastWasComma = true;
+                i++;
+            }
+            else if ((byte >= 48 && byte <= 57) || byte === 45 || byte === 46) {
+                currentValue += String.fromCharCode(byte);
+                lastWasComma = false;
+                i++;
+            }
+            else if (byte === 32 || byte === 9 || byte === 10 || byte === 13) {
+                i++;
+            }
+            else {
+                i++;
+            }
+        }
+        else {
+            i++;
+        }
+        if (onProgress && i % 5000000 === 0) {
+            onProgress(Math.round((i / totalLength) * 100));
+        }
+    }
+    return { values, endPos: i };
+}
+function parseObjectArrayIncremental(buffer, startPos, onProgress, maxObjects) {
+    if (startPos >= buffer.length || buffer[startPos] !== 91)
+        return null;
+    const values = [];
+    let i = startPos + 1;
+    let depth = 1;
+    let inString = false;
+    let escapeNext = false;
+    let objectStart = -1;
+    const totalLength = buffer.length;
+    let objectCount = 0;
+    while (i < buffer.length && (buffer[i] === 32 || buffer[i] === 9 || buffer[i] === 10 || buffer[i] === 13)) {
+        i++;
+    }
+    if (buffer[i] === 93) {
+        return { values: [], endPos: i + 1 };
+    }
+    while (i < buffer.length) {
+        const byte = buffer[i];
+        if (escapeNext) {
+            escapeNext = false;
+            i++;
+            continue;
+        }
+        if (byte === 92) {
+            escapeNext = true;
+            i++;
+            continue;
+        }
+        if (byte === 34) {
+            inString = !inString;
+            i++;
+            continue;
+        }
+        if (!inString) {
+            if (byte === 123) {
+                if (depth === 1 && objectStart === -1)
+                    objectStart = i;
+                depth++;
+                i++;
+            }
+            else if (byte === 125) {
+                depth--;
+                if (depth === 1 && objectStart !== -1) {
+                    try {
+                        const obj = JSON.parse(extractValueAsString(buffer, objectStart, i + 1));
+                        values.push(obj);
+                        objectCount++;
+                        if (maxObjects && objectCount >= maxObjects) {
+                            let searchPos = i + 1;
+                            while (searchPos < buffer.length && buffer[searchPos] !== 93)
+                                searchPos++;
+                            return { values, endPos: searchPos + 1 };
+                        }
+                    }
+                    catch (e) { /* skip malformed objects */ }
+                    objectStart = -1;
+                    if (onProgress && objectCount % 50000 === 0) {
+                        onProgress(Math.round((i / totalLength) * 100));
+                    }
+                }
+                i++;
+            }
+            else if (byte === 91) {
+                depth++;
+                i++;
+            }
+            else if (byte === 93) {
+                depth--;
+                if (depth === 0)
+                    return { values, endPos: i + 1 };
+                i++;
+            }
+            else {
+                i++;
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return { values, endPos: i };
+}
+export class LargeFileParser {
+    constructor(onProgress, options) {
+        var _a, _b;
+        this.skipLargeActions = false;
+        this.maxActions = 0;
+        this.onProgress = onProgress;
+        if (options) {
+            this.skipLargeActions = (_a = options.skipLargeActions) !== null && _a !== void 0 ? _a : false;
+            this.maxActions = (_b = options.maxActions) !== null && _b !== void 0 ? _b : 0;
+        }
+    }
+    parse(input) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        let view = new Uint8Array(input);
+        if (view.length >= 3 && view[0] === BOM[0] && view[1] === BOM[1] && view[2] === BOM[2]) {
+            view = view.subarray(3);
+        }
+        (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, 'scanning', 5);
+        const properties = findAllPropertiesAtRoot(view);
+        const angleDataPos = (_b = properties.get('angleData')) !== null && _b !== void 0 ? _b : -1;
+        const pathDataPos = (_c = properties.get('pathData')) !== null && _c !== void 0 ? _c : -1;
+        const settingsPos = (_d = properties.get('settings')) !== null && _d !== void 0 ? _d : -1;
+        const actionsPos = (_e = properties.get('actions')) !== null && _e !== void 0 ? _e : -1;
+        const decorationsPos = (_f = properties.get('decorations')) !== null && _f !== void 0 ? _f : -1;
+        const result = {};
+        if (settingsPos !== -1) {
+            (_g = this.onProgress) === null || _g === void 0 ? void 0 : _g.call(this, 'parsing_settings', 10);
+            const settingsEnd = findValueEnd(view, settingsPos);
+            if (settingsEnd !== -1) {
+                try {
+                    result.settings = JSON.parse(extractValueAsString(view, settingsPos, settingsEnd));
+                }
+                catch (e) {
+                    result.settings = {};
+                }
+            }
+        }
+        if (angleDataPos !== -1) {
+            (_h = this.onProgress) === null || _h === void 0 ? void 0 : _h.call(this, 'parsing_angleData', 15);
+            const angleResult = parseNumberArrayIncremental(view, angleDataPos, (p) => {
+                var _a;
+                (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, 'parsing_angleData', 15 + p * 0.25);
+            });
+            if (angleResult) {
+                result.angleData = angleResult.values;
+            }
+        }
+        if (pathDataPos !== -1) {
+            const pathEnd = findValueEnd(view, pathDataPos);
+            if (pathEnd !== -1) {
+                const pathStr = extractValueAsString(view, pathDataPos, pathEnd);
+                result.pathData = pathStr.slice(1, -1);
+            }
+        }
+        if (actionsPos !== -1) {
+            const actionsEnd = findValueEnd(view, actionsPos);
+            const actionsSize = actionsEnd - actionsPos;
+            (_j = this.onProgress) === null || _j === void 0 ? void 0 : _j.call(this, 'parsing_actions', 50);
+            if (actionsSize > 100 * 1024 * 1024 && this.skipLargeActions) {
+                result.actions = [];
+            }
+            else if (actionsSize > 50 * 1024 * 1024) {
+                const actionsResult = parseObjectArrayIncremental(view, actionsPos, (p) => { var _a; return (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, 'parsing_actions', 50 + p * 0.45); }, this.maxActions || undefined);
+                if (actionsResult)
+                    result.actions = actionsResult.values;
+            }
+            else {
+                try {
+                    result.actions = JSON.parse(extractValueAsString(view, actionsPos, actionsEnd));
+                }
+                catch (e) {
+                    result.actions = [];
+                }
+            }
+        }
+        if (decorationsPos !== -1) {
+            (_k = this.onProgress) === null || _k === void 0 ? void 0 : _k.call(this, 'parsing_decorations', 95);
+            const decorationsEnd = findValueEnd(view, decorationsPos);
+            if (decorationsEnd !== -1) {
+                try {
+                    result.decorations = JSON.parse(extractValueAsString(view, decorationsPos, decorationsEnd));
+                }
+                catch (e) {
+                    result.decorations = [];
+                }
+            }
+        }
+        (_l = this.onProgress) === null || _l === void 0 ? void 0 : _l.call(this, 'complete', 100);
+        return result;
+    }
+    stringify(obj) {
+        return JSON.stringify(obj);
+    }
+}
+export default LargeFileParser;

package/dist/src/parser.d.ts

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

package/dist/src/parser.js

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

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

@@ -1,8 +1,5 @@
-interface PathDataTable {
-    [key: string]: number;
-}
 declare const _default: {
-    pathDataTable: PathDataTable;
+    pathDataTable: Record<string, number>;
     parseToangleData: (pathdata: string) => number[];
 };
 export default _default;

package/dist/src/pathdata/index.js

@@ -1,5 +1,48 @@
-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 };
-const parseToangleData = (pathdata) => Array.from(pathdata).map(t => pathDataTable[t]);
+/** Standard direction characters → absolute angle */
+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, "!": 999
+};
+/**
+ * Special offset characters — these are NOT absolute angles.
+ * Instead, they represent a relative change from the previous angle:
+ *   result = previous_angle + offset
+ */
+const offsetMap = {
+    "5": 72,
+    "6": -72,
+    "7": 52,
+    "8": -52,
+    "9": -30,
+    "h": 120,
+    "j": -120,
+    "t": 60,
+    "y": 300,
+};
+const parseToangleData = (pathdata) => {
+    const result = new Array(pathdata.length);
+    let prev = 0;
+    for (let i = 0; i < pathdata.length; i++) {
+        const c = pathdata[i];
+        if (c in pathDataTable) {
+            // Standard character: absolute angle
+            result[i] = pathDataTable[c];
+            prev = pathDataTable[c];
+        }
+        else if (c in offsetMap) {
+            // Special character: relative offset from previous angle
+            result[i] = prev + offsetMap[c];
+            prev = result[i];
+        }
+        else {
+            // Unknown character: keep current angle
+            result[i] = prev;
+        }
+    }
+    return result;
+};
 export default {
     pathDataTable,
     parseToangleData

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

@@ -10,8 +10,6 @@ export declare class Level {
     settings: Record<string, any>;
     __decorations: AdofaiEvent[];
     tiles: Tile[];
-    private _angleDir;
-    private _twirlCount;
     /** 预计算的事件缓存 */
     private _precomputedEvents;
     /** 是否启用预计算模式 */
@@ -20,68 +18,21 @@ export declare class Level {
     private _lightweightData;
     constructor(opt: string | LevelOptions, provider?: ParseProvider);
     generateGUID(): string;
-    /**
-     * 触发进度事件
-     */
     private _emitProgress;
-    /**
-     * 启用预计算模式 - 在 load() 和 calculateTilePosition() 过程中不触发事件，
-     * 而是将所有事件缓存起来，之后可以通过 getPrecomputedEvents() 获取
-     */
     enablePrecomputeMode(): void;
-    /**
-     * 禁用预计算模式
-     */
     disablePrecomputeMode(): void;
-    /**
-     * 获取预计算的事件缓存
-     * 返回所有缓存的进度事件，可以用于渲染器按帧播放
-     */
     getPrecomputedEvents(): PrecomputedProgressEvents | null;
-    /**
-     * 清除预计算的事件缓存
-     */
     clearPrecomputedEvents(): void;
-    /**
-     * 按进度百分比获取事件（用于渲染器按帧渲染）
-     * @param percent 0-100 的百分比
-     * @param stage 可选，指定阶段
-     */
     getEventsAtPercent(percent: number, stage?: ParseProgressEvent['stage']): ParseProgressEvent[];
-    /**
-     * 获取指定阶段的总事件数
-     */
     getPrecomputedEventCount(stage?: ParseProgressEvent['stage']): number;
-    /**
-     * 获取轻量级预计算数据
-     * 只包含渲染必需的数据：angles, positions, twirlFlags
-     * 内存占用极低，适合大物量谱面
-     */
     getLightweightData(): LightweightPrecomputedData | null;
-    /**
-     * 轻量级预计算 - 只计算渲染必需的数据
-     * 不存储完整的 tile 对象，极大减少内存占用
-     *
-     * @param skipPositionCalculation 是否跳过坐标计算（如果只需要角度数据）
-     */
     precomputeLightweight(skipPositionCalculation?: boolean): LightweightPrecomputedData;
-    /**
-     * 获取指定范围内的轻量级渲染数据（分片获取，避免一次性加载全部）
-     * @param startIndex 起始索引
-     * @param count 数量
-     */
     getLightweightDataRange(startIndex: number, count: number): {
         angles: number[];
         positions: [number, number][];
         twirlFlags: boolean[];
     } | null;
-    /**
-     * 清除轻量级预计算数据
-     */
     clearLightweightData(): void;
-    /**
-     * 获取单个 tile 的渲染数据（按需获取，不预加载全部）
-     */
     getTileRenderData(index: number): {
         angle: number;
         position: [number, number] | null;
@@ -91,16 +42,6 @@ export declare class Level {
     on(eventName: string, callback: Function): string;
     trigger(eventName: string, data: any): void;
     off(guid: string): void;
-    private _createArray;
-    private _changeAngle;
-    private _normalizeAngle;
-    private _parsechangedAngle;
-    private _filterByFloor;
-    private _flattenAngleDatas;
-    private _flattenActionsWithFloor;
-    private _filterByFloorwithDeco;
-    private _flattenDecorationsWithFloor;
-    private _parseAngle;
     filterActionsByEventType(en: string): {
         index: number;
         action: ActionData;
@@ -110,12 +51,6 @@ export declare class Level {
         actions: ActionData[];
     };
     calculateTileCoordinates(): void;
-    /**
-     * 计算所有 Tile 的坐标位置
-     * 触发 parse:tilePosition 和 parse:progress 事件报告进度
-     *
-     * 性能优化：预先构建 PositionTrack 索引，避免循环内重复遍历
-     */
     calculateTilePosition(): number[][];
     floorOperation(info?: {
         type: 'append' | 'insert' | 'delete';