adofai 3.2.0 → 3.3.0

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';

package/dist/src/structure/Level.js

@@ -1,27 +1,9 @@
-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 pathData from '../pathdata';
 import exportAsADOFAI from './format';
 import effectProcessor from '../filter/effectProcessor';
 import { EffectCleanerType } from '../filter/effectProcessor';
+import * as presets from '../filter/presets';
+import { createTiles, changeAngles, filterActionsByEventType as filterActions, getActionsByIndex as getActions, calculateTilePositions, precomputePositions, flattenAngleDatas, flattenActionsWithFloor, flattenDecorationsWithFloor } from './levelAngle';
 function uuid() {
     var _a;
     const r = new Uint8Array(16);
@@ -42,7 +24,6 @@ function uuid() {
         + h(r[8]) + h(r[9]) + '-'
         + h(r[10]) + h(r[11]) + h(r[12]) + h(r[13]) + h(r[14]) + h(r[15]);
 }
-import * as presets from '../filter/presets';
 export class Level {
     constructor(opt, provider) {
         /** 预计算的事件缓存 */
@@ -59,9 +40,6 @@ export class Level {
     generateGUID() {
         return `event_${uuid()}`;
     }
-    /**
-     * 触发进度事件
-     */
     _emitProgress(stage, current, total, data) {
         const progressEvent = {
             stage,
@@ -70,7 +48,6 @@ export class Level {
             percent: total > 0 ? Math.round((current / total) * 100) : 0,
             data
         };
-        // 如果是预计算模式，存储事件而不是触发
         if (this._precomputeMode && this._precomputedEvents) {
             this._precomputedEvents[stage].push(progressEvent);
         }
@@ -79,10 +56,6 @@ export class Level {
             this.trigger(`parse:${stage}`, progressEvent);
         }
     }
-    /**
-     * 启用预计算模式 - 在 load() 和 calculateTilePosition() 过程中不触发事件，
-     * 而是将所有事件缓存起来，之后可以通过 getPrecomputedEvents() 获取
-     */
     enablePrecomputeMode() {
         this._precomputeMode = true;
         this._precomputedEvents = {
@@ -94,30 +67,15 @@ export class Level {
             complete: []
         };
     }
-    /**
-     * 禁用预计算模式
-     */
     disablePrecomputeMode() {
         this._precomputeMode = false;
     }
-    /**
-     * 获取预计算的事件缓存
-     * 返回所有缓存的进度事件，可以用于渲染器按帧播放
-     */
     getPrecomputedEvents() {
         return this._precomputedEvents;
     }
-    /**
-     * 清除预计算的事件缓存
-     */
     clearPrecomputedEvents() {
         this._precomputedEvents = null;
     }
-    /**
-     * 按进度百分比获取事件（用于渲染器按帧渲染）
-     * @param percent 0-100 的百分比
-     * @param stage 可选，指定阶段
-     */
     getEventsAtPercent(percent, stage) {
         if (!this._precomputedEvents)
             return [];
@@ -127,9 +85,7 @@ export class Level {
             const events = this._precomputedEvents[s];
             for (const event of events) {
                 if (event.percent <= percent) {
-                    // 获取不超过目标百分比的最后一个事件
                     if (result.length === 0 || result[result.length - 1].percent <= event.percent) {
-                        // 避免重复添加相同百分比的事件
                         const lastEvent = result[result.length - 1];
                         if (!lastEvent || lastEvent.stage !== event.stage || lastEvent.current !== event.current) {
                             result.push(event);
@@ -140,81 +96,31 @@ export class Level {
         }
         return result;
     }
-    /**
-     * 获取指定阶段的总事件数
-     */
     getPrecomputedEventCount(stage) {
         if (!this._precomputedEvents)
             return 0;
-        if (stage) {
+        if (stage)
             return this._precomputedEvents[stage].length;
-        }
         return Object.values(this._precomputedEvents).reduce((sum, arr) => sum + arr.length, 0);
     }
-    /**
-     * 获取轻量级预计算数据
-     * 只包含渲染必需的数据：angles, positions, twirlFlags
-     * 内存占用极低，适合大物量谱面
-     */
     getLightweightData() {
         return this._lightweightData;
     }
-    /**
-     * 轻量级预计算 - 只计算渲染必需的数据
-     * 不存储完整的 tile 对象，极大减少内存占用
-     *
-     * @param skipPositionCalculation 是否跳过坐标计算（如果只需要角度数据）
-     */
     precomputeLightweight(skipPositionCalculation = false) {
         var _a, _b;
         const totalTiles = this.tiles.length;
-        // 预分配数组
         const angles = new Array(totalTiles);
         const positions = skipPositionCalculation ? [] : new Array(totalTiles);
         const twirlFlags = new Array(totalTiles);
-        // 提取角度和 twirl 标记
         for (let i = 0; i < totalTiles; i++) {
             const tile = this.tiles[i];
             angles[i] = (_a = tile.angle) !== null && _a !== void 0 ? _a : 0;
             twirlFlags[i] = ((_b = tile.twirl) !== null && _b !== void 0 ? _b : 0) % 2 === 1;
         }
-        // 计算坐标（如果需要）
         if (!skipPositionCalculation) {
-            const startPos = [0, 0];
-            const angleData = this.angleData;
-            // 预构建 PositionTrack 索引
-            const positionTrackMap = new Map();
-            for (const action of this.actions) {
-                if (action.eventType === 'PositionTrack' && action.positionOffset) {
-                    if (action.editorOnly !== true && action.editorOnly !== 'Enabled') {
-                        positionTrackMap.set(action.floor, action);
-                    }
-                }
-            }
+            const result = precomputePositions(this.angleData, totalTiles, this.actions);
             for (let i = 0; i < totalTiles; i++) {
-                // 处理 PositionTrack
-                const posTrack = positionTrackMap.get(i);
-                if (posTrack === null || posTrack === void 0 ? void 0 : posTrack.positionOffset) {
-                    startPos[0] += posTrack.positionOffset[0];
-                    startPos[1] += posTrack.positionOffset[1];
-                }
-                positions[i] = [startPos[0], startPos[1]];
-                // 计算下一个位置（向前回溯连续999）
-                let angle;
-                if (angleData[i] === 999) {
-                    let minus = 1;
-                    while (i - minus >= 0 && angleData[i - minus] === 999) {
-                        minus++;
-                    }
-                    const realAngle = i - minus >= 0 ? angleData[i - minus] : 0;
-                    angle = realAngle + (minus - 1) * 180;
-                }
-                else {
-                    angle = angleData[i];
-                }
-                const rad = angle * Math.PI / 180;
-                startPos[0] += Math.cos(rad);
-                startPos[1] += Math.sin(rad);
+                positions[i] = result.positions[i];
             }
         }
         this._lightweightData = {
@@ -226,11 +132,6 @@ export class Level {
         };
         return this._lightweightData;
     }
-    /**
-     * 获取指定范围内的轻量级渲染数据（分片获取，避免一次性加载全部）
-     * @param startIndex 起始索引
-     * @param count 数量
-     */
     getLightweightDataRange(startIndex, count) {
         if (!this._lightweightData)
             return null;
@@ -241,15 +142,9 @@ export class Level {
             twirlFlags: this._lightweightData.twirlFlags.slice(startIndex, end)
         };
     }
-    /**
-     * 清除轻量级预计算数据
-     */
     clearLightweightData() {
         this._lightweightData = null;
     }
-    /**
-     * 获取单个 tile 的渲染数据（按需获取，不预加载全部）
-     */
     getTileRenderData(index) {
         var _a, _b;
         if (index < 0 || index >= this.tiles.length)
@@ -273,7 +168,6 @@ export class Level {
             if (typeof opt === 'string' || isArrayBuffer || isUint8Array || isBuffer) {
                 try {
                     let input = isArrayBuffer ? new Uint8Array(opt) : opt;
-                    // 确保此时 input 是 string, Uint8Array 或 Buffer
                     options = (_a = this._provider) === null || _a === void 0 ? void 0 : _a.parse(input);
                 }
                 catch (e) {
@@ -288,15 +182,12 @@ export class Level {
                 reject("Options must be String, Buffer, ArrayBuffer or Object");
                 return;
             }
-            // 阶段2: 处理 pathData 或 angleData
             const hasPathData = options && typeof options === 'object' && options !== null && typeof options.pathData !== 'undefined';
             const hasAngleData = options && typeof options === 'object' && options !== null && typeof options.angleData !== 'undefined';
             if (hasPathData) {
                 const pathDataStr = options['pathData'];
-                // 开始转换 pathData
                 this._emitProgress('pathData', 0, pathDataStr.length, { source: pathDataStr });
                 this.angleData = pathData.parseToangleData(pathDataStr);
-                // 转换完成，返回结果
                 this._emitProgress('pathData', pathDataStr.length, pathDataStr.length, {
                     source: pathDataStr,
                     processed: this.angleData
@@ -312,7 +203,6 @@ export class Level {
                 reject("There is not any angle datas.");
                 return;
             }
-            // 阶段3: 提取其他数据
             if (options && typeof options === 'object' && options !== null && Array.isArray(options.actions)) {
                 this.actions = options['actions'];
             }
@@ -333,11 +223,16 @@ export class Level {
                 this.__decorations = [];
             }
             this.tiles = [];
-            this._angleDir = -180;
-            this._twirlCount = 0;
-            // 阶段4: 创建 Tile 数组（带进度回调）
-            this._createArray(this.angleData.length, { angleData: this.angleData, actions: this.actions, decorations: this.__decorations })
-                .then(e => {
+            let twirlCount = 0;
+            createTiles(this.angleData.length, {
+                angleData: this.angleData,
+                actions: this.actions,
+                decorations: this.__decorations
+            }, {
+                onProgress: (stage, current, total, data) => this._emitProgress(stage, current, total, data),
+                onTwirl: (count) => { twirlCount = count; },
+                getTwirl: () => twirlCount,
+            }).then(e => {
                 this.tiles = e;
                 this._emitProgress('complete', this.angleData.length, this.angleData.length);
                 this.trigger('load', this);
@@ -376,284 +271,17 @@ export class Level {
             callbacks.splice(index, 1);
         }
     }
-    _createArray(xLength, opt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tiles = new Array(xLength);
-            const batchSize = Math.max(100, Math.floor(xLength / 100)); // 每批处理的数量，提高最小批量
-            // 性能优化：预先按 floor 分组 actions 和 decorations
-            const actionsByFloor = new Map();
-            if (Array.isArray(opt.actions)) {
-                for (const action of opt.actions) {
-                    if (!actionsByFloor.has(action.floor)) {
-                        actionsByFloor.set(action.floor, []);
-                    }
-                    actionsByFloor.get(action.floor).push(action);
-                }
-            }
-            const decorationsByFloor = new Map();
-            if (Array.isArray(opt.decorations)) {
-                for (const deco of opt.decorations) {
-                    if (!decorationsByFloor.has(deco.floor)) {
-                        decorationsByFloor.set(deco.floor, []);
-                    }
-                    decorationsByFloor.get(deco.floor).push(deco);
-                }
-            }
-            for (let i = 0; i < xLength; i++) {
-                // 从 Map 中直接获取当前 floor 的 actions
-                const floorActions = actionsByFloor.get(i) || [];
-                const floorDecos = decorationsByFloor.get(i) || [];
-                // 更新 _twirlCount
-                for (const action of floorActions) {
-                    if (action.eventType === 'Twirl') {
-                        this._twirlCount++;
-                    }
-                }
-                // 计算相对角度
-                const angle = this._parseAngle(opt.angleData, i, this._twirlCount % 2);
-                // 移除 floor 属性并创建 tile
-                const tileActions = floorActions.map((_a) => {
-                    var { floor } = _a, rest = __rest(_a, ["floor"]);
-                    return rest;
-                });
-                const tileDecos = floorDecos.map((_a) => {
-                    var { floor } = _a, rest = __rest(_a, ["floor"]);
-                    return rest;
-                });
-                tiles[i] = {
-                    direction: opt.angleData[i],
-                    _lastdir: opt.angleData[i - 1] || 0,
-                    actions: tileActions,
-                    angle: angle,
-                    addDecorations: tileDecos,
-                    twirl: this._twirlCount,
-                    extraProps: {}
-                };
-                // 降低进度汇报和让出循环的频率
-                if (i % batchSize === 0 || i === xLength - 1) {
-                    this._emitProgress('relativeAngle', i + 1, xLength, {
-                        tileIndex: i,
-                        angle: opt.angleData[i],
-                        relativeAngle: angle
-                    });
-                    // 每 10% 让出一次，或者对于超大谱面增加频率
-                    if (i % (batchSize * 10) === 0) {
-                        yield new Promise(r => setTimeout(r, 0));
-                    }
-                }
-            }
-            return tiles;
-        });
-    }
-    _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;
-    }
-    _normalizeAngle(v) {
-        return ((v % 360) + 360) % 360;
-    }
-    _parsechangedAngle(agd, i, isTwirl, lstagd) {
-        var _a;
-        let prev = 0;
-        if (i === 0) {
-            this._angleDir = 180;
-        }
-        if (agd === 999) {
-            // 向前回溯（1-based i → tiles 0-based index: i-1 是当前tile）
-            let minus = 1;
-            while (i - minus - 1 >= 0 && ((_a = this.tiles[i - minus - 1]) === null || _a === void 0 ? void 0 : _a.direction) === 999) {
-                minus++;
-            }
-            const realAngle = i - minus - 1 >= 0 ? this.tiles[i - minus - 1].direction : 0;
-            this._angleDir = this._normalizeAngle(realAngle + (minus - 1) * 180);
-            if (isNaN(this._angleDir)) {
-                this._angleDir = 0;
-            }
-            prev = 0;
-        }
-        else {
-            const delta = this._normalizeAngle(this._angleDir - agd);
-            if (isTwirl === 0) {
-                prev = delta;
-            }
-            else {
-                prev = this._normalizeAngle(360 - delta);
-            }
-            if (prev === 0) {
-                prev = 360;
-            }
-            this._angleDir = this._normalizeAngle(agd + 180);
-        }
-        return prev;
-    }
-    _filterByFloor(arr, i) {
-        if (!Array.isArray(arr))
-            return [];
-        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.flatMap((tile, index) => (Array.isArray(tile === null || tile === void 0 ? void 0 : tile.actions) ? tile.actions : []).map((_a) => {
-            var { floor } = _a, rest = __rest(_a, ["floor"]);
-            return (Object.assign({ floor: index }, rest));
-        }));
-    }
-    _filterByFloorwithDeco(arr, i) {
-        if (!Array.isArray(arr))
-            return [];
-        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.flatMap((tile, index) => (Array.isArray(tile === null || tile === void 0 ? void 0 : tile.addDecorations) ? tile.addDecorations : []).map((_a) => {
-            var { floor } = _a, rest = __rest(_a, ["floor"]);
-            return (Object.assign({ floor: index }, rest));
-        }));
-    }
-    _parseAngle(agd, i, isTwirl) {
-        let prev = 0;
-        if (i === 0) {
-            this._angleDir = 180;
-        }
-        if (agd[i] === 999) {
-            // 向前回溯，找到第一个非999的真实角度
-            let minus = 1;
-            while (i - minus >= 0 && agd[i - minus] === 999) {
-                minus++;
-            }
-            const realAngle = i - minus >= 0 ? agd[i - minus] : 0;
-            this._angleDir = this._normalizeAngle(realAngle + (minus - 1) * 180);
-            if (isNaN(this._angleDir)) {
-                this._angleDir = 0;
-            }
-            prev = 0;
-        }
-        else {
-            const delta = this._normalizeAngle(this._angleDir - agd[i]);
-            if (isTwirl === 0) {
-                prev = delta;
-            }
-            else {
-                prev = this._normalizeAngle(360 - delta);
-            }
-            if (prev === 0) {
-                prev = 360;
-            }
-            this._angleDir = this._normalizeAngle(agd[i] + 180);
-        }
-        return prev;
-    }
     filterActionsByEventType(en) {
-        return Object.entries(this.tiles)
-            .flatMap(([index, a]) => (Array.isArray(a.actions) ? a.actions : []).map(b => ({ b, index })))
-            .filter(({ b }) => b.eventType === en)
-            .map(({ b, index }) => ({
-            index: Number(index),
-            action: b
-        }));
+        return filterActions(this.tiles, en);
     }
     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)
-        };
+        return getActions(this.tiles, en, index);
     }
     calculateTileCoordinates() {
         console.warn("calculateTileCoordinates is deprecated. Use calculateTilePosition instead.");
     }
-    /**
-     * 计算所有 Tile 的坐标位置
-     * 触发 parse:tilePosition 和 parse:progress 事件报告进度
-     *
-     * 性能优化：预先构建 PositionTrack 索引，避免循环内重复遍历
-     */
     calculateTilePosition() {
-        const angles = this.angleData;
-        const totalTiles = this.tiles.length;
-        const positions = [];
-        const startPos = [0, 0];
-        // 性能优化：预先构建 PositionTrack 索引 Map，O(n) 预处理
-        const positionTrackMap = new Map();
-        for (const action of this.actions) {
-            if (action.eventType === 'PositionTrack' && action.positionOffset) {
-                if (action.editorOnly !== true && action.editorOnly !== 'Enabled') {
-                    positionTrackMap.set(action.floor, action);
-                }
-            }
-        }
-        // 触发开始事件
-        this._emitProgress('tilePosition', 0, totalTiles);
-        // 预处理 floats 数组（向前回溯连续999）
-        const floats = new Array(totalTiles);
-        for (let i = 0; i < totalTiles; i++) {
-            if (angles[i] === 999) {
-                let minus = 1;
-                while (i - minus >= 0 && angles[i - minus] === 999) {
-                    minus++;
-                }
-                const realAngle = i - minus >= 0 ? angles[i - minus] : 0;
-                floats[i] = realAngle + (minus - 1) * 180;
-            }
-            else {
-                floats[i] = angles[i];
-            }
-        }
-        // 进度事件触发频率：每 1% 或最少每 100 个 tile 触发一次
-        const progressInterval = Math.max(100, Math.floor(totalTiles / 100));
-        for (let i = 0; i <= totalTiles; i++) {
-            const isLastTile = i === totalTiles;
-            const angle1 = isLastTile ? (floats[i - 1] || 0) : floats[i];
-            const angle2 = i === 0 ? 0 : (floats[i - 1] || 0);
-            const currentTile = this.tiles[i];
-            // 使用索引 Map 直接查询，O(1) 复杂度
-            const posTrack = positionTrackMap.get(i);
-            if (posTrack === null || posTrack === void 0 ? void 0 : posTrack.positionOffset) {
-                startPos[0] += posTrack.positionOffset[0];
-                startPos[1] += posTrack.positionOffset[1];
-            }
-            const tempPos = [startPos[0], startPos[1]];
-            positions.push(tempPos);
-            if (currentTile) {
-                currentTile.position = tempPos;
-                currentTile.extraProps.angle1 = angle1;
-                currentTile.extraProps.angle2 = angle2 - 180;
-                currentTile.extraProps.cangle = isLastTile ? floats[i - 1] + 180 : floats[i];
-            }
-            // 更新位置
-            const rad = angle1 * Math.PI / 180;
-            startPos[0] += Math.cos(rad);
-            startPos[1] += Math.sin(rad);
-            // 触发进度事件（降低频率，轻量级数据）
-            if (i % progressInterval === 0 || isLastTile) {
-                this._emitProgress('tilePosition', i, totalTiles, {
-                    tileIndex: i,
-                    position: [tempPos[0], tempPos[1]],
-                    angle: angle1
-                });
-            }
-        }
-        // 触发完成事件
-        this._emitProgress('tilePosition', totalTiles, totalTiles, {
-            processed: positions.flat()
-        });
-        return positions;
+        return calculateTilePositions(this.angleData, this.tiles, this.actions, (stage, current, total, data) => this._emitProgress(stage, current, total, data));
     }
     floorOperation(info = { type: 'append', direction: 0 }) {
         switch (info.type) {
@@ -678,7 +306,7 @@ export class Level {
                 }
                 break;
         }
-        this._changeAngle();
+        changeAngles(this.tiles);
     }
     appendFloor(args) {
         this.tiles.push({
@@ -690,7 +318,7 @@ export class Level {
             twirl: this.tiles[this.tiles.length - 1].twirl,
             extraProps: {}
         });
-        this._changeAngle();
+        changeAngles(this.tiles);
     }
     clearDeco() {
         this.tiles = effectProcessor.clearDecorations(this.tiles);
@@ -709,10 +337,10 @@ export class Level {
     }
     export(type, indent, useAdofaiStyle = true, indentChar, indentStep) {
         const ADOFAI = {
-            angleData: this._flattenAngleDatas(this.tiles),
+            angleData: flattenAngleDatas(this.tiles),
             settings: this.settings,
-            actions: this._flattenActionsWithFloor(this.tiles),
-            decorations: this._flattenDecorationsWithFloor(this.tiles)
+            actions: flattenActionsWithFloor(this.tiles),
+            decorations: flattenDecorationsWithFloor(this.tiles)
         };
         return type === 'object' ? ADOFAI : exportAsADOFAI(ADOFAI, indent, useAdofaiStyle, indentChar, indentStep);
     }