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

package/dist/extended/convert.js

@@ -82,6 +82,13 @@ const guideKindMapping = {
     6: ConnectorKind.GUIDE_CYAN,
     7: ConnectorKind.GUIDE_BLACK,
 };
+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;
+};
 /** Convert a PJSekaiExtendedLevelData to a Level Data (Next Sekai) */
 export const extendedToLevelData = (data, offset = 0) => {
     const allIntermediateEntities = [];
@@ -94,94 +101,94 @@ export const extendedToLevelData = (data, offset = 0) => {
     for (const entity of data.entities) {
         if (entity.archetype === '#BPM_CHANGE') {
             createIntermediate('#BPM_CHANGE', {
-                '#BEAT': entity.data['#BEAT'],
-                '#BPM': entity.data['#BPM'],
+                '#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];
-        if (entity.archetype === 'TimeScaleGroup') {
-            const groupIntermediate = createIntermediate('TimeScaleGroup', {});
-            timescaleGroupsByIndex.set(i, groupIntermediate);
-            let rawChangeIdx = entity.data['first'];
-            let lastChangeIntermediate = null;
-            while (rawChangeIdx !== undefined && rawChangeIdx > 0) {
-                const rawChange = data.entities[rawChangeIdx];
-                const changeIntermediate = createIntermediate('TimeScaleChange', {
-                    '#BEAT': rawChange.data['#BEAT'],
-                    timeScale: rawChange.data['timeScale'],
-                    timeScaleSkip: 0.0,
-                    timeScaleGroup: groupIntermediate,
-                    timeScaleEase: 0,
-                });
-                if (lastChangeIntermediate) {
-                    lastChangeIntermediate.data['next'] = changeIntermediate;
-                }
-                else {
-                    groupIntermediate.data['first'] = changeIntermediate;
-                }
-                lastChangeIntermediate = changeIntermediate;
-                const nextIdx = rawChange.data['next'];
-                if (nextIdx !== undefined && nextIdx > 0) {
-                    rawChangeIdx = nextIdx;
-                }
-                else {
-                    break;
-                }
+        if (entity.archetype !== 'TimeScaleGroup')
+            continue;
+        const groupIntermediate = createIntermediate('TimeScaleGroup', {});
+        timescaleGroupsByIndex.set(i, groupIntermediate);
+        let rawChangeIdx = getNum(entity.data, 'first', -1);
+        if (rawChangeIdx < 0)
+            continue;
+        let lastChangeIntermediate = null;
+        while (true) {
+            const rawChange = data.entities[rawChangeIdx];
+            if (!rawChange)
+                break;
+            const changeIntermediate = createIntermediate('TimeScaleChange', {
+                '#BEAT': getNum(rawChange.data, '#BEAT'),
+                timeScale: getNum(rawChange.data, 'timeScale'),
+                timeScaleSkip: 0.0,
+                timeScaleGroup: groupIntermediate,
+                timeScaleEase: 0,
+            });
+            if (lastChangeIntermediate) {
+                lastChangeIntermediate.data['next'] = changeIntermediate;
             }
+            else {
+                groupIntermediate.data['first'] = changeIntermediate;
+            }
+            lastChangeIntermediate = changeIntermediate;
+            const nextIdx = getNum(rawChange.data, 'next', 0);
+            if (nextIdx <= 0)
+                break;
+            rawChangeIdx = nextIdx;
         }
     }
     const notesByOriginalIndex = new Map();
     for (let i = 0; i < data.entities.length; i++) {
         const entity = data.entities[i];
-        if (noteTypeMapping[entity.archetype]) {
-            const mappedArchetype = noteTypeMapping[entity.archetype];
-            const directionData = entity.data['direction'] ?? 0;
-            const noteIntermediate = createIntermediate(mappedArchetype, {
-                '#BEAT': entity.data['#BEAT'],
-                lane: entity.data['lane'] ?? 0.0,
-                size: entity.data['size'] ?? 0.0,
-                direction: flickDirectionMapping[directionData],
-                segmentKind: ConnectorKind.ACTIVE_NORMAL,
-            });
-            notesByOriginalIndex.set(i, noteIntermediate);
-        }
+        const mappedArchetype = noteTypeMapping[entity.archetype];
+        if (!mappedArchetype)
+            continue;
+        const noteIntermediate = createIntermediate(mappedArchetype, {
+            '#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);
     }
     const connectorsByOriginalIndex = new Map();
     for (let i = 0; i < data.entities.length; i++) {
         const entity = data.entities[i];
-        if (activeConnectorKindMapping[entity.archetype]) {
-            const connectorKind = activeConnectorKindMapping[entity.archetype];
-            const head = notesByOriginalIndex.get(entity.data['head']);
-            const tail = notesByOriginalIndex.get(entity.data['tail']);
-            const segmentHead = notesByOriginalIndex.get(entity.data['start']);
-            const segmentTail = notesByOriginalIndex.get(entity.data['end']);
-            if (!head || !tail || !segmentHead || !segmentTail)
-                continue;
-            const connectorIntermediate = createIntermediate('Connector', {
-                head,
-                tail,
-                segmentHead,
-                segmentTail,
-                activeHead: segmentHead,
-                activeTail: segmentTail,
-            });
-            head.data['connectorEase'] = easeTypeMapping[entity.data['ease'] ?? 0];
-            head.data['segmentKind'] = connectorKind;
-            tail.data['segmentKind'] = connectorKind;
-            segmentHead.data['segmentKind'] = connectorKind;
-            connectorsByOriginalIndex.set(i, connectorIntermediate);
-        }
+        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)
+            continue;
+        const connectorIntermediate = createIntermediate('Connector', {
+            head,
+            tail,
+            segmentHead,
+            segmentTail,
+            activeHead: segmentHead,
+            activeTail: segmentTail,
+        });
+        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);
     }
     for (const [i, note] of notesByOriginalIndex.entries()) {
         const entity = data.entities[i];
-        const timescaleGroupIndex = entity.data['timeScaleGroup'] ?? -1;
+        const timescaleGroupIndex = getNum(entity.data, 'timeScaleGroup', -1);
         if (timescaleGroupIndex >= 0 && timescaleGroupsByIndex.has(timescaleGroupIndex)) {
             note.data['#TIMESCALE_GROUP'] = timescaleGroupsByIndex.get(timescaleGroupIndex);
         }
-        const attachIndex = entity.data['attach'] ?? -1;
+        const attachIndex = getNum(entity.data, 'attach', -1);
         if (attachIndex > 0) {
             const attachConnector = connectorsByOriginalIndex.get(attachIndex);
             if (attachConnector) {
@@ -190,7 +197,7 @@ export const extendedToLevelData = (data, offset = 0) => {
                 note.data['isAttached'] = 1;
             }
         }
-        const slideIndex = entity.data['slide'] ?? -1;
+        const slideIndex = getNum(entity.data, 'slide', -1);
         if (slideIndex > 0) {
             const slideConnector = connectorsByOriginalIndex.get(slideIndex);
             if (slideConnector) {
@@ -200,18 +207,18 @@ export const extendedToLevelData = (data, offset = 0) => {
     }
     for (let i = 0; i < data.entities.length; i++) {
         const entity = data.entities[i];
-        if (entity.archetype === 'SimLine') {
-            const left = notesByOriginalIndex.get(entity.data['a']);
-            const right = notesByOriginalIndex.get(entity.data['b']);
-            if (left && right) {
-                createIntermediate('SimLine', { left, right });
-            }
+        if (entity.archetype !== 'SimLine')
+            continue;
+        const left = notesByOriginalIndex.get(getNum(entity.data, 'a'));
+        const right = notesByOriginalIndex.get(getNum(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) => {
-        let anchors = anchorsByBeat.get(beat);
+        const anchors = anchorsByBeat.get(beat);
         if (anchors) {
             for (const anchor of anchors) {
                 if (anchorPositions.get(anchor)?.has(pos))
@@ -228,15 +235,12 @@ export const extendedToLevelData = (data, offset = 0) => {
                     (connectorEase === -1 ||
                         anchor.data['connectorEase'] === connectorEase ||
                         anchor.data['connectorEase'] === -1)) {
-                    if (segmentKind !== -1 && anchor.data['segmentKind'] === -1) {
+                    if (segmentKind !== -1 && anchor.data['segmentKind'] === -1)
                         anchor.data['segmentKind'] = segmentKind;
-                    }
-                    if (segmentAlpha !== -1 && anchor.data['segmentAlpha'] === -1) {
+                    if (segmentAlpha !== -1 && anchor.data['segmentAlpha'] === -1)
                         anchor.data['segmentAlpha'] = segmentAlpha;
-                    }
-                    if (connectorEase !== -1 && anchor.data['connectorEase'] === -1) {
+                    if (connectorEase !== -1 && anchor.data['connectorEase'] === -1)
                         anchor.data['connectorEase'] = connectorEase;
-                    }
                     anchorPositions.get(anchor).add(pos);
                     return anchor;
                 }
@@ -246,73 +250,63 @@ export const extendedToLevelData = (data, offset = 0) => {
             '#BEAT': beat,
             lane,
             size,
-            '#TIMESCALE_GROUP': timescaleGroup,
+            ...(timescaleGroup !== undefined ? { '#TIMESCALE_GROUP': timescaleGroup } : {}),
             segmentKind,
             segmentAlpha,
             connectorEase,
         });
-        if (!anchorsByBeat.has(beat)) {
+        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];
-        if (entity.archetype === 'Guide') {
-            const startBeat = entity.data['startBeat'];
-            const startLane = entity.data['startLane'];
-            const startSize = entity.data['startSize'];
-            const startTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['startTimeScaleGroup']);
-            const headBeat = entity.data['headBeat'];
-            const headLane = entity.data['headLane'];
-            const headSize = entity.data['headSize'];
-            const headTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['headTimeScaleGroup']);
-            const tailBeat = entity.data['tailBeat'];
-            const tailLane = entity.data['tailLane'];
-            const tailSize = entity.data['tailSize'];
-            const tailTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['tailTimeScaleGroup']);
-            const endBeat = entity.data['endBeat'];
-            const endLane = entity.data['endLane'];
-            const endSize = entity.data['endSize'];
-            const endTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['endTimeScaleGroup']);
-            const ease = easeTypeMapping[entity.data['ease'] ?? 0];
-            const fade = entity.data['fade'] ?? 1;
-            const [startAlpha, endAlpha] = fadeAlphaMapping[fade];
-            const kind = guideKindMapping[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);
-            createIntermediate('Connector', {
-                head,
-                tail,
-                segmentHead: start,
-                segmentTail: end,
-            });
-        }
+        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 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 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 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 [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);
+        createIntermediate('Connector', { head, tail, segmentHead: start, segmentTail: end });
     }
     for (const anchorList of anchorsByBeat.values()) {
         for (const anchor of anchorList) {
-            if (anchor.data['segmentKind'] === -1) {
+            if (anchor.data['segmentKind'] === -1)
                 anchor.data['segmentKind'] = ConnectorKind.GUIDE_NEUTRAL;
-            }
-            if (anchor.data['segmentAlpha'] === -1) {
+            if (anchor.data['segmentAlpha'] === -1)
                 anchor.data['segmentAlpha'] = 1.0;
-            }
-            if (anchor.data['connectorEase'] === -1) {
+            if (anchor.data['connectorEase'] === -1)
                 anchor.data['connectorEase'] = EaseType.LINEAR;
-            }
         }
     }
     for (const entity of allIntermediateEntities) {
-        if (entity.archetype === 'Connector') {
-            const head = entity.data['head'];
-            const tail = entity.data['tail'];
-            if (head && tail) {
-                head.data['next'] = tail;
-            }
+        if (entity.archetype !== 'Connector')
+            continue;
+        const head = entity.data['head'];
+        const tail = entity.data['tail'];
+        if (head && tail) {
+            head.data['next'] = tail;
         }
     }
     allIntermediateEntities.sort((a, b) => {
@@ -329,7 +323,7 @@ export const extendedToLevelData = (data, offset = 0) => {
     let entityRefCounter = 0;
     const getRef = (intermediateEntity) => {
         let ref = intermediateToRef.get(intermediateEntity);
-        if (ref)
+        if (ref !== undefined)
             return ref;
         ref = (entityRefCounter++).toString(16);
         intermediateToRef.set(intermediateEntity, ref);
@@ -345,6 +339,12 @@ export const extendedToLevelData = (data, offset = 0) => {
             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) });
             }

package/dist/index.d.ts

@@ -4,11 +4,11 @@ import { ucmmwsToLevelData } from './mmw/convert.js';
 import { susToUSC } from './sus/convert.js';
 import { uscToLevelData } from './usc/convert.js';
 import { USC } from './usc/index.js';
-import { extendedToLevelData } from './extended/convert.js';
-export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData };
+import { extendedToLevelData, type ExtendedEntityData, type ExtendedLevelData } from './extended/convert.js';
+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.7";
+export declare const version = "1.5.8";
 export declare const databaseEngineItem: {
     readonly name: "next-rush-plus";
     readonly version: 13;

package/dist/index.js

@@ -7,8 +7,8 @@ import { isUSC } from './usc/analyze.js';
 import { isLevelData } from './LevelData/analyze.js';
 import { isPJSK } from './pjsk/analyze.js';
 import { pjskToUSC } from './pjsk/convert.js';
-import { extendedToLevelData } from './extended/convert.js';
-export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData };
+import { extendedToLevelData, } from './extended/convert.js';
+export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData, };
 export * from './usc/index.js';
 export const convertToLevelData = (input, offset = 0) => {
     if (isLevelData(input)) {
@@ -60,7 +60,7 @@ export const convertToLevelData = (input, offset = 0) => {
     }
     return uscToLevelData(usc, offset, true, true);
 };
-export const version = '1.5.7';
+export const version = '1.5.8';
 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.7",
+  "version": "1.5.8",
   "description": "A new Project Sekai inspired engine for Sonolus",
   "author": "Hyeon2",
   "repository": {