sonolus-next-rush-plus-engine 1.5.8 → 1.5.9

package/dist/extended/convert.d.ts

@@ -1,7 +1,13 @@
 import { type LevelData } from '@sonolus/core';
+type ExtendedEntityDataField = {
+    name: string;
+    value?: number;
+    ref?: string;
+};
 export type ExtendedEntityData = {
     archetype: string;
-    data: Record<string, number | string>;
+    name?: string;
+    data: ExtendedEntityDataField[];
 };
 export type ExtendedLevelData = {
     bgmOffset: number;
@@ -9,3 +15,4 @@ export type ExtendedLevelData = {
 };
 /** Convert a PJSekaiExtendedLevelData to a Level Data (Next Sekai) */
 export declare const extendedToLevelData: (data: ExtendedLevelData, offset?: number) => LevelData;
+export {};

package/dist/extended/convert.js

@@ -82,43 +82,87 @@ const guideKindMapping = {
     6: ConnectorKind.GUIDE_CYAN,
     7: ConnectorKind.GUIDE_BLACK,
 };
+/** data 배열 → 평탄한 Record로 변환 (value → number, ref → string) */
+const flattenData = (fields) => {
+    const result = {};
+    for (const field of fields) {
+        if (field.value !== undefined)
+            result[field.name] = field.value;
+        else if (field.ref !== undefined)
+            result[field.name] = field.ref;
+    }
+    return result;
+};
+/** 숫자 값 읽기 */
 const getNum = (data, key, defaultValue = 0) => {
     const val = data[key];
-    if (val === undefined || val === null)
-        return defaultValue;
-    const n = Number(val);
-    return isNaN(n) ? defaultValue : n;
+    if (typeof val === 'number')
+        return val;
+    if (typeof val === 'string') {
+        const n = Number(val);
+        return isNaN(n) ? defaultValue : n;
+    }
+    return defaultValue;
+};
+/** 참조 값 읽기 (number | string) */
+const getEntityRef = (data, key) => {
+    const val = data[key];
+    if (val === undefined)
+        return undefined;
+    return val;
+};
+/** 참조로 FlatEntity 조회 (number → 인덱스, string → 이름) */
+const resolveEntity = (ref, entities, entitiesByName) => {
+    if (typeof ref === 'number')
+        return entities[ref];
+    return entitiesByName.get(ref);
 };
 /** Convert a PJSekaiExtendedLevelData to a Level Data (Next Sekai) */
 export const extendedToLevelData = (data, offset = 0) => {
+    const flatEntities = data.entities.map((e) => ({
+        archetype: e.archetype,
+        name: e.name,
+        data: flattenData(e.data),
+    }));
+    const entitiesByName = new Map();
+    for (const entity of flatEntities) {
+        if (entity.name)
+            entitiesByName.set(entity.name, entity);
+    }
+    const resolve = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        return resolveEntity(ref, flatEntities, entitiesByName);
+    };
     const allIntermediateEntities = [];
     const createIntermediate = (archetype, entityData) => {
-        const intermediateEntity = { archetype, data: entityData };
-        allIntermediateEntities.push(intermediateEntity);
-        return intermediateEntity;
+        const entity = { archetype, data: entityData };
+        allIntermediateEntities.push(entity);
+        return entity;
     };
     createIntermediate('Initialization', {});
-    for (const entity of data.entities) {
-        if (entity.archetype === '#BPM_CHANGE') {
-            createIntermediate('#BPM_CHANGE', {
-                '#BEAT': getNum(entity.data, '#BEAT'),
-                '#BPM': getNum(entity.data, '#BPM'),
-            });
-        }
+    for (const entity of flatEntities) {
+        if (entity.archetype !== '#BPM_CHANGE')
+            continue;
+        createIntermediate('#BPM_CHANGE', {
+            '#BEAT': getNum(entity.data, '#BEAT'),
+            '#BPM': getNum(entity.data, '#BPM'),
+        });
     }
     const timescaleGroupsByIndex = new Map();
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
+    const timescaleGroupsByName = new Map();
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
         if (entity.archetype !== 'TimeScaleGroup')
             continue;
         const groupIntermediate = createIntermediate('TimeScaleGroup', {});
         timescaleGroupsByIndex.set(i, groupIntermediate);
-        let rawChangeIdx = getNum(entity.data, 'first', -1);
-        if (rawChangeIdx < 0)
-            continue;
+        if (entity.name)
+            timescaleGroupsByName.set(entity.name, groupIntermediate);
+        let rawChangeRef = getEntityRef(entity.data, 'first');
         let lastChangeIntermediate = null;
-        while (true) {
-            const rawChange = data.entities[rawChangeIdx];
+        while (rawChangeRef !== undefined) {
+            const rawChange = resolve(rawChangeRef);
             if (!rawChange)
                 break;
             const changeIntermediate = createIntermediate('TimeScaleChange', {
@@ -135,89 +179,115 @@ export const extendedToLevelData = (data, offset = 0) => {
                 groupIntermediate.data['first'] = changeIntermediate;
             }
             lastChangeIntermediate = changeIntermediate;
-            const nextIdx = getNum(rawChange.data, 'next', 0);
-            if (nextIdx <= 0)
-                break;
-            rawChangeIdx = nextIdx;
+            rawChangeRef = getEntityRef(rawChange.data, 'next');
         }
     }
-    const notesByOriginalIndex = new Map();
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
+    const resolveTimescaleGroup = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        if (typeof ref === 'number')
+            return timescaleGroupsByIndex.get(ref);
+        return timescaleGroupsByName.get(ref);
+    };
+    const notesByIndex = new Map();
+    const notesByName = new Map();
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
         const mappedArchetype = noteTypeMapping[entity.archetype];
         if (!mappedArchetype)
             continue;
-        const noteIntermediate = createIntermediate(mappedArchetype, {
+        const tsg = resolveTimescaleGroup(getEntityRef(entity.data, 'timeScaleGroup'));
+        const noteData = {
             '#BEAT': getNum(entity.data, '#BEAT'),
             lane: getNum(entity.data, 'lane', 0),
             size: getNum(entity.data, 'size', 0),
             direction: flickDirectionMapping[getNum(entity.data, 'direction', 0)],
             segmentKind: ConnectorKind.ACTIVE_NORMAL,
-        });
-        notesByOriginalIndex.set(i, noteIntermediate);
+        };
+        if (tsg !== undefined)
+            noteData['#TIMESCALE_GROUP'] = tsg;
+        const noteIntermediate = createIntermediate(mappedArchetype, noteData);
+        notesByIndex.set(i, noteIntermediate);
+        if (entity.name)
+            notesByName.set(entity.name, noteIntermediate);
     }
-    const connectorsByOriginalIndex = new Map();
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
+    const resolveNote = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        if (typeof ref === 'number')
+            return notesByIndex.get(ref);
+        return notesByName.get(ref);
+    };
+    const connectorsByIndex = new Map();
+    const connectorsByName = new Map();
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
         const connectorKind = activeConnectorKindMapping[entity.archetype];
         if (!connectorKind)
             continue;
-        const head = notesByOriginalIndex.get(getNum(entity.data, 'head'));
-        const tail = notesByOriginalIndex.get(getNum(entity.data, 'tail'));
-        const segmentHead = notesByOriginalIndex.get(getNum(entity.data, 'start'));
-        const segmentTail = notesByOriginalIndex.get(getNum(entity.data, 'end'));
-        if (!head || !tail || !segmentHead || !segmentTail)
+        const headNote = resolveNote(getEntityRef(entity.data, 'head'));
+        const tailNote = resolveNote(getEntityRef(entity.data, 'tail'));
+        const segmentHeadNote = resolveNote(getEntityRef(entity.data, 'start'));
+        const segmentTailNote = resolveNote(getEntityRef(entity.data, 'end'));
+        if (!headNote || !tailNote || !segmentHeadNote || !segmentTailNote)
             continue;
         const connectorIntermediate = createIntermediate('Connector', {
-            head,
-            tail,
-            segmentHead,
-            segmentTail,
-            activeHead: segmentHead,
-            activeTail: segmentTail,
+            head: headNote,
+            tail: tailNote,
+            segmentHead: segmentHeadNote,
+            segmentTail: segmentTailNote,
+            activeHead: segmentHeadNote,
+            activeTail: segmentTailNote,
         });
-        head.data['connectorEase'] = easeTypeMapping[getNum(entity.data, 'ease', 0)];
-        head.data['segmentKind'] = connectorKind;
-        tail.data['segmentKind'] = connectorKind;
-        segmentHead.data['segmentKind'] = connectorKind;
-        connectorsByOriginalIndex.set(i, connectorIntermediate);
+        headNote.data['connectorEase'] =
+            easeTypeMapping[getNum(entity.data, 'ease', 0)] ?? EaseType.LINEAR;
+        headNote.data['segmentKind'] = connectorKind;
+        tailNote.data['segmentKind'] = connectorKind;
+        segmentHeadNote.data['segmentKind'] = connectorKind;
+        connectorsByIndex.set(i, connectorIntermediate);
+        if (entity.name)
+            connectorsByName.set(entity.name, connectorIntermediate);
     }
-    for (const [i, note] of notesByOriginalIndex.entries()) {
-        const entity = data.entities[i];
-        const timescaleGroupIndex = getNum(entity.data, 'timeScaleGroup', -1);
-        if (timescaleGroupIndex >= 0 && timescaleGroupsByIndex.has(timescaleGroupIndex)) {
-            note.data['#TIMESCALE_GROUP'] = timescaleGroupsByIndex.get(timescaleGroupIndex);
-        }
-        const attachIndex = getNum(entity.data, 'attach', -1);
-        if (attachIndex > 0) {
-            const attachConnector = connectorsByOriginalIndex.get(attachIndex);
+    const resolveConnector = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        if (typeof ref === 'number')
+            return connectorsByIndex.get(ref);
+        return connectorsByName.get(ref);
+    };
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
+        const note = notesByIndex.get(i);
+        if (!note)
+            continue;
+        const attachRef = getEntityRef(entity.data, 'attach');
+        if (attachRef !== undefined) {
+            const attachConnector = resolveConnector(attachRef);
             if (attachConnector) {
                 note.data['attachHead'] = attachConnector.data['head'];
                 note.data['attachTail'] = attachConnector.data['tail'];
                 note.data['isAttached'] = 1;
             }
         }
-        const slideIndex = getNum(entity.data, 'slide', -1);
-        if (slideIndex > 0) {
-            const slideConnector = connectorsByOriginalIndex.get(slideIndex);
+        const slideRef = getEntityRef(entity.data, 'slide');
+        if (slideRef !== undefined) {
+            const slideConnector = resolveConnector(slideRef);
             if (slideConnector) {
                 note.data['activeHead'] = slideConnector.data['activeHead'];
             }
         }
     }
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
+    for (const entity of flatEntities) {
         if (entity.archetype !== 'SimLine')
             continue;
-        const left = notesByOriginalIndex.get(getNum(entity.data, 'a'));
-        const right = notesByOriginalIndex.get(getNum(entity.data, 'b'));
-        if (left && right) {
+        const left = resolveNote(getEntityRef(entity.data, 'a'));
+        const right = resolveNote(getEntityRef(entity.data, 'b'));
+        if (left && right)
             createIntermediate('SimLine', { left, right });
-        }
     }
     const anchorsByBeat = new Map();
     const anchorPositions = new Map();
-    const getAnchor = (beat, lane, size, timescaleGroup, pos, segmentKind = -1, segmentAlpha = -1, connectorEase = -1) => {
+    const getAnchor = (beat, lane, size, tsg, pos, segmentKind = -1, segmentAlpha = -1, connectorEase = -1) => {
         const anchors = anchorsByBeat.get(beat);
         if (anchors) {
             for (const anchor of anchors) {
@@ -225,7 +295,7 @@ export const extendedToLevelData = (data, offset = 0) => {
                     continue;
                 if (anchor.data['lane'] === lane &&
                     anchor.data['size'] === size &&
-                    anchor.data['#TIMESCALE_GROUP'] === timescaleGroup &&
+                    anchor.data['#TIMESCALE_GROUP'] === tsg &&
                     (segmentKind === -1 ||
                         anchor.data['segmentKind'] === segmentKind ||
                         anchor.data['segmentKind'] === -1) &&
@@ -246,48 +316,49 @@ export const extendedToLevelData = (data, offset = 0) => {
                 }
             }
         }
-        const anchor = createIntermediate('AnchorNote', {
+        const anchorData = {
             '#BEAT': beat,
             lane,
             size,
-            ...(timescaleGroup !== undefined ? { '#TIMESCALE_GROUP': timescaleGroup } : {}),
             segmentKind,
             segmentAlpha,
             connectorEase,
-        });
+        };
+        if (tsg !== undefined)
+            anchorData['#TIMESCALE_GROUP'] = tsg;
+        const anchor = createIntermediate('AnchorNote', anchorData);
         if (!anchorsByBeat.has(beat))
             anchorsByBeat.set(beat, []);
         anchorsByBeat.get(beat).push(anchor);
         anchorPositions.set(anchor, new Set([pos]));
         return anchor;
     };
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
+    for (const entity of flatEntities) {
         if (entity.archetype !== 'Guide')
             continue;
         const startBeat = getNum(entity.data, 'startBeat');
         const startLane = getNum(entity.data, 'startLane');
         const startSize = getNum(entity.data, 'startSize');
-        const startTimeScaleGroup = timescaleGroupsByIndex.get(getNum(entity.data, 'startTimeScaleGroup'));
+        const startTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'startTimeScaleGroup'));
         const headBeat = getNum(entity.data, 'headBeat');
         const headLane = getNum(entity.data, 'headLane');
         const headSize = getNum(entity.data, 'headSize');
-        const headTimeScaleGroup = timescaleGroupsByIndex.get(getNum(entity.data, 'headTimeScaleGroup'));
+        const headTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'headTimeScaleGroup'));
         const tailBeat = getNum(entity.data, 'tailBeat');
         const tailLane = getNum(entity.data, 'tailLane');
         const tailSize = getNum(entity.data, 'tailSize');
-        const tailTimeScaleGroup = timescaleGroupsByIndex.get(getNum(entity.data, 'tailTimeScaleGroup'));
+        const tailTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'tailTimeScaleGroup'));
         const endBeat = getNum(entity.data, 'endBeat');
         const endLane = getNum(entity.data, 'endLane');
         const endSize = getNum(entity.data, 'endSize');
-        const endTimeScaleGroup = timescaleGroupsByIndex.get(getNum(entity.data, 'endTimeScaleGroup'));
-        const ease = easeTypeMapping[getNum(entity.data, 'ease', 0)];
+        const endTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'endTimeScaleGroup'));
+        const ease = easeTypeMapping[getNum(entity.data, 'ease', 0)] ?? EaseType.LINEAR;
         const [startAlpha, endAlpha] = fadeAlphaMapping[getNum(entity.data, 'fade', 1)];
-        const kind = guideKindMapping[getNum(entity.data, 'color', 0)];
-        const start = getAnchor(startBeat, startLane, startSize, startTimeScaleGroup, 'segmentHead', kind, startAlpha);
-        const end = getAnchor(endBeat, endLane, endSize, endTimeScaleGroup, 'segmentTail', kind, endAlpha);
-        const head = getAnchor(headBeat, headLane, headSize, headTimeScaleGroup, 'head', kind, -1, ease);
-        const tail = getAnchor(tailBeat, tailLane, tailSize, tailTimeScaleGroup, 'tail', kind);
+        const kind = guideKindMapping[getNum(entity.data, 'color', 0)] ?? ConnectorKind.GUIDE_NEUTRAL;
+        const start = getAnchor(startBeat, startLane, startSize, startTSG, 'segmentHead', kind, startAlpha);
+        const end = getAnchor(endBeat, endLane, endSize, endTSG, 'segmentTail', kind, endAlpha);
+        const head = getAnchor(headBeat, headLane, headSize, headTSG, 'head', kind, -1, ease);
+        const tail = getAnchor(tailBeat, tailLane, tailSize, tailTSG, 'tail', kind);
         createIntermediate('Connector', { head, tail, segmentHead: start, segmentTail: end });
     }
     for (const anchorList of anchorsByBeat.values()) {
@@ -305,9 +376,8 @@ export const extendedToLevelData = (data, offset = 0) => {
             continue;
         const head = entity.data['head'];
         const tail = entity.data['tail'];
-        if (head && tail) {
+        if (head && tail)
             head.data['next'] = tail;
-        }
     }
     allIntermediateEntities.sort((a, b) => {
         const isInitA = a.archetype === 'Initialization' ? 0 : 1;
@@ -321,7 +391,7 @@ export const extendedToLevelData = (data, offset = 0) => {
     const entities = [];
     const intermediateToRef = new Map();
     let entityRefCounter = 0;
-    const getRef = (intermediateEntity) => {
+    const getOutputRef = (intermediateEntity) => {
         let ref = intermediateToRef.get(intermediateEntity);
         if (ref !== undefined)
             return ref;
@@ -332,21 +402,18 @@ export const extendedToLevelData = (data, offset = 0) => {
     for (const intermediateEntity of allIntermediateEntities) {
         const entity = {
             archetype: intermediateEntity.archetype,
-            name: getRef(intermediateEntity),
+            name: getOutputRef(intermediateEntity),
             data: [],
         };
         for (const [dataName, dataValue] of Object.entries(intermediateEntity.data)) {
             if (typeof dataValue === 'number') {
                 entity.data.push({ name: dataName, value: dataValue });
             }
-            else if (typeof dataValue === 'string') {
-                const asNum = Number(dataValue);
-                if (!isNaN(asNum)) {
-                    entity.data.push({ name: dataName, value: asNum });
-                }
-            }
             else if (dataValue !== undefined && dataValue !== null) {
-                entity.data.push({ name: dataName, ref: getRef(dataValue) });
+                entity.data.push({
+                    name: dataName,
+                    ref: getOutputRef(dataValue),
+                });
             }
         }
         entities.push(entity);

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import { extendedToLevelData, type ExtendedEntityData, type ExtendedLevelData }
 export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData, type ExtendedEntityData, type ExtendedLevelData, };
 export * from './usc/index.js';
 export declare const convertToLevelData: (input: string | Uint8Array | USC | LevelData, offset?: number) => LevelData;
-export declare const version = "1.5.8";
+export declare const version = "1.5.9";
 export declare const databaseEngineItem: {
     readonly name: "next-rush-plus";
     readonly version: 13;

package/dist/index.js

@@ -60,7 +60,7 @@ export const convertToLevelData = (input, offset = 0) => {
     }
     return uscToLevelData(usc, offset, true, true);
 };
-export const version = '1.5.8';
+export const version = '1.5.9';
 export const databaseEngineItem = {
     name: 'next-rush-plus',
     version: 13,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonolus-next-rush-plus-engine",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "description": "A new Project Sekai inspired engine for Sonolus",
   "author": "Hyeon2",
   "repository": {